Sly 1:Builds/May 19 2002/Functions

This page lists all known functions in the build, grouped by the source code file they were compiled from.

D:/sce/ee/lib/crt0.s

0x00100008

D:\P2\ps2t\spaprops.ic

0x001000c8

RefThunkBasicDERIVED_FROMQ(BASIC *, int, CRef *)
RefThunkLoREMOVEFnUser(BASIC *, int, CRef *)
RefThunkLoREMOVEFn(BASIC *, int, CRef *)
RefThunkLoADD(BASIC *, int, CRef *)
RefThunkLoCLONE(BASIC *, int, CRef *)
RefThunkLoSETPARENT(BASIC *, int, CRef *)
RefThunkLoANCESTORQ(BASIC *, int, CRef *)
RefThunkLoMATCHES_NAMEQ(BASIC *, int, CRef *)
RefThunkLoCUSTOM_BOOL_PROPERTY(BASIC *, int, CRef *)
RefThunkLoCUSTOM_INT_PROPERTY(BASIC *, int, CRef *)
RefThunkLoCUSTOM_FLOAT_PROPERTY(BASIC *, int, CRef *)
RefThunkLoCUSTOM_CLQ_PROPERTY(BASIC *, int, CRef *)
RefThunkLoCUSTOM_LM_PROPERTY(BASIC *, int, CRef *)
RefThunkLoCUSTOM_OID_PROPERTY(BASIC *, int, CRef *)
RefThunkLoCUSTOM_VECTOR_PROPERTY(BASIC *, int, CRef *)
RefThunkAloINVALIDATE_LIGHTING(BASIC *, int, CRef *)
RefThunkAloROTATION_MATCHES_VELOCITY(BASIC *, int, CRef *)
RefThunkAloSCROLLING_MASTER_SPEEDS(BASIC *, int, CRef *)
RefThunkAloEYES_CLOSED(BASIC *, int, CRef *)
RefThunkAloSTART_SOUND(BASIC *, int, CRef *)
RefThunkAloSTOP_SOUND(BASIC *, int, CRef *)
RefThunkAloFADE_IN(BASIC *, int, CRef *)
RefThunkAloFADE_OUT(BASIC *, int, CRef *)
RefThunkAloCURRENT_SMA(BASIC *, int, CRef *)
RefThunkAloCURRENT_ASEGA(BASIC *, int, CRef *)
RefThunkAloNEAREST_ASEGA(BASIC *, int, CRef *)
RefThunkAloMATCH_OTHER_OBJECT(BASIC *, int, CRef *)
RefThunkSoEDGE_GRAB(BASIC *, int, CRef *)
RefThunkWarpSET_SM_GOAL(BASIC *, int, CRef *)
RefThunkWarpTRIGGER(BASIC *, int, CRef *)
RefThunkExitTRIGGER(BASIC *, int, CRef *)
RefThunkAsegAPPLY(BASIC *, int, CRef *)
RefThunkAsegENSURE(BASIC *, int, CRef *)
RefThunkAsegFIND_LABEL(BASIC *, int, CRef *)
RefThunkAsegaSEEK(BASIC *, int, CRef *)
RefThunkAsegaRETRACT(BASIC *, int, CRef *)
RefThunkAsegaSNAP(BASIC *, int, CRef *)
RefThunkBrkBREAK(BASIC *, int, CRef *)
RefThunkButtonSET_SM_GOAL(BASIC *, int, CRef *)
RefThunkVolbtnSET_SM_GOAL(BASIC *, int, CRef *)
RefThunkPoMAKE_ACTIVE(BASIC *, int, CRef *)
RefThunkPoINVULNERABLEQ(BASIC *, int, CRef *)
RefThunkAlarmTRIGGER(BASIC *, int, CRef *)
RefThunkAlarmSET_SM_GOAL(BASIC *, int, CRef *)
RefThunkSensorENABLE(BASIC *, int, CRef *)
RefThunkSensorDISABLE(BASIC *, int, CRef *)
RefThunkLasenEXTEND(BASIC *, int, CRef *)
RefThunkLasenRETRACT(BASIC *, int, CRef *)
RefThunkEmitterPAUSE(BASIC *, int, CRef *)
RefThunkEmitterPAUSE_FOREVER(BASIC *, int, CRef *)
RefThunkEmitterUNPAUSE(BASIC *, int, CRef *)
RefThunkEmitterADD_SKELETON(BASIC *, int, CRef *)
RefThunkExploADD_SKELETON(BASIC *, int, CRef *)
RefThunkExplsEXPLODE(BASIC *, int, CRef *)
RefThunkExplsEXPLODE_OVR(BASIC *, int, CRef *)
RefThunkExplgEXPLODE(BASIC *, int, CRef *)
RefThunkSmAPPLY(BASIC *, int, CRef *)
RefThunkSmaRETRACT(BASIC *, int, CRef *)
RefThunkSwDEFAULT_REVERB(BASIC *, int, CRef *)
RefThunkSwPUSH_REVERB(BASIC *, int, CRef *)
RefThunkSwPOP_REVERB(BASIC *, int, CRef *)
RefThunkSwLEVEL_VISITEDQ(BASIC *, int, CRef *)
RefThunkSwLEVEL_PRIMARYQ(BASIC *, int, CRef *)
RefThunkSwLEVEL_SECONDARYQ(BASIC *, int, CRef *)
RefThunkSwLEVEL_TERTIARYQ(BASIC *, int, CRef *)
RefThunkSwCANCEL_DIALOG(BASIC *, int, CRef *)
RefThunkCmPUSH_LOOK_KIND(BASIC *, int, CRef *)
RefThunkCmPOP_LOOK_KIND(BASIC *, int, CRef *)
RefThunkCmLOOK_KIND(BASIC *, int, CRef *)
RefThunkCmSET_SNIPER_FOCUS(BASIC *, int, CRef *)
RefThunkCmJOLT(BASIC *, int, CRef *)
RefThunkClueBREAK(BASIC *, int, CRef *)
RefThunkPipeCAMERA_MANUAL_OFFSET(BASIC *, int, CRef *)
RefThunkStepguardUSE_ANIMATION(BASIC *, int, CRef *)
RefThunkStepguardUSE_ANIMATION_IMMEDIATE(BASIC *, int, CRef *)
RefThunkStepguardMATCH_ANIMATION_PHASE(BASIC *, int, CRef *)
RefThunkStepguardADD_ATTACK_EFFECT(BASIC *, int, CRef *)
RefThunkStepguardUSE_DEATH_ANIMATION(BASIC *, int, CRef *)
RefThunkStepguardSET_STATE_EXTERNAL(BASIC *, int, CRef *)
RefThunkStepguardUSE_PHYS(BASIC *, int, CRef *)
RefThunkStepguardJUMP(BASIC *, int, CRef *)
RefThunkStepguardSET_PATROL_ANIMATION(BASIC *, int, CRef *)
RefThunkSmartguardUSE_FLASHLIGHT_TARGET(BASIC *, int, CRef *)
RefThunkBombPRIME(BASIC *, int, CRef *)
RefThunkBombDETONATE(BASIC *, int, CRef *)
RefThunkCanFIRE_AT_POSITION(BASIC *, int, CRef *)
RefThunkJtTHROW(BASIC *, int, CRef *)
RefThunkJtUNHOOK(BASIC *, int, CRef *)
RefThunkJtPROFILE(BASIC *, int, CRef *)
RefThunkJtADD_SPEED_BOOST(BASIC *, int, CRef *)
RefThunkJtPLACE_ON_PIPE(BASIC *, int, CRef *)
RefThunkRchmSET_NATURAL_COEFFICIENTS(BASIC *, int, CRef *)
RefThunkRchmSET_CENTER_COEFFICIENTS(BASIC *, int, CRef *)
RefThunkDartgunSTART_TARGET_AREA_CHANGE(BASIC *, int, CRef *)
RefThunkDartgunADD_TARGET_AREA_TARGET(BASIC *, int, CRef *)
RefThunkWaypointSET_SM_GOAL(BASIC *, int, CRef *)
RefThunkJloACTIVATE(BASIC *, int, CRef *)
RefThunkJloDEACTIVATE(BASIC *, int, CRef *)
RefThunkRwmADD_AMMO(BASIC *, int, CRef *)
RefThunkRwmENABLE_CACHE(BASIC *, int, CRef *)
RefThunkRwmDISABLE_CACHE(BASIC *, int, CRef *)
RefThunkRwmRESIZE_CACHE(BASIC *, int, CRef *)
RefThunkRwmRELOAD(BASIC *, int, CRef *)
RefThunkRwmFIRE(BASIC *, int, CRef *)
RefThunkRwmCLEAR_FIRE_INFO(BASIC *, int, CRef *)
RefThunkRwmCLEAR_TARGET_INFO(BASIC *, int, CRef *)
RefThunkRwmCLEAR_AIM_CONSTRAINTS(BASIC *, int, CRef *)
RefThunkDialogINSTRUCT(BASIC *, int, CRef *)
RefThunkDialogCONFRONT(BASIC *, int, CRef *)
RefThunkDialogADD_DIALOG_EQUIVALENCE(BASIC *, int, CRef *)
RefThunkDialogTRIGGER(BASIC *, int, CRef *)
RefThunkDialogUNTRIGGER(BASIC *, int, CRef *)
RefThunkLockgTRIGGER(BASIC *, int, CRef *)
RefThunkWrADD_CIRCLE_WARP(BASIC *, int, CRef *)
RefThunkWrADD_BEND_WARP(BASIC *, int, CRef *)
RefThunkWrADD_BEND_NOISE(BASIC *, int, CRef *)
RefThunkWrADD_SWIVEL_NOISE(BASIC *, int, CRef *)
RefThunkVaultADD_GOAD_DIALOG(BASIC *, int, CRef *)
RefThunkCrbrainACTIVATE(BASIC *, int, CRef *)
RefThunkCrbrainSCORE(BASIC *, int, CRef *)
RefThunkMgcGENERATE(BASIC *, int, CRef *)
RefThunkSuvADD_BOOST_OPPORTUNITY(BASIC *, int, CRef *)
RefThunkSuvADD_BOOST_COLLECT(BASIC *, int, CRef *)
RefThunkSuvADD_CHECK_POINT(BASIC *, int, CRef *)
RefThunkSuvADD_FEATURE(BASIC *, int, CRef *)
RefThunkSuvRESET(BASIC *, int, CRef *)
RefThunkVolCHECK_POINT(BASIC *, int, CRef *)
RefThunkMurrayADD_ENEMY(BASIC *, int, CRef *)
RefThunkSwpSET_SHAPE(BASIC *, int, CRef *)
RefThunkJackADD_PRIZE(BASIC *, int, CRef *)
RefThunkLgnbATTACK(BASIC *, int, CRef *)
RefThunkJsgCLEAR(BASIC *, int, CRef *)
RefThunkJsgAPPLY(BASIC *, int, CRef *)
RefThunkJsgRETRACT(BASIC *, int, CRef *)
RefThunkJsgSET_CONTEXT(BASIC *, int, CRef *)
RefThunkJsgCUT(BASIC *, int, CRef *)
RefThunkJsgSET_FOCUS(BASIC *, int, CRef *)
RefThunkJsgCALL_SPLICE(BASIC *, int, CRef *)
RefThunkJsgSET_TUNNEL(BASIC *, int, CRef *)
RefThunkJsgPAUSE(BASIC *, int, CRef *)
RefThunkJsgJUMP(BASIC *, int, CRef *)
RefThunkJsgRUN(BASIC *, int, CRef *)
RefThunkJsgCLIMB(BASIC *, int, CRef *)
RefThunkJsgATTACK(BASIC *, int, CRef *)
RefThunkJsgCALL_ANIMATION(BASIC *, int, CRef *)
RefThunkJsgSET_CLOCK_SPEED(BASIC *, int, CRef *)
BuildEopids(void)

D:\P2\splice\bif.cpp

0x00110df0

RefOpAdd(int, CRef *, CFrame *)
RefOpSub(int, CRef *, CFrame *)
RefOpMult(int, CRef *, CFrame *)
RefOpDiv(int, CRef *, CFrame *)
RefOpPrint(int, CRef *, CFrame *)
RefOpPrintFrame(int, CRef *, CFrame *)
RefOpPrintSidebag(int, CRef *, CFrame *)
RefOpIntEqual(int, CRef *, CFrame *)
RefCmp(CRef *, CMPK)
RefOpL(int, CRef *, CFrame *)
RefOpLE(int, CRef *, CFrame *)
RefOpG(int, CRef *, CFrame *)
RefOpGE(int, CRef *, CFrame *)
RefOpEqv(int, CRef *, CFrame *)
RefEqualHelper(CRef *, CRef *)
RefOpEqual(int, CRef *, CFrame *)
RefOpIsBoolean(int, CRef *, CFrame *)
RefOpIsNum(int, CRef *, CFrame *)
RefOpIsFloat(int, CRef *, CFrame *)
RefOpIsInteger(int, CRef *, CFrame *)
RefOpIsSymbol(int, CRef *, CFrame *)
RefOpIsVector(int, CRef *, CFrame *)
RefOpIsMatrix(int, CRef *, CFrame *)
RefOpIsClq(int, CRef *, CFrame *)
RefOpIsLm(int, CRef *, CFrame *)
RefOpIsSmp(int, CRef *, CFrame *)
RefOpIsList(int, CRef *, CFrame *)
RefOpIsNull(int, CRef *, CFrame *)
RefOpIsObject(int, CRef *, CFrame *)
RefOpIsNullObj(int, CRef *, CFrame *)
RefOpIsMethod(int, CRef *, CFrame *)
RefOpIsProcedure(int, CRef *, CFrame *)
RefOpAreNear(int, CRef *, CFrame *)
RefOpNot(int, CRef *, CFrame *)
RefOpCons(int, CRef *, CFrame *)
RefOpCar(int, CRef *, CFrame *)
RefOpCdr(int, CRef *, CFrame *)
RefOpSetCadr(int, CRef *, CFrame *, BIFK)
RefOpSetCar(int, CRef *, CFrame *)
RefOpSetCdr(int, CRef *, CFrame *)
RefOpLength(int, CRef *, CFrame *)
RefOpNth(int, CRef *, CFrame *)
RefOpIsMember(int, CRef *, CFrame *)
RefOpList(int, CRef *, CFrame *)
RefOpAppend(int, CRef *, CFrame *)
RefOpMap(int, CRef *, CFrame *)
RefOpFilter(int, CRef *, CFrame *)
RefOpForEach(int, CRef *, CFrame *)
RefOpEval(int, CRef *, CFrame *)
RefOpVector(int, CRef *, CFrame *)
RefOpMatrix(int, CRef *, CFrame *)
RefOpSetMusicRegister(int, CRef *, CFrame *)
RefOpClq(int, CRef *, CFrame *)
RefOpLm(int, CRef *, CFrame *)
RefOpSmp(int, CRef *, CFrame *)
RefOpGetElement(int, CRef *, CFrame *)
RefOpRandomSeed(int, CRef *, CFrame *)
RefOpRandom(int, CRef *, CFrame *)
RefUfo(CRef *, UFOK)
RefOpSqrt(int, CRef *, CFrame *)
RefOpSin(int, CRef *, CFrame *)
RefOpCos(int, CRef *, CFrame *)
RefOpTan(int, CRef *, CFrame *)
RefOpAsin(int, CRef *, CFrame *)
RefOpAcos(int, CRef *, CFrame *)
RefOpAtan(int, CRef *, CFrame *)
RefOpRadNormalize(int, CRef *, CFrame *)
RefOpAtan2(int, CRef *, CFrame *)
RefOpVectorDotProduct(int, CRef *, CFrame *)
RefOpVectorCrossProduct(int, CRef *, CFrame *)
RefOpVectorLth(int, CRef *, CFrame *)
RefOpVectorDistance(int, CRef *, CFrame *)
RefOpVectorDistanceSquared(int, CRef *, CFrame *)
RefOpVectorNormalize(int, CRef *, CFrame *)
RefOpVectorProjectNormal(int, CRef *, CFrame *)
RefOpVectorProjectTangent(int, CRef *, CFrame *)
RefOpVectorBallisticVelocity(int, CRef *, CFrame *)
RefOpVectorRadianNormal(int, CRef *, CFrame *)
RefOpMatrixTranspose(int, CRef *, CFrame *)
RefOpMatrixInvert(int, CRef *, CFrame *)
RefOpMatrixCalculateDmat(int, CRef *, CFrame *)
RefOpMatrixInterpolateRotate(int, CRef *, CFrame *)
RefOpMatrixDecomposeToTranslate(int, CRef *, CFrame *)
RefOpMatrixDecomposeToRotate(int, CRef *, CFrame *)
RefOpMatrixDecomposeToEuler(int, CRef *, CFrame *)
RefOpMatrixDecomposeToRadianNormal(int, CRef *, CFrame *)
RefOpMatrixLookAt(int, CRef *, CFrame *)
RefOpMatrixTiltUpright(int, CRef *, CFrame *)
RefOpClqEvaluate(int, CRef *, CFrame *)
RefOpClqEvaluateLm(int, CRef *, CFrame *)
RefOpClqFit(int, CRef *, CFrame *)
RefOpLmLimit(int, CRef *, CFrame *)
RefOpLmCheck(int, CRef *, CFrame *)
RefOpFloor(int, CRef *, CFrame *)
RefOpCeiling(int, CRef *, CFrame *)
RefOpRound(int, CRef *, CFrame *)
RefOpTruncate(int, CRef *, CFrame *)
RefOpAbs(int, CRef *, CFrame *)
RefOpMaximum(int, CRef *, CFrame *)
RefOpMinimum(int, CRef *, CFrame *)
RefOpModulo(int, CRef *, CFrame *)
RefOpCurrentTime(int, CRef *, CFrame *)
RefOpScheduleCallback(int, CRef *, CFrame *)
RefOpDeferObjectUpdate(int, CRef *, CFrame *)
RefOpObjectOption(int, CRef *, CFrame *, BIFK)
RefOpAddO(int, CRef *, CFrame *)
RefOpEnsureO(int, CRef *, CFrame *)
RefOpSetO(int, CRef *, CFrame *)
RefOpGetO(int, CRef *, CFrame *)
RefPairFromAplo(int, LO **)
RefOpFindObject(int, CRef *, CFrame *)
RefOpFindObjects(int, CRef *, CFrame *)
RefOpFindNearestObject(int, CRef *, CFrame *)
RefOpFindNearestObjects(int, CRef *, CFrame *)
RefOpFindPlayerObject(int, CRef *, CFrame *)
RefOpFindWorldObject(int, CRef *, CFrame *)
RefOpFindCameraObject(int, CRef *, CFrame *)
RefOpFindClassObjects(int, CRef *, CFrame *)
RefOpFindObjectsInBoundingBox(int, CRef *, CFrame *)
RefOpFindObjectsInBoundingSphere(int, CRef *, CFrame *)
RefOpHitTestObjectsImpl(BIFK, int, CRef *, CFrame *)
RefOpHitTestObjects(int, CRef *, CFrame *)
RefOpHitTestObjectsFirst(int, CRef *, CFrame *)
RefOpConvertObjectPosition(int, CRef *, CFrame *)
RefOpConvertObjectVector(int, CRef *, CFrame *)
RefOpConvertObjectMatrix(int, CRef *, CFrame *)
RefOpNearClipCenter(int, CRef *, CFrame *)
RefOpStartSound(int, CRef *, CFrame *)
RefOpStopSound(int, CRef *, CFrame *)
RefOpStartRumble(int, CRef *, CFrame *)
RefOpEmitSmokeCloud(int, CRef *, CFrame *)
RefOpPredictAnimationEffect(int, CRef *, CFrame *)
VU_FLOAT::VU_FLOAT(float)
VU_VECTOR::VU_VECTOR(VECTOR const &)
VECTOR::TEMPNAMEPLACEHOLDERVALUE(VU_VECTOR)
TEMPNAMEPLACEHOLDERVALUE(VU_FLOAT, VU_VECTOR)

D:\P2\splice\eval.cpp

0x00118d58

RefEvalSymbol(CPair *, CFrame *)
RefEvalSet(CPair *, CFrame *)
RefEvalDefine(CPair *, CFrame *)
RefEvalAssert(CPair *, CFrame *)
RefEvalIf(CPair *, CFrame *)
RefEvalOr(CPair *, CFrame *)
RefEvalAnd(CPair *, CFrame *)
RefEvalCond(CPair *, CFrame *)
RefEvalCase(CPair *, CFrame *)
RefEvalLet(CPair *, CFrame *)
RefEvalWhile(CPair *, CFrame *)
RefEvalLambda(CPair *, CFrame *)
RefEvalLambdaBody(CPair *, CFrame *)
RefEvalBegin(CPair *, CFrame *)
RefEvalApply(CPair *, CFrame *)
RefEvalImport(CPair *, CFrame *)
RefEval(CPair *, CFrame *)

D:\P2\splice\frame.cpp

0x0011a8f8

CFrame::SetSingleParent(CFrame *)
CFrame::AddParent(CFrame *)
CFrame::RefAddBinding(unsigned int, CRef *)
CFrame::RefSetBinding(unsigned int, CRef *)
CFrame::FFindBinding(unsigned int, int, CRef *)
CFrame::PrefFindBinding(unsigned int, int)
CFrame::CloneTo(CFrame *)
PframeNew(void)
DeleteFrame(CFrame *)

D:\P2\splice\gc.cpp

0x0011ade8

CGc::CGc(void)
CGc::~CGc(void)
CGc::Startup(void)
CGc::Shutdown(void)
CGc::AddRootFrame(CFrame *)
CGc::AddRootSidebag(CSidebag *)
CGc::PushFrame(CFrame *)
CGc::PframePop(void)
CGc::PushPair(CPair *)
CGc::PpairPop(void)
CGc::PushProc(CProc *)
CGc::PprocPop(void)
CGc::UpdateRecyclable(void)
CGc::MarkLiveObjects(void)
CGc::Collect(void)

D:\P2\splice\method.cpp

0x0011b6b0

PmethodNew(void)

D:\P2\splice\pair.cpp

0x0011b700

CPair::CloneTo(CPair *, CFrame *)
PpairNew(void)
DeletePair(CPair *)

D:\P2\splice\proc.cpp

0x0011b818

CProc::CloneTo(CProc *, CFrame *)
PprocNew(void)

D:\P2\splice\ref.cpp

0x0011b898

CRef::CRef(void)
CRef::CRef(CRef const &)
CRef::~CRef(void)
CRef::TEMPNAMEPLACEHOLDERVALUE(CRef const &)
CRef::TEMPNAMEPLACEHOLDERVALUE(CRef const &) const
CRef::CloneTo(CRef *, CFrame *)
CRef::Decref(void) const
CRef::Incref(void) const
CRef::SetTag(TAGK)
CRef::SetS32(int)
CRef::SetF32(float)
CRef::SetBool(int)
CRef::SetSymid(unsigned int)
CRef::SetBifk(BIFK)
CRef::SetPair(CPair *)
CRef::SetProc(CProc *)
CRef::SetVector(VECTOR *)
CRef::SetMatrix(MATRIX4 *)
CRef::SetClq(CLQ *)
CRef::SetLm(LM *)
CRef::SetSmp(SMP *)
CRef::SetBasic(BASIC *)
CRef::SetMethod(CMethod *)
CRef::RefCoerceS32(void)
CRef::RefCoerceF32(void)

D:\P2\splice\serialize.cpp

0x0011c470

PpairSerializeIn(CBinaryInputStream *)

D:\P2\splice\sidebag.cpp

0x0011c818

CSidebag::RefAddBinding(int, CRef *)
CSidebag::RefSetBinding(int, CRef *)
CSidebag::FFindBinding(int, CRef *)
CSidebag::CloneTo(CSidebag *)
PsidebagNew(void)

D:\P2\splice\spliceutils.cpp

0x0011cc00

StartupSplice(void)
ShutdownSplice(void)

D:\P2\splice\splotheap.cpp

0x0011cdc8

CSplotheap::Startup(int, int)
CSplotheap::Shutdown(void)
CSplotheap::PvAllocUnsafe(void)
CSplotheap::PvAllocClear(void)
CSplotheap::PsplotLookup(int)
CSplotheap::UpdateRecyclable(void)
CSplotheap::UnmarkAll(void)
CSplotheap::FreeGarbage(void)
PvFromPsplot(SPLOT *)
PsplotFromPv(void *)
FIsPvGarbage(void *)
MarkPvAlive(void *)

D:\P2\splice\vecmat.cpp

0x0011d0f8

PvectorNew(void)
IncrefVector(VECTOR *)
DecrefVector(VECTOR *)
PmatrixNew(void)
IncrefMatrix(MATRIX4 *)
DecrefMatrix(MATRIX4 *)
DeleteMatrix(MATRIX4 *)
PclqNew(void)
IncrefClq(CLQ *)
DecrefClq(CLQ *)
PlmNew(void)
IncrefLm(LM *)
DecrefLm(LM *)
PsmpNew(void)
IncrefSmp(SMP *)
DecrefSmp(SMP *)
StartupSpliceStructuredTypeFactories(void)
ShutdownSpliceStructuredTypeFactories(void)

D:\P2\989snd.c

0x0011d890

snd_GotReturns(void)
snd_PrepareReturnBuffer(unsigned int *, int)
snd_SendIOPCommandAndWait(int, int, int *)
snd_SendIOPCommandNoWait(int, int, int *, void (*)(unsigned int, unsigned long), unsigned long)
snd_PostMessage(void)
snd_SendCurrentBatch(void)

D:\P2\brx.c

0x0011f3e8

StartupBrx(void)
PchzFromWid(WID)
PchzFriendlyFromWid(WID)
PchzFriendlyFromCid(CID)
PchzFromOid(OID)
OidFromPchz(char *)
PloNew(CID, SW *, ALO *, OID, int)
LoadOptionFromBrx(void *, EOPID *, CBinaryInputStream *)
LoadOptionsFromBrx(void *, CBinaryInputStream *)
IploFromStockOid(int)
LoadSwObjectsFromBrx(SW *, ALO *, CBinaryInputStream *)
SetLoDefaults(LO *)

D:\P2\ac.c

0x001200b0

FindKey(float, int, int, int, char *, float *, float *, void **)
EvaluateAcp(ACP *, ALO *, float, float, int, VECTOR *, VECTOR *)
GetAcpTimes(ACP *, int *, float **)
EvaluateAcr(ACR *, ALO *, float, float, int, MATRIX3 *, VECTOR *)
EvaluateAcrEul(ACR *, ALO *, float, float, int, VECTOR *, VECTOR *)
GetAcrTimes(ACR *, int *, float **)
EvaluateAcs(ACS *, ALO *, float, int, MATRIX3 *)
GetAcsTimes(ACS *, int *, float **)
EvaluateAcg(ACG *, ALO *, float, float, int, float *, float *)
GetAcgTimes(ACG *, int *, float **)
LoadAcgbFromBrx(ACGB *, CBinaryInputStream *)
EvaluateAcgb(ACGB *, ALO *, float, float, int, float *, float *)
GetAcgbTimes(ACGB *, int *, float **)
LoadAcgbwFromBrx(ACGBW *, CBinaryInputStream *)
EvaluateAcgbw(ACGBW *, ALO *, float, float, int, float *, float *)
GetAcgbwTimes(ACGBW *, int *, float **)
EvaluateAcgl(ACGL *, ALO *, float, float, int, float *, float *)
LoadAcglFromBrx(ACGL *, CBinaryInputStream *)
GetAcglTimes(ACGL *, int *, float **)
EvaluateApacg(ACG **, ALO *, float, float, int, VECTOR *, VECTOR *, VECTOR *)
LoadApacgFromBrx(ACG **, VECTOR *, CBinaryInputStream *)
GetApacgTimes(ACG **, int *, float **)
EvaluateAkvb(int, KVB *, float, float, int, VECTOR *, VECTOR *)
LoadAkvbFromBrx(int *, KVB **, CBinaryInputStream *)
GetAkvbTimes(int, KVB *, int *, float **)
EvaluateAcpc(ACPC *, ALO *, float, float, int, VECTOR *, VECTOR *)
LoadAcpcFromBrx(ACPC *, CBinaryInputStream *)
GetAcpcTimes(ACPC *, int *, float **)
EvaluateAcpb(ACPB *, ALO *, float, float, int, VECTOR *, VECTOR *)
LoadAcpbFromBrx(ACPB *, CBinaryInputStream *)
GetAcpbTimes(ACPB *, int *, float **)
EvaluateAcrc(ACRC *, ALO *, float, float, int, MATRIX3 *, VECTOR *)
EvaluateAcrcEul(ACRC *, ALO *, float, float, int, VECTOR *, VECTOR *)
LoadAcrcFromBrx(ACRC *, CBinaryInputStream *)
GetAcrcTimes(ACRC *, int *, float **)
EvaluateAcrb(ACRB *, ALO *, float, float, int, MATRIX3 *, VECTOR *)
EvaluateAcrbEul(ACRB *, ALO *, float, float, int, VECTOR *, VECTOR *)
LoadAcrbFromBrx(ACRB *, CBinaryInputStream *)
GetAcrbTimes(ACRB *, int *, float **)
EvaluateAcsc(ACSC *, ALO *, float, int, MATRIX3 *)
LoadAcscFromBrx(ACSC *, CBinaryInputStream *)
GetAcscTimes(ACSC *, int *, float **)
EvaluateAcsb(ACSB *, ALO *, float, int, MATRIX3 *)
LoadAcsbFromBrx(ACSB *, CBinaryInputStream *)
GetAcsbTimes(ACSB *, int *, float **)
EvaluateAcpbl(ACPBL *, ALO *, float, float, int, VECTOR *, VECTOR *)
EvaluateAcrbl(ACRBL *, ALO *, float, float, int, MATRIX3 *, VECTOR *)
EvaluateAcgblt(ACGBLT *, ALO *, float, float, int, float *, float *)
EvaluateAcgblp(ACGBLP *, ALO *, float, float, int, float *, float *)
PacpNew(ACVK)
PacrNew(ACVK)
PacsNew(ACVK)
PacgNew(ACGK)

D:\P2\act.c

0x001227c8

PactNew(SW *, ALO *, VTACT *)
PactNewClone(ACT *, SW *, ALO *)
CloneAct(ACT *, ACT *)
InitAct(ACT *, ALO *)
RetractAct(ACT *, int)
GetActPositionGoal(ACT *, float, VECTOR *, VECTOR *)
GetActRotationGoal(ACT *, float, MATRIX3 *, VECTOR *)
GetActTwistGoal(ACT *, float *, float *)
GetActScale(ACT *, MATRIX3 *)
GGetActPoseGoal(ACT *, int)
CalculateActDefaultAck(ACT *)
SnapAct(ACT *, int)
CalculateAloPositionSpring(ALO *, float, VECTOR *, VECTOR *, VECTOR *)
ProjectActPosition(ACT *)
CalculateAloRotationSpring(ALO *, float, MATRIX3 *, VECTOR *, VECTOR *)
ProjectActRotation(ACT *)
ProjectActPose(ACT *, int)
PredictAloPosition(ALO *, float, VECTOR *, VECTOR *)
PredictAloRotation(ALO *, float, MATRIX3 *, VECTOR *)
AdaptAct(ACT *)
InitActval(ACTVAL *, ALO *)
GetActvalPositionGoal(ACTVAL *, float, VECTOR *, VECTOR *)
GetActvalRotationGoal(ACTVAL *, float, MATRIX3 *, VECTOR *)
GetActvalTwistGoal(ACTVAL *, float *, float *)
GetActvalScale(ACTVAL *, MATRIX3 *)
GGetActvalPoseGoal(ACTVAL *, int)
InitActref(ACTREF *, ALO *)
GetActrefPositionGoal(ACTREF *, float, VECTOR *, VECTOR *)
GetActrefRotationGoal(ACTREF *, float, MATRIX3 *, VECTOR *)
GetActrefTwistGoal(ACTREF *, float *, float *)
GetActrefScale(ACTREF *, MATRIX3 *)
GGetActrefPoseGoal(ACTREF *, int)
InitActadj(ACTADJ *, ALO *)
GetActadjPositionGoal(ACTADJ *, float, VECTOR *, VECTOR *)
GetActadjRotationGoal(ACTADJ *, float, MATRIX3 *, VECTOR *)
GetActadjTwistGoal(ACTADJ *, float *, float *)
GetActadjScale(ACTADJ *, MATRIX3 *)
GGetActadjPoseGoal(ACTADJ *, int)
InitActbank(ACTBANK *, ALO *)
GetActbankRotationGoal(ACTBANK *, float, MATRIX3 *, VECTOR *)

D:\P2\actseg.c

0x00124538

RetractActseg(ACTSEG *, int)
CloneActseg(ACTSEG *, ACTSEG *)
GetActsegPositionGoal(ACTSEG *, float, VECTOR *, VECTOR *)
GetActsegRotationGoal(ACTSEG *, float, MATRIX3 *, VECTOR *)
GetActsegTwistGoal(ACTSEG *, float *, float *)
GetActsegScale(ACTSEG *, MATRIX3 *)
GGetActsegPoseGoal(ACTSEG *, int)

D:\P2\alarm.c

0x00124a10

BreakAlbrk(ALBRK *)
SetAlbrkAlarm(ALBRK *, ALARM *)
InitAlarm(ALARM *)
PostAlarmLoad(ALARM *)
CloneAlarm(ALARM *, ALARM *)
UpdateAlarm(ALARM *, float)
GetAlarmParams(ALARM *, SOP **)
PostAlarmLoadCallbackHookup(ALARM *, MSGID, void *)
SetAlarmAlarms(ALARM *, ALARMS)
TriggerAlarm(ALARM *, ALTK)
DisableAlarmAlbrk(ALARM *)
EnableAlarmSensors(ALARM *)
DisableAlarmSensors(ALARM *)
NotifyAlarmSensorsOnTrigger(ALARM *)
AddAlarmAlbrk(ALARM *, OID)
AddAlarmSensor(ALARM *, OID)
AddAlarmStepguard(ALARM *, OID)
SetAlarmRsmg(ALARM *, int, OID, OID, OID)
FGetAlarmSensorList(ALARM *, void *)

D:\P2\alo.c

0x00125550

FIsZeroV(VECTOR *)
FIsZeroW(VECTOR *)
FIsZeroDv(VECTOR *)
FIsZeroDw(VECTOR *)
InitAlo(ALO *)
AddAloHierarchy(ALO *)
OnAloAdd(ALO *)
RemoveAloHierarchy(ALO *)
OnAloRemove(ALO *)
UpdateAloOrig(ALO *)
SetAloParent(ALO *, ALO *)
ApplyAloProxy(ALO *, PROXY *)
BindAlo(ALO *)
PostAloLoad(ALO *)
PostAloLoadCallback(ALO *, MSGID, void *)
SnipAloObjects(ALO *, int, SNIP *)
UpdateAloHierarchy(ALO *, float)
UpdateAlo(ALO *, float)
InvalidateAloLighting(ALO *)
UpdateAloXfWorld(ALO *)
UpdateAloXfWorldHierarchy(ALO *)
PresetAloAccel(ALO *, float)
ProjectAloTransform(ALO *, float, int)
PredictAloTransform(ALO *, ALO *, float, VECTOR *, MATRIX3 *, VECTOR *, VECTOR *)
PredictAloTransformAdjust(ALO *, ALO *, float, VECTOR *, MATRIX3 *, VECTOR *, VECTOR *)
ToggleShowPhys(int)
DupAloRo(ALO *, RO *, RO *)
RenderFastShadow(ALO *, CM *, RO *)
RenderAloAll(ALO *, CM *, RO *)
RenderAloSelf(ALO *, CM *, RO *)
RenderAloGlobset(ALO *, CM *, RO *)
RenderAloLine(ALO *, CM *, VECTOR *, VECTOR *, float, float)
SetAloOverrideCel(ALO *, RGBA)
UpdateAloThrob(ALO *, float)
SetAloBlotContext(ALO *, BLOT *)
EnsureAloFader(ALO *)
FadeAloIn(ALO *, float)
FadeAloOut(ALO *, float)
AdjustAloRtckMat(ALO *, CM *, RTCK, VECTOR *, MATRIX4 *)
CloneAloHierarchy(ALO *, ALO *)
CloneAlo(ALO *, ALO *)
HandleAloMessage(ALO *, MSGID, void *)
TranslateAloToPos(ALO *, VECTOR *)
RotateAloToMat(ALO *, MATRIX3 *)
SetAloVelocityVec(ALO *, VECTOR *)
SetAloVelocityXYZ(ALO *, float, float, float)
SetAloAngularVelocityVec(ALO *, VECTOR *)
SetAloAngularVelocityXYZ(ALO *, float, float, float)
SetAloVelocityLocal(ALO *, VECTOR *)
GetAloVelocityLocal(ALO *, VECTOR *)
MatchAloOtherObject(ALO *, ALO *)
CalculateAloMovement(ALO *, ALO *, VECTOR *, VECTOR *, VECTOR *, VECTOR *, VECTOR *)
CalculateAloTransform(ALO *, ALO *, int, VECTOR *, MATRIX3 *, VECTOR *, VECTOR *)
CalculateAloTransformAdjust(ALO *, ALO *, VECTOR *, MATRIX3 *, VECTOR *, VECTOR *)
ConvertAloPos(ALO *, ALO *, VECTOR *, VECTOR *)
ConvertAloVec(ALO *, ALO *, VECTOR *, VECTOR *)
ConvertAloMat(ALO *, ALO *, MATRIX3 *, MATRIX3 *)
FDrivenAlo(ALO *)
RetractAloDrive(ALO *)
ConvertAloMovement(ALO *, ALO *, VECTOR *, VECTOR *, VECTOR *, VECTOR *, VECTOR *, VECTOR *, VECTOR *, VECTOR *, VECTOR *)
CalculateAloDrive(ALO *, CLQ *, LM *, float, float, float *, float *, float *)
FGetAloChildrenList(ALO *, void *)
PactsegNewAlo(ALO *)
LoadAloFromBrx(ALO *, CBinaryInputStream *)
LoadAloAloxFromBrx(ALO *, CBinaryInputStream *)
BindAloAlox(ALO *)
AdjustAloRotation(ALO *, MATRIX3 *, VECTOR *)
UnadjustAloRotation(ALO *, MATRIX3 *)
SetAloInitialVelocity(ALO *, VECTOR *)
SetAloInitialAngularVelocity(ALO *, VECTOR *)
PasegdEnsureAlo(ALO *)
SetAloFastShadowRadius(ALO *, float)
GetAloFastShadowRadius(ALO *, float *)
SetAloFastShadowDepth(ALO *, float)
GetAloFastShadowDepth(ALO *, float *)
PshadowAloEnsure(ALO *)
SetAloCastShadow(ALO *, int)
SetAloShadowShader(ALO *, OID)
SetAloShadowNearRadius(ALO *, float)
SetAloShadowFarRadius(ALO *, float)
SetAloShadowNearCast(ALO *, float)
SetAloShadowFarCast(ALO *, float)
SetAloShadowConeAngle(ALO *, float)
SetAloShadowFrustrumUp(ALO *, VECTOR *)
SetAloDynamicShadowObject(ALO *, OID)
PshadowInferAlo(ALO *)
GetAloCastShadow(ALO *, int *)
GetAloShadowShader(ALO *, OID *)
GetAloShadowNearRadius(ALO *, float *)
GetAloShadowFarRadius(ALO *, float *)
GetAloShadowNearCast(ALO *, float *)
GetAloShadowFarCast(ALO *, float *)
GetAloShadowConeAngle(ALO *, float *)
GetAloShadowFrustrumUp(ALO *, VECTOR *)
GetAloEuler(ALO *, VECTOR *)
SetAloEuler(ALO *, VECTOR *)
EnsureAloActRestore(ALO *)
EnsureAloActla(ALO *)
RecacheAloActList(ALO *)
InsertAloAct(ALO *, ACT *)
ResortAloActList(ALO *)
PasegaFindAlo(ALO *, OID)
PsmaFindAlo(ALO *, OID)
PasegaFindAloNearest(ALO *)
CreateAloActadj(ALO *, int, ACTADJ **)
FIsAloStatic(ALO *)
ResolveAlo(ALO *)
SetAloPositionSpring(ALO *, float)
SetAloPositionSpringDetail(ALO *, CLQ *)
SetAloPositionDamping(ALO *, float)
SetAloPositionDampingDetail(ALO *, CLQ *)
SetAloRotationSpring(ALO *, float)
SetAloRotationSpringDetail(ALO *, CLQ *)
SetAloRotationDamping(ALO *, float)
SetAloRotationDampingDetail(ALO *, CLQ *)
SetAloPositionSmooth(ALO *, float)
SetAloPositionSmoothMaxAccel(ALO *, float)
SetAloPositionSmoothDetail(ALO *, SMPA *)
SetAloRotationSmooth(ALO *, float)
SetAloRotationSmoothMaxAccel(ALO *, float)
SetAloRotationSmoothDetail(ALO *, SMPA *)
SetAloDefaultAckPos(ALO *, ACK)
SetAloDefaultAckRot(ALO *, ACK)
SetAloRestorePosition(ALO *, int)
SetAloNoFreeze(ALO *, int)
SetAloRestorePositionAck(ALO *, ACK)
SetAloRestoreRotation(ALO *, int)
SetAloRestoreRotationAck(ALO *, ACK)
SetAloLookAt(ALO *, ACK)
SetAloLookAtIgnore(ALO *, float)
GetAloLookAtIgnore(ALO *, float *)
SetAloLookAtPanFunction(ALO *, CLQ *)
GetAloLookAtPanFunction(ALO *, CLQ *)
SetAloLookAtPanLimits(ALO *, LM *)
GetAloLookAtPanLimits(ALO *, LM *)
SetAloLookAtTiltFunction(ALO *, CLQ *)
GetAloLookAtTiltFunction(ALO *, CLQ *)
SetAloLookAtTiltLimits(ALO *, LM *)
GetAloLookAtTiltLimits(ALO *, LM *)
SetAloLookAtEnabledPriority(ALO *, int)
GetAloLookAtEnabledPriority(ALO *, int *)
SetAloLookAtDisabledPriority(ALO *, int)
GetAloLookAtDisabledPriority(ALO *, int *)
SetAloRotationMatchesVelocity(ALO *, float, float, ACK)
PtargetEnsureAlo(ALO *)
SetAloTargetAttacks(ALO *, int)
SetAloTargetRadius(ALO *, float)
SetAloTargetHitTest(ALO *, int)
SetAloScrollingMasterSpeeds(ALO *, float, float)
SetAloEyesClosed(ALO *, float)
EnsureAloSfx(ALO *)
SetAloSfxid(ALO *, SFXID)
SetAloSfxidSpl(ALO *, SFXID)
GetAloSfxid(ALO *, SFXID *)
SetAloSStart(ALO *, float)
GetAloSStart(ALO *, float *)
SetAloSFull(ALO *, float)
SetAloSndRepeat(ALO *, LM *)
GetAloSFull(ALO *, float *)
SetAloUVolume(ALO *, float)
SetAloUDoppler(ALO *, float)
GetAloUDoppler(ALO *, float *)
SetAloUVolumeSpl(ALO *, float)
GetAloUVolume(ALO *, float *)
SetAloUPitch(ALO *, float)
SetAloUPitchSpl(ALO *, float)
GetAloUPitch(ALO *, float *)
GetAloSndRepeat(ALO *, LM *)
StartAloSound(ALO *, SFXID, float, float, float, LM *)
StopAloSound(ALO *)
EnsureAloThrob(ALO *)
SetAloThrobKind(ALO *, THROBK)
GetAloThrobKind(ALO *, THROBK *)
SetAloThrobInColor(ALO *, VECTOR *)
GetAloThrobInColor(ALO *, VECTOR *)
SetAloThrobOutColor(ALO *, VECTOR *)
GetAloThrobOutColor(ALO *, VECTOR *)
SetAloThrobDtInOut(ALO *, float)
GetAloThrobDtInOut(ALO *, float *)
SetAloInteractCane(ALO *, int)
GetAloInteractCane(ALO *, int *)
SetAloInteractCaneSweep(ALO *, int)
GetAloInteractCaneSweep(ALO *, int *)
SetAloInteractCaneRush(ALO *, int)
GetAloInteractCaneRush(ALO *, int *)
SetAloInteractCaneSmash(ALO *, int)
GetAloInteractCaneSmash(ALO *, int *)
SetAloInteractBomb(ALO *, int)
GetAloInteractBomb(ALO *, int *)
SetAloInteractShock(ALO *, int)
GetAloInteractShock(ALO *, int *)
FAbsorbAloWkr(ALO *, WKR *)
SetAloPoseCombo(ALO *, OID)
SetAloForceCameraFade(ALO *, int)
SetAloRealClock(ALO *, int)
GetAloParams(ALO *, SOP **)
OnAloThrobParamsChanged(ALO *)

D:\P2\aseg.c

0x0012dcb8

InitAseg(ASEG *)
LoadAsegFromBrx(ASEG *, CBinaryInputStream *)
LoadAsegEventsFromBrx(ASEG *, CBinaryInputStream *, int, int *, EA **)
CloneAseg(ASEG *, LO *)
PostAsegLoad(ASEG *)
PostAsegLoadCallback(ASEG *, MSGID, void *)
ApplyAsegOvr(ASEG *, ALO *, int, OVR *, float, float, int, ASEGA **)
ApplyAseg(ASEG *, ALO *, float, float, int, ASEGA **)
PasegaApplyAseg(ASEG *, ALO *, float, float, int)
PasegaFindAseg(ASEG *, ALO *)
EnsureAseg(ASEG *, ALO *, SEEK, float, float, int, ASEGA **)
PasegaEnsureAseg(ASEG *, ALO *, SEEK, float, float, int)
ApplyAsegCur(ASEG *, ALO *, float, float, int, ASEGA **)
FWipingAseg(ASEG *)
FindAsegClosestPoint(ASEG *, ALO *, VECTOR *, float, float *, VECTOR *, VECTOR *)
PeaFindAsegLabel(ASEG *, OID)
TFindAsegLabel(ASEG *, OID)
PchnFindAseg(ASEG *, ALO *)
PredictAsegEffect(ASEG *, float, float, ALO *, ALO *, int, VECTOR *, MATRIX3 *, VECTOR *, VECTOR *)
GetAsegWaypoints(ASEG *, ALO *, int *, WAYPOINT ***)
StripAsegChn(ASEG *, CHN *)
StripAsegAlo(ASEG *, ALO *)
LoadAsegblFromBrx(ASEGBL *, CBinaryInputStream *)
PostAsegblLoad(ASEGBL *)
CloneAsegbl(ASEGBL *, LO *)
RenderAsegPath(ASEG *, ALO *, RGBA, CM *, int)

D:\P2\asega.c

0x0012fd98

PasegaNew(SW *)
SetAsegaHandsOff(ASEGA *, int)
UpdateAsegaIeaCur(ASEGA *)
PactsegFindAsega(ASEGA *, OID)
HandleAsegaEvent(ASEGA *, EA *, int *)
HandleAsegaEventsFF(ASEGA *, ASEG *, int *)
HandleAsegaEvents(ASEGA *, ASEG *, int *)
RemoveAsega(ASEGA *)
RetractAsega(ASEGA *)
UFromEaErrorFunc(EA *, float)
FWrapAsegaTime(ASEGA *, float *, float *)
UpdateAsega(ASEGA *, float)
SeekAsega(ASEGA *, SEEK, float, float)
SnapAsega(ASEGA *, int)
AdaptAsega(ASEGA *)
FindChnClosestPointLocal(CHN *, ALO *, VECTOR *, float, float, float, float *, VECTOR *, VECTOR *)
SetAsegaSpeed(ASEGA *, float)
SetAsegaMasterSpeed(ASEGA *, float)
SetAsegaPriority(ASEGA *, int)
SendAsegaMessage(ASEGA *, MSGID, void *)
SubscribeAsegaStruct(ASEGA *, void (*)(void *, MSGID, void *), void *)
SubscribeAsegaObject(ASEGA *, LO *)

D:\P2\barrier.c

0x00132528

InitBarrier(BARRIER *)
CloneBarrier(BARRIER *, BARRIER *)
PostBarrierLoad(BARRIER *)
UpdateBarrier(BARRIER *, float)
FIgnoreBarrierIntersection(BARRIER *, SO *)
NotifyBarrierImpact(BARRIER *, XP *, int)
AddBarrierObject(BARRIER *, OID)
AddBarrierClass(BARRIER *, CID)

D:\P2\bas.c

0x00132a28

CBinaryAsyncStream::CBinaryAsyncStream(void *)
CBinaryAsyncStream::~CBinaryAsyncStream(void)
CBinaryAsyncStream::FOpenFile(CFileLocation *)
CBinaryAsyncStream::FOpenSector(unsigned int, unsigned int)
CBinaryAsyncStream::Close(void)
CBinaryAsyncStream::StartSpooling(void)
CBinaryAsyncStream::FSpooling(void)
CBinaryAsyncStream::FSpoolingComplete(void)
CBinaryAsyncStream::FinishSpooling(void)
CBinaryAsyncStream::Spool(void)
CBinaryAsyncStream::Skip(int)

D:\P2\basic.c

0x00132e90

FIsBasicDerivedFrom(BASIC *, CID)
EnsureBasicSidebag(BASIC *)
GetBasicCid(BASIC *, CID *)

D:\P2\bez.c

0x00132f20

EvaluateBezierWeightedFloat(float, float, float, float, float, float, float, float, float, float *, float *, float *)
EvaluateBezierFloat(float, float, float, float, float, float, float, float *, float *, float *)
EvaluateBezierPos(float, float, float, VECTOR *, VECTOR *, VECTOR *, VECTOR *, VECTOR *, VECTOR *, VECTOR *)
EvaluateBezierMat(float, float, float, MATRIX3 *, VECTOR *, MATRIX3 *, VECTOR *, MATRIX3 *, VECTOR *, VECTOR *)
TesselateBezier(float, float, float, VECTOR *, VECTOR *, VECTOR *, VECTOR *, int, VECTOR *)
SBezierPosLength(float, float, VECTOR *, VECTOR *, VECTOR *, VECTOR *)
LimitBezierMulti(int,...)

D:\P2\binoc.c

0x00133d68

InitBei(BEI *, CLQ *, float, float, int)
GEvaluateBei(BEI *, int)
InitBinoc(BINOC *, BLOTK)
ResetBinoc(BINOC *)
PostBinocLoad(BINOC *)
DrawBinocCompass(BINOC *, GIFS &)
DrawBinocZoom(BINOC *, GIFS &)
DrawBinocReticle(BINOC *, GIFS &)
DrawBinocOutline(BINOC *, GIFS &)
DrawBinocScan(BINOC *, GIFS &)
DrawBinocFilter(BINOC *, GIFS &)
SetBinocBlots(BINOC *, BLOTS)
SetBinocBinocs(BINOC *, BINOCS)
NCmpSlo(SLO *, SLO *)
UpdateFilterRose(BINOC *, CID, int (*)(void *, VECTOR *, float *), int (*)(void *, int, HP *), int, float, ALO *)
GetSoSphere(SO *, VECTOR *, float *)
GetAloSphere(ALO *, VECTOR *, float *)
ChpFillAlo(ALO *, int, HP *)
ChpFillSo(SO *, int, HP *)
SetBinocBfk(BINOC *, BFK, int)
UpdateBinocActiveFilter(BINOC *, JOY *)
UpdateBinocActive(BINOC *, JOY *)
OnBinocActive(BINOC *, int)
OnBinocReset(BINOC *)
SetBinocAchzDraw(BINOC *, char *)
FDoneBinocAchz(BINOC *)
SetBinocLookat(BINOC *, ALO *)
SetBinocZoom(BINOC *, float)
DtAppearBinoc(BINOC *)
DtDisappearBinoc(BINOC *)
DrawBinoc(BINOC *)
GetBinocReticleFocus(BINOC *, float *, float *)
OnBinocPush(BINOC *)
OnBinocPop(BINOC *)
CTextBox::SetPos(float, float)
CTextBox::SetSize(float, float)
CTextBox::SetTextColor(RGBA)
CTextBox::SetHorizontalJust(JH)
CTextBox::SetVerticalJust(JV)

D:\P2\bis.c

0x0013a488

CBinaryInputStream::CBinaryInputStream(int, void *, int)
CBinaryInputStream::~CBinaryInputStream(void)
CBinaryInputStream::FOpenSector(unsigned int, unsigned int)
CBinaryInputStream::OpenMemory(int, void *)
CBinaryInputStream::FOpenFile(CFileLocation *)
CBinaryInputStream::Close(void)
CBinaryInputStream::DecrementCdReadLimit(int)
CBinaryInputStream::PumpCd(void)
CBinaryInputStream::PumpHost(void)
CBinaryInputStream::Pump(void)
CBinaryInputStream::Decompress(void)
CBinaryInputStream::Read(int, void *)
CBinaryInputStream::Align(int)
CBinaryInputStream::U8Read(void)
CBinaryInputStream::U16Read(void)
CBinaryInputStream::U32Read(void)
CBinaryInputStream::S8Read(void)
CBinaryInputStream::S16Read(void)
CBinaryInputStream::S32Read(void)
CBinaryInputStream::F32Read(void)
CBinaryInputStream::ReadVector(VECTOR *)
CBinaryInputStream::ReadVector4(VECTOR4 *)
CBinaryInputStream::ReadMatrix(MATRIX3 *)
CBinaryInputStream::ReadMatrix4(MATRIX4 *)
CBinaryInputStream::ReadGeom(GEOM *)
CBinaryInputStream::ReadBspc(GEOM *, BSPC *)
CBinaryInputStream::ReadVbsp(int *, VBSP **)
CBinaryInputStream::ReadStringSw(char **)

D:\P2\bbmark.c

0x0013b968

UpdateSwPox(SW *, OXA *, OXA *, unsigned char, unsigned char)
PoxAddSw(SW *, OXA *, OXA *)
PoxRemoveSw(SW *, OXA *, OXA *)
PoxFromSoSo(SO *, SO *)
PxpFirstFromSoSo(SO *, SO *)
AddSwAaobrObject(SW *, SO *)
RemoveSwAaobrObject(SW *, SO *)
InvalidateSwAaox(SW *)
UpdateSwAaox(SW *)
InvalidateSwXpForObject(SW *, SO *, int)
RecalcSwXpAll(SW *, int)
RecalcSwOxfFilterForObject(SW *, SO *)

D:\P2\blend.c

0x0013c470

VerifyAeaEquivalence(int, EA *, int, EA *)
EnsureAsegBlendDynamic(ALO *, int, int, void *, int, int *, int *, ASEGBL **)
FillBlAmrsg(int, int, void *, int, int, OID *)
CalculateBlendAmrsg(int, int, void *, int, int, MRSG *, float *)
ImrsgLookUp(float, float, int, MRSG *, float *)
ReblendAsegbl(ASEGBL *, int, int, void *)
SetAsegblSlerp(ASEGBL *, ALO *)

D:\P2\blip.c

0x0013d0a0

BuildBlipAqwGifs(int, QW **)
StartupBlips(void)
PblipNew(BLIPG *)
RemoveBlip(BLIP *)
PblipgNew(SW *)
InitBlipg(BLIPG *)
OnBlipgAdd(BLIPG *)
OnBlipgRemove(BLIPG *)
SetBlipgShader(BLIPG *, OID)
PropagateBlipgShader(BLIPG *)
SetBlipgEmitb(BLIPG *, EMITB *)
UpdateBlipg(BLIPG *, float)
SubscribeBlipgObject(BLIPG *, LO *)
CblipeProjectBlipTransformAccel(MATRIX4 *, VU_FLOAT, BLIPP *, BLIPV *, BLIPX *, int, BLIPOK, VECTOR *, VECTOR *)
ProjectBlipgTransformAccel(BLIPG *, float)
ProjectBlipgTransform(BLIPG *, float, int)
RenderBlipgSelf(BLIPG *, CM *, RO *)
DrawBlipg(RPL *)
PropagateBlipgShaders(int)

D:\P2\bomb.c

0x0013ed60

InitBomb(BOMB *)
LoadBombFromBrx(BOMB *, CBinaryInputStream *)
CloneBomb(BOMB *, BOMB *)
PostBombLoad(BOMB *)
HandleBombMessage(BOMB *, MSGID, void *)
UpdateBomb(BOMB *, float)
OnBombAdd(BOMB *)
GetBombParams(BOMB *, SOP **)
DecideBombPrime(BOMB *, SO *)
FAbsorbBombWkr(BOMB *, WKR *)
PrimeBomb(BOMB *, float)
ApplyBombThrow(BOMB *, PO *)
DetonateBomb(BOMB *)
PsfxEnsureBomb(BOMB *, ENSK)

D:\P2\bone.c

0x0013ffc8

RenderAloAsBone(ALO *, CM *, RO *)
RenderBoneSelf(BONE *, CM *, RO *)
RenderLboneSelf(LBONE *, CM *, RO *)

D:\P2\bq.c

0x00140280

CByteQueue::Init(int, void *)
CByteQueue::Reset(void)
CByteQueue::CbFill(int, CQueueInput *)
CByteQueue::CbDrain(int, CQueueOutput *)
CByteQueue::CbFill(int, unsigned char *)
CByteQueue::FreeDrain(int)
CQueueInputMemory::CbRead(int, void *)
CQueueInputFile::CbRead(int, void *)

D:\P2\break.c

0x00140610

InitBrk(BRK *)
LoadBrkFromBrx(BRK *, CBinaryInputStream *)
CloneBrk(BRK *, BRK *)
PostBrkLoad(BRK *)
PostBrkLoadCallbackHookup(BRK *, MSGID, void *)
UpdateBrk(BRK *, float)
FAbsorbBrkWkr(BRK *, WKR *)
BreakBrk(BRK *)
SetBrkBroken(BRK *, int)
SetBrkExclude(BRK *, OID)
SetBrkRemain(BRK *, OID)
SetBrkFixed(BRK *, OID)
SetBrkRemainFixed(BRK *, OID)
SetBrkOnPlayer(BRK *, int)
GetBrkOnPlayer(BRK *, int *)
SetBrkOnBomb(BRK *, int)
GetBrkOnBomb(BRK *, int *)
AddBrkTouchObject(BRK *, OID)
AddBrkTouchClass(BRK *, CID)
PsfxEnsureBrk(BRK *, ENSK)
FCheckBrkTouchObject(BRK *, SO *)
UpdateBrkp(BRKP *, float)
HandleBrkpMessage(BRKP *, MSGID, void *)
FIgnoreBrkpIntersection(BRKP *, SO *)
SetBrkpBrkps(BRKP *, BRKPS)
InitBreak(BREAK *)
InitFragile(FRAGILE *)
AdjustFragileNewXp(FRAGILE *, XP *, int)
AdjustZapbreakNewXp(ZAPBREAK *, XP *, int)
UpdateZapbreak(ZAPBREAK *, float)

D:\P2\bsp.c

0x00141980

ClsgClipEdgeToBsp(BSP *, VECTOR *, VECTOR *, int *, int, LSG *)
PruneBsp(BSP *, VECTOR *, float, BSP **)
PbspPointInBspQuick(VECTOR *, BSP *)
CloneBspc(GEOM *, BSPC *, GEOM *, BSPC *)

D:\P2\button.c

0x00142198

PostAshLoad(SW *, ASH *, ALO *)
FFoundAshAseg(ASH *, ASEG *)
FAddAshAseg(ASH *, ASEG *)
FAddAshOid(ASH *, OID)
InitBtn(BTN *)
LoadBtn(BTN *, ALO *)
PostBtnLoad(BTN *)
RestoreBtnFromCheckpointCallback(BTN *, MSGID, void *)
SetBtnRsmg(BTN *, int, OID, OID, OID)
SetBtnButtons(BTN *, BUTTONS)
FAddRsmg(RSMG *, int, int *, int, OID, OID, OID)
TriggerRsmg(SW *, int, RSMG *, LO *, int)
RunBtnAsegs(BTN *, IASH, int)
TriggerBtn(BTN *, int, int)
UntriggerBtn(BTN *, int)
InitButton(BUTTON *)
LoadButtonFromBrx(BUTTON *, CBinaryInputStream *)
InsertButtonPos(BUTTON *, PNT *, VECTOR *)
InsertButtonMat(BUTTON *, XFM *, MATRIX3 *)
PostButtonLoad(BUTTON *)
CloneButton(BUTTON *, BUTTON *)
SetButtonButtons(BUTTON *, BUTTONS)
FCheckButtonObject(BUTTON *, SO *)
IposFindButtonClosest(BUTTON *, float *)
ImatFindButtonClosest(BUTTON *, float *)
PresetButtonAccel(BUTTON *, float)
UpdateButtonInternalXps(BUTTON *)
UpdateButton(BUTTON *, float)
FAbsorbButtonWkr(BUTTON *, WKR *)
GetButtonParams(BUTTON *, SOP **)
InitVolbtn(VOLBTN *)
LoadVolbtnFromBrx(VOLBTN *, CBinaryInputStream *)
PostVolbtnLoad(VOLBTN *)
CloneVolbtn(VOLBTN *, VOLBTN *)
SetVolbtnButtons(VOLBTN *, BUTTONS)
UpdateVolbtn(VOLBTN *, float)
FGetVolbtnPushObjectsWithinList(VOLBTN *, void *)
AddBtnAseg(BTN *, ALO *, OID)
AddButtonAseg(BUTTON *, OID)
AddVolbtnAseg(VOLBTN *, OID)
AddBtnOffAseg(BTN *, ALO *, OID)
AddButtonOffAseg(BUTTON *, OID)
AddVolbtnOffAseg(VOLBTN *, OID)
AddButtonPushObject(BUTTON *, OID)
AddButtonNoPushObject(BUTTON *, OID)
AddButtonPushClass(BUTTON *, CID)
AddButtonNoPushClass(BUTTON *, CID)
AddVolbtnPushObject(VOLBTN *, OID)
SetButtonRsmg(BUTTON *, int, OID, OID, OID)
SetVolbtnRsmg(VOLBTN *, int, OID, OID, OID)

D:\P2\cat.c

0x00144638

StartupCatalog(void)
CWalCatalog::Init(CFileLocation *, CFileLocation *)
CWalCatalog::Reload(void)
CWalCatalog::FFindFile(char *, FK, CFileLocation *)
CWalCatalog::BuildFl(WALE *, CFileLocation *)
CWalCatalog::FDefaultWorld(char *, CFileLocation *)
CWalCatalog::CGetWorlds(int, char **, CFileLocation *)
CCatalog::Init(void)
CCatalog::Reload(void)
CCatalog::FFindFile(char *, FK, CFileLocation *)
CCatalog::FDefaultWorld(char *, CFileLocation *)
CCatalog::CGetWorlds(int, char **, CFileLocation *)
CFileLocation::Clear(void)

D:\P2\can.c

0x001450f0

InitCan(CAN *)
PostCanLoad(CAN *)
FIgnoreCanIntersection(CAN *, SO *)
UpdateCan(CAN *, float)
GetCanParams(CAN *, SOP **)
BreakCan(CAN *)
SetCanGoalState(CAN *, OID)
TrackCan(CAN *, PO *, float, OID *)
FPrepareCanToFire(CAN *)
FireCan(CAN *)
PsoFireCanAtPos(CAN *, VECTOR *)
AddCanFireAccuracy(CAN *, float)

D:\P2\cd.c

0x00145e18

CpchzTokenizePath(char *)
FValidCdMmode(void)
SetCdMmode(void)
StartupCd(void)
UpdateCd(void)
CdPath(char *, char *, int)
ReadCd(unsigned int, unsigned int, void *)
ReadCdDirect(unsigned int, unsigned int, void *)
FCdCompleted(int)

D:\P2\chkpnt.c

0x00146390

ResetChkmgrCheckpoints(CHKMGR *)
SaveChkmgrCheckpoint(CHKMGR *, OID, OID)
ReturnChkmgrToCheckpoint(CHKMGR *)
RestoreChkmgrFromCheckpoint(CHKMGR *)
IchkAllocChkmgr(CHKMGR *)
FGetChkmgrIchk(CHKMGR *, int)
SetChkmgrIchk(CHKMGR *, int)
ClearChkmgrIchk(CHKMGR *, int)
LoadVolFromBrx(VOL *, CBinaryInputStream *)
FCheckVolPoint(VOL *, VECTOR *)
InitChkpnt(CHKPNT *)
LoadChkpntFromBrx(CHKPNT *, CBinaryInputStream *)
BindChkpnt(CHKPNT *)
PostChkpntLoad(CHKPNT *)
CloneChkpnt(CHKPNT *, CHKPNT *)
UpdateChkpnt(CHKPNT *, float)
TriggerChkpnt(CHKPNT *)
AddChkpntVol(CHKPNT *, OID)
AddChkpntAseg(CHKPNT *, OID)
SetChkpntWarp(CHKPNT *, OID)

D:\P2\clip.c

0x00146f50

PsoHitTestLineObjects(int, VECTOR *, VECTOR *, int, SO **, LSG *)
ClsgClipEdgeToObject(SO *, VECTOR *, VECTOR *, int, LSG *)
ClsgClipEdgeToObjectPruned(SO *, BSP *, VECTOR *, VECTOR *, int, LSG *)
ClsgClipCylinderToObject(SO *, VECTOR *, VECTOR *, float, int, LSG *)
ClsgClipLineToSphere(VECTOR *, float, VECTOR *, VECTOR *, int, LSG *)
ClsgClipEdgeToSphere(VECTOR *, float, VECTOR *, VECTOR *, int, LSG *)
ClsgClipCylinderToSphere(VECTOR *, float, VECTOR *, VECTOR *, float, int, LSG *)
ClsgClipEdgeToCylinder(VECTOR *, VECTOR *, float, VECTOR *, VECTOR *, int, LSG *)
SgnCompareMaa(MAA *, MAA *)
ClsgMergeAlsg(int, LSG *)
ClsgClipCylinderToBsp(BSPC *, GEOM *, VECTOR *, VECTOR *, float, int, LSG *)

D:\P2\clock.c

0x00148418

SetClockRate(float)
MarkClockTick(CLOCK *)
MarkClockTickRealOnly(CLOCK *)
ResetClock(CLOCK *, float)
SetClockEnabled(CLOCK *, int)
StartupClock(void)
TickNow(void)

D:\P2\cm.c

0x001486d0

StartupCm(void)
CheckCmProgress(CM *, float, float, float, float)
ResetCmProgress(CM *)
CalcCmAdjust(CM *, SO *, CPDEFI *, VECTOR *)
SpringCm(CM *, VECTOR *, VECTOR *, VECTOR *, float, float, float)
AdjustCmCpdefi(CM *, SO *, float, CPDEFI *)
ResetCmAdjust(CM *, SO *, CPDEFI *)
GetCmCpdefi(CM *, SO *, float, CPDEFI *)
BuildCmFgfn(CM *, float, FGFN *)
RecalcCmFrustrum(CM *)
InitCm(CM *)
SetSwCameraFov(SW *, float)
SetSwCameraNearClip(SW *, float)
SetSwCameraFarClip(SW *, float)
SetSwCameraNearFog(SW *, float)
SetSwCameraFarFog(SW *, float)
SetSwCameraUFogMax(SW *, float)
SetSwCameraRgbaFog(SW *, RGBA *)
SetSwCameraMrdRatio(SW *, float)
SetCmPos(CM *, VECTOR *)
SetCmMat(CM *, MATRIX3 *)
SetCmFov(CM *, float)
SetCmNearClip(CM *, float)
SetCmFarClip(CM *, float)
SetCmNearFog(CM *, float)
SetCmFarFog(CM *, float)
SetCmUFogMax(CM *, float)
SetCmRgbaFog(CM *, RGBA *)
SetCmMrdRatio(CM *, float)
GetCmParams(CM *, SOP **)
ResetCm(CM *, int)
FFilterCamera(void *, SO *)
CpsoClipCmObjects(CM *, SO *, VECTOR *, float, float, int, SO **)
ClearCmFadeObjects(CM *)
AddCmFadeObject(CM *, ALO *)
RemoveCmFadeObject(CM *, ALO *)
UpdateCmFade(CM *)
PxpMarkCmContacts(CM *, VECTOR *, MATRIX3 *, VECTOR *)
FDisplaceCmPos(CM *, VECTOR *, VECTOR *, MATRIX3 *, float, float *, float *, float *)
UpdateCmLast(CM *, int, float)
SetupCmRotateToCam(CM *)
ConvertCmScreenToWorld(CM *, VECTOR *, VECTOR *)
ConvertCmWorldToScreen(CM *, VECTOR *, VECTOR *)
UnlockCm(int)
SetupCm(CM *)
CombineEyeLookAtProj(VECTOR *, MATRIX3 *, MATRIX4 *, MATRIX4 *)
BuildFrustrum(MATRIX3 *, float, float, VECTOR *)
UpdateCmMat4(CM *)
DrawCm(CM *)
SetCmPosMat(CM *, VECTOR *, MATRIX3 *)
SetCmLookAt(CM *, VECTOR *, VECTOR *)
ConvertWorldToCylindVelocity(VECTOR *, VECTOR *, VECTOR *, float *, float *, float *)
ConvertCylindToWorldVelocity(VECTOR *, VECTOR *, float, float, float, VECTOR *)
ResetCmLookAtSmooth(CM *, VECTOR *)
SetCmLookAtSmooth(CM *, int, VECTOR *, VECTOR *, SO *, float, float, float, float, float, float)
AdjustCmJoy(CM *, JOY *, JOYID, float *)
SetCmPolicy(CM *, CPP, CPLCY *, SO *, void *)
RevokeCmPolicy(CM *, int, CPP, CPLCY *, SO *, void *)
FInsideCmMrd(CM *, VU_VECTOR, float, float, float *)
DecomposeCylind(VECTOR *, VECTOR *, float *, float *, float *)
DecomposeSphere(VECTOR *, VECTOR *, float *, float *, float *)
SetCmCut(CM *, float *)
AdaptCm(CM *, VECTOR *, float, float)
SetCm(CM *, VECTOR *, VECTOR *, float, float)
SquishCmEye(CM *, VECTOR *, VECTOR *, VECTOR *)
PushCmLookk(CM *, LOOKK)
LookkPopCm(CM *)
LookkCurCm(CM *)
SetCmSniperFocus(CM *, ALO *, float, float)
JoltCm(CM *)

D:\P2\cnvo.c

0x0014bb60

InitCnvo(CNVO *)
LoadCnvoFromBrx(CNVO *, CBinaryInputStream *)
PostCnvoLoad(CNVO *)
AdjustCnvoXpVelocity(CNVO *, XP *, int)
GetCnvoParams(CNVO *, SOP **)
SetCnvoBeltSpeed(CNVO *, float)
MatchCnvoScrollerToBeltSpeed(CNVO *)

D:\P2\coin.c

0x0014be50

InitDprize(DPRIZE *)
LoadDprizeFromBrx(DPRIZE *, CBinaryInputStream *)
CloneDprize(DPRIZE *, DPRIZE *)
PostDprizeLoad(DPRIZE *)
ProjectDprizeTransform(DPRIZE *, float, int)
FFilterDprizeObjects(DPRIZE *, SO *)
CheckDprizeBounce(DPRIZE *)
CheckDprizeCollect(DPRIZE *)
FAbsorbDprizeWkr(DPRIZE *, WKR *)
UpdateDprize(DPRIZE *, float)
RenderDprizeAll(DPRIZE *, CM *, RO *)
SetDprizeDprizes(DPRIZE *, DPRIZES)
InitCoin(COIN *)
UpdateCoin(COIN *, float)
CreateSwCharm(SW *)
AddLife(void *)
OnCoinSmack(COIN *)
SetCoinDprizes(COIN *, DPRIZES)
InitCharm(CHARM *)
SetCharmDprizes(CHARM *, DPRIZES)
InitKey(KEY *)
SetKeyDprizes(KEY *, DPRIZES)
InitGold(GOLD *)
SetGoldDprizes(GOLD *, DPRIZES)
SgnCompareSdprize(void const *, void const *)
CpdprizeFindSwDprizes(SW *, CID, int, DPRIZE **)
CpdprizeAttractSwDprizes(SW *, CID, VECTOR *, int, DPRIZE **)
RemoveSwExtraneousCharms(SW *)

D:\P2\cplcy.c

0x0014e810

InitCplcy(CPLCY *, CM *)
FActiveCplcy(CPLCY *)
SetCpmanCpmt(CPMAN *, CPMT)
SetCpmanCpmtGlobal(int)
ToggleCpmanOverride(int)
UpdateCpman(CPMAN *, CPDEFI *, JOY *, float)
PosCplookAnchor(CPLOOK *)
PosCplookEye(CPLOOK *)
StartCplookSound(CPLOOK *)
PushCplookLookk(CPLOOK *, LOOKK)
LookkPopCplook(CPLOOK *)
LookkCurCplook(CPLOOK *)
InitCplook(CPLOOK *, CM *)
ActivateCplook(CPLOOK *, void *)
UpdateCplook(CPLOOK *, CPDEFI *, JOY *, float)
DeactivateCplook(CPLOOK *, void *)
InitCpalign(CPALIGN *, CM *)
ActivateCpalign(CPALIGN *, void *)
UpdateCpalign(CPALIGN *, CPDEFI *, JOY *, float)
ActivateCpaseg(CPASEG *, void *)
DeactivateCpaseg(CPASEG *, void *)
UpdateCpaseg(CPASEG *, CPDEFI *, JOY *, float)

D:\P2\credit.c

0x00150580

InitCredit(CREDIT *, BLOTK)
PostCreditLoad(CREDIT *)
SetCreditClock(CREDIT *, float *)
UpdateCredit(CREDIT *)
DrawCredit(CREDIT *)
PlaceCredit(CREDIT *, float, float, int)
VacateCredit(CREDIT *)
SetCreditLine(CREDIT *, int, char *, float)

D:\P2\crout.c

0x00150ad0

CroutDecomp(int, float *, float *)
CroutSolve(int, float *, float *, float *)

D:\P2\crusher.c

0x00150f60

OnCrfodAdd(CRFOD *)
OnCrfodRemove(CRFOD *)
CloneCrfod(CRFOD *, CRFOD *)
InitCrfodb(CRFODB *)
CalcHeadingVector(float, VECTOR *)
UpdateCrfodbGoal(CRFODB *, int)
FDetectCrfodb(CRFODB *)
FAbsorbCrfodbWkr(CRFODB *, WKR *)
SgsNextCrfodkAI(CRFODK *)
FDetectCrfodk(CRFODK *)
FAbsorbCrfodkWkr(CRFODK *, WKR *)
InitCrbrain(CRBRAIN *)
ActivateCrbrain(CRBRAIN *)
ScoreCrbrain(CRBRAIN *, int)

D:\P2\crv.c

0x00151a58

SMeasureApos(int, VECTOR *, float *)
GWrapApos(float, int, float *, int)
IposFindAposG(float, int, float *, int, float *, float *)
EvaluateAposG(float, int, VECTOR *, float *, int, VECTOR *, VECTOR *)
FindAposClosestPointAll(VECTOR *, CONSTR *, int, VECTOR *, VECTOR *, VECTOR *, int *, float *)
FindAposClosestPointSegment(VECTOR *, CONSTR *, int, VECTOR *, int, int, VECTOR *, VECTOR *, int *, float *)
ConvertApos(int, VECTOR *, MATRIX4 *, MATRIX4 *)
PcrvNew(CRVK)
SFromCrvU(CRV *, float)
UFromCrvS(CRV *, float)
IcvFindCrvU(CRV *, float, float *, float *)
IcvFindCrvS(CRV *, float, float *, float *)
GMeasureCrvU(CRVMC *, float)
UMaxCrv(CRV *)
SMaxCrv(CRV *)
SMeasureCrvSegmentU(CRVMS *, float)
FindCrvClosestPointOnLineSegmentFromU(CRV *, VECTOR *, VECTOR *, float, VECTOR *, VECTOR *, float *, float *)
RenderCrv(CRV *, MATRIX4 *, CM *, RGBA, int)
RenderCrvAxesU(CRV *, float, MATRIX4 *, CM *, int)
RenderCrvAxesS(CRV *, float, MATRIX4 *, CM *, int)
DuGetCrvSearchIncrement(CRV *)
LoadCrvlFromBrx(CRVL *, CBinaryInputStream *)
EvaluateCrvlFromU(CRVL *, float, VECTOR *, VECTOR *)
EvaluateCrvlFromS(CRVL *, float, VECTOR *, VECTOR *)
RenderCrvlSegment(CRVL *, int, MATRIX4 *, CM *, RGBA, int)
ConvertCrvl(CRVL *, MATRIX4 *, MATRIX4 *)
SFromCrvlU(CRVL *, float)
UFromCrvlS(CRVL *, float)
MeasureCrvl(CRVL *)
FindCrvlClosestPointAll(CRVL *, VECTOR *, CONSTR *, VECTOR *, VECTOR *, float *, float *)
FindCrvlClosestPointFromU(CRVL *, VECTOR *, float, CONSTR *, VECTOR *, VECTOR *, float *, float *)
FindCrvlClosestPointFromS(CRVL *, VECTOR *, float, CONSTR *, VECTOR *, VECTOR *, float *, float *)
LoadCrvcFromBrx(CRVC *, CBinaryInputStream *)
InvalidateCrvcCache(CRVC *)
FillCrvcCache(CRVC *, int)
EvaluateCrvcFromU(CRVC *, float, VECTOR *, VECTOR *)
EvaluateCrvcFromS(CRVC *, float, VECTOR *, VECTOR *)
RenderCrvcSegment(CRVC *, int, MATRIX4 *, CM *, RGBA, int)
ConvertCrvc(CRVC *, MATRIX4 *, MATRIX4 *)
SFromCrvcU(CRVC *, float)
UFromCrvcS(CRVC *, float)
MeasureCrvc(CRVC *)
FindCrvcClosestPointAll(CRVC *, VECTOR *, CONSTR *, VECTOR *, VECTOR *, float *, float *)
FindCrvcClosestPointFromU(CRVC *, VECTOR *, float, CONSTR *, VECTOR *, VECTOR *, float *, float *)
FindCrvcClosestPointFromS(CRVC *, VECTOR *, float, CONSTR *, VECTOR *, VECTOR *, float *, float *)

D:\P2\cycle.c

0x00153bf0

InitCycle(CYCLE *)
PostCycleLoad(CYCLE *)
PresetCycleAccel(CYCLE *, float)
UpdateCycleWheels(CYCLE *)
UpdateCycleExpls(CYCLE *)
UpdateCycle(CYCLE *, float)
UpdateCycleActive(CYCLE *, JOY *, float)
UpdateCycleInternalXps(CYCLE *)
AddCycleCustomXps(CYCLE *, SO *, int, BSP *, BSP *, XP **)
AdjustCycleNewXp(CYCLE *, XP *, int)
RenderCycleSelf(CYCLE *, CM *, RO *)
UpdateCycleBounds(CYCLE *)
UpdateCycleXfWorld(CYCLE *)
GetCycleCpdefi(CYCLE *, float, CPDEFI *)
OnCycleActive(CYCLE *, int, PO *)
SetCycleCycles(CYCLE *, CYCLES)

D:\P2\dart.c

0x00155778

InitDart(DART *)
OnDartAdd(DART *)
RemoveDart(DART *)
CloneDart(DART *, DART *)
LoadDartFromBrx(DART *, CBinaryInputStream *)
HandleDartMessage(DART *, MSGID, void *)
PostDartLoad(DART *)
UpdateDart(DART *, float)
GetDartParams(DART *, SOP **)
SetDartDarts(DART *, DARTS)
ApplyDartThrow(DART *, PO *)
UpdateDartAirborne(DART *, float)

D:\P2\dartgun.c

0x001561e0

InitDartgun(DARTGUN *)
HandleDartgunMessage(DARTGUN *, MSGID, void *)
BindDartgun(DARTGUN *)
PostDartgunLoad(DARTGUN *)
UpdateDartgun(DARTGUN *, float)
FIgnoreDartgunIntersection(DARTGUN *, SO *)
GetDartgunParams(DARTGUN *, SOP **)
BreakDartgun(DARTGUN *)
SetDartgunGoalState(DARTGUN *, OID)
TrackDartgun(DARTGUN *, OID *)
FPrepareDartgunToFire(DARTGUN *)
FireDartgun(DARTGUN *)
AgeDartgunStuckDart(DARTGUN *)
PratGetDartgunRatTarget(DARTGUN *)
AddDartgunRatTarget(DARTGUN *, OID)
StartDartgunTargetAreaChange(DARTGUN *)
AddDartgunTargetAreaTarget(DARTGUN *, ALO *)

D:\P2\dialog.c

0x00157160

InitDialog(DIALOG *)
LoadDialogFromBrx(DIALOG *, CBinaryInputStream *)
LoadDialogEventsFromBrx(DIALOG *, CBinaryInputStream *, int *, DE **)
SetDialogInstruct(DIALOG *)
SetDialogConfront(DIALOG *)
GetDialogPlayed(DIALOG *, int *)
SetDialogPlayed(DIALOG *, int)
SetDialogDialogs(DIALOG *, DIALOGS)
UpdateDialog(DIALOG *, float)
HandleDialogEvent(DIALOG *, DE *)
HandleDialogMessage(DIALOG *, MSGID, void *)
FPauseDialog(DIALOG *)
HandleDialogEvents(DIALOG *)
TriggerDialog(DIALOG *)
UntriggerDialog(DIALOG *)
AddDialogEquivalence(DIALOG *, WID, OID)

D:\P2\difficulty.c

0x001585b8

PdifficultyEnsureSw(SW *, ENSK)
OnDifficultyGameLoad(DIFFICULTY *)
OnDifficultyWorldPreLoad(DIFFICULTY *)
OnDifficultyWorldPostLoad(DIFFICULTY *)
OnDifficultyInitialTeleport(DIFFICULTY *)
OnDifficultyPlayerDeath(DIFFICULTY *)
OnDifficultyTriggerCheckpoint(DIFFICULTY *, CHKPNT *)
OnDifficultyCollectKey(DIFFICULTY *)
OnDifficultyAward(DIFFICULTY *, int, int, VECTOR *)
OnDifficultyBreak(DIFFICULTY *, VECTOR *, int)
OnDifficultyNpc(DIFFICULTY *, VECTOR *, int)
OnDifficultyMiniNpc(DIFFICULTY *, VECTOR *, int)
ChangeSuck(int)
ResetSuckChkpnts(int)
SetSuckChkpnts(int)

D:\P2\dl.c

0x00158d00

InitDl(DL *, int)
ClearDl(DL *)
ClearDle(DLE *)
PdleFromDlEntry(DL *, void *)
AppendDlEntry(DL *, void *)
PrependDlEntry(DL *, void *)
InsertDlEntryBefore(DL *, void *, void *)
RemoveDlEntry(DL *, void *)
FFindDlEntry(DL *, void *)
FIsDlEmpty(DL *)
MergeDl(DL *, DL *)
CPvDl(DL *)

D:\P2\dmas.c

0x00159158

StartupDma(void)
DMAS::DMAS(void)
DMAS::Clear(void)
DMAS::Reset(void)
DMAS::AllocGlobal(int)
DMAS::AllocSw(int, int)
DMAS::AllocStack(int)
DMAS::AllocStatic(int, QW *)
DMAS::Detach(int *, QW **)
DMAS::DetachCopySw(int *, QW **, QW **, int)
DMAS::Send(sceDmaChan *)
DMAS::Sync(sceDmaChan *)
DMAS::AddDmaCnt(void)
DMAS::AddDmaRefs(int, QW *)
DMAS::AddDmaCall(QW *)
DMAS::AddDmaRet(void)
DMAS::AddDmaBulk(int, QW *)
DMAS::AddDmaEnd(void)
DMAS::EndDmaCnt(void)
DMAS::EndPrim(int)

D:\P2\dsp.c

0x00159840

PostDspLoad(DSP *)
UpdateDsp(DSP *, float)

D:\P2\dysh.c

0x00159ca0

InitDysh(DYSH *)
SetDyshShadow(DYSH *, SHADOW *)
RenderDyshSelf(DYSH *, CM *, RO *)
DrawDysh(RPL *)

D:\P2\dzg.c

0x0015a540

InitDzg(DZG *, int)
ClearDzgSolution(DZG *)
AppendDzgDz(DZG *, DZ *)
FillDzgDz(DZG *, int, DZ *, int, XP **, int *, SO ***)
EnforceDzgDz(DZG *, DZ *)
SolveDzg(DZG *, int, int, XP **, int *, SO ***)
SolveDzgFric(DZG *, int, int, XP **, int *, SO ***, float)
ApplyDzg(DZG *, int, int *, SO ***, float, float)
SolveInequalities(int, float *, float *, float *)

D:\P2\emitter.c

0x0015bb90

InitEmitb(EMITB *)
InitEmitter(EMITTER *)
LoadEmitmeshFromBrx(EMITMESH *, CBinaryInputStream *)
LoadEmitblipColorsFromBrx(EMITBLIP *, int, LO *, CBinaryInputStream *)
LoadEmitterFromBrx(EMITTER *, CBinaryInputStream *)
CloneEmitter(EMITTER *, EMITTER *)
BindEmitterCallback(EMITTER *, MSGID, void *)
BindEmitter(EMITTER *)
PostEmitterLoad(EMITTER *)
HandleEmitterMessage(EMITTER *, MSGID, void *)
GetEmitterParams(EMITTER *, SOP **)
RenderEmitterSelf(EMITTER *, CM *, RO *)
PemitbCopyOnWrite(EMITB *)
PemitbEnsureEmitter(EMITTER *, ENSK)
PemitterEnsureEmitter(EMITTER *, ENSK)
AddEmitterSkeleton(EMITTER *, OID, OID, float, float, float, float)
ModifyEmitterParticles(EMITTER *)
UpdateEmitter(EMITTER *, float)
PauseEmitter(EMITTER *, float)
PauseEmitterIndefinite(EMITTER *)
UnpauseEmitter(EMITTER *)
FPausedEmitter(EMITTER *)
SetEmitterEnabled(EMITTER *, int)
GetEmitterEnabled(EMITTER *, int *)
GetEmitterPaused(EMITTER *, int *)
OnEmitterValuesChanged(EMITTER *)
SetEmitterParticleCount(EMITTER *, int)
SetEmitterAutoPause(EMITTER *, int)
SetEmitbRipt(EMITB *, RIPT)
SetEmitterRipt(EMITTER *, RIPT)
SetExploRipt(EXPLO *, RIPT)
WakeSoWater(SO *, WATER *, float, VECTOR *, VECTOR *, float, float)
StandardSmokeCloud(VECTOR *, float)
ChooseEmitoPos(EMITO *, int, int, VECTOR *, VECTOR *)
ConvertEmitoPosVec(EMITO *, VECTOR *, VECTOR *)
CalculateEmitvx(int, LM *, int, EMITVX *)
ChooseEmitVelocity(EMITVX *, float, float, LM *, VECTOR *, int, VECTOR *)
ChooseEmitvVelocityAge(EMITV *, EMITVX *, EMITO *, int, VECTOR *, VECTOR *, VECTOR *, float *, float *)
EmitRips(EMITB *, EMITG *, int, VECTOR *, VECTOR *, float *, float *)
EmitBlips(EMITB *, EMITG *, int, VECTOR *, VECTOR *, float *, float *, VECTOR *, VECTOR *)
OriginateParticles(int, EMITB *, EMITGEN *)
OriginateSplineSinkParticles(int, EMITB *, EMITGEN &, EMITGEN &)
EmitParticles(int, EMITB *, EMITG *)
EmitRipsSphere(VECTOR *, VECTOR *, int, EMITRIP *, EMITV *, RIPG **, LO *)
StockSplashBig(VECTOR *, float, SO *)
StockSplashSmall(VECTOR *, float, SO *)
AddEmitoSkeleton(EMITO *, OID, OID, float, float, float, float, LO *)
BindEmitb(EMITB *, LO *)
SetEmitdvEmitb(EMITDV *, EMITB *)
CalculateEmitdvMatrix(EMITDV *, float, MATRIX4 *)
PostExplLoad(EXPL *)
CalculateExplTransform(EXPL *, VECTOR *, MATRIX3 *)
ExplodeExpl(EXPL *)
ExplodeExplParams(EXPL *, unsigned int, ALO *, VECTOR *, VECTOR *, float, float)
ExplodeExplExplso(EXPL *, EXPLSO *)
LoadExplgFromBrx(EXPLG *, CBinaryInputStream *)
CloneExplg(EXPLG *, EXPLG *)
BindExplg(EXPLG *)
ExplodeExplgExplso(EXPLG *, EXPLSO *)
InitExplo(EXPLO *)
LoadExploFromBrx(EXPLO *, CBinaryInputStream *)
CloneExplo(EXPLO *, EXPLO *)
BindExplo(EXPLO *)
ExplodeExploExplso(EXPLO *, EXPLSO *)
GetExploParams(EXPLO *, SOP **)
AddExploSkeleton(EXPLO *, OID, OID, float, float, float, float)
PemitbEnsureExplo(EXPLO *, ENSK)
InitExpls(EXPLS *)
BindExpls(EXPLS *)
HandleExplsMessage(EXPLS *, MSGID, void *)
ExplodeExplsExplso(EXPLS *, EXPLSO *)
GetExplsParams(EXPLS *, SOP **)
UpdateExplsLiveEdit(EXPLS *, float)
PsfxEnsureExpls(EXPLS *, ENSK)
FireExplsExplso(EXPLS *, EXPLSO *)
InferExpl(EXPL **, ALO *)
FireSwTimedExplodeStyles(SW *)

D:\P2\eyes.c

0x00161110

InitEyes(EYES *, SAAF *)
PostEyesLoad(EYES *)
SetEyesEyess(EYES *, EYESS)
UpdateEyes(EYES *, float)
SetEyesClosed(EYES *, float)
PsaiFromEyesShd(EYES *, SHD *)

D:\P2\fader.c

0x001615d8

UpdateFader(FADER *, float)
PfaderNew(ALO *)
RemoveFader(FADER *)

D:\P2\find.c

0x001617e8

PdlFromSwOid(SW *, OID)
MatchSwObject(LO *, int, int, int, LO *, int, int *, LO **, int *)
CploFindSwObjects(SW *, int, OID, LO *, int, LO **)
PloFindSwObject(SW *, int, OID, LO *)
PloFindSwNearest(SW *, OID, LO *)
PloFindSwChild(SW *, OID, ALO *)
FIsCidDerivedFrom(CID, CID)
CploFindSwObjectsByClass(SW *, int, CID, LO *, int, LO **)
PloFindSwObjectByClass(SW *, int, CID, LO *)
PaloFindLoCommonParent(LO *, LO *)

D:\P2\flash.c

0x001621f0

InitFlash(FLASH *)
LoadFlashFromBrx(FLASH *, CBinaryInputStream *)
UpdateFlash(FLASH *, float)
RenderFlashSelf(FLASH *, CM *, RO *)
FPosFlashWithin(FLASH *, VECTOR *)

D:\P2\fly.c

0x00162470

InitFly(FLY *)
LoadFlyFromBrx(FLY *, CBinaryInputStream *)
CloneFly(FLY *, FLY *)
FreezeFly(FLY *, int)
PostFlyLoad(FLY *)
PresetFlyAccel(FLY *, float)
UpdateFly(FLY *, float)
RenderFlySelf(FLY *, CM *, RO *)
FAbsorbFlyWkr(FLY *, WKR *)
GetFlyParams(FLY *, SOP **)
SetFlyFlys(FLY *, FLYS)
EmitFlyDroppings(FLY *)
FFindFlyClosestLandingPos(FLY *, VECTOR *)
FlysAttemptedFlyLanding(FLY *)
FShouldFlyFlee(FLY *)
FFilterFly(void *, SO *)
FCheckFlyOpenSpaceBelow(FLY *)

D:\P2\font.c

0x00163de0

StartupFont(void)
CFont::CopyTo(CFont *)
CFont::SetupDraw(CTextBox *, GIFS *)
CFont::CleanupDraw(CTextBox *, GIFS *)
CFont::DxFromPchz(char *)
CFont::DyWrapPchz(char *, float)
CFont::ClineWrapPchz(char *, float)
CFont::DxMaxLine(char *)
CFont::GetExtents(char *, float *, float *, float)
CFont::DrawPchz(char *, CTextBox *, CTextBox *, GIFS *)
CFont::PushScaling(float, float)
CFont::PopScaling(void)
CFontDebug::CFontDebug(void)
CFontDebug::PfontClone(float, float)
CFontDebug::CopyTo(CFontDebug *)
CFontDebug::FValid(char)
CFontDebug::DxFromCh(char)
CFontDebug::SetupDraw(CTextBox *, GIFS *)
CFontDebug::SwitchTex0(GIFS *)
CFontDebug::DxDrawCh(char, float, float, unsigned int, GIFS *)
CFontDebug::EdgeRect(CTextEdge *, CTextBox *, GIFS *)
CFontBrx::PfontClone(float, float)
CFontBrx::CopyTo(CFontBrx *)
CFontBrx::FValid(char)
CFontBrx::DxFromCh(char)
CFontBrx::FEnsureLoaded(GIFS *)
CFontBrx::SetupDraw(CTextBox *, GIFS *)
CFontBrx::SwitchTex0(GIFS *)
CFontBrx::DxDrawCh(char, float, float, unsigned int, GIFS *)
CFontBrx::DrawPart(float, float, float, float, float, float, float, float, unsigned int, GIFS *)
CFontBrx::EdgeRect(CTextEdge *, CTextBox *, GIFS *)
CFontBrx::LoadFromBrx(CBinaryInputStream *)
CFontBrx::PostLoad(GSB *)
CFontBrx::PglyffFromCh(char)
CRichText::CRichText(char *, CFont *)
CRichText::Reset(void)
CRichText::SetBaseColor(RGBA)
CRichText::ChNext(void)
CRichText::Cch(void)
CRichText::Trim(int)
CRichText::Dx(void)
CRichText::ClineWrap(float)
CRichText::DxMaxLine(void)
CRichText::GetExtents(float *, float *, float)
CRichText::Draw(CTextBox *, CTextBox *, GIFS *)
PostFontsLoad(void)

D:\P2\frm.c

0x001667c0

VU1_Interrupt(int)
StartupFrame(void)
OpenFrame(void)
EnsureVu1Code(VIFS *, void *, void *)
FinalizeFrameVifs(VIFS *, int *, QW **)
FinalizeFrameGifs(GIFS *, int *, QW **)
CloseFrame(void)
PrepareGsForFrameRender(FRM *)
FrameRenderLoop(void *)
RenderFrame(FRM *, int)
ClearPendingFrame(FRM *)
FlushFrames(int)
BlendPrevFrame(void)

D:\P2\freeze.c

0x00167a38

RemergeSwObject(SW *, ALO *)
MergeSwFreezeGroups(SW *, ALO *, ALO *)
SplinterSwFreezeGroup(SW *, ALO *)
MergeSwGroup(SW *, MRG *)
AddSwMergeGroup(SW *, MRG *)
RemoveFromArray(int *, void **, void *)
RemoveSwMergeGroup(SW *, MRG *)
RemergeSwObjects(SW *)
FreezeAloHierarchy(ALO *, int)
GetAloFrozen(ALO *, int *)
FreezeAlo(ALO *, int)
FreezeSo(SO *, int)
RefreezeSwObjects(SW *)
UpdateSwBusyList(SW *)

D:\P2\frzg.c

0x00168488

PostFrzgLoad(FRZG *)
AddFrzgObject(FRZG *, OID)

D:\P2\game.c

0x00168598

StartupGame(void)
PchzFromLevel(GAMEWORLD, WORLDLEVEL)
PchzFriendlyFromLevel(GAMEWORLD, WORLDLEVEL)
PchzFriendlyFromWorld(char *)
FFindLevel(char *, GAMEWORLD *, WORLDLEVEL *)
InitGameState(GS *)
SetupGame(char *, int)
UpdateGameState(float)
GrflsFromWid(WID)
ClearLs(LS *)
UnloadGame(void)
RetryGame(void)
StartGame(void)
SetCcharm(int)
FCharmAvailable(void)
SetClife(int)
SetCcoin(int)
PfLookupDialog(LS *, OID)
AchzFromGameworld(GAMEWORLD)
CwlpGetWlps(int, WLP *)
OnGameLoad(GAME *)
OnGameWorldTransition(GAME *)
OnGameAlarmTriggered(GAME *)
OnGameAlarmDisabled(GAME *)
OnGameEnterUis(GAME *, UIS)
StartGameTimedChallenge(GAME *, GOLD *)
EndGameTimedChallenge(GAME *, int *)
OnGameTimedChallengeTimerNotify(TIMER *, TIMERNOTK)
StartGameTimedChallengeTimer(GAME *, float)
ResetGameTimedChallenge(GAME *)
PrepareGameGoldForTimedChallenge(GAME *)
GetBlueprintInfo(int *, int *)
CcharmMost(void)

D:\P2\geom.c

0x00169400

InitGeom(GEOM *)
CloneGeom(GEOM *, MATRIX4 *, GEOM *)
BuildGeomPointMap(GEOM *)

D:\P2\gifs.c

0x00169778

GIFS::GIFS(void)
GIFS::AddPrimEnd(void)
GIFS::EndPrim(int)
GIFS::CheckReg(int, int)
GIFS::AddPrimBulk(int, int, int, unsigned long, QW **)
GIFS::AddPrimPack(int, int, unsigned long)
GIFS::PackRGBA(unsigned int)
GIFS::PackUV(int, int)
GIFS::PackSTQ(float, float, float)
GIFS::PackXYZ(int, int, int)
GIFS::PackXYZF(int, int, int, int)
GIFS::PackXYZFNoKick(int, int, int, int)
GIFS::PackAD(int, long)
GIFS::AddPrimList(int, unsigned long)
GIFS::ListRGBAQ(unsigned int, float)
GIFS::ListUV(int, int)
GIFS::ListXYZF(int, int, int, int)
GIFS::AddImage(int)

D:\P2\glbs.c

0x00169fe0

GLBS::GLBS(void)
GLBS::~GLBS(void)
GLBS::SetTransform(VECTOR *, MATRIX3 *)
GLBS::FindLights(VECTOR *, float)
GLBS::ResetStrip(void)
GLBS::BeginStrip(SHD *)
GLBS::DrawPrelit(void)
GLBS::DrawThreeWay(void)
GLBS::EndStrip(void)
GLBS::SetPos(VECTOR *)
GLBS::SetNormal(VECTOR *)
GLBS::SetRgba(RGBA)
GLBS::SetUv(UVF *)
GLBS::AddVtx(int)

D:\P2\glob.c

0x0016b000

BuildGlobsetSaaArray(GLOBSET *)
LoadGlobsetFromBrx(GLOBSET *, CBinaryInputStream *, ALO *)
EnsureBuffer(int, VIFS *)
EnsureBufferCel(int, VIFS *)
BuildSubcel(GLOBSET *, int, SUBCEL *, int, VECTORF *, int, TWEF *, SUBPOSEF *, VECTORF *, float *, VIFS *)
BuildSubglobSinglePass(GLOBSET *, GLOB *, int, SUBGLOB *, SHD *, VECTORF *, VECTORF *, RGBA *, UVF *, int, VTXF *, SUBPOSEF *, VECTORF *, VECTORF *, float *, VIFS *, SGVR *)
BuildSubglobThreeWay(GLOBSET *, GLOB *, int, SUBGLOB *, SHD *, VECTORF *, VECTORF *, RGBA *, UVF *, int, VTXF *, SUBPOSEF *, VECTORF *, VECTORF *, float *, VIFS *, SGVR *)
BuildSubglobLighting(GLOB *, SUBGLOB *, SUBGLOBI *)
PostGlobsetLoad(GLOBSET *, ALO *)
BindGlobset(GLOBSET *, ALO *)
CloneGlobset(GLOBSET *, ALO *, GLOBSET *)
CloneGlob(GLOBSET *, GLOB *, GLOBI *)
UpdateGlobset(GLOBSET *, ALO *, float)
UpdateAloConstraints(ALO *)
UpdateAloInfluences(ALO *, RO *)
PredrawGlob(GLOBSET *, GLOB *, GLOBI *, ALO *)
RotateVu1Buffer(void)
DrawGlob(RPL *)

D:\P2\gomer.c

0x00171100

InitGomer(GOMER *)
PostGomerLoad(GOMER *)
RenderGomerSelf(GOMER *, CM *, RO *)
FDetectGomer(GOMER *)
GetGomerParams(GOMER *, SOP **)

D:\P2\gs.c

0x001719d8

BlendDisplayOnBufferMismatch(void)
VBlankS_Interrupt(int)
SyncVBlank(void)
SwapGsBuffers(void)
RestoreGsBuffers(void)
GS_Interrupt(int)
ResetGs(void)
SendDmaSyncGsFinish(sceDmaChan *, QW *)
BuildClearGifs(QW *, RGBA, int)
StartupGs(void)
BlastAqwGifsBothFrames(QW *)
ClearFrameBuffers(void)
FadeFramesToBlack(float)
ResetGsMemory(void)
NLog2(unsigned int)
InitGsb(GSB *, int, int)
ResetGsb(GSB *)
IgsAllocGsb(GSB *, int)
BuildImageGifs(int, int, int, int, int, int, GIFS *)
BuildClutTex2(CLUT *, int)
BuildClutGifs(CLUT *, int, GIFS *)
BuildBmpTex0(BMP *, int)
BuildBmpGifs(BMP *, int, GIFS *)
FBuildUploadBitmapGifs(int, GSB *, GIFS *)
UploadBitmaps(int, GSB *)
PqwGifsBitmapUpload(int)
PropagateSur(SUR *)
ReferenceShaderAqwRegs(SHD *, SHDP *, QW *, int, int, SAI *)
ReferenceUVAnimation(QW *, int, SAI *)
RebaseSurs(int, int, void *, void *)
PropagateSurs(void)
PqwVifsBitmapUpload(int)
DrawOnBitmap(BMP *, GIFS *)

D:\P2\hg.c

0x00173900

InitHg(HG *)
PostHgLoad(HG *)
PresetHgAccel(HG *, float)
UpdateHg(HG *, float)
UpdateHgActive(HG *, JOY *, float)
RenderHgSelf(HG *, CM *, RO *)
GetHgCpdefi(HG *, float, CPDEFI *)
SetHgHgs(HG *, HGS)

D:\P2\hide.c

0x00174558

StartupHide(void)
ResetHideList(void)
InitHshape(HSHAPE *)
OnHshapeAdd(HSHAPE *)
OnHshapeRemove(HSHAPE *)
BindHshape(HSHAPE *)
CloneHshape(HSHAPE *, HSHAPE *)
GetHshapeHidePos(HSHAPE *, float, VECTOR *, float *)
GetHshapeClosestHidePos(HSHAPE *, float *, VECTOR *, float *)
InitHpnt(HPNT *)
OnHpntAdd(HPNT *)
OnHpntRemove(HPNT *)
BindHpnt(HPNT *)
CloneHpnt(HPNT *, HPNT *)
GetHpntClosestHidePos(HPNT *, VECTOR *, float *)
InitHbsk(HBSK *)
LoadHbskFromBrx(HBSK *, CBinaryInputStream *)
OnHbskAdd(HBSK *)
OnHbskRemove(HBSK *)
CloneHbsk(HBSK *, HBSK *)
FIgnoreHbskIntersection(HBSK *, SO *)
PresetHbskAccel(HBSK *, float)
SetHbskHbsks(HBSK *, HBSKS)
CdartStuckHbsk(HBSK *)
PdartOldestHbskStuck(HBSK *)
GetHbskClosestHidePos(HBSK *, VECTOR *, float *)

D:\P2\hnd.c

0x001754b0

InitHnd(HND *)
LoadHndFromBrx(HND *, CBinaryInputStream *)

D:\P2\ik.c

0x00175520

RenderIkhSelf(IKH *, CM *, RO *)
RenderLikhSelf(LIKH *, CM *, RO *)
SolveAloIK(ALO *)

D:\P2\jack.c

0x00175e98

InitJack(JACK *)
PostJackLoad(JACK *)
UpdateJackActive(JACK *, JOY *, float)
SetJackJacks(JACK *, JACKS)
PjacknAllocJack(JACK *, VECTOR *)
TakeJackDamage(JACK *)
AddJackPrize(JACK *, int, int, SO *)
InitJackb(JACKB *)
PostJackbLoad(JACKB *)
PlanJackbChase(JACKB *)
UpdateJackb(JACKB *, float)
HandleJackbMessage(JACKB *, MSGID, void *)
SetJackbJbs(JACKB *, JBS)
InitJackn(JACKN *)
LoadJacknFromBrx(JACKN *, CBinaryInputStream *)
UpdateJackn(JACKN *, float)
RenderJacknSelf(JACKN *, CM *, RO *)
RebindJackn(JACKN *)
InitJackf(JACKF *)
UpdateJackf(JACKF *, float)
BuildJackfRim(JACKF *)
JekClassifyJackfVertex(JACKF *, int, int)
JekClassifyJackfEdge(JACKF *, int, int, JEA *)
NCmpJep(void const *, void const *)
UpdateJackfGrid(JACKF *)
CjeSpliceJackfRim(JACKF *, int, int, int, JE *, JE *)
ApplyJackfGap(JACKF *)
JkFromJackfIJK(JACKF *, int, int, int)
GetJackfPos(JACKF *, float, float, VECTOR *)
GetJackfRim(JACKF *, float, VECTOR *, VECTOR *)
GetJackfGap(JACKF *, float, VECTOR *, VECTOR *)
MapJackfCell(JACKF *, VECTOR *, int *, int *, int *)
IjeFindJackfClosestEdge(JACKF *, int, int, JE *, VECTOR *, float *, float *)
DrawJackf(RPL *)
RenderJackfSelf(JACKF *, CM *, RO *)
DropJackf(JACKF *)
CalculateJackfField(JACKF *, int, JE *, int *)

D:\P2\jlo.c

0x0017a0d8

InitJlo(JLO *)
LoadJloFromBrx(JLO *, CBinaryInputStream *)
PostJloLoad(JLO *)
PresetJloAccel(JLO *, float)
UpdateJlo(JLO *, float)
JlosNextJlo(JLO *)
SetJloJlovol(JLO *, JLOVOL *)
FireJlo(JLO *)
LandJlo(JLO *)
JumpJlo(JLO *)
HandleJloMessage(JLO *, MSGID, void *)
SetJloJlos(JLO *, JLOS)
ActivateJlo(JLO *)
DeactivateJlo(JLO *)
InitJloc(JLOC *)
LoadJlocFromBrx(JLOC *, CBinaryInputStream *)
PostJlocLoad(JLOC *)
PxfmChooseJloc(JLOC *)
GetJlocParams(JLOC *, SOP **)
InitJlovol(JLOVOL *)
BindJlovol(JLOVOL *)
HandleJlovolMessage(JLOVOL *, MSGID, void *)

D:\P2\joy.c

0x0017b480

StartupJoy(void)
AddGrfusr(int)
RemoveGrfusr(int)
UpdateGrfjoytFromGrfusr(void)
InitJoy(JOY *, int, int)
UpdateJoy(JOY *)
SetJoyJoys(JOY *, JOYS, JOYK)
GetJoyXYDeflection(JOY *, unsigned char, unsigned char, float *, float *, float *, unsigned char *, unsigned char *, int *, LM *)
FReadJoy(JOY *)
SetJoyBtnHandled(JOY *, unsigned short)
TriggerJoyRumbleRumk(JOY *, RUMK, float)
EnableJoyRumble(JOY *, int)
StartJoySelection(JOY *)
DxSelectionJoy(JOY *)
DySelectionJoy(JOY *)
UBtnpJoy(JOY *, BTNP)
AddCode(CODE *)
_ResetCodes(void)
_MatchCodes(JOY *, unsigned short)
UpdateCodes(void)
AddFcht(int)
LoadLevel(int)
StartupCodes(void)

D:\P2\jt.c

0x0017ca10

InitJt(JT *)
LoadJtFromBrx(JT *, CBinaryInputStream *)
PostJtLoad(JT *)
PresetJtAccelBase(JT *)
PresetJtAccel(JT *, float)
AdjustJtNewXp(JT *, XP *, int)
AdjustJtDz(JT *, int, DZ *, int, float)
HandleJtGrfjtsc(JT *)
UpdateJtInternalXps(JT *)
FCheckJtXpBase(JT *, XP *, int)
AdjustJtXpVelocity(JT *, XP *, int)
HandleJtMessage(JT *, MSGID, void *)
FTurnJtToTarget(JT *)
UpdateJtBalance(JT *)
RebuildJtXmg(JT *, ALO *, float, ALO *, ACTADJ *, XMG *)
FMatchJtXmg(JT *, XMG *, ACTADJ *)
UpdateJtStand(JT *)
ThrowJt(JT *, VECTOR *, float, float)
UnhookJt(JT *)
CalculateJtToolSpin(JT *, float, MATRIX3 *)
RenderJtAll(JT *, CM *, RO *)
RenderJtSelf(JT *, CM *, RO *)
UpdateJtTool(JT *)
AdjustJtXps(JT *)
UpdateJtPosWorldPrev(JT *)
ProjectJtTransform(JT *, float, int)
UpdateJtBounds(JT *)
PsoGetJtEffect(JT *, int *)
AddJtCustomXps(JT *, SO *, int, BSP *, BSP *, XP **)
CtTorqueJt(JT *)
GetJtCpdefi(JT *, float, CPDEFI *)
GetJtCpdefiFlatten(JT *, CPDEFI *)
UpdateJtActive(JT *, JOY *, float)
UpdateJt(JT *, float)
UpdateJtDrive(JT *)
ChooseJtPhys(JT *)
EnableJtActadj(JT *, int)
SetJtJts(JT *, JTS, JTBS)
ProfileJt(JT *, int)
SetJtPuppet(JT *, ASEGA *, EA *)
PaloAbsorbWkr(WKR *, int, ALO **)
NCmpWkr(WKR *, WKR *)
UpdateJtEffect(JT *)
FIsJtSoundBase(JT *)
CollectJtPrize(JT *, PCK, ALO *)
GetJtDiapi(JT *, DIALOG *, DIAPI *)
PlayJtDialog(JT *, DIALOG *)

D:\P2\jp.c

0x001856f0

InitJp(JP *)
PostJpLoad(JP *)
PresetJpAccel(JP *, float)
UpdateJp(JP *, float)
UpdateJpActive(JP *, JOY *, float)
RenderJpSelf(JP *, CM *, RO *)
UseJpCharm(JP *)
OnJpActive(JP *, int, PO *)
RenderJpAll(JP *, CM *, RO *)
FInvulnerableJp(JP *, ZPK)
ApplyJpThrow(JP *, PO *)
FTakeJpDamage(JP *, ZPR *)
AdjustJpXps(JP *)
HandleJpMessage(JP *, MSGID, void *)
JthsCurrentJp(JP *)
SetJpJps(JP *, JPS)

D:\P2\jsg.c

0x00187100

InitJsg(JSG *)
GetJsgLocation(JSG *, LO *, VECTOR *, float *)
SetJsgFocus(JSG *, LO *)
SetJsgTn(JSG *, TN *)
NextJsgJsge(JSG *)
FIsJsgJsgeComplete(JSG *, JSGE *)
UpdateJsgJsge(JSG *)
ReadJsgJoystick(JSG *, JOY *)
FIsJsgActive(JSG *)
ClearJsg(JSG *)
ApplyJsg(JSG *, JT *)
RetractJsg(JSG *)
PjsgeAllocJsg(JSG *, JSGEK, OID, int)
AddJsgContext(JSG *, OID)
AddJsgCut(JSG *, OID)
AddJsgFocus(JSG *, OID)
AddJsgLabel(JSG *, OID)
AddJsgTunnel(JSG *, OID)
AddJsgPause(JSG *, OID, float)
AddJsgAseg(JSG *, OID, int)
AddJsgJump(JSG *, OID, JSGJK, JSGLK, int)
AddJsgRun(JSG *, OID, float, int)
AddJsgClimb(JSG *, OID, float, int)
AddJsgAttack(JSG *, OID, FTAK, int)
AddJsgClock(JSG *, float)

D:\P2\jump.c

0x00188638

PresetJtAccelJump(JT *)
UpdateJtActiveJump(JT *, JOY *)
FCheckJtSingleEdge(JT *, SO *, EDGE *, VECTOR *)
FCheckJtEdgeNormal(JT *, VECTOR *, VECTOR *)
FCheckJtEdgeGrab(JT *, SO *, VECTOR *, XPK, void *, VECTOR *)
PxpFindJtBestEdge(JT *, int *, VECTOR *)
JtsResetJt(JT *)
HandleJtDiveEffect(JT *)
UpdateJtJump(JT *)
FTimeJtJumpToTarget(JT *, VECTOR *, VECTOR *, VECTOR *, VECTOR *, float *)
GetJtJumpVelocity(JT *, VECTOR *)
GetJtJumpToTargetVelocity(JT *, VECTOR *)
GetJtJumpBoostVelocity(JT *, VECTOR *)
StartupJmt(void)
ResetJmtList(void)
OnJmtAdd(JMT *)
OnJmtRemove(JMT *)
CloneJmt(JMT *, JMT *)
PostJmtLoad(JMT *)

D:\P2\keyhole.c

0x0018b070

InitKeyhole(KEYHOLE *)
LoadKeyholeFromBrx(KEYHOLE *, CBinaryInputStream *)
DrawKeyholeMask(KEYHOLE *, float, float, float, float)
DrawKeyhole(KEYHOLE *, float)

D:\P2\landing.c

0x0018c178

OnLandingAdd(LANDING *)
OnLandingRemove(LANDING *)
CloneLanding(LANDING *, LANDING *)

D:\P2\lgn.c

0x0018c258

InitLgn(LGN *)
PostLgnLoad(LGN *)
UpdateLgnActive(LGN *, JOY *, float)
UpdateLgn(LGN *, float)
OnLgnActive(LGN *, int, PO *)
RenderLgnAll(LGN *, CM *, RO *)
GetLgnCpdefi(LGN *, float, CPDEFI *)
FInvulnerableLgn(LGN *, ZPK)
JthsCurrentLgn(LGN *)
UseLgnCharm(LGN *)
ApplyLgnThrow(LGN *, PO *)
FTakeLgnDamage(LGN *, ZPR *)
HandleLgnMessage(LGN *, MSGID, void *)
AdjustLgnXps(LGN *)
SetLgnLgns(LGN *, LGNS)
UpdateLgnrAim(LGNR *, JOY *)
DrawLgnr(LGNR *)
InitSwp(SWP *)
PostSwpLoad(SWP *)
UpdateSwp(SWP *, float)
ProjectSwpTransform(SWP *, float, int)
SetSwpShape(SWP *, SHAPE *, float)
InitLgnb(LGNB *)
PostLgnbLoad(LGNB *)
UpdateLgnb(LGNB *, float)
PresetLgnbAccel(LGNB *, float)
FAbsorbLgnbWkr(LGNB *, WKR *)
AttackLgnb(LGNB *, VECTOR *)
GetLgnbAttacking(LGNB *, int *)

D:\P2\lo.c

0x0018ece0

InitLo(LO *)
PostLoLoad(LO *)
AddLo(LO *)
AddLoHierarchy(LO *)
OnLoAdd(LO *)
RemoveLo(LO *)
DeferLoRemove(LO *)
SetLoSuckHideLimits(LO *, LM *)
RemoveLoHierarchy(LO *)
OnLoRemove(LO *)
SnipLo(LO *)
FFindLoParent(LO *, ALO *)
SetLoParent(LO *, ALO *)
FIsLoInWorld(LO *)
GetLoInWorld(LO *, int *)
PloCloneLo(LO *, SW *, ALO *)
CloneLoHierarchy(LO *, LO *)
CloneLo(LO *, LO *)
SubscribeSwPpmqStruct(SW *, MQ **, void (*)(void *, MSGID, void *), void *)
UnsubscribeSwPpmqStruct(SW *, MQ **, void (*)(void *, MSGID, void *), void *)
SubscribeLoStruct(LO *, void (*)(void *, MSGID, void *), void *)
UnsubscribeLoStruct(LO *, void (*)(void *, MSGID, void *), void *)
SubscribeLoObject(LO *, LO *)
UnsubscribeLoObject(LO *, LO *)
SendLoMessage(LO *, MSGID, void *)
LoadLoFromBrx(LO *, CBinaryInputStream *)
FMatchesLoName(LO *, OID)
OidProxyLo(LO *)
OidProxyLoPreferred(LO *)
GetLoOidProxy(LO *, OID *)
PchzProxyLoPreferred(LO *)
PostSpliceEventCallback(LO *, unsigned int, void *)
FFilterSpliceEvent(LO *, SYMEVID, int, void **)
HandleLoSpliceEvent(LO *, unsigned int, int, void **)
EnsureLoSidebagBool(LO *, OPTID, int)
EnsureLoSidebagInt(LO *, OPTID, int)
EnsureLoSidebagFloat(LO *, OPTID, float)
EnsureLoSidebagClq(LO *, OPTID, CLQ *)
EnsureLoSidebagLm(LO *, OPTID, LM *)
EnsureLoSidebagOid(LO *, OPTID, OID)
EnsureLoSidebagVector(LO *, OPTID, VECTOR *)
PchzFromLo(LO *)

D:\P2\light.c

0x001900e0

InitLight(LIGHT *)
UpdateLightXfWorldHierarchy(LIGHT *)
RemoveLightFromSw(LIGHT *)
AddLightToSw(LIGHT *)
OnLightAdd(LIGHT *)
OnLightRemove(LIGHT *)
CloneLight(LIGHT *, LIGHT *)
FitLinearFunction(float, float, float, float, float *, float *)
FitRecipFunction(float, float, float, float, float *, float *)
ConvertFallOff(LM *, float *, float *)
ConvertAngleStrength(float, float, float, float, float *, float *)
InvalidateLight(LIGHT *)
RebuildLightVifs(LIGHT *)
SetLightKind(LIGHT *, LIGHTK)
SetLightHighlightColor(LIGHT *, VECTOR *)
SetLightMidtoneStrength(LIGHT *, float)
SetLightShadowStrength(LIGHT *, float)
SetLightHighlightAngle(LIGHT *, float)
SetLightMidtoneAngle(LIGHT *, float)
SetLightShadowAngle(LIGHT *, float)
SetLightDirection(LIGHT *, VECTOR *)
SetLightDynamic(LIGHT *, int)
SetLightFallOff(LIGHT *, LM *)
SetLightConeAngle(LIGHT *, float)
SetLightHotSpotAngle(LIGHT *, float)
SetLightFrustrumUp(LIGHT *, VECTOR *)
RebuildLightFrustrum(LIGHT *)
UpdateLightBeamGrfzon(LIGHT *)
SetLightDiffuse_Old(LIGHT *, float)
GetLightDiffuse_Old(LIGHT *, float *)
SetLightSaturate_Old(LIGHT *, VECTOR *)
GetLightSaturate_Old(LIGHT *, VECTOR *)
GetLightParams(LIGHT *, SOP **)
NCmpFindLight(LIGHT **, LIGHT **)
PrepareSwLightsForDraw(SW *)
TwpsFindSwLightsNoVu0(SW *, VECTOR *, float, int, int, int *, int *, LIGHT **, char *)
TwpsFindSwLights(SW *, VECTOR *, float, int, int, int *, int *, LIGHT **, char *)

D:\P2\lookat.c

0x00191c50

InitActla(ACTLA *, ALO *)
SetActlaTarget(ACTLA *, ALO *, VECTOR *)
PaloGetActlaTarget(ACTLA *)
UpdateActla(ACTLA *, float)
GetActlaRotationGoal(ACTLA *, float, MATRIX3 *, VECTOR *)

D:\P2\main.c

0x00192030

StartupSif(void)
StartupVU0(void)
StartupVU1(void)
ExecuteReset(void *)
StartupReset(void)
ClearReset(void)
iCheckReset(void)
Startup(void)
Shutdown(void)

D:\P2\map2d.c

0x00192b90

PtriFindMap(MAP *, VECTOR *)
PvFromMapIpos(MAP *, int)
PvecFromMapIpos(MAP *, int)

D:\P2\mark.c

0x00192c80

ReportXPs(int)
MuFromAmtlk(MTLK *)
ElasFromAmtlk(MTLK *)
PxpAdd(SO *, SO *, VECTOR *, VECTOR *, float, XPK, void *, void *, XP **)
RecalcSwXpPos(SW *, int, XP **)
RecalcSwXpMovement(SW *, int, XP **)
FreeSwXpList(SW *, XP *)
FindClosestPointOnLine(VECTOR *, VECTOR *, VECTOR *, float *, float *)
FindClosestPointOnLineSegment(VECTOR *, VECTOR *, VECTOR *, float *, float *)
ClsgClipSoAllEdges(SO *, SO *, BSP *, int, LSG *)
ClsgClipSoBspEdges(SO *, SO *, int, BSP *, int, LSG *)
CategorizeAlsg(int, LSG *, int *, int *, LSG **, LSG **)
CplsgFindEdgePath(SURF *, int, int, LSG *, LSG **)
MarkSoContactsBspBsp(SO *, SO *, int, BSP *, BSP *, XP **)
CsbiIntersectSphereBsp(VECTOR *, float, int, BSP *, BSP *, GEOM *, int, SBI *)
MarkSoContactsSphereBsp(SO *, VECTOR *, float, SO *, int, BSP *, BSP *, XP **)
MarkSoContactsSphereSphere(SO *, SO *, XP **)
CalculateCenterContact(SO *, VECTOR *, float, VECTOR *, float *)
FMarkSoContactsCenterBsp(SO *, SO *, int, BSP *, BSP *, XP **)
FClipEdgeToSphere(VECTOR *, float, VECTOR *, VECTOR *, float *, VECTOR *, VECTOR *, float *)
FMarkSoContactsCenterSphere(SO *, SO *, XP **)
AddSoXps(SO *, SO *, int, int, BSP *, BSP *, XP **)
PxpMarkSwContactsRoot(SW *, SO **, int)

D:\P2\mat.c

0x001955a0

MATRIX4::PostCopyMatrix3(void)
MATRIX4::TEMPNAMEPLACEHOLDERVALUE(MATRIX3 const &)
MatMulMatTransMat(MATRIX3 const &, MATRIX3 const &)
LoadIdentityMatrix4(MATRIX4 *)
TEMPNAMEPLACEHOLDERVALUE(MATRIX4 const &, VU_FLOAT)
TEMPNAMEPLACEHOLDERVALUE(MATRIX4 const &, MATRIX4 const &)
MultiplyMatrix4Vector(MATRIX4 *, VECTOR *, float, VECTOR *)
TEMPNAMEPLACEHOLDERVALUE(MATRIX4 const &, VU_VECTOR4)
TransposeMatrix4(MATRIX4 *, MATRIX4 *)
AddMatrix4Matrix4(MATRIX4 *, MATRIX4 *, MATRIX4 *)
LoadRotateMatrixRad(float, VECTOR *, MATRIX3 *)
LoadRotateMatrix(VECTOR *, MATRIX3 *)
LoadRotateMatrixEuler(VECTOR *, MATRIX3 *)
LoadMatrixFromPosRot(VECTOR *, MATRIX3 *, MATRIX4 *)
LoadMatrixFromPosRotInverse(VECTOR *, MATRIX3 *, MATRIX4 *)
LoadMatrixFromPosRotScale(VECTOR *, MATRIX3 *, VECTOR *, MATRIX4 *)
CosRotateMatrixMagnitude(MATRIX3 *)
DecomposeRotateMatrixRad(MATRIX3 *, float *, VECTOR *)
DecomposeRotateMatrixEuler(MATRIX3 *, VECTOR *)
NormalizeRotateMatrix3(MATRIX3 *)
CalculateDmat(MATRIX3 *, MATRIX3 *, MATRIX3 *)
CalculateDmat4(MATRIX4 *, MATRIX4 *, MATRIX4 *)
DecomposeRotateMatrixPanTilt(MATRIX3 *, float *, float *)
LoadRotateMatrixPanTilt(float, float, MATRIX3 *)
LoadLookAtMatrix(VECTOR *, MATRIX3 *)
TiltMatUpright(MATRIX3 *, MATRIX3 *, MATRIX3 *)
LoadSquishStretchMatrix(VECTOR *, float, float, MATRIX3 *)
FInvertMatrix(int, float *, float *)
FInvertMatrix3(MATRIX3 *, MATRIX3 *)
FInvertMatrix4(MATRIX4 *, MATRIX4 *)
BuildOrthonormalMatrixY(VECTOR *, VECTOR *, MATRIX3 *)
BuildOrthonormalMatrixZ(VECTOR *, VECTOR *, MATRIX3 *)
BuildRotateVectorsMatrix(VECTOR *, VECTOR *, MATRIX3 *)
BuildSimpleProjectionMatrix(float, float, float, float, float, float, MATRIX4 *)
LoadScaleMatrixScalar(VECTOR *, float, MATRIX4 *)
LoadScaleMatrixVector(VECTOR *, MATRIX3 *, VECTOR *, MATRIX4 *)
LoadRotateVectorMatrix(VECTOR *, VECTOR *, MATRIX3 *)

D:\P2\mecha.c

0x00197848

InitMecha(MECHA *)
PostMechaLoad(MECHA *)
PresetMechaAccel(MECHA *, float)
UpdateMecha(MECHA *, float)
UpdateMechaActive(MECHA *, JOY *, float)
RenderMechaSelf(MECHA *, CM *, RO *)
HandleMechaMessage(MECHA *, MSGID, void *)
PsoGetMechaEffect(MECHA *, int *)
UpdateMechaEffect(MECHA *)
AddMechaCustomXps(MECHA *, SO *, int, BSP *, BSP *, XP **)
ChooseStepAttackTarget(STEP *, int, VECTOR *, float, float, TARGET **, VECTOR *)
SetMechaMechas(MECHA *, MECHAS)

D:\P2\mb.c

0x00198c78

InitMbg(MBG *)
LoadMbgFromBrx(MBG *, CBinaryInputStream *)
PostMbgLoad(MBG *)
PsoHitTestCylinderObjects(int, VECTOR *, VECTOR *, float, int, SO **, LSG *)
FFilterMbgAttackObjects(MBG *, SO *)
FObstructedMbg(MBG *, VECTOR *, VECTOR *)
FIgnoreMbgIntersection(MBG *, SO *)
FCanMbgAttack(MBG *)
FDetectMbg(MBG *)
OnMbgEnteringSgs(MBG *, SGS, ASEG *)
UpdateMbgGoal(MBG *, int)
UpdateMbgSgs(MBG *)
OnMbgExitingSgs(MBG *, SGS)
HandleMbgMessage(MBG *, MSGID, void *)
SetMbgMbsk(MBG *, MBSK)
InitScentmap(SCENTMAP *)
LookupScentmap(SCENTMAP *, VECTOR *, int *, int *)
PostScentmapLoad(SCENTMAP *)
PscpFindScentmap(SCENTMAP *, VECTOR *, float, SCFK)
UpdateScentmap(SCENTMAP *, float)
InitBhg(BHG *)
PostBhgLoad(BHG *)
SgsNextBhgAI(BHG *)
OnBhgEnteringSgs(BHG *, SGS, ASEG *)
UpdateBhgSgs(BHG *)

D:\P2\memcard.c

0x00199ec8

StartupMemcard(void)

D:\P2\memory.c

0x00199ed0

StartupMemMgr(void)
PvAllocGlobalImpl(int)
HardLockError(RGBA)
CheckForOutOfMemory(int)
PvAllocSwImpl(int)
FreeSw(void)
PvAllocSwCopyImpl(int, void *)
PvAllocSwClearImpl(int)
InitStackImpl(void)
PvAllocStackImpl(int)
PvAllocStackClearImpl(int)
FreeStackImpl(void)
CopyAqw(void *, void *, int)
CopyAb(void *, void *, unsigned int)

D:\P2\menu.c

0x0019a610

PushMenu(BLOT *, MI *, int, int, int, char *, int, int)
PopMenu(void)
SetCurMenu(BLOT *, MI *, int, int, int, char *, int, int)
ToggleBool(int)
DrawDebugmenu(DEBUGMENU *)
SetMainMenu(BLOT *)
DismissDebugmenu(DEBUGMENU *)
UpdateDebugmenuActive(DEBUGMENU *, JOY *)
OnDebugmenuActive(DEBUGMENU *, int)
OnDebugmenuReset(DEBUGMENU *)
ShowBrxWorlds(int)
SetMusic(int)
SgnCompareMiName(MI *, MI *)
ShowMusic(int)
ShowWarpPositions(int)
TeleportPlayerGSwnd(int)
FAddClassObjectMenuItem(LO *, MI *)
PmiClassObjects(int, MI *)
RemoveClassObjects(int)
ShowClassObjects(int)
NoParams(int)
ShowParams(int)
RecalcMenu(void)
ToggleRumbleEnabled(int)
CkeyGetCkeyMaxGameworld(int, WLP *, GAMEWORLD)
RefreshGwkmlText(GWKML *)
ShowKeys(int)
ShowLevelKeys(int)
CollectWorldKeys(int, int)
ToggleCollectKey(int)
EnsureCurrentKey(GAMEWORLD, WORLDLEVEL)
VisitAllWorlds(int)
CSpliceVarAccessor::CSpliceVarAccessor(void)
CSpliceVarAccessor::~CSpliceVarAccessor(void)
CSpliceVarAccessor::Init(LO *, OPID, LM *, OPIDCT *, int, CSpliceVarAccessor *, int, float, void *)
CSpliceVarAccessor::Retrieve(void)
CSpliceVarAccessor::Draw(CFont *, CTextBox *)
CSpliceVarAccessor::Commit(void)
CSpliceVarAccessor::Rollback(void)
CSpliceVarAccessor::Reset(void)
CSpliceVarAccessor::Adjust(ADJM, float)
CSpliceVarAccessor::FHasChanged(void)
CSpliceVarAccessor::FLiveEditable(void)
CSpliceVarAccessor::PvVarOwner(void)
CSpliceVarAccessor::OnPopMenu(void)
CSpliceVarAccessor::GGetRef(CRef *)
CSpliceVarAccessor::GGet(void)
CSpliceVarAccessor::SetGRef(float, CRef *)
CSpliceVarAccessor::SetG(float)
CSpliceVarAccessor::GConstrain(float)
CSpliceVarAccessor::IComponent(void)

D:\P2\missile.c

0x0019e7f8

InitMissile(MISSILE *)
LoadMissileFromBrx(MISSILE *, CBinaryInputStream *)
OnMissileRemove(MISSILE *)
ProjectMissileTransform(MISSILE *, float, int)
FireMissile(MISSILE *, ALO *, VECTOR *)
RenderMissileAll(MISSILE *, CM *, RO *)
InitAccmiss(ACCMISS *)
FireAccmiss(ACCMISS *, ALO *, VECTOR *)
PresetAccmissAccel(ACCMISS *, float)
InitTarmiss(TARMISS *)
UpdateTarmiss(TARMISS *, float)
FireSplmiss(SPLMISS *, ALO *, VECTOR *)
ProjectSplmissTransform(SPLMISS *, float, int)
InitGroundmiss(GROUNDMISS *)
PresetGroundmissAccel(GROUNDMISS *, float)

D:\P2\mouthgame.c

0x0019f778

InitMgv(MGV *)
LoadMgvFromBrx(MGV *, CBinaryInputStream *)
OidTmblGoal(int, int)
PostMgvLoad(MGV *)
UpdateMgvActive(MGV *, JOY *, float)
HandleMgvMessage(MGV *, MSGID, void *)
DamageMgv(MGV *)
ScoreMgv(MGV *)
InitMgc(MGC *)
LoadMgcFromBrx(MGC *, CBinaryInputStream *)
PostMgcLoad(MGC *)
UpdateMgc(MGC *, float)
GenerateMgc(MGC *, ALO *, int, float)
HandleMgcMessage(MGC *, MSGID, void *)
ClearMgc(MGC *)

D:\P2\mpeg.c

0x001a0210

CQueueOutputIop::Init(int, int)
CQueueOutputIop::Reset(void)
CQueueOutputIop::CbWrite(int, void *)
CQueueOutputIop::CbSend(int, void *)
CQueueOutputIop::Update(void)
CQueueOutputIop::FAsyncDrain(void)
CQueueOutputIpu::CbWrite(int, void *)
CQueueOutputIpu::FAsyncDrain(void)
CMpegAudio::Init(void)
CMpegAudio::Reset(void)
CMpegAudio::Close(void)
CMpegAudio::FAccept(int, unsigned char *)
CMpegAudio::Update(void)
FMpegAcceptVideo(sceMpeg *, sceMpegCbDataStr *, CMpeg *)
FMpegAcceptAudio(sceMpeg *, sceMpegCbDataStr *, CMpeg *)
FMpegDecodeVideo(sceMpeg *, sceMpegCbData *, CMpeg *)
FMpegDecoderIdle(sceMpeg *, sceMpegCbData *, CMpeg *)
FMpegDecoderError(sceMpeg *, sceMpegCbData *, CMpeg *)
BuildMpegGifs(QW *, sceIpuRGB32 *, int, int, int, int, int)
CMpeg::Set(char *)
CMpeg::Execute(void)
CMpeg::Start(CBinaryAsyncStream *)
CMpeg::Update(void)
CMpeg::Finish(void)
CMpeg::CbDemuxed(int)
PlayMovie(int)

D:\P2\mrkv.c

0x001a1840

InitMrkv(MRKV *)

D:\P2\ms.c

0x001a18a0

RenderMsGlobset(MS *, CM *, RO *)

D:\P2\murray.c

0x001a1e08

InitMurray(MURRAY *)
PostMurrayLoad(MURRAY *)
OnMurrayEnteringSgs(MURRAY *, SGS, ASEG *)
OnMurrayExitingSgs(MURRAY *, SGS)
UpdateMurrayGoal(MURRAY *, int)
UpdateMurraySgs(MURRAY *)
FAbsorbMurrayWkr(MURRAY *, WKR *)
FDetectMurray(MURRAY *)
FCanMurrayAttack(MURRAY *)
AddMurrayEnemy(MURRAY *, ALO *)
SetMurrayPursueXfm(MURRAY *, XFM *)
SetMurrayPatrolXfm(MURRAY *, XFM *)
CollectMurrayPrize(MURRAY *, PCK, ALO *)

D:\P2\path.c

0x001a2418

PcbspExtract(CBSP *)
PcgtExtract(CGT *)
PcgtPointInCbspQuick(CBSP *, VECTOR *)
PcgtPointInCbspSafe(CBSP *, VECTOR *)
CbskFromG(float)
ClsgClipEdgeToCbsp(CBSP *, VECTOR *, VECTOR *, int, LSG *)
FClipEdgeToCbsp(CBSP *, VECTOR *, VECTOR *)
IcgvFromPcgv(CG *, CGV *)
FindPathAStar(CG *, CGV *, CGV *, int, int *, CGV **)
SimplifyApcgvNeighbor(CBSP *, int *, CGV **)
CposFindPath(CG *, VECTOR *, VECTOR *, int, VECTOR *)
FindClosestPointInCg(CG *, VECTOR *, VECTOR *)
LoadPathzoneFromBrx(PATHZONE *, CBinaryInputStream *)
HookupCg(CG *)
CposFindPathzonePath(PATHZONE *, VECTOR *, VECTOR *, int, VECTOR *)
FindPathzoneClosestPoint(PATHZONE *, VECTOR *, VECTOR *)
ChoosePathzoneRandomPoint(PATHZONE *, VECTOR *)
OnPathzoneAdd(PATHZONE *)
OnPathzoneRemove(PATHZONE *)
ClonePathzone(PATHZONE *, PATHZONE *)
RenderPathzone(PATHZONE *, CM *)

D:\P2\phasemem.c

0x001a3dd8

SetPhase(PHASE)
ClearPhase(PHASE)

D:\P2\pipe.c

0x001a3e30

StartupPipe(void)
ResetPipeList(void)
InitPipe(PIPE *)
OnPipeAdd(PIPE *)
OnPipeRemove(PIPE *)
ClonePipe(PIPE *, PIPE *)
SetPipeCameraOffset(PIPE *, float, float)

D:\P2\pnt.c

0x001a3fc8

LoadPntFromBrx(PNT *, CBinaryInputStream *)
GetPntPos(PNT *, VECTOR *)
SetPntParent(PNT *, ALO *)
ApplyPntProxy(PNT *, PROXY *)

D:\P2\po.c

0x001a40e0

InitPo(PO *)
ClonePo(PO *, PO *)
HandlePoMessage(PO *, MSGID, void *)
OnPoActive(PO *, int, PO *)
GetPoCpdefi(PO *, float, CPDEFI *)
FIsPoSoundBase(PO *)
MakePoActive(PO *)
FInvulnerablePo(PO *, ZPK)
FTakePoDamage(PO *, ZPR *)
JthsCurrentPo(PO *)
CollectPoPrize(PO *, PCK, ALO *)
PpoCur(void)
PpoStart(void)
_IppoFindPo(PO *)
AddPoToList(PO *)
RemovePoFromList(PO *)
OnPoAdd(PO *)
OnPoRemove(PO *)
SwitchToIppo(int)
SetPoPlayable(PO *, int)
SwitchToPo(PO *)
PpziCur(void)
GetPoDiapi(PO *, DIALOG *, DIAPI *)
PlayPoDialog(PO *, DIALOG *)
UpdatePo(PO *, float)
UsePoCharm(PO *)

D:\P2\prog.c

0x001a4c10

CProg::CProg(RGBA, RGBA, RGBA, RGBA)
CProg::Begin(void)
CProg::SetRemain(int)
CProg::End(void)
CProg::Draw(void)

D:\P2\prompt.c

0x001a5028

AchzFromRespk(RESPK)
PostPromptLoad(PROMPT *)
OnPromptActive(PROMPT *, int)
UpdatePromptActive(PROMPT *, JOY *)
SetPrompt(PROMPT *, PRP, PRK)
SetPromptBlots(PROMPT *, BLOTS)
DrawPrompt(PROMPT *)
SetPromptPrk(PROMPT *, PRK)
ExecutePrompt(PROMPT *)
CancelPrompt(PROMPT *)

D:\P2\proxy.c

0x001a6758

InitProxy(PROXY *)
LoadProxyFromBrx(PROXY *, CBinaryInputStream *)
CloneProxy(PROXY *, PROXY *)
PostProxyLoad(PROXY *)

D:\P2\puffer.c

0x001a6da8

InitPuffer(PUFFER *)
LoadPufferFromBrx(PUFFER *, CBinaryInputStream *)
PostPufferLoad(PUFFER *)
PresetPufferAccel(PUFFER *, float)
FFilterPuffer(PUFFER *, SO *)
UpdatePuffer(PUFFER *, float)
PpufftChoosePuffer(PUFFER *)
OnPufferActive(PUFFER *, int, PO *)
UpdatePufferActive(PUFFER *, JOY *, float)
AdjustPufferNewXp(PUFFER *, XP *, int)
AddPufferWaterAcceleration(PUFFER *, WATER *, float)
HandlePufferMessage(PUFFER *, MSGID, void *)
PostPuffcLoad(PUFFC *)
PresetPuffcAccel(PUFFC *, float)
FDetectPuffc(PUFFC *)
UpdatePuffcGoal(PUFFC *, int)
OnPuffcExitingSgs(PUFFC *, SGS)
OnPuffcEnteringSgs(PUFFC *, SGS, ASEG *)
UpdatePuffcSgs(PUFFC *)
HandlePuffcMessage(PUFFC *, MSGID, void *)
UpdatePuffc(PUFFC *, float)
FCanPuffcAttack(PUFFC *)
PostPuffbLoad(PUFFB *)
UpdatePuffb(PUFFB *, float)
PpuffvChoosePuffb(PUFFB *, PUFFC *)
LandPuffb(PUFFB *, PUFFC *)
JumpPuffb(PUFFB *, PUFFC *)
DiePuffb(PUFFB *, PUFFC *)
IppathzoneFindPuffb(PUFFB *, PATHZONE *)
PostPufftLoad(PUFFT *)
InitPuffv(PUFFV *)
AddPuffvOidLand(PUFFV *, OID)
PostPuffvLoad(PUFFV *)

D:\P2\pzo.c

0x001a9250

InitSprize(SPRIZE *)
LoadSprizeFromBrx(SPRIZE *, CBinaryInputStream *)
BindSprize(SPRIZE *)
PostSprizeLoad(SPRIZE *)
UpdateSprize(SPRIZE *, float)
CollectSprize(SPRIZE *)
EmitSprizeExplosion(SPRIZE *)
PcsFromSprize(SPRIZE *)
AddSprizeAseg(SPRIZE *, OID)
HandleSprizeMessage(SPRIZE *, MSGID, void *)
FIgnoreSprizeIntersection(SPRIZE *, SO *)
InitScprize(SCPRIZE *)
CloneScprize(SCPRIZE *, SCPRIZE *)
PcsFromScprize(SCPRIZE *)
CollectScprize(SCPRIZE *)
CollectLifetkn(LIFETKN *)
LoadLockFromBrx(LOCK *, CBinaryInputStream *)
PostLockLoad(LOCK *)
LoadLockgFromBrx(LOCKG *, CBinaryInputStream *)
PostLockgLoad(LOCKG *)
SetLockgIndex(LOCKG *, int)
AddLockgLock(LOCKG *, OID)
TriggerLockg(LOCKG *)
InitClue(CLUE *)
LoadClueFromBrx(CLUE *, CBinaryInputStream *)
CloneClue(CLUE *, CLUE *)
PostClueLoad(CLUE *)
OnClueSmack(CLUE *)
CollectClue(CLUE *)
BreakClue(CLUE *)
CollectClueSilent(CLUE *)
ImpactClue(CLUE *, int)
FAbsorbClueWkr(CLUE *, WKR *)
RenderClueAll(CLUE *, CM *, RO *)
CollectAllClues(int)
SetGrfvault(int)
OpenVaultCheat(int)
ToggleGrfvault(int)
InitVault(VAULT *)
PostTmblLoad(TMBL *, OID)
PostVaultLoad(VAULT *)
OnVaultActive(VAULT *, int, PO *)
UpdateVaultActive(VAULT *, JOY *, float)
HandleVaultMessage(VAULT *, MSGID, void *)
AddVaultGoadDialog(VAULT *, GOADK, OID)
OpenVault(VAULT *)

D:\P2\rail.c

0x001ab6e8

OnRailAdd(RAIL *)
OnRailRemove(RAIL *)
CloneRail(RAIL *, RAIL *)

D:\P2\rat.c

0x001ab7c8

InitRat(RAT *)
LoadRatFromBrx(RAT *, CBinaryInputStream *)
PostRatLoad(RAT *)
OnRatAdd(RAT *)
OnRatRemove(RAT *)
CloneRat(RAT *, RAT *)
PresetRatAccel(RAT *, float)
UpdateRat(RAT *, float)
AdjustRatNewXp(RAT *, XP *, int)
AdjustRatXpVelocity(RAT *, XP *, int)
RenderRatAll(RAT *, CM *, RO *)
FAbsorbRatWkr(RAT *, WKR *)
ChooseRatFleeTarget(RAT *)
HideRat(RAT *, int)
SetRatRats(RAT *, RATS)
GetRatParams(RAT *, SOP **)
OnRatholeAdd(RATHOLE *)
OnRatholeRemove(RATHOLE *)

D:\P2\rchm.c

0x001ace60

InitRchm(RCHM *)
LoadRchmFromBrx(RCHM *, CBinaryInputStream *)
PostRchmLoad(RCHM *)
ReblendRchm(RCHM *, TWR *, VECTOR *)
BuildRchmCoefficients(RCHM *, float, float, float, float *)
ConvertRchmIposToRclIoLhub(RCHM *, int, float *, float *, float *)
IposConvertRchmRclIoLhub(RCHM *, int, int, int)
SetRchmNaturalCoefficients(RCHM *, float, float, float)
SetRchmCenterCoefficients(RCHM *, float, float, float)
RenderRchmGrid(RCHM *, CM *)
PredictRchmTargetPos(RCHM *, TARGET *, float, VECTOR *)
PredictRchmTargetLocalPos(RCHM *, TARGET *, float, VECTOR *)
PtwrMapRchmSafe(RCHM *, BSP *, VECTOR *)
FindRchmClosestPoint(RCHM *, VECTOR *, VECTOR *, TWR **, float *)
FChooseJtReachTarget(JT *, LO *, int)
TrackJtTarget(JT *, RCHM *, TARGET *)
TrackJtPipe(JT *, RCHM *, PIPE *, float *)

D:\P2\render.c

0x001ae908

SubmitRpl(RPL *)
NCmpPrplReverseZ(RPL **, RPL **)
CprplPartitionArpl(int, RPL *, RPL **)
RenderSw(SW *, CM *)
EnsureRenderGlobals(void)
EnsureCameraGlobals(void)
EnsureScreenCleared(void)
SetupRpDynamicTexture(RPL *)
SetupRpBackground(RPL *)
SetupRpBlotContext(RPL *)
SetupRpGlob(RPL *)
SetupRpBlip(RPL *)
SetupRpWorldMap(RPL *)
DrawSw(SW *, CM *)
FillScreenRect(int, int, int, int, float, float, float, float, GIFS *)
StartupRender(void)

D:\P2\rip.c

0x001af898

PripgNew(SW *, RIPGT)
InitRipg(RIPG *)
SetRipgEmitb(RIPG *, EMITB *)
OnRipgRemove(RIPG *)
ProjectRipgTransform(RIPG *, float, int)
UpdateRipgBounds(RIPG *)
UpdateRipg(RIPG *, float)
BounceRipgRips(RIPG *)
RenderRipgSelf(RIPG *, CM *, RO *)
PvtripFromRipt(RIPT)
PripNewRipg(RIPT, RIPG *)
InitRip(RIP *, VECTOR *, float, SO *)
RemoveRip(RIP *)
AddRipRef(RIP *)
ReleaseRip(RIP *)
TouchRip(RIP *, int)
ForceRipFade(RIP *, float)
FBounceRip(RIP *, SO *, VECTOR *, VECTOR *)
ProjectRipTransform(RIP *, float)
UpdateRip(RIP *, float)
FRenderRipPosMat(RIP *, CM *, VECTOR *, MATRIX3 *)
RenderRip(RIP *, CM *)
SubscribeRipObject(RIP *, LO *)
SubscribeRipStruct(RIP *, void (*)(void *, MSGID, void *), void *)
UnsubscribeRipStruct(RIP *, void (*)(void *, MSGID, void *), void *)
InitDroplet(DROPLET *, VECTOR *, float, SO *)
TouchDroplet(DROPLET *, int)
InitBublet(BUBLET *, VECTOR *, float, SO *)
ProjectBubletTransform(BUBLET *, float)
TouchBublet(BUBLET *, int)
InitRipple(RIPPLE *, VECTOR *, float, SO *)
InitPuff(PUFF *, VECTOR *, float, SO *)
InitDablet(DABLET *, VECTOR *, float, SO *)
InitFlake(FLAKE *, VECTOR *, float, SO *)
UpdateFlake(FLAKE *, float)
RenderFlake(FLAKE *, CM *)
TouchFlake(FLAKE *, int)
InitSpark(SPARK *, VECTOR *, float, SO *)
RenderSpark(SPARK *, CM *)
InitBurst(BURST *, VECTOR *, float, SO *)
InitTrail(TRAIL *, VECTOR *, float, SO *)
OnTrailRemove(TRAIL *)
SetTrailTrls(TRAIL *, TRLS, void *)
DetachTrail(TRAIL *)
ProjectTrailTransform(TRAIL *, float)
RenderTrail(TRAIL *, CM *)
HandleTrailMessage(TRAIL *, MSGID, void *)
InitFireball(FIREBALL *, VECTOR *, float, SO *)
UpdateFireball(FIREBALL *, float)
InitSmokecloud(SMOKECLOUD *, VECTOR *, float, SO *)
InitSmoketrail(SMOKETRAIL *, VECTOR *, float, SO *)
InitDebris(DEBRIS *, VECTOR *, float, SO *)
InitSmack(SMACK *, VECTOR *, float, SO *)
ProjectSmackTransform(SMACK *, float)
RenderSmack(SMACK *, CM *)
UpdateSmack(SMACK *, float)
InitOrbit(ORBIT *, VECTOR *, float, SO *)
ProjectOrbitTransform(ORBIT *, float)
UpdateOrbit(ORBIT *, float)
RenderOrbit(ORBIT *, CM *)
InitRay(RAY *, VECTOR *, float, SO *)
InitRose(ROSE *, VECTOR *, float, SO *)
ProjectRoseTransform(ROSE *, float)
UpdateRose(ROSE *, float)
RenderRose(ROSE *, CM *)
SetRoseRoses(ROSE *, ROSES)
SgnCmpHp(void const *, void const *)
ChpBuildConvexHullScreen(VECTOR *, int, HP *)
ChpBuildConvexHullXY(MATRIX4 *, int, HP *)
PostFlyingEmit(FLYING *, EMITB *)
RenderFlying(FLYING *, CM *)
CreateStuck(RIP *, ALO *, SO *, VECTOR *, VECTOR *, STUCK **)
FBounceFlying(FLYING *, SO *, VECTOR *, VECTOR *)
UpdateStuck(STUCK *, float)
RenderStuck(STUCK *, CM *)
PostLeafEmit(LEAF *, EMITB *)
ProjectLeafTransform(LEAF *, float)
FBounceLeaf(LEAF *, SO *, VECTOR *, VECTOR *)
FFilterFlameObjects(void *, SO *)
PostFlameEmit(FLAME *, EMITB *)
PostBulletEmit(BULLET *, EMITB *)
RenderBullet(BULLET *, CM *)
FBounceBullet(BULLET *, SO *, VECTOR *, VECTOR *)
PostShrapnelEmit(SHRAPNEL *, EMITB *)
FBounceShrapnel(SHRAPNEL *, SO *, VECTOR *, VECTOR *)
RenderShrapnel(SHRAPNEL *, CM *)
InitGlint(GLINT *, VECTOR *, float, SO *)
RenderGlint(GLINT *, CM *)
InitMatch(MATCH *, VECTOR *, float, SO *)
LaunchMatch(MATCH *)
ProjectMatchTransform(MATCH *, float)
UpdateMatch(MATCH *, float)
RenderMatch(MATCH *, CM *)
PostRemitEmit(REMIT *, EMITB *)
UpdateRemit(REMIT *, float)

D:\P2\rog.c

0x001b59e8

InitRov(ROV *)
LoadRovFromBrx(ROV *, CBinaryInputStream *)
PostRovLoad(ROV *)
UpdateRovActive(ROV *, JOY *, float)
UpdateRov(ROV *, float)
ReadRovJoystick(ROV *, JOY *)
RovsNextRov(ROV *)
SetRovRovs(ROV *, ROVS)
RovtsNextRov(ROV *)
SetRovRovts(ROV *, ROVTS)
HandleRovMessage(ROV *, MSGID, void *)
PresetRovAccel(ROV *, float)
AdjustRovXpVelocity(ROV *, XP *, int)
AdjustRovNewXp(ROV *, XP *, int)
PropagateRovForce(ROV *, int, XP *, int, DZ *, FX *)
FIsRovSoundBase(ROV *)
GetRovParams(ROV *, SOP **)
InitRob(ROB *)
SetRobCollectible(ROB *, OID)
SetRobHarvester(ROB *, OID)
SetRobVehicle(ROB *, OID)
SetRobPrize(ROB *, OID)
AddRobSpawnTunnel(ROB *, OID)
RobkCur(void)
BindRob(ROB *)
PostRobLoad(ROB *)
UpdateRob(ROB *, float)
RobsNextRob(ROB *)
SetRobRobs(ROB *, ROBS)
AddRobRoc(ROB *)
AddRobRoh(ROB *)
AdjustRobDifficulty(ROB *, float)
DestroyedRobRoc(ROB *, ROC *)
SpawnedRobRoh(ROB *, ROH *)
GrabbedRobRoh(ROB *, ROH *)
DroppedRobRoh(ROB *, ROH *)
ReturnedRobRoh(ROB *, ROH *)
ExitedRobRoh(ROB *, ROH *)
KilledRobRoh(ROB *, ROH *)
FChooseRobRoc(ROB *, ROH *)
TakeRobRoc(ROB *, ROH *, ROC *)
FChooseRobRoh(ROB *, ROC *)
FChooseRobReturnPoint(ROB *, ROH *)
ChooseRobWanderLocation(ROB *, ROH *)
ProddCurRob(ROB *, ENSK)
GetRobParams(ROB *, SOP **)
InitRoh(ROH *)
LoadRohFromBrx(ROH *, CBinaryInputStream *)
CloneRoh(ROH *, ROH *)
PostRohLoad(ROH *)
UpdateRoh(ROH *, float)
MoveRohToTarget(ROH *, VECTOR *, int)
RohsNextRoh(ROH *)
SetRohRohs(ROH *, ROHS)
FAbsorbRohWkr(ROH *, WKR *)
ProcContactRoh(ROH *)
GetRohParams(ROH *, SOP **)
InitRoc(ROC *)
LoadRocFromBrx(ROC *, CBinaryInputStream *)
CloneRoc(ROC *, ROC *)
PostRocLoad(ROC *)
UpdateRoc(ROC *, float)
PresetRocAccel(ROC *, float)
AdjustRocNewXp(ROC *, XP *, int)
FAbsorbRocWkr(ROC *, WKR *)
RocsNextRoc(ROC *)
SetRocRocs(ROC *, ROCS)
GetRocParams(ROC *, SOP **)
InitRost(ROST *)
LoadRostFromBrx(ROST *, CBinaryInputStream *)
CloneRost(ROST *, ROST *)
PostRostLoad(ROST *)
UpdateRost(ROST *, float)
RostsNextRost(ROST *)
SetRostRosts(ROST *, ROSTS)
GetRostParams(ROST *, SOP **)
InitRop(ROP *)
LoadRopFromBrx(ROP *, CBinaryInputStream *)
PostRopLoad(ROP *)
UpdateRop(ROP *, float)
SetRopRops(ROP *, ROPS)
RopsNextRop(ROP *)

D:\P2\rope.c

0x001ba3c8

InitRope(ROPE *)
PostRopeLoad(ROPE *)
SMinimizeRope(MRX *, float)
DrawRope(RPL *)
RenderRopeAll(ROPE *, CM *, RO *)

D:\P2\rumble.c

0x001bac80

InitRumble(RUMBLE *, int, int)
UpdateRumble(RUMBLE *)
TriggerRumbleRumk(RUMBLE *, RUMK, float)
TriggerRumbleRumpat(RUMBLE *, RUMPAT *, float)
SetRumbleRums(RUMBLE *, RUMS)
StopRumbleActuators(RUMBLE *)

D:\P2\rwm.c

0x001bb008

InitRwm(RWM *)
AddRwmRwc(RWM *, OID, int, int, int)
InitRwmCallback(RWM *, MSGID, void *)
PostRwmLoad(RWM *)
PrwcFindRwm(RWM *, OID)
EnableRwmRwc(RWM *, OID)
DisableRwmRwc(RWM *, OID)
ResizeRwmRwc(RWM *, OID, int)
FIsRwmAmmo(RWM *, SO *)
FAvailableRwmAmmo(RWM *, SO *)
CycleRwmCache(RWM *)
ReloadRwm(RWM *)
FEnsureRwmLoaded(RWM *)
FFireRwm(RWM *, int)
ClearRwmFireInfo(RWM *)
ClearRwmTargetInfo(RWM *)
ClearRwmAimConstraints(RWM *)
GetRwfiPosMat(RWFI *, VECTOR *, MATRIX3 *)
GetRwtiPos(RWTI *, VECTOR *, VECTOR *)
GetRwacPan(RWAC *, float *)
GetRwacTilt(RWAC *, float *)

D:\P2\sampler.c

0x001bc620

StartupSampler(void)
CSampler::Startup(void)
CSampler::Update(void)
CSampler::OnMovieFinished(void)
CSampler::Shutdown(void)

D:\P2\sc.c

0x001bc978

SolveAloSpline(ALO *)

D:\P2\screen.c

0x001bd378

StartupScreen(void)
PostBlotsLoad(void)
UpdateBlots(void)
ForceHideBlots(void)
DrawBrightnessBar(void)
DrawPlayerSuck(void)
ResetBlots(void)
RenderBlots(void)
DrawBlots(void)
InitBlot(BLOT *, BLOTK)
PostBlotLoad(BLOT *)
UpdateBlot(BLOT *)
SetBlotAchzDraw(BLOT *, char *)
SetBlotFontScale(BLOT *, float)
DrawBlot(BLOT *)
DrawBlotRect(BLOT *, RGBA *)
DtAppearBlot(BLOT *)
DtVisibleBlot(BLOT *)
DtDisappearBlot(BLOT *)
SetBlotDtAppear(BLOT *, float)
SetBlotDtVisible(BLOT *, float)
SetBlotDtDisappear(BLOT *, float)
OnBlotReset(BLOT *)
ShowBlot(BLOT *)
HideBlot(BLOT *)
SetBlotBlots(BLOT *, BLOTS)
FIncludeBlotForPeg(BLOT *, BLOT *)
ResizeBlot(BLOT *, float, float)
RepositionBlot(BLOT *)
RepositionBlotDependents(BLOT *)
SetBlotClock(BLOT *, float *)
PostCtrLoad(CTR *)
UpdateCtr(CTR *)
DrawCtr(CTR *)
RebuildCtrAchzDraw(CTR *)
DtVisibleCtr(CTR *)
PostTimerLoad(TIMER *)
UpdateTimer(TIMER *)
DrawTimer(TIMER *)
SetTimer(TIMER *, float)
SetTimerSpeed(TIMER *, float)
SetTimerThreshold(TIMER *, float, unsigned int, void (*)(TIMER *, TIMERNOTK))
SetTimerExpire(TIMER *, float, void (*)(TIMER *, TIMERNOTK))
StartTimer(TIMER *)
StopTimer(TIMER *)
RebuildTimerAchzDraw(TIMER *, float)
SetTimerTimers(TIMER *, TIMERS)
DtVisibleTrunkctr(TRUNKCTR *)
DtVisibleCrusherctr(CRUSHERCTR *)
DtVisiblePuffchargectr(PUFFCHARGECTR *)
PostBossctrLoad(BOSSCTR *)
DrawBossctr(BOSSCTR *)
PostNoteLoad(NOTE *)
SetNoteAchzDraw(NOTE *, char *)
DrawNote(NOTE *)
PostTitleLoad(TITLE *)
SetTitleAchzDraw(TITLE *, char *)
SetTitleBlots(TITLE *, BLOTS)
FIncludeTitleForPeg(TITLE *, BLOT *)
DrawTitle(TITLE *)
PostTotalsLoad(TOTALS *)
FormatTotalsGrfls(TOTALS *, int)
SetTotalsGrfls(TOTALS *, int)
SetTotalsBlots(TOTALS *, BLOTS)
DrawTotals(TOTALS *)
PostCallLoad(CALL *)
DrawCall(CALL *)
ToggleLetterbox(int)
DrawLetterbox(LETTERBOX *)
PostScoresLoad(SCORES *)
UpdateScores(SCORES *)
DrawScores(SCORES *)
PostLogoLoad(LOGO *)
DrawLogo(LOGO *)
PostAttractLoad(ATTRACT *)
SetAttractAchzDraw(ATTRACT *, char *)
SetAttractBlots(ATTRACT *, BLOTS)
UpdateAttract(ATTRACT *)
DrawAttract(ATTRACT *)
DrawLineScreen(unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, RGBA, int)

D:\P2\sensor.c

0x001c1d20

InitSensor(SENSOR *)
GetSensorParams(SENSOR *, SOP **)
SetSensorAlarm(SENSOR *, ALARM *)
SetSensorSensors(SENSOR *, SENSORS)
FCheckSensorObject(SENSOR *, SO *)
FIgnoreSensorObject(SENSOR *, SO *)
FOnlySensorTriggerObject(SENSOR *, SO *)
PauseSensor(SENSOR *)
UpdateSensor(SENSOR *, float)
AddSensorTriggerObject(SENSOR *, OID)
AddSensorNoTriggerObject(SENSOR *, OID)
AddSensorTriggerClass(SENSOR *, CID)
AddSensorNoTriggerClass(SENSOR *, CID)
InitLasen(LASEN *)
LoadLasenFromBrx(LASEN *, CBinaryInputStream *)
BindLasen(LASEN *)
PostLasenLoad(LASEN *)
UpdateBusyLasenSenseTimes(void)
UpdateLasen(LASEN *, float)
FreezeLasen(LASEN *, int)
RenderLasenSelf(LASEN *, CM *, RO *)
GetLasenParams(LASEN *, SOP **)
FFilterLasen(void *, SO *)
SenseLasen(LASEN *, SENSORS *)
EnableLasen(LASEN *, SENSM)
DisableLasen(LASEN *)
OnLasenAlarmTriggered(LASEN *)
SetLasenSensors(LASEN *, SENSORS)
SCalcLasenShapeExtent(LASEN *, LBEAM *)
RetractLasen(LASEN *, float)
ExtendLasen(LASEN *, float)
InitCamsen(CAMSEN *)
PostCamsenLoad(CAMSEN *)
UpdateCamsen(CAMSEN *, float)
RenderCamsenSelf(CAMSEN *, CM *, RO *)
FIgnoreCamsenIntersection(CAMSEN *, SO *)
GetCamsenParams(CAMSEN *, SOP **)
FFilterCamsen(void *, SO *)
SenseCamsen(CAMSEN *, SENSORS *)
EnableCamsen(CAMSEN *, SENSM)
DisableCamsen(CAMSEN *)
OnCamsenAlarmTriggered(CAMSEN *)
SetCamsenSensors(CAMSEN *, SENSORS)
SetCamsenCsdts(CAMSEN *, CSDTS)
InitPrsen(PRSEN *)
PostPrsenLoad(PRSEN *)
UpdatePrsen(PRSEN *, float)
GetPrsenParams(PRSEN *, SOP **)
SensePrsen(PRSEN *, SENSORS *)
EnablePrsen(PRSEN *, SENSM)
DisablePrsen(PRSEN *)
OnPrsenAlarmTriggered(PRSEN *)
SetPrsenSensors(PRSEN *, SENSORS)
UpdatePrsenLoopShader(PRSEN *)

D:\P2\shadow.c

0x001c5020

InitShadow(SHADOW *)
PostShadowLoad(SHADOW *)
InvalidateShadowVifs(SHADOW *)
RebuildShadowRegion(SHADOW *)
SetShadowShader(SHADOW *, OID)
FShadowRadiusSet(SHADOW *)
SetShadowNearRadius(SHADOW *, float)
SetShadowFarRadius(SHADOW *, float)
SetShadowCastPosition(SHADOW *, VECTOR *)
SetShadowCastNormal(SHADOW *, VECTOR *)
SetShadowNearCast(SHADOW *, float)
SetShadowFarCast(SHADOW *, float)
SetShadowConeAngle(SHADOW *, float)
SetShadowFrustrumUp(SHADOW *, VECTOR *)
FShadowValid(SHADOW *, int)
FFilterFastShadows(void *, SO *)
UpdateShadow(SHADOW *, float)
RebuildShadowVifs(SHADOW *)
DrawShadow(SHADOW *)
FShadowIntersectsSphere(SHADOW *, VECTOR *, float)
FindSwShadows(SW *, VECTOR *, float, int, int *, SHADOW **)

D:\P2\shape.c

0x001c5f10

InitShape(SHAPE *)
RenderShape(SHAPE *, CM *)
LoadShapeFromBrx(SHAPE *, CBinaryInputStream *)
SetShapeParent(SHAPE *, ALO *)

D:\P2\shd.c

0x001c6198

Tex0FromTexIframeCtk(TEX *, int, CTK)
PackTexGifs(TEX *, int, CTK, SHDK, GIFS *)
LoadClutFromBrx(CBinaryInputStream *, CLUT *)
LoadColorTablesFromBrx(CBinaryInputStream *)
LoadBmpFromBrx(CBinaryInputStream *, BMP *)
LoadBitmapsFromBrx(CBinaryInputStream *)
LoadFontsFromBrx(CBinaryInputStream *)
LoadTexFromBrx(CBinaryInputStream *, TEX *)
LoadShadersFromBrx(CBinaryInputStream *)
UploadPermShaders(void)
PropagateShaders(int)
FillShaders(int)
UnloadShaders(void)
ConvertRgbToHsv(VECTOR *, VECTOR *)
ConvertHsvToRgb(VECTOR *, VECTOR *)
ConvertUserHsvToUserRgb(VECTOR *, VECTOR *)
ConvertUserRgbToUserHsv(VECTOR *, VECTOR *)
PshdFindShader(OID)
SetSaiIframe(SAI *, int)
SetSaiDuDv(SAI *, float, float)
PropagateSais(void)
UpdateShaders(float)

D:\P2\shdanim.c

0x001c85e8

CbFromSaak(SAAK)
PvtsaaFromSaak(SAAK)
PsaaLoadFromBrx(CBinaryInputStream *)
InitSaa(SAA *, SAAF *)
PostSaaLoad(SAA *)
FUpdatableSaa(SAA *)
UCompleteSaa(SAA *)
PsaiFromSaaShd(SAA *, SHD *)
InitLoop(LOOP *, SAAF *)
PostLoopLoad(LOOP *)
UpdateLoop(LOOP *, float)
UCompleteLoop(LOOP *)
InitPingpong(PINGPONG *, SAAF *)
PostPingpongLoad(PINGPONG *)
UpdatePingpong(PINGPONG *, float)
UCompletePingpong(PINGPONG *)
InitShuffle(SHUFFLE *, SAAF *)
UpdateShuffle(SHUFFLE *, float)
InitHologram(HOLOGRAM *, SAAF *)
PostHologramLoad(HOLOGRAM *)
NotifyHologramRender(HOLOGRAM *, ALO *, RPL *)
InitScroller(SCROLLER *, SAAF *)
UpdateScroller(SCROLLER *, float)
UCompleteScroller(SCROLLER *)
SetScrollerMasterSpeeds(SCROLLER *, float, float)
InitCircler(CIRCLER *, SAAF *)
UpdateCircler(CIRCLER *, float)
UCompleteCircler(CIRCLER *)
InitLooker(LOOKER *, SAAF *)
SetLookerSgvr(LOOKER *, SGVR *, GLOBSET *, GLOB *, SUBGLOB *)
SetVecPosad(VECTOR *, POSAD *)
SetUvPuvqd(UVF *, UVQ *)
NotifyLookerRender(LOOKER *, ALO *, RPL *)

D:\P2\sky.c

0x001c9990

PostSkyLoad(SKY *)
UpdateSky(SKY *, float)

D:\P2\slotheap.c

0x001c9a30

_InitSlotheap(SLOTHEAP *, int, int)
CreateSlotheapSw(SLOTHEAP *, int, int)
CreateSlotheapSwAlign64(SLOTHEAP *, int, int)
PvAllocSlotheapUnsafe(SLOTHEAP *)
PvAllocSlotheapImpl(SLOTHEAP *)
PvAllocSlotheapClearImpl(SLOTHEAP *)
FreeSlotheapPv(SLOTHEAP *, void *)

D:\P2\sm.c

0x001c9c50

LoadSmFromBrx(SM *, CBinaryInputStream *)
PostSmLoad(SM *)
PostSmLoadCallback(SM *, MSGID, void *)
PsmaApplySm(SM *, ALO *, OID, int)
PsmaFindSm(SM *, ALO *)
IsmsFindSmOptional(SM *, OID)
IsmsFindSmRequired(SM *, OID)
OidFromSmIsms(SM *, int)
RetractSma(SMA *)
SetSmaGoal(SMA *, OID)
GetSmaGoal(SMA *, OID *)
GetSmaCur(SMA *, OID *)
GetSmaNext(SMA *, OID *)
SetSmaSvt(SMA *, float)
SeekSma(SMA *, OID)
ChooseSmaTransition(SMA *)
EndSmaTransition(SMA *)
HandleSmaMessage(SMA *, MSGID, void *)
SkipSma(SMA *, float)
SendSmaMessage(SMA *, MSGID, void *)
NotifySmaSpliceOnEnterState(SMA *, int, int)

D:\P2\smartguard.c

0x001cada0

InitSmartguard(SMARTGUARD *)
PostSmartguardLoadFlashlight(SMARTGUARD *)
UseSmartguardFlashlightTarget(SMARTGUARD *, SGS, OID)
PostSmartguardLoad(SMARTGUARD *)
FFilterSmartguardDetect(SMARTGUARD *, SO *)
FDetectSmartguard(SMARTGUARD *)
UpdateSmartguard(SMARTGUARD *, float)
UpdateSmartguardFlashlight(SMARTGUARD *)
OnSmartguardEnteringSgs(SMARTGUARD *, SGS, ASEG *)
FCanSmartguardAttack(SMARTGUARD *)
SgasGetSmartguard(SMARTGUARD *)
HandleSmartguardMessage(SMARTGUARD *, MSGID, void *)
FreezeSmartguard(SMARTGUARD *, int)

D:\P2\so.c

0x001cb970

InitSo(SO *)
OnSoAdd(SO *)
OnSoRemove(SO *)
EnableSoPhys(SO *, int)
GetSoParams(SO *, SOP **)
DisplaceSo(SO *, int)
ImpactSo(SO *, int)
PivotSo(SO *, int)
ExtendSoBounds(SO *, VECTOR *, float)
UpdateSoBounds(SO *)
UpdateGeomWorld(GEOM *, GEOM *, VU_VECTOR, MATRIX3 *)
UpdateSoXfWorldHierarchy(SO *)
UpdateSoXfWorld(SO *)
FIgnoreSoIntersection(SO *, SO *)
UpdateSoImpacts(SO *)
UProjectVector(VECTOR *, VECTOR *, VECTOR *)
AdjustSoXpLocal(SO *, XP *, int)
CalculateSoAngularEffectWorld(SO *, VECTOR *, VECTOR *)
AccelSoTowardPosSpring(SO *, VECTOR *, CLQ *, VECTOR *, CLQ *, float)
AccelSoTowardMatSpring(SO *, MATRIX3 *, CLQ *, VECTOR *, CLQ *, float)
PresetSoAccel(SO *, float)
DrawGeom(GEOM *, CM *, RGBA)
RenderSoSelf(SO *, CM *, RO *)
UpdateSo(SO *, float)
SetSoMass(SO *, float)
AdjustSoMomint(SO *, float)
DiscardSoXps(SO *)
UpdateSoPosWorldPrev(SO *)
TranslateSoToPos(SO *, VECTOR *)
RotateSoToMat(SO *, MATRIX3 *)
TranslateSoToPosSafe(SO *, VECTOR *, VECTOR *)
SetSoVelocityVec(SO *, VECTOR *)
SetSoAngularVelocityVec(SO *, VECTOR *)
AddSoAcceleration(SO *, VECTOR *)
AddSoAngularAcceleration(SO *, VECTOR *)
SetSoConstraints(SO *, CT, VECTOR *, CT, VECTOR *)
SetSoParent(SO *, ALO *)
ApplySoProxy(SO *, PROXY *)
AccelSoTowardMatSmooth(SO *, float, MATRIX3 *, SMP *)
GetSoCpdefi(SO *, float, CPDEFI *)
FIsSoTouching(SO *, SO *)
PsoFirstSoTouching(SO *)
CloneSo(SO *, SO *)
ApplySoConstraintWorld(SO *, CONSTR *, VECTOR *, VECTOR *, VECTOR *)
ApplyConstr(CONSTR *, VECTOR *, VECTOR *, VECTOR *)
ApplySoConstraintLocal(SO *, CONSTR *, VECTOR *, VECTOR *, VECTOR *)
AddSoXa(SO *, XA *)
RemoveSoXa(SO *, XA *)
AddSoWaterAcceleration(SO *, WATER *, float)
AddSoExternalAccelerations(SO *, XA *, float)
LoadSoFromBrx(SO *, CBinaryInputStream *)
SetSoSphere(SO *, float)
SetSoNoInteract(SO *, int)
ConstrFromCnstr(CNSTR, CT *, VECTOR *)
SetSoCnstrForce(SO *, CNSTR)
SetSoCnstrTorque(SO *, CNSTR)
SetSoCameraStyle(SO *, CMK)
SetSoIgnoreLocked(SO *, int)
SetSoIceable(SO *, int)
SetSoMtlk(SO *, MTLK)
SetSoEdgeGrab(SO *, EGK)
SendSoMessage(SO *, MSGID, void *)
PxpFindSoGround(SO *, SO *, int *)
SetSoNoGravity(SO *, int)
SetSoNoXpsAll(SO *, int)
SetSoNoXpsSelf(SO *, int)
SetSoNoXpsCenter(SO *, int)
RebuildSoPhysHook(SO *)
PsoFindSoPhysHook(SO *, int)
RecalcSoLocked(SO *)
FGetSoContactList(SO *, void *)
GetSoContacts(SO *, int *, SO ***)
FSoInStsoList(STSO *, SO *)
GenerateSoSpliceTouchingEvents(SO *)
FInflictSoZap(SO *, XP *, ZPR *)
EnsureSoLvo(SO *)
ProjectSoLvo(SO *, float)
ProjectSoTransform(SO *, float, int)
ApplySoImpulse(SO *, VECTOR *, VECTOR *, float)
CalculateSoTrajectoryApex(SO *, VECTOR *, float, VECTOR *)
FAbsorbSoWkr(SO *, WKR *)
CloneSoPhys(SO *, SO *, int)

D:\P2\solve.c

0x001d0b00

RenumberSo(SO *, int *, SO **)
CalculateSoEffect(SO *, VECTOR *, FX *, VECTOR *)
PropagateSoForce(SO *, int, XP *, int, DZ *, FX *)
DistributeSoEffects(SO *, int, int, SO **, FX *)
SolveSwGroup(SW *, int, SO **, int, XP **, float, int)
CpxpBuildXpArray(int, SO **, int, XP **)
BuildContactGroup(SO *, int *, SO **, int *, SO **)
SplitSoFreeze(SO *, int)
SortSwGroup(int, SO **)
SplitSwGroup(SW *, int, SO **, float, int)
SolveSw(SW *, float, int)

D:\P2\sort.c

0x001d2588

SwapEntries(void *, int, int, int)
HeapSort(void *, int, int, int (*)(void *, void *))

D:\P2\sound.c

0x001d2718

UnloadMusic(void)
SbpEnsureBank(int)
SbpEnsureBank(SFXID)
NewSfx(SFX **)
FContinuousSound(SFXID)
SetVagUnpaused(unsigned int, unsigned long)
PreloadVag(char *, FK)
FPauseForVag(void)
FVagPlaying(void)
StopVag(void)
PauseVag(void)
ContinueVag(void)
KillMusic(void)
PreloadMusidSongComplete(unsigned int, unsigned long)
PreloadMusidSong(MUSID)
StartMusidSong(MUSID)
PauseMusic(void)
ContinueMusic(void)
PexcAlloc(void)
RemoveExc(EXC *)
KillExcitement(void)
PexcSetExcitement(int)
SetIexcCurHigh(EXC *)
FBlockHyst(void)
UnsetExcitement(EXC *)
UnsetExcitementHyst(EXC *)
StartupSound(void)
FAmbientsPaused(void)
CalculateVolPan(float, VECTOR *, float *, float *, float, float, float)
SDistEarZoom(VECTOR *, VECTOR *)
SDistEarNormal(VECTOR *, VECTOR *)
PposEar(void)
SetDoppler(AMB *)
PfneardistGet(void)
SDistEar(VECTOR *)
CalculateDistVolPan(VECTOR *, float *, float *, float, float, float)
PambAlloc(void)
DropPamb(AMB **)
RemoveAmb(AMB *)
StopSound(AMB *, int)
SetPambFrq(AMB *, float)
RefreshPambVolPan(AMB *)
SetPambVol(AMB *, float)
FillPamb(AMB *, AMB **, int, ALO *, VECTOR *, float, float, float, float, float, LM *, LM *)
ActivatePamb(AMB *, SFXID)
ScheduleNextIntermittentSound(AMB *)
StartSound(SFXID, AMB **, ALO *, VECTOR *, float, float, float, float, float, LM *, LM *)
SoundStoppedCB(unsigned int, unsigned long)
HandleWipeVolumes(int, float)
UpdateSounds(void)
SetMvgkRvol(MVGK, float)
SetMvgkUvol(MVGK, float)
UvolGetMvgk(MVGK)
RvolGetMvgk(MVGK)
KillSoundSystem(void)
KillSounds(int)
PushSwReverb(SW *, REVERBK, int)
PopSwReverb(SW *)
SetSwDefaultReverb(SW *, REVERBK, int)
SetSwIntermittentSound(SW *, SFXID)
SetSwIntermittentVolPct(SW *, LM *)
SetSwIntermittentRepeat(SW *, LM *)
StartSwIntermittentSounds(SW *)
SetAMRegister(int, unsigned char)
HsNextFootFall(void)
NextSneakyFootstep(void)

D:\P2\speaker.c

0x001d5578

InitSpeaker(SPEAKER *)
PostSpeakerLoad(SPEAKER *)
SetSpeakerSmIdle(SPEAKER *, OID)
GetSpeakerParams(SPEAKER *, SOP **)

D:\P2\spire.c

0x001d5778

OnSpireAdd(SPIRE *)
OnSpireRemove(SPIRE *)
CloneSpire(SPIRE *, SPIRE *)

D:\P2\splicemap.c

0x001d5858

LoadSwSpliceFromBrx(SW *, CBinaryInputStream *)
PframeFromIsplice(int, SW *)
RefEvalModule(int, SW *)

D:\P2\spliceobj.c

0x001d5e00

PeopidFind(BASIC *, int)
RefGetObjectList(BASIC *, OTYP, void (*)(void *))
RefGetPeopid(BASIC *, EOPID *)
FAppendSpliceListElement(void *, void *)
FSpliceListElementExists(void *, void *)
RefSetPvsFromSplice(int, CRef *, OTYP *, void **)
RefSetArgListFromPvs(int, OTYP *, void **)
RefSetPeopid(BASIC *, EOPID *, CRef *)
RefGetOption(BASIC *, int)
RefSetOption(BASIC *, int, CRef *)
RefAddOption(BASIC *, int, CRef *)
RefEnsureOption(BASIC *, int, CRef *)
RefSetArgsFromSplice(int, CRef *, OTYP *,...)

D:\P2\sprbuf.c

0x001d7058

LoadSprBuf(int,...)
SaveSprBuf(void *,...)

D:\P2\sqtr.c

0x001d7648

UpdateSqtrm(SQTRM *, VECTOR *, MATRIX3 *, float, float)
RenderSqtrm(SQTRM *, CM *)
DrawSqtrm(RPL *)

D:\P2\squish.c

0x001d8068

LoadSquishFromBrx(SQUISH *, CBinaryInputStream *)
UpdateSquish(SQUISH *, float)
RenderSquishSelf(SQUISH *, CM *, RO *)
AdjustSquishNewXp(SQUISH *, XP *, int)
NotifySquishImpact(SQUISH *, XP *, int)

D:\P2\step.c

0x001d87a8

InitStep(STEP *)
PostStepLoad(STEP *)
LimitStepHands(STEP *, int)
RetractStepExtremity(STEP *, ALO *, float, ALO *, ALO *)
RenderStepSelf(STEP *, CM *, RO *)
ReadStepJoystick(STEP *, JOY *)
UpdateStepFootfall(STEP *, float, SFF *)
UpdateStepPhys(STEP *)
SetStepPhys(STEP *, SO *, int)
UpdateStep(STEP *, float)
CtTorqueStep(STEP *)
PropagateStepForce(STEP *, int, XP *, int, DZ *, FX *)
RotateStepToMat(STEP *, MATRIX3 *)
CloneStepPhys(STEP *, SO *, int)
PresetStepAccel(STEP *, float)
PresetStepAccelBase(STEP *)
FCheckStepXpBase(STEP *, XP *, int)
AdjustStepNewXp(STEP *, XP *, int)
AdjustStepDz(STEP *, int, DZ *, int, float)
AdjustStepDzBase(STEP *, int, DZ *, int)
UpdateStepMatTarget(STEP *)
AdjustStepXpVelocity(STEP *, XP *, int)
UpdateStepXfWorld(STEP *)
AdjustStepXpVelocityBase(STEP *, XP *, int)
AdjustStepXps(STEP *)
AddStepCustomXps(STEP *, SO *, int, BSP *, BSP *, XP **)
AddStepCustomXpsBase(STEP *, SO *, BSP *, XP **)
FixStepAngularVelocity(STEP *)
PredictStepPosition(STEP *, float, VECTOR *, VECTOR *)
PredictStepRotation(STEP *, float, MATRIX3 *, VECTOR *)
SetStepSpinRatio(STEP *, float)
SetStepGravityRatio(STEP *, float)
GetStepParams(STEP *, SOP **)

D:\P2\stepact.c

0x001da4c8

GetActaddPositionGoal(ACTADD *, float, VECTOR *, VECTOR *)
GetActaddRotationGoal(ACTADD *, float, MATRIX3 *, VECTOR *)

D:\P2\stepcane.c

0x001da7a0

SetJtJtcs(JT *, JTCS)
UpdateJtCane(JT *)
UpdateJtActiveCane(JT *, JOY *)
ChooseJtAttackTarget(JT *, int, VECTOR *, float, float, TARGET **, VECTOR *)
ChooseJtSweepTarget(JT *, BL *, ASEGBL *)
ChooseJtRushTarget(JT *)
ChooseJtSmashTarget(JT *)

D:\P2\stepguard.c

0x001db548

InitStepguard(STEPGUARD *)
LoadStepguardFromBrx(STEPGUARD *, CBinaryInputStream *)
CloneStepguard(STEPGUARD *, STEPGUARD *)
BindStepguard(STEPGUARD *)
PostStepguardLoadCallback(STEPGUARD *, MSGID, void *)
PostStepguardLoad(STEPGUARD *)
FIgnoreStepguardIntersection(STEPGUARD *, SO *)
OnStepguardAdd(STEPGUARD *)
OnStepguardRemove(STEPGUARD *)
PresetStepguardAccel(STEPGUARD *, float)
DradEnemyStepguard(STEPGUARD *)
SetStepguardTargetHeading(STEPGUARD *, float, float)
UpdateStepguardAI(STEPGUARD *)
UpdateStepguardDrive(STEPGUARD *)
UpdateStepguard(STEPGUARD *, float)
SgsNextStepguardAI(STEPGUARD *)
SetStepguardGoal(STEPGUARD *, VECTOR *)
FReachedStepguardGoal(STEPGUARD *)
FFilterStepguardJump(STEPGUARD *, SO *)
MoveStepguardToGoal(STEPGUARD *)
LookStepguardAtGoal(STEPGUARD *)
UpdateStepguardGoal(STEPGUARD *, int)
OnStepguardWaypointActive(STEPGUARD *)
UpdateStepguardSgs(STEPGUARD *)
SetStepguardSgs(STEPGUARD *, SGS, ASEG *)
SetStepguardSgsExternal(STEPGUARD *, SGS, ASEG *)
OnStepguardExitingSgs(STEPGUARD *, SGS)
OnStepguardEnteringSgs(STEPGUARD *, SGS, ASEG *)
SggsGetStepguard(STEPGUARD *)
FAbsorbStepguardWkr(STEPGUARD *, WKR *)
FTakeStepguardDamage(STEPGUARD *, ZPR *)
HandleStepguardGrfsgsc(STEPGUARD *)
DoStepguardFreefallJump(STEPGUARD *)
DoStepguardFreefallLanding(STEPGUARD *)
HandleStepguardMessage(STEPGUARD *, MSGID, void *)
SgasGetStepguard(STEPGUARD *)
FCanStepguardAttack(STEPGUARD *)
RenderStepguardSelf(STEPGUARD *, CM *, RO *)
FValidSgs(SGS)
UseStepguardAnimation(STEPGUARD *, SGS, OID)
UseStepguardAnimationImmediate(STEPGUARD *, SGS, OID)
UseStepguardDeathAnimation(STEPGUARD *, int, OID)
PasegFindStepguard(STEPGUARD *, OID)
LoadStepguardAnimations(STEPGUARD *)
UseStepguardExpl(STEPGUARD *, OID)
UseStepguardRwm(STEPGUARD *, OID)
UseStepguardPhys(STEPGUARD *, SGS, OID)
LoadStepguardPhys(STEPGUARD *)
AddStepguardEffect(STEPGUARD *, OID, ZPK)
SetStepguardPathzone(STEPGUARD *, OID)
PsoEnemyStepguard(STEPGUARD *)
SetStepguardEnemyObject(STEPGUARD *, SO *)
RebindStepguardEnemy(STEPGUARD *)
AdjustStepguardNewXp(STEPGUARD *, XP *, int)
AdjustStepguardDz(STEPGUARD *, int, DZ *, int, float)
SetStepguardAttackAngleMax(STEPGUARD *, float)
AddStepguardAlarm(STEPGUARD *, ALARM *)
MatchStepguardAnimationPhase(STEPGUARD *, OID, OID, OID, OID)
AddStepguardCustomXps(STEPGUARD *, SO *, int, BSP *, BSP *, XP **)
ApplyStepguardThrow(STEPGUARD *, PO *)
UpdateStepguardEffect(STEPGUARD *)
SetStepguardPatrolAnimation(STEPGUARD *, ASEG *)
FInflictStepguardZap(STEPGUARD *, XP *, ZPR *)
FDetectStepguard(STEPGUARD *)
FCheckStepguardEnemyHidden(STEPGUARD *)
PsggNew(SW *)
InitSgg(SGG *)
AddSggGuard(SGG *, STEPGUARD *)
AddSggGuardName(SGG *, OID)
AddSggSearchXfmName(SGG *, OID)
RemoveSggGuard(SGG *, STEPGUARD *)
BindSgg(SGG *)
PostSggLoadCallback(SGG *, MSGID, void *)
EnsureSggCallback(SGG *)
PsoEnemySgg(SGG *)
UpdateSggCallback(SGG *, MSGID, void *)
SggsNextSgg(SGG *)
FDetectSgg(SGG *)
FAbandonSggSearch(SGG *)
EnsureSggAlarm(SGG *, ALARM *)
TriggerSggAlarms(SGG *, ALTK)
SetSggSggs(SGG *, SGGS)
AssignSggSearchPoints(SGG *)

D:\P2\stephang.c

0x001e0d00

PostJtLoadSwing(JT *, BL *, ASEGBL **)
AnticipateJtForce(JT *, SO *, VECTOR *, VECTOR *, FX *)
CalculateJtHangAccel(JT *)
PresetJtAccelHang(JT *)
AddJtExternalAccelerations(JT *, XA *, float)
UpdateJtActiveHang(JT *, JOY *)
CheckJtUnhook(JT *)
UpdateJtHookOx(JT *, LO *, int)
AddJtHookXps(JT *, int, LO *, VECTOR *, VECTOR *, VECTOR *)
GetJtHangHeading(JT *, float *)
UpdateJtIkHang(JT *)

D:\P2\stephide.c

0x001e2840

JtbsChooseJtHide(JT *, LO *, JTHK *)
MeasureJtJumpToTarget(JT *, VECTOR *, ALO *, VECTOR *, VECTOR *, float *, float *, VECTOR *, VECTOR *)
GetJtRailLanding(JT *, RAIL *, float, VECTOR *, VECTOR *)
GMeasureJumpRail(MJR *, float)
GMeasureJumpHshape(MJH *, float)
FFindJtObstruction(JT *, float, VECTOR *, VECTOR *, VECTOR *)
JtbsChooseJtLanding(JT *, LO *)
UpdateJtActiveHide(JT *, JOY *)
MatchJtXmgRail(JT *, XMG *, ACTADJ *)
UpdateJtHide(JT *)
UpdateJtInternalXpsHide(JT *)
SetJtHfdk(JT *, HFDK)
ResetJtDynamicTunnel(JT *)
PresetJtAccelHide(JT *)

D:\P2\steppipe.c

0x001e4eb8

PostJtLoadPipe(JT *)
GetJtPipeGoalMat(JT *, PIPE *, float, MATRIX3 *)
PresetJtAccelPipe(JT *)
UpdateJtActivePipe(JT *, JOY *)
UpdateJtInternalXpsPipe(JT *)
SetJtJtpdk(JT *, JTPDK)
PlaceJtOnPipe(JT *, PIPE *)

D:\P2\steppower.c

0x001e6118

SetFsp(FSP)
UpdateJtActivePowerUp(JT *, JOY *)
IRotatePowerUp(JOY *, int, int, int *)

D:\P2\steprun.c

0x001e6630

PostStepLoadRun(STEP *, BLRUN *, ASEGBL **)
CalculateBlrunV(int, BLRUN *, MRSG *, VECTOR *)
ProjectStepRunPlant(STEP *, BLRUN *, float, float, int, int, VECTOR *)
FIntersectStepRunPlant(STEP *, VECTOR *, VECTOR *, float *)
FReblendAbl2D(int, int, int, BL *,...)
AdjustStepRun(STEP *, BLRUN *, ASEGBL *, ASEGA *)
SetStepRunTarget(STEP *, float, float, BLRUN *, ASEGBL *)

D:\P2\stepside.c

0x001e7190

PostJtLoadSidestep(JT *, BLSS *, ASEGBL **)
AdjustJtSidestep(JT *, BLSS *, ASEGBL *)
SetJtSidestepTarget(JT *, BLSS *, ASEGBL *, float, float)

D:\P2\stepski.c

0x001e78c0

PostJtLoadSki(JT *)
UpdateJtActiveSki(JT *, JOY *)
ProjectJtTransformSki(JT *, float, int)
EmitJtSkiParticles(JT *)
AddJtSpeedBoost(JT *, float)

D:\P2\stepzap.c

0x001e8e38

PostJtLoadZap(JT *)
PresetJtAccelZap(JT *)
UpdateJtZap(JT *)
PzqeAppendJt(JT *, JTBS)
PopJtZqe(JT *)
FTakeJtDamage(JT *, ZPR *)
FInvulnerableJt(JT *, ZPK)
OnJtDead(JT *)
SgnCmpSpkn(void const *, void const *)
DrawHaloSpks(VECTOR *, int, SPKS *, SPKD *, RPL *)
DrawJtHaloElectric(RPL *)
DrawJtHaloFire(RPL *)
RenderJtSelfZap(JT *, CM *, RO *)
JthsCurrentJt(JT *)
UseJtCharm(JT *)
UpdateJtWater(JT *)
FFindJtWaterSurface(JT *, WATER *, VECTOR *)
AddJtWaterAcceleration(JT *, WATER *, float)
InitZpr(ZPR *, ZPK, LO *)

D:\P2\stream.c

0x001eb050

OSTRM::OSTRM(int)
OSTRM::OSTRM(void *, int)
OSTRM::~OSTRM(void)
OSTRM::CbWrite(void *, int)
OSTRM::Flush(void)

D:\P2\suv.c

0x001eb368

InitSuv(SUV *)
PostSuvLoad(SUV *)
PresetSuvAccel(SUV *, float)
GExcludeAlm(int, LM *, float)
UpdateSuvBalance(SUV *)
DsGetTrackRelative(float, float, float)
FIsSuvAheadOf(SUV *, SUV *)
UpdateSuvLine(SUV *, int *)
UpdateSuvHeading(SUV *)
UpdateSuvWheels(SUV *)
UpdateSuvExpls(SUV *)
BoostSuv(SUV *)
UpdateSuvVolumes(SUV *, int)
RampTo(float *, float, float *, float)
SetSuvTargetFrq(SUV *, float, float)
SetSuvTargetVol(SUV *, float, float)
UpdateSuvSounds(SUV *, float)
UpdateSuvPuncher(SUV *)
UpdateSuv(SUV *, float)
UpdateSuvActive(SUV *, JOY *, float)
UpdateSuvInternalXps(SUV *)
AddSuvCustomXps(SUV *, SO *, int, BSP *, BSP *, XP **)
AdjustSuvNewXp(SUV *, XP *, int)
UpdateSuvInfluences(SUV *, RO *)
RenderSuvSelf(SUV *, CM *, RO *)
UpdateSuvBounds(SUV *)
CollectSuvPrize(SUV *, PCK, ALO *)
UpdateSuvShapes(SUV *)
UpdateSuvXfWorld(SUV *)
GetSuvCpdefi(SUV *, float, CPDEFI *)
OnSuvActive(SUV *, int, PO *)
HandleSuvMessage(SUV *, MSGID, void *)
SetSuvTrack(SUV *, SHAPE *)
SetSuvLine(SUV *, SHAPE *)
AddSuvBoostOpportunity(SUV *, VOL *)
AddSuvBoostCollect(SUV *, VOL *)
AddSuvCheckPoint(SUV *, VOL *)
AddSuvFeature(SUV *, VOL *, float, float, EXPL *, EXPL *)
SetSuvSuvs(SUV *, SUVS)
ResetSuv(SUV *)
VecCombo(VU_FLOAT, VU_VECTOR, VU_FLOAT, VU_VECTOR)

D:\P2\sw.c

0x001ef790

InitSwDlHash(SW *)
InitSw(SW *)
DeleteSw(SW *)
SetupBulkDataFromBrx(int, CBinaryInputStream *)
LoadBulkDataFromBrx(CBinaryInputStream *)
SetSwGravity(SW *, float)
FOverflowSwLo(SW *, LO *, int)
PxaAllocSw(SW *)
FreeSwXaList(SW *, XA *)
PmqAllocSw(SW *)
FreeSwMqList(SW *, MQ *)
EnsureSwCallback(SW *, void (*)(void *, MSGID, void *), void *, MSGID, void *)
PostSwCallback(SW *, void (*)(void *, MSGID, void *), void *, MSGID, void *)
ClearSwCallbacks(SW *, int, void (*)(void *, MSGID, void *), void *, MSGID, void *)
ProcessSwCallbacks(SW *)
ProcessSwSpliceScheduledCallbacks(SW *, float)
PstsoAllocSw(SW *)
FreeSwStsoList(SW *, STSO *)
AddSwProxySource(SW *, LO *, int)
PloGetSwProxySource(SW *, int)
IntersectSwBoundingBox(SW *, SO *, VECTOR *, VECTOR *, int (*)(void *, SO *), void *, int *, SO ***)
IntersectSwBoundingSphere(SW *, SO *, VECTOR *, float, int (*)(void *, SO *), void *, int *, SO ***)
RemoveOxa(OXA *, OXA **)
InitSwAoxa(SW *)
AddOxa(OXA *, OXA **)
PoxaAllocSw(SW *, SO *)
FreeSwPoxa(SW *, OXA *)
CreateSwDefaultLights(SW *)
LoadNameTableFromBrx(CBinaryInputStream *)
LoadWorldTableFromBrx(CBinaryInputStream *)
CreateSwPrizes(SW *)
LoadSwFromBrx(SW *, CBinaryInputStream *)
FClipLineHomogeneous(VECTOR4 *)
DrawLineWorld(VECTOR *, VECTOR *, RGBA, CM *, int)
DrawAxesWorld(VECTOR *, MATRIX3 *, float, CM *, int)
DrawBezWorld(VECTOR *, VECTOR *, VECTOR *, VECTOR *, float, RGBA, CM *, int)
GetSwParams(SW *, SOP **)
SetSwIllum(SW *, float)
SetSwIllumShadow(SW *, float)
SetSwExcitement(SW *, float)
FLevelSwVisited(SW *, WID)
FLevelSwPrimary(SW *, WID)
FLevelSwSecondary(SW *, WID)
FLevelSwTertiary(SW *, WID)
SetSwPlayerSuck(SW *, float)
GetSwPlayerSuck(SW *, float *)
IncrementSwHandsOff(SW *)
DecrementSwHandsOff(SW *)
IsSwVagPlaying(SW *, int *)
SetSwDarken(SW *, float)
SetSwDarkenSmooth(SW *, float)
CancelSwDialogPlaying(SW *)

D:\P2\tail.c

0x001f22f0

InitTail(TAIL *)
PostTailLoad(TAIL *)
UpdateTailConstraints(TAIL *)
MatchTailOtherObject(TAIL *, ALO *)

D:\P2\tank.c

0x001f2e30

InitTank(TANK *)
PostTankLoad(TANK *)
UpdateTank(TANK *, float)
UseTankCharm(TANK *)
UpdateTankActive(TANK *, JOY *, float)
OnTankActive(TANK *, int, PO *)
RenderTankAll(TANK *, CM *, RO *)
ImpactTank(TANK *, int)
FInvulnerableTank(TANK *, ZPK)
ApplyTankThrow(TANK *, PO *)
FTakeTankDamage(TANK *, ZPR *)
AdjustTankXps(TANK *)
AdjustTankNewXp(TANK *, XP *, int)
HandleTankMessage(TANK *, MSGID, void *)
JthsCurrentTank(TANK *)
SetTankTanks(TANK *, TANKS)

D:\P2\target.c

0x001f4948

StartupTarget(void)
ResetTargetList(void)
InitTarget(TARGET *)
OnTargetAdd(TARGET *)
OnTargetRemove(TARGET *)
CloneTarget(TARGET *, TARGET *)
RenderTarget(TARGET *, CM *)

D:\P2\text.c

0x001f4b90

CchParsePchzInt(char *, int *)
CchParsePchzTft(char *, TFT *, char **)
WriteTftPchz(TFT *, OSTRM *, char *)
FNegTftUl(TFT *, UL *)
UnRadixFromChConversion(char)
CchAchFromUl(char *, int, unsigned long, unsigned int)
WriteTftUl(TFT *, OSTRM *, unsigned long)
ExpFirstFromG(double)
ChDigitFromG(double, int, int)
CchAchFromDouble(char *, int, TFT *, double)
WriteTftDouble(TFT *, OSTRM *, double)
WriteTft(TFT *, OSTRM *, char **, char *, int)
CchOstrmPrintf(OSTRM *, char *, char *)
UpperizePchz(char *)
PchzDupSwCchImpl(char *, int)

D:\P2\thread.c

0x001f68c0

SemaCreate(int, int)
ResetSema(int)
InitCritSect(CRITSECT *)
EnterCritSect(CRITSECT *)
LeaveCritSect(CRITSECT *)
StartupThread(void)

D:\P2\tn.c

0x001f6b40

PtnfnFromTn(TN *)
GetTnfnNose(TNFN *, CPDEFI *, VECTOR *, TN *)
InitTn(TN *)
OnTnRemove(TN *)
LoadTnFromBrx(TN *, CBinaryInputStream *)
PostTnLoad(TN *)
SetTnTns(TN *, TNS)
UpdateTnCallback(TN *, MSGID, void *)
UpdateTn(TN *, float)
RenderTnSelf(TN *, CM *, RO *)
FreezeTn(TN *, int)
SetTnFocusRatio(TN *, float)
CalculateTnCrv(TN *, VECTOR *, VECTOR *, VECTOR *)
CalculateTnPos(TN *, VECTOR *, float, float, CLQ *, LM *, FTND, VECTOR *)
GetTnParams(TN *, SOP **)
ActivateCptn(CPTN *, void *)
DeactivateCptn(CPTN *, void *)
SetCptn(CPTN *, void *)
RevokeCptn(CPTN *, void *)
UpdateCptn(CPTN *, CPDEFI *, JOY *, float)
LoadTbspFromBrx(CBinaryInputStream *, int *, TSURF **, int *, TBSP **)
FCheckTbspPoint(TBSP *, VECTOR *)

D:\P2\transition.c

0x001f9038

CTransition::CTransition(void)
CTransition::Set(char *, OID, OID, int)
CTransition::Execute(void)
ResetWorld(int)
LoadBrxWorld(int)

D:\P2\turret.c

0x001f9760

PostTurretLoad(TURRET *)
UpdateTurret(TURRET *, float)
UpdateTurretActive(TURRET *, JOY *, float)
OnTurretActive(TURRET *, int, PO *)
FFilterTurret(TURRET *, SO *)
UpdateTurretAim(TURRET *)
FireTurret(TURRET *)
HandleTurretMessage(TURRET *, MSGID, void *)
FIgnoreTurretIntersection(TURRET *, SO *)
CollectTurretPrize(TURRET *, PCK, ALO *)
GetTurretDiapi(TURRET *, DIALOG *, DIAPI *)

D:\P2\tv.c

0x001fa1b8

InitTv(TV *, BLOTK)
PostTvLoad(TV *)
GetTvItvbMinMax(TV *, int *, int *)
DrawTvArea(TV *, GIFS &, int)
DrawTvBands(TV *, GIFS &)
DrawTvOutline(TV *, GIFS &)
DrawTv(TV *)
SetTvTvs(TV *, TVS)
AcceptTvSpeaker(TV *)
SetTvTvgs(TV *, TVGS)
SetTvBlots(TV *, BLOTS)
UpdateTv(TV *)
RenderTv(TV *)
PreTvContext(RPL *)
PostTvContext(RPL *)
SetTvSpeaker(TV *, SPEAKER *)
SetTvReplace(TV *, ALO *)
OnTvReset(TV *)

D:\P2\ub.c

0x001fced0

PostUbvLoad(UBV *)
UpdateUbv(UBV *, float)
SetUbvUbvs(UBV *, UBVS)
PostUbpLoad(UBP *)
UpdateUbp(UBP *, float)
SetUbpUbps(UBP *, UBPS, VECTOR *)
CaptureUbpBomb(UBP *, MSGID, void *)
DetonateUbpBomb(UBP *, MSGID, void *)
NotifyUbpImpact(UBP *, XP *, int)
RenderUbpAll(UBP *, CM *, RO *)
FIgnoreUbpIntersection(UBP *, SO *)
InitUbg(UBG *)
PostUbgLoad(UBG *)
PsoPadUbgClosest(UBG *, VECTOR *)
OnUbgEnteringSgs(UBG *, SGS, ASEG *)
SgsNextUbgAI(UBG *)
FDetectUbg(UBG *)
FCanUbgAttack(UBG *)
DoUbgFreefallJump(UBG *)
DoUbgFreefallLanding(UBG *)
UpdateUbgGoal(UBG *, int)
UpdateUbgSgs(UBG *)
FIgnoreUbgIntersection(UBG *, SO *)

D:\P2\ui.c

0x001fe690

StartupUi(void)
InitUi(UI *)
PostUiLoad(UI *)
UpdateUi(UI *)
PushUiActiveBlot(UI *, BLOT *)
PopUiActiveBlot(UI *)
DrawUiSplash(UI *)
DrawUiSelf(UI *)
DrawUi(UI *)
RenderUi(UI *)
ResetUi(UI *)
SetUiUis(UI *, UIS)
SetUiUPause(UI *, float)
FDebugmenuActive(UI *)

D:\P2\update.c

0x001ff5b8

UpdateSwObjects(SW *, float)
UpdateSwPosWorldPrev(SW *)
UpdateSwRealClock(SW *, float)
UpdateSwDarkening(SW *, float)
UpdateSw(SW *, float)

D:\P2\util.c

0x001ffef8

RadNormalize(float)
GLimitAbs(float, float)
GSmooth(float, float, float, SMP *, float *)
GSmoothA(float, float, float, float, SMPA *, float *)
RadSmooth(float, float, float, SMP *, float *)
RadSmoothA(float, float, float, float, SMPA *, float *)
PosSmooth(VU_VECTOR, VU_VECTOR, float, SMP *, VECTOR *)
SmoothMatrix(MATRIX3 *, MATRIX3 *, SMP *, float, MATRIX3 *, VECTOR *)
NRandInRange(int, int)
GRandInRange(float, float)
GRandGaussian(float, float, float)
FFloatsNear(float, float, float)
CSolveQuadratic(float, float, float, float *)
PrescaleClq(CLQ *, float, float, CLQ *)
CalculateSinCos(float, float *, float *)
GTrunc(double)
GTrunc(float)
GModPositive(float, float)
FitClq(float, float, float, float, CLQ *)
FCheckLm(LM *, float)
FCheckAlm(int, LM *, float)
GLimitLm(LM *, float)
SgnCompareG(float *, float *)
Force(void *)
MinimizeRange(float (*)(void *, float), void *, float, float, float, float, float *, float *)

D:\P2\vec.c

0x00201008

SetVectorCylind(VECTOR *, float, float, float)
SetVectorSphere(VECTOR *, float, float, float)
SProjectVector(VECTOR *, VECTOR *, VECTOR *, VECTOR *)
GetNormalVectors(VECTOR *, VECTOR *, VECTOR *, VECTOR *)
GetNormalVector(VECTOR *, VECTOR *)
RadBetweenVectors(VECTOR *, VECTOR *, VECTOR *)
FindClosestPointBetweenLines(VECTOR *, VECTOR *, VECTOR *, VECTOR *, float *, float *, VECTOR *)
FindClosestPointBetweenLineSegments(VECTOR *, VECTOR *, VECTOR *, VECTOR *, float *, float *, VECTOR *)
CalculateVectorPanTilt(VECTOR *, float *, float *)
ConvertDeulToW(VECTOR *, VECTOR *, VECTOR *)
FCalculateMuzzleVelocity(VECTOR *, VECTOR *, float, VECTOR *, SO *)
FCalculateMuzzleVelocitySpeed(VECTOR *, VECTOR *, float, VECTOR *, SO *)
FCalculateMuzzleVelocityAngle(VECTOR *, VECTOR *, float, VECTOR *, SO *)
LimitVectorLength(VECTOR *, float, VECTOR *)

D:\P2\vife.c

0x00201cd0

DMAI::DMAI(int, QW *)
DMAI::EnsureQw(void)
DMAI::FDone(void)
DMAI::AdvancePrplsCur(void)
DMAI::GetBulk(int, void *)
DMAI::Skip(int)
DMAI::UnNext(void)
DMAI::UsNext(void)
DMAI::BNext(void)
DMAI::Align(int)
VIFE::VIFE(VIFEK, VIFES *)
VIFE::Emulate(int, QW *, SLI *)
VIFE::Mask(unsigned int, unsigned int, int, int, QW *)
VIFE::EmulateUnpack(unsigned int, DMAI *)
VIFE::EmulateClip(QW *, int *)
VIFE::EmulateXgkick(QW *)
VIFE::Nop(void)
VIFE::NopCel(void)
VIFE::SetupRgl(void)
VIFE::SetupRglCel(void)
VIFE::CopyRgl(void)
VIFE::CopyRglCel(void)
VIFE::DrawP0(void)
VIFE::DrawP12(void)
VIFE::DrawP12Force(int)
VIFE::PostNidRgba(void)
VIFE::ClearLightingToF32(void)
VIFE::ConvertLightingU8ToF32(void)
VIFE::AddDirectionLightAsF32(void)
VIFE::AddPositionLightAsF32(void)
VIFE::AddFrustrumLightAsF32(void)
VIFE::AddQuickLightAsF32(void)
VIFE::AddDirectionLightAsQuickF32(void)
VIFE::AddPositionLightAsQuickF32(void)
VIFE::AddFrustrumLightAsQuickF32(void)
VIFE::ConvertLightingF32ToU8(void)
VIFE::ProcessPrelit(void)
VIFE::ProcessPrelitClip(int)
VIFE::ProcessThreeWayClip(void)
VIFE::ProcessThreeWay(void)
VIFE::ProcessVolume(void)
VIFE::DrawVolume(void)
VIFE::FadeAmbientP0(void)
VIFE::FadeDiffuseP12(void)
VIFE::CopySaturateP12(void)
VIFE::CullThreeWay(void)
VIFE::CullPrelit(void)
VIFE::ToggleCullPrelit(void)
VIFE::PvtxpCullFan(VTXP *, VTXP *, int)
VIFE::PvtxpClipFanToPlane(VTXP *, VTXP *, QW *)
VIFE::PvtxpClipFanToFrustrum(VTXP *, VTXP *, int)
VIFE::ClipThreeWay(int, int)
VIFE::ClipPrelit(int, int)
VIFE::DrawPrelit(void)
VIFE::DrawShadow(void)
VIFE::DrawBlipesFixed(void)
VIFE::DrawBlipesFlying(void)
VIFE::DrawBlipesRolling(void)
VIFE::DrawCelBorders(void)
VIFE::ApplyBonesHelper(QW *, QW *, int, MATRIX4 *, QW *)
VIFE::ApplyBonesPos(void)
VIFE::ApplyBonesNormal(void)
VIFE::ApplyPoseHelperRsgl(int)
VIFE::ApplyPoseHelper(QW *, QW *, int, QW *, QW *)
VIFE::ApplyPosePos(void)
VIFE::ApplyPoseNormal(void)
VIFE::ApplyPoseSubcel(void)
VIFE::PostPoseNormals(void)
VIFE::AnimateUVs(void)
VIFE::ApplyWarpHelper(int)
VIFE::ApplyWarp_Plus0(void)
VIFE::ApplyWarp_Plus2(void)
VIFE::ApplyWarp_Plus3(void)
VIFE::EmulateMscal(char *, int)

D:\P2\vifs.c

0x00209660

VIFS::VIFS(void)
VIFS::Align(int)
VIFS::AddVifBaseOffset(int, int)
VIFS::AddVifMscal(void *)
VIFS::AddVifMscalf(void *)
VIFS::AddVifFlush(void)
VIFS::AddVifFlusha(void)
VIFS::AddVifFlushe(void)
VIFS::AddVifStcycl(int, int)
VIFS::AddVifStrow(QW *)
VIFS::AddVifStmask(unsigned int)
VIFS::CbUnpackSetup(UPK, int, int)
VIFS::UnpackHelper(UPK, int, int, int *, unsigned int **)
VIFS::AddVifUnpack(UPK, int, void *, int)
VIFS::AddVifUnpackRefs(UPK, int, void *, int, void ***)
VIFS::AddVifDirect(int, QW *, int)
VIFS::AddVifDirectRefs(int, QW *, int)
VIFS::AddVifGifs(GIFS *)

D:\P2\vis.c

0x00209ca0

InitVismap(VISMAP *)
LoadVismapFromBrx(VISMAP *, CBinaryInputStream *)
GrfzonOneHop(VISMAP *, VBSP *)
ClipVbspSphereOneHop(VISMAP *, VBSP *, VU_VECTOR, float, int *)
ClipVismapSphereOneHop(VISMAP *, VECTOR *, float, int *)
ClipVismapPointNoHop(VISMAP *, VECTOR *, int *)

D:\P2\water.c

0x0020a078

InitWater(WATER *)
PostWaterLoad(WATER *)
CalculateWaterCurrent(WATER *, VECTOR *, VECTOR *, VECTOR *)
UpdateSwXaList(SW *, XA **)
UpdateWater(WATER *, float)
AddWaterExternalAccelerations(WATER *, XA *, float)
HandleWaterMessage(WATER *, MSGID, void *)
UpdateWaterMergeGroup(WATER *)
UGetWaterSubmerged(WATER *, SO *, VECTOR *, VECTOR *)
UpdateWaterBounds(WATER *)
FInflictWaterZap(WATER *, XP *, ZPR *)
PzpdEnsureWater(WATER *, ENSK)

D:\P2\waypoint.c

0x0020ae80

InitWaypoint(WAYPOINT *)
PostWaypointLoad(WAYPOINT *)
SetWaypointRsmg(WAYPOINT *, int, OID, OID, OID)
UpdateWaypoint(WAYPOINT *, float)
SetWaypointWps(WAYPOINT *, WPS)
HandleWaypointMessage(WAYPOINT *, MSGID, void *)
PwpsgNew(void)
AddWpsgWaypoint(WPSG *, WAYPOINT *)
RemoveWpsgWaypoint(WPSG *, WAYPOINT *)
UpdateWpsgCallback(WPSG *, MSGID, void *)
EnsureWpsgCallback(WPSG *)

D:\P2\wibu_ee.c

0x0020b3a0

wibuInit(void)
wibuGetFirstSerial(void)

D:\P2\wipe.c

0x0020b4f0

InitWipe(WIPE *)
UpdateWipe(WIPE *, JOY *)
DrawWipe(WIPE *)
ActivateWipe(WIPE *, TRANS *, WIPEK)
SetWipeButtonTrans(WIPE *, TRANS *, WIPEK)
FCatchWipeButtonTrans(WIPE *, JOY *, WIPES)
SetWipeWipes(WIPE *, WIPES)
WipeToWorldWarp(char *, OID, WIPEK)

D:\P2\wm.c

0x0020bd20

PostWmLoad(WM *)
BindWm(WM *)
RefreshWmMoveStats(WM *, WORLDLEVEL)
ThrowWmDisplayState(WM *, WORLDLEVEL, int)
CatchWmDisplayState(WM *)
UpdateWm(WM *, float)
RenderWmAll(WM *, CM *, RO *)
HandleWmMessage(WM *, MSGID, void *)
SetWmWms(WM *, WMS)
ShowWm(WM *, WORLDLEVEL, WMS)
HideWm(WM *)
MoveWm(WM *, WMD)
GetWmWorldPosScreen(WM *, WORLDLEVEL, VECTOR *)
SetWmCursor(WM *, WORLDLEVEL)
PostWmcLoad(WMC *)
UpdateWmcActive(WMC *, JOY *)
OnWmcActive(WMC *, int)
DrawWmFan(float, float, float, float, int, RGBA, RGBA, int)
DrawWmc(WMC *)

D:\P2\wr.c

0x0020de18

InitWr(WR *)
GetWrParams(WR *, SOP **)
HandleWrMessage(WR *, MSGID, void *)
ApplyWrGlob(WR *, ALO *, GLOB *)
UpdateWrStateVectors(WR *)
WarpWrTransform(WR *, float, VECTOR *, MATRIX3 *, VECTOR *, MATRIX3 *, VECTOR *)
GetWrBounds(WR *, VECTOR *)
UNoise(int)
UNoise(float, float, float)
UBias(float, float)
GFromOnz(ONZ *)
UpdateWrMatrixes(WR *)
AddWrCircleWarp(WR *)
AddWrBendWarp(WR *)
PwreGetWrCur(WR *, ENSK, WREK)
PwreGetWrCircle(WR *, ENSK)
PwreGetWrBend(WR *, ENSK)
SetWrWavelength(WR *, float)
GetWrWavelength(WR *, float *)
AddOnzOnze(ONZ *, float, float, float, float)
AddWrBendNoise(WR *, float, float, float, float)
AddWrSwivelNoise(WR *, float, float, float, float)

D:\P2\xform.c

0x0020f340

InitXfm(XFM *)
LoadXfmFromBrx(XFM *, CBinaryInputStream *)
SetXfmParent(XFM *, ALO *)
ApplyXfmProxy(XFM *, PROXY *)
GetXfmParams(XFM *, SOP **)
ConvertXfmLocalToWorld(XFM *, VECTOR *, VECTOR *)
ConvertXfmWorldToLocal(XFM *, VECTOR *, VECTOR *)
GetXfmPos(XFM *, VECTOR *)
GetXfmMat(XFM *, MATRIX3 *)
PwarpFromOid(OID, OID)
LoadWarpFromBrx(WARP *, CBinaryInputStream *)
CloneWarp(WARP *, WARP *)
PostWarpLoad(WARP *)
GetWarpParams(WARP *, SOP **)
TriggerWarp(WARP *)
AddWarpShowWhenDifficult(WARP *, OID)
SetWarpRsmg(WARP *, int, OID, OID, OID)
TeleportSwPlayer(SW *, OID, OID)
PexitDefault(void)
TriggerDefaultExit(int, WIPEK)
LoadExitFromBrx(EXIT *, CBinaryInputStream *)
PostExitLoad(EXIT *)
SetExitExits(EXIT *, EXITS)
TriggerExit(EXIT *)
WipeExit(EXIT *)
UpdateExit(EXIT *, float)
GetExitParams(EXIT *, SOP **)
InitCamera(CAMERA *)
PostCameraLoad(CAMERA *)
EnableCamera(CAMERA *, int)

D:\P2\zap.c

0x00210da8

InitTzp(TZP *)
PostTzpLoad(TZP *)
UpdateTzp(TZP *, float)
CloneTzp(TZP *, TZP *)
RenderTzpAll(TZP *, CM *, RO *)
FInflictTzpZap(TZP *, XP *, ZPR *)
PzpdEnsureTzp(TZP *, ENSK)
InitVolzp(VOLZP *)
UpdateVolzp(VOLZP *, float)
InitZpd(ZPD *, SO *)
PostZpdLoad(ZPD *)
ApplyZpdThrow(ZPD *, PO *)
InflictZpdZap(ZPD *, XP *, ZPR *)
AddZpdZapObject(ZPD *, OID)
AddZpdZapLo(ZPD *, LO *)
RemoveZpdZapLo(ZPD *, LO *)

../../../../../../src/newlib/libc/machine/r5900/memcmp.S

0x00211d4c

../../../../../../src/newlib/libc/machine/r5900/memcpy.S

0x00211de0

../../../../../../src/newlib/libc/machine/r5900/memmove.S

0x00211e90

../../../../../../src/newlib/libc/machine/r5900/memset.S

0x00211f94

/usr/local/sce/ee/gcc/src/newlib/libc/stdlib/qsort.c

0x00212058

/usr/local/sce/ee/gcc/src/newlib/libc/stdlib/rand.c

0x00212a80

/usr/local/sce/ee/gcc/src/newlib/libc/string/strcasecmp.c

0x00212ac0

klib.s

0x00212b90

intr.c

0x00212fe0

thread.c

0x002132c0

kprintf.c

0x00213510

sifcmd.c

0x00213e88

sifrpc.c

0x00214580

filestub.c

0x00214e70

eeloadfile.c

0x00216028

iopreset.c

0x00216470

diei.c

0x002166f8

initsys.c

0x00216758

libosd.c

0x00216880

exit.c

0x00216a00

glue.c

0x00216a80

deci2.c

0x00216b20

tlbfunc.c

0x00216b78

tlbtrap.s

0x00216f40

/usr/local/sce/ee/gcc/src/gcc/libgcc2.c

0x00217068

/usr/local/sce/ee/gcc/build/gcc/dp-bit.c

0x00218c10

/usr/local/sce/ee/gcc/build/gcc/fp-bit.c

0x002198d0

/usr/local/sce/ee/gcc/src/gcc/cp/new2.cc

0x00219b10

/usr/local/sce/ee/gcc/src/gcc/cp/exception.cc

0x0021ab58

terminate(void)
__default_unexpected(void)
set_terminate(void (*)(void))
set_unexpected(void (*)(void))
unexpected(void)
uncaught_exception(void)
exception::what(void) const
bad_exception::~bad_exception(void)
bad_exception::bad_exception(void)
bad_exception type_info function
exception::~exception(void)
exception::exception(void)
exception type_info function

/usr/local/sce/ee/gcc/src/gcc/frame.c

0x0021b2b0

/usr/local/sce/ee/gcc/src/gcc/cp/new.cc

0x0021c238

set_new_handler(void (*)(void))
operator new [](unsigned int, void *)
operator new(unsigned int, void *)
bad_alloc::what(void) const
bad_alloc type_info function
bad_alloc::~bad_alloc(void)

/usr/local/sce/ee/gcc/src/gcc/cp/tinfo.cc

0x0021c2e8

type_info::~type_info(void)
type_info::TEMPNAMEPLACEHOLDERVALUE(type_info const &) const
__user_type_info::dcast(type_info const &, int, void *, type_info const *, void *) const
__si_type_info::dcast(type_info const &, int, void *, type_info const *, void *) const
__class_type_info::dcast(type_info const &, int, void *, type_info const *, void *) const
__class_type_info::__class_type_info(char const *, __class_type_info::base_info const *, unsigned int)
__class_type_info type_info function
__class_type_info::~__class_type_info(void)
__si_type_info::__si_type_info(char const *, __user_type_info const &)
__si_type_info type_info function
__si_type_info::~__si_type_info(void)
__user_type_info::__user_type_info(char const *)
__user_type_info type_info function
__user_type_info::~__user_type_info(void)
bad_typeid::~bad_typeid(void)
bad_typeid::bad_typeid(void)
bad_typeid type_info function
bad_cast::~bad_cast(void)
bad_cast::bad_cast(void)
bad_cast type_info function
type_info::TEMPNAMEPLACEHOLDERVALUE(type_info const &) const
type_info::name(void) const
type_info::type_info(char const *)
type_info type_info function

/usr/local/sce/ee/gcc/src/gcc/cp/tinfo2.cc

0x0021c9b8

type_info::before(type_info const &) const
__is_pointer(void *)
void type_info function
long long type_info function
long type_info function
int type_info function
short type_info function
bool type_info function
char type_info function
wchar_t type_info function
long double type_info function
double type_info function
float type_info function
unsigned int type_info function
unsigned long type_info function
unsigned long long type_info function
unsigned short type_info function
unsigned char type_info function
signed char type_info function
__array_type_info type_info function
__array_type_info::~__array_type_info(void)
__ptmd_type_info type_info function
__ptmd_type_info::~__ptmd_type_info(void)
__ptmf_type_info type_info function
__ptmf_type_info::~__ptmf_type_info(void)
__func_type_info type_info function
__func_type_info::~__func_type_info(void)
__builtin_type_info type_info function
__builtin_type_info::~__builtin_type_info(void)
__attr_type_info type_info function
__attr_type_info::~__attr_type_info(void)
__pointer_type_info type_info function
__pointer_type_info::~__pointer_type_info(void)

/usr/local/sce/ee/gcc/src/newlib/libc/stdlib/abort.c

0x0021d738

/usr/local/sce/ee/gcc/src/newlib/libc/errno/errno.c

0x0021d758

/usr/local/sce/ee/gcc/src/newlib/libc/signal/signal.c

0x0021d768

/usr/local/sce/ee/gcc/src/newlib/libc/reent/signalr.c

0x0021d908

../../../../../../src/newlib/libc/machine/r5900/strcmp.S

0x0021d984

../../../../../../src/newlib/libc/machine/r5900/strncpy.S

0x0021dac8

D:/PS2/1394/sntty/main.c

0x0021dc90

vu/vu.c

0x0021de20

libscedemo.c

0x0021df50

graphdev.c

0x0021e140

libdma.c

0x0021ee90

../eecdvd.c

0x0021f430

libpad.c

0x00220900

cache.c

0x002217d0

/usr/local/sce/ee/gcc/src/newlib/libm/math/sf_atan.c

0x00221918

/usr/local/sce/ee/gcc/src/newlib/libm/math/sf_cos.c

0x00221bc0

/usr/local/sce/ee/gcc/src/newlib/libm/math/sf_fabs.c

0x00221ca8

/usr/local/sce/ee/gcc/src/newlib/libm/math/sf_floor.c

0x00221cc8

/usr/local/sce/ee/gcc/src/newlib/libm/math/sf_sin.c

0x00221db0

/usr/local/sce/ee/gcc/src/newlib/libm/math/sf_tan.c

0x00221ea0

/usr/local/sce/ee/gcc/src/newlib/libm/math/wf_acos.c

0x00221f28

/usr/local/sce/ee/gcc/src/newlib/libm/math/wf_asin.c

0x00222028

/usr/local/sce/ee/gcc/src/newlib/libm/math/wf_atan2.c

0x00222128

/usr/local/sce/ee/gcc/src/newlib/libm/math/wf_fmod.c

0x00222250

/usr/local/sce/ee/gcc/src/newlib/libm/math/wf_log.c

0x00222390

/usr/local/sce/ee/gcc/src/newlib/libm/math/wf_log10.c

0x002224d8

/usr/local/sce/ee/gcc/src/newlib/libm/math/wf_pow.c

0x00222628

/usr/local/sce/ee/gcc/src/newlib/libm/math/ef_acos.c

0x00222b30

/usr/local/sce/ee/gcc/src/newlib/libm/math/ef_asin.c

0x00222f60

/usr/local/sce/ee/gcc/src/newlib/libm/math/ef_atan2.c

0x00223300

/usr/local/sce/ee/gcc/src/newlib/libm/math/ef_fmod.c

0x002235e8

/usr/local/sce/ee/gcc/src/newlib/libm/math/ef_log.c

0x00223838

/usr/local/sce/ee/gcc/src/newlib/libm/math/ef_log10.c

0x00223b60

/usr/local/sce/ee/gcc/src/newlib/libm/math/ef_pow.c

0x00223c90

/usr/local/sce/ee/gcc/src/newlib/libm/math/ef_rem_pio2.c

0x00224520

/usr/local/sce/ee/gcc/src/newlib/libm/math/ef_sqrt.c

0x00224900

/usr/local/sce/ee/gcc/src/newlib/libm/math/kf_cos.c

0x00224a38

/usr/local/sce/ee/gcc/src/newlib/libm/math/kf_rem_pio2.c

0x00224b90

/usr/local/sce/ee/gcc/src/newlib/libm/math/kf_sin.c

0x002254e0

/usr/local/sce/ee/gcc/src/newlib/libm/math/kf_tan.c

0x002255e8

/usr/local/sce/ee/gcc/src/newlib/libm/common/s_matherr.c

0x00225880

/usr/local/sce/ee/gcc/src/newlib/libm/common/s_rint.c

0x002258a8

/usr/local/sce/ee/gcc/src/newlib/libm/common/sf_finite.c

0x00225aa8

/usr/local/sce/ee/gcc/src/newlib/libm/math/sf_isnan.c

0x00225ad0

/usr/local/sce/ee/gcc/src/newlib/libm/common/sf_scalbn.c

0x00225af8

/usr/local/sce/ee/gcc/src/newlib/libm/common/sf_copysign.c

0x00225c58

pack.c

0x00225c88

mpeg.c

0x00226898

init.c

0x00227278

defhandler.c

0x00227c70

mpc.c

0x00227c90

csc.c

0x0022c8f0

bit.c

0x0022d0b0

libipu.c

0x0022d2c0

ipuinit.c

0x0022d630