From cc941d2f4fd4e81236e3da9c8b8a6150cebdc2fe Mon Sep 17 00:00:00 2001 From: Ran-j Date: Sat, 25 Jul 2026 21:23:24 -0300 Subject: [PATCH 1/8] refactor: from guest threads to EE scheduler --- ps2xIOP/include/ps2x/iop/iop_types.h | 3 + ps2xIOP/src/modules/cri_dtx.cpp | 50 +- ps2xRecomp/src/lib/control_flow_emitter.cpp | 12 +- ps2xRecomp/src/lib/function_emitter.cpp | 2 +- ps2xRecomp/src/lib/ps2_recompiler.cpp | 9 +- ps2xRecomp/src/lib/special_translator.cpp | 4 +- ps2xRuntime/include/ps2_runtime.h | 101 +- ps2xRuntime/include/ps2_syscalls.h | 13 +- ps2xRuntime/include/runtime/ee_scheduler.h | 435 ++++ ps2xRuntime/include/runtime/ps2_memory.h | 12 +- ps2xRuntime/src/lib/Kernel/EeScheduler.cpp | 1886 +++++++++++++++++ ps2xRuntime/src/lib/Kernel/Stubs/CD.cpp | 8 +- ps2xRuntime/src/lib/Kernel/Stubs/GS.cpp | 212 +- ps2xRuntime/src/lib/Kernel/Stubs/GS.h | 2 - ps2xRuntime/src/lib/Kernel/Stubs/IPU.cpp | 94 +- ps2xRuntime/src/lib/Kernel/Stubs/MPEG.cpp | 395 +--- ps2xRuntime/src/lib/Kernel/Stubs/MPEG.h | 5 +- ps2xRuntime/src/lib/Kernel/Syscalls/Common.h | 49 +- .../src/lib/Kernel/Syscalls/Helpers/Runtime.h | 410 ---- .../src/lib/Kernel/Syscalls/Helpers/State.h | 227 +- .../src/lib/Kernel/Syscalls/Interrupt.cpp | 717 +------ .../src/lib/Kernel/Syscalls/Interrupt.h | 29 +- .../src/lib/Kernel/Syscalls/Lifecycle.cpp | 116 - .../src/lib/Kernel/Syscalls/Lifecycle.h | 10 - ps2xRuntime/src/lib/Kernel/Syscalls/RPC.cpp | 320 ++- ps2xRuntime/src/lib/Kernel/Syscalls/Sync.cpp | 942 ++------ .../src/lib/Kernel/Syscalls/System.cpp | 218 +- ps2xRuntime/src/lib/Kernel/Syscalls/System.h | 2 +- .../src/lib/Kernel/Syscalls/Thread.cpp | 1191 ++--------- ps2xRuntime/src/lib/ps2_debug_panel.cpp | 148 +- ps2xRuntime/src/lib/ps2_gs_gpu.cpp | 4 +- ps2xRuntime/src/lib/ps2_iop_host.cpp | 22 +- ps2xRuntime/src/lib/ps2_runtime.cpp | 489 ++--- ps2xRuntime/src/main.cpp | 79 +- ps2xTest/src/code_generator_tests.cpp | 61 +- ps2xTest/src/ps2_gs_tests.cpp | 154 +- ps2xTest/src/ps2_runtime_expansion_tests.cpp | 1290 ++--------- ps2xTest/src/ps2_runtime_interrupt_tests.cpp | 884 +++----- ps2xTest/src/ps2_runtime_kernel_tests.cpp | 1656 +++++++-------- ps2xTest/src/ps2_sif_dma_tests.cpp | 66 +- ps2xTest/src/ps2_sif_rpc_tests.cpp | 47 +- 41 files changed, 4991 insertions(+), 7383 deletions(-) create mode 100644 ps2xRuntime/include/runtime/ee_scheduler.h create mode 100644 ps2xRuntime/src/lib/Kernel/EeScheduler.cpp delete mode 100644 ps2xRuntime/src/lib/Kernel/Syscalls/Lifecycle.cpp delete mode 100644 ps2xRuntime/src/lib/Kernel/Syscalls/Lifecycle.h diff --git a/ps2xIOP/include/ps2x/iop/iop_types.h b/ps2xIOP/include/ps2x/iop/iop_types.h index f84da6509..37989ca7e 100644 --- a/ps2xIOP/include/ps2x/iop/iop_types.h +++ b/ps2xIOP/include/ps2x/iop/iop_types.h @@ -94,6 +94,9 @@ namespace ps2x::iop bool signalCompletion = false; CallbackPolicy callbackPolicy = CallbackPolicy::RuntimeDefault; ServerDispatchPolicy serverDispatchPolicy = ServerDispatchPolicy::RuntimeDefault; + uint32_t guestFunction = 0; + uint32_t guestArguments[4]{}; + uint32_t guestDefaultResultAddress = 0; }; enum class SifTransferKind : uint32_t diff --git a/ps2xIOP/src/modules/cri_dtx.cpp b/ps2xIOP/src/modules/cri_dtx.cpp index 839629b68..8014d3873 100644 --- a/ps2xIOP/src/modules/cri_dtx.cpp +++ b/ps2xIOP/src/modules/cri_dtx.cpp @@ -133,48 +133,26 @@ namespace ps2x::iop::detail const bool hasUrpcHandler = isUrpc && command < 64u && urpcFunction != 0u; if (hasUrpcHandler && request.serverFunction != 0u) { - uint32_t serverResult = 0u; - if (m_host.invokeGuestFunction(request.callToken, - request.serverFunction, - request.function, - request.serverBuffer, - request.send.size, - 0u, - &serverResult)) - { - result.handled = true; - result.resultAddress = serverResult; - if (result.resultAddress == 0u && request.serverBuffer != 0u) - { - result.resultAddress = request.serverBuffer; - } - if (result.resultAddress == 0u && request.receive.address != 0u) - { - result.resultAddress = request.receive.address; - } - return result; - } + result.guestFunction = request.serverFunction; + result.guestArguments[0] = request.function; + result.guestArguments[1] = request.serverBuffer; + result.guestArguments[2] = request.send.size; + result.guestDefaultResultAddress = request.serverBuffer != 0u + ? request.serverBuffer + : request.receive.address; + return result; } if (hasUrpcHandler && request.send.address != 0u && request.send.size > 0u) { - uint32_t dispatcherResult = 0u; - if (m_host.invokeGuestFunction(request.callToken, - m_bindings.dispatcherFunctionAddress, - request.function, - request.send.address, - request.send.size, - 0u, - &dispatcherResult)) - { - result.handled = true; - result.resultAddress = dispatcherResult != 0u - ? dispatcherResult - : request.send.address; - return result; - } + result.guestFunction = m_bindings.dispatcherFunctionAddress; + result.guestArguments[0] = request.function; + result.guestArguments[1] = request.send.address; + result.guestArguments[2] = request.send.size; + result.guestDefaultResultAddress = request.send.address; + return result; } if (request.function == 2u && diff --git a/ps2xRecomp/src/lib/control_flow_emitter.cpp b/ps2xRecomp/src/lib/control_flow_emitter.cpp index 315b8d8dc..4bf8dc550 100644 --- a/ps2xRecomp/src/lib/control_flow_emitter.cpp +++ b/ps2xRecomp/src/lib/control_flow_emitter.cpp @@ -177,7 +177,7 @@ namespace ps2recomp m_ss << fmt::format("{}ctx->pc = 0x{:X}u;\n", indent, target); if (target <= sourcePc && !isCallLikeEdge()) { - m_ss << fmt::format("{}if (runtime->shouldPreemptGuestExecution()) {{\n", indent); + m_ss << fmt::format("{}if (runtime->eeCheckpointDue()) {{\n", indent); m_ss << fmt::format("{} return;\n", indent); m_ss << fmt::format("{}}}\n", indent); } @@ -296,10 +296,16 @@ namespace ps2recomp const std::string_view handlerName = isSyscall ? resolvedSyscallName : resolvedStubName; m_ss << indent << "{\n"; - m_ss << indent << " const uint32_t __entryPc = ctx->pc;\n"; + if (kind == StaticBranchKind::Call) + { + m_ss << fmt::format("{} ctx->pc = 0x{:X}u;\n", indent, fallthroughPc()); + } + else + { + m_ss << indent << " ctx->pc = getRegU32(ctx, 31);\n"; + } m_ss << indent << " " << (isSyscall ? "ps2_syscalls::" : "ps2_stubs::") << handlerName << "(rdram, ctx, runtime);\n"; - m_ss << indent << " if (ctx->pc == __entryPc) { ctx->pc = getRegU32(ctx, 31); }\n"; m_ss << indent << "}\n"; if (kind == StaticBranchKind::Jump) diff --git a/ps2xRecomp/src/lib/function_emitter.cpp b/ps2xRecomp/src/lib/function_emitter.cpp index 53a6005e6..328c0e01a 100644 --- a/ps2xRecomp/src/lib/function_emitter.cpp +++ b/ps2xRecomp/src/lib/function_emitter.cpp @@ -226,7 +226,7 @@ namespace ps2recomp } } - // Fallthrough with no terminating branch: advance ctx->pc past the function so dispatchLoop doesn't re-call it forever. + // Fallthrough with no terminating branch: publish the next PC so the EE dispatcher does not re-enter this function. if (!instructions.empty() && !lastInstructionWasControlFlow) { ss << " ctx->pc = 0x" << std::hex << function.end << "u;\n" diff --git a/ps2xRecomp/src/lib/ps2_recompiler.cpp b/ps2xRecomp/src/lib/ps2_recompiler.cpp index df7e356da..36223c588 100644 --- a/ps2xRecomp/src/lib/ps2_recompiler.cpp +++ b/ps2xRecomp/src/lib/ps2_recompiler.cpp @@ -1078,7 +1078,7 @@ namespace ps2recomp stub << "#ifdef _DEBUG\n"; stub << " PS_LOG_ENTRY(\"" << generatedName << "\");\n"; stub << "#endif\n"; - stub << " const uint32_t __entryPc = ctx->pc;\n" + stub << " ctx->pc = getRegU32(ctx, 31);\n" << " "; if (function.isSkipped) @@ -1115,12 +1115,7 @@ namespace ps2recomp } } - stub << "\n" - << " if (ctx->pc == __entryPc)\n" - << " {\n" - << " ctx->pc = getRegU32(ctx, 31);\n" - << " }\n" - << "}"; + stub << "\n}"; m_generatedStubs[function.start] = stub.str(); } } diff --git a/ps2xRecomp/src/lib/special_translator.cpp b/ps2xRecomp/src/lib/special_translator.cpp index ab1ee5558..b01a93771 100644 --- a/ps2xRecomp/src/lib/special_translator.cpp +++ b/ps2xRecomp/src/lib/special_translator.cpp @@ -41,7 +41,9 @@ namespace ps2recomp case SPECIAL_JALR: return fmt::format("// JALR ${}, ${} - Handled by branch logic", inst.rd, inst.rs); case SPECIAL_SYSCALL: - return fmt::format("runtime->handleSyscall(rdram, ctx, 0x{:X}u);", (inst.raw >> 6) & 0xFFFFFu); + return fmt::format("ctx->pc = 0x{:X}u;\nruntime->handleSyscall(rdram, ctx, 0x{:X}u);", + inst.address + 4u, + (inst.raw >> 6) & 0xFFFFFu); case SPECIAL_BREAK: return fmt::format("runtime->handleBreak(rdram, ctx);"); case SPECIAL_SYNC: diff --git a/ps2xRuntime/include/ps2_runtime.h b/ps2xRuntime/include/ps2_runtime.h index dda11c1a6..da4a81b7a 100644 --- a/ps2xRuntime/include/ps2_runtime.h +++ b/ps2xRuntime/include/ps2_runtime.h @@ -17,11 +17,10 @@ #include #include #include -#include #include -#include -#include #include +#include +#include #include "ps2_log.h" #include "runtime/ps2_address.h" @@ -40,6 +39,8 @@ namespace ps2x::iop class PS2IopHostAdapter; class PS2IopTransport; +class EeScheduler; +struct EeEvent; enum PS2Exception { @@ -248,7 +249,6 @@ inline void ps2TraceGuestWrite(uint8_t *rdram, (void)valueHi; (void)op; (void)ctx; - // TODO we dont need this anymore so on next release it will be deleted } inline void ps2TraceGuestRangeWrite(uint8_t *rdram, @@ -262,7 +262,6 @@ inline void ps2TraceGuestRangeWrite(uint8_t *rdram, (void)size; (void)op; (void)ctx; - // TODO we dont need this anymore so on next release it will be deleted } class PS2Runtime @@ -321,46 +320,6 @@ class PS2Runtime SkipCallDebug = 3, }; - class GuestExecutionScope - { - public: - explicit GuestExecutionScope(PS2Runtime *runtime) noexcept; - ~GuestExecutionScope(); - - GuestExecutionScope(const GuestExecutionScope &) = delete; - GuestExecutionScope &operator=(const GuestExecutionScope &) = delete; - - private: - PS2Runtime *m_runtime = nullptr; - }; - - class GuestExecutionReleaseScope - { - public: - explicit GuestExecutionReleaseScope(PS2Runtime *runtime) noexcept; - ~GuestExecutionReleaseScope(); - - GuestExecutionReleaseScope(const GuestExecutionReleaseScope &) = delete; - GuestExecutionReleaseScope &operator=(const GuestExecutionReleaseScope &) = delete; - - private: - PS2Runtime *m_runtime = nullptr; - uint32_t m_depth = 0u; - }; - - class DeferredGuestYieldScope - { - public: - explicit DeferredGuestYieldScope(bool &pendingOut) noexcept; - ~DeferredGuestYieldScope(); - - DeferredGuestYieldScope(const DeferredGuestYieldScope &) = delete; - DeferredGuestYieldScope &operator=(const DeferredGuestYieldScope &) = delete; - - private: - bool &m_pendingOut; - }; - bool replaceFunction(uint32_t address, RecompiledFunction func); // TODO remove this later need to update all tests bool registerFunction(uint32_t address, RecompiledFunction func); @@ -413,31 +372,27 @@ class PS2Runtime uint32_t guestHeapLimit() const; uint32_t reserveAsyncCallbackStack(uint32_t size, uint32_t alignment = 16u); - void dispatchLoop(uint8_t *rdram, R5900Context *ctx); - void drainCompletedDmacHandlers(uint8_t *rdram); - bool shouldPreemptGuestExecution(); - void yieldGuestExecutionAfterWake(); - void waitForGuestExecutionHandoff(); - void waitForGuestExecutionHandoff(uint64_t baselineEpoch); - uint64_t guestExecutionHandoffEpochSnapshot() const - { - return m_guestExecutionHandoffEpoch.load(std::memory_order_acquire); - } - void requestStop(); bool isStopRequested() const; - uint32_t guestExecutionWaiterCountForTesting() const - { - return m_guestExecutionWaiters.load(std::memory_order_acquire); - } + EeScheduler &eeScheduler(); + const EeScheduler &eeScheduler() const; + void postEeEvent(EeEvent event); + bool eeCheckpointDue() const noexcept; - uint64_t guestExecutionHandoffTimeouts() const + struct EeExitHandlerRegistration { - return m_guestExecutionHandoffTimeouts.load(std::memory_order_relaxed); - } + uint32_t function = 0; + uint32_t argument = 0; + }; + void addEeExitHandler(int threadId, uint32_t function, uint32_t argument); + std::vector takeEeExitHandlers(int threadId); + void removeEeExitHandlers(int threadId); + bool findEeSyscallOverride(uint32_t syscallNumber, uint32_t &handler) const; + void setEeSyscallOverride(uint8_t *rdram, uint32_t syscallNumber, uint32_t handler); + void initializeEeKernelState(uint8_t *rdram); uint8_t Load8(uint8_t *rdram, R5900Context *ctx, uint32_t vaddr); uint16_t Load16(uint8_t *rdram, R5900Context *ctx, uint32_t vaddr); @@ -502,12 +457,6 @@ class PS2Runtime uint32_t allocateGuestBlockLocked(uint32_t size, uint32_t alignment); void freeGuestBlockLocked(uint32_t guestAddr); void coalesceGuestHeapLocked(); - void enterGuestExecution(); - void leaveGuestExecution(); - uint32_t releaseGuestExecution(); - void reacquireGuestExecution(uint32_t depth); - void markGuestExecutionAcquired(); - void HandleIntegerOverflow(R5900Context *ctx); [[nodiscard]] ps2x::iop::RpcAbi selectIopRpcAbi(const ps2x::iop::RpcAbiRequest &request) const; @@ -515,9 +464,8 @@ class PS2Runtime void notifyIopSifTransfer(uint8_t *rdram, const ps2x::iop::SifTransfer &transfer); void resetIop(); - friend class GuestExecutionScope; - friend class GuestExecutionReleaseScope; friend class PS2IopTransport; + friend class EeScheduler; private: PS2Memory m_memory; @@ -530,12 +478,11 @@ class PS2Runtime VU1Interpreter m_vu0; VU1Interpreter m_vu1; R5900Context m_cpuContext; - mutable std::recursive_mutex m_guestExecutionMutex; - mutable std::atomic m_guestExecutionWaiters{0u}; - mutable std::mutex m_guestExecutionHandoffMutex; - mutable std::condition_variable m_guestExecutionHandoffCv; - std::atomic m_guestExecutionHandoffEpoch{0u}; - std::atomic m_guestExecutionHandoffTimeouts{0u}; + std::unique_ptr m_eeScheduler; + mutable std::mutex m_eeKernelStateMutex; + std::unordered_map> m_eeExitHandlers; + std::unordered_map m_eeSyscallOverrides; + std::unordered_set m_eeSyscallMirrorAddresses; mutable std::mutex m_guestHeapMutex; mutable std::mutex m_asyncCallbackStackMutex; std::vector m_guestHeapBlocks; diff --git a/ps2xRuntime/include/ps2_syscalls.h b/ps2xRuntime/include/ps2_syscalls.h index e23795bb1..0360e606a 100644 --- a/ps2xRuntime/include/ps2_syscalls.h +++ b/ps2xRuntime/include/ps2_syscalls.h @@ -11,8 +11,6 @@ std::string translatePs2Path(const char *ps2Path); -extern std::atomic g_activeThreads; - inline std::mutex g_sys_fd_mutex; namespace ps2_syscalls @@ -29,15 +27,10 @@ namespace ps2_syscalls bool dispatchNumericSyscall(uint32_t syscallNumber, uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime); void dispatchDmacHandlersForCause(uint8_t *rdram, PS2Runtime *runtime, uint32_t cause); - void initializeGuestKernelState(uint8_t *rdram); + void initializeGuestKernelState(uint8_t *rdram, PS2Runtime *runtime); void TODO(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime, uint32_t encodedSyscallId); - void notifyRuntimeStop(); - void joinAllGuestHostThreads(); - void detachAllGuestHostThreads(); - void EnsureVSyncWorkerRunning(uint8_t *rdram, PS2Runtime *runtime); - uint64_t GetCurrentVSyncTick(); - uint64_t WaitForNextVSyncTick(uint8_t *rdram, PS2Runtime *runtime); - void WaitVSyncTick(uint8_t *rdram, PS2Runtime *runtime); + uint64_t GetCurrentVSyncTick(PS2Runtime *runtime); + void WaitVSyncTick(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime, int fixedResult = -1); } #endif // PS2_SYSCALLS_H diff --git a/ps2xRuntime/include/runtime/ee_scheduler.h b/ps2xRuntime/include/runtime/ee_scheduler.h new file mode 100644 index 000000000..8fb1e263a --- /dev/null +++ b/ps2xRuntime/include/runtime/ee_scheduler.h @@ -0,0 +1,435 @@ +#pragma once + +#include "ps2_runtime.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// This exception is the EE equivalent of a longjmp to the dispatcher. It is +// not an error and must only be caught at EeScheduler::run(). +struct EeDispatcherTransfer final +{ +}; + +enum class EeThreadStatus : uint8_t +{ + Running, + Ready, + Waiting, + WaitingSuspended, + Suspended, + Dormant, +}; + +enum class EeWaitReason : uint8_t +{ + None, + Sleep, + Semaphore, + EventFlag, + VSync, + External, + Mpeg, +}; + +struct EeSemaphoreWait +{ + int id = 0; +}; + +struct EeEventFlagWait +{ + int id = 0; + uint32_t bits = 0; + uint32_t mode = 0; + uint32_t resultAddress = 0; +}; + +struct EeVSyncWait +{ + uint64_t afterTick = 0; + int fixedResult = -1; +}; + +struct EeExternalWait +{ + uint32_t type = 0; + uint64_t token = 0; +}; + +using EeWaitPayload = std::variant; + +struct EeWaitState +{ + EeWaitReason reason = EeWaitReason::None; + EeWaitPayload payload{}; + std::function completion; +}; + +enum class GuestInvocationKind : uint8_t +{ + Interrupt, + Alarm, + GsCallback, + RpcCallback, + SyscallOverride, + ExitHandler, + HleCall, +}; + +struct GuestInvocation +{ + GuestInvocationKind kind = GuestInvocationKind::Interrupt; + uint64_t sequence = 0; + uint64_t tag = 0; + R5900Context context{}; + std::function onComplete; +}; + +struct GuestThread +{ + int id = 0; + R5900Context context{}; + uint32_t entry = 0; + uint32_t stack = 0; + uint32_t stackSize = 0; + uint32_t gp = 0; + uint32_t attr = 0; + uint32_t option = 0; + uint32_t arg = 0; + int initialPriority = 0; + int currentPriority = 0; + EeThreadStatus status = EeThreadStatus::Dormant; + int suspendCount = 0; + uint32_t wakeupCount = 0; + bool ownsStack = false; + uint32_t tlsBase = 0; + EeWaitState wait{}; + std::function resumeCompletion; + std::vector invocations; + + [[nodiscard]] R5900Context &activeContext() + { + return invocations.empty() ? context : invocations.back().context; + } + + [[nodiscard]] const R5900Context &activeContext() const + { + return invocations.empty() ? context : invocations.back().context; + } +}; + +struct EeSemaphore +{ + int id = 0; + int count = 0; + int maxCount = 0; + int initCount = 0; + uint32_t attr = 0; + uint32_t option = 0; + std::deque waiters; +}; + +struct EeEventFlag +{ + int id = 0; + uint32_t attr = 0; + uint32_t option = 0; + uint32_t initBits = 0; + uint32_t bits = 0; + std::deque waiters; +}; + +struct EeAlarm +{ + int id = 0; + uint16_t ticks = 0; + uint32_t handler = 0; + uint32_t argument = 0; + uint32_t gp = 0; + uint32_t sp = 0; +}; + +struct EeIrqHandler +{ + int id = 0; + uint32_t cause = 0; + uint32_t handler = 0; + uint32_t argument = 0; + uint32_t gp = 0; + uint32_t sp = 0; + bool enabled = true; + int order = 0; +}; + +struct EeThreadSnapshot +{ + int id = 0; + uint32_t pc = 0; + uint32_t entry = 0; + uint32_t stack = 0; + uint32_t stackSize = 0; + uint32_t gp = 0; + int initialPriority = 0; + int currentPriority = 0; + EeThreadStatus status = EeThreadStatus::Dormant; + EeWaitReason waitReason = EeWaitReason::None; + int waitId = 0; + int suspendCount = 0; + uint32_t wakeupCount = 0; +}; + +struct EeSemaphoreSnapshot +{ + int id = 0; + int count = 0; + int maxCount = 0; + uint32_t waiters = 0; +}; + +struct EeEventFlagSnapshot +{ + int id = 0; + uint32_t bits = 0; + uint32_t initBits = 0; + uint32_t attr = 0; + uint32_t waiters = 0; +}; + +struct EeKernelSnapshot +{ + uint64_t sequence = 0; + int runningThreadId = 0; + std::vector threads; + std::vector semaphores; + std::vector eventFlags; +}; + +enum class EeEventType : uint8_t +{ + Stop, + VBlankStart, + VBlankEnd, + Dmac, + ExternalWake, + Alarm, +}; + +struct EeEvent +{ + EeEventType type = EeEventType::ExternalWake; + uint32_t id = 0; + uint64_t value = 0; +}; + +struct EeThreadCreateParams +{ + uint32_t attr = 0; + uint32_t entry = 0; + uint32_t stack = 0; + uint32_t stackSize = 0; + uint32_t gp = 0; + int priority = 0; + uint32_t option = 0; +}; + +class EeScheduler +{ +public: + static constexpr int kMainThreadId = 1; + static constexpr int kFirstThreadId = 2; + static constexpr int kLastThreadId = 255; + static constexpr int kPriorityCount = 128; + + explicit EeScheduler(PS2Runtime &runtime); + ~EeScheduler(); + + EeScheduler(const EeScheduler &) = delete; + EeScheduler &operator=(const EeScheduler &) = delete; + + void reset(uint8_t *rdram, const R5900Context &mainContext); + void run(); + void requestStop(); + void postEvent(EeEvent event); + [[nodiscard]] bool checkpointDue() const noexcept; + [[nodiscard]] bool isExecutingGuest() const noexcept; + + // Kernel object API. All calls except postEvent/requestStop execute on the + // EE executor and therefore need no host synchronization. + int createThread(const EeThreadCreateParams ¶ms); + int deleteThread(int id, uint32_t &ownedStack); + int startThread(int id, uint32_t arg, const R5900Context &caller, bool interruptSafe); + [[noreturn]] void exitCurrent(bool deleteThread); + int terminateThread(int id, uint32_t &ownedStack, bool interruptSafe); + int suspendThread(int id, bool interruptSafe); + int resumeThread(int id, bool interruptSafe); + void sleepCurrent(); + int wakeupThread(int id, bool interruptSafe); + int cancelWakeup(int id); + int changePriority(int id, int priority, bool interruptSafe, int &oldPriority); + int rotateReadyQueue(int priority, bool interruptSafe); + int releaseWait(int id, bool interruptSafe); + void transferIfRequested(bool interruptSafe); + + int createSemaphore(int initCount, int maxCount, uint32_t attr, uint32_t option); + int deleteSemaphore(int id, bool interruptSafe); + int signalSemaphore(int id, bool interruptSafe); + int pollSemaphore(int id); + void waitSemaphore(int id); + + int createEventFlag(uint32_t initialBits, uint32_t attr, uint32_t option); + int deleteEventFlag(int id, bool interruptSafe); + int setEventFlag(int id, uint32_t bits, bool interruptSafe); + int clearEventFlag(int id, uint32_t mask); + int pollEventFlag(int id, uint32_t bits, uint32_t mode, uint32_t &observedBits); + void waitEventFlag(int id, uint32_t bits, uint32_t mode, uint32_t resultAddress); + + int setAlarm(uint16_t ticks, uint32_t handler, uint32_t argument, uint32_t gp, uint32_t sp); + int cancelAlarm(int id); + void queueInvocation(GuestInvocation invocation); + [[noreturn]] void invokeCurrent(GuestInvocation invocation); + [[noreturn]] void invokeCurrentSequence(std::vector invocations); + [[nodiscard]] bool hasInvocation(GuestInvocationKind kind, uint64_t tag) const; + [[nodiscard]] uint32_t invocationStackTop(); + + int addIrqHandler(bool dmac, + uint32_t cause, + uint32_t handler, + bool append, + uint32_t argument, + uint32_t gp, + uint32_t sp); + int removeIrqHandler(bool dmac, uint32_t cause, int id); + int setIrqHandlerEnabled(bool dmac, int id, bool enabled); + int setIrqCauseEnabled(bool dmac, uint32_t cause, bool enabled); + void dispatchIrq(bool dmac, uint32_t cause); + void setVSyncFlag(uint32_t flagAddress, uint32_t tickAddress); + [[nodiscard]] uint64_t currentVSyncTick() const noexcept; + uint32_t setGsVSyncCallback(uint32_t callback, uint32_t gp, uint32_t sp); + + [[noreturn]] void waitVSync(uint64_t afterTick, int fixedResult = -1); + void completeVSync(uint64_t tick); + void completeExternalWait(uint32_t type, uint64_t token, int result); + [[noreturn]] void waitExternal(EeWaitReason reason, + uint32_t type, + uint64_t token, + std::function completion = {}); + + [[nodiscard]] GuestThread *thread(int id); + [[nodiscard]] const GuestThread *thread(int id) const; + [[nodiscard]] EeSemaphore *semaphore(int id); + [[nodiscard]] const EeSemaphore *semaphore(int id) const; + [[nodiscard]] EeEventFlag *eventFlag(int id); + [[nodiscard]] const EeEventFlag *eventFlag(int id) const; + [[nodiscard]] GuestThread *currentThread(); + [[nodiscard]] const GuestThread *currentThread() const; + [[nodiscard]] int currentThreadId() const noexcept; + [[nodiscard]] R5900Context *currentContext(); + [[nodiscard]] uint8_t *rdram() const noexcept; + + // Direct syscall tests use the same main-thread record without starting a + // second executor. Production execution calls reset() before run(). + void bindMainContextForSyscall(R5900Context &ctx, uint8_t *rdram); + + [[nodiscard]] EeKernelSnapshot snapshot() const; + void publishSnapshot(); + +private: + struct ScheduledEvent + { + std::chrono::steady_clock::time_point deadline{}; + EeEvent event{}; + uint64_t sequence = 0; + }; + + void assertExecutor() const; + [[nodiscard]] int allocateThreadId(); + GuestThread &acquireInvocationThread(); + void enqueueReady(GuestThread &thread, bool front = false); + void removeReady(GuestThread &thread); + [[nodiscard]] GuestThread *selectReady(); + void makeRunning(GuestThread &thread); + void makeDormant(GuestThread &thread); + void removeFromWaitObject(GuestThread &thread); + [[noreturn]] void blockCurrent(EeWaitState wait); + void makeReady(GuestThread &thread, int result, bool interruptSafe); + void requestPreemptionIfHigher(const GuestThread &readyThread, bool interruptSafe); + void applyPendingPreemption(); + void processPendingEvents(); + void processDueDeadlines(); + void processEvent(const EeEvent &event); + void finishEventWaiters(EeEventFlag &flag, bool interruptSafe); + [[nodiscard]] static bool eventCondition(uint32_t current, uint32_t requested, uint32_t mode); + static int waitObjectId(const EeWaitState &wait); + void writeGuestU32(uint32_t address, uint32_t value); + void waitForEvent(); + void scheduleEvent(std::chrono::steady_clock::time_point deadline, EeEvent event); + void updateNextDeadline(); + void copyMainContextToRuntime(); + + PS2Runtime &m_runtime; + uint8_t *m_rdram = nullptr; + std::array, kPriorityCount> m_readyQueues{}; + std::unordered_map m_threads; + std::unordered_map m_semaphores; + std::unordered_map m_eventFlags; + std::unordered_map m_alarms; + std::unordered_map m_intcHandlers; + std::unordered_map m_dmacHandlers; + int m_nextThreadId = kFirstThreadId; + int m_nextInvocationThreadId = -1; + int m_nextSemaphoreId = 1; + int m_nextEventFlagId = 1; + int m_nextAlarmId = 1; + int m_nextIntcHandlerId = 1; + int m_nextDmacHandlerId = 1; + int m_intcHeadOrder = 0; + int m_intcTailOrder = 1000; + int m_dmacHeadOrder = 0; + int m_dmacTailOrder = 1000; + uint32_t m_enabledIntcMask = 0xFFFFFFFFu; + uint32_t m_enabledDmacMask = 0xFFFFFFFFu; + int m_currentThreadId = 0; + bool m_rescheduleRequested = false; + bool m_insideInterrupt = false; + std::thread::id m_executorThread{}; + std::atomic m_running{false}; + std::atomic m_guestExecuting{false}; + std::atomic m_stopRequested{false}; + std::atomic m_checkpointPending{false}; + + mutable std::mutex m_eventMutex; + std::condition_variable m_eventCv; + std::deque m_events; + std::vector m_deadlines; + std::deque m_pendingInvocations; + uint64_t m_eventSequence = 0; + uint64_t m_invocationSequence = 0; + uint64_t m_vsyncTick = 0; + uint32_t m_vsyncFlagAddress = 0; + uint32_t m_vsyncTickAddress = 0; + uint32_t m_gsVSyncCallback = 0; + uint32_t m_gsVSyncCallbackGp = 0; + uint32_t m_gsVSyncCallbackSp = 0; + std::unordered_map m_invocationStackTops; + std::atomic m_nextDeadlineNanoseconds{0}; + + mutable std::mutex m_snapshotMutex; + EeKernelSnapshot m_snapshot; + uint64_t m_snapshotSequence = 0; +}; diff --git a/ps2xRuntime/include/runtime/ps2_memory.h b/ps2xRuntime/include/runtime/ps2_memory.h index 30fc455bd..cd96b5a74 100644 --- a/ps2xRuntime/include/runtime/ps2_memory.h +++ b/ps2xRuntime/include/runtime/ps2_memory.h @@ -204,20 +204,16 @@ struct GSRegisters uint64_t extdata; // External data uint64_t extwrite; // External write uint64_t bgcolor; // Background color - // Status. Concurrency contract: the vsync worker thread toggles the FIELD bit - // (bit 13) once per tick; guest threads issue write-one-to-clear writes against - // the SIGNAL/FINISH status bits (0..1) via the MMIO path; the GIF sets SIGNAL - // and FINISH from yet another thread. All three interleave, so this register - // must be updated with atomic RMWs only (no load-then-store pairs anywhere). + // Status remains atomic because the renderer/UI can observe it while the + // single EE executor updates SIGNAL, FINISH and FIELD. std::atomic csr; + std::atomic vsyncTick; uint64_t imr; // Interrupt mask uint64_t busdir; // Bus direction uint64_t siglblid; // Signal label ID }; -static_assert(sizeof(GSRegisters) == (19u * sizeof(uint64_t)), "GSRegisters layout changed unexpectedly"); +static_assert(sizeof(GSRegisters) == (20u * sizeof(uint64_t)), "GSRegisters layout changed unexpectedly"); static_assert(alignof(GSRegisters) == alignof(uint64_t), "GSRegisters alignment must remain 64-bit"); -// CSR is written by the vsync worker while guest threads concurrently read/write it -// (MMIO) and the GIF sets SIGNAL/FINISH; a lock-free atomic keeps that path wait-free. static_assert(std::atomic::is_always_lock_free, "GS CSR atomic must be lock-free on all supported targets"); // PS2 VIF (VPU Interface) registers diff --git a/ps2xRuntime/src/lib/Kernel/EeScheduler.cpp b/ps2xRuntime/src/lib/Kernel/EeScheduler.cpp new file mode 100644 index 000000000..9901f0147 --- /dev/null +++ b/ps2xRuntime/src/lib/Kernel/EeScheduler.cpp @@ -0,0 +1,1886 @@ +#include "runtime/ee_scheduler.h" + +#include "ps2_log.h" +#include "ps2_runtime_macros.h" + +#include +#include +#include +#include +#include + +namespace +{ + constexpr int KE_OK = 0; + constexpr int KE_ERROR = -1; + constexpr int KE_ILLEGAL_PRIORITY = -403; + constexpr int KE_ILLEGAL_THID = -406; + constexpr int KE_UNKNOWN_THID = -407; + constexpr int KE_UNKNOWN_SEMID = -408; + constexpr int KE_UNKNOWN_EVFID = -409; + constexpr int KE_DORMANT = -413; + constexpr int KE_NOT_DORMANT = -414; + constexpr int KE_NOT_SUSPEND = -415; + constexpr int KE_NOT_WAIT = -416; + constexpr int KE_RELEASE_WAIT = -418; + constexpr int KE_SEMA_ZERO = -419; + constexpr int KE_SEMA_OVF = -420; + constexpr int KE_EVF_COND = -421; + constexpr int KE_WAIT_DELETE = -425; + + constexpr uint32_t WEF_OR = 0x01u; + constexpr uint32_t WEF_CLEAR = 0x10u; + constexpr uint32_t WEF_CLEAR_ALL = 0x20u; + constexpr auto kVBlankPeriod = std::chrono::microseconds(16667); + constexpr auto kVBlankDuration = std::chrono::microseconds(500); + constexpr uint64_t kAlarmTickMicroseconds = 64u; + + template + int allocatePositiveId(int &nextId, const Map &objects) + { + const int first = std::max(1, nextId); + int candidate = first; + do + { + if (!objects.contains(candidate)) + { + nextId = (candidate == std::numeric_limits::max()) ? 1 : candidate + 1; + return candidate; + } + candidate = (candidate == std::numeric_limits::max()) ? 1 : candidate + 1; + } while (candidate != first); + return 0; + } +} + +EeScheduler::EeScheduler(PS2Runtime &runtime) + : m_runtime(runtime) +{ +} + +EeScheduler::~EeScheduler() +{ + requestStop(); +} + +void EeScheduler::reset(uint8_t *rdram, const R5900Context &mainContext) +{ + m_executorThread = std::this_thread::get_id(); + m_rdram = rdram; + m_readyQueues = {}; + m_threads.clear(); + m_semaphores.clear(); + m_eventFlags.clear(); + m_alarms.clear(); + m_intcHandlers.clear(); + m_dmacHandlers.clear(); + m_nextThreadId = kFirstThreadId; + m_nextInvocationThreadId = -1; + m_nextSemaphoreId = 1; + m_nextEventFlagId = 1; + m_nextAlarmId = 1; + m_nextIntcHandlerId = 1; + m_nextDmacHandlerId = 1; + m_intcHeadOrder = 0; + m_intcTailOrder = 1000; + m_dmacHeadOrder = 0; + m_dmacTailOrder = 1000; + m_enabledIntcMask = 0xFFFFFFFFu; + m_enabledDmacMask = 0xFFFFFFFFu; + m_currentThreadId = 0; + m_rescheduleRequested = false; + m_insideInterrupt = false; + m_stopRequested.store(false, std::memory_order_release); + m_checkpointPending.store(false, std::memory_order_release); + { + std::lock_guard lock(m_eventMutex); + m_events.clear(); + m_deadlines.clear(); + m_pendingInvocations.clear(); + } + m_eventSequence = 0; + m_invocationSequence = 0; + m_vsyncTick = 0; + m_vsyncFlagAddress = 0; + m_vsyncTickAddress = 0; + m_gsVSyncCallback = 0; + m_gsVSyncCallbackGp = 0; + m_gsVSyncCallbackSp = 0; + m_runtime.memory().gs().vsyncTick.store(0u, std::memory_order_release); + + GuestThread main{}; + main.id = kMainThreadId; + main.context = mainContext; + main.entry = mainContext.pc; + main.stack = getRegU32(&mainContext, 29); + main.gp = getRegU32(&mainContext, 28); + main.initialPriority = 0; + main.currentPriority = 0; + main.status = EeThreadStatus::Ready; + m_threads.emplace(main.id, std::move(main)); + m_readyQueues[0].push_back(kMainThreadId); + scheduleEvent(std::chrono::steady_clock::now() + kVBlankPeriod, + EeEvent{EeEventType::VBlankStart, 0, 0}); + publishSnapshot(); +} + +void EeScheduler::run() +{ + assertExecutor(); + m_running.store(true, std::memory_order_release); + + while (!m_stopRequested.load(std::memory_order_acquire)) + { + processPendingEvents(); + if (m_stopRequested.load(std::memory_order_acquire)) + { + break; + } + + if (m_currentThreadId == 0) + { + GuestThread *next = selectReady(); + if (!next && m_pendingInvocations.empty()) + { + publishSnapshot(); + waitForEvent(); + continue; + } + if (next) + { + makeRunning(*next); + } + else + { + GuestThread *owner = &acquireInvocationThread(); + GuestInvocation invocation = std::move(m_pendingInvocations.front()); + m_pendingInvocations.pop_front(); + owner->status = EeThreadStatus::Running; + m_currentThreadId = owner->id; + if (getRegU32(&invocation.context, 29) == 0u) + { + SET_GPR_U32(&invocation.context, 29, invocationStackTop()); + } + owner->invocations.push_back(std::move(invocation)); + } + } + + GuestThread *running = currentThread(); + assert(running != nullptr); + if (running->resumeCompletion) + { + auto completion = std::move(running->resumeCompletion); + running->resumeCompletion = {}; + try + { + completion(running->activeContext()); + } + catch (const EeDispatcherTransfer &) + { + } + if (m_currentThreadId == 0) + { + continue; + } + } + R5900Context &context = running->activeContext(); + copyMainContextToRuntime(); + publishSnapshot(); + + m_runtime.m_debugPc.store(context.pc, std::memory_order_relaxed); + m_runtime.m_debugRa.store(getRegU32(&context, 31), std::memory_order_relaxed); + m_runtime.m_debugSp.store(getRegU32(&context, 29), std::memory_order_relaxed); + m_runtime.m_debugGp.store(getRegU32(&context, 28), std::memory_order_relaxed); + + if (context.pc == 0u) + { + if (!running->invocations.empty()) + { + GuestInvocation completed = std::move(running->invocations.back()); + running->invocations.pop_back(); + if (completed.onComplete) + { + try + { + completed.onComplete(completed.context, running->activeContext()); + } + catch (const EeDispatcherTransfer &) + { + } + } + continue; + } + makeDormant(*running); + m_currentThreadId = 0; + continue; + } + + if (!m_pendingInvocations.empty()) + { + GuestInvocation invocation = std::move(m_pendingInvocations.front()); + m_pendingInvocations.pop_front(); + if (getRegU32(&invocation.context, 29) == 0u) + { + SET_GPR_U32(&invocation.context, 29, invocationStackTop()); + } + running->invocations.push_back(std::move(invocation)); + continue; + } + + if (!m_runtime.hasFunction(context.pc)) + { + if (!running->invocations.empty()) + { + context.pc = 0u; + } + else + { + m_runtime.reportMissingFunction(m_rdram, + &context, + context.pc, + context.pc, + PS2Runtime::GuestBranchKind::DirectJump, + "EE scheduler"); + makeDormant(*running); + m_currentThreadId = 0; + } + continue; + } + PS2Runtime::RecompiledFunction function = m_runtime.lookupFunction(context.pc); + + try + { + m_insideInterrupt = !running->invocations.empty() && + running->invocations.back().kind == GuestInvocationKind::Interrupt; + m_checkpointPending.store(false, std::memory_order_release); + m_guestExecuting.store(true, std::memory_order_release); + function(m_rdram, &context, &m_runtime); + m_guestExecuting.store(false, std::memory_order_release); + m_insideInterrupt = false; + } + catch (const EeDispatcherTransfer &) + { + m_guestExecuting.store(false, std::memory_order_release); + m_insideInterrupt = false; + } + catch (...) + { + m_guestExecuting.store(false, std::memory_order_release); + m_running.store(false, std::memory_order_release); + publishSnapshot(); + throw; + } + + processPendingEvents(); + if (m_rescheduleRequested && m_currentThreadId != 0) + { + GuestThread *preempted = currentThread(); + assert(preempted != nullptr); + enqueueReady(*preempted, true); + m_currentThreadId = 0; + m_rescheduleRequested = false; + } + } + + m_guestExecuting.store(false, std::memory_order_release); + m_running.store(false, std::memory_order_release); + copyMainContextToRuntime(); + publishSnapshot(); +} + +void EeScheduler::requestStop() +{ + m_stopRequested.store(true, std::memory_order_release); + m_checkpointPending.store(true, std::memory_order_release); + m_eventCv.notify_all(); +} + +void EeScheduler::postEvent(EeEvent event) +{ + if (event.type == EeEventType::Stop) + { + requestStop(); + return; + } + + { + std::lock_guard lock(m_eventMutex); + m_events.push_back(event); + } + m_checkpointPending.store(true, std::memory_order_release); + m_eventCv.notify_one(); +} + +bool EeScheduler::checkpointDue() const noexcept +{ + if (m_checkpointPending.load(std::memory_order_acquire) || + m_stopRequested.load(std::memory_order_acquire)) + { + return true; + } + const int64_t deadline = m_nextDeadlineNanoseconds.load(std::memory_order_acquire); + if (deadline == 0) + { + return false; + } + const int64_t now = std::chrono::duration_cast( + std::chrono::steady_clock::now().time_since_epoch()) + .count(); + return now >= deadline; +} + +bool EeScheduler::isExecutingGuest() const noexcept +{ + return m_guestExecuting.load(std::memory_order_acquire); +} + +int EeScheduler::createThread(const EeThreadCreateParams ¶ms) +{ + assertExecutor(); + if (params.priority < 1 || params.priority >= kPriorityCount) + { + return KE_ILLEGAL_PRIORITY; + } + + const int id = allocateThreadId(); + if (id == 0) + { + return KE_ERROR; + } + + GuestThread thread{}; + thread.id = id; + thread.entry = params.entry; + thread.stack = params.stack; + thread.stackSize = params.stackSize; + thread.gp = params.gp; + thread.attr = params.attr; + thread.option = params.option; + thread.initialPriority = params.priority; + thread.currentPriority = params.priority; + thread.status = EeThreadStatus::Dormant; + m_threads.emplace(id, std::move(thread)); + publishSnapshot(); + return id; +} + +int EeScheduler::deleteThread(int id, uint32_t &ownedStack) +{ + assertExecutor(); + ownedStack = 0; + if (id <= kMainThreadId) + { + return KE_ILLEGAL_THID; + } + auto it = m_threads.find(id); + if (it == m_threads.end()) + { + return KE_UNKNOWN_THID; + } + if (it->second.status != EeThreadStatus::Dormant) + { + return KE_NOT_DORMANT; + } + if (it->second.ownsStack) + { + ownedStack = it->second.stack; + } + m_threads.erase(it); + publishSnapshot(); + return KE_OK; +} + +int EeScheduler::startThread(int id, uint32_t arg, const R5900Context &caller, bool interruptSafe) +{ + assertExecutor(); + GuestThread *target = thread(id); + if (!target) + { + return KE_UNKNOWN_THID; + } + if (target->status != EeThreadStatus::Dormant) + { + return KE_NOT_DORMANT; + } + + target->context = R5900Context{}; + target->context.pc = target->entry; + target->arg = arg; + target->suspendCount = 0; + target->wakeupCount = 0; + target->wait = {}; + SET_GPR_U32(&target->context, 4, arg); + SET_GPR_U32(&target->context, 28, target->gp != 0u ? target->gp : getRegU32(&caller, 28)); + const uint32_t stackTop = target->stack != 0u + ? (target->stack + target->stackSize) & ~0xFu + : getRegU32(&caller, 29); + SET_GPR_U32(&target->context, 29, stackTop); + SET_GPR_U32(&target->context, 31, 0u); + enqueueReady(*target); + requestPreemptionIfHigher(*target, interruptSafe); + publishSnapshot(); + return KE_OK; +} + +[[noreturn]] void EeScheduler::exitCurrent(bool deleteThreadRecord) +{ + assertExecutor(); + GuestThread *exiting = currentThread(); + assert(exiting != nullptr); + const int id = exiting->id; + const uint32_t ownedStack = deleteThreadRecord && exiting->ownsStack ? exiting->stack : 0u; + makeDormant(*exiting); + m_currentThreadId = 0; + if (deleteThreadRecord && id != kMainThreadId) + { + m_threads.erase(id); + } + if (ownedStack != 0u) + { + m_runtime.guestFree(ownedStack); + } + publishSnapshot(); + throw EeDispatcherTransfer{}; +} + +int EeScheduler::terminateThread(int id, uint32_t &ownedStack, bool interruptSafe) +{ + assertExecutor(); + ownedStack = 0; + if (id == 0 || id == m_currentThreadId) + { + return KE_ILLEGAL_THID; + } + GuestThread *target = thread(id); + if (!target) + { + return KE_UNKNOWN_THID; + } + if (target->status == EeThreadStatus::Dormant) + { + return KE_DORMANT; + } + if (target->ownsStack) + { + ownedStack = target->stack; + target->ownsStack = false; + } + makeDormant(*target); + (void)interruptSafe; + publishSnapshot(); + return KE_OK; +} + +int EeScheduler::suspendThread(int id, bool interruptSafe) +{ + assertExecutor(); + if (id == 0) + { + id = m_currentThreadId; + } + GuestThread *target = thread(id); + if (!target) + { + return KE_UNKNOWN_THID; + } + if (target->status == EeThreadStatus::Dormant) + { + return KE_DORMANT; + } + + ++target->suspendCount; + switch (target->status) + { + case EeThreadStatus::Running: + target->status = EeThreadStatus::Suspended; + m_currentThreadId = 0; + m_rescheduleRequested = true; + break; + case EeThreadStatus::Ready: + removeReady(*target); + target->status = EeThreadStatus::Suspended; + break; + case EeThreadStatus::Waiting: + target->status = EeThreadStatus::WaitingSuspended; + break; + case EeThreadStatus::WaitingSuspended: + case EeThreadStatus::Suspended: + break; + case EeThreadStatus::Dormant: + break; + } + if (interruptSafe && m_insideInterrupt) + { + m_rescheduleRequested = true; + } + publishSnapshot(); + return KE_OK; +} + +int EeScheduler::resumeThread(int id, bool interruptSafe) +{ + assertExecutor(); + if (id == 0) + { + return KE_ILLEGAL_THID; + } + GuestThread *target = thread(id); + if (!target) + { + return KE_UNKNOWN_THID; + } + if (target->suspendCount == 0) + { + return KE_NOT_SUSPEND; + } + --target->suspendCount; + if (target->suspendCount != 0) + { + return KE_OK; + } + if (target->status == EeThreadStatus::WaitingSuspended) + { + target->status = EeThreadStatus::Waiting; + } + else if (target->status == EeThreadStatus::Suspended) + { + enqueueReady(*target); + requestPreemptionIfHigher(*target, interruptSafe); + } + publishSnapshot(); + return KE_OK; +} + +void EeScheduler::sleepCurrent() +{ + assertExecutor(); + GuestThread *self = currentThread(); + assert(self != nullptr); + if (self->wakeupCount != 0u) + { + --self->wakeupCount; + setReturnS32(&self->activeContext(), KE_OK); + return; + } + blockCurrent(EeWaitState{EeWaitReason::Sleep, std::monostate{}}); +} + +int EeScheduler::wakeupThread(int id, bool interruptSafe) +{ + assertExecutor(); + if (id == 0 || id == m_currentThreadId) + { + return KE_ILLEGAL_THID; + } + GuestThread *target = thread(id); + if (!target) + { + return KE_UNKNOWN_THID; + } + if (target->status == EeThreadStatus::Dormant) + { + return KE_DORMANT; + } + if ((target->status == EeThreadStatus::Waiting || target->status == EeThreadStatus::WaitingSuspended) && + target->wait.reason == EeWaitReason::Sleep) + { + makeReady(*target, KE_OK, interruptSafe); + } + else + { + ++target->wakeupCount; + } + publishSnapshot(); + return KE_OK; +} + +int EeScheduler::cancelWakeup(int id) +{ + assertExecutor(); + if (id == 0) + { + id = m_currentThreadId; + } + GuestThread *target = thread(id); + if (!target) + { + return KE_UNKNOWN_THID; + } + const int old = static_cast(target->wakeupCount); + target->wakeupCount = 0; + publishSnapshot(); + return old; +} + +int EeScheduler::changePriority(int id, int priority, bool interruptSafe, int &oldPriority) +{ + assertExecutor(); + if (priority < 1 || priority >= kPriorityCount) + { + return KE_ILLEGAL_PRIORITY; + } + if (id == 0) + { + id = m_currentThreadId; + } + GuestThread *target = thread(id); + if (!target) + { + return KE_UNKNOWN_THID; + } + oldPriority = target->currentPriority; + if (target->status == EeThreadStatus::Ready) + { + removeReady(*target); + target->currentPriority = priority; + enqueueReady(*target); + requestPreemptionIfHigher(*target, interruptSafe); + } + else + { + target->currentPriority = priority; + if (target->status == EeThreadStatus::Running) + { + for (int p = 0; p < target->currentPriority; ++p) + { + if (!m_readyQueues[p].empty()) + { + m_rescheduleRequested = true; + break; + } + } + } + } + publishSnapshot(); + return KE_OK; +} + +int EeScheduler::rotateReadyQueue(int priority, bool interruptSafe) +{ + assertExecutor(); + if (priority == 0) + { + const GuestThread *self = currentThread(); + priority = self ? self->currentPriority : 0; + } + if (priority < 0 || priority >= kPriorityCount) + { + return KE_ILLEGAL_PRIORITY; + } + + GuestThread *self = currentThread(); + if (self && self->currentPriority == priority) + { + enqueueReady(*self); + m_currentThreadId = 0; + m_rescheduleRequested = true; + } + else + { + auto &queue = m_readyQueues[priority]; + if (queue.size() > 1u) + { + const int head = queue.front(); + queue.pop_front(); + queue.push_back(head); + } + } + (void)interruptSafe; + publishSnapshot(); + return KE_OK; +} + +int EeScheduler::releaseWait(int id, bool interruptSafe) +{ + assertExecutor(); + if (id == 0) + { + return KE_ILLEGAL_THID; + } + GuestThread *target = thread(id); + if (!target) + { + return KE_UNKNOWN_THID; + } + if (target->status != EeThreadStatus::Waiting && target->status != EeThreadStatus::WaitingSuspended) + { + return KE_NOT_WAIT; + } + removeFromWaitObject(*target); + makeReady(*target, KE_RELEASE_WAIT, interruptSafe); + publishSnapshot(); + return KE_OK; +} + +void EeScheduler::transferIfRequested(bool interruptSafe) +{ + assertExecutor(); + if (interruptSafe || m_insideInterrupt || !m_rescheduleRequested) + { + return; + } + if (m_currentThreadId != 0) + { + GuestThread *self = currentThread(); + assert(self != nullptr); + enqueueReady(*self, true); + m_currentThreadId = 0; + } + m_rescheduleRequested = false; + publishSnapshot(); + throw EeDispatcherTransfer{}; +} + +int EeScheduler::createSemaphore(int initCount, int maxCount, uint32_t attr, uint32_t option) +{ + assertExecutor(); + if (maxCount <= 0 || initCount < 0 || initCount > maxCount) + { + return KE_ERROR; + } + const int id = allocatePositiveId(m_nextSemaphoreId, m_semaphores); + if (id == 0) + { + return KE_ERROR; + } + EeSemaphore semaphore{}; + semaphore.id = id; + semaphore.count = initCount; + semaphore.maxCount = maxCount; + semaphore.initCount = initCount; + semaphore.attr = attr; + semaphore.option = option; + m_semaphores.emplace(id, std::move(semaphore)); + publishSnapshot(); + return id; +} + +int EeScheduler::deleteSemaphore(int id, bool interruptSafe) +{ + assertExecutor(); + auto it = m_semaphores.find(id); + if (it == m_semaphores.end()) + { + return KE_UNKNOWN_SEMID; + } + std::deque waiters = std::move(it->second.waiters); + m_semaphores.erase(it); + for (const int threadId : waiters) + { + if (GuestThread *waiter = thread(threadId)) + { + makeReady(*waiter, KE_WAIT_DELETE, interruptSafe); + } + } + publishSnapshot(); + return id; +} + +int EeScheduler::signalSemaphore(int id, bool interruptSafe) +{ + assertExecutor(); + EeSemaphore *object = semaphore(id); + if (!object) + { + return KE_UNKNOWN_SEMID; + } + if (!object->waiters.empty()) + { + const int waiterId = object->waiters.front(); + object->waiters.pop_front(); + GuestThread *waiter = thread(waiterId); + assert(waiter != nullptr); + makeReady(*waiter, id, interruptSafe); + publishSnapshot(); + return id; + } + if (object->count == object->maxCount) + { + return KE_SEMA_OVF; + } + ++object->count; + publishSnapshot(); + return id; +} + +int EeScheduler::pollSemaphore(int id) +{ + assertExecutor(); + EeSemaphore *object = semaphore(id); + if (!object) + { + return KE_UNKNOWN_SEMID; + } + if (object->count == 0) + { + return KE_SEMA_ZERO; + } + --object->count; + publishSnapshot(); + return id; +} + +void EeScheduler::waitSemaphore(int id) +{ + assertExecutor(); + EeSemaphore *object = semaphore(id); + if (!object) + { + GuestThread *self = currentThread(); + assert(self != nullptr); + setReturnS32(&self->activeContext(), KE_UNKNOWN_SEMID); + return; + } + if (object->count != 0) + { + --object->count; + GuestThread *self = currentThread(); + assert(self != nullptr); + setReturnS32(&self->activeContext(), id); + publishSnapshot(); + return; + } + GuestThread *self = currentThread(); + assert(self != nullptr); + object->waiters.push_back(self->id); + blockCurrent(EeWaitState{EeWaitReason::Semaphore, EeSemaphoreWait{id}}); +} + +int EeScheduler::createEventFlag(uint32_t initialBits, uint32_t attr, uint32_t option) +{ + assertExecutor(); + const int id = allocatePositiveId(m_nextEventFlagId, m_eventFlags); + if (id == 0) + { + return KE_ERROR; + } + EeEventFlag flag{}; + flag.id = id; + flag.attr = attr; + flag.option = option; + flag.initBits = initialBits; + flag.bits = initialBits; + m_eventFlags.emplace(id, std::move(flag)); + publishSnapshot(); + return id; +} + +int EeScheduler::deleteEventFlag(int id, bool interruptSafe) +{ + assertExecutor(); + auto it = m_eventFlags.find(id); + if (it == m_eventFlags.end()) + { + return KE_UNKNOWN_EVFID; + } + std::deque waiters = std::move(it->second.waiters); + m_eventFlags.erase(it); + for (const int threadId : waiters) + { + if (GuestThread *waiter = thread(threadId)) + { + makeReady(*waiter, KE_WAIT_DELETE, interruptSafe); + } + } + publishSnapshot(); + return KE_OK; +} + +int EeScheduler::setEventFlag(int id, uint32_t bits, bool interruptSafe) +{ + assertExecutor(); + EeEventFlag *flag = eventFlag(id); + if (!flag) + { + return KE_UNKNOWN_EVFID; + } + flag->bits |= bits; + finishEventWaiters(*flag, interruptSafe); + publishSnapshot(); + return KE_OK; +} + +int EeScheduler::clearEventFlag(int id, uint32_t mask) +{ + assertExecutor(); + EeEventFlag *flag = eventFlag(id); + if (!flag) + { + return KE_UNKNOWN_EVFID; + } + flag->bits &= mask; + publishSnapshot(); + return KE_OK; +} + +int EeScheduler::pollEventFlag(int id, uint32_t bits, uint32_t mode, uint32_t &observedBits) +{ + assertExecutor(); + EeEventFlag *flag = eventFlag(id); + if (!flag) + { + return KE_UNKNOWN_EVFID; + } + if (!eventCondition(flag->bits, bits, mode)) + { + return KE_EVF_COND; + } + observedBits = flag->bits; + if ((mode & WEF_CLEAR_ALL) != 0u) + { + flag->bits = 0; + } + else if ((mode & WEF_CLEAR) != 0u) + { + flag->bits &= ~bits; + } + publishSnapshot(); + return KE_OK; +} + +void EeScheduler::waitEventFlag(int id, uint32_t bits, uint32_t mode, uint32_t resultAddress) +{ + assertExecutor(); + EeEventFlag *flag = eventFlag(id); + GuestThread *self = currentThread(); + assert(self != nullptr); + if (!flag) + { + setReturnS32(&self->activeContext(), KE_UNKNOWN_EVFID); + return; + } + if (eventCondition(flag->bits, bits, mode)) + { + const uint32_t observed = flag->bits; + writeGuestU32(resultAddress, observed); + if ((mode & WEF_CLEAR_ALL) != 0u) + { + flag->bits = 0; + } + else if ((mode & WEF_CLEAR) != 0u) + { + flag->bits &= ~bits; + } + setReturnS32(&self->activeContext(), KE_OK); + publishSnapshot(); + return; + } + flag->waiters.push_back(self->id); + blockCurrent(EeWaitState{EeWaitReason::EventFlag, + EeEventFlagWait{id, bits, mode, resultAddress}}); +} + +int EeScheduler::setAlarm(uint16_t ticks, + uint32_t handler, + uint32_t argument, + uint32_t gp, + uint32_t sp) +{ + assertExecutor(); + if (handler == 0u || !m_runtime.hasFunction(handler)) + { + return KE_ERROR; + } + const int id = allocatePositiveId(m_nextAlarmId, m_alarms); + if (id == 0) + { + return KE_ERROR; + } + m_alarms.emplace(id, EeAlarm{id, ticks, handler, argument, gp, sp}); + const uint64_t tickCount = ticks == 0u ? 1u : static_cast(ticks); + scheduleEvent(std::chrono::steady_clock::now() + + std::chrono::microseconds(tickCount * kAlarmTickMicroseconds), + EeEvent{EeEventType::Alarm, static_cast(id), 0}); + return id; +} + +int EeScheduler::cancelAlarm(int id) +{ + assertExecutor(); + if (m_alarms.erase(id) == 0u) + { + return KE_ERROR; + } + { + std::lock_guard lock(m_eventMutex); + std::erase_if(m_deadlines, [id](const ScheduledEvent &scheduled) + { + return scheduled.event.type == EeEventType::Alarm && + scheduled.event.id == static_cast(id); + }); + updateNextDeadline(); + } + return KE_OK; +} + +void EeScheduler::queueInvocation(GuestInvocation invocation) +{ + assertExecutor(); + invocation.sequence = ++m_invocationSequence; + m_pendingInvocations.push_back(std::move(invocation)); + m_checkpointPending.store(true, std::memory_order_release); +} + +[[noreturn]] void EeScheduler::invokeCurrent(GuestInvocation invocation) +{ + assertExecutor(); + GuestThread *owner = currentThread(); + assert(owner != nullptr); + if (getRegU32(&invocation.context, 29) == 0u) + { + SET_GPR_U32(&invocation.context, 29, invocationStackTop()); + } + invocation.sequence = ++m_invocationSequence; + owner->invocations.push_back(std::move(invocation)); + publishSnapshot(); + throw EeDispatcherTransfer{}; +} + +[[noreturn]] void EeScheduler::invokeCurrentSequence(std::vector invocations) +{ + assertExecutor(); + GuestThread *owner = currentThread(); + assert(owner != nullptr); + assert(!invocations.empty()); + for (auto it = invocations.rbegin(); it != invocations.rend(); ++it) + { + if (getRegU32(&it->context, 29) == 0u) + { + SET_GPR_U32(&it->context, 29, invocationStackTop()); + } + it->sequence = ++m_invocationSequence; + owner->invocations.push_back(std::move(*it)); + } + publishSnapshot(); + throw EeDispatcherTransfer{}; +} + +bool EeScheduler::hasInvocation(GuestInvocationKind kind, uint64_t tag) const +{ + const GuestThread *owner = currentThread(); + if (!owner) + { + return false; + } + return std::any_of(owner->invocations.begin(), owner->invocations.end(), + [kind, tag](const GuestInvocation &invocation) + { + return invocation.kind == kind && invocation.tag == tag; + }); +} + +uint32_t EeScheduler::invocationStackTop() +{ + assertExecutor(); + const GuestThread *owner = currentThread(); + if (!owner) + { + throw std::logic_error("EE invocation stack requested without a current guest context"); + } + const size_t depth = owner ? owner->invocations.size() : 0u; + const uint64_t key = (static_cast(static_cast(owner->id)) << 32u) | + static_cast(depth); + const auto existing = m_invocationStackTops.find(key); + if (existing != m_invocationStackTops.end()) + { + return existing->second; + } + constexpr uint32_t kInvocationStackSize = 0x4000u; + const uint32_t top = m_runtime.reserveAsyncCallbackStack(kInvocationStackSize, 16u); + if (top == 0u) + { + throw std::runtime_error("EE invocation stack space exhausted"); + } + m_invocationStackTops.emplace(key, top); + return top; +} + +int EeScheduler::addIrqHandler(bool dmac, + uint32_t cause, + uint32_t handler, + bool append, + uint32_t argument, + uint32_t gp, + uint32_t sp) +{ + assertExecutor(); + auto &handlers = dmac ? m_dmacHandlers : m_intcHandlers; + int &nextId = dmac ? m_nextDmacHandlerId : m_nextIntcHandlerId; + const int id = allocatePositiveId(nextId, handlers); + if (id == 0) + { + return KE_ERROR; + } + int &head = dmac ? m_dmacHeadOrder : m_intcHeadOrder; + int &tail = dmac ? m_dmacTailOrder : m_intcTailOrder; + handlers.emplace(id, + EeIrqHandler{id, + cause, + handler, + argument, + gp, + sp, + true, + append ? ++tail : --head}); + return id; +} + +int EeScheduler::removeIrqHandler(bool dmac, uint32_t cause, int id) +{ + assertExecutor(); + auto &handlers = dmac ? m_dmacHandlers : m_intcHandlers; + auto it = handlers.find(id); + if (it != handlers.end() && it->second.cause == cause) + { + handlers.erase(it); + } + return KE_OK; +} + +int EeScheduler::setIrqHandlerEnabled(bool dmac, int id, bool enabled) +{ + assertExecutor(); + auto &handlers = dmac ? m_dmacHandlers : m_intcHandlers; + auto it = handlers.find(id); + if (it != handlers.end()) + { + it->second.enabled = enabled; + } + return KE_OK; +} + +int EeScheduler::setIrqCauseEnabled(bool dmac, uint32_t cause, bool enabled) +{ + assertExecutor(); + if (cause < 32u) + { + uint32_t &mask = dmac ? m_enabledDmacMask : m_enabledIntcMask; + if (enabled) + { + mask |= 1u << cause; + } + else + { + mask &= ~(1u << cause); + } + } + return KE_OK; +} + +void EeScheduler::dispatchIrq(bool dmac, uint32_t cause) +{ + assertExecutor(); + const uint32_t mask = dmac ? m_enabledDmacMask : m_enabledIntcMask; + if (cause < 32u && (mask & (1u << cause)) == 0u) + { + return; + } + const auto &handlers = dmac ? m_dmacHandlers : m_intcHandlers; + std::vector matching; + for (const auto &[id, handler] : handlers) + { + (void)id; + if (handler.enabled && handler.cause == cause && handler.handler != 0u && + m_runtime.hasFunction(handler.handler)) + { + matching.push_back(handler); + } + } + std::sort(matching.begin(), matching.end(), [](const EeIrqHandler &left, const EeIrqHandler &right) + { return left.order < right.order; }); + for (const EeIrqHandler &handler : matching) + { + GuestInvocation invocation{}; + invocation.kind = GuestInvocationKind::Interrupt; + invocation.context.pc = handler.handler; + SET_GPR_U32(&invocation.context, 4, cause); + SET_GPR_U32(&invocation.context, 5, handler.argument); + SET_GPR_U32(&invocation.context, 28, handler.gp); + SET_GPR_U32(&invocation.context, 29, handler.sp); + SET_GPR_U32(&invocation.context, 31, 0u); + queueInvocation(std::move(invocation)); + } +} + +void EeScheduler::setVSyncFlag(uint32_t flagAddress, uint32_t tickAddress) +{ + assertExecutor(); + m_vsyncFlagAddress = flagAddress; + m_vsyncTickAddress = tickAddress; + writeGuestU32(flagAddress, 0u); + if (tickAddress != 0u) + { + const uint32_t physical = tickAddress & 0x1FFFFFFFu; + if (m_rdram && physical <= PS2_RAM_SIZE - sizeof(uint64_t)) + { + const uint64_t zero = 0u; + std::memcpy(m_rdram + physical, &zero, sizeof(zero)); + } + } +} + +uint64_t EeScheduler::currentVSyncTick() const noexcept +{ + return m_vsyncTick; +} + +uint32_t EeScheduler::setGsVSyncCallback(uint32_t callback, uint32_t gp, uint32_t sp) +{ + assertExecutor(); + (void)sp; + const uint32_t previous = m_gsVSyncCallback; + m_gsVSyncCallback = callback; + m_gsVSyncCallbackGp = gp; + m_gsVSyncCallbackSp = 0u; + return previous; +} + +[[noreturn]] void EeScheduler::waitVSync(uint64_t afterTick, int fixedResult) +{ + blockCurrent(EeWaitState{EeWaitReason::VSync, EeVSyncWait{afterTick, fixedResult}}); +} + +void EeScheduler::completeVSync(uint64_t tick) +{ + assertExecutor(); + std::vector completed; + for (const auto &[id, candidate] : m_threads) + { + if ((candidate.status == EeThreadStatus::Waiting || candidate.status == EeThreadStatus::WaitingSuspended) && + candidate.wait.reason == EeWaitReason::VSync && + std::get(candidate.wait.payload).afterTick < tick) + { + completed.push_back(id); + } + } + std::sort(completed.begin(), completed.end()); + for (const int id : completed) + { + GuestThread *waiter = thread(id); + assert(waiter != nullptr); + const EeVSyncWait wait = std::get(waiter->wait.payload); + const int result = wait.fixedResult >= 0 + ? wait.fixedResult + : static_cast((tick - 1u) & 1u); + makeReady(*waiter, result, false); + } + publishSnapshot(); +} + +void EeScheduler::completeExternalWait(uint32_t type, uint64_t token, int result) +{ + assertExecutor(); + std::vector completed; + for (const auto &[id, candidate] : m_threads) + { + if ((candidate.status != EeThreadStatus::Waiting && candidate.status != EeThreadStatus::WaitingSuspended) || + (candidate.wait.reason != EeWaitReason::External && + candidate.wait.reason != EeWaitReason::Mpeg)) + { + continue; + } + const auto &external = std::get(candidate.wait.payload); + if (external.type == type && external.token == token) + { + completed.push_back(id); + } + } + std::sort(completed.begin(), completed.end()); + for (const int id : completed) + { + GuestThread *waiter = thread(id); + assert(waiter != nullptr); + makeReady(*waiter, result, false); + } + publishSnapshot(); +} + +[[noreturn]] void EeScheduler::waitExternal(EeWaitReason reason, + uint32_t type, + uint64_t token, + std::function completion) +{ + EeWaitState wait{reason, EeExternalWait{type, token}, std::move(completion)}; + blockCurrent(std::move(wait)); +} + +GuestThread *EeScheduler::thread(int id) +{ + auto it = m_threads.find(id); + return it == m_threads.end() ? nullptr : &it->second; +} + +const GuestThread *EeScheduler::thread(int id) const +{ + auto it = m_threads.find(id); + return it == m_threads.end() ? nullptr : &it->second; +} + +EeSemaphore *EeScheduler::semaphore(int id) +{ + auto it = m_semaphores.find(id); + return it == m_semaphores.end() ? nullptr : &it->second; +} + +const EeSemaphore *EeScheduler::semaphore(int id) const +{ + auto it = m_semaphores.find(id); + return it == m_semaphores.end() ? nullptr : &it->second; +} + +EeEventFlag *EeScheduler::eventFlag(int id) +{ + auto it = m_eventFlags.find(id); + return it == m_eventFlags.end() ? nullptr : &it->second; +} + +const EeEventFlag *EeScheduler::eventFlag(int id) const +{ + auto it = m_eventFlags.find(id); + return it == m_eventFlags.end() ? nullptr : &it->second; +} + +GuestThread *EeScheduler::currentThread() +{ + return thread(m_currentThreadId); +} + +const GuestThread *EeScheduler::currentThread() const +{ + return thread(m_currentThreadId); +} + +int EeScheduler::currentThreadId() const noexcept +{ + return m_currentThreadId; +} + +R5900Context *EeScheduler::currentContext() +{ + GuestThread *self = currentThread(); + return self ? &self->activeContext() : nullptr; +} + +uint8_t *EeScheduler::rdram() const noexcept +{ + return m_rdram; +} + +void EeScheduler::bindMainContextForSyscall(R5900Context &ctx, uint8_t *rdram) +{ + if (m_executorThread == std::thread::id{}) + { + reset(rdram, ctx); + GuestThread *main = selectReady(); + assert(main != nullptr); + makeRunning(*main); + return; + } + assertExecutor(); + m_rdram = rdram; + if (m_currentThreadId == 0) + { + GuestThread *main = thread(kMainThreadId); + assert(main != nullptr); + assert(main->status == EeThreadStatus::Ready); + removeReady(*main); + makeRunning(*main); + } +} + +EeKernelSnapshot EeScheduler::snapshot() const +{ + std::lock_guard lock(m_snapshotMutex); + return m_snapshot; +} + +void EeScheduler::publishSnapshot() +{ + EeKernelSnapshot next{}; + next.sequence = ++m_snapshotSequence; + next.runningThreadId = m_currentThreadId; + next.threads.reserve(m_threads.size()); + for (const auto &[id, item] : m_threads) + { + if (id < 0) + { + continue; + } + EeThreadSnapshot snapshot{}; + snapshot.id = id; + snapshot.pc = item.activeContext().pc; + snapshot.entry = item.entry; + snapshot.stack = item.stack; + snapshot.stackSize = item.stackSize; + snapshot.gp = item.gp; + snapshot.initialPriority = item.initialPriority; + snapshot.currentPriority = item.currentPriority; + snapshot.status = item.status; + snapshot.waitReason = item.wait.reason; + snapshot.waitId = waitObjectId(item.wait); + snapshot.suspendCount = item.suspendCount; + snapshot.wakeupCount = item.wakeupCount; + next.threads.push_back(snapshot); + } + std::sort(next.threads.begin(), next.threads.end(), [](const auto &left, const auto &right) + { return left.id < right.id; }); + next.semaphores.reserve(m_semaphores.size()); + for (const auto &[id, item] : m_semaphores) + { + next.semaphores.push_back(EeSemaphoreSnapshot{id, + item.count, + item.maxCount, + static_cast(item.waiters.size())}); + } + std::sort(next.semaphores.begin(), next.semaphores.end(), [](const auto &left, const auto &right) + { return left.id < right.id; }); + next.eventFlags.reserve(m_eventFlags.size()); + for (const auto &[id, item] : m_eventFlags) + { + next.eventFlags.push_back(EeEventFlagSnapshot{id, + item.bits, + item.initBits, + item.attr, + static_cast(item.waiters.size())}); + } + std::sort(next.eventFlags.begin(), next.eventFlags.end(), [](const auto &left, const auto &right) + { return left.id < right.id; }); + { + std::lock_guard lock(m_snapshotMutex); + m_snapshot = std::move(next); + } +} + +void EeScheduler::assertExecutor() const +{ + assert(m_executorThread == std::this_thread::get_id()); +} + +int EeScheduler::allocateThreadId() +{ + for (int attempts = 0; attempts <= kLastThreadId - kFirstThreadId; ++attempts) + { + const int candidate = m_nextThreadId; + m_nextThreadId = candidate == kLastThreadId ? kFirstThreadId : candidate + 1; + if (!m_threads.contains(candidate)) + { + return candidate; + } + } + return 0; +} + +GuestThread &EeScheduler::acquireInvocationThread() +{ + for (auto &[id, candidate] : m_threads) + { + if (id < 0 && candidate.status == EeThreadStatus::Dormant && candidate.invocations.empty()) + { + return candidate; + } + } + + GuestThread dispatcher{}; + dispatcher.id = m_nextInvocationThreadId--; + dispatcher.initialPriority = 0; + dispatcher.currentPriority = 0; + dispatcher.status = EeThreadStatus::Dormant; + return m_threads.emplace(dispatcher.id, std::move(dispatcher)).first->second; +} + +void EeScheduler::enqueueReady(GuestThread &item, bool front) +{ + assert(item.currentPriority >= 0 && item.currentPriority < kPriorityCount); + item.status = EeThreadStatus::Ready; + auto &queue = m_readyQueues[item.currentPriority]; + if (front) + { + queue.push_front(item.id); + } + else + { + queue.push_back(item.id); + } +} + +void EeScheduler::removeReady(GuestThread &item) +{ + if (item.status != EeThreadStatus::Ready) + { + return; + } + auto &queue = m_readyQueues[item.currentPriority]; + auto it = std::find(queue.begin(), queue.end(), item.id); + assert(it != queue.end()); + queue.erase(it); +} + +GuestThread *EeScheduler::selectReady() +{ + for (auto &queue : m_readyQueues) + { + if (queue.empty()) + { + continue; + } + const int id = queue.front(); + queue.pop_front(); + GuestThread *selected = thread(id); + assert(selected != nullptr); + assert(selected->status == EeThreadStatus::Ready); + return selected; + } + return nullptr; +} + +void EeScheduler::makeRunning(GuestThread &item) +{ + assert(m_currentThreadId == 0); + assert(item.status == EeThreadStatus::Ready); + item.status = EeThreadStatus::Running; + m_currentThreadId = item.id; +} + +void EeScheduler::makeDormant(GuestThread &item) +{ + removeReady(item); + removeFromWaitObject(item); + item.status = EeThreadStatus::Dormant; + item.wait = {}; + item.resumeCompletion = {}; + item.suspendCount = 0; + item.wakeupCount = 0; + item.invocations.clear(); +} + +void EeScheduler::removeFromWaitObject(GuestThread &item) +{ + const int id = item.id; + if (item.wait.reason == EeWaitReason::Semaphore) + { + const int objectId = std::get(item.wait.payload).id; + if (EeSemaphore *object = semaphore(objectId)) + { + auto it = std::find(object->waiters.begin(), object->waiters.end(), id); + if (it != object->waiters.end()) + { + object->waiters.erase(it); + } + } + } + else if (item.wait.reason == EeWaitReason::EventFlag) + { + const int objectId = std::get(item.wait.payload).id; + if (EeEventFlag *object = eventFlag(objectId)) + { + auto it = std::find(object->waiters.begin(), object->waiters.end(), id); + if (it != object->waiters.end()) + { + object->waiters.erase(it); + } + } + } + item.wait = {}; +} + +void EeScheduler::blockCurrent(EeWaitState wait) +{ + GuestThread *self = currentThread(); + assert(self != nullptr); + self->wait = std::move(wait); + self->status = self->suspendCount == 0 ? EeThreadStatus::Waiting : EeThreadStatus::WaitingSuspended; + m_currentThreadId = 0; + publishSnapshot(); + throw EeDispatcherTransfer{}; +} + +void EeScheduler::makeReady(GuestThread &item, int result, bool interruptSafe) +{ + auto completion = std::move(item.wait.completion); + item.wait = {}; + setReturnS32(&item.activeContext(), result); + item.resumeCompletion = std::move(completion); + if (item.suspendCount != 0) + { + item.status = EeThreadStatus::Suspended; + return; + } + enqueueReady(item); + requestPreemptionIfHigher(item, interruptSafe); +} + +void EeScheduler::requestPreemptionIfHigher(const GuestThread &readyThread, bool interruptSafe) +{ + const GuestThread *running = currentThread(); + if (!running || readyThread.currentPriority >= running->currentPriority) + { + return; + } + m_rescheduleRequested = true; + if (interruptSafe || m_insideInterrupt) + { + m_checkpointPending.store(true, std::memory_order_release); + } +} + +void EeScheduler::applyPendingPreemption() +{ + if (!m_rescheduleRequested) + { + return; + } + if (m_currentThreadId == 0) + { + m_rescheduleRequested = false; + return; + } + GuestThread *self = currentThread(); + assert(self != nullptr); + enqueueReady(*self, true); + m_currentThreadId = 0; + m_rescheduleRequested = false; +} + +void EeScheduler::processPendingEvents() +{ + assertExecutor(); + processDueDeadlines(); + std::deque pending; + { + std::lock_guard lock(m_eventMutex); + pending.swap(m_events); + } + for (const EeEvent &event : pending) + { + processEvent(event); + } + m_checkpointPending.store(false, std::memory_order_release); + applyPendingPreemption(); +} + +void EeScheduler::processDueDeadlines() +{ + const auto now = std::chrono::steady_clock::now(); + std::vector due; + { + std::lock_guard lock(m_eventMutex); + auto firstFuture = std::partition(m_deadlines.begin(), m_deadlines.end(), [now](const ScheduledEvent &item) + { return item.deadline <= now; }); + due.insert(due.end(), + std::make_move_iterator(m_deadlines.begin()), + std::make_move_iterator(firstFuture)); + m_deadlines.erase(m_deadlines.begin(), firstFuture); + updateNextDeadline(); + } + std::sort(due.begin(), due.end(), [](const ScheduledEvent &left, const ScheduledEvent &right) + { + if (left.deadline != right.deadline) + { + return left.deadline < right.deadline; + } + if (left.event.type != right.event.type) + { + return left.event.type < right.event.type; + } + if (left.event.id != right.event.id) + { + return left.event.id < right.event.id; + } + return left.sequence < right.sequence; + }); + for (ScheduledEvent &scheduled : due) + { + if (scheduled.event.type == EeEventType::VBlankStart) + { + scheduleEvent(scheduled.deadline + kVBlankDuration, + EeEvent{EeEventType::VBlankEnd, 0, m_vsyncTick + 1u}); + scheduleEvent(scheduled.deadline + kVBlankPeriod, + EeEvent{EeEventType::VBlankStart, 0, 0}); + } + processEvent(scheduled.event); + } +} + +void EeScheduler::processEvent(const EeEvent &event) +{ + switch (event.type) + { + case EeEventType::Stop: + requestStop(); + break; + case EeEventType::VBlankStart: + ++m_vsyncTick; + m_runtime.memory().gs().vsyncTick.store(m_vsyncTick, std::memory_order_release); + if ((m_vsyncTick & 1u) != 0u) + { + m_runtime.memory().gs().csr.fetch_or(0x2000ull, std::memory_order_acq_rel); + } + else + { + m_runtime.memory().gs().csr.fetch_and(~0x2000ull, std::memory_order_acq_rel); + } + writeGuestU32(m_vsyncFlagAddress, 1u); + if (m_vsyncTickAddress != 0u) + { + const uint32_t physical = m_vsyncTickAddress & 0x1FFFFFFFu; + if (m_rdram && physical <= PS2_RAM_SIZE - sizeof(uint64_t)) + { + std::memcpy(m_rdram + physical, &m_vsyncTick, sizeof(m_vsyncTick)); + } + } + m_vsyncFlagAddress = 0u; + m_vsyncTickAddress = 0u; + completeVSync(m_vsyncTick); + if (m_gsVSyncCallback != 0u && m_runtime.hasFunction(m_gsVSyncCallback)) + { + GuestInvocation invocation{}; + invocation.kind = GuestInvocationKind::GsCallback; + invocation.context.pc = m_gsVSyncCallback; + SET_GPR_U32(&invocation.context, 4, static_cast(m_vsyncTick)); + SET_GPR_U32(&invocation.context, 28, m_gsVSyncCallbackGp); + SET_GPR_U32(&invocation.context, 29, m_gsVSyncCallbackSp); + SET_GPR_U32(&invocation.context, 31, 0u); + queueInvocation(std::move(invocation)); + } + dispatchIrq(false, 2u); + break; + case EeEventType::ExternalWake: + completeExternalWait(event.id, event.value, KE_OK); + break; + case EeEventType::VBlankEnd: + dispatchIrq(false, 3u); + break; + case EeEventType::Dmac: + break; + case EeEventType::Alarm: + { + auto it = m_alarms.find(static_cast(event.id)); + if (it == m_alarms.end()) + { + break; + } + const EeAlarm alarm = it->second; + m_alarms.erase(it); + GuestInvocation invocation{}; + invocation.kind = GuestInvocationKind::Alarm; + invocation.context.pc = alarm.handler; + SET_GPR_U32(&invocation.context, 4, static_cast(alarm.id)); + SET_GPR_U32(&invocation.context, 5, static_cast(alarm.ticks)); + SET_GPR_U32(&invocation.context, 6, alarm.argument); + SET_GPR_U32(&invocation.context, 28, alarm.gp); + SET_GPR_U32(&invocation.context, 29, alarm.sp); + SET_GPR_U32(&invocation.context, 31, 0u); + queueInvocation(std::move(invocation)); + break; + } + } +} + +void EeScheduler::finishEventWaiters(EeEventFlag &flag, bool interruptSafe) +{ + for (auto it = flag.waiters.begin(); it != flag.waiters.end();) + { + GuestThread *waiter = thread(*it); + assert(waiter != nullptr); + const EeEventFlagWait wait = std::get(waiter->wait.payload); + if (!eventCondition(flag.bits, wait.bits, wait.mode)) + { + ++it; + continue; + } + const uint32_t observed = flag.bits; + writeGuestU32(wait.resultAddress, observed); + if ((wait.mode & WEF_CLEAR_ALL) != 0u) + { + flag.bits = 0; + } + else if ((wait.mode & WEF_CLEAR) != 0u) + { + flag.bits &= ~wait.bits; + } + it = flag.waiters.erase(it); + makeReady(*waiter, KE_OK, interruptSafe); + } +} + +bool EeScheduler::eventCondition(uint32_t current, uint32_t requested, uint32_t mode) +{ + return (mode & WEF_OR) != 0u ? (current & requested) != 0u + : (current & requested) == requested; +} + +int EeScheduler::waitObjectId(const EeWaitState &wait) +{ + switch (wait.reason) + { + case EeWaitReason::Semaphore: + return std::get(wait.payload).id; + case EeWaitReason::EventFlag: + return std::get(wait.payload).id; + default: + return 0; + } +} + +void EeScheduler::writeGuestU32(uint32_t address, uint32_t value) +{ + if (address == 0u) + { + return; + } + const uint32_t physical = address & 0x1FFFFFFFu; + if (!m_rdram || physical > PS2_RAM_SIZE - sizeof(value)) + { + return; + } + std::memcpy(m_rdram + physical, &value, sizeof(value)); +} + +void EeScheduler::waitForEvent() +{ + std::unique_lock lock(m_eventMutex); + if (m_deadlines.empty()) + { + m_eventCv.wait(lock, [this]() + { return !m_events.empty() || m_stopRequested.load(std::memory_order_acquire); }); + return; + } + const auto next = std::min_element(m_deadlines.begin(), m_deadlines.end(), [](const ScheduledEvent &left, const ScheduledEvent &right) + { return left.deadline < right.deadline; }) + ->deadline; + m_eventCv.wait_until(lock, next); +} + +void EeScheduler::scheduleEvent(std::chrono::steady_clock::time_point deadline, EeEvent event) +{ + { + std::lock_guard lock(m_eventMutex); + m_deadlines.push_back(ScheduledEvent{deadline, event, ++m_eventSequence}); + updateNextDeadline(); + } + m_eventCv.notify_one(); +} + +void EeScheduler::updateNextDeadline() +{ + if (m_deadlines.empty()) + { + m_nextDeadlineNanoseconds.store(0, std::memory_order_release); + return; + } + const auto it = std::min_element(m_deadlines.begin(), m_deadlines.end(), [](const ScheduledEvent &left, const ScheduledEvent &right) + { return left.deadline < right.deadline; }); + const int64_t nanoseconds = std::chrono::duration_cast( + it->deadline.time_since_epoch()) + .count(); + m_nextDeadlineNanoseconds.store(nanoseconds, std::memory_order_release); +} + +void EeScheduler::copyMainContextToRuntime() +{ + const GuestThread *main = thread(kMainThreadId); + if (main) + { + m_runtime.m_cpuContext = main->context; + } +} diff --git a/ps2xRuntime/src/lib/Kernel/Stubs/CD.cpp b/ps2xRuntime/src/lib/Kernel/Stubs/CD.cpp index 9228e835a..1d6db890e 100644 --- a/ps2xRuntime/src/lib/Kernel/Stubs/CD.cpp +++ b/ps2xRuntime/src/lib/Kernel/Stubs/CD.cpp @@ -573,7 +573,7 @@ namespace ps2_stubs } if (hitStreamEnd || g_cdStreamingLbn == g_cdStreamingEndLbn) { - notifyMpegCdStreamEof(); + notifyMpegCdStreamEof(runtime); } } else @@ -582,7 +582,7 @@ namespace ps2_stubs { std::memset(rdram + offset, 0, requestedBytes); } - notifyMpegCdStreamEof(); + notifyMpegCdStreamEof(runtime); } if (int32_t *err = reinterpret_cast(getMemPtr(rdram, errAddr)); err) @@ -635,7 +635,7 @@ namespace ps2_stubs g_cdStreamingEndLbn = cdStreamingEndLbnForStart(g_cdStreamingLbn); g_cdStReadTraceCount = 0u; - notifyMpegCdStreamStart(); + notifyMpegCdStreamStart(runtime); std::cerr << "[sceCdStStart] lbn=0x" << std::hex << g_cdStreamingLbn << " endLbn=0x" << g_cdStreamingEndLbn << std::dec << std::endl; @@ -649,7 +649,7 @@ namespace ps2_stubs void sceCdStStop(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { - notifyMpegCdStreamEof(); + notifyMpegCdStreamEof(runtime); setReturnS32(ctx, 1); } diff --git a/ps2xRuntime/src/lib/Kernel/Stubs/GS.cpp b/ps2xRuntime/src/lib/Kernel/Stubs/GS.cpp index 0fd65656b..b29df1bcd 100644 --- a/ps2xRuntime/src/lib/Kernel/Stubs/GS.cpp +++ b/ps2xRuntime/src/lib/Kernel/Stubs/GS.cpp @@ -3,20 +3,12 @@ #include "ps2_log.h" #include "runtime/ps2_gs_common.h" #include "runtime/ps2_gs_psmct16.h" +#include "runtime/ee_scheduler.h" namespace ps2_stubs { namespace { - std::mutex g_gs_sync_v_mutex; - uint64_t g_gs_sync_v_base_tick = 0u; - std::mutex g_gs_sync_v_callback_mutex; - uint32_t g_gs_sync_v_callback_func = 0u; - uint32_t g_gs_sync_v_callback_gp = 0u; - uint32_t g_gs_sync_v_callback_sp = 0u; - uint32_t g_gs_sync_v_callback_stack_base = 0u; - uint32_t g_gs_sync_v_callback_stack_top = 0u; - uint32_t g_gs_sync_v_callback_bad_pc_logs = 0u; uint64_t makeClearPrim(bool useContext2) { return static_cast(GS_PRIM_SPRITE) | @@ -598,175 +590,6 @@ namespace ps2_stubs setReturnU32(ctx, terminatePacketBuilderState(rdram, ctx, runtime)); } - static void resetGsSyncVState() - { - std::lock_guard lock(g_gs_sync_v_mutex); - g_gs_sync_v_base_tick = ps2_syscalls::GetCurrentVSyncTick(); - } - - static int32_t getGsSyncVFieldForTick(uint64_t tick) - { - std::lock_guard lock(g_gs_sync_v_mutex); - if (tick <= g_gs_sync_v_base_tick) - { - return 0; - } - - return static_cast((tick - g_gs_sync_v_base_tick - 1u) & 1u); - } - - void resetGsSyncVCallbackState() - { - { - std::lock_guard lock(g_gs_sync_v_callback_mutex); - g_gs_sync_v_callback_func = 0u; - g_gs_sync_v_callback_gp = 0u; - g_gs_sync_v_callback_sp = 0u; - g_gs_sync_v_callback_stack_base = 0u; - g_gs_sync_v_callback_stack_top = 0u; - g_gs_sync_v_callback_bad_pc_logs = 0u; - } - resetGsSyncVState(); - } - - void dispatchGsSyncVCallback(uint8_t *rdram, PS2Runtime *runtime, uint64_t tick) - { - if (!rdram || !runtime) - { - return; - } - - uint32_t callback = 0u; - uint32_t gp = 0u; - uint32_t callbackStackTop = 0u; - const uint64_t callbackTick = (tick != 0u) ? tick : ps2_syscalls::GetCurrentVSyncTick(); - { - std::lock_guard lock(g_gs_sync_v_callback_mutex); - callback = g_gs_sync_v_callback_func; - gp = g_gs_sync_v_callback_gp; - callbackStackTop = g_gs_sync_v_callback_stack_top; - if (callback == 0u) - { - return; - } - } - - if (!runtime->hasFunction(callback)) - { - static uint32_t s_missingCallbackLogCount = 0u; - if (s_missingCallbackLogCount < 32u) - { - PS2_IF_AGRESSIVE_LOGS({ - std::cerr << "[sceGsSyncVCallback:missing] cb=0x" << std::hex << callback - << " gp=0x" << gp - << " tick=0x" << callbackTick - << std::dec << std::endl; - }); - ++s_missingCallbackLogCount; - } - return; - } - - if (callbackStackTop == 0u) - { - constexpr uint32_t kCallbackStackSize = 0x4000u; - const uint32_t stackTop = runtime->reserveAsyncCallbackStack(kCallbackStackSize, 16u); - if (stackTop != 0u) - { - std::lock_guard lock(g_gs_sync_v_callback_mutex); - if (g_gs_sync_v_callback_stack_top == 0u) - { - g_gs_sync_v_callback_stack_base = stackTop - (kCallbackStackSize - 0x10u); - g_gs_sync_v_callback_stack_top = stackTop; - } - callbackStackTop = g_gs_sync_v_callback_stack_top; - } - } - - try - { - R5900Context callbackCtx{}; - SET_GPR_U32(&callbackCtx, 28, gp); - SET_GPR_U32(&callbackCtx, 29, (callbackStackTop != 0u) ? callbackStackTop : (PS2_RAM_SIZE - 0x10u)); - SET_GPR_U32(&callbackCtx, 31, 0u); - SET_GPR_U32(&callbackCtx, 4, static_cast(callbackTick)); - callbackCtx.pc = callback; - - static uint32_t s_dispatchLogCount = 0u; - const bool shouldLogDispatch = (s_dispatchLogCount < 64u); - if (shouldLogDispatch) - { - PS2_IF_AGRESSIVE_LOGS({ - RUNTIME_LOG("[sceGsSyncVCallback:dispatch] cb=0x" << std::hex << callback - << " gp=0x" << gp - << " sp=0x" << getRegU32(&callbackCtx, 29) - << " tick=0x" << callbackTick - << std::dec << std::endl); - }); - } - - uint32_t steps = 0u; - bool reschedulePending = false; - uint64_t handoffBaseline = 0u; - { - PS2Runtime::GuestExecutionScope guestExecution(runtime); - PS2Runtime::DeferredGuestYieldScope deferYield(reschedulePending); - - while (callbackCtx.pc != 0u && !runtime->isStopRequested() && steps < 1024u) - { - if (!runtime->hasFunction(callbackCtx.pc)) - { - if (g_gs_sync_v_callback_bad_pc_logs < 16u) - { - std::cerr << "[sceGsSyncVCallback:bad-pc] pc=0x" << std::hex << callbackCtx.pc - << " ra=0x" << getRegU32(&callbackCtx, 31) - << " sp=0x" << getRegU32(&callbackCtx, 29) - << " gp=0x" << getRegU32(&callbackCtx, 28) - << std::dec << std::endl; - ++g_gs_sync_v_callback_bad_pc_logs; - } - callbackCtx.pc = 0u; - break; - } - - auto step = runtime->lookupFunction(callbackCtx.pc); - if (!step) - { - break; - } - ++steps; - step(rdram, &callbackCtx, runtime); - } - handoffBaseline = runtime->guestExecutionHandoffEpochSnapshot(); - } - if (reschedulePending && !runtime->isStopRequested()) - { - runtime->waitForGuestExecutionHandoff(handoffBaseline); - } - - if (shouldLogDispatch) - { - PS2_IF_AGRESSIVE_LOGS({ - RUNTIME_LOG("[sceGsSyncVCallback:return] cb=0x" << std::hex << callback - << " finalPc=0x" << callbackCtx.pc - << " ra=0x" << getRegU32(&callbackCtx, 31) - << " steps=0x" << steps - << std::dec << std::endl); - }); - ++s_dispatchLogCount; - } - } - catch (const std::exception &e) - { - static uint32_t warnCount = 0u; - if (warnCount < 8u) - { - std::cerr << "[sceGsSyncVCallback] callback exception: " << e.what() << std::endl; - ++warnCount; - } - } - } - void sceGsExecLoadImage(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { uint32_t imgAddr = getRegU32(ctx, 4); @@ -979,8 +802,6 @@ namespace ps2_stubs g_gparam.omode = static_cast(omode & 0xFF); g_gparam.ffmode = static_cast(ffmode & 0x1); writeGsGParamToScratch(runtime); - resetGsSyncVState(); - uint64_t pmode = makePmode(1, 0, 0, 0, 0, 0x80); uint64_t smode2 = (interlace & 0x1) | ((ffmode & 0x1) << 1); uint64_t dispfb = makeDispFb(0, 10, 0, 0, 0); @@ -1459,14 +1280,10 @@ namespace ps2_stubs void sceGsSyncV(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { - const uint64_t tick = ps2_syscalls::WaitForNextVSyncTick(rdram, runtime); - if (g_gparam.interlace != 0u) - { - setReturnS32(ctx, getGsSyncVFieldForTick(tick)); - return; - } - - setReturnS32(ctx, 1); + ps2_syscalls::WaitVSyncTick(rdram, + ctx, + runtime, + g_gparam.interlace != 0u ? -1 : 1); } void sceGsSyncVCallback(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) @@ -1477,17 +1294,9 @@ namespace ps2_stubs const uint32_t gp = getRegU32(ctx, 28); const uint32_t sp = getRegU32(ctx, 29); - uint32_t oldCallback = 0u; - { - std::lock_guard lock(g_gs_sync_v_callback_mutex); - oldCallback = g_gs_sync_v_callback_func; - g_gs_sync_v_callback_func = newCallback; - if (newCallback != 0u) - { - g_gs_sync_v_callback_gp = gp; - g_gs_sync_v_callback_sp = sp; - } - } + EeScheduler &ee = runtime->eeScheduler(); + ee.bindMainContextForSyscall(*ctx, rdram); + const uint32_t oldCallback = ee.setGsVSyncCallback(newCallback, gp, sp); static uint32_t s_syncVCallbackLogCount = 0u; if (s_syncVCallbackLogCount < 128u) @@ -1504,11 +1313,6 @@ namespace ps2_stubs ++s_syncVCallbackLogCount; } - if (newCallback != 0u) - { - ps2_syscalls::EnsureVSyncWorkerRunning(rdram, runtime); - } - setReturnU32(ctx, oldCallback); } diff --git a/ps2xRuntime/src/lib/Kernel/Stubs/GS.h b/ps2xRuntime/src/lib/Kernel/Stubs/GS.h index 8cc2e377f..82cd0b8e6 100644 --- a/ps2xRuntime/src/lib/Kernel/Stubs/GS.h +++ b/ps2xRuntime/src/lib/Kernel/Stubs/GS.h @@ -4,8 +4,6 @@ namespace ps2_stubs { - void resetGsSyncVCallbackState(); - void dispatchGsSyncVCallback(uint8_t *rdram, PS2Runtime *runtime, uint64_t tick); void sceGifPkAddGsAD(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime); void sceGifPkAddGsData(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime); void sceGifPkCloseGifTag(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime); diff --git a/ps2xRuntime/src/lib/Kernel/Stubs/IPU.cpp b/ps2xRuntime/src/lib/Kernel/Stubs/IPU.cpp index a589216e6..e851bd256 100644 --- a/ps2xRuntime/src/lib/Kernel/Stubs/IPU.cpp +++ b/ps2xRuntime/src/lib/Kernel/Stubs/IPU.cpp @@ -1,47 +1,19 @@ #include "Common.h" #include "IPU.h" +#include "runtime/ee_scheduler.h" -namespace ps2_stubs +namespace { - void sceIpuInit(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) + constexpr uint32_t REG_IPU_CTRL = 0x10002010u; + constexpr uint32_t REG_IPU_CMD = 0x10002000u; + constexpr uint32_t REG_IPU_IN_FIFO = 0x10007010u; + constexpr uint32_t IQVAL_BASE = 0x1721e0u; + constexpr uint32_t VQVAL_BASE = 0x172230u; + constexpr uint32_t SETD4_CHCR_ENTRY = 0x126428u; + + void completeIpuInit(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { - static constexpr uint32_t REG_IPU_CTRL = 0x10002010u; - static constexpr uint32_t REG_IPU_CMD = 0x10002000u; - static constexpr uint32_t REG_IPU_IN_FIFO = 0x10007010u; - static constexpr uint32_t IQVAL_BASE = 0x1721e0u; - static constexpr uint32_t VQVAL_BASE = 0x172230u; - static constexpr uint32_t SETD4_CHCR_ENTRY = 0x126428u; - - if (!runtime) - return; - - if (!runtime->memory().getRDRAM()) - { - if (!runtime->memory().initialize()) - { - setReturnS32(ctx, -1); - return; - } - } - - if (!runtime->syncCoreSubsystems()) - { - setReturnS32(ctx, -1); - return; - } - PS2Memory &mem = runtime->memory(); - - if (runtime->hasFunction(SETD4_CHCR_ENTRY)) - { - auto setD4 = runtime->lookupFunction(SETD4_CHCR_ENTRY); - ctx->r[4] = _mm_set_epi64x(0, 1); - { - PS2Runtime::GuestExecutionScope guestExecution(runtime); - setD4(rdram, ctx, runtime); - } - } - mem.write32(REG_IPU_CTRL, 0x40000000u); mem.write32(REG_IPU_CMD, 0u); @@ -70,12 +42,54 @@ namespace ps2_stubs mem.write32(REG_IPU_CMD, 0x60000000u); mem.write32(REG_IPU_CMD, 0x90000000u); - mem.write32(REG_IPU_CTRL, 0x40000000u); mem.write32(REG_IPU_CMD, 0u); - setReturnS32(ctx, 0); } +} + +namespace ps2_stubs +{ + void sceIpuInit(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) + { + if (!runtime) + return; + + if (!runtime->memory().getRDRAM()) + { + if (!runtime->memory().initialize()) + { + setReturnS32(ctx, -1); + return; + } + } + + if (!runtime->syncCoreSubsystems()) + { + setReturnS32(ctx, -1); + return; + } + + if (runtime->hasFunction(SETD4_CHCR_ENTRY)) + { + EeScheduler &scheduler = runtime->eeScheduler(); + scheduler.bindMainContextForSyscall(*ctx, rdram); + GuestInvocation invocation{}; + invocation.kind = GuestInvocationKind::HleCall; + invocation.context = *ctx; + invocation.context.pc = SETD4_CHCR_ENTRY; + SET_GPR_U32(&invocation.context, 4, 1u); + SET_GPR_U32(&invocation.context, 29, 0u); + SET_GPR_U32(&invocation.context, 31, 0u); + invocation.onComplete = [rdram, runtime](const R5900Context &, R5900Context &parent) + { + completeIpuInit(rdram, &parent, runtime); + }; + scheduler.invokeCurrent(std::move(invocation)); + } + + completeIpuInit(rdram, ctx, runtime); + } void sceIpuRestartDMA(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { diff --git a/ps2xRuntime/src/lib/Kernel/Stubs/MPEG.cpp b/ps2xRuntime/src/lib/Kernel/Stubs/MPEG.cpp index bd161d479..8e1e2ddc1 100644 --- a/ps2xRuntime/src/lib/Kernel/Stubs/MPEG.cpp +++ b/ps2xRuntime/src/lib/Kernel/Stubs/MPEG.cpp @@ -1,5 +1,6 @@ #include "Common.h" #include "MPEG.h" +#include "runtime/ee_scheduler.h" #if !defined(PS2X_HAS_FFMPEG) #define PS2X_HAS_FFMPEG 1 @@ -15,8 +16,6 @@ extern "C" } #endif -#include -#include #include #include @@ -472,16 +471,11 @@ namespace ps2_stubs bool streamEnded = false; bool decoderFailed = false; uint64_t cdStreamGeneration = 0u; - bool noFrameStallArmed = false; - std::chrono::steady_clock::time_point noFrameStallStart{}; - uint32_t consecutiveEmptyGetPicture = 0u; bool waitingForVideoSequenceHeader = true; std::vector videoSequenceSyncBuffer; std::vector pssBuffer; std::vector pssGuestAddrs; std::deque decodedFrames; - bool hasLastFrame = false; - MpegDecodedFrame lastFrame; std::unique_ptr decoder; }; @@ -513,7 +507,7 @@ namespace ps2_stubs }; std::mutex g_mpeg_stub_mutex; - std::condition_variable g_mpeg_cv; + constexpr uint32_t kMpegPictureWaitType = 1u; MpegStubState g_mpeg_stub_state; // TODO this resolution should follow runtime resolution @@ -529,10 +523,6 @@ namespace ps2_stubs constexpr uint8_t kMpegPrivateStream1 = 0xBDu; constexpr size_t kStartCodeNotFound = std::numeric_limits::max(); constexpr uint32_t kMpegCallbackDataSize = 0x20u; - constexpr uint32_t kMpegCallbackMaxSteps = 0x4000u; - constexpr std::chrono::milliseconds kMpegGetPictureNoFrameWaitTimeout{64}; - constexpr std::chrono::milliseconds kMpegNoFrameEndTimeout{500}; - constexpr uint32_t kMpegMaxConsecutiveEmptyGetPicture = 60u; uint32_t align16(uint32_t value) { @@ -732,77 +722,6 @@ namespace ps2_stubs } } - void clearNoFrameStall(MpegPlaybackState &playback) - { - playback.noFrameStallArmed = false; - playback.noFrameStallStart = {}; - } - - void finishPlaybackStream(uint32_t mpegAddr, MpegPlaybackState &playback); - - bool maybeFinishNoFrameStall(uint32_t mpegAddr, MpegPlaybackState &playback) - { - if (playback.streamEnded || playback.decoderFailed || !playback.decodedFrames.empty()) - { - clearNoFrameStall(playback); - playback.consecutiveEmptyGetPicture = 0u; - return false; - } - - if (!playback.sawInput || playback.picturesServed == 0u) - { - return false; - } - - const auto now = std::chrono::steady_clock::now(); - const bool cdStreamEofSeen = g_mpeg_stub_state.currentCdStreamEofSeen; - - bool stallByNoFrame = false; - if (cdStreamEofSeen) - { - if (!playback.noFrameStallArmed) - { - playback.noFrameStallArmed = true; - playback.noFrameStallStart = now; - } - else if (now - playback.noFrameStallStart >= kMpegNoFrameEndTimeout) - { - stallByNoFrame = true; - } - } - else - { - clearNoFrameStall(playback); - } - - const bool stallByConsecutive = - cdStreamEofSeen && (playback.consecutiveEmptyGetPicture >= kMpegMaxConsecutiveEmptyGetPicture); - - if (!stallByNoFrame && !stallByConsecutive) - { - return false; - } - - finishPlaybackStream(mpegAddr, playback); - - static uint32_t s_noFrameEofLogCount = 0u; - if (s_noFrameEofLogCount < 16u) - { - PS2_IF_AGRESSIVE_LOGS({ - std::cerr << "[MPEG:no-frame-eof] mpeg=0x" << std::hex << mpegAddr - << std::dec << " served=" << playback.picturesServed - << " sawInput=" << playback.sawInput - << " cdEof=" << cdStreamEofSeen - << " reason=" - << (stallByNoFrame ? "no-frame" : "consecutive") - << " consecutiveEmpty=" << playback.consecutiveEmptyGetPicture - << std::endl; - }); - ++s_noFrameEofLogCount; - } - return true; - } - void feedElementaryStream(MpegPlaybackState &playback, const uint8_t *data, size_t size) { if (!data || size == 0) @@ -890,10 +809,6 @@ namespace ps2_stubs playback.videoSequenceSyncBuffer.clear(); flushDecoderIfEnded(playback); - if (!playback.decodedFrames.empty()) - { - clearNoFrameStall(playback); - } } void erasePssPrefix(MpegPlaybackState &playback, size_t count) @@ -1190,10 +1105,6 @@ namespace ps2_stubs playback.pssGuestAddrs.push_back(guestAddr + static_cast(i)); } processPssBuffer(mpegAddr, playback, callbackEvents); - if (!playback.decodedFrames.empty()) - { - clearNoFrameStall(playback); - } } size_t appendGuestBytes(uint32_t mpegAddr, @@ -1317,15 +1228,6 @@ namespace ps2_stubs return; } - thread_local PS2Runtime *s_callbackStackRuntime = nullptr; - thread_local uint32_t s_callbackStackTop = 0u; - if (s_callbackStackRuntime != runtime || s_callbackStackTop == 0u) - { - constexpr uint32_t kCallbackStackSize = 0x4000u; - s_callbackStackRuntime = runtime; - s_callbackStackTop = runtime->reserveAsyncCallbackStack(kCallbackStackSize, 16u); - } - const uint32_t cbDataAddr = runtime->guestMalloc(kMpegCallbackDataSize, 16u); if (cbDataAddr == 0u) { @@ -1342,61 +1244,18 @@ namespace ps2_stubs SET_GPR_U32(&callbackCtx, 5, cbDataAddr); SET_GPR_U32(&callbackCtx, 6, callback.data); SET_GPR_U32(&callbackCtx, 7, 0u); - SET_GPR_U32(&callbackCtx, 29, (s_callbackStackTop != 0u) ? s_callbackStackTop : (PS2_RAM_SIZE - 0x10u)); + SET_GPR_U32(&callbackCtx, 29, 0u); SET_GPR_U32(&callbackCtx, 31, 0u); callbackCtx.pc = callback.func; - uint32_t steps = 0u; - bool reschedulePending = false; - uint64_t handoffBaseline = 0u; - { - PS2Runtime::GuestExecutionScope guestExecution(runtime); - PS2Runtime::DeferredGuestYieldScope deferYield(reschedulePending); - - while (callbackCtx.pc != 0u && !runtime->isStopRequested() && steps < kMpegCallbackMaxSteps) - { - if (!runtime->hasFunction(callbackCtx.pc)) - { - static uint32_t badPcLogCount = 0u; - if (badPcLogCount < 16u) - { - std::cerr << "[MPEG:callback:bad-pc] cb=0x" << std::hex << callback.func - << " pc=0x" << callbackCtx.pc - << " ra=0x" << getRegU32(&callbackCtx, 31) - << std::dec << std::endl; - ++badPcLogCount; - } - break; - } - - PS2Runtime::RecompiledFunction step = runtime->lookupFunction(callbackCtx.pc); - if (!step) - { - break; - } - - step(rdram, &callbackCtx, runtime); - ++steps; - } - handoffBaseline = runtime->guestExecutionHandoffEpochSnapshot(); - } - if (reschedulePending && !runtime->isStopRequested()) + GuestInvocation invocation{}; + invocation.kind = GuestInvocationKind::RpcCallback; + invocation.context = callbackCtx; + invocation.onComplete = [runtime, cbDataAddr](const R5900Context &, R5900Context &) { - runtime->waitForGuestExecutionHandoff(handoffBaseline); - } - - if (steps >= kMpegCallbackMaxSteps) - { - static uint32_t stepLimitLogCount = 0u; - if (stepLimitLogCount < 16u) - { - std::cerr << "[MPEG:callback:step-limit] cb=0x" << std::hex << callback.func - << " pc=0x" << callbackCtx.pc << std::dec << std::endl; - ++stepLimitLogCount; - } - } - - runtime->guestFree(cbDataAddr); + runtime->guestFree(cbDataAddr); + }; + runtime->eeScheduler().queueInvocation(std::move(invocation)); } void dispatchStreamCallbacks(uint8_t *rdram, @@ -1428,7 +1287,6 @@ namespace ps2_stubs return; } - PS2Runtime::GuestExecutionReleaseScope releaseGuestExecution(runtime); dispatchStreamCallbacks(rdram, ctx, runtime, events); } @@ -1543,11 +1401,27 @@ namespace ps2_stubs { std::lock_guard lock(g_mpeg_stub_mutex); resetMpegStubStateUnlocked(); - g_mpeg_cv.notify_all(); } - void notifyMpegCdStreamStart() + void enqueueMpegDecodedFrameForTesting(uint32_t mpegAddr) + { + constexpr int kTestFrameWidth = 16; + constexpr int kTestFrameHeight = 16; + + MpegDecodedFrame frame; + frame.width = kTestFrameWidth; + frame.height = kTestFrameHeight; + frame.rgba.resize(static_cast(kTestFrameWidth * kTestFrameHeight * 4), 0x80u); + + std::lock_guard lock(g_mpeg_stub_mutex); + MpegPlaybackState &playback = getPlaybackState(mpegAddr); + playback.sawInput = true; + playback.decodedFrames.push_back(std::move(frame)); + } + + void notifyMpegCdStreamStart(PS2Runtime *runtime) { + (void)runtime; std::lock_guard lock(g_mpeg_stub_mutex); ++g_mpeg_stub_state.cdStreamGeneration; g_mpeg_stub_state.currentCdStreamEofSeen = false; @@ -1566,23 +1440,26 @@ namespace ps2_stubs std::cerr << "[MPEG:CdStreamStart] generation=" << g_mpeg_stub_state.cdStreamGeneration << " reopened=" << g_mpeg_stub_state.playbackByMpeg.size() << std::endl; }); - g_mpeg_cv.notify_all(); } - void notifyMpegCdStreamEof() + void notifyMpegCdStreamEof(PS2Runtime *runtime) { - std::lock_guard lock(g_mpeg_stub_mutex); - g_mpeg_stub_state.currentCdStreamEofSeen = true; + std::vector completedMpegIds; bool changed = false; - for (auto &[mpegAddr, playback] : g_mpeg_stub_state.playbackByMpeg) { - if (!playback.sawInput || playback.streamEnded) + std::lock_guard lock(g_mpeg_stub_mutex); + g_mpeg_stub_state.currentCdStreamEofSeen = true; + for (auto &[mpegAddr, playback] : g_mpeg_stub_state.playbackByMpeg) { - continue; - } + completedMpegIds.push_back(mpegAddr); + if (!playback.sawInput || playback.streamEnded) + { + continue; + } - finishPlaybackStream(mpegAddr, playback); - changed = true; + finishPlaybackStream(mpegAddr, playback); + changed = true; + } } if (changed) @@ -1595,52 +1472,58 @@ namespace ps2_stubs }); ++s_eofLogCount; } - g_mpeg_cv.notify_all(); + } + if (runtime) + { + for (const uint32_t mpegAddr : completedMpegIds) + { + runtime->eeScheduler().completeExternalWait(kMpegPictureWaitType, mpegAddr, KE_OK); + } } } void sceMpegFlush(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { (void)rdram; - (void)runtime; - const uint32_t mpegAddr = getRegU32(ctx, 4); - std::lock_guard lock(g_mpeg_stub_mutex); - MpegPlaybackState &playback = getPlaybackState(mpegAddr); - if (playback.decoder) { - playback.decoder->flush(playback.decodedFrames); + std::lock_guard lock(g_mpeg_stub_mutex); + MpegPlaybackState &playback = getPlaybackState(mpegAddr); + if (playback.decoder) + { + playback.decoder->flush(playback.decodedFrames); + } } - g_mpeg_cv.notify_all(); + runtime->eeScheduler().completeExternalWait(kMpegPictureWaitType, mpegAddr, KE_OK); setReturnS32(ctx, 0); } void sceMpegAddBs(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { - (void)runtime; - const uint32_t mpegAddr = getRegU32(ctx, 4); const uint32_t dataAddr = getRegU32(ctx, 5); const uint32_t byteCount = getRegU32(ctx, 6); - std::lock_guard lock(g_mpeg_stub_mutex); - MpegPlaybackState &playback = getPlaybackState(mpegAddr); size_t copied = 0u; - while (copied < byteCount) { - const uint32_t curAddr = dataAddr + static_cast(copied); - const uint32_t offset = curAddr & PS2_RAM_MASK; - const size_t chunk = std::min(static_cast(byteCount) - copied, PS2_RAM_SIZE - offset); - const uint8_t *src = getConstMemPtr(rdram, curAddr); - if (!src || chunk == 0u) + std::lock_guard lock(g_mpeg_stub_mutex); + MpegPlaybackState &playback = getPlaybackState(mpegAddr); + while (copied < byteCount) { - break; + const uint32_t curAddr = dataAddr + static_cast(copied); + const uint32_t offset = curAddr & PS2_RAM_MASK; + const size_t chunk = std::min(static_cast(byteCount) - copied, PS2_RAM_SIZE - offset); + const uint8_t *src = getConstMemPtr(rdram, curAddr); + if (!src || chunk == 0u) + { + break; + } + feedElementaryStream(playback, src, chunk); + copied += chunk; } - feedElementaryStream(playback, src, chunk); - copied += chunk; } - g_mpeg_cv.notify_all(); + runtime->eeScheduler().completeExternalWait(kMpegPictureWaitType, mpegAddr, KE_OK); setReturnS32(ctx, static_cast(copied)); } @@ -1801,12 +1684,14 @@ namespace ps2_stubs void sceMpegDelete(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { (void)rdram; - (void)runtime; const uint32_t mpegAddr = getRegU32(ctx, 4); - std::lock_guard lock(g_mpeg_stub_mutex); - g_mpeg_stub_state.callbacksByMpeg.erase(mpegAddr); - g_mpeg_stub_state.playbackByMpeg.erase(mpegAddr); + { + std::lock_guard lock(g_mpeg_stub_mutex); + g_mpeg_stub_state.callbacksByMpeg.erase(mpegAddr); + g_mpeg_stub_state.playbackByMpeg.erase(mpegAddr); + } + runtime->eeScheduler().completeExternalWait(kMpegPictureWaitType, mpegAddr, KE_WAIT_DELETE); setReturnU32(ctx, 0u); } @@ -1821,14 +1706,13 @@ namespace ps2_stubs size_t decodedCount = 0u; uint32_t traceIdx = 0u; { - PS2Runtime::GuestExecutionReleaseScope releaseGuestExecution(runtime); std::lock_guard lock(g_mpeg_stub_mutex); MpegPlaybackState &playback = getPlaybackState(mpegAddr); consumed = appendGuestBytes(mpegAddr, playback, rdram, dataAddr, byteCount, callbackEvents); decodedCount = playback.decodedFrames.size(); traceIdx = g_mpeg_stub_state.demuxPssTraceCount++; } - g_mpeg_cv.notify_all(); + runtime->eeScheduler().completeExternalWait(kMpegPictureWaitType, mpegAddr, KE_OK); if (traceIdx < 32u) { @@ -1872,8 +1756,6 @@ namespace ps2_stubs size_t decodedCount = 0u; uint32_t traceIdx = 0u; { - // This prevents an ABBA deadlock with sceMpegGetPicture on thread 5, need investigation on other games - PS2Runtime::GuestExecutionReleaseScope releaseGuestExecution(runtime); std::lock_guard lock(g_mpeg_stub_mutex); MpegPlaybackState &playback = getPlaybackState(mpegAddr); consumed = appendGuestRingBytes( @@ -1888,7 +1770,7 @@ namespace ps2_stubs decodedCount = playback.decodedFrames.size(); traceIdx = g_mpeg_stub_state.demuxRingTraceCount++; } - g_mpeg_cv.notify_all(); + runtime->eeScheduler().completeExternalWait(kMpegPictureWaitType, mpegAddr, KE_OK); if (traceIdx < 32u) { @@ -1959,84 +1841,36 @@ namespace ps2_stubs bool haveFrame = false; MpegDecodedFrame frame; { - PS2Runtime::GuestExecutionReleaseScope releaseGuestExecution(runtime); std::unique_lock lock(g_mpeg_stub_mutex); MpegPlaybackState &playback = getPlaybackState(mpegAddr); - const uint64_t waitCdStreamGeneration = g_mpeg_stub_state.cdStreamGeneration; - - if (playback.decodedFrames.empty()) + if (playback.decodedFrames.empty() && + !g_mpeg_stub_state.currentCdStreamEofSeen && + !playback.streamEnded && + !playback.decoderFailed) { - playback.consecutiveEmptyGetPicture++; if (g_mpeg_stub_state.getPictureWaitTraceCount < 32u) { PS2_IF_AGRESSIVE_LOGS({ std::cerr << "[MPEG:GetPicture] waiting for frames, mpeg=0x" << std::hex << mpegAddr << std::dec << " ended=" << playback.streamEnded << " failed=" << playback.decoderFailed - << " sawInput=" << playback.sawInput - << " consec=" << playback.consecutiveEmptyGetPicture << std::endl; + << " sawInput=" << playback.sawInput << std::endl; }); ++g_mpeg_stub_state.getPictureWaitTraceCount; } - } - - std::shared_ptr currentThreadInfo = nullptr; - { - std::lock_guard mapLock(g_thread_map_mutex); - auto it = g_threads.find(g_currentThreadId); - if (it != g_threads.end()) - currentThreadInfo = it->second; - } - - const auto noFrameWaitStart = std::chrono::steady_clock::now(); - while (runtime && - g_mpeg_stub_state.playbackByMpeg.find(mpegAddr) != g_mpeg_stub_state.playbackByMpeg.end() && - getPlaybackState(mpegAddr).decodedFrames.empty() && - !getPlaybackState(mpegAddr).streamEnded && - !getPlaybackState(mpegAddr).decoderFailed && - g_mpeg_stub_state.cdStreamGeneration == waitCdStreamGeneration && - !runtime->isStopRequested() && - (!currentThreadInfo || !currentThreadInfo->terminated.load(std::memory_order_relaxed))) - { - g_mpeg_cv.wait_for(lock, std::chrono::milliseconds(8)); - - auto playbackIt = g_mpeg_stub_state.playbackByMpeg.find(mpegAddr); - if (playbackIt == g_mpeg_stub_state.playbackByMpeg.end()) - { - break; - } - - MpegPlaybackState &waitPlayback = playbackIt->second; - if (maybeFinishNoFrameStall(mpegAddr, waitPlayback)) - { - break; - } - - if (!g_mpeg_stub_state.currentCdStreamEofSeen && - std::chrono::steady_clock::now() - noFrameWaitStart >= kMpegGetPictureNoFrameWaitTimeout) - { - static uint32_t s_noFrameYieldLogCount = 0u; - if (s_noFrameYieldLogCount < 16u) + lock.unlock(); + runtime->eeScheduler().waitExternal( + EeWaitReason::Mpeg, + kMpegPictureWaitType, + mpegAddr, + [rdram, runtime](R5900Context &resumeContext) { - PS2_IF_AGRESSIVE_LOGS({ - std::cerr << "[MPEG:GetPicture:yield] mpeg=0x" << std::hex << mpegAddr - << std::dec << " generation=" << g_mpeg_stub_state.cdStreamGeneration - << " sawInput=" << waitPlayback.sawInput - << " served=" << waitPlayback.picturesServed - << " cdEof=" << g_mpeg_stub_state.currentCdStreamEofSeen - << std::endl; - }); - ++s_noFrameYieldLogCount; - } - break; - } - } - - if (g_mpeg_stub_state.playbackByMpeg.find(mpegAddr) == g_mpeg_stub_state.playbackByMpeg.end()) - { - // The MPEG decoder was deleted while we were waiting. - setReturnS32(ctx, -1); - return; + if (static_cast(getRegU32(&resumeContext, 2)) < 0) + { + return; + } + sceMpegGetPicture(rdram, &resumeContext, runtime); + }); } if (!playback.decodedFrames.empty()) @@ -2049,9 +1883,6 @@ namespace ps2_stubs height = playback.height; frameCount = playback.picturesServed; playback.picturesServed += 1u; - playback.consecutiveEmptyGetPicture = 0u; - playback.lastFrame = frame; - playback.hasLastFrame = true; haveFrame = true; if (g_mpeg_stub_state.pictureTraceCount < 32u) { @@ -2064,41 +1895,9 @@ namespace ps2_stubs }); ++g_mpeg_stub_state.pictureTraceCount; } - if (!playback.decodedFrames.empty()) - { - clearNoFrameStall(playback); - } - } - else if (!g_mpeg_stub_state.currentCdStreamEofSeen && - playback.sawInput && - playback.hasLastFrame && - playback.picturesServed > 0u && - !playback.streamEnded && - !playback.decoderFailed) - { - frame = playback.lastFrame; - width = static_cast(frame.width); - height = static_cast(frame.height); - frameCount = playback.picturesServed; - playback.picturesServed += 1u; - playback.consecutiveEmptyGetPicture = 0u; - haveFrame = true; - - static uint32_t s_duplicateFrameLogCount = 0u; - if (s_duplicateFrameLogCount < 16u) - { - PS2_IF_AGRESSIVE_LOGS({ - std::cerr << "[MPEG:GetPicture:DUP] mpeg=0x" << std::hex << mpegAddr - << std::dec << " generation=" << g_mpeg_stub_state.cdStreamGeneration - << " frame=" << frameCount - << " size=" << width << "x" << height << std::endl; - }); - ++s_duplicateFrameLogCount; - } } else { - maybeFinishNoFrameStall(mpegAddr, playback); width = playback.width; height = playback.height; frameCount = playback.picturesServed; @@ -2147,8 +1946,6 @@ namespace ps2_stubs void sceMpegInit(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { (void)rdram; - (void)runtime; - std::lock_guard lock(g_mpeg_stub_mutex); const uint64_t cdStreamGeneration = g_mpeg_stub_state.cdStreamGeneration; const bool currentCdStreamEofSeen = g_mpeg_stub_state.currentCdStreamEofSeen; @@ -2156,21 +1953,17 @@ namespace ps2_stubs g_mpeg_stub_state.initialized = true; g_mpeg_stub_state.cdStreamGeneration = cdStreamGeneration; g_mpeg_stub_state.currentCdStreamEofSeen = currentCdStreamEofSeen; - g_mpeg_cv.notify_all(); setReturnU32(ctx, 0u); } void sceMpegIsEnd(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { (void)rdram; - // runtime used below for GuestExecutionReleaseScope const uint32_t mpegAddr = getRegU32(ctx, 4); - PS2Runtime::GuestExecutionReleaseScope releaseGuestExecution(runtime); std::lock_guard lock(g_mpeg_stub_mutex); g_mpeg_stub_state.initialized = true; MpegPlaybackState &playback = getPlaybackState(mpegAddr); - maybeFinishNoFrameStall(mpegAddr, playback); const bool ended = playback.streamEnded || (playback.decoderFailed && playback.sawInput); if (g_mpeg_stub_state.isEndTraceCount < 16u) diff --git a/ps2xRuntime/src/lib/Kernel/Stubs/MPEG.h b/ps2xRuntime/src/lib/Kernel/Stubs/MPEG.h index bd9a8d5a4..76225e990 100644 --- a/ps2xRuntime/src/lib/Kernel/Stubs/MPEG.h +++ b/ps2xRuntime/src/lib/Kernel/Stubs/MPEG.h @@ -5,8 +5,9 @@ namespace ps2_stubs { void resetMpegStubState(); - void notifyMpegCdStreamStart(); - void notifyMpegCdStreamEof(); + void enqueueMpegDecodedFrameForTesting(uint32_t mpegAddr); + void notifyMpegCdStreamStart(PS2Runtime *runtime = nullptr); + void notifyMpegCdStreamEof(PS2Runtime *runtime = nullptr); void sceMpegFlush(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime); void sceMpegAddBs(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime); void sceMpegAddCallback(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime); diff --git a/ps2xRuntime/src/lib/Kernel/Syscalls/Common.h b/ps2xRuntime/src/lib/Kernel/Syscalls/Common.h index a0ba1325a..e7362e095 100644 --- a/ps2xRuntime/src/lib/Kernel/Syscalls/Common.h +++ b/ps2xRuntime/src/lib/Kernel/Syscalls/Common.h @@ -1,6 +1,7 @@ #include "ps2_syscalls.h" #include "ps2_log.h" #include "ps2_runtime.h" +#include "runtime/ee_scheduler.h" #include "ps2_runtime_macros.h" #include "ps2_stubs.h" #include @@ -14,7 +15,6 @@ #include #include #include -#include #include #include #include @@ -35,10 +35,51 @@ std::string translatePs2Path(const char *ps2Path); #include "Helpers/Loader.h" #include "Helpers/Runtime.h" -namespace ps2_syscalls +inline bool resolveEeGuestRange(uint32_t address, size_t size, uint32_t &offset, bool &scratch) { - inline void yieldGuestExecutionAfterWake(PS2Runtime *runtime) + scratch = ps2IsScratchpadAddress(address); + if (scratch) { - runtime->yieldGuestExecutionAfterWake(); + offset = ps2ScratchpadOffset(address); + return size <= PS2_SCRATCHPAD_SIZE && offset <= PS2_SCRATCHPAD_SIZE - size; } + + if (address < PS2_RAM_SIZE) + { + offset = address; + } + else if ((address >= 0x20000000u && address < 0x40000000u) || + (address >= 0x80000000u && address < 0xC0000000u)) + { + offset = address & 0x1FFFFFFFu; + } + else + { + return false; + } + return size <= PS2_RAM_SIZE && offset <= PS2_RAM_SIZE - size; +} + +template +inline const T *getEeGuestStruct(const uint8_t *rdram, uint32_t address) +{ + uint32_t offset = 0; + bool scratch = false; + if (!rdram || (address & (alignof(T) - 1u)) != 0u || + !resolveEeGuestRange(address, sizeof(T), offset, scratch)) + { + return nullptr; + } + if (scratch) + { + const uint8_t *base = ps2GetScratchpadHostPtr(); + return base ? reinterpret_cast(base + offset) : nullptr; + } + return reinterpret_cast(rdram + offset); +} + +template +inline T *getEeGuestStruct(uint8_t *rdram, uint32_t address) +{ + return const_cast(getEeGuestStruct(static_cast(rdram), address)); } diff --git a/ps2xRuntime/src/lib/Kernel/Syscalls/Helpers/Runtime.h b/ps2xRuntime/src/lib/Kernel/Syscalls/Helpers/Runtime.h index 67a99de16..690936401 100644 --- a/ps2xRuntime/src/lib/Kernel/Syscalls/Helpers/Runtime.h +++ b/ps2xRuntime/src/lib/Kernel/Syscalls/Helpers/Runtime.h @@ -1,153 +1,3 @@ -struct ThreadExitException final : public std::exception -{ - const char *what() const noexcept override - { - return "PS2 Thread Exit"; - } -}; - -static void throwIfTerminated(const std::shared_ptr &info) -{ - if (info && info->terminated.load()) - { - throw ThreadExitException(); - } -} - -// Condition-variable waits in the EE runtime must release the global guest -// execution mutex, but must not reacquire it while still holding the local -// wait-object mutex. Reacquiring guest execution while holding a semaphore, -// thread, event-flag, or vsync mutex can create an ABBA deadlock: -// -// awakened thread: local wait mutex -> waiting for GuestExecutionScope -// running thread: GuestExecutionScope -> waiting for local wait mutex -// -// This helper keeps guest execution released for the whole host wait and for -// any post-wake bookkeeping that needs the local mutex, then unlocks the local -// mutex before the GuestExecutionReleaseScope destructor reacquires guest code. -template -static void waitWithGuestExecutionReleasedUntilUnlocked(PS2Runtime *runtime, - Lock &lock, - WaitFn waitFn, - FinishFn finishFn) -{ - auto releaseGuestExecution = std::make_unique(runtime); - - waitFn(); - finishFn(); - - if (lock.owns_lock()) - { - lock.unlock(); - } - - releaseGuestExecution.reset(); -} - -template -static void waitWithGuestExecutionReleasedUntilUnlocked(PS2Runtime *runtime, Lock &lock, WaitFn waitFn) -{ - waitWithGuestExecutionReleasedUntilUnlocked(runtime, lock, waitFn, []() {}); -} - -static void waitWhileSuspended(const std::shared_ptr &info, PS2Runtime *runtime = nullptr) -{ - if (!info) - return; - - std::unique_lock lock(info->m); - if (info->suspendCount > 0) - { - info->status = THS_SUSPEND; - info->waitType = TSW_NONE; - info->waitId = 0; - - bool terminated = false; - waitWithGuestExecutionReleasedUntilUnlocked( - runtime, - lock, - [&]() - { - info->cv.wait(lock, [&]() - { return info->suspendCount == 0 || info->terminated.load(); }); - }, - [&]() - { - terminated = info->terminated.load(); - if (!terminated) - { - info->status = THS_RUN; - } - }); - - if (terminated) - { - throw ThreadExitException(); - } - } -} - -static std::shared_ptr lookupThreadInfo(int tid) -{ - std::lock_guard lock(g_thread_map_mutex); - auto it = g_threads.find(tid); - if (it != g_threads.end()) - { - return it->second; - } - return nullptr; -} - -static std::shared_ptr ensureCurrentThreadInfo(R5900Context *ctx) -{ - const int tid = g_currentThreadId; - std::lock_guard lock(g_thread_map_mutex); - auto it = g_threads.find(tid); - if (it != g_threads.end()) - { - return it->second; - } - - auto info = std::make_shared(); - info->started = true; - info->status = THS_RUN; - info->currentPriority = info->priority; - info->suspendCount = 0; - if (ctx) - { - info->entry = ctx->pc; - info->stack = getRegU32(ctx, 29); - info->gp = getRegU32(ctx, 28); - } - info->waitType = TSW_NONE; - info->waitId = 0; - - g_threads.emplace(tid, info); - return info; -} - -static std::shared_ptr lookupSemaInfo(int sid) -{ - std::lock_guard lock(g_sema_map_mutex); - auto it = g_semas.find(sid); - if (it != g_semas.end()) - { - return it->second; - } - return nullptr; -} - -static std::shared_ptr lookupEventFlagInfo(int eid) -{ - std::lock_guard lock(g_event_flag_map_mutex); - auto it = g_eventFlags.find(eid); - if (it != g_eventFlags.end()) - { - return it->second; - } - return nullptr; -} - static void setRegU32(R5900Context *ctx, int reg, uint32_t value) { if (!ctx || reg < 0 || reg > 31) @@ -155,104 +5,6 @@ static void setRegU32(R5900Context *ctx, int reg, uint32_t value) SET_GPR_U32(ctx, reg, value); } -static std::chrono::microseconds alarmTicksToDuration(uint16_t ticks) -{ - constexpr uint64_t kAlarmTickUsec = 64u; // Approximate EE H-SYNC tick period. - const uint64_t clampedTicks = (ticks == 0u) ? 1u : static_cast(ticks); - return std::chrono::microseconds(clampedTicks * kAlarmTickUsec); -} - -static void ensureAlarmWorkerRunning() -{ - std::call_once(g_alarm_worker_once, []() - { std::thread([]() - { - for (;;) - { - std::shared_ptr readyAlarm; - { - std::unique_lock lock(g_alarm_mutex); - while (!readyAlarm) - { - if (g_alarms.empty()) - { - g_alarm_cv.wait(lock); - continue; - } - - auto nextIt = std::min_element(g_alarms.begin(), g_alarms.end(), - [](const auto &a, const auto &b) - { - return a.second->dueAt < b.second->dueAt; - }); - if (nextIt == g_alarms.end()) - { - g_alarm_cv.wait(lock); - continue; - } - - const auto now = std::chrono::steady_clock::now(); - if (nextIt->second->dueAt > now) - { - g_alarm_cv.wait_until(lock, nextIt->second->dueAt); - continue; - } - - readyAlarm = nextIt->second; - g_alarms.erase(nextIt); - } - } - - if (!readyAlarm || !readyAlarm->runtime || !readyAlarm->rdram || !readyAlarm->handler) - { - continue; - } - if (!readyAlarm->runtime->hasFunction(readyAlarm->handler)) - { - continue; - } - - try - { - constexpr uint32_t kAlarmCallbackStackSize = 0x4000u; - thread_local PS2Runtime *s_alarmStackRuntime = nullptr; - thread_local uint32_t s_alarmStackTop = 0u; - if (s_alarmStackRuntime != readyAlarm->runtime || s_alarmStackTop == 0u) - { - s_alarmStackRuntime = readyAlarm->runtime; - s_alarmStackTop = readyAlarm->runtime->reserveAsyncCallbackStack(kAlarmCallbackStackSize, 16u); - } - - R5900Context callbackCtx{}; - setRegU32(&callbackCtx, 28, readyAlarm->gp); - setRegU32(&callbackCtx, 29, - (s_alarmStackTop != 0u) ? s_alarmStackTop : (PS2_RAM_SIZE - 0x10u)); - setRegU32(&callbackCtx, 31, 0); - setRegU32(&callbackCtx, 4, static_cast(readyAlarm->id)); - setRegU32(&callbackCtx, 5, static_cast(readyAlarm->ticks)); - setRegU32(&callbackCtx, 6, readyAlarm->commonArg); - setRegU32(&callbackCtx, 7, 0); - callbackCtx.pc = readyAlarm->handler; - - PS2Runtime::RecompiledFunction func = readyAlarm->runtime->lookupFunction(readyAlarm->handler); - func(readyAlarm->rdram, &callbackCtx, readyAlarm->runtime); - } - catch (const ThreadExitException &) - { - } - catch (const std::exception &e) - { - static int alarmExceptionLogs = 0; - if (alarmExceptionLogs < 8) - { - std::cerr << "[SetAlarm] callback exception: " << e.what() << std::endl; - ++alarmExceptionLogs; - } - } - } }) - .detach(); }); -} - static void rpcCopyToRdram(uint8_t *rdram, uint32_t dst, uint32_t src, size_t size) { if (!rdram || size == 0) @@ -331,146 +83,6 @@ static bool readStackU32(uint8_t *rdram, uint32_t sp, uint32_t offset, uint32_t return true; } -enum class RpcInvokeExitReason -{ - Returned, - NullPc, - MissingFunction, - StepLimit, - SamePcLimit -}; - -static const char *rpcInvokeExitReasonName(RpcInvokeExitReason reason) -{ - switch (reason) - { - case RpcInvokeExitReason::Returned: - return "returned"; - case RpcInvokeExitReason::NullPc: - return "null-pc"; - case RpcInvokeExitReason::MissingFunction: - return "missing-function"; - case RpcInvokeExitReason::StepLimit: - return "step-limit"; - case RpcInvokeExitReason::SamePcLimit: - return "same-pc-limit"; - default: - return "unknown"; - } -} - -static bool rpcInvokeFunction(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime, - uint32_t funcAddr, uint32_t a0, uint32_t a1, uint32_t a2, uint32_t a3, uint32_t *outV0) -{ - if (!runtime || !ctx || !funcAddr || !runtime->hasFunction(funcAddr)) - return false; - - constexpr uint32_t kRpcInvokeStackSize = 0x4000u; - constexpr uint32_t kRpcInvokeReturnSentinel = 0x00FFF000u; - constexpr uint32_t kRpcInvokeMaxSteps = 0x8000u; - - R5900Context tmp = *ctx; - setRegU32(&tmp, 4, a0); - setRegU32(&tmp, 5, a1); - setRegU32(&tmp, 6, a2); - setRegU32(&tmp, 7, a3); - - thread_local uint32_t s_rpcInvokeStackBase = 0u; - thread_local uint32_t s_rpcInvokeStackTop = 0u; - if (s_rpcInvokeStackTop == 0u) - { - const uint32_t stackBase = runtime->guestMalloc(kRpcInvokeStackSize, 16u); - if (stackBase != 0u) - { - s_rpcInvokeStackBase = stackBase; - s_rpcInvokeStackTop = (stackBase + kRpcInvokeStackSize) & ~0xFu; - } - } - if (s_rpcInvokeStackTop != 0u) - { - setRegU32(&tmp, 29, s_rpcInvokeStackTop); - } - (void)s_rpcInvokeStackBase; - - setRegU32(&tmp, 31, kRpcInvokeReturnSentinel); - tmp.pc = funcAddr; - - uint32_t steps = 0u; - uint32_t lastPc = 0xFFFFFFFFu; - uint32_t samePcCount = 0u; - RpcInvokeExitReason exitReason = RpcInvokeExitReason::MissingFunction; - while (tmp.pc != 0u && - tmp.pc != kRpcInvokeReturnSentinel && - runtime->hasFunction(tmp.pc) && - steps < kRpcInvokeMaxSteps) - { - const uint32_t pc = tmp.pc; - if (pc == lastPc) - { - ++samePcCount; - if (samePcCount > 0x2000u) - { - exitReason = RpcInvokeExitReason::SamePcLimit; - break; - } - } - else - { - lastPc = pc; - samePcCount = 0u; - } - - PS2Runtime::RecompiledFunction func = runtime->lookupFunction(pc); - { - PS2Runtime::GuestExecutionScope guestExecution(runtime); - func(rdram, &tmp, runtime); - } - ++steps; - } - - if (outV0) - { - *outV0 = getRegU32(&tmp, 2); - } - - if (tmp.pc == kRpcInvokeReturnSentinel) - { - return true; - } - - if (tmp.pc == 0u) - { - exitReason = RpcInvokeExitReason::NullPc; - } - else if (steps >= kRpcInvokeMaxSteps) - { - exitReason = RpcInvokeExitReason::StepLimit; - } - else if (!runtime->hasFunction(tmp.pc)) - { - exitReason = RpcInvokeExitReason::MissingFunction; - } - - static std::atomic s_rpcInvokeFailureLogs{0u}; - constexpr uint32_t kMaxRpcInvokeFailureLogs = 64u; - const uint32_t logIndex = s_rpcInvokeFailureLogs.fetch_add(1u, std::memory_order_relaxed); - if (logIndex < kMaxRpcInvokeFailureLogs) - { - PS2_IF_AGRESSIVE_LOGS({ - std::cerr << "[SyscallOverride:invoke-failed]" - << " func=0x" << std::hex << funcAddr - << " exitPc=0x" << tmp.pc - << " ra=0x" << getRegU32(&tmp, 31) - << std::dec - << " steps=" << steps - << " reason=" << rpcInvokeExitReasonName(exitReason) - << std::endl; - }); - } - - return false; -} - static uint32_t rpcAllocPacketAddr(uint8_t *rdram) { if (kRpcPacketPoolCount == 0) @@ -493,28 +105,6 @@ static uint32_t rpcAllocServerAddr(uint8_t *rdram) return addr; } -struct IrqHandlerInfo -{ - int id = 0; - uint32_t cause = 0; - uint32_t handler = 0; - uint32_t arg = 0; - uint32_t gp = 0; - uint32_t sp = 0; - bool enabled = true; - int order = 0; -}; - -static std::unordered_map g_intcHandlers; -static std::unordered_map g_dmacHandlers; -static int g_nextIntcHandlerId = 1; -static int g_nextDmacHandlerId = 1; - -static int g_intc_head_order = 0; -static int g_intc_tail_order = 1000; -static int g_dmac_head_order = 0; -static int g_dmac_tail_order = 1000; - inline std::string translatePs2Path(const char *ps2Path) { if (!ps2Path || !*ps2Path) diff --git a/ps2xRuntime/src/lib/Kernel/Syscalls/Helpers/State.h b/ps2xRuntime/src/lib/Kernel/Syscalls/Helpers/State.h index db1709269..110b2f39b 100644 --- a/ps2xRuntime/src/lib/Kernel/Syscalls/Helpers/State.h +++ b/ps2xRuntime/src/lib/Kernel/Syscalls/Helpers/State.h @@ -2,40 +2,10 @@ #include #include -#include inline std::unordered_map g_fileDescriptors; inline int g_nextFd = 3; // Start after stdin, stdout, stderr -struct ThreadInfo -{ - uint32_t entry = 0; - uint32_t stack = 0; - uint32_t stackSize = 0; - uint32_t gp = 0; - uint32_t priority = 0; - uint32_t attr = 0; - uint32_t option = 0; - uint32_t arg = 0; - bool started = false; - bool ownsStack = false; - uint32_t tlsBase = 0; - - // Thread Status - int status = 0x10; // THS_DORMANT - int waitType = 0; // TSW_NONE - int waitId = 0; - int wakeupCount = 0; - int currentPriority = 0; - int suspendCount = 0; - std::atomic currentPc{0}; - - std::mutex m; - std::condition_variable cv; - std::atomic forceRelease{false}; - std::atomic terminated{false}; -}; - // Thread status #define THS_RUN 0x01 #define THS_READY 0x02 @@ -138,6 +108,24 @@ struct ee_thread_status_t uint32_t wakeupCount; // 0x2C }; +// PS2SDK EE kernel.h t_ee_thread. CreateThread consumes this full 0x24-byte +// descriptor; it is not the attr-first IOP thread descriptor. +struct ee_thread_t +{ + int status; + uint32_t func; + uint32_t stack; + int stack_size; + uint32_t gp_reg; + int initial_priority; + int current_priority; + uint32_t attr; + uint32_t option; +}; + +static_assert(sizeof(ee_thread_t) == 0x24u); +static_assert(sizeof(ee_thread_status_t) == 0x30u); + struct ee_sema_t { int count; @@ -148,43 +136,7 @@ struct ee_sema_t uint32_t option; }; -struct SemaInfo -{ - int count = 0; - int maxCount = 0; - int initCount = 0; - uint32_t attr = 0; - uint32_t option = 0; - int waiters = 0; - bool deleted = false; - std::mutex m; - std::condition_variable cv; -}; - -struct EventFlagInfo -{ - uint32_t attr = 0; - uint32_t option = 0; - uint32_t initBits = 0; - uint32_t bits = 0; - int waiters = 0; - bool deleted = false; - std::mutex m; - std::condition_variable cv; -}; - -struct AlarmInfo -{ - int id = 0; - uint16_t ticks = 0; - uint32_t handler = 0; - uint32_t commonArg = 0; - uint32_t gp = 0; - uint32_t sp = 0; - uint8_t *rdram = nullptr; - PS2Runtime *runtime = nullptr; - std::chrono::steady_clock::time_point dueAt; -}; +static_assert(sizeof(ee_sema_t) == 0x18u); struct io_stat_t { @@ -204,136 +156,8 @@ static constexpr uint32_t kFioSoIROth = 0x0004; static constexpr uint32_t kFioSoIWOth = 0x0002; static constexpr uint32_t kFioSoIXOth = 0x0001; -inline std::unordered_map> g_threads; -inline int g_nextThreadId = 2; // Reserve 1 for the main thread -inline thread_local int g_currentThreadId = 1; -inline std::mutex g_thread_map_mutex; -inline std::unordered_map g_hostThreads; -inline std::mutex g_host_thread_mutex; - -inline std::unordered_map> g_semas; -inline int g_nextSemaId = 1; -inline std::mutex g_sema_map_mutex; -inline std::unordered_map> g_eventFlags; -inline int g_nextEventFlagId = 1; -inline std::mutex g_event_flag_map_mutex; -inline std::unordered_map> g_alarms; -inline int g_nextAlarmId = 1; -inline std::mutex g_alarm_mutex; -inline std::condition_variable g_alarm_cv; -inline std::once_flag g_alarm_worker_once; -inline std::atomic g_activeThreads{0}; inline std::mutex g_fd_mutex; -static void registerHostThread(int tid, std::thread worker) -{ - std::thread stale; - { - std::lock_guard lock(g_host_thread_mutex); - auto it = g_hostThreads.find(tid); - if (it != g_hostThreads.end()) - { - stale = std::move(it->second); - g_hostThreads.erase(it); - } - g_hostThreads.emplace(tid, std::move(worker)); - } - - if (stale.joinable()) - { - if (stale.get_id() == std::this_thread::get_id()) - { - stale.detach(); - } - else - { - stale.join(); - } - } -} - -static void joinHostThreadById(int tid) -{ - std::thread worker; - { - std::lock_guard lock(g_host_thread_mutex); - auto it = g_hostThreads.find(tid); - if (it != g_hostThreads.end()) - { - worker = std::move(it->second); - g_hostThreads.erase(it); - } - } - - if (!worker.joinable()) - { - return; - } - - if (worker.get_id() == std::this_thread::get_id()) - { - worker.detach(); - } - else - { - worker.join(); - } -} - -static void joinAllHostThreads() -{ - std::vector workers; - { - std::lock_guard lock(g_host_thread_mutex); - workers.reserve(g_hostThreads.size()); - const std::thread::id selfId = std::this_thread::get_id(); - for (auto it = g_hostThreads.begin(); it != g_hostThreads.end();) - { - std::thread &worker = it->second; - if (worker.joinable() && worker.get_id() == selfId) - { - ++it; - continue; - } - - workers.push_back(std::move(worker)); - it = g_hostThreads.erase(it); - } - } - - for (auto &worker : workers) - { - if (!worker.joinable()) - { - continue; - } - worker.join(); - } -} - -static void detachAllHostThreads() -{ - std::vector workers; - { - std::lock_guard lock(g_host_thread_mutex); - workers.reserve(g_hostThreads.size()); - for (auto &entry : g_hostThreads) - { - workers.push_back(std::move(entry.second)); - } - g_hostThreads.clear(); - } - - for (auto &worker : workers) - { - if (!worker.joinable()) - { - continue; - } - worker.detach(); - } -} - struct RpcServerState { uint32_t sid = 0; @@ -397,24 +221,11 @@ inline uint32_t g_rpc_next_id = 1; inline uint32_t g_rpc_packet_index = 0; inline uint32_t g_rpc_server_index = 0; inline uint32_t g_rpc_active_queue = 0; -struct ExitHandlerEntry -{ - uint32_t func = 0; - uint32_t arg = 0; -}; - -inline std::mutex g_exit_handler_mutex; -inline std::unordered_map> g_exit_handlers; - inline std::mutex g_bootmode_mutex; inline bool g_bootmode_initialized = false; inline uint32_t g_bootmode_pool_offset = 0; inline std::unordered_map g_bootmode_addresses; -inline std::mutex g_syscall_override_mutex; -inline std::unordered_map g_syscall_overrides; -inline std::unordered_set g_syscall_mirror_addrs; - static constexpr uint32_t kGuestSyscallTableGuestBase = 0x80011F80u; static constexpr uint32_t kGuestSyscallTablePhysBase = kGuestSyscallTableGuestBase & 0x1FFFFFFFu; static constexpr uint32_t kGuestSyscallMirrorLimit = 0x00080000u; diff --git a/ps2xRuntime/src/lib/Kernel/Syscalls/Interrupt.cpp b/ps2xRuntime/src/lib/Kernel/Syscalls/Interrupt.cpp index f7f1cf99a..2c9801681 100644 --- a/ps2xRuntime/src/lib/Kernel/Syscalls/Interrupt.cpp +++ b/ps2xRuntime/src/lib/Kernel/Syscalls/Interrupt.cpp @@ -1,538 +1,103 @@ #include "Common.h" #include "Interrupt.h" -#include "ps2_log.h" -#include "Stubs/GS.h" namespace ps2_syscalls { - namespace interrupt_state + namespace { - constexpr uint32_t kIntcVblankStart = 2u; - constexpr uint32_t kIntcVblankEnd = 3u; - constexpr auto kVblankPeriod = std::chrono::microseconds(16667); - constexpr int kMaxCatchupTicks = 4; - constexpr uint32_t kMaxIrqHandlerSteps = 4096u; - - std::mutex g_irq_handler_mutex; - std::mutex g_irq_worker_mutex; - std::condition_variable g_irq_worker_cv; - std::mutex g_vsync_flag_mutex; - std::condition_variable g_vsync_cv; - std::atomic g_irq_worker_stop{false}; - std::atomic g_irq_worker_running{false}; - uint32_t g_enabled_intc_mask = 0xFFFFFFFFu; - uint32_t g_enabled_dmac_mask = 0xFFFFFFFFu; - uint64_t g_vsync_tick_counter = 0u; - VSyncFlagRegistration g_vsync_registration{}; - } - - using namespace interrupt_state; - - static void writeGuestU32NoThrow(uint8_t *rdram, uint32_t addr, uint32_t value) - { - if (addr == 0u) - { - return; - } - - uint8_t *dst = getMemPtr(rdram, addr); - if (!dst) - { - return; - } - std::memcpy(dst, &value, sizeof(value)); - } - - static void writeGuestU64NoThrow(uint8_t *rdram, uint32_t addr, uint64_t value) - { - if (addr == 0u) - { - return; - } - - uint8_t *dst = getMemPtr(rdram, addr); - if (!dst) - { - return; - } - std::memcpy(dst, &value, sizeof(value)); - } - - static uint32_t readGuestU32NoThrow(uint8_t *rdram, uint32_t addr) - { - if (addr == 0u) - { - return 0u; - } - - uint8_t *src = getMemPtr(rdram, addr); - if (!src) - { - return 0u; - } - - uint32_t value = 0u; - std::memcpy(&value, src, sizeof(value)); - return value; - } - - static uint32_t getAsyncHandlerStackTop(PS2Runtime *runtime) - { - constexpr uint32_t kAsyncHandlerStackSize = 0x4000u; - thread_local PS2Runtime *s_cachedRuntime = nullptr; - thread_local uint32_t s_cachedStackTop = 0u; - - if (runtime == nullptr) + EeScheduler &scheduler(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { - return PS2_RAM_SIZE - 0x10u; + EeScheduler &result = runtime->eeScheduler(); + result.bindMainContextForSyscall(*ctx, rdram); + return result; } - if (s_cachedRuntime != runtime || s_cachedStackTop == 0u) + void setCauseEnabled(uint8_t *rdram, + R5900Context *ctx, + PS2Runtime *runtime, + bool dmac, + bool enabled) { - s_cachedRuntime = runtime; - s_cachedStackTop = runtime->reserveAsyncCallbackStack(kAsyncHandlerStackSize, 16u); + setReturnS32(ctx, + scheduler(rdram, ctx, runtime) + .setIrqCauseEnabled(dmac, getRegU32(ctx, 4), enabled)); } - return (s_cachedStackTop != 0u) ? s_cachedStackTop : (PS2_RAM_SIZE - 0x10u); - } - - static void dispatchIntcHandlersForCause(uint8_t *rdram, PS2Runtime *runtime, uint32_t cause) - { - if (!rdram || !runtime) + void addHandler(uint8_t *rdram, + R5900Context *ctx, + PS2Runtime *runtime, + bool dmac) { - return; + const int id = scheduler(rdram, ctx, runtime) + .addIrqHandler(dmac, + getRegU32(ctx, 4), + getRegU32(ctx, 5), + getRegU32(ctx, 6) != 0u, + getRegU32(ctx, 7), + getRegU32(ctx, 28), + getRegU32(ctx, 29)); + setReturnS32(ctx, id); } - std::vector handlers; + void removeHandler(uint8_t *rdram, + R5900Context *ctx, + PS2Runtime *runtime, + bool dmac) { - std::lock_guard lock(g_irq_handler_mutex); - if (cause < 32u && (g_enabled_intc_mask & (1u << cause)) == 0u) - { - return; - } - - handlers.reserve(g_intcHandlers.size()); - for (const auto &[id, info] : g_intcHandlers) - { - (void)id; - if (!info.enabled) - { - continue; - } - if (info.cause != cause) - { - continue; - } - if (info.handler == 0u) - { - continue; - } - handlers.push_back(info); - } - std::sort(handlers.begin(), handlers.end(), [](const IrqHandlerInfo &a, const IrqHandlerInfo &b) - { return a.order < b.order; }); + setReturnS32(ctx, + scheduler(rdram, ctx, runtime) + .removeIrqHandler(dmac, + getRegU32(ctx, 4), + static_cast(getRegU32(ctx, 5)))); } - for (const IrqHandlerInfo &info : handlers) + void setHandlerEnabled(uint8_t *rdram, + R5900Context *ctx, + PS2Runtime *runtime, + bool dmac, + bool enabled) { - if (!runtime->hasFunction(info.handler)) - { - if (cause == kIntcVblankStart) - { - PS2_IF_AGRESSIVE_LOGS({ - static std::atomic s_missingHandlerLogCount{0u}; - const uint32_t logIndex = s_missingHandlerLogCount.fetch_add(1u, std::memory_order_relaxed); - if (logIndex < 32u) - { - auto flags = std::cout.flags(); - std::cout << "[INTC:missing] cause=" << cause - << " handler=0x" << std::hex << info.handler - << std::dec - << " id=" << info.id - << std::endl; - std::cout.flags(flags); - } - }); - } - continue; - } - - try - { - R5900Context irqCtx{}; - SET_GPR_U32(&irqCtx, 28, info.gp); - SET_GPR_U32(&irqCtx, 29, getAsyncHandlerStackTop(runtime)); - SET_GPR_U32(&irqCtx, 31, 0u); - SET_GPR_U32(&irqCtx, 4, cause); - SET_GPR_U32(&irqCtx, 5, info.arg); - SET_GPR_U32(&irqCtx, 6, 0u); - SET_GPR_U32(&irqCtx, 7, 0u); - irqCtx.pc = info.handler; - - bool reschedulePending = false; - uint64_t handoffBaseline = 0u; - uint32_t steps = 0u; - { - PS2Runtime::GuestExecutionScope guestExecution(runtime); - PS2Runtime::DeferredGuestYieldScope deferYield(reschedulePending); - - while (irqCtx.pc != 0u && runtime && !runtime->isStopRequested() && steps < kMaxIrqHandlerSteps) - { - PS2Runtime::RecompiledFunction step = runtime->lookupFunction(irqCtx.pc); - if (!step) - { - break; - } - step(rdram, &irqCtx, runtime); - ++steps; - } - handoffBaseline = runtime->guestExecutionHandoffEpochSnapshot(); - } - if (steps >= kMaxIrqHandlerSteps) - { - static uint32_t s_stepLimitLogCount = 0u; - if (s_stepLimitLogCount < 16u) - { - std::cerr << "[INTC:step-limit] handler=0x" << std::hex << info.handler << " pc=0x" << irqCtx.pc << std::dec << std::endl; - ++s_stepLimitLogCount; - } - } - if (reschedulePending && !runtime->isStopRequested()) - { - runtime->waitForGuestExecutionHandoff(handoffBaseline); - } - } - catch (const ThreadExitException &) - { - } - catch (const std::exception &e) - { - static uint32_t warnCount = 0; - if (warnCount < 8u) - { - std::cerr << "[INTC] handler 0x" << std::hex << info.handler - << " threw exception: " << e.what() << std::dec << std::endl; - ++warnCount; - } - } + setReturnS32(ctx, + scheduler(rdram, ctx, runtime) + .setIrqHandlerEnabled(dmac, + static_cast(getRegU32(ctx, 5)), + enabled)); } } - void dispatchDmacHandlersForCause(uint8_t *rdram, PS2Runtime *runtime, uint32_t cause) + void dispatchDmacHandlersForCause(uint8_t *, PS2Runtime *runtime, uint32_t cause) { - if (!rdram || !runtime) - { - return; - } - - std::vector handlers; - { - std::lock_guard lock(g_irq_handler_mutex); - if (cause < 32u && (g_enabled_dmac_mask & (1u << cause)) == 0u) - { - return; - } - - handlers.reserve(g_dmacHandlers.size()); - for (const auto &[id, info] : g_dmacHandlers) - { - (void)id; - if (!info.enabled) - { - continue; - } - if (info.cause != cause) - { - continue; - } - if (info.handler == 0u) - { - continue; - } - handlers.push_back(info); - } - std::sort(handlers.begin(), handlers.end(), [](const IrqHandlerInfo &a, const IrqHandlerInfo &b) - { return a.order < b.order; }); - } - - for (const IrqHandlerInfo &info : handlers) - { - if (!runtime->hasFunction(info.handler)) - { - continue; - } - - try - { - R5900Context irqCtx{}; - SET_GPR_U32(&irqCtx, 28, info.gp); - SET_GPR_U32(&irqCtx, 29, getAsyncHandlerStackTop(runtime)); - SET_GPR_U32(&irqCtx, 31, 0u); - SET_GPR_U32(&irqCtx, 4, cause); - SET_GPR_U32(&irqCtx, 5, info.arg); - SET_GPR_U32(&irqCtx, 6, 0u); - SET_GPR_U32(&irqCtx, 7, 0u); - irqCtx.pc = info.handler; - - bool reschedulePending = false; - uint64_t handoffBaseline = 0u; - uint32_t steps = 0u; - { - PS2Runtime::GuestExecutionScope guestExecution(runtime); - PS2Runtime::DeferredGuestYieldScope deferYield(reschedulePending); - - while (irqCtx.pc != 0u && runtime && !runtime->isStopRequested() && - steps < kMaxIrqHandlerSteps) - { - PS2Runtime::RecompiledFunction step = runtime->lookupFunction(irqCtx.pc); - if (!step) - { - break; - } - step(rdram, &irqCtx, runtime); - ++steps; - } - handoffBaseline = runtime->guestExecutionHandoffEpochSnapshot(); - } - if (steps >= kMaxIrqHandlerSteps) - { - static uint32_t s_stepLimitLogCount = 0u; - if (s_stepLimitLogCount < 16u) - { - std::cerr << "[DMAC:step-limit] handler=0x" << std::hex << info.handler - << " pc=0x" << irqCtx.pc << std::dec << std::endl; - ++s_stepLimitLogCount; - } - } - if (reschedulePending && !runtime->isStopRequested()) - { - runtime->waitForGuestExecutionHandoff(handoffBaseline); - } - } - catch (const ThreadExitException &) - { - } - catch (const std::exception &e) - { - static uint32_t warnCount = 0; - if (warnCount < 8u) - { - std::cerr << "[DMAC] handler 0x" << std::hex << info.handler - << " threw exception: " << e.what() << std::dec << std::endl; - ++warnCount; - } - } - } + runtime->eeScheduler().dispatchIrq(true, cause); } - static void updateGsCsrFieldForVSync(PS2Runtime *runtime, uint64_t tickValue) + uint64_t GetCurrentVSyncTick(PS2Runtime *runtime) { - if (!runtime) - { - return; - } - - constexpr uint64_t kGsCsrFieldMask = 0x2000ull; - std::atomic &csr = runtime->memory().gs().csr; - if (tickValue & 1ull) - { - csr.fetch_or(kGsCsrFieldMask); - } - else - { - csr.fetch_and(~kGsCsrFieldMask); - } + return runtime->eeScheduler().currentVSyncTick(); } - static uint64_t signalVSyncFlag(uint8_t *rdram, PS2Runtime *runtime) + void WaitVSyncTick(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime, int fixedResult) { - VSyncFlagRegistration reg{}; - uint64_t tickValue = 0u; - { - std::lock_guard lock(g_vsync_flag_mutex); - reg = g_vsync_registration; - g_vsync_registration = {}; - tickValue = ++g_vsync_tick_counter; - } - - g_vsync_cv.notify_all(); - updateGsCsrFieldForVSync(runtime, tickValue); - - if (reg.flagAddr != 0u) - { - writeGuestU32NoThrow(rdram, reg.flagAddr, 1u); - } - if (reg.tickAddr != 0u) - { - writeGuestU64NoThrow(rdram, reg.tickAddr, tickValue); - } - return tickValue; - } - - static void interruptWorkerMain(uint8_t *rdram, PS2Runtime *runtime) - { - g_currentThreadId = -1; - - using clock = std::chrono::steady_clock; - auto nextTick = clock::now() + kVblankPeriod; - - while (runtime != nullptr && !runtime->isStopRequested()) - { - { - std::unique_lock lock(g_irq_worker_mutex); - if (g_irq_worker_cv.wait_until(lock, nextTick, []() - { return g_irq_worker_stop.load(std::memory_order_acquire); })) - { - break; - } - } - - const auto now = clock::now(); - int ticksToProcess = 0; - while (now >= nextTick && ticksToProcess < kMaxCatchupTicks) - { - ++ticksToProcess; - nextTick += kVblankPeriod; - } - if (ticksToProcess == 0) - { - continue; - } - - for (int i = 0; i < ticksToProcess; ++i) - { - bool reschedulePending = false; - uint64_t handoffBaseline = 0u; - { - PS2Runtime::GuestExecutionScope guestExecution(runtime); - PS2Runtime::DeferredGuestYieldScope deferYield(reschedulePending); - const uint64_t tickValue = signalVSyncFlag(rdram, runtime); - ps2_stubs::dispatchGsSyncVCallback(rdram, runtime, tickValue); - dispatchIntcHandlersForCause(rdram, runtime, kIntcVblankStart); - handoffBaseline = runtime->guestExecutionHandoffEpochSnapshot(); - } - if (reschedulePending && !runtime->isStopRequested()) - { - runtime->waitForGuestExecutionHandoff(handoffBaseline); - } - std::this_thread::sleep_for(std::chrono::microseconds(500)); - dispatchIntcHandlersForCause(rdram, runtime, kIntcVblankEnd); - } - } - - g_irq_worker_running.store(false, std::memory_order_release); - g_irq_worker_cv.notify_all(); - } - - static void ensureInterruptWorkerRunning(uint8_t *rdram, PS2Runtime *runtime) - { - if (!rdram || !runtime) - { - return; - } - - std::lock_guard lock(g_irq_worker_mutex); - if (g_irq_worker_running.load(std::memory_order_acquire)) - { - return; - } - - g_irq_worker_stop.store(false, std::memory_order_release); - g_irq_worker_running.store(true, std::memory_order_release); - try - { - std::thread(interruptWorkerMain, rdram, runtime).detach(); - } - catch (...) - { - g_irq_worker_running.store(false, std::memory_order_release); - } - } - - void EnsureVSyncWorkerRunning(uint8_t *rdram, PS2Runtime *runtime) - { - ensureInterruptWorkerRunning(rdram, runtime); - } - - uint64_t GetCurrentVSyncTick() - { - std::lock_guard lock(g_vsync_flag_mutex); - return g_vsync_tick_counter; - } - - void stopInterruptWorker() - { - g_irq_worker_stop.store(true, std::memory_order_release); - g_irq_worker_cv.notify_all(); - std::unique_lock lock(g_irq_worker_mutex); - g_irq_worker_cv.wait_for(lock, std::chrono::milliseconds(500), []() - { return !g_irq_worker_running.load(std::memory_order_acquire); }); - g_vsync_cv.notify_all(); - } - - uint64_t WaitForNextVSyncTick(uint8_t *rdram, PS2Runtime *runtime) - { - ensureInterruptWorkerRunning(rdram, runtime); - std::unique_lock lock(g_vsync_flag_mutex); - uint64_t current = g_vsync_tick_counter; - uint64_t result = current; - waitWithGuestExecutionReleasedUntilUnlocked( - runtime, - lock, - [&]() - { - g_vsync_cv.wait(lock, [current, runtime]() - { return g_vsync_tick_counter > current || (runtime != nullptr && runtime->isStopRequested()); }); - }, - [&]() - { - result = g_vsync_tick_counter; - }); - return result; - } - - void WaitVSyncTick(uint8_t *rdram, PS2Runtime *runtime) - { - (void)WaitForNextVSyncTick(rdram, runtime); + EeScheduler &ee = scheduler(rdram, ctx, runtime); + ee.waitVSync(ee.currentVSyncTick(), fixedResult); } void SetVSyncFlag(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { - const uint32_t flagAddr = getRegU32(ctx, 4); - const uint32_t tickAddr = getRegU32(ctx, 5); - + const uint32_t flagAddress = getRegU32(ctx, 4); + const uint32_t tickAddress = getRegU32(ctx, 5); + if ((flagAddress != 0u && !getEeGuestStruct(rdram, flagAddress)) || + (tickAddress != 0u && !getEeGuestStruct(rdram, tickAddress))) { - std::lock_guard lock(g_vsync_flag_mutex); - g_vsync_registration.flagAddr = flagAddr; - g_vsync_registration.tickAddr = tickAddr; + setReturnS32(ctx, KE_ERROR); + return; } - - writeGuestU32NoThrow(rdram, flagAddr, 0u); - writeGuestU64NoThrow(rdram, tickAddr, 0u); - ensureInterruptWorkerRunning(rdram, runtime); + scheduler(rdram, ctx, runtime).setVSyncFlag(flagAddress, tickAddress); setReturnS32(ctx, KE_OK); } void EnableIntc(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { - const uint32_t cause = getRegU32(ctx, 4); - if (cause < 32u) - { - std::lock_guard lock(g_irq_handler_mutex); - g_enabled_intc_mask |= (1u << cause); - } - if (cause == kIntcVblankStart || cause == kIntcVblankEnd) - { - PS2_IF_AGRESSIVE_LOGS({ - static std::atomic s_enableLogCount{0u}; - const uint32_t logIndex = s_enableLogCount.fetch_add(1u, std::memory_order_relaxed); - if (logIndex < 32u) - { - RUNTIME_LOG("[EnableIntc] cause=" << cause); - } - }); - } - setReturnS32(ctx, KE_OK); + setCauseEnabled(rdram, ctx, runtime, false, true); } void iEnableIntc(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) @@ -542,24 +107,7 @@ namespace ps2_syscalls void DisableIntc(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { - const uint32_t cause = getRegU32(ctx, 4); - if (cause < 32u) - { - std::lock_guard lock(g_irq_handler_mutex); - g_enabled_intc_mask &= ~(1u << cause); - } - if (cause == kIntcVblankStart || cause == kIntcVblankEnd) - { - PS2_IF_AGRESSIVE_LOGS({ - static std::atomic s_disableLogCount{0u}; - const uint32_t logIndex = s_disableLogCount.fetch_add(1u, std::memory_order_relaxed); - if (logIndex < 32u) - { - RUNTIME_LOG("[DisableIntc] cause=" << cause); - } - }); - } - setReturnS32(ctx, KE_OK); + setCauseEnabled(rdram, ctx, runtime, false, false); } void iDisableIntc(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) @@ -569,47 +117,7 @@ namespace ps2_syscalls void AddIntcHandler(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { - IrqHandlerInfo info{}; - info.cause = getRegU32(ctx, 4); - info.handler = getRegU32(ctx, 5); - uint32_t next = getRegU32(ctx, 6); - info.arg = getRegU32(ctx, 7); - info.gp = getRegU32(ctx, 28); - info.sp = getRegU32(ctx, 29); - info.enabled = true; - - int handlerId = 0; - { - std::lock_guard lock(g_irq_handler_mutex); - info.order = (next == 0) ? --g_intc_head_order : ++g_intc_tail_order; - handlerId = g_nextIntcHandlerId++; - info.id = handlerId; - g_intcHandlers[handlerId] = info; - } - - if (info.cause == kIntcVblankStart) - { - PS2_IF_AGRESSIVE_LOGS({ - static std::atomic s_addHandlerLogCount{0u}; - const uint32_t logIndex = s_addHandlerLogCount.fetch_add(1u, std::memory_order_relaxed); - if (logIndex < 32u) - { - auto flags = std::cout.flags(); - std::cout << "[AddIntcHandler] cause=" << info.cause - << " handler=0x" << std::hex << info.handler - << " arg=0x" << info.arg - << " gp=0x" << info.gp - << " sp=0x" << info.sp - << std::dec - << " id=" << handlerId - << std::endl; - std::cout.flags(flags); - } - }); - } - - ensureInterruptWorkerRunning(rdram, runtime); - setReturnS32(ctx, handlerId); + addHandler(rdram, ctx, runtime, false); } void AddIntcHandler2(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) @@ -619,40 +127,12 @@ namespace ps2_syscalls void RemoveIntcHandler(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { - const uint32_t cause = getRegU32(ctx, 4); - const int handlerId = static_cast(getRegU32(ctx, 5)); - if (handlerId > 0) - { - std::lock_guard lock(g_irq_handler_mutex); - auto it = g_intcHandlers.find(handlerId); - if (it != g_intcHandlers.end() && it->second.cause == cause) - { - g_intcHandlers.erase(it); - } - } - setReturnS32(ctx, KE_OK); + removeHandler(rdram, ctx, runtime, false); } void AddDmacHandler(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { - IrqHandlerInfo info{}; - info.cause = getRegU32(ctx, 4); - info.handler = getRegU32(ctx, 5); - uint32_t next = getRegU32(ctx, 6); - info.arg = getRegU32(ctx, 7); - info.gp = getRegU32(ctx, 28); - info.sp = getRegU32(ctx, 29); - info.enabled = true; - - int handlerId = 0; - { - std::lock_guard lock(g_irq_handler_mutex); - info.order = (next == 0) ? --g_dmac_head_order : ++g_dmac_tail_order; - handlerId = g_nextDmacHandlerId++; - info.id = handlerId; - g_dmacHandlers[handlerId] = info; - } - setReturnS32(ctx, handlerId); + addHandler(rdram, ctx, runtime, true); } void AddDmacHandler2(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) @@ -662,81 +142,32 @@ namespace ps2_syscalls void RemoveDmacHandler(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { - const uint32_t cause = getRegU32(ctx, 4); - const int handlerId = static_cast(getRegU32(ctx, 5)); - if (handlerId > 0) - { - std::lock_guard lock(g_irq_handler_mutex); - auto it = g_dmacHandlers.find(handlerId); - if (it != g_dmacHandlers.end() && it->second.cause == cause) - { - g_dmacHandlers.erase(it); - } - } - setReturnS32(ctx, KE_OK); + removeHandler(rdram, ctx, runtime, true); } void EnableIntcHandler(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { - const int handlerId = static_cast(getRegU32(ctx, 5)); - { - std::lock_guard lock(g_irq_handler_mutex); - if (auto it = g_intcHandlers.find(handlerId); it != g_intcHandlers.end()) - { - it->second.enabled = true; - } - } - setReturnS32(ctx, KE_OK); + setHandlerEnabled(rdram, ctx, runtime, false, true); } void DisableIntcHandler(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { - const int handlerId = static_cast(getRegU32(ctx, 5)); - { - std::lock_guard lock(g_irq_handler_mutex); - if (auto it = g_intcHandlers.find(handlerId); it != g_intcHandlers.end()) - { - it->second.enabled = false; - } - } - setReturnS32(ctx, KE_OK); + setHandlerEnabled(rdram, ctx, runtime, false, false); } void EnableDmacHandler(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { - const int handlerId = static_cast(getRegU32(ctx, 5)); - { - std::lock_guard lock(g_irq_handler_mutex); - if (auto it = g_dmacHandlers.find(handlerId); it != g_dmacHandlers.end()) - { - it->second.enabled = true; - } - } - setReturnS32(ctx, KE_OK); + setHandlerEnabled(rdram, ctx, runtime, true, true); } void DisableDmacHandler(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { - const int handlerId = static_cast(getRegU32(ctx, 5)); - { - std::lock_guard lock(g_irq_handler_mutex); - if (auto it = g_dmacHandlers.find(handlerId); it != g_dmacHandlers.end()) - { - it->second.enabled = false; - } - } - setReturnS32(ctx, KE_OK); + setHandlerEnabled(rdram, ctx, runtime, true, false); } void EnableDmac(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { - const uint32_t cause = getRegU32(ctx, 4); - if (cause < 32u) - { - std::lock_guard lock(g_irq_handler_mutex); - g_enabled_dmac_mask |= (1u << cause); - } - setReturnS32(ctx, KE_OK); + setCauseEnabled(rdram, ctx, runtime, true, true); } void iEnableDmac(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) @@ -746,13 +177,7 @@ namespace ps2_syscalls void DisableDmac(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { - const uint32_t cause = getRegU32(ctx, 4); - if (cause < 32u) - { - std::lock_guard lock(g_irq_handler_mutex); - g_enabled_dmac_mask &= ~(1u << cause); - } - setReturnS32(ctx, KE_OK); + setCauseEnabled(rdram, ctx, runtime, true, false); } void iDisableDmac(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) diff --git a/ps2xRuntime/src/lib/Kernel/Syscalls/Interrupt.h b/ps2xRuntime/src/lib/Kernel/Syscalls/Interrupt.h index eb9ba5f03..dc83ae6e2 100644 --- a/ps2xRuntime/src/lib/Kernel/Syscalls/Interrupt.h +++ b/ps2xRuntime/src/lib/Kernel/Syscalls/Interrupt.h @@ -1,37 +1,12 @@ #pragma once -#include #include "ps2_syscalls.h" namespace ps2_syscalls { - namespace interrupt_state - { - struct VSyncFlagRegistration - { - uint32_t flagAddr; - uint32_t tickAddr; - }; - - extern std::mutex g_irq_handler_mutex; - extern std::mutex g_irq_worker_mutex; - extern std::condition_variable g_irq_worker_cv; - extern std::mutex g_vsync_flag_mutex; - extern std::condition_variable g_vsync_cv; - extern std::atomic g_irq_worker_stop; - extern std::atomic g_irq_worker_running; - extern uint32_t g_enabled_intc_mask; - extern uint32_t g_enabled_dmac_mask; - extern uint64_t g_vsync_tick_counter; - extern VSyncFlagRegistration g_vsync_registration; - } - void dispatchDmacHandlersForCause(uint8_t *rdram, PS2Runtime *runtime, uint32_t cause); - void EnsureVSyncWorkerRunning(uint8_t *rdram, PS2Runtime *runtime); - uint64_t GetCurrentVSyncTick(); - void stopInterruptWorker(); - uint64_t WaitForNextVSyncTick(uint8_t *rdram, PS2Runtime *runtime); - void WaitVSyncTick(uint8_t *rdram, PS2Runtime *runtime); + uint64_t GetCurrentVSyncTick(PS2Runtime *runtime); + void WaitVSyncTick(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime, int fixedResult); void SetVSyncFlag(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime); void EnableIntc(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime); void iEnableIntc(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime); diff --git a/ps2xRuntime/src/lib/Kernel/Syscalls/Lifecycle.cpp b/ps2xRuntime/src/lib/Kernel/Syscalls/Lifecycle.cpp deleted file mode 100644 index d5a31ea74..000000000 --- a/ps2xRuntime/src/lib/Kernel/Syscalls/Lifecycle.cpp +++ /dev/null @@ -1,116 +0,0 @@ -#include "Common.h" -#include "Interrupt.h" -#include "Lifecycle.h" - -namespace ps2_syscalls -{ - using namespace interrupt_state; - - void notifyRuntimeStop() - { - stopInterruptWorker(); - { - std::lock_guard lock(g_irq_handler_mutex); - g_intcHandlers.clear(); - g_dmacHandlers.clear(); - g_nextIntcHandlerId = 1; - g_nextDmacHandlerId = 1; - g_enabled_intc_mask = 0xFFFFFFFFu; - g_enabled_dmac_mask = 0xFFFFFFFFu; - } - { - std::lock_guard lock(g_vsync_flag_mutex); - g_vsync_registration = {}; - g_vsync_tick_counter = 0u; - } - - std::vector> threads; - threads.reserve(32); - { - std::lock_guard lock(g_thread_map_mutex); - for (const auto &entry : g_threads) - { - if (entry.second) - { - threads.push_back(entry.second); - } - } - g_threads.clear(); - g_nextThreadId = 2; // Reserve id 1 for main thread. - } - g_currentThreadId = 1; - - for (const auto &threadInfo : threads) - { - { - std::lock_guard lock(threadInfo->m); - threadInfo->forceRelease = true; - threadInfo->terminated = true; - } - threadInfo->cv.notify_all(); - } - - std::vector> semas; - { - std::lock_guard lock(g_sema_map_mutex); - semas.reserve(g_semas.size()); - for (const auto &entry : g_semas) - { - if (entry.second) - { - semas.push_back(entry.second); - } - } - g_semas.clear(); - g_nextSemaId = 1; - } - for (const auto &sema : semas) - { - sema->cv.notify_all(); - } - - std::vector> eventFlags; - { - std::lock_guard lock(g_event_flag_map_mutex); - eventFlags.reserve(g_eventFlags.size()); - for (const auto &entry : g_eventFlags) - { - if (entry.second) - { - eventFlags.push_back(entry.second); - } - } - g_eventFlags.clear(); - g_nextEventFlagId = 1; - } - for (const auto &eventFlag : eventFlags) - { - eventFlag->cv.notify_all(); - } - - { - std::lock_guard lock(g_alarm_mutex); - g_alarms.clear(); - } - g_alarm_cv.notify_all(); - - { - std::lock_guard lock(g_exit_handler_mutex); - g_exit_handlers.clear(); - } - { - std::lock_guard lock(g_syscall_override_mutex); - g_syscall_overrides.clear(); - } - } - - void joinAllGuestHostThreads() - { - joinAllHostThreads(); - } - - void detachAllGuestHostThreads() - { - detachAllHostThreads(); - } -} diff --git a/ps2xRuntime/src/lib/Kernel/Syscalls/Lifecycle.h b/ps2xRuntime/src/lib/Kernel/Syscalls/Lifecycle.h deleted file mode 100644 index 749ca1e29..000000000 --- a/ps2xRuntime/src/lib/Kernel/Syscalls/Lifecycle.h +++ /dev/null @@ -1,10 +0,0 @@ -#pragma once - -#include "ps2_syscalls.h" - -namespace ps2_syscalls -{ - void notifyRuntimeStop(); - void joinAllGuestHostThreads(); - void detachAllGuestHostThreads(); -} diff --git a/ps2xRuntime/src/lib/Kernel/Syscalls/RPC.cpp b/ps2xRuntime/src/lib/Kernel/Syscalls/RPC.cpp index 4aeb00f13..f5dfcc5af 100644 --- a/ps2xRuntime/src/lib/Kernel/Syscalls/RPC.cpp +++ b/ps2xRuntime/src/lib/Kernel/Syscalls/RPC.cpp @@ -6,13 +6,13 @@ namespace ps2_syscalls { namespace { - SifRpcDebugEvent makeRpcDebugEvent(const char *op, R5900Context *ctx) + SifRpcDebugEvent makeRpcDebugEvent(const char *op, R5900Context *ctx, PS2Runtime *runtime) { SifRpcDebugEvent event{}; event.op = op; event.pc = ctx ? ctx->pc : 0u; event.ra = ctx ? getRegU32(ctx, 31) : 0u; - event.threadId = static_cast(g_currentThreadId); + event.threadId = runtime ? static_cast(runtime->eeScheduler().currentThreadId()) : 0u; return event; } @@ -139,34 +139,13 @@ namespace ps2_syscalls } #endif - bool signalRpcCompletionSema(uint32_t semaId) + bool signalRpcCompletionSema(PS2Runtime *runtime, uint32_t semaId) { - if (semaId == 0u || semaId > 0xFFFFu) + if (!runtime || semaId == 0u || semaId > 0xFFFFu) { return false; } - - auto sema = lookupSemaInfo(static_cast(semaId)); - if (!sema) - { - return false; - } - - bool signaled = false; - { - std::lock_guard lock(sema->m); - if (!sema->deleted && sema->count < sema->maxCount) - { - sema->count++; - signaled = true; - } - } - - if (signaled) - { - sema->cv.notify_one(); - } - return signaled; + return runtime->eeScheduler().signalSemaphore(static_cast(semaId), true) >= 0; } } // namespace @@ -261,7 +240,7 @@ namespace ps2_syscalls RUNTIME_LOG("[SifInitRpc] Initialized"); } - SifRpcDebugEvent event = makeRpcDebugEvent("InitRpc", ctx); + SifRpcDebugEvent event = makeRpcDebugEvent("InitRpc", ctx, runtime); event.result = 0; pushSifRpcDebugEventLocked(event); setReturnS32(ctx, 0); @@ -277,7 +256,7 @@ namespace ps2_syscalls if (!client) { - SifRpcDebugEvent event = makeRpcDebugEvent("BindRpc", ctx); + SifRpcDebugEvent event = makeRpcDebugEvent("BindRpc", ctx, runtime); event.clientPtr = clientPtr; event.sid = rpcId; event.mode = mode; @@ -342,7 +321,7 @@ namespace ps2_syscalls client->cbuf = 0; } - SifRpcDebugEvent event = makeRpcDebugEvent("BindRpc", ctx); + SifRpcDebugEvent event = makeRpcDebugEvent("BindRpc", ctx, runtime); event.clientPtr = clientPtr; event.serverPtr = serverPtr; event.sid = rpcId; @@ -473,7 +452,7 @@ namespace ps2_syscalls auto *client = reinterpret_cast(getMemPtr(rdram, clientPtr)); if (!client) { - SifRpcDebugEvent event = makeRpcDebugEvent("CallRpc", ctx); + SifRpcDebugEvent event = makeRpcDebugEvent("CallRpc", ctx, runtime); event.clientPtr = clientPtr; event.sid = sidHint; event.rpcNum = rpcNum; @@ -535,24 +514,12 @@ namespace ps2_syscalls } } - uint32_t resultPointer = 0u; - bool handled = false; - bool handledByIop = false; - bool serverDispatched = false; - bool callbackCompleted = false; - bool copiedFallback = false; - bool zeroedFallback = false; ps2x::iop::RpcResult iopResult{}; - - const auto completionSemaphore = [&]() + uint32_t completionSemaphore = static_cast(client->hdr.sema_id); + if (completionSemaphore == 0xFFFFFFFFu || completionSemaphore == 0u) { - uint32_t semaphore = static_cast(client->hdr.sema_id); - if (semaphore == 0xFFFFFFFFu || semaphore == 0u) - { - semaphore = endParameter; - } - return semaphore; - }; + completionSemaphore = endParameter; + } { ps2x::iop::RpcRequest request{}; @@ -569,171 +536,162 @@ namespace ps2_syscalls request.endParameter = endParameter; iopResult = PS2IopTransport::handleRpc(runtime, rdram, ctx, request); - handled = iopResult.handled; - handledByIop = iopResult.handled; - resultPointer = iopResult.resultAddress; if (iopResult.signalNowaitCompletion && (mode & kSifRpcModeNowait) != 0u) { - (void)signalRpcCompletionSema(completionSemaphore()); + (void)signalRpcCompletionSema(runtime, completionSemaphore); } if (iopResult.signalCompletion) { - (void)signalRpcCompletionSema(completionSemaphore()); + (void)signalRpcCompletionSema(runtime, completionSemaphore); } } - if (server && server->func != 0u && iopResult.serverDispatchPolicy != ps2x::iop::ServerDispatchPolicy::Suppress) + uint32_t guestFunction = iopResult.guestFunction; + uint32_t guestA0 = iopResult.guestArguments[0]; + uint32_t guestA1 = iopResult.guestArguments[1]; + uint32_t guestA2 = iopResult.guestArguments[2]; + uint32_t guestA3 = iopResult.guestArguments[3]; + uint32_t guestDefaultResult = iopResult.guestDefaultResultAddress; + if (guestFunction == 0u && server && server->func != 0u && + iopResult.serverDispatchPolicy != ps2x::iop::ServerDispatchPolicy::Suppress) + { + guestFunction = server->func; + guestA0 = rpcNum; + guestA1 = server->buf; + guestA2 = sendSize; + guestDefaultResult = server->buf != 0u ? server->buf : receiveBuffer; + } + const bool serverDispatched = guestFunction != 0u && runtime->hasFunction(guestFunction); + + auto finishCall = [=](const R5900Context *guestResult, R5900Context &parent) { - uint32_t serverResult = 0u; - serverDispatched = rpcInvokeFunction(rdram, - ctx, - runtime, - server->func, - rpcNum, - server->buf, - sendSize, - 0u, - &serverResult); - if (serverDispatched) + bool handled = iopResult.handled; + uint32_t resultPointer = iopResult.resultAddress; + bool copiedFallback = false; + bool zeroedFallback = false; + if (guestResult) { handled = true; - resultPointer = serverResult; - if (resultPointer == 0u && server->buf != 0u) - { - resultPointer = server->buf; - } + resultPointer = getRegU32(guestResult, 2); if (resultPointer == 0u) { - resultPointer = receiveBuffer; + resultPointer = guestDefaultResult; } } - } - if (receiveBuffer != 0u && receiveSize != 0u) - { - if (handled && resultPointer != 0u && resultPointer != receiveBuffer) + if (receiveBuffer != 0u && receiveSize != 0u) { - rpcCopyToRdram(rdram, - receiveBuffer, - resultPointer, - receiveSize); + if (handled && resultPointer != 0u && resultPointer != receiveBuffer) + { + rpcCopyToRdram(rdram, receiveBuffer, resultPointer, receiveSize); + } + else if (!handled && sendBuf != 0u && sendSize != 0u && sendBuf != receiveBuffer) + { + rpcCopyToRdram(rdram, receiveBuffer, sendBuf, std::min(sendSize, receiveSize)); + copiedFallback = true; + } + else if (!handled) + { + rpcZeroRdram(rdram, receiveBuffer, receiveSize); + zeroedFallback = true; + } } - else if (!handled && sendBuf != 0u && sendSize != 0u && sendBuf != receiveBuffer) + + auto completeClient = [=](R5900Context &base, bool callbackCompleted) { - const uint32_t copySize = std::min(sendSize, receiveSize); - rpcCopyToRdram(rdram, receiveBuffer, sendBuf, copySize); - copiedFallback = true; - } - else if (!handled) + { + std::lock_guard lock(g_rpc_mutex); + g_rpc_clients[clientPtr].busy = false; + } + SifRpcDebugEvent event = makeRpcDebugEvent("CallRpc", &base, runtime); + event.clientPtr = clientPtr; + event.serverPtr = serverPtr; + event.sid = sid; + event.rpcNum = rpcNum; + event.mode = mode; + event.sendBuf = sendBuf; + event.sendSize = sendSize; + event.recvBuf = receiveBuffer; + event.recvSize = receiveSize; + event.resultPtr = resultPointer; + event.endFunc = endFunction; + event.endParam = endParameter; + event.semaId = completionSemaphore; + event.flags = + ((mode & kSifRpcModeNowait) ? kSifRpcDebugFlagNowait : 0u) | + (iopResult.handled ? kSifRpcDebugFlagHandledByHle : 0u) | + (callbackCompleted ? kSifRpcDebugFlagCallback : 0u) | + (serverDispatched ? kSifRpcDebugFlagServerDispatch : 0u) | + (!handled ? kSifRpcDebugFlagUnhandled : 0u) | + (copiedFallback ? kSifRpcDebugFlagFallbackCopy : 0u) | + (zeroedFallback ? kSifRpcDebugFlagFallbackZero : 0u); + fillRpcDebugPreview(rdram, sendBuf, sendSize, event.sendPreview, event.sendPreviewSize); + fillRpcDebugPreview(rdram, receiveBuffer, receiveSize, event.recvPreview, event.recvPreviewSize); + event.result = 0; +#if PS2X_ENABLE_IOP_RPC_TRACE + if ((event.flags & kSifRpcDebugFlagUnhandled) != 0u) + { + logUnhandledRpcTrace(event); + } +#endif + pushSifRpcDebugEvent(event); + }; + + setReturnS32(&parent, 0); + if (endFunction == 0u || iopResult.callbackPolicy == ps2x::iop::CallbackPolicy::Suppress) { - rpcZeroRdram(rdram, receiveBuffer, receiveSize); - zeroedFallback = true; + completeClient(parent, endFunction != 0u); + return; } - } - if (endFunction != 0u) - { - if (iopResult.callbackPolicy == ps2x::iop::CallbackPolicy::Suppress) + uint32_t callbackFunction = endFunction; + if (!runtime->hasFunction(callbackFunction) && callbackFunction >= 0x10000u && + runtime->hasFunction(callbackFunction - 0x10000u)) { - callbackCompleted = true; + callbackFunction -= 0x10000u; } - else + if (!runtime->hasFunction(callbackFunction)) { - callbackCompleted = rpcInvokeFunction(rdram, - ctx, - runtime, - endFunction, - endParameter, - 0u, - 0u, - 0u, - nullptr); - if (!callbackCompleted && endFunction >= 0x10000u) - { - const uint32_t normalizedEndFunction = endFunction - 0x10000u; - if (runtime->hasFunction(normalizedEndFunction)) - { - callbackCompleted = rpcInvokeFunction( - rdram, - ctx, - runtime, - normalizedEndFunction, - endParameter, - 0u, - 0u, - 0u, - nullptr); - } - } + (void)signalRpcCompletionSema(runtime, completionSemaphore); + completeClient(parent, false); + return; } - if (!callbackCompleted) + GuestInvocation callback{}; + callback.kind = GuestInvocationKind::RpcCallback; + callback.context = parent; + callback.context.pc = callbackFunction; + SET_GPR_U32(&callback.context, 4, endParameter); + SET_GPR_U32(&callback.context, 29, runtime->eeScheduler().invocationStackTop()); + SET_GPR_U32(&callback.context, 31, 0u); + callback.onComplete = [completeClient](const R5900Context &, R5900Context &base) { - const bool signaled = signalRpcCompletionSema(completionSemaphore()); - static uint32_t unresolvedCallbackWarnings = 0u; - if (unresolvedCallbackWarnings < 32u) - { - std::cerr - << "[SifCallRpc] unresolved end callback endFunc=0x" - << std::hex << endFunction - << " semaId=0x" << completionSemaphore() - << " fallbackSignal=" << std::dec - << (signaled ? 1 : 0) << std::endl; - ++unresolvedCallbackWarnings; - } - } - } - - { - std::lock_guard lock(g_rpc_mutex); - g_rpc_clients[clientPtr].busy = false; - } - - SifRpcDebugEvent event = makeRpcDebugEvent("CallRpc", ctx); - event.clientPtr = clientPtr; - event.serverPtr = serverPtr; - event.sid = sid; - event.rpcNum = rpcNum; - event.mode = mode; - event.sendBuf = sendBuf; - event.sendSize = sendSize; - event.recvBuf = receiveBuffer; - event.recvSize = receiveSize; - event.resultPtr = resultPointer; - event.endFunc = endFunction; - event.endParam = endParameter; - event.semaId = static_cast(client->hdr.sema_id); - event.flags = - ((mode & kSifRpcModeNowait) ? kSifRpcDebugFlagNowait : 0u) | - (handledByIop ? kSifRpcDebugFlagHandledByHle : 0u) | - (callbackCompleted ? kSifRpcDebugFlagCallback : 0u) | - (serverDispatched ? kSifRpcDebugFlagServerDispatch : 0u) | - (!handled ? kSifRpcDebugFlagUnhandled : 0u) | - (copiedFallback ? kSifRpcDebugFlagFallbackCopy : 0u) | - (zeroedFallback ? kSifRpcDebugFlagFallbackZero : 0u); - fillRpcDebugPreview(rdram, - sendBuf, - sendSize, - event.sendPreview, - event.sendPreviewSize); - fillRpcDebugPreview(rdram, - receiveBuffer, - receiveSize, - event.recvPreview, - event.recvPreviewSize); - event.result = 0; + completeClient(base, true); + }; + runtime->eeScheduler().invokeCurrent(std::move(callback)); + }; -#if PS2X_ENABLE_IOP_RPC_TRACE - if ((event.flags & kSifRpcDebugFlagUnhandled) != 0u) - { - logUnhandledRpcTrace(event); + if (serverDispatched) + { + GuestInvocation invocation{}; + invocation.kind = GuestInvocationKind::RpcCallback; + invocation.context = *ctx; + invocation.context.pc = guestFunction; + SET_GPR_U32(&invocation.context, 4, guestA0); + SET_GPR_U32(&invocation.context, 5, guestA1); + SET_GPR_U32(&invocation.context, 6, guestA2); + SET_GPR_U32(&invocation.context, 7, guestA3); + SET_GPR_U32(&invocation.context, 29, runtime->eeScheduler().invocationStackTop()); + SET_GPR_U32(&invocation.context, 31, 0u); + invocation.onComplete = [finishCall](const R5900Context &completed, R5900Context &parent) + { + finishCall(&completed, parent); + }; + runtime->eeScheduler().invokeCurrent(std::move(invocation)); } -#endif - pushSifRpcDebugEvent(event); - - setReturnS32(ctx, 0); + finishCall(nullptr, *ctx); } void SifRegisterRpc(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) @@ -754,7 +712,7 @@ namespace ps2_syscalls t_SifRpcServerData *sd = reinterpret_cast(getMemPtr(rdram, sdPtr)); if (!sd) { - SifRpcDebugEvent event = makeRpcDebugEvent("RegisterRpc", ctx); + SifRpcDebugEvent event = makeRpcDebugEvent("RegisterRpc", ctx, runtime); event.serverPtr = sdPtr; event.sid = sid; event.sendBuf = buf; @@ -836,7 +794,7 @@ namespace ps2_syscalls } RUNTIME_LOG("[SifRegisterRpc] sid=0x" << std::hex << sid << " sd=0x" << sdPtr << std::dec); - SifRpcDebugEvent event = makeRpcDebugEvent("RegisterRpc", ctx); + SifRpcDebugEvent event = makeRpcDebugEvent("RegisterRpc", ctx, runtime); event.serverPtr = sdPtr; event.sid = sid; event.sendBuf = buf; diff --git a/ps2xRuntime/src/lib/Kernel/Syscalls/Sync.cpp b/ps2xRuntime/src/lib/Kernel/Syscalls/Sync.cpp index 8243c48b1..33945fc27 100644 --- a/ps2xRuntime/src/lib/Kernel/Syscalls/Sync.cpp +++ b/ps2xRuntime/src/lib/Kernel/Syscalls/Sync.cpp @@ -1,426 +1,120 @@ #include "Common.h" #include "Sync.h" +#include "runtime/ee_scheduler.h" namespace ps2_syscalls { - static bool looksLikeGuestPointerOrNull(uint32_t value) + namespace { - if (value == 0u) - { - return true; - } - const uint32_t normalized = value & 0x1FFFFFFFu; - return normalized < PS2_RAM_SIZE; - } + constexpr uint32_t WEF_OR = 0x01u; + constexpr uint32_t WEF_CLEAR = 0x10u; + constexpr uint32_t WEF_CLEAR_ALL = 0x20u; + constexpr uint32_t WEF_MODE_MASK = WEF_OR | WEF_CLEAR | WEF_CLEAR_ALL; + constexpr uint32_t EA_MULTI = 0x02u; - static bool readGuestU32Safe(const uint8_t *rdram, uint32_t addr, uint32_t &out) - { - const uint8_t *b0 = getConstMemPtr(rdram, addr + 0u); - const uint8_t *b1 = getConstMemPtr(rdram, addr + 1u); - const uint8_t *b2 = getConstMemPtr(rdram, addr + 2u); - const uint8_t *b3 = getConstMemPtr(rdram, addr + 3u); - if (!b0 || !b1 || !b2 || !b3) + EeScheduler &scheduler(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { - out = 0u; - return false; + EeScheduler &result = runtime->eeScheduler(); + result.bindMainContextForSyscall(*ctx, rdram); + return result; } - out = static_cast(*b0) | - (static_cast(*b1) << 8) | - (static_cast(*b2) << 16) | - (static_cast(*b3) << 24); - return true; - } - - struct DecodedSemaParams - { - int init = 0; - int max = 1; - uint32_t attr = 0; - uint32_t option = 0; - }; - - static DecodedSemaParams decodeCreateSemaParams(const uint32_t *param, uint32_t availableWords) - { - DecodedSemaParams out{}; - if (!param || availableWords == 0u) + void deleteSemaphoreImpl(uint8_t *rdram, + R5900Context *ctx, + PS2Runtime *runtime, + bool interruptSafe) { - return out; + EeScheduler &ee = scheduler(rdram, ctx, runtime); + const int result = ee.deleteSemaphore(static_cast(getRegU32(ctx, 4)), interruptSafe); + setReturnS32(ctx, result); + ee.transferIfRequested(interruptSafe); } - // EE layout (kernel.h): - // [0]=count [1]=max_count [2]=init_count [3]=wait_threads [4]=attr [5]=option - const bool hasEeLayout = availableWords >= 3u; - const int eeMax = hasEeLayout ? static_cast(param[1]) : 1; - const int eeInit = hasEeLayout ? static_cast(param[2]) : 0; - const uint32_t eeAttr = (availableWords >= 5u) ? param[4] : 0u; - const uint32_t eeOption = (availableWords >= 6u) ? param[5] : 0u; - - // Legacy layout (IOP-style): - // [0]=attr [1]=option [2]=init [3]=max - const bool hasLegacyLayout = availableWords >= 4u; - const int legacyMax = hasLegacyLayout ? static_cast(param[3]) : 1; - const int legacyInit = hasLegacyLayout ? static_cast(param[2]) : 0; - const uint32_t legacyAttr = hasLegacyLayout ? param[0] : 0u; - const uint32_t legacyOption = hasLegacyLayout ? param[1] : 0u; - - auto countLooksPlausible = [](int value) -> bool + void signalSemaphoreImpl(uint8_t *rdram, + R5900Context *ctx, + PS2Runtime *runtime, + bool interruptSafe) { - return value > 0 && value <= 0x10000; - }; - - bool useLegacyLayout = hasLegacyLayout && !hasEeLayout; - if (hasLegacyLayout && hasEeLayout && countLooksPlausible(legacyMax) && !countLooksPlausible(eeMax)) - { - useLegacyLayout = true; - } - else if (hasLegacyLayout && hasEeLayout && countLooksPlausible(legacyMax) && countLooksPlausible(eeMax)) - { - // If both max values look valid, prefer the layout whose option field - // looks like a pointer/NULL payload. - const bool eeOptionLooksValid = looksLikeGuestPointerOrNull(eeOption); - const bool legacyOptionLooksValid = looksLikeGuestPointerOrNull(legacyOption); - if (!eeOptionLooksValid && legacyOptionLooksValid) - { - useLegacyLayout = true; - } + EeScheduler &ee = scheduler(rdram, ctx, runtime); + const int result = ee.signalSemaphore(static_cast(getRegU32(ctx, 4)), interruptSafe); + setReturnS32(ctx, result); + ee.transferIfRequested(interruptSafe); } - if (useLegacyLayout && hasLegacyLayout) + void deleteEventFlagImpl(uint8_t *rdram, + R5900Context *ctx, + PS2Runtime *runtime, + bool interruptSafe) { - out.max = legacyMax; - out.init = legacyInit; - out.attr = legacyAttr; - out.option = legacyOption; + EeScheduler &ee = scheduler(rdram, ctx, runtime); + const int result = ee.deleteEventFlag(static_cast(getRegU32(ctx, 4)), interruptSafe); + setReturnS32(ctx, result); + ee.transferIfRequested(interruptSafe); } - else + + void setEventFlagImpl(uint8_t *rdram, + R5900Context *ctx, + PS2Runtime *runtime, + bool interruptSafe) { - if (!hasEeLayout) - { - return out; - } - out.max = eeMax; - out.init = eeInit; - out.attr = eeAttr; - out.option = eeOption; + EeScheduler &ee = scheduler(rdram, ctx, runtime); + const int result = ee.setEventFlag(static_cast(getRegU32(ctx, 4)), + getRegU32(ctx, 5), + interruptSafe); + setReturnS32(ctx, result); + ee.transferIfRequested(interruptSafe); } - - return out; } void CreateSema(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { - uint32_t paramAddr = getRegU32(ctx, 4); // $a0 - if (paramAddr == 0u) + const uint32_t address = getRegU32(ctx, 4); + const auto *param = address == 0u ? nullptr : getEeGuestStruct(rdram, address); + if (!param) { setReturnS32(ctx, KE_ERROR); return; } - uint32_t rawParams[6] = {}; - uint32_t availableWords = 0u; - for (uint32_t i = 0; i < 6u; ++i) - { - if (!readGuestU32Safe(rdram, paramAddr + (i * 4u), rawParams[i])) - { - break; - } - availableWords = i + 1u; - } - - if (availableWords < 3u) - { - setReturnS32(ctx, KE_ERROR); - return; - } - - const DecodedSemaParams decoded = decodeCreateSemaParams(rawParams, availableWords); - int init = decoded.init; - int max = decoded.max; - uint32_t attr = decoded.attr; - uint32_t option = decoded.option; - - if (max <= 0) - { - max = 1; - } - if (init < 0) - { - init = 0; - } - if (init > max) - { - init = max; - } - - int id = 0; - auto info = std::make_shared(); - info->count = init; - info->maxCount = max; - info->initCount = init; - info->attr = attr; - info->option = option; - - { - std::lock_guard lock(g_sema_map_mutex); - for (int attempts = 0; attempts < 0x7FFF; ++attempts) - { - if (g_nextSemaId <= 0) - { - g_nextSemaId = 1; - } - - const int candidate = g_nextSemaId++; - if (candidate <= 0) - { - continue; - } - - if (g_semas.find(candidate) == g_semas.end()) - { - id = candidate; - break; - } - } - - if (id <= 0) - { - setReturnS32(ctx, KE_ERROR); - return; - } - - g_semas.emplace(id, info); - } - RUNTIME_LOG("[CreateSema] id=" << id << " init=" << init << " max=" << max); - setReturnS32(ctx, id); + // ee_sema_t from ps2sdk. The IOP attr/option/init/max ordering is not + // accepted by the EE runtime. + setReturnS32(ctx, + scheduler(rdram, ctx, runtime) + .createSemaphore(param->init_count, + param->max_count, + param->attr, + param->option)); } void DeleteSema(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { - int sid = static_cast(getRegU32(ctx, 4)); - std::shared_ptr sema; - - { - std::lock_guard lock(g_sema_map_mutex); - auto it = g_semas.find(sid); - if (it == g_semas.end()) - { - setReturnS32(ctx, KE_UNKNOWN_SEMID); - return; - } - sema = it->second; - g_semas.erase(it); - } - - { - std::lock_guard lock(sema->m); - sema->deleted = true; - } - sema->cv.notify_all(); - - // PS2 EE BIOS returns sid on success. - setReturnS32(ctx, sid); + deleteSemaphoreImpl(rdram, ctx, runtime, false); } void iDeleteSema(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { - DeleteSema(rdram, ctx, runtime); + deleteSemaphoreImpl(rdram, ctx, runtime, true); } void SignalSema(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { - int sid = static_cast(getRegU32(ctx, 4)); - auto sema = lookupSemaInfo(sid); - if (!sema) - { - setReturnS32(ctx, KE_UNKNOWN_SEMID); - return; - } - - // PS2 EE BIOS returns sid on success; KE_SEMA_OVF overrides on overflow. - int ret = sid; - int beforeCount = 0; - int afterCount = 0; - bool wokeWaiter = false; - { - std::lock_guard lock(sema->m); - beforeCount = sema->count; - if (sema->count >= sema->maxCount) - { - ret = KE_SEMA_OVF; - } - else - { - sema->count++; - wokeWaiter = sema->waiters > 0; - sema->cv.notify_one(); - } - afterCount = sema->count; - } - - static std::atomic s_signalSemaLogs{0}; - const uint32_t sigLog = s_signalSemaLogs.fetch_add(1, std::memory_order_relaxed); - if (sigLog < 256u) - { - RUNTIME_LOG("[SignalSema] tid=" << g_currentThreadId - << " sid=" << sid - << " count=" << beforeCount << "->" << afterCount - << " ret=" << ret - << std::endl); - } - - setReturnS32(ctx, ret); - if (wokeWaiter) - { - yieldGuestExecutionAfterWake(runtime); - } + signalSemaphoreImpl(rdram, ctx, runtime, false); } void iSignalSema(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { - SignalSema(rdram, ctx, runtime); + signalSemaphoreImpl(rdram, ctx, runtime, true); } void WaitSema(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { - int sid = static_cast(getRegU32(ctx, 4)); - auto sema = lookupSemaInfo(sid); - if (!sema) - { - setReturnS32(ctx, KE_UNKNOWN_SEMID); - return; - } - - auto info = ensureCurrentThreadInfo(ctx); - throwIfTerminated(info); - - std::unique_lock lock(sema->m); - - // PS2 EE BIOS returns sid on success. - int ret = sid; - int countAfter = sema->count; - bool terminated = false; - bool consumed = false; - - if (sema->count == 0) - { - static std::atomic s_waitSemaBlockLogs{0}; - const uint32_t blockLog = s_waitSemaBlockLogs.fetch_add(1, std::memory_order_relaxed); - if (blockLog < 256u) - { - RUNTIME_LOG("[WaitSema:block] tid=" << g_currentThreadId - << " sid=" << sid - << " pc=0x" << std::hex << ctx->pc - << " ra=0x" << getRegU32(ctx, 31) - << std::dec - << std::endl); - } - - if (info) - { - std::lock_guard tLock(info->m); - info->status = (info->suspendCount > 0) ? THS_WAITSUSPEND : THS_WAIT; - info->waitType = TSW_SEMA; - info->waitId = sid; - info->forceRelease = false; - } - - sema->waiters++; - waitWithGuestExecutionReleasedUntilUnlocked( - runtime, - lock, - [&]() - { - sema->cv.wait(lock, [&]() - { - const bool forced = info ? info->forceRelease.load() : false; - const bool isTerminated = info ? info->terminated.load() : false; - return sema->count > 0 || sema->deleted || forced || isTerminated; - }); - }, - [&]() - { - sema->waiters--; - if (sema->deleted) - { - ret = KE_WAIT_DELETE; - } - - if (info) - { - std::lock_guard tLock(info->m); - terminated = info->terminated.load(); - info->status = (info->suspendCount > 0) ? THS_SUSPEND : THS_RUN; - info->waitType = TSW_NONE; - info->waitId = 0; - if (info->forceRelease) - { - info->forceRelease = false; - ret = KE_RELEASE_WAIT; - } - } - - if (!terminated && ret == sid && sema->count > 0) - { - sema->count--; - consumed = true; - } - countAfter = sema->count; - }); - } - - if (terminated) - { - throw ThreadExitException(); - } - - if (!consumed && lock.owns_lock()) - { - if (ret == sid && sema->count > 0) - { - sema->count--; - consumed = true; - } - countAfter = sema->count; - } - - static std::atomic s_waitSemaWakeLogs{0}; - const uint32_t wakeLog = s_waitSemaWakeLogs.fetch_add(1, std::memory_order_relaxed); - if (wakeLog < 256u) - { - RUNTIME_LOG("[WaitSema:wake] tid=" << g_currentThreadId - << " sid=" << sid - << " ret=" << ret - << " count=" << countAfter - << std::endl); - } - if (lock.owns_lock()) - { - lock.unlock(); - } - waitWhileSuspended(info, runtime); - setReturnS32(ctx, ret); + scheduler(rdram, ctx, runtime).waitSemaphore(static_cast(getRegU32(ctx, 4))); } void PollSema(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { - int sid = static_cast(getRegU32(ctx, 4)); - auto sema = lookupSemaInfo(sid); - if (!sema) - { - setReturnS32(ctx, KE_UNKNOWN_SEMID); - return; - } - - std::lock_guard lock(sema->m); - if (sema->count > 0) - { - sema->count--; - setReturnS32(ctx, sid); // PS2 EE BIOS returns sid on success. - return; - } - - setReturnS32(ctx, KE_SEMA_ZERO); + setReturnS32(ctx, + scheduler(rdram, ctx, runtime).pollSemaphore(static_cast(getRegU32(ctx, 4)))); } void iPollSema(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) @@ -430,30 +124,25 @@ namespace ps2_syscalls void ReferSemaStatus(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { - int sid = static_cast(getRegU32(ctx, 4)); - uint32_t statusAddr = getRegU32(ctx, 5); - - auto sema = lookupSemaInfo(sid); - if (!sema) + EeScheduler &ee = scheduler(rdram, ctx, runtime); + const EeSemaphore *semaphore = ee.semaphore(static_cast(getRegU32(ctx, 4))); + if (!semaphore) { setReturnS32(ctx, KE_UNKNOWN_SEMID); return; } - - ee_sema_t *status = reinterpret_cast(getMemPtr(rdram, statusAddr)); + auto *status = getEeGuestStruct(rdram, getRegU32(ctx, 5)); if (!status) { setReturnS32(ctx, KE_ERROR); return; } - - std::lock_guard lock(sema->m); - status->count = sema->count; - status->max_count = sema->maxCount; - status->init_count = sema->initCount; - status->wait_threads = sema->waiters; - status->attr = sema->attr; - status->option = sema->option; + status->count = semaphore->count; + status->max_count = semaphore->maxCount; + status->init_count = semaphore->initCount; + status->wait_threads = static_cast(semaphore->waiters.size()); + status->attr = semaphore->attr; + status->option = semaphore->option; setReturnS32(ctx, KE_OK); } @@ -462,131 +151,50 @@ namespace ps2_syscalls ReferSemaStatus(rdram, ctx, runtime); } - constexpr uint32_t WEF_OR = 1; - constexpr uint32_t WEF_CLEAR = 0x10; - constexpr uint32_t WEF_CLEAR_ALL = 0x20; - constexpr uint32_t WEF_MODE_MASK = WEF_OR | WEF_CLEAR | WEF_CLEAR_ALL; - constexpr uint32_t EA_MULTI = 0x2; - void CreateEventFlag(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { - uint32_t paramAddr = getRegU32(ctx, 4); // $a0 - const uint32_t *param = reinterpret_cast(getConstMemPtr(rdram, paramAddr)); - - auto info = std::make_shared(); - if (param) + struct EeEventFlagParam { - info->attr = param[0]; - info->option = param[1]; - info->initBits = param[2]; - info->bits = info->initBits; - } - - int id = 0; + uint32_t attr; + uint32_t option; + uint32_t bits; + }; + const uint32_t address = getRegU32(ctx, 4); + const auto *param = address == 0u ? nullptr : getEeGuestStruct(rdram, address); + if (!param) { - std::lock_guard mapLock(g_event_flag_map_mutex); - id = g_nextEventFlagId++; - g_eventFlags[id] = info; + setReturnS32(ctx, KE_ERROR); + return; } - setReturnS32(ctx, id); + setReturnS32(ctx, + scheduler(rdram, ctx, runtime).createEventFlag(param->bits, param->attr, param->option)); } void DeleteEventFlag(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { - int eid = static_cast(getRegU32(ctx, 4)); - std::shared_ptr info; - { - std::lock_guard mapLock(g_event_flag_map_mutex); - auto it = g_eventFlags.find(eid); - if (it == g_eventFlags.end()) - { - setReturnS32(ctx, KE_UNKNOWN_EVFID); - return; - } - info = it->second; - g_eventFlags.erase(it); - } - - if (!info) - { - setReturnS32(ctx, KE_UNKNOWN_EVFID); - return; - } + deleteEventFlagImpl(rdram, ctx, runtime, false); + } - { - std::lock_guard lock(info->m); - info->deleted = true; - } - info->cv.notify_all(); - setReturnS32(ctx, 0); + void iDeleteEventFlag(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) + { + deleteEventFlagImpl(rdram, ctx, runtime, true); } void SetEventFlag(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { - int eid = static_cast(getRegU32(ctx, 4)); - uint32_t bits = getRegU32(ctx, 5); - auto info = lookupEventFlagInfo(eid); - if (!info) - { - setReturnS32(ctx, KE_UNKNOWN_EVFID); - return; - } - - if (bits == 0) - { - setReturnS32(ctx, KE_OK); - return; - } - - uint32_t newBits = 0u; - bool hadWaiters = false; - { - std::lock_guard lock(info->m); - info->bits |= bits; - newBits = info->bits; - hadWaiters = info->waiters > 0; - } - - static std::atomic s_setEventFlagLogs{0}; - const uint32_t setLog = s_setEventFlagLogs.fetch_add(1, std::memory_order_relaxed); - if (setLog < 256u) - { - RUNTIME_LOG("[SetEventFlag] tid=" << g_currentThreadId - << " eid=" << eid - << " bits=0x" << std::hex << bits - << " newBits=0x" << newBits - << std::dec << std::endl); - } - info->cv.notify_all(); - setReturnS32(ctx, 0); - if (hadWaiters) - { - yieldGuestExecutionAfterWake(runtime); - } + setEventFlagImpl(rdram, ctx, runtime, false); } void iSetEventFlag(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { - SetEventFlag(rdram, ctx, runtime); + setEventFlagImpl(rdram, ctx, runtime, true); } void ClearEventFlag(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { - int eid = static_cast(getRegU32(ctx, 4)); - uint32_t bits = getRegU32(ctx, 5); - auto info = lookupEventFlagInfo(eid); - if (!info) - { - setReturnS32(ctx, KE_UNKNOWN_EVFID); - return; - } - - { - std::lock_guard lock(info->m); - info->bits &= bits; - } - info->cv.notify_all(); - setReturnS32(ctx, KE_OK); + setReturnS32(ctx, + scheduler(rdram, ctx, runtime) + .clearEventFlag(static_cast(getRegU32(ctx, 4)), getRegU32(ctx, 5))); } void iClearEventFlag(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) @@ -596,251 +204,84 @@ namespace ps2_syscalls void WaitEventFlag(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { - int eid = static_cast(getRegU32(ctx, 4)); - uint32_t waitBits = getRegU32(ctx, 5); - uint32_t mode = getRegU32(ctx, 6); - uint32_t resBitsAddr = getRegU32(ctx, 7); - - if ((mode & ~WEF_MODE_MASK) != 0) + const int id = static_cast(getRegU32(ctx, 4)); + const uint32_t bits = getRegU32(ctx, 5); + const uint32_t mode = getRegU32(ctx, 6); + if ((mode & ~WEF_MODE_MASK) != 0u) { setReturnS32(ctx, KE_ILLEGAL_MODE); return; } - - if (waitBits == 0) + if (bits == 0u) { setReturnS32(ctx, KE_EVF_ILPAT); return; } - - auto info = lookupEventFlagInfo(eid); - if (!info) + EeScheduler &ee = scheduler(rdram, ctx, runtime); + const EeEventFlag *flag = ee.eventFlag(id); + if (!flag) { setReturnS32(ctx, KE_UNKNOWN_EVFID); return; } - - uint32_t *resBitsPtr = resBitsAddr ? reinterpret_cast(getMemPtr(rdram, resBitsAddr)) : nullptr; - - std::unique_lock lock(info->m); - if ((info->attr & EA_MULTI) == 0 && info->waiters > 0) + if ((flag->attr & EA_MULTI) == 0u && !flag->waiters.empty()) { setReturnS32(ctx, KE_EVF_MULTI); return; } - - auto tInfo = ensureCurrentThreadInfo(ctx); - throwIfTerminated(tInfo); - int ret = KE_OK; - - auto satisfied = [&]() - { - if (tInfo && tInfo->forceRelease.load()) - return true; - if (tInfo && tInfo->terminated.load()) - return true; - if (info->deleted) - { - return true; - } - if (mode & WEF_OR) - { - return (info->bits & waitBits) != 0; - } - return (info->bits & waitBits) == waitBits; - }; - - bool waitedWithGuestRelease = false; - bool terminated = false; - uint32_t bitsAfter = info->bits; - - auto finishEventFlagWaitLocked = [&]() - { - if (ret == KE_OK && info->deleted) - { - ret = KE_WAIT_DELETE; - } - - if (ret == KE_OK) - { - if (resBitsPtr) - { - *resBitsPtr = info->bits; - } - - if (mode & WEF_CLEAR_ALL) - { - info->bits = 0; - } - else if (mode & WEF_CLEAR) - { - info->bits &= ~waitBits; - } - } - - bitsAfter = info->bits; - }; - - if (!satisfied()) - { - static std::atomic s_waitEventBlockLogs{0}; - const uint32_t evBlockLog = s_waitEventBlockLogs.fetch_add(1, std::memory_order_relaxed); - if (evBlockLog < 256u) - { - RUNTIME_LOG("[WaitEventFlag:block] tid=" << g_currentThreadId - << " eid=" << eid - << " waitBits=0x" << std::hex << waitBits - << " mode=0x" << mode - << " bits=0x" << info->bits - << " pc=0x" << ctx->pc - << " ra=0x" << getRegU32(ctx, 31) - << std::dec - << std::endl); - } - - if (tInfo) - { - std::lock_guard tLock(tInfo->m); - tInfo->status = (tInfo->suspendCount > 0) ? THS_WAITSUSPEND : THS_WAIT; - tInfo->waitType = TSW_EVENT; - tInfo->waitId = eid; - tInfo->forceRelease = false; - } - - info->waiters++; - waitedWithGuestRelease = true; - waitWithGuestExecutionReleasedUntilUnlocked( - runtime, - lock, - [&]() - { - info->cv.wait(lock, satisfied); - }, - [&]() - { - info->waiters--; - - if (tInfo) - { - std::lock_guard tLock(tInfo->m); - terminated = tInfo->terminated.load(); - tInfo->status = (tInfo->suspendCount > 0) ? THS_SUSPEND : THS_RUN; - tInfo->waitType = TSW_NONE; - tInfo->waitId = 0; - if (tInfo->forceRelease) - { - tInfo->forceRelease = false; - ret = KE_RELEASE_WAIT; - } - } - - if (!terminated) - { - finishEventFlagWaitLocked(); - } - else - { - bitsAfter = info->bits; - } - }); - } - - if (terminated) - { - throw ThreadExitException(); - } - - if (!waitedWithGuestRelease) + const uint32_t resultAddress = getRegU32(ctx, 7); + if (resultAddress != 0u && !getEeGuestStruct(rdram, resultAddress)) { - finishEventFlagWaitLocked(); - } - - static std::atomic s_waitEventWakeLogs{0}; - const uint32_t evWakeLog = s_waitEventWakeLogs.fetch_add(1, std::memory_order_relaxed); - if (evWakeLog < 256u) - { - RUNTIME_LOG("[WaitEventFlag:wake] tid=" << g_currentThreadId - << " eid=" << eid - << " ret=" << ret - << " bits=0x" << std::hex << bitsAfter - << std::dec - << std::endl); - } - - if (lock.owns_lock()) - { - lock.unlock(); + setReturnS32(ctx, KE_ERROR); + return; } - waitWhileSuspended(tInfo, runtime); - setReturnS32(ctx, ret); + ee.waitEventFlag(id, bits, mode, resultAddress); } void PollEventFlag(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { - int eid = static_cast(getRegU32(ctx, 4)); - uint32_t waitBits = getRegU32(ctx, 5); - uint32_t mode = getRegU32(ctx, 6); - uint32_t resBitsAddr = getRegU32(ctx, 7); - - if ((mode & ~WEF_MODE_MASK) != 0) + const int id = static_cast(getRegU32(ctx, 4)); + const uint32_t bits = getRegU32(ctx, 5); + const uint32_t mode = getRegU32(ctx, 6); + if ((mode & ~WEF_MODE_MASK) != 0u) { setReturnS32(ctx, KE_ILLEGAL_MODE); return; } - - if (waitBits == 0) + if (bits == 0u) { setReturnS32(ctx, KE_EVF_ILPAT); return; } - - auto info = lookupEventFlagInfo(eid); - if (!info) + EeScheduler &ee = scheduler(rdram, ctx, runtime); + const EeEventFlag *flag = ee.eventFlag(id); + if (!flag) { setReturnS32(ctx, KE_UNKNOWN_EVFID); return; } - - uint32_t *resBitsPtr = resBitsAddr ? reinterpret_cast(getMemPtr(rdram, resBitsAddr)) : nullptr; - - std::lock_guard lock(info->m); - if ((info->attr & EA_MULTI) == 0 && info->waiters > 0) + if ((flag->attr & EA_MULTI) == 0u && !flag->waiters.empty()) { setReturnS32(ctx, KE_EVF_MULTI); return; } - - bool ok = false; - if (mode & WEF_OR) - { - ok = (info->bits & waitBits) != 0; - } - else + uint32_t *output = nullptr; + if (getRegU32(ctx, 7) != 0u) { - ok = (info->bits & waitBits) == waitBits; - } - - if (!ok) - { - setReturnS32(ctx, KE_EVF_COND); - return; - } - - if (resBitsPtr) - { - *resBitsPtr = info->bits; - } - - if (mode & WEF_CLEAR_ALL) - { - info->bits = 0; + output = getEeGuestStruct(rdram, getRegU32(ctx, 7)); + if (!output) + { + setReturnS32(ctx, KE_ERROR); + return; + } } - else if (mode & WEF_CLEAR) + uint32_t observed = 0; + const int result = ee.pollEventFlag(id, bits, mode, observed); + if (result == KE_OK && output) { - info->bits &= ~waitBits; + *output = observed; } - - setReturnS32(ctx, KE_OK); + setReturnS32(ctx, result); } void iPollEventFlag(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) @@ -850,43 +291,38 @@ namespace ps2_syscalls void ReferEventFlagStatus(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { - int eid = static_cast(getRegU32(ctx, 4)); - uint32_t infoAddr = getRegU32(ctx, 5); - - struct Ps2EventFlagInfo + struct EeEventFlagStatus { uint32_t attr; uint32_t option; uint32_t initBits; - uint32_t currBits; - int32_t numThreads; + uint32_t currentBits; + int32_t waitThreads; int32_t reserved1; int32_t reserved2; }; - auto info = lookupEventFlagInfo(eid); - if (!info) + EeScheduler &ee = scheduler(rdram, ctx, runtime); + const EeEventFlag *flag = ee.eventFlag(static_cast(getRegU32(ctx, 4))); + if (!flag) { setReturnS32(ctx, KE_UNKNOWN_EVFID); return; } - - Ps2EventFlagInfo *out = infoAddr ? reinterpret_cast(getMemPtr(rdram, infoAddr)) : nullptr; - if (!out) + auto *status = getEeGuestStruct(rdram, getRegU32(ctx, 5)); + if (!status) { - setReturnS32(ctx, -1); + setReturnS32(ctx, KE_ERROR); return; } - - std::lock_guard lock(info->m); - out->attr = info->attr; - out->option = info->option; - out->initBits = info->initBits; - out->currBits = info->bits; - out->numThreads = info->waiters; - out->reserved1 = 0; - out->reserved2 = 0; - setReturnS32(ctx, 0); + *status = {flag->attr, + flag->option, + flag->initBits, + flag->bits, + static_cast(flag->waiters.size()), + 0, + 0}; + setReturnS32(ctx, KE_OK); } void iReferEventFlagStatus(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) @@ -896,55 +332,18 @@ namespace ps2_syscalls void SetAlarm(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { - uint16_t ticks = static_cast(getRegU32(ctx, 4) & 0xFFFFu); - uint32_t handler = getRegU32(ctx, 5); - uint32_t arg = getRegU32(ctx, 6); - - static int logCount = 0; - if (logCount < 5) - { - RUNTIME_LOG("[SetAlarm] ticks=" << ticks - << " handler=0x" << std::hex << handler - << " arg=0x" << arg << std::dec << std::endl); - ++logCount; - } - - if (!runtime || !handler || !runtime->hasFunction(handler)) - { - setReturnS32(ctx, KE_ERROR); - return; - } - - auto info = std::make_shared(); - info->ticks = ticks; - info->handler = handler; - info->commonArg = arg; - info->gp = getRegU32(ctx, 28); - info->sp = getRegU32(ctx, 29); - info->rdram = rdram; - info->runtime = runtime; - info->dueAt = std::chrono::steady_clock::now() + alarmTicksToDuration(ticks); - - int alarmId = 0; - { - std::lock_guard lock(g_alarm_mutex); - alarmId = g_nextAlarmId++; - if (g_nextAlarmId <= 0) - { - g_nextAlarmId = 1; - } - info->id = alarmId; - g_alarms[alarmId] = info; - } - - ensureAlarmWorkerRunning(); - g_alarm_cv.notify_all(); - setReturnS32(ctx, alarmId); + setReturnS32(ctx, + scheduler(rdram, ctx, runtime) + .setAlarm(static_cast(getRegU32(ctx, 4)), + getRegU32(ctx, 5), + getRegU32(ctx, 6), + getRegU32(ctx, 28), + getRegU32(ctx, 29))); } - void InitAlarm(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) + void InitAlarm(uint8_t *, R5900Context *ctx, PS2Runtime *) { - setReturnS32(ctx, 0); + setReturnS32(ctx, KE_OK); } void iSetAlarm(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) @@ -954,27 +353,8 @@ namespace ps2_syscalls void CancelAlarm(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { - int alarmId = static_cast(getRegU32(ctx, 4)); - if (alarmId <= 0) - { - setReturnS32(ctx, KE_ERROR); - return; - } - - bool removed = false; - { - std::lock_guard lock(g_alarm_mutex); - removed = g_alarms.erase(alarmId) != 0; - } - - if (removed) - { - g_alarm_cv.notify_all(); - setReturnS32(ctx, KE_OK); - return; - } - - setReturnS32(ctx, KE_ERROR); + setReturnS32(ctx, + scheduler(rdram, ctx, runtime).cancelAlarm(static_cast(getRegU32(ctx, 4)))); } void iCancelAlarm(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) @@ -989,6 +369,6 @@ namespace ps2_syscalls void iReleaseAlarm(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { - iCancelAlarm(rdram, ctx, runtime); + CancelAlarm(rdram, ctx, runtime); } } diff --git a/ps2xRuntime/src/lib/Kernel/Syscalls/System.cpp b/ps2xRuntime/src/lib/Kernel/Syscalls/System.cpp index c8f3e8683..e6819b6fe 100644 --- a/ps2xRuntime/src/lib/Kernel/Syscalls/System.cpp +++ b/ps2xRuntime/src/lib/Kernel/Syscalls/System.cpp @@ -405,145 +405,41 @@ namespace ps2_syscalls setReturnS32(ctx, 0); } - static uint32_t computeBuiltinFindAddressResult(uint8_t *rdram, - uint32_t originalStart, - uint32_t originalEnd, - uint32_t target); - bool dispatchSyscallOverride(uint32_t syscallNumber, uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { uint32_t handler = 0u; - { - std::lock_guard lock(g_syscall_override_mutex); - auto it = g_syscall_overrides.find(syscallNumber); - if (it == g_syscall_overrides.end()) - { - return false; - } - handler = it->second; - } - - if (!runtime || !ctx || handler == 0u) + if (!runtime || !ctx || + !runtime->findEeSyscallOverride(syscallNumber, handler) || + handler == 0u) { return false; } - const uint32_t overrideA0 = getRegU32(ctx, 4); - const uint32_t overrideA1 = getRegU32(ctx, 5); - const uint32_t overrideA2 = getRegU32(ctx, 6); - const uint32_t overrideA3 = getRegU32(ctx, 7); - const uint32_t overridePc = ctx->pc; - const uint32_t overrideRa = getRegU32(ctx, 31); - - thread_local std::vector s_activeSyscallOverrides; - if (std::find(s_activeSyscallOverrides.begin(), s_activeSyscallOverrides.end(), syscallNumber) != s_activeSyscallOverrides.end()) + EeScheduler &scheduler = runtime->eeScheduler(); + scheduler.bindMainContextForSyscall(*ctx, rdram); + if (scheduler.hasInvocation(GuestInvocationKind::SyscallOverride, syscallNumber)) { - static std::atomic s_reentrantLogs{0u}; - constexpr uint32_t kMaxReentrantLogs = 32u; - const uint32_t logIndex = s_reentrantLogs.fetch_add(1u, std::memory_order_relaxed); - if (logIndex < kMaxReentrantLogs) - { - PS2_IF_AGRESSIVE_LOGS({ - std::cerr << "[SyscallOverride:reentrant]" - << " syscall=0x" << std::hex << syscallNumber - << " handler=0x" << handler - << " pc=0x" << ctx->pc - << " ra=0x" << getRegU32(ctx, 31) - << std::dec << std::endl; - }); - } return false; } - s_activeSyscallOverrides.push_back(syscallNumber); - struct ScopedActiveOverride - { - std::vector &active; - ~ScopedActiveOverride() - { - if (!active.empty()) - { - active.pop_back(); - } - } - } scopedActiveOverride{s_activeSyscallOverrides}; - - uint32_t retV0 = 0u; - const bool invoked = rpcInvokeFunction(rdram, - ctx, - runtime, - handler, - getRegU32(ctx, 4), - getRegU32(ctx, 5), - getRegU32(ctx, 6), - getRegU32(ctx, 7), - &retV0); - - if (syscallNumber == 0x83u) + if (!runtime->hasFunction(handler)) { - const uint32_t builtinRet = computeBuiltinFindAddressResult(rdram, overrideA0, overrideA1, overrideA2); - const bool mismatch = (retV0 != builtinRet); - - static std::atomic s_findAddressOverrideLogs{0u}; - static std::atomic s_findAddressOverrideMismatchLogs{0u}; - constexpr uint32_t kMaxFindAddressOverrideLogs = 64u; - constexpr uint32_t kMaxFindAddressOverrideMismatchLogs = 128u; - - const uint32_t logIndex = s_findAddressOverrideLogs.fetch_add(1u, std::memory_order_relaxed); - const uint32_t mismatchIndex = mismatch - ? s_findAddressOverrideMismatchLogs.fetch_add(1u, std::memory_order_relaxed) - : 0u; - if (logIndex < kMaxFindAddressOverrideLogs || - (mismatch && mismatchIndex < kMaxFindAddressOverrideMismatchLogs)) - { - const uint32_t guestMinus20c = (retV0 != 0u) ? (retV0 - 0x20Cu) : 0u; - const uint32_t guestMinus168 = (retV0 != 0u) ? (retV0 - 0x168u) : 0u; - const uint32_t builtinMinus20c = (builtinRet != 0u) ? (builtinRet - 0x20Cu) : 0u; - const uint32_t builtinMinus168 = (builtinRet != 0u) ? (builtinRet - 0x168u) : 0u; - - PS2_IF_AGRESSIVE_LOGS({ - std::cerr << "[Syscall83:override]" - << " handler=0x" << std::hex << handler - << " invoked=" << (invoked ? "true" : "false") - << " pc=0x" << overridePc - << " ra=0x" << overrideRa - << " a0=0x" << overrideA0 - << " a1=0x" << overrideA1 - << " a2=0x" << overrideA2 - << " a3=0x" << overrideA3 - << " guestRet=0x" << retV0 - << " builtinRet=0x" << builtinRet - << " guest-20c=0x" << guestMinus20c - << " builtin-20c=0x" << builtinMinus20c - << " guest-168=0x" << guestMinus168 - << " builtin-168=0x" << builtinMinus168 - << " match=" << (mismatch ? "false" : "true") - << std::dec << std::endl; - }); - } + setReturnS32(ctx, KE_ERROR); + return true; } - if (!invoked) + GuestInvocation invocation{}; + invocation.kind = GuestInvocationKind::SyscallOverride; + invocation.tag = syscallNumber; + invocation.context = *ctx; + invocation.context.pc = handler; + SET_GPR_U32(&invocation.context, 29, scheduler.invocationStackTop()); + SET_GPR_U32(&invocation.context, 31, 0u); + invocation.onComplete = [](const R5900Context &completed, R5900Context &parent) { - static std::atomic s_fallbackLogs{0u}; - constexpr uint32_t kMaxFallbackLogs = 64u; - const uint32_t logIndex = s_fallbackLogs.fetch_add(1u, std::memory_order_relaxed); - if (logIndex < kMaxFallbackLogs) - { - PS2_IF_AGRESSIVE_LOGS({ - std::cerr << "[SyscallOverride:fallback]" - << " syscall=0x" << std::hex << syscallNumber - << " handler=0x" << handler - << " pc=0x" << ctx->pc - << " ra=0x" << getRegU32(ctx, 31) - << std::dec << std::endl; - }); - } - return false; - } - - setReturnU32(ctx, retV0); - return true; + parent.r[2] = completed.r[2]; + }; + scheduler.invokeCurrent(std::move(invocation)); } static bool tryResolveGuestSyscallMirrorAddr(uint32_t syscallIndex, uint32_t &guestAddr) @@ -573,73 +469,20 @@ namespace ps2_syscalls } } - static void seedGuestSyscallTableProbeLocked(uint8_t *rdram) - { - writeGuestKernelWord(rdram, kGuestSyscallTableProbeBase + 0u, kGuestSyscallTableGuestBase >> 16); - writeGuestKernelWord(rdram, kGuestSyscallTableProbeBase + 8u, kGuestSyscallTableGuestBase & 0xFFFFu); - g_syscall_mirror_addrs.insert(kGuestSyscallTableProbeBase + 0u); - g_syscall_mirror_addrs.insert(kGuestSyscallTableProbeBase + 8u); - } - - static void mirrorGuestSyscallEntryLocked(uint8_t *rdram, uint32_t syscallIndex, uint32_t handler) - { - uint32_t guestAddr = 0u; - if (!tryResolveGuestSyscallMirrorAddr(syscallIndex, guestAddr)) - { - return; - } - - writeGuestKernelWord(rdram, guestAddr, handler); - if (handler == 0u) - { - g_syscall_mirror_addrs.erase(guestAddr); - return; - } - - g_syscall_mirror_addrs.insert(guestAddr); - } - - void initializeGuestKernelState(uint8_t *rdram) + void initializeGuestKernelState(uint8_t *rdram, PS2Runtime *runtime) { - if (!rdram) + if (!runtime) { return; } - - std::lock_guard lock(g_syscall_override_mutex); - for (uint32_t guestAddr : g_syscall_mirror_addrs) - { - writeGuestKernelWord(rdram, guestAddr, 0u); - } - g_syscall_mirror_addrs.clear(); - - seedGuestSyscallTableProbeLocked(rdram); - - for (const auto &entry : g_syscall_overrides) - { - mirrorGuestSyscallEntryLocked(rdram, entry.first, entry.second); - } + runtime->initializeEeKernelState(rdram); } void SetSyscall(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { - (void)runtime; const uint32_t syscallIndex = getRegU32(ctx, 4); const uint32_t handler = getRegU32(ctx, 5); - - { - std::lock_guard lock(g_syscall_override_mutex); - if (handler == 0u) - { - g_syscall_overrides.erase(syscallIndex); - } - else - { - g_syscall_overrides[syscallIndex] = handler; - } - - mirrorGuestSyscallEntryLocked(rdram, syscallIndex, handler); - } + runtime->setEeSyscallOverride(rdram, syscallIndex, handler); setReturnS32(ctx, 0); } @@ -1091,7 +934,9 @@ namespace ps2_syscalls // GetThreadTLS (stub): return 0 void GetThreadTLS(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { - auto info = ensureCurrentThreadInfo(ctx); + EeScheduler &ee = runtime->eeScheduler(); + ee.bindMainContextForSyscall(*ctx, rdram); + GuestThread *info = ee.currentThread(); if (!info) { setReturnU32(ctx, 0); @@ -1149,11 +994,10 @@ namespace ps2_syscalls return; } - int tid = g_currentThreadId; - { - std::lock_guard lock(g_exit_handler_mutex); - g_exit_handlers[tid].push_back({func, arg}); - } + EeScheduler &ee = runtime->eeScheduler(); + ee.bindMainContextForSyscall(*ctx, rdram); + const int tid = ee.currentThreadId(); + runtime->addEeExitHandler(tid, func, arg); setReturnS32(ctx, 0); } diff --git a/ps2xRuntime/src/lib/Kernel/Syscalls/System.h b/ps2xRuntime/src/lib/Kernel/Syscalls/System.h index 02d9e915b..3bfb232a6 100644 --- a/ps2xRuntime/src/lib/Kernel/Syscalls/System.h +++ b/ps2xRuntime/src/lib/Kernel/Syscalls/System.h @@ -23,7 +23,7 @@ namespace ps2_syscalls void sceSifLoadModule(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime); void sceSifLoadModuleBuffer(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime); void TODO(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime, uint32_t encodedSyscallId); - void initializeGuestKernelState(uint8_t *rdram); + void initializeGuestKernelState(uint8_t *rdram, PS2Runtime *runtime); void SetSyscall(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime); void SetupThread(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime); void SetupHeap(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime); diff --git a/ps2xRuntime/src/lib/Kernel/Syscalls/Thread.cpp b/ps2xRuntime/src/lib/Kernel/Syscalls/Thread.cpp index 39511a9ab..5110ee2c2 100644 --- a/ps2xRuntime/src/lib/Kernel/Syscalls/Thread.cpp +++ b/ps2xRuntime/src/lib/Kernel/Syscalls/Thread.cpp @@ -1,74 +1,156 @@ #include "Common.h" #include "Thread.h" +#include "runtime/ee_scheduler.h" namespace ps2_syscalls { - static void applySuspendStatusLocked(ThreadInfo &info) + namespace { - if (info.waitType != TSW_NONE) + EeScheduler &scheduler(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { - info.status = THS_WAITSUSPEND; + EeScheduler &result = runtime->eeScheduler(); + result.bindMainContextForSyscall(*ctx, rdram); + return result; } - else - { - info.status = THS_SUSPEND; - } - } - static void notifyThreadWaitObject(int waitType, int waitId) - { - if (waitType == TSW_SEMA) + int rawThreadStatus(EeThreadStatus status) { - auto sema = lookupSemaInfo(waitId); - if (sema) + switch (status) { - sema->cv.notify_all(); + case EeThreadStatus::Running: + return THS_RUN; + case EeThreadStatus::Ready: + return THS_READY; + case EeThreadStatus::Waiting: + return THS_WAIT; + case EeThreadStatus::WaitingSuspended: + return THS_WAITSUSPEND; + case EeThreadStatus::Suspended: + return THS_SUSPEND; + case EeThreadStatus::Dormant: + return THS_DORMANT; } + return THS_DORMANT; } - else if (waitType == TSW_EVENT) + + int rawWaitType(EeWaitReason reason) { - auto eventFlag = lookupEventFlagInfo(waitId); - if (eventFlag) + switch (reason) { - eventFlag->cv.notify_all(); + case EeWaitReason::Sleep: + return TSW_SLEEP; + case EeWaitReason::Semaphore: + return TSW_SEMA; + case EeWaitReason::EventFlag: + return TSW_EVENT; + case EeWaitReason::VSync: + return 4; + case EeWaitReason::External: + case EeWaitReason::Mpeg: + return 5; + case EeWaitReason::None: + return TSW_NONE; } + return TSW_NONE; } - } - static void runExitHandlersForThread(int tid, uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) - { - if (!runtime || !ctx) - return; - - std::vector handlers; + int waitId(const GuestThread &thread) { - std::lock_guard lock(g_exit_handler_mutex); - auto it = g_exit_handlers.find(tid); - if (it == g_exit_handlers.end()) - return; - handlers = std::move(it->second); - g_exit_handlers.erase(it); + if (thread.wait.reason == EeWaitReason::Semaphore) + { + return std::get(thread.wait.payload).id; + } + if (thread.wait.reason == EeWaitReason::EventFlag) + { + return std::get(thread.wait.payload).id; + } + return 0; } - for (const auto &handler : handlers) + [[noreturn]] void exitThreadWithHandlers(int tid, + R5900Context *ctx, + PS2Runtime *runtime, + bool deleteThread) { - if (!handler.func) - continue; - try + EeScheduler &ee = runtime->eeScheduler(); + const auto handlers = runtime->takeEeExitHandlers(tid); + std::vector invocations; + invocations.reserve(handlers.size()); + for (const PS2Runtime::EeExitHandlerRegistration &handler : handlers) { - rpcInvokeFunction(rdram, ctx, runtime, handler.func, handler.arg, 0, 0, 0, nullptr); + if (handler.function == 0u || !runtime->hasFunction(handler.function)) + { + continue; + } + GuestInvocation invocation{}; + invocation.kind = GuestInvocationKind::ExitHandler; + invocation.context = *ctx; + invocation.context.pc = handler.function; + SET_GPR_U32(&invocation.context, 4, handler.argument); + SET_GPR_U32(&invocation.context, 29, ee.invocationStackTop()); + SET_GPR_U32(&invocation.context, 31, 0u); + invocations.push_back(std::move(invocation)); } - catch (const ThreadExitException &) + if (invocations.empty()) { - // ignore + ee.exitCurrent(deleteThread); } - catch (const std::exception &) + invocations.back().onComplete = [runtime, deleteThread](const R5900Context &, R5900Context &) { - } + runtime->eeScheduler().exitCurrent(deleteThread); + }; + ee.invokeCurrentSequence(std::move(invocations)); + } + + void changePriorityImpl(uint8_t *rdram, + R5900Context *ctx, + PS2Runtime *runtime, + bool interruptSafe) + { + EeScheduler &ee = scheduler(rdram, ctx, runtime); + const int id = static_cast(getRegU32(ctx, 4)); + const int priority = static_cast(getRegU32(ctx, 5)); + int oldPriority = 0; + const int result = ee.changePriority(id, priority, interruptSafe, oldPriority); + setReturnS32(ctx, result); + ee.transferIfRequested(interruptSafe); + } + + void rotateReadyQueueImpl(uint8_t *rdram, + R5900Context *ctx, + PS2Runtime *runtime, + bool interruptSafe) + { + EeScheduler &ee = scheduler(rdram, ctx, runtime); + const int result = ee.rotateReadyQueue(static_cast(getRegU32(ctx, 4)), interruptSafe); + setReturnS32(ctx, result); + ee.transferIfRequested(interruptSafe); + } + + void wakeupThreadImpl(uint8_t *rdram, + R5900Context *ctx, + PS2Runtime *runtime, + bool interruptSafe) + { + EeScheduler &ee = scheduler(rdram, ctx, runtime); + const int result = ee.wakeupThread(static_cast(getRegU32(ctx, 4)), interruptSafe); + setReturnS32(ctx, result); + ee.transferIfRequested(interruptSafe); + } + + void releaseWaitImpl(uint8_t *rdram, + R5900Context *ctx, + PS2Runtime *runtime, + bool interruptSafe) + { + EeScheduler &ee = scheduler(rdram, ctx, runtime); + const int result = ee.releaseWait(static_cast(getRegU32(ctx, 4)), interruptSafe); + setReturnS32(ctx, result); + ee.transferIfRequested(interruptSafe); } } - void FlushCache(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) + void FlushCache(uint8_t *, R5900Context *ctx, PS2Runtime *) { setReturnS32(ctx, KE_OK); } @@ -78,719 +160,210 @@ namespace ps2_syscalls FlushCache(rdram, ctx, runtime); } - void EnableCache(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) + void EnableCache(uint8_t *, R5900Context *ctx, PS2Runtime *) { setReturnS32(ctx, KE_OK); } - void DisableCache(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) + void DisableCache(uint8_t *, R5900Context *ctx, PS2Runtime *) { setReturnS32(ctx, KE_OK); } - void ResetEE(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) + void ResetEE(uint8_t *, R5900Context *ctx, PS2Runtime *) { - std::cerr << "Syscall: ResetEE - requesting runtime stop" << std::endl; - // runtime->requestStop(); setReturnS32(ctx, KE_OK); } - void SetMemoryMode(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) + void SetMemoryMode(uint8_t *, R5900Context *ctx, PS2Runtime *) { setReturnS32(ctx, KE_OK); } - void InitThread(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) + void InitThread(uint8_t *, R5900Context *ctx, PS2Runtime *) { - // This is a common ps2sdk helper that some games link against. - setReturnS32(ctx, 1); + setReturnS32(ctx, EeScheduler::kMainThreadId); } void CreateThread(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { - uint32_t paramAddr = getRegU32(ctx, 4); // $a0 points to ThreadParam - if (paramAddr == 0u) + const uint32_t address = getRegU32(ctx, 4); + if (address == 0u) { - std::cerr << "CreateThread error: null ThreadParam pointer" << std::endl; setReturnS32(ctx, KE_ERROR); return; } - - const uint32_t *param = reinterpret_cast(getConstMemPtr(rdram, paramAddr)); - + const auto *param = getEeGuestStruct(rdram, address); if (!param) { - std::cerr << "CreateThread error: invalid ThreadParam address 0x" << std::hex << paramAddr << std::dec << std::endl; setReturnS32(ctx, KE_ERROR); return; } - auto info = std::make_shared(); - info->attr = param[0]; - info->entry = param[1]; - info->stack = param[2]; - info->stackSize = param[3]; - - auto looksLikeGuestPtr = [](uint32_t v) -> bool - { - if (v == 0) - { - return true; - } - const uint32_t norm = v & 0x1FFFFFFFu; - return norm < PS2_RAM_SIZE && norm >= 0x10000u; - }; - - auto looksLikePriority = [](uint32_t v) -> bool - { - // Typical EE priorities are very small integers (1..127). - return v <= 0x400u; - }; - - const uint32_t gpA = param[4]; - const uint32_t prioA = param[5]; - const uint32_t gpB = param[5]; - const uint32_t prioB = param[4]; - - // Prefer the standard EE layout (gp at +0x10, priority at +0x14), - // but keep a fallback for callsites that used the swapped decode. - if (looksLikeGuestPtr(gpA) && looksLikePriority(prioA)) - { - info->gp = gpA; - info->priority = prioA; - } - else if (looksLikeGuestPtr(gpB) && looksLikePriority(prioB)) - { - info->gp = gpB; - info->priority = prioB; - } - else - { - info->gp = gpA; - info->priority = prioA; - } - - info->option = param[6]; - if (info->priority == 0) - { - info->priority = 1; - } - if (info->priority >= 128) + if (param->stack_size < 0) { - info->priority = 127; + setReturnS32(ctx, KE_ERROR); + return; } - info->currentPriority = static_cast(info->priority); - - int id = 0; + if (param->stack != 0u) { - std::lock_guard lock(g_thread_map_mutex); - // Keep IDs in the classic low range used by patched libkernel helpers. - for (int attempts = 0; attempts < 0xFE; ++attempts) - { - if (g_nextThreadId < 2 || g_nextThreadId > 0xFF) - { - g_nextThreadId = 2; - } - - const int candidate = g_nextThreadId; - g_nextThreadId = (g_nextThreadId >= 0xFF) ? 2 : (g_nextThreadId + 1); - - if (g_threads.find(candidate) == g_threads.end()) - { - id = candidate; - break; - } - } - - if (id == 0) + uint32_t stackOffset = 0u; + bool scratch = false; + if (!resolveEeGuestRange(param->stack, + static_cast(param->stack_size), + stackOffset, + scratch)) { setReturnS32(ctx, KE_ERROR); return; } - - g_threads[id] = info; } - RUNTIME_LOG("[CreateThread] id=" << id - << " entry=0x" << std::hex << info->entry - << " stack=0x" << info->stack - << " size=0x" << info->stackSize - << " gp=0x" << info->gp - << " prio=" << std::dec << info->priority << std::endl); - - setReturnS32(ctx, id); + // PS2SDK EE t_ee_thread: status, func, stack, stack_size, gp_reg, + // initial_priority, current_priority, attr, option. + const EeThreadCreateParams decoded{ + param->attr, + param->func, + param->stack, + static_cast(param->stack_size), + param->gp_reg, + param->initial_priority, + param->option, + }; + setReturnS32(ctx, scheduler(rdram, ctx, runtime).createThread(decoded)); } void DeleteThread(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { - int tid = static_cast(getRegU32(ctx, 4)); // $a0 - if (tid == 0) + EeScheduler &ee = scheduler(rdram, ctx, runtime); + const int id = static_cast(getRegU32(ctx, 4)); + uint32_t ownedStack = 0; + const int result = ee.deleteThread(id, ownedStack); + if (result == KE_OK) { - setReturnS32(ctx, KE_ILLEGAL_THID); - return; + runtime->removeEeExitHandlers(id); } - - auto info = lookupThreadInfo(tid); - if (!info) + if (ownedStack != 0u) { - setReturnS32(ctx, KE_UNKNOWN_THID); - return; + runtime->guestFree(ownedStack); } - - uint32_t autoStackToFree = 0; - { - std::lock_guard lock(info->m); - if (info->started || info->status != THS_DORMANT) - { - setReturnS32(ctx, KE_NOT_DORMANT); - return; - } - - if (info->ownsStack && info->stack != 0) - { - autoStackToFree = info->stack; - info->stack = 0; - info->stackSize = 0; - info->ownsStack = false; - } - } - - { - std::lock_guard lock(g_thread_map_mutex); - g_threads.erase(tid); - } - - { - std::lock_guard lock(g_exit_handler_mutex); - g_exit_handlers.erase(tid); - } - - if (runtime && autoStackToFree != 0) - { - runtime->guestFree(autoStackToFree); - } - - setReturnS32(ctx, KE_OK); + setReturnS32(ctx, result); } void StartThread(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { - int tid = static_cast(getRegU32(ctx, 4)); // $a0 = thread id - uint32_t arg = getRegU32(ctx, 5); // $a1 = user arg - if (tid == 0) - { - setReturnS32(ctx, KE_ILLEGAL_THID); - return; - } - - auto info = lookupThreadInfo(tid); - if (!info) + EeScheduler &ee = scheduler(rdram, ctx, runtime); + const int id = static_cast(getRegU32(ctx, 4)); + const uint32_t arg = getRegU32(ctx, 5); + GuestThread *target = ee.thread(id); + if (!target) { - std::cerr << "StartThread error: unknown thread id " << tid << std::endl; setReturnS32(ctx, KE_UNKNOWN_THID); return; } - - if (!runtime || !runtime->hasFunction(info->entry)) + if (target->status != EeThreadStatus::Dormant) { - std::cerr << "[StartThread] entry 0x" << std::hex << info->entry << std::dec << " is not registered" << std::endl; - setReturnS32(ctx, KE_ERROR); + setReturnS32(ctx, KE_NOT_DORMANT); return; } - if (runtime->isStopRequested()) + if (!runtime->hasFunction(target->entry)) { setReturnS32(ctx, KE_ERROR); return; } - - joinHostThreadById(tid); - - const uint32_t callerSp = getRegU32(ctx, 29); - const uint32_t callerGp = getRegU32(ctx, 28); - + if (target->stack == 0u && target->stackSize != 0u) { - std::lock_guard lock(info->m); - if (info->started || info->status != THS_DORMANT) + target->stack = runtime->guestMalloc(target->stackSize, 16u); + if (target->stack == 0u) { - setReturnS32(ctx, KE_NOT_DORMANT); + setReturnS32(ctx, KE_ERROR); return; } - - info->started = true; - info->status = THS_READY; - info->arg = arg; - info->terminated = false; - info->forceRelease = false; - info->waitType = TSW_NONE; - info->waitId = 0; - info->wakeupCount = 0; - info->suspendCount = 0; - if (info->stack == 0 && info->stackSize != 0) - { - const uint32_t autoStack = runtime->guestMalloc(info->stackSize, 16u); - if (autoStack != 0) - { - info->stack = autoStack; - info->ownsStack = true; - RUNTIME_LOG("[StartThread] id=" << tid - << " auto-stack=0x" << std::hex << autoStack - << " size=0x" << info->stackSize << std::dec << std::endl); - } - } - - if (info->stack != 0 && info->stackSize == 0) - { - // Some games leave size zero in the thread param even though a stack - // buffer is supplied; use a conservative default instead of caller SP. - info->stackSize = 0x800u; - } - } - - g_activeThreads.fetch_add(1, std::memory_order_relaxed); - try - { - std::thread worker([=]() mutable - { - { - std::string name = "PS2Thread_" + std::to_string(tid); - ThreadNaming::SetCurrentThreadName(name); - } - R5900Context threadCtxCopy{}; - R5900Context *threadCtx = &threadCtxCopy; - - { - std::lock_guard lock(info->m); - info->status = THS_RUN; - } - - uint32_t threadSp = callerSp; - if (info->stack) - { - const uint32_t stackSize = (info->stackSize != 0) ? info->stackSize : 0x800u; - threadSp = (info->stack + stackSize) & ~0xFu; - } - uint32_t threadGp = info->gp; - const uint32_t normalizedGp = threadGp & 0x1FFFFFFFu; - if (threadGp == 0 || normalizedGp < 0x10000u || normalizedGp >= PS2_RAM_SIZE) - { - threadGp = callerGp; - } - - SET_GPR_U32(threadCtx, 29, threadSp); - SET_GPR_U32(threadCtx, 28, threadGp); - SET_GPR_U32(threadCtx, 4, info->arg); - SET_GPR_U32(threadCtx, 31, 0); - threadCtx->pc = info->entry; - - g_currentThreadId = tid; - - RUNTIME_LOG("[StartThread] id=" << tid - << " entry=0x" << std::hex << info->entry - << " sp=0x" << GPR_U32(threadCtx, 29) - << " gp=0x" << GPR_U32(threadCtx, 28) - << " arg=0x" << info->arg << std::dec << std::endl); - - bool exited = false; - try - { - uint32_t lastPc = 0xFFFFFFFFu; - uint32_t samePcCount = 0; - constexpr uint32_t kSamePcYieldMask = 0xFFu; - constexpr uint32_t kSamePcWarnInterval = 0x20000u; - uint64_t stepCount = 0u; - - while (runtime && !runtime->isStopRequested()) - { - ++stepCount; - if (info->terminated.load(std::memory_order_relaxed)) - { - throw ThreadExitException(); - } - - waitWhileSuspended(info, runtime); - - const uint32_t pc = threadCtx->pc; - info->currentPc.store(pc, std::memory_order_relaxed); - if (pc == 0u) - { - break; - } - - if ((stepCount & 0x1FFFFFu) == 0u) - { - RUNTIME_LOG("[StartThread] id=" << tid - << " heartbeat pc=0x" << std::hex << pc - << " ra=0x" << GPR_U32(threadCtx, 31) - << " sp=0x" << GPR_U32(threadCtx, 29) - << " gp=0x" << GPR_U32(threadCtx, 28) - << std::dec << std::endl); - } - - if (pc == lastPc) - { - ++samePcCount; - if ((samePcCount & kSamePcYieldMask) == 0u) - { - std::this_thread::sleep_for(std::chrono::milliseconds(1)); - } - if (samePcCount > kSamePcWarnInterval) - { - // If a thread is spinning for an extremely long time (e.g. idle thread), - // force a 1ms sleep to prevent host CPU starvation. - if ((samePcCount % (kSamePcWarnInterval * 8u)) == 0u) - { - std::this_thread::sleep_for(std::chrono::milliseconds(1)); - } - else if ((samePcCount % (kSamePcWarnInterval)) == 0u) - { - std::this_thread::yield(); - } - } - } - else - { - samePcCount = 0; - lastPc = pc; - } - - PS2Runtime::RecompiledFunction step = runtime->lookupFunction(pc); - if (!step) - { - std::cerr << "[StartThread] id=" << tid << " missing function for pc=0x" - << std::hex << pc << std::dec << std::endl; - throw ThreadExitException(); - } - uint64_t handoffBaseline = 0u; - { - PS2Runtime::GuestExecutionScope guestExecution(runtime); - step(rdram, threadCtx, runtime); - handoffBaseline = runtime->guestExecutionHandoffEpochSnapshot(); - } - runtime->waitForGuestExecutionHandoff(handoffBaseline); - } - } - catch (const ThreadExitException &) - { - exited = true; - } - catch (const std::exception &e) - { - std::cerr << "[StartThread] id=" << tid << " exception: " << e.what() << std::endl; - } - - if (!exited) - { - RUNTIME_LOG("[StartThread] id=" << tid << " returned (pc=0x" - << std::hex << threadCtx->pc << std::dec << ")" << std::endl); - } - - runExitHandlersForThread(tid, rdram, threadCtx, runtime); - - uint32_t detachedAutoStack = 0; - { - std::lock_guard lock(info->m); - info->started = false; - info->status = THS_DORMANT; - info->waitType = TSW_NONE; - info->waitId = 0; - info->wakeupCount = 0; - info->suspendCount = 0; - info->forceRelease = false; - info->terminated = false; - } - - bool stillRegistered = false; - { - std::lock_guard lock(g_thread_map_mutex); - stillRegistered = (g_threads.find(tid) != g_threads.end()); - } - if (!stillRegistered) - { - // ExitDeleteThread removes the record immediately; reclaim auto stack here. - std::lock_guard lock(info->m); - if (info->ownsStack && info->stack != 0) - { - detachedAutoStack = info->stack; - info->stack = 0; - info->stackSize = 0; - info->ownsStack = false; - } - } - - if (detachedAutoStack != 0 && runtime) - { - runtime->guestFree(detachedAutoStack); - } - - // Notify anybody waiting for termination (like TerminateThread) - info->cv.notify_all(); - - g_activeThreads.fetch_sub(1, std::memory_order_relaxed); }); - registerHostThread(tid, std::move(worker)); + target->ownsStack = true; } - catch (const std::exception &e) - { - std::cerr << "[StartThread] failed to spawn host thread for tid=" << tid << ": " << e.what() << std::endl; - g_activeThreads.fetch_sub(1, std::memory_order_relaxed); - std::lock_guard lock(info->m); - info->started = false; - info->status = THS_DORMANT; - info->waitType = TSW_NONE; - info->waitId = 0; - info->wakeupCount = 0; - info->suspendCount = 0; - info->forceRelease = false; - info->terminated = false; - setReturnS32(ctx, KE_ERROR); - return; - } - - setReturnS32(ctx, KE_OK); + const int result = ee.startThread(id, arg, *ctx, false); + setReturnS32(ctx, result); + ee.transferIfRequested(false); } void ExitThread(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { - RUNTIME_LOG("[ExitThread] Game requested thread exit! PC=0x" << std::hex << ctx->pc - << " RA=0x" << getRegU32(ctx, 31) << std::dec << " tid=" << g_currentThreadId << std::endl); - - runExitHandlersForThread(g_currentThreadId, rdram, ctx, runtime); - auto info = ensureCurrentThreadInfo(ctx); - if (info) - { - std::lock_guard lock(info->m); - info->terminated = true; - info->forceRelease = true; - info->waitType = TSW_NONE; - info->waitId = 0; - info->wakeupCount = 0; - } - if (info) - { - info->cv.notify_all(); - } - throw ThreadExitException(); + EeScheduler &ee = scheduler(rdram, ctx, runtime); + exitThreadWithHandlers(ee.currentThreadId(), ctx, runtime, false); } void ExitDeleteThread(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { - int tid = g_currentThreadId; - RUNTIME_LOG("[ExitDeleteThread] Game requested thread exit & delete! PC=0x" << std::hex << ctx->pc - << " RA=0x" << getRegU32(ctx, 31) << std::dec << " tid=" << tid << std::endl); - - runExitHandlersForThread(tid, rdram, ctx, runtime); - auto info = ensureCurrentThreadInfo(ctx); - if (info) - { - std::lock_guard lock(info->m); - info->terminated = true; - info->forceRelease = true; - info->waitType = TSW_NONE; - info->waitId = 0; - info->wakeupCount = 0; - } - if (info) - { - info->cv.notify_all(); - } - { - std::lock_guard lock(g_thread_map_mutex); - g_threads.erase(tid); - } - throw ThreadExitException(); + EeScheduler &ee = scheduler(rdram, ctx, runtime); + exitThreadWithHandlers(ee.currentThreadId(), ctx, runtime, true); } void TerminateThread(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { - int tid = static_cast(getRegU32(ctx, 4)); - if (tid == 0) - tid = g_currentThreadId; - - auto info = (tid == g_currentThreadId) ? ensureCurrentThreadInfo(ctx) : lookupThreadInfo(tid); - if (!info) + EeScheduler &ee = scheduler(rdram, ctx, runtime); + uint32_t ownedStack = 0; + const int result = ee.terminateThread(static_cast(getRegU32(ctx, 4)), ownedStack, false); + if (ownedStack != 0u) { - setReturnS32(ctx, KE_UNKNOWN_THID); - return; + runtime->guestFree(ownedStack); } - - int waitType = TSW_NONE; - int waitId = 0; - { - std::lock_guard lock(info->m); - if (info->status == THS_DORMANT) - { - setReturnS32(ctx, KE_DORMANT); - return; - } - waitType = info->waitType; - waitId = info->waitId; - info->terminated = true; - info->forceRelease = true; - } - info->cv.notify_all(); - notifyThreadWaitObject(waitType, waitId); - - if (tid == g_currentThreadId) - { - runExitHandlersForThread(tid, rdram, ctx, runtime); - throw ThreadExitException(); - } - else - { - // Block until the target thread actually finishes unwinding and becomes dormant. - // Drop the thread mutex before reacquiring GuestExecutionScope to avoid lock inversion. - std::unique_lock lock(info->m); - waitWithGuestExecutionReleasedUntilUnlocked( - runtime, - lock, - [&]() - { - info->cv.wait(lock, [&]() - { return !info->started && info->status == THS_DORMANT; }); - }); - } - - setReturnS32(ctx, KE_OK); + setReturnS32(ctx, result); } void SuspendThread(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { - int tid = static_cast(getRegU32(ctx, 4)); - if (tid == 0) - tid = g_currentThreadId; - - auto info = (tid == g_currentThreadId) ? ensureCurrentThreadInfo(ctx) : lookupThreadInfo(tid); - if (!info) - { - setReturnS32(ctx, KE_UNKNOWN_THID); - return; - } - - { - std::lock_guard lock(info->m); - if (info->status == THS_DORMANT) - { - setReturnS32(ctx, KE_DORMANT); - return; - } - info->suspendCount++; - applySuspendStatusLocked(*info); - } - info->cv.notify_all(); - - if (tid == g_currentThreadId) - { - std::unique_lock lock(info->m); - bool terminated = false; - waitWithGuestExecutionReleasedUntilUnlocked( - runtime, - lock, - [&]() - { - info->cv.wait(lock, [&]() - { return info->suspendCount == 0 || info->terminated.load(); }); - }, - [&]() - { - terminated = info->terminated.load(); - if (!terminated) - { - info->status = THS_RUN; - } - }); - - if (terminated) - { - throw ThreadExitException(); - } - } - - setReturnS32(ctx, KE_OK); + EeScheduler &ee = scheduler(rdram, ctx, runtime); + const int result = ee.suspendThread(static_cast(getRegU32(ctx, 4)), false); + setReturnS32(ctx, result); + ee.transferIfRequested(false); } void ResumeThread(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { - int tid = static_cast(getRegU32(ctx, 4)); - if (tid == 0) - tid = g_currentThreadId; - - auto info = (tid == g_currentThreadId) ? ensureCurrentThreadInfo(ctx) : lookupThreadInfo(tid); - if (!info) - { - setReturnS32(ctx, KE_UNKNOWN_THID); - return; - } - - { - std::lock_guard lock(info->m); - if (info->status == THS_DORMANT) - { - setReturnS32(ctx, KE_DORMANT); - return; - } - if (info->suspendCount <= 0) - { - setReturnS32(ctx, KE_NOT_SUSPEND); - return; - } - info->suspendCount--; - if (info->suspendCount == 0) - { - if (info->waitType != TSW_NONE) - { - info->status = THS_WAIT; - } - else - { - info->status = (tid == g_currentThreadId) ? THS_RUN : THS_READY; - } - } - } - info->cv.notify_all(); - setReturnS32(ctx, KE_OK); + EeScheduler &ee = scheduler(rdram, ctx, runtime); + const int result = ee.resumeThread(static_cast(getRegU32(ctx, 4)), false); + setReturnS32(ctx, result); + ee.transferIfRequested(false); } void GetThreadId(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { - setReturnS32(ctx, g_currentThreadId); + setReturnS32(ctx, scheduler(rdram, ctx, runtime).currentThreadId()); } void ReferThreadStatus(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { - int tid = static_cast(getRegU32(ctx, 4)); - uint32_t statusAddr = getRegU32(ctx, 5); - - if (tid == 0) // TH_SELF + EeScheduler &ee = scheduler(rdram, ctx, runtime); + int id = static_cast(getRegU32(ctx, 4)); + if (id == 0) { - tid = g_currentThreadId; + id = ee.currentThreadId(); } - - auto info = (tid == g_currentThreadId) ? ensureCurrentThreadInfo(ctx) : lookupThreadInfo(tid); - if (!info) + const GuestThread *thread = ee.thread(id); + if (!thread) { setReturnS32(ctx, KE_UNKNOWN_THID); return; } - - ee_thread_status_t *status = reinterpret_cast(getMemPtr(rdram, statusAddr)); + auto *status = getEeGuestStruct(rdram, getRegU32(ctx, 5)); if (!status) { setReturnS32(ctx, KE_ERROR); return; } - - std::lock_guard lock(info->m); - status->status = info->status; - status->func = info->entry; - status->stack = info->stack; - status->stack_size = info->stackSize; - status->gp_reg = info->gp; - status->initial_priority = info->priority; - status->current_priority = info->currentPriority; - status->attr = info->attr; - status->option = info->option; - status->waitType = info->waitType; - status->waitId = info->waitId; - status->wakeupCount = info->wakeupCount; + *status = {}; + status->status = rawThreadStatus(thread->status); + status->func = thread->entry; + status->stack = thread->stack; + status->stack_size = static_cast(thread->stackSize); + status->gp_reg = thread->gp; + status->initial_priority = thread->initialPriority; + status->current_priority = thread->currentPriority; + status->attr = thread->attr; + status->option = thread->option; + status->waitType = rawWaitType(thread->wait.reason); + status->waitId = waitId(*thread); + status->wakeupCount = thread->wakeupCount; setReturnS32(ctx, KE_OK); } @@ -801,362 +374,64 @@ namespace ps2_syscalls void SleepThread(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { - auto info = ensureCurrentThreadInfo(ctx); - if (!info) - { - setReturnS32(ctx, KE_UNKNOWN_THID); - return; - } - - throwIfTerminated(info); - - int ret = 0; - int wakeupCountAfter = 0; - bool terminated = false; - std::unique_lock lock(info->m); - - if (info->wakeupCount > 0) - { - info->wakeupCount--; - info->status = THS_RUN; - info->waitType = TSW_NONE; - info->waitId = 0; - ret = 0; - wakeupCountAfter = info->wakeupCount; - } - else - { - static std::atomic s_sleepBlockLogs{0}; - const uint32_t sleepBlockLog = s_sleepBlockLogs.fetch_add(1, std::memory_order_relaxed); - if (sleepBlockLog < 256u) - { - RUNTIME_LOG("[SleepThread:block] tid=" << g_currentThreadId - << " pc=0x" << std::hex << ctx->pc - << " ra=0x" << getRegU32(ctx, 31) - << std::dec << std::endl); - } - - info->status = THS_WAIT; - info->waitType = TSW_SLEEP; - info->waitId = 0; - info->forceRelease = false; - - waitWithGuestExecutionReleasedUntilUnlocked( - runtime, - lock, - [&]() - { - info->cv.wait(lock, [&]() - { return info->wakeupCount > 0 || info->forceRelease.load() || info->terminated.load(); }); - }, - [&]() - { - terminated = info->terminated.load(); - if (terminated) - { - return; - } - - info->status = THS_RUN; - info->waitType = TSW_NONE; - info->waitId = 0; - - if (info->forceRelease.load()) - { - info->forceRelease = false; - ret = KE_RELEASE_WAIT; - } - else - { - if (info->wakeupCount > 0) - { - info->wakeupCount--; - } - ret = 0; - } - wakeupCountAfter = info->wakeupCount; - }); - } - - if (terminated) - { - throw ThreadExitException(); - } - - static std::atomic s_sleepWakeLogs{0}; - const uint32_t sleepWakeLog = s_sleepWakeLogs.fetch_add(1, std::memory_order_relaxed); - if (sleepWakeLog < 256u) - { - RUNTIME_LOG("[SleepThread:wake] tid=" << g_currentThreadId - << " ret=" << ret - << " wakeupCount=" << wakeupCountAfter - << std::endl); - } - - if (lock.owns_lock()) - { - lock.unlock(); - } - waitWhileSuspended(info, runtime); - setReturnS32(ctx, ret); + EeScheduler &ee = scheduler(rdram, ctx, runtime); + ee.sleepCurrent(); + setReturnS32(ctx, KE_OK); } void WakeupThread(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { - int tid = static_cast(getRegU32(ctx, 4)); - if (tid == 0) - { - setReturnS32(ctx, KE_ILLEGAL_THID); - return; - } - if (tid == g_currentThreadId) - { - setReturnS32(ctx, KE_ILLEGAL_THID); - return; - } - - auto info = lookupThreadInfo(tid); - if (!info) - { - setReturnS32(ctx, KE_UNKNOWN_THID); - return; - } - - int newWakeupCount = 0; - int statusAfter = THS_DORMANT; - bool wokeSleeper = false; - { - std::lock_guard lock(info->m); - if (info->status == THS_DORMANT) - { - setReturnS32(ctx, KE_DORMANT); - return; - } - if (info->status == THS_WAIT && info->waitType == TSW_SLEEP) - { - if (info->suspendCount > 0) - { - info->status = THS_SUSPEND; - } - else - { - info->status = THS_READY; - } - info->waitType = TSW_NONE; - info->waitId = 0; - info->wakeupCount++; - info->cv.notify_one(); - wokeSleeper = true; - } - else - { - info->wakeupCount++; - } - newWakeupCount = info->wakeupCount; - statusAfter = info->status; - } - - static std::atomic s_wakeupLogs{0}; - const uint32_t wakeupLog = s_wakeupLogs.fetch_add(1, std::memory_order_relaxed); - if (wakeupLog < 256u) - { - RUNTIME_LOG("[WakeupThread] tid=" << g_currentThreadId - << " target=" << tid - << " status=" << statusAfter - << " wakeupCount=" << newWakeupCount - << std::endl); - } - setReturnS32(ctx, KE_OK); - if (wokeSleeper) - { - yieldGuestExecutionAfterWake(runtime); - } + wakeupThreadImpl(rdram, ctx, runtime, false); } void iWakeupThread(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { - WakeupThread(rdram, ctx, runtime); + wakeupThreadImpl(rdram, ctx, runtime, true); } void CancelWakeupThread(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { - int tid = static_cast(getRegU32(ctx, 4)); - if (tid == 0) - tid = g_currentThreadId; - - auto info = (tid == g_currentThreadId) ? ensureCurrentThreadInfo(ctx) : lookupThreadInfo(tid); - if (!info) - { - setReturnS32(ctx, KE_UNKNOWN_THID); - return; - } - - int previous = 0; - { - std::lock_guard lock(info->m); - previous = info->wakeupCount; - info->wakeupCount = 0; - } - setReturnS32(ctx, previous); + setReturnS32(ctx, + scheduler(rdram, ctx, runtime).cancelWakeup(static_cast(getRegU32(ctx, 4)))); } void iCancelWakeupThread(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { - int tid = static_cast(getRegU32(ctx, 4)); - if (tid == 0) + if (getRegU32(ctx, 4) == 0u) { setReturnS32(ctx, KE_ILLEGAL_THID); return; } - - auto info = lookupThreadInfo(tid); - if (!info) - { - setReturnS32(ctx, KE_UNKNOWN_THID); - return; - } - - int previous = 0; - { - std::lock_guard lock(info->m); - previous = info->wakeupCount; - info->wakeupCount = 0; - } - setReturnS32(ctx, previous); + CancelWakeupThread(rdram, ctx, runtime); } void ChangeThreadPriority(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { - int tid = static_cast(getRegU32(ctx, 4)); - int newPrio = static_cast(getRegU32(ctx, 5)); - - if (tid == 0) - tid = g_currentThreadId; - - auto info = (tid == g_currentThreadId) ? ensureCurrentThreadInfo(ctx) : lookupThreadInfo(tid); - if (!info) - { - setReturnS32(ctx, KE_UNKNOWN_THID); - return; - } - - { - std::lock_guard lock(info->m); - if (info->status == THS_DORMANT) - { - setReturnS32(ctx, KE_DORMANT); - return; - } - - if (newPrio == 0) - { - newPrio = (info->currentPriority > 0) ? info->currentPriority : 1; - } - if (newPrio <= 0 || newPrio >= 128) - { - setReturnS32(ctx, KE_ILLEGAL_PRIORITY); - return; - } - - info->currentPriority = newPrio; - } - - setReturnS32(ctx, KE_OK); + changePriorityImpl(rdram, ctx, runtime, false); } void iChangeThreadPriority(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { - ChangeThreadPriority(rdram, ctx, runtime); + changePriorityImpl(rdram, ctx, runtime, true); } void RotateThreadReadyQueue(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { - static int logCount = 0; - int prio = static_cast(getRegU32(ctx, 4)); - if (prio == 0) - { - auto current = ensureCurrentThreadInfo(ctx); - if (current) - { - std::lock_guard lock(current->m); - prio = (current->currentPriority > 0) ? current->currentPriority : 1; - } - } - if (logCount < 16) - { - RUNTIME_LOG("[RotateThreadReadyQueue] prio=" << prio); - ++logCount; - } - if (prio <= 0 || prio >= 128) - { - setReturnS32(ctx, KE_ILLEGAL_PRIORITY); - return; - } - - setReturnS32(ctx, KE_OK); - yieldGuestExecutionAfterWake(runtime); + rotateReadyQueueImpl(rdram, ctx, runtime, false); } void iRotateThreadReadyQueue(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { - RotateThreadReadyQueue(rdram, ctx, runtime); + rotateReadyQueueImpl(rdram, ctx, runtime, true); } void ReleaseWaitThread(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { - int tid = static_cast(getRegU32(ctx, 4)); - if (tid == 0 || tid == g_currentThreadId) - { - setReturnS32(ctx, KE_ILLEGAL_THID); - return; - } - - auto info = lookupThreadInfo(tid); - if (!info) - { - setReturnS32(ctx, KE_UNKNOWN_THID); - return; - } - - bool wasWaiting = false; - int waitType = 0; - int waitId = 0; - - { - std::lock_guard lock(info->m); - if (info->status == THS_WAIT || info->status == THS_WAITSUSPEND) - { - wasWaiting = true; - waitType = info->waitType; - waitId = info->waitId; - info->forceRelease = true; - info->waitType = TSW_NONE; - info->waitId = 0; - if (info->suspendCount > 0) - { - info->status = THS_SUSPEND; - } - else - { - info->status = THS_READY; - } - } - } - - if (!wasWaiting) - { - setReturnS32(ctx, KE_NOT_WAIT); - return; - } - - info->cv.notify_all(); - notifyThreadWaitObject(waitType, waitId); - setReturnS32(ctx, KE_OK); - yieldGuestExecutionAfterWake(runtime); + releaseWaitImpl(rdram, ctx, runtime, false); } void iReleaseWaitThread(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { - ReleaseWaitThread(rdram, ctx, runtime); + releaseWaitImpl(rdram, ctx, runtime, true); } } diff --git a/ps2xRuntime/src/lib/ps2_debug_panel.cpp b/ps2xRuntime/src/lib/ps2_debug_panel.cpp index 9e5e2fd14..71c647943 100644 --- a/ps2xRuntime/src/lib/ps2_debug_panel.cpp +++ b/ps2xRuntime/src/lib/ps2_debug_panel.cpp @@ -2,6 +2,7 @@ #include "ps2_runtime.h" #include "ps2_runtime_macros.h" #include "ps2_log.h" +#include "runtime/ee_scheduler.h" #include #include "Kernel/Syscalls/Helpers/State.h" @@ -32,39 +33,45 @@ namespace { #if defined(PS2X_ENABLE_DEBUG_UI) && !defined(PLATFORM_VITA) - const char *threadStatusName(int status) + const char *threadStatusName(EeThreadStatus status) { switch (status) { - case THS_RUN: + case EeThreadStatus::Running: return "RUN"; - case THS_READY: + case EeThreadStatus::Ready: return "READY"; - case THS_WAIT: + case EeThreadStatus::Waiting: return "WAIT"; - case THS_SUSPEND: + case EeThreadStatus::Suspended: return "SUSPEND"; - case THS_WAITSUSPEND: + case EeThreadStatus::WaitingSuspended: return "WAITSUSP"; - case THS_DORMANT: + case EeThreadStatus::Dormant: return "DORMANT"; default: return "?"; } } - const char *waitTypeName(int waitType) + const char *waitTypeName(EeWaitReason waitType) { switch (waitType) { - case TSW_NONE: + case EeWaitReason::None: return "NONE"; - case TSW_SLEEP: + case EeWaitReason::Sleep: return "SLEEP"; - case TSW_SEMA: + case EeWaitReason::Semaphore: return "SEMA"; - case TSW_EVENT: + case EeWaitReason::EventFlag: return "EVENT"; + case EeWaitReason::VSync: + return "VSYNC"; + case EeWaitReason::External: + return "EXTERNAL"; + case EeWaitReason::Mpeg: + return "MPEG"; default: return "?"; } @@ -698,7 +705,7 @@ namespace const uint32_t gp = runtime.m_debugGp.load(std::memory_order_relaxed); ImGui::Text("Runtime: %s", runtime.isStopRequested() ? "stop requested" : "running"); - ImGui::Text("Guest execution waiters: %u", runtime.guestExecutionWaiterCountForTesting()); + ImGui::Text("EE executor: %s", runtime.eeScheduler().isExecutingGuest() ? "guest" : "scheduler"); ImGui::Separator(); textHex32("PC", pc); ImGui::SameLine(); @@ -756,60 +763,11 @@ namespace } } - void drawThreadsTab() + void drawThreadsTab(PS2Runtime &runtime) { - struct ThreadRow - { - int id = 0; - uint32_t entry = 0; - uint32_t stack = 0; - uint32_t stackSize = 0; - uint32_t gp = 0; - uint32_t priority = 0; - int status = 0; - int waitType = 0; - int waitId = 0; - int currentPriority = 0; - int wakeupCount = 0; - int suspendCount = 0; - uint32_t currentPc = 0u; - bool terminated = false; - }; - - std::vector rows; - { - std::lock_guard lock(g_thread_map_mutex); - rows.reserve(g_threads.size()); - for (const auto &[id, ptr] : g_threads) - { - if (!ptr) - { - continue; - } - ThreadRow row{}; - row.id = id; - { - std::lock_guard threadLock(ptr->m); - row.entry = ptr->entry; - row.stack = ptr->stack; - row.stackSize = ptr->stackSize; - row.gp = ptr->gp; - row.priority = ptr->priority; - row.currentPriority = ptr->currentPriority; - row.status = ptr->status; - row.waitType = ptr->waitType; - row.waitId = ptr->waitId; - row.wakeupCount = ptr->wakeupCount; - row.suspendCount = ptr->suspendCount; - } - row.currentPc = ptr->currentPc.load(std::memory_order_relaxed); - row.terminated = ptr->terminated.load(std::memory_order_relaxed); - rows.push_back(row); - } - } - - ImGui::Text("Threads: %zu activeThreads=%d", rows.size(), g_activeThreads.load(std::memory_order_relaxed)); - if (ImGui::BeginTable("threads", 12, ImGuiTableFlags_Borders | ImGuiTableFlags_RowBg | ImGuiTableFlags_Resizable | ImGuiTableFlags_ScrollY, ImVec2(0, 320))) + const EeKernelSnapshot snapshot = runtime.eeScheduler().snapshot(); + ImGui::Text("Threads: %zu running=%d", snapshot.threads.size(), snapshot.runningThreadId); + if (ImGui::BeginTable("threads", 11, ImGuiTableFlags_Borders | ImGuiTableFlags_RowBg | ImGuiTableFlags_Resizable | ImGuiTableFlags_ScrollY, ImVec2(0, 320))) { ImGui::TableSetupColumn("ID"); ImGui::TableSetupColumn("Status"); @@ -822,9 +780,8 @@ namespace ImGui::TableSetupColumn("Prio"); ImGui::TableSetupColumn("Wake"); ImGui::TableSetupColumn("Susp"); - ImGui::TableSetupColumn("Term"); ImGui::TableHeadersRow(); - for (const ThreadRow &row : rows) + for (const EeThreadSnapshot &row : snapshot.threads) { ImGui::TableNextRow(); ImGui::TableNextColumn(); @@ -832,11 +789,11 @@ namespace ImGui::TableNextColumn(); ImGui::Text("%s", threadStatusName(row.status)); ImGui::TableNextColumn(); - ImGui::Text("%s", waitTypeName(row.waitType)); + ImGui::Text("%s", waitTypeName(row.waitReason)); ImGui::TableNextColumn(); ImGui::Text("%d", row.waitId); ImGui::TableNextColumn(); - ImGui::Text("0x%08X", row.currentPc); + ImGui::Text("0x%08X", row.pc); ImGui::TableNextColumn(); ImGui::Text("0x%08X", row.entry); ImGui::TableNextColumn(); @@ -844,23 +801,21 @@ namespace ImGui::TableNextColumn(); ImGui::Text("0x%08X", row.gp); ImGui::TableNextColumn(); - ImGui::Text("%d/%u", row.currentPriority, row.priority); + ImGui::Text("%d/%d", row.currentPriority, row.initialPriority); ImGui::TableNextColumn(); - ImGui::Text("%d", row.wakeupCount); + ImGui::Text("%u", row.wakeupCount); ImGui::TableNextColumn(); ImGui::Text("%d", row.suspendCount); - ImGui::TableNextColumn(); - ImGui::Text("%u", row.terminated ? 1u : 0u); } ImGui::EndTable(); } } - void drawKernelTab() + void drawKernelTab(PS2Runtime &runtime) { + const EeKernelSnapshot snapshot = runtime.eeScheduler().snapshot(); ImGui::SeparatorText("Semaphores"); { - std::lock_guard lock(g_sema_map_mutex); if (ImGui::BeginTable("semas", 7, ImGuiTableFlags_Borders | ImGuiTableFlags_RowBg | ImGuiTableFlags_Resizable)) { ImGui::TableSetupColumn("ID"); @@ -871,26 +826,23 @@ namespace ImGui::TableSetupColumn("Attr"); ImGui::TableSetupColumn("Deleted"); ImGui::TableHeadersRow(); - for (const auto &[id, sema] : g_semas) + for (const EeSemaphoreSnapshot &sema : snapshot.semaphores) { - if (!sema) - continue; - std::lock_guard semaLock(sema->m); ImGui::TableNextRow(); ImGui::TableNextColumn(); - ImGui::Text("%d", id); + ImGui::Text("%d", sema.id); ImGui::TableNextColumn(); - ImGui::Text("%d", sema->count); + ImGui::Text("%d", sema.count); ImGui::TableNextColumn(); - ImGui::Text("%d", sema->maxCount); + ImGui::Text("%d", sema.maxCount); ImGui::TableNextColumn(); - ImGui::Text("%d", sema->initCount); + ImGui::Text("-"); ImGui::TableNextColumn(); - ImGui::Text("%d", sema->waiters); + ImGui::Text("%u", sema.waiters); ImGui::TableNextColumn(); - ImGui::Text("0x%08X", sema->attr); + ImGui::Text("-"); ImGui::TableNextColumn(); - ImGui::Text("%u", sema->deleted ? 1u : 0u); + ImGui::Text("0"); } ImGui::EndTable(); } @@ -898,7 +850,6 @@ namespace ImGui::SeparatorText("Event flags"); { - std::lock_guard lock(g_event_flag_map_mutex); if (ImGui::BeginTable("evf", 6, ImGuiTableFlags_Borders | ImGuiTableFlags_RowBg | ImGuiTableFlags_Resizable)) { ImGui::TableSetupColumn("ID"); @@ -908,24 +859,21 @@ namespace ImGui::TableSetupColumn("Attr"); ImGui::TableSetupColumn("Deleted"); ImGui::TableHeadersRow(); - for (const auto &[id, evf] : g_eventFlags) + for (const EeEventFlagSnapshot &evf : snapshot.eventFlags) { - if (!evf) - continue; - std::lock_guard evfLock(evf->m); ImGui::TableNextRow(); ImGui::TableNextColumn(); - ImGui::Text("%d", id); + ImGui::Text("%d", evf.id); ImGui::TableNextColumn(); - ImGui::Text("0x%08X", evf->bits); + ImGui::Text("0x%08X", evf.bits); ImGui::TableNextColumn(); - ImGui::Text("0x%08X", evf->initBits); + ImGui::Text("0x%08X", evf.initBits); ImGui::TableNextColumn(); - ImGui::Text("%d", evf->waiters); + ImGui::Text("%u", evf.waiters); ImGui::TableNextColumn(); - ImGui::Text("0x%08X", evf->attr); + ImGui::Text("0x%08X", evf.attr); ImGui::TableNextColumn(); - ImGui::Text("%u", evf->deleted ? 1u : 0u); + ImGui::Text("0"); } ImGui::EndTable(); } @@ -2249,12 +2197,12 @@ void PS2DebugPanel::draw(PS2Runtime &runtime) } if (ImGui::BeginTabItem("Threads")) { - drawThreadsTab(); + drawThreadsTab(runtime); ImGui::EndTabItem(); } if (ImGui::BeginTabItem("Kernel")) { - drawKernelTab(); + drawKernelTab(runtime); ImGui::EndTabItem(); } if (ImGui::BeginTabItem("IOP/SIF")) diff --git a/ps2xRuntime/src/lib/ps2_gs_gpu.cpp b/ps2xRuntime/src/lib/ps2_gs_gpu.cpp index f1f2bde9f..e9f67c946 100644 --- a/ps2xRuntime/src/lib/ps2_gs_gpu.cpp +++ b/ps2xRuntime/src/lib/ps2_gs_gpu.cpp @@ -617,7 +617,7 @@ void GS::recordDebugEventUnlocked(GSDebugHistoryEntry entry) return; } - const uint64_t tick = ps2_syscalls::GetCurrentVSyncTick(); + const uint64_t tick = m_privRegs ? m_privRegs->vsyncTick.load(std::memory_order_acquire) : 0u; if (m_debugLastVsyncTick == UINT64_MAX) { m_debugLastVsyncTick = tick; @@ -960,7 +960,7 @@ void GS::latchHostPresentationFrameUnlocked() const GSPmodeState pmode = decodePmode(m_privRegs->pmode); const GSSmode2State smode2 = decodeSMode2(m_privRegs->smode2); const bool applyFieldMode = smode2.interlaced && !smode2.frameMode; - const bool oddField = (ps2_syscalls::GetCurrentVSyncTick() & 1ull) != 0ull; + const bool oddField = (m_privRegs->vsyncTick.load(std::memory_order_acquire) & 1ull) != 0ull; const GSFrameReg displayFrame1 = decodeDisplayFrame(m_privRegs->dispfb1); const GSFrameReg displayFrame2 = decodeDisplayFrame(m_privRegs->dispfb2); const GSDisplayReadOrigin displayOrigin1 = decodeDisplayReadOrigin(m_privRegs->dispfb1); diff --git a/ps2xRuntime/src/lib/ps2_iop_host.cpp b/ps2xRuntime/src/lib/ps2_iop_host.cpp index d60484382..1a165a686 100644 --- a/ps2xRuntime/src/lib/ps2_iop_host.cpp +++ b/ps2xRuntime/src/lib/ps2_iop_host.cpp @@ -458,21 +458,17 @@ bool PS2IopHostAdapter::invokeGuestFunction(uint64_t callToken, uint32_t a3, uint32_t *resultAddress) { - if (!m_activeContext || callToken == 0 || callToken != m_activeToken) + (void)callToken; + (void)address; + (void)a0; + (void)a1; + (void)a2; + (void)a3; + if (resultAddress) { - return false; + *resultAddress = 0u; } - return rpcInvokeFunction(m_activeRdram - ? m_activeRdram - : m_runtime.memory().getRDRAM(), - m_activeContext, - &m_runtime, - address, - a0, - a1, - a2, - a3, - resultAddress); + return false; } void PS2IopHostAdapter::log(ps2x::iop::LogLevel level, std::string_view message) diff --git a/ps2xRuntime/src/lib/ps2_runtime.cpp b/ps2xRuntime/src/lib/ps2_runtime.cpp index b79e386a5..a94c6b4c7 100644 --- a/ps2xRuntime/src/lib/ps2_runtime.cpp +++ b/ps2xRuntime/src/lib/ps2_runtime.cpp @@ -5,6 +5,7 @@ #include "game_overrides.h" #include "ps2_runtime_macros.h" #include "runtime/ps2_gs_gpu.h" +#include "runtime/ee_scheduler.h" #include "ThreadNaming.h" #include "Kernel/Stubs/Audio.h" #include "Kernel/Stubs/GS.h" @@ -107,9 +108,6 @@ namespace }; thread_local DispatchHistory g_dispatchHistory; - thread_local std::unordered_map g_guestExecutionDepths; - thread_local uint32_t g_deferredGuestYieldDepth = 0u; - thread_local bool g_deferredGuestYieldPending = false; bool computeFileCrc32(const std::string &path, uint32_t &crcOut) { @@ -368,40 +366,6 @@ namespace } } -PS2Runtime::GuestExecutionScope::GuestExecutionScope(PS2Runtime *runtime) noexcept - : m_runtime(runtime) -{ - if (m_runtime) - { - m_runtime->enterGuestExecution(); - } -} - -PS2Runtime::GuestExecutionScope::~GuestExecutionScope() -{ - if (m_runtime) - { - m_runtime->leaveGuestExecution(); - } -} - -PS2Runtime::GuestExecutionReleaseScope::GuestExecutionReleaseScope(PS2Runtime *runtime) noexcept - : m_runtime(runtime) -{ - if (m_runtime) - { - m_depth = m_runtime->releaseGuestExecution(); - } -} - -PS2Runtime::GuestExecutionReleaseScope::~GuestExecutionReleaseScope() -{ - if (m_runtime && m_depth != 0u) - { - m_runtime->reacquireGuestExecution(m_depth); - } -} - static void UploadFrame(Texture2D &tex, PS2Runtime *rt, uint32_t &outWidth, uint32_t &outHeight) { static uint64_t s_lastPresentationTick = std::numeric_limits::max(); @@ -415,7 +379,7 @@ static void UploadFrame(Texture2D &tex, PS2Runtime *rt, uint32_t &outWidth, uint static std::vector s_scratch; static std::vector s_uploadBuffer(DEFAULT_FB_SIZE, 0u); - const uint64_t currentTick = ps2_syscalls::GetCurrentVSyncTick(); + const uint64_t currentTick = rt->eeScheduler().currentVSyncTick(); const bool needsLatch = !s_hasLatchedInitialFrame || currentTick != s_lastPresentationTick; if (needsLatch) { @@ -510,6 +474,7 @@ PS2Runtime::PS2Runtime() { m_iopHost = std::make_unique(*this); m_iopSubsystem = std::make_unique(*m_iopHost); + m_eeScheduler = std::make_unique(*this); #if defined(PS2X_IOP_ENABLE_PLUGINS) && PS2X_IOP_ENABLE_PLUGINS && \ !defined(PLATFORM_VITA) && (defined(_WIN32) || defined(__linux__)) if (const char *applicationDirectory = GetApplicationDirectory(); @@ -559,7 +524,6 @@ PS2Runtime::~PS2Runtime() try { requestStop(); - ps2_syscalls::detachAllGuestHostThreads(); m_iopSubsystem.reset(); m_iopHost.reset(); #if defined(PLATFORM_VITA) @@ -1928,249 +1892,6 @@ uint32_t PS2Runtime::reserveAsyncCallbackStack(uint32_t size, uint32_t alignment return top - 0x10u; } -void PS2Runtime::dispatchLoop(uint8_t *rdram, R5900Context *ctx) -{ - uint32_t lastPc = std::numeric_limits::max(); - uint32_t samePcCount = 0; - constexpr uint32_t kSamePcYieldInterval = 0x4000u; - - while (!isStopRequested()) - { - const uint32_t pc = ctx->pc; - - if (pc == lastPc) - { - ++samePcCount; - if ((samePcCount % kSamePcYieldInterval) == 0u) - { - PS2_IF_AGRESSIVE_LOGS({ - RUNTIME_LOG("CPU is doing some work at PC 0x" << std::hex << pc << ". PC not updating."); - }); - std::this_thread::yield(); - } - } - else - { - samePcCount = 0; - lastPc = pc; - } - - m_debugPc.store(pc, std::memory_order_relaxed); - m_debugRa.store(static_cast(_mm_extract_epi32(ctx->r[31], 0)), std::memory_order_relaxed); - m_debugSp.store(static_cast(_mm_extract_epi32(ctx->r[29], 0)), std::memory_order_relaxed); - m_debugGp.store(static_cast(_mm_extract_epi32(ctx->r[28], 0)), std::memory_order_relaxed); - - RecompiledFunction fn = lookupFunction(pc); - const uint32_t dispatchedPc = pc; - const uint32_t dispatchedRa = static_cast(_mm_extract_epi32(ctx->r[31], 0)); - - uint64_t handoffBaseline = 0u; - { - GuestExecutionScope guestExecution(this); - fn(rdram, ctx, this); - handoffBaseline = guestExecutionHandoffEpochSnapshot(); - } - - waitForGuestExecutionHandoff(handoffBaseline); - - if (ctx->pc == 0u) - { - const uint32_t ra = static_cast(_mm_extract_epi32(ctx->r[31], 0)); - const uint32_t sp = static_cast(_mm_extract_epi32(ctx->r[29], 0)); - const uint32_t gp = static_cast(_mm_extract_epi32(ctx->r[28], 0)); - PS2_IF_AGRESSIVE_LOGS({ - std::cerr << "[dispatch:pc-zero] from=0x" << std::hex << dispatchedPc - << " fromRa=0x" << dispatchedRa - << " ra=0x" << ra - << " sp=0x" << sp - << " gp=0x" << gp - << " trace=" << formatDispatchHistory() - << std::dec << std::endl; - }); - - // PC=0 means this guest thread returned (usually via jr $ra with RA=0). - // Do not request a global runtime stop here: other guest threads may still run. - break; - } - } -} - -void PS2Runtime::enterGuestExecution() -{ - uint32_t &depth = g_guestExecutionDepths[this]; - - if (depth != 0u) - { - m_guestExecutionMutex.lock(); - ++depth; - return; - } - - m_guestExecutionWaiters.fetch_add(1u, std::memory_order_acq_rel); - m_guestExecutionMutex.lock(); - m_guestExecutionWaiters.fetch_sub(1u, std::memory_order_acq_rel); - depth = 1u; - markGuestExecutionAcquired(); -} - -void PS2Runtime::leaveGuestExecution() -{ - auto it = g_guestExecutionDepths.find(this); - if (it == g_guestExecutionDepths.end() || it->second == 0u) - { - return; - } - - --it->second; - m_guestExecutionMutex.unlock(); - if (it->second == 0u) - { - g_guestExecutionDepths.erase(it); - } -} - -uint32_t PS2Runtime::releaseGuestExecution() -{ - auto it = g_guestExecutionDepths.find(this); - if (it == g_guestExecutionDepths.end() || it->second == 0u) - { - return 0u; - } - - const uint32_t depth = it->second; - for (uint32_t i = 0; i < depth; ++i) - { - m_guestExecutionMutex.unlock(); - } - g_guestExecutionDepths.erase(it); - return depth; -} - -void PS2Runtime::reacquireGuestExecution(uint32_t depth) -{ - if (depth == 0u) - { - return; - } - - uint32_t &heldDepth = g_guestExecutionDepths[this]; - uint32_t remaining = depth; - - if (heldDepth == 0u) - { - m_guestExecutionWaiters.fetch_add(1u, std::memory_order_acq_rel); - m_guestExecutionMutex.lock(); - m_guestExecutionWaiters.fetch_sub(1u, std::memory_order_acq_rel); - heldDepth = 1u; - markGuestExecutionAcquired(); - --remaining; - } - - for (uint32_t i = 0; i < remaining; ++i) - { - m_guestExecutionMutex.lock(); - ++heldDepth; - } -} - -void PS2Runtime::markGuestExecutionAcquired() -{ - { - std::lock_guard lock(m_guestExecutionHandoffMutex); - m_guestExecutionHandoffEpoch.fetch_add(1u, std::memory_order_acq_rel); - } - m_guestExecutionHandoffCv.notify_all(); -} - -void PS2Runtime::waitForGuestExecutionHandoff() -{ - waitForGuestExecutionHandoff(guestExecutionHandoffEpochSnapshot()); -} - -void PS2Runtime::waitForGuestExecutionHandoff(uint64_t baselineEpoch) -{ - // Lock-free fast path - if (m_guestExecutionWaiters.load(std::memory_order_acquire) == 0u) - { - return; - } - - std::unique_lock lock(m_guestExecutionHandoffMutex); - - if (m_guestExecutionWaiters.load(std::memory_order_acquire) == 0u) - { - return; - } - - const bool handedOff = m_guestExecutionHandoffCv.wait_for( - lock, - std::chrono::milliseconds(2), - [&]() - { - return m_guestExecutionWaiters.load(std::memory_order_acquire) == 0u || - m_guestExecutionHandoffEpoch.load(std::memory_order_relaxed) != baselineEpoch || - isStopRequested(); - }); - - if (!handedOff) - { - m_guestExecutionHandoffTimeouts.fetch_add(1u, std::memory_order_relaxed); - } -} - -PS2Runtime::DeferredGuestYieldScope::DeferredGuestYieldScope(bool &pendingOut) noexcept - : m_pendingOut(pendingOut) -{ - ++g_deferredGuestYieldDepth; -} - -PS2Runtime::DeferredGuestYieldScope::~DeferredGuestYieldScope() -{ - if (--g_deferredGuestYieldDepth == 0u && g_deferredGuestYieldPending) - { - g_deferredGuestYieldPending = false; - m_pendingOut = true; - } -} - -void PS2Runtime::yieldGuestExecutionAfterWake() -{ - if (g_deferredGuestYieldDepth != 0u) - { - g_deferredGuestYieldPending = true; - return; - } - - auto it = g_guestExecutionDepths.find(this); - if (it == g_guestExecutionDepths.end() || it->second == 0u) - { - std::this_thread::yield(); - return; - } - - const uint64_t handoffEpoch = m_guestExecutionHandoffEpoch.load(std::memory_order_acquire); - { - GuestExecutionReleaseScope releaseGuestExecution(this); - std::unique_lock lock(m_guestExecutionHandoffMutex); - m_guestExecutionHandoffCv.wait_for(lock, std::chrono::milliseconds(2), [&]() - { return m_guestExecutionHandoffEpoch.load(std::memory_order_acquire) != handoffEpoch; }); - } -} - -bool PS2Runtime::shouldPreemptGuestExecution() -{ - thread_local uint32_t s_backEdgeYieldCounter = 0u; - const uint32_t waiterCount = m_guestExecutionWaiters.load(std::memory_order_acquire); - const uint32_t yieldInterval = (waiterCount != 0u) ? 64u : 100u; - if (++s_backEdgeYieldCounter < yieldInterval) - { - return false; - } - - s_backEdgeYieldCounter = 0u; - return true; -} - uint8_t PS2Runtime::Load8(uint8_t *rdram, R5900Context *ctx, uint32_t vaddr) { try @@ -2341,7 +2062,10 @@ void PS2Runtime::kickGifDmaChainFromMMIO(uint8_t *rdram, void PS2Runtime::requestStop() { m_stopRequested.store(true, std::memory_order_relaxed); - ps2_syscalls::notifyRuntimeStop(); + if (m_eeScheduler) + { + m_eeScheduler->requestStop(); + } } bool PS2Runtime::isStopRequested() const @@ -2349,6 +2073,134 @@ bool PS2Runtime::isStopRequested() const return m_stopRequested.load(std::memory_order_relaxed); } +EeScheduler &PS2Runtime::eeScheduler() +{ + return *m_eeScheduler; +} + +const EeScheduler &PS2Runtime::eeScheduler() const +{ + return *m_eeScheduler; +} + +void PS2Runtime::postEeEvent(EeEvent event) +{ + m_eeScheduler->postEvent(event); +} + +bool PS2Runtime::eeCheckpointDue() const noexcept +{ + return m_eeScheduler->checkpointDue(); +} + +void PS2Runtime::addEeExitHandler(int threadId, uint32_t function, uint32_t argument) +{ + std::lock_guard lock(m_eeKernelStateMutex); + m_eeExitHandlers[threadId].push_back({function, argument}); +} + +std::vector PS2Runtime::takeEeExitHandlers(int threadId) +{ + std::lock_guard lock(m_eeKernelStateMutex); + auto it = m_eeExitHandlers.find(threadId); + if (it == m_eeExitHandlers.end()) + { + return {}; + } + auto handlers = std::move(it->second); + m_eeExitHandlers.erase(it); + return handlers; +} + +void PS2Runtime::removeEeExitHandlers(int threadId) +{ + std::lock_guard lock(m_eeKernelStateMutex); + m_eeExitHandlers.erase(threadId); +} + +bool PS2Runtime::findEeSyscallOverride(uint32_t syscallNumber, uint32_t &handler) const +{ + std::lock_guard lock(m_eeKernelStateMutex); + const auto it = m_eeSyscallOverrides.find(syscallNumber); + if (it == m_eeSyscallOverrides.end()) + { + return false; + } + handler = it->second; + return true; +} + +void PS2Runtime::setEeSyscallOverride(uint8_t *rdram, uint32_t syscallNumber, uint32_t handler) +{ + constexpr uint32_t kTableBase = 0x80011F80u & 0x1FFFFFFFu; + constexpr uint32_t kMirrorLimit = 0x00080000u; + const int64_t offset = static_cast(static_cast(syscallNumber)) * 4; + const int64_t address = static_cast(kTableBase) + offset; + + std::lock_guard lock(m_eeKernelStateMutex); + if (handler == 0u) + { + m_eeSyscallOverrides.erase(syscallNumber); + } + else + { + m_eeSyscallOverrides[syscallNumber] = handler; + } + if (!rdram || address < 0 || address + 4 > kMirrorLimit) + { + return; + } + const uint32_t guestAddress = static_cast(address); + std::memcpy(rdram + guestAddress, &handler, sizeof(handler)); + if (handler == 0u) + { + m_eeSyscallMirrorAddresses.erase(guestAddress); + } + else + { + m_eeSyscallMirrorAddresses.insert(guestAddress); + } +} + +void PS2Runtime::initializeEeKernelState(uint8_t *rdram) +{ + if (!rdram) + { + return; + } + constexpr uint32_t kTableGuestBase = 0x80011F80u; + constexpr uint32_t kTableBase = kTableGuestBase & 0x1FFFFFFFu; + constexpr uint32_t kMirrorLimit = 0x00080000u; + constexpr uint32_t kProbeBase = 0x000002F0u; + + std::lock_guard lock(m_eeKernelStateMutex); + for (const uint32_t address : m_eeSyscallMirrorAddresses) + { + const uint32_t zero = 0u; + std::memcpy(rdram + address, &zero, sizeof(zero)); + } + m_eeSyscallMirrorAddresses.clear(); + const uint32_t high = kTableGuestBase >> 16; + const uint32_t low = kTableGuestBase & 0xFFFFu; + std::memcpy(rdram + kProbeBase, &high, sizeof(high)); + std::memcpy(rdram + kProbeBase + 8u, &low, sizeof(low)); + m_eeSyscallMirrorAddresses.insert(kProbeBase); + m_eeSyscallMirrorAddresses.insert(kProbeBase + 8u); + + for (const auto &[syscallNumber, handler] : m_eeSyscallOverrides) + { + const int64_t offset = static_cast(static_cast(syscallNumber)) * 4; + const int64_t address = static_cast(kTableBase) + offset; + if (address < 0 || address + 4 > kMirrorLimit) + { + continue; + } + const uint32_t guestAddress = static_cast(address); + std::memcpy(rdram + guestAddress, &handler, sizeof(handler)); + m_eeSyscallMirrorAddresses.insert(guestAddress); + } +} + void PS2Runtime::HandleIntegerOverflow(R5900Context *ctx) { raiseCop0Exception(ctx, EXCEPTION_INTEGER_OVERFLOW); @@ -2360,9 +2212,8 @@ void PS2Runtime::run() ps2_stubs::resetSifState(); resetIop(); ps2_stubs::resetAudioStubState(); - ps2_stubs::resetGsSyncVCallbackState(); ps2_stubs::resetMpegStubState(); - ps2_syscalls::initializeGuestKernelState(m_memory.getRDRAM()); + initializeEeKernelState(m_memory.getRDRAM()); m_cpuContext.r[4] = _mm_setzero_si128(); m_cpuContext.r[5] = _mm_setzero_si128(); m_cpuContext.r[29] = _mm_set_epi64x(0, static_cast(PS2_RAM_SIZE - 0x10u)); @@ -2378,7 +2229,6 @@ void PS2Runtime::run() Texture2D frameTex = LoadTextureFromImage(blank); UnloadImage(blank); - g_activeThreads.store(1, std::memory_order_relaxed); std::atomic gameThreadFinished{false}; std::thread gameThread([&]() @@ -2386,7 +2236,8 @@ void PS2Runtime::run() ThreadNaming::SetCurrentThreadName("GameThread"); try { - dispatchLoop(m_memory.getRDRAM(), &m_cpuContext); + m_eeScheduler->reset(m_memory.getRDRAM(), m_cpuContext); + m_eeScheduler->run(); uint32_t pc = m_debugPc.load(std::memory_order_relaxed); RUNTIME_LOG("Game thread returned. PC=0x" << std::hex << pc << " RA=0x" << static_cast(_mm_extract_epi32(m_cpuContext.r[31], 0)) << std::dec << std::endl); @@ -2399,13 +2250,10 @@ void PS2Runtime::run() { std::cerr << "Error during program execution: unknown exception" << std::endl; } - g_activeThreads.fetch_sub(1, std::memory_order_relaxed); gameThreadFinished.store(true, std::memory_order_release); }); - ps2_syscalls::EnsureVSyncWorkerRunning(m_memory.getRDRAM(), this); - uint64_t tick = 0; - while (!isStopRequested() && g_activeThreads.load(std::memory_order_relaxed) > 0) + while (!isStopRequested() && !gameThreadFinished.load(std::memory_order_acquire)) { PS2_IF_AGRESSIVE_LOGS({ tick++; @@ -2420,7 +2268,7 @@ void PS2Runtime::run() const uint32_t dbgRa = m_debugRa.load(std::memory_order_relaxed); const uint32_t dbgSp = m_debugSp.load(std::memory_order_relaxed); const uint32_t dbgGp = m_debugGp.load(std::memory_order_relaxed); - const int activeThreads = g_activeThreads.load(std::memory_order_relaxed); + const auto eeSnapshot = m_eeScheduler->snapshot(); RUNTIME_LOG("[run:tick] tick=" << tick << " pc=0x" << std::hex << dbgPc @@ -2430,7 +2278,7 @@ void PS2Runtime::run() << " dispfb1=0x" << gs.dispfb1 << " display1=0x" << gs.display1 << std::dec - << " activeThreads=" << activeThreads + << " activeThreads=" << eeSnapshot.threads.size() << " dma=" << curDma << " gif=" << curGif << " gsw=" << curGs @@ -2473,54 +2321,9 @@ void PS2Runtime::run() } requestStop(); - - const auto joinDeadline = std::chrono::steady_clock::now() + std::chrono::seconds(2); - while (!gameThreadFinished.load(std::memory_order_acquire) && - std::chrono::steady_clock::now() < joinDeadline) - { - std::this_thread::sleep_for(std::chrono::milliseconds(1)); - } - if (gameThread.joinable()) { - if (gameThreadFinished.load(std::memory_order_acquire)) - { - gameThread.join(); - } - else - { - std::cerr << "[run] game thread did not stop within timeout; detaching" << std::endl; - gameThread.detach(); - } - } - - const auto workerDeadline = std::chrono::steady_clock::now() + std::chrono::milliseconds(1000); - while (g_activeThreads.load(std::memory_order_relaxed) > 0 && - std::chrono::steady_clock::now() < workerDeadline) - { - std::this_thread::sleep_for(std::chrono::milliseconds(1)); - } - - if (g_activeThreads.load(std::memory_order_relaxed) > 0) - { - requestStop(); - const auto finalWorkerDeadline = std::chrono::steady_clock::now() + std::chrono::milliseconds(1000); - while (g_activeThreads.load(std::memory_order_relaxed) > 0 && - std::chrono::steady_clock::now() < finalWorkerDeadline) - { - std::this_thread::sleep_for(std::chrono::milliseconds(1)); - } - } - - if (g_activeThreads.load(std::memory_order_relaxed) == 0) - { - ps2_syscalls::joinAllGuestHostThreads(); - } - else - { - std::cerr << "[run] guest host threads did not stop within timeout; detaching remaining worker threads" - << std::endl; - ps2_syscalls::detachAllGuestHostThreads(); + gameThread.join(); } if (m_debugUiInitialized && m_debugUiShutdownCallback) @@ -2531,11 +2334,5 @@ void PS2Runtime::run() UnloadTexture(frameTex); CloseWindow(); - const int remainingThreads = g_activeThreads.load(std::memory_order_relaxed); - RUNTIME_LOG("[run] exiting loop, activeThreads=" << remainingThreads); - if (remainingThreads > 0) - { - std::cerr << "[run] warning: " << remainingThreads - << " guest worker thread(s) still active during shutdown." << std::endl; - } + RUNTIME_LOG("[run] exiting loop"); } diff --git a/ps2xRuntime/src/main.cpp b/ps2xRuntime/src/main.cpp index e2c08b5d8..563bcbd74 100644 --- a/ps2xRuntime/src/main.cpp +++ b/ps2xRuntime/src/main.cpp @@ -26,38 +26,69 @@ namespace { #if defined(__ANDROID__) + int g_logcatPipeFds[2]{-1, -1}; + std::thread g_logcatThread; + + void stopLogcatRedirect() + { + std::fflush(stdout); + std::fflush(stderr); + close(STDOUT_FILENO); + close(STDERR_FILENO); + if (g_logcatPipeFds[1] >= 0) + { + close(g_logcatPipeFds[1]); + g_logcatPipeFds[1] = -1; + } + if (g_logcatThread.joinable()) + { + g_logcatThread.join(); + } + } + void redirectStdioToLogcat() { - static int pipeFds[2]; - if (pipe(pipeFds) != 0) + if (pipe(g_logcatPipeFds) != 0) { return; } setvbuf(stdout, nullptr, _IOLBF, 0); setvbuf(stderr, nullptr, _IONBF, 0); - dup2(pipeFds[1], STDOUT_FILENO); - dup2(pipeFds[1], STDERR_FILENO); - - std::thread([]() - { - FILE *reader = fdopen(pipeFds[0], "r"); - if (!reader) - { - return; - } - char line[1024]; - while (fgets(line, sizeof(line), reader)) - { - size_t len = std::strlen(line); - if (len > 0 && line[len - 1] == '\n') - { - line[len - 1] = '\0'; - } - __android_log_write(ANDROID_LOG_INFO, "ps2x", line); - } - }) - .detach(); + dup2(g_logcatPipeFds[1], STDOUT_FILENO); + dup2(g_logcatPipeFds[1], STDERR_FILENO); + + g_logcatThread = std::thread([]() + { + FILE *reader = fdopen(g_logcatPipeFds[0], "r"); + if (!reader) + { + return; + } + char line[1024]; + while (fgets(line, sizeof(line), reader)) + { + size_t len = std::strlen(line); + if (len > 0 && line[len - 1] == '\n') + { + line[len - 1] = '\0'; + } + __android_log_write(ANDROID_LOG_INFO, "ps2x", line); + } + fclose(reader); + g_logcatPipeFds[0] = -1; + }); + if (std::atexit(stopLogcatRedirect) != 0) + { + close(STDOUT_FILENO); + close(STDERR_FILENO); + close(g_logcatPipeFds[1]); + g_logcatPipeFds[1] = -1; + if (g_logcatThread.joinable()) + { + g_logcatThread.join(); + } + } } #endif diff --git a/ps2xTest/src/code_generator_tests.cpp b/ps2xTest/src/code_generator_tests.cpp index b1e8e0cbc..2a4b980cf 100644 --- a/ps2xTest/src/code_generator_tests.cpp +++ b/ps2xTest/src/code_generator_tests.cpp @@ -156,6 +156,34 @@ void register_code_generator_tests() { MiniTest::Case("CodeGenerator", [](TestCase &tc) { + tc.Run("SYSCALL publishes its continuation before entering the runtime", [](TestCase &t) { + Function func; + func.name = "syscall_resume"; + func.start = 0x9000; + func.end = 0x9008; + func.isRecompiled = true; + + Instruction syscall{}; + syscall.address = 0x9000; + syscall.opcode = OPCODE_SPECIAL; + syscall.function = SPECIAL_SYSCALL; + syscall.raw = (0x44u << 6) | SPECIAL_SYSCALL; + + Instruction after = makeNop(0x9004); + + CodeGenerator gen({}, {}); + const std::string generated = gen.generateFunction(func, {syscall, after}, false); + const size_t continuation = generated.find("ctx->pc = 0x9004u;"); + const size_t dispatch = generated.find("runtime->handleSyscall(rdram, ctx, 0x44u);"); + + t.IsTrue(continuation != std::string::npos, + "generated syscall must publish the next guest PC"); + t.IsTrue(dispatch != std::string::npos, + "generated syscall must still dispatch the encoded syscall"); + t.IsTrue(continuation < dispatch, + "the continuation PC must be visible before a syscall can transfer to the scheduler"); + }); + tc.Run("R5900 MULT writes rd when rd is non-zero", [](TestCase &t) { CodeGenerator gen({}, {}); @@ -1174,6 +1202,35 @@ void register_code_generator_tests() "JAL should pass call-site and fallthrough PCs to the runtime helper"); }); + tc.Run("JAL to a resolved syscall publishes fallthrough before the handler", [](TestCase &t) { + Function func; + func.name = "jal_syscall_resume"; + func.start = 0xA040; + func.end = 0xA048; + func.isRecompiled = true; + + Symbol target; + target.name = "GetThreadId"; + target.address = 0xB040; + target.isFunction = true; + + CodeGenerator gen({target}, {}); + gen.setRelocationCallNames({{0xA040u, "GetThreadId"}}); + const std::string generated = gen.generateFunction( + func, {makeJal(0xA040, 0xB040), makeNop(0xA044)}, false); + const size_t continuation = generated.find("ctx->pc = 0xA048u;"); + const size_t handler = generated.find("ps2_syscalls::GetThreadId(rdram, ctx, runtime);"); + + t.IsTrue(continuation != std::string::npos, + "a resolved HLE JAL should publish its fallthrough PC"); + t.IsTrue(handler != std::string::npos, + "the resolved syscall handler should still be called directly"); + t.IsTrue(continuation < handler, + "the fallthrough must be restart-safe before a blocking HLE handler runs"); + t.IsTrue(generated.find("__entryPc") == std::string::npos, + "resolved HLE calls must not retain the unchanged-PC compatibility guard"); + }); + tc.Run("trailing JAL without decoded delay slot still emits call flow", [](TestCase &t) { Function func; func.name = "jal_truncated"; @@ -1317,8 +1374,8 @@ void register_code_generator_tests() "mid-function backward loop head should be re-enterable after returning to the dispatcher"); t.IsTrue(generated.find("ctx->pc = 0x1104u;") != std::string::npos, "backward internal branch should preserve the loop target in ctx->pc"); - t.IsTrue(generated.find("if (runtime->shouldPreemptGuestExecution()) {") != std::string::npos, - "backward internal branch should consult the runtime preemption policy before re-entering the loop"); + t.IsTrue(generated.find("if (runtime->eeCheckpointDue()) {") != std::string::npos, + "backward internal branch should consult the EE event checkpoint before re-entering the loop"); t.IsTrue(generated.find("return;") != std::string::npos, "backward internal branch should return to the dispatcher when the runtime preemption policy requests it"); t.IsTrue(generated.find("runtime->cooperativeGuestYield();") == std::string::npos, diff --git a/ps2xTest/src/ps2_gs_tests.cpp b/ps2xTest/src/ps2_gs_tests.cpp index 4c3e8ec1c..51c236247 100644 --- a/ps2xTest/src/ps2_gs_tests.cpp +++ b/ps2xTest/src/ps2_gs_tests.cpp @@ -4,6 +4,7 @@ #include "ps2_stubs.h" #include "ps2_syscalls.h" #include "runtime/ps2_gs_gpu.h" +#include "runtime/ee_scheduler.h" #include "runtime/ps2_gs_memory.h" #include "runtime/ps2_gs_psmct32.h" #include "runtime/ps2_gs_psmt4.h" @@ -24,6 +25,21 @@ namespace { std::atomic g_gsSyncCallbackHits{0u}; std::atomic g_gsSyncCallbackLastTick{0u}; + std::atomic g_gsSyncFirstField{-1}; + std::atomic g_gsSyncSecondField{-1}; + std::atomic g_gsSyncCallbackSp{0u}; + std::atomic g_gsSyncCallbackGp{0u}; + std::atomic g_gsSyncCallbackPrevious{0u}; + + constexpr uint32_t kGsSyncWait0Pc = 0x0011F000u; + constexpr uint32_t kGsSyncResume0Pc = 0x0011F010u; + constexpr uint32_t kGsSyncWait1Pc = 0x0011F020u; + constexpr uint32_t kGsSyncResume1Pc = 0x0011F030u; + constexpr uint32_t kGsCallbackMainPc = 0x0011F040u; + constexpr uint32_t kGsCallbackResumePc = 0x0011F050u; + constexpr uint32_t kGsCallbackPc = 0x00120000u; + constexpr uint32_t kGsCallbackGp = 0x0036A7F0u; + constexpr uint32_t kGsCallbackCallerSp = 0x00123450u; static_assert(sizeof(GsImageMem) == 12, "GsImageMem size mismatch"); @@ -94,10 +110,54 @@ namespace (void)runtime; g_gsSyncCallbackLastTick.store(getRegU32(ctx, 4), std::memory_order_relaxed); + g_gsSyncCallbackSp.store(getRegU32(ctx, 29), std::memory_order_relaxed); + g_gsSyncCallbackGp.store(getRegU32(ctx, 28), std::memory_order_relaxed); g_gsSyncCallbackHits.fetch_add(1u, std::memory_order_relaxed); ctx->pc = 0u; } + void testGsSyncWait0(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) + { + ctx->pc = kGsSyncResume0Pc; + ps2_stubs::sceGsSyncV(rdram, ctx, runtime); + } + + void testGsSyncResume0(uint8_t *, R5900Context *ctx, PS2Runtime *) + { + g_gsSyncFirstField.store(static_cast(getRegU32(ctx, 2)), std::memory_order_release); + ctx->pc = kGsSyncWait1Pc; + } + + void testGsSyncWait1(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) + { + ctx->pc = kGsSyncResume1Pc; + ps2_stubs::sceGsSyncV(rdram, ctx, runtime); + } + + void testGsSyncResume1(uint8_t *, R5900Context *ctx, PS2Runtime *runtime) + { + g_gsSyncSecondField.store(static_cast(getRegU32(ctx, 2)), std::memory_order_release); + ctx->pc = 0u; + runtime->requestStop(); + } + + void testGsCallbackMain(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) + { + setRegU32(*ctx, 4, kGsCallbackPc); + setRegU32(*ctx, 28, kGsCallbackGp); + setRegU32(*ctx, 29, kGsCallbackCallerSp); + ctx->pc = kGsCallbackResumePc; + ps2_stubs::sceGsSyncVCallback(rdram, ctx, runtime); + g_gsSyncCallbackPrevious.store(getRegU32(ctx, 2), std::memory_order_release); + ps2_syscalls::WaitVSyncTick(rdram, ctx, runtime, -1); + } + + void testGsCallbackResume(uint8_t *, R5900Context *ctx, PS2Runtime *runtime) + { + ctx->pc = 0u; + runtime->requestStop(); + } + void writeGsImageTest(uint8_t *rdram, uint32_t addr, const GsImageMem &image) { std::memcpy(rdram + addr, &image, sizeof(image)); @@ -3343,11 +3403,8 @@ void register_ps2_gs_tests() "sceGsResetGraph should free its temporary GIF packet"); }); - tc.Run("sceGsSyncV waits on VBlank and reports interlaced field parity", [](TestCase &t) + tc.Run("sceGsSyncV resumes through the scheduler with deterministic field parity", [](TestCase &t) { - notifyRuntimeStop(); - ps2_stubs::resetGsSyncVCallbackState(); - PS2Runtime runtime; t.IsTrue(runtime.memory().initialize(), "runtime memory initialize should succeed"); std::vector rdram(PS2_RAM_SIZE, 0u); @@ -3358,66 +3415,57 @@ void register_ps2_gs_tests() setRegU32(resetCtx, 6, 2u); setRegU32(resetCtx, 7, 1u); ps2_stubs::sceGsResetGraph(rdram.data(), &resetCtx, &runtime); - - R5900Context sync0{}; - ps2_stubs::sceGsSyncV(rdram.data(), &sync0, &runtime); - t.Equals(static_cast(getRegU32Test(sync0, 2)), 0, "first interlaced sceGsSyncV should report even field"); - - R5900Context sync1{}; - ps2_stubs::sceGsSyncV(rdram.data(), &sync1, &runtime); - t.Equals(static_cast(getRegU32Test(sync1, 2)), 1, "second interlaced sceGsSyncV should report odd field"); - - R5900Context resetProgCtx{}; - setRegU32(resetProgCtx, 4, 0u); - setRegU32(resetProgCtx, 5, 0u); - setRegU32(resetProgCtx, 6, 2u); - setRegU32(resetProgCtx, 7, 1u); - ps2_stubs::sceGsResetGraph(rdram.data(), &resetProgCtx, &runtime); - - R5900Context syncProg{}; - ps2_stubs::sceGsSyncV(rdram.data(), &syncProg, &runtime); - t.Equals(static_cast(getRegU32Test(syncProg, 2)), 1, "progressive sceGsSyncV should always return one"); - - runtime.requestStop(); - notifyRuntimeStop(); - ps2_stubs::resetGsSyncVCallbackState(); + runtime.registerFunction(kGsSyncWait0Pc, testGsSyncWait0); + runtime.registerFunction(kGsSyncResume0Pc, testGsSyncResume0); + runtime.registerFunction(kGsSyncWait1Pc, testGsSyncWait1); + runtime.registerFunction(kGsSyncResume1Pc, testGsSyncResume1); + g_gsSyncFirstField.store(-1, std::memory_order_release); + g_gsSyncSecondField.store(-1, std::memory_order_release); + + R5900Context mainContext{}; + mainContext.pc = kGsSyncWait0Pc; + runtime.eeScheduler().reset(rdram.data(), mainContext); + runtime.eeScheduler().run(); + + t.Equals(g_gsSyncFirstField.load(std::memory_order_acquire), 0, + "first interlaced VBlank should report even field"); + t.Equals(g_gsSyncSecondField.load(std::memory_order_acquire), 1, + "second interlaced VBlank should report odd field"); }); - tc.Run("sceGsSyncVCallback uses the shared VBlank worker", [](TestCase &t) + tc.Run("sceGsSyncVCallback runs as a scheduler invocation on its callback stack", [](TestCase &t) { - notifyRuntimeStop(); - ps2_stubs::resetGsSyncVCallbackState(); g_gsSyncCallbackHits.store(0u, std::memory_order_relaxed); g_gsSyncCallbackLastTick.store(0u, std::memory_order_relaxed); + g_gsSyncCallbackSp.store(0u, std::memory_order_relaxed); + g_gsSyncCallbackGp.store(0u, std::memory_order_relaxed); + g_gsSyncCallbackPrevious.store(0xFFFFFFFFu, std::memory_order_relaxed); PS2Runtime runtime; t.IsTrue(runtime.memory().initialize(), "runtime memory initialize should succeed"); std::vector rdram(PS2_RAM_SIZE, 0u); - - constexpr uint32_t kCallbackAddr = 0x120000u; - runtime.registerFunction(kCallbackAddr, testGsSyncVCallback); - - R5900Context callbackCtx{}; - setRegU32(callbackCtx, 4, kCallbackAddr); - ps2_stubs::sceGsSyncVCallback(rdram.data(), &callbackCtx, &runtime); - t.Equals(getRegU32Test(callbackCtx, 2), 0u, "first sceGsSyncVCallback registration should return no previous callback"); - - const bool callbackFired = waitUntil([]() { - return g_gsSyncCallbackHits.load(std::memory_order_acquire) > 0u; - }, std::chrono::milliseconds(80)); - - t.IsTrue(callbackFired, "registered GS VSync callback should fire from the VBlank worker"); + runtime.configureGuestHeap(0x01F00000u, 0x01F00000u); + runtime.registerFunction(kGsCallbackMainPc, testGsCallbackMain); + runtime.registerFunction(kGsCallbackResumePc, testGsCallbackResume); + runtime.registerFunction(kGsCallbackPc, testGsSyncVCallback); + + R5900Context mainContext{}; + mainContext.pc = kGsCallbackMainPc; + runtime.eeScheduler().reset(rdram.data(), mainContext); + runtime.eeScheduler().run(); + + t.Equals(g_gsSyncCallbackPrevious.load(std::memory_order_acquire), 0u, + "first callback registration should return no previous callback"); + t.Equals(g_gsSyncCallbackHits.load(std::memory_order_acquire), 1u, + "the callback should execute once at the next VBlank boundary"); t.IsTrue(g_gsSyncCallbackLastTick.load(std::memory_order_acquire) > 0u, "VSync callback should receive a positive tick value"); - - R5900Context clearCtx{}; - setRegU32(clearCtx, 4, 0u); - ps2_stubs::sceGsSyncVCallback(rdram.data(), &clearCtx, &runtime); - t.Equals(getRegU32Test(clearCtx, 2), kCallbackAddr, "clearing sceGsSyncVCallback should return the previous callback"); - - runtime.requestStop(); - notifyRuntimeStop(); - ps2_stubs::resetGsSyncVCallbackState(); + t.Equals(g_gsSyncCallbackGp.load(std::memory_order_acquire), kGsCallbackGp, + "callback invocation should preserve the registered GP"); + t.IsTrue(g_gsSyncCallbackSp.load(std::memory_order_acquire) >= 0x01F00000u, + "callback invocation should use the reserved async stack pool"); + t.IsTrue(g_gsSyncCallbackSp.load(std::memory_order_acquire) != kGsCallbackCallerSp, + "callback invocation must not reuse the caller stack"); }); tc.Run("GS T4HL/T4HH shared-plane upload preserves both index planes via RMW", [](TestCase &t) diff --git a/ps2xTest/src/ps2_runtime_expansion_tests.cpp b/ps2xTest/src/ps2_runtime_expansion_tests.cpp index c31b4d425..bc8d8bf86 100644 --- a/ps2xTest/src/ps2_runtime_expansion_tests.cpp +++ b/ps2xTest/src/ps2_runtime_expansion_tests.cpp @@ -8,6 +8,7 @@ #include "ps2_syscalls.h" #include "ps2_stubs.h" #include "runtime/ps2_gs_gpu.h" +#include "runtime/ee_scheduler.h" #include "runtime/ps2_gs_psmct32.h" #include "ps2_runtime_macros.h" #include "Stubs/MPEG.h" @@ -17,12 +18,10 @@ #include "Stubs/VU.h" #include -#include #include #include #include #include -#include #include using namespace ps2recomp; @@ -99,106 +98,11 @@ namespace return generated.find(needle) != std::string::npos; } - template - bool waitUntil(Predicate pred, std::chrono::milliseconds timeout) - { - const auto deadline = std::chrono::steady_clock::now() + timeout; - while (std::chrono::steady_clock::now() < deadline) - { - if (pred()) - { - return true; - } - std::this_thread::sleep_for(std::chrono::milliseconds(1)); - } - return pred(); - } - uint32_t frameOffsetBytes(uint32_t x, uint32_t y, uint32_t fbw) { return GSPSMCT32::addrPSMCT32(0u, (fbw != 0u) ? fbw : 1u, x, y); } - void testRuntimeWorkerLoop(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) - { - if (!ctx || !runtime) - { - return; - } - - // Keep touching guest memory so teardown races are easier to catch. - (void)Ps2FastRead64(rdram, static_cast(0x01FFFFF8u + (ctx->insn_count & 0x7u))); - ++ctx->insn_count; - - if (runtime->isStopRequested()) - { - ctx->pc = 0u; - return; - } - - std::this_thread::sleep_for(std::chrono::milliseconds(1)); - } - - std::atomic gSerializedGuestActive{0}; - std::atomic gSerializedGuestMaxActive{0}; - std::atomic gPreemptionPolicyEntryCount{0}; - std::atomic gPreemptionPolicyAllowFirstProbe{false}; - std::atomic gPreemptionPolicyPeerRan{false}; - - void testSerializedGuestStep(uint8_t *, R5900Context *ctx, PS2Runtime *) - { - const int32_t active = gSerializedGuestActive.fetch_add(1, std::memory_order_acq_rel) + 1; - int32_t observedMax = gSerializedGuestMaxActive.load(std::memory_order_relaxed); - while (observedMax < active && - !gSerializedGuestMaxActive.compare_exchange_weak( - observedMax, - active, - std::memory_order_release, - std::memory_order_relaxed)) - { - } - - std::this_thread::sleep_for(std::chrono::milliseconds(25)); - gSerializedGuestActive.fetch_sub(1, std::memory_order_acq_rel); - if (ctx) - { - ctx->pc = 0u; - } - } - - void testPreemptionPolicyStep(uint8_t *, R5900Context *ctx, PS2Runtime *runtime) - { - if (!ctx || !runtime) - { - return; - } - - const int32_t entryIndex = gPreemptionPolicyEntryCount.fetch_add(1, std::memory_order_acq_rel) + 1; - if (entryIndex == 1) - { - while (!gPreemptionPolicyAllowFirstProbe.load(std::memory_order_acquire)) - { - std::this_thread::yield(); - } - - bool shouldPreempt = false; - for (int attempt = 0; attempt < 256 && - !shouldPreempt; - ++attempt) - { - shouldPreempt = runtime->shouldPreemptGuestExecution(); - } - setRegU32(*ctx, 2, shouldPreempt ? 1u : 0u); - } - else - { - gPreemptionPolicyPeerRan.store(true, std::memory_order_release); - setRegU32(*ctx, 2, 2u); - } - - ctx->pc = 0u; - } - void testResumeOwnerFallbackHandler(uint8_t *, R5900Context *ctx, PS2Runtime *) { if (ctx) @@ -236,69 +140,118 @@ namespace } } - constexpr uint32_t kAsyncCounterAddr = 0x2400u; - - void testWaitForAsyncCounter(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) + std::atomic gMpegStreamCallbackCount{0u}; + std::atomic gMpegStreamCallbackMpeg{0u}; + std::atomic gMpegStreamCallbackType{0u}; + std::atomic gMpegStreamCallbackDataAddr{0u}; + std::atomic gMpegStreamCallbackLen{0u}; + std::atomic gMpegStreamCallbackUserData{0u}; + constexpr uint32_t kMpegCallbackStopPc = 0x00124FF0u; + std::atomic gMpegWaitResult{-999}; + std::atomic gMpegWaitStage{0u}; + std::atomic gMpegNoDuplicateStage{0u}; + std::atomic gMpegNoDuplicateProducerStage{0u}; + + constexpr uint32_t kMpegWaitMainPc = 0x00125000u; + constexpr uint32_t kMpegWaitResumePc = 0x00125010u; + constexpr uint32_t kMpegWaitProducerPc = 0x00125020u; + constexpr uint32_t kMpegWaitHandle = 0x00123000u; + constexpr uint32_t kMpegWaitImage = 0x00130000u; + constexpr uint32_t kMpegNoDuplicateMainPc = 0x00125030u; + constexpr uint32_t kMpegNoDuplicateResumePc = 0x00125040u; + constexpr uint32_t kMpegNoDuplicateProducerPc = 0x00125050u; + constexpr uint32_t kMpegNoDuplicateHandle = 0x00124000u; + constexpr uint32_t kMpegNoDuplicateImage = 0x00131000u; + constexpr uint32_t kIpuInitMainPc = 0x00125100u; + constexpr uint32_t kIpuInitResumePc = 0x00125104u; + constexpr uint32_t kIpuSetD4Pc = 0x00126428u; + std::atomic gIpuSetD4Hits{0u}; + std::atomic gIpuSetD4Argument{0u}; + std::atomic gIpuInitResult{-999}; + + void testIpuSetD4(uint8_t *, R5900Context *ctx, PS2Runtime *) { - if (!rdram || !ctx) - { - return; - } + gIpuSetD4Hits.fetch_add(1u, std::memory_order_acq_rel); + gIpuSetD4Argument.store(::getRegU32(ctx, 4), std::memory_order_release); + ctx->pc = 0u; + } - uint32_t counter = 0u; - do - { - std::memcpy(&counter, rdram + kAsyncCounterAddr, sizeof(counter)); - if (counter == 0u) - { - if (runtime != nullptr) - { - runtime->yieldGuestExecutionAfterWake(); - } - std::this_thread::sleep_for(std::chrono::milliseconds(1)); - } - } while (counter == 0u); + void testIpuInitMain(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) + { + ctx->pc = kIpuInitResumePc; + ps2_stubs::sceIpuInit(rdram, ctx, runtime); + } + void testIpuInitResume(uint8_t *, R5900Context *ctx, PS2Runtime *runtime) + { + gIpuInitResult.store(getRegS32(*ctx, 2), std::memory_order_release); ctx->pc = 0u; + runtime->requestStop(); } - void testSignalAsyncCounter(uint8_t *rdram, R5900Context *ctx, PS2Runtime *) + void testMpegWaitMain(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { - if (rdram) - { - const uint32_t counter = 1u; - std::memcpy(rdram + kAsyncCounterAddr, &counter, sizeof(counter)); - } + gMpegWaitStage.store(1u, std::memory_order_release); + setRegU32(*ctx, 4, kMpegWaitHandle); + setRegU32(*ctx, 5, kMpegWaitImage); + ctx->pc = kMpegWaitResumePc; + ps2_stubs::sceMpegGetPicture(rdram, ctx, runtime); + } - if (ctx) - { - ctx->pc = 0u; - } + void testMpegWaitResume(uint8_t *, R5900Context *ctx, PS2Runtime *runtime) + { + gMpegWaitStage.store(3u, std::memory_order_release); + gMpegWaitResult.store(static_cast(::getRegU32(ctx, 2)), std::memory_order_release); + ctx->pc = 0u; + runtime->requestStop(); } - std::atomic gAsyncCallbackObservedSp{0u}; - std::atomic gAsyncCallbackObservedGp{0u}; + void testStopAfterMpegCallback(uint8_t *, R5900Context *ctx, PS2Runtime *runtime) + { + ctx->pc = 0u; + runtime->requestStop(); + } - void testRecordAsyncCallbackStack(uint8_t *, R5900Context *ctx, PS2Runtime *) + void testMpegWaitProducer(uint8_t *, R5900Context *ctx, PS2Runtime *runtime) { - if (!ctx) - { - return; - } + gMpegWaitStage.store(2u, std::memory_order_release); + ps2_stubs::notifyMpegCdStreamEof(runtime); + ctx->pc = 0u; + } + + void testMpegNoDuplicateMain(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) + { + setRegU32(*ctx, 4, kMpegNoDuplicateHandle); + setRegU32(*ctx, 5, kMpegNoDuplicateImage); + ps2_stubs::sceMpegGetPicture(rdram, ctx, runtime); + + gMpegNoDuplicateStage.store(1u, std::memory_order_release); + ctx->pc = kMpegNoDuplicateResumePc; + ps2_stubs::sceMpegGetPicture(rdram, ctx, runtime); - gAsyncCallbackObservedSp.store(::getRegU32(ctx, 29), std::memory_order_release); - gAsyncCallbackObservedGp.store(::getRegU32(ctx, 28), std::memory_order_release); + gMpegNoDuplicateStage.store(4u, std::memory_order_release); ctx->pc = 0u; + runtime->requestStop(); } - std::atomic gMpegStreamCallbackCount{0u}; - std::atomic gMpegStreamCallbackMpeg{0u}; - std::atomic gMpegStreamCallbackType{0u}; - std::atomic gMpegStreamCallbackDataAddr{0u}; - std::atomic gMpegStreamCallbackLen{0u}; - std::atomic gMpegStreamCallbackUserData{0u}; + void testMpegNoDuplicateResume(uint8_t *, R5900Context *ctx, PS2Runtime *runtime) + { + gMpegNoDuplicateStage.store(3u, std::memory_order_release); + ctx->pc = 0u; + runtime->requestStop(); + } + + void testMpegNoDuplicateProducer(uint8_t *, R5900Context *ctx, PS2Runtime *runtime) + { + gMpegNoDuplicateProducerStage.store( + gMpegNoDuplicateStage.load(std::memory_order_acquire), + std::memory_order_release); + gMpegNoDuplicateStage.store(2u, std::memory_order_release); + ps2_stubs::notifyMpegCdStreamEof(runtime); + ctx->pc = 0u; + } - void testRecordMpegStreamCallback(uint8_t *rdram, R5900Context *ctx, PS2Runtime *) + void testRecordMpegStreamCallback(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { if (!rdram || !ctx) { @@ -320,6 +273,7 @@ namespace gMpegStreamCallbackUserData.store(::getRegU32(ctx, 6), std::memory_order_release); gMpegStreamCallbackCount.fetch_add(1u, std::memory_order_acq_rel); ctx->pc = 0u; + runtime->requestStop(); } } @@ -358,277 +312,6 @@ void register_ps2_runtime_expansion_tests() } }); - tc.Run("guest execution is serialized per runtime", [](TestCase &t) - { - PS2Runtime runtime; - std::vector rdram(PS2_RAM_SIZE, 0u); - gSerializedGuestActive.store(0, std::memory_order_release); - gSerializedGuestMaxActive.store(0, std::memory_order_release); - - constexpr uint32_t kEntries[] = { - 0x120000u, - 0x130000u, - 0x140000u, - 0x150000u, - }; - constexpr size_t kEntryCount = sizeof(kEntries) / sizeof(kEntries[0]); - R5900Context contexts[kEntryCount]{}; - std::vector workers; - workers.reserve(kEntryCount); - - for (size_t i = 0; i < kEntryCount; ++i) - { - runtime.registerFunction(kEntries[i], &testSerializedGuestStep); - contexts[i].pc = kEntries[i]; - } - - for (size_t i = 0; i < kEntryCount; ++i) - { - workers.emplace_back([&, i]() - { - runtime.dispatchLoop(rdram.data(), &contexts[i]); - }); - } - - for (std::thread &worker : workers) - { - if (worker.joinable()) - { - worker.join(); - } - } - - t.Equals(gSerializedGuestActive.load(std::memory_order_acquire), 0, - "serialized guest dispatch should leave no active workers"); - t.Equals(gSerializedGuestMaxActive.load(std::memory_order_acquire), 1, - "dispatchLoop should not execute guest code concurrently on one runtime"); - }); - - tc.Run("wake handoff lets a contending guest thread acquire before returning", [](TestCase &t) - { - PS2Runtime runtime; - std::atomic peerRan{false}; - std::thread peer; - bool peerWaiting = false; - bool peerRanWhileMainHeld = false; - bool peerRanAfterHandoff = false; - - { - PS2Runtime::GuestExecutionScope mainScope(&runtime); - peer = std::thread([&]() - { - PS2Runtime::GuestExecutionScope peerScope(&runtime); - peerRan.store(true, std::memory_order_release); - }); - - peerWaiting = waitUntil([&]() - { - return runtime.guestExecutionWaiterCountForTesting() > 0u; - }, std::chrono::milliseconds(100)); - - peerRanWhileMainHeld = peerRan.load(std::memory_order_acquire); - runtime.yieldGuestExecutionAfterWake(); - peerRanAfterHandoff = peerRan.load(std::memory_order_acquire); - } - - if (peer.joinable()) - { - peer.join(); - } - - t.IsTrue(peerWaiting, "peer guest thread should contend while the waker owns guest execution"); - t.IsFalse(peerRanWhileMainHeld, "peer guest thread should not run before the waker yields execution"); - t.IsTrue(peerRanAfterHandoff, "wake handoff should let the peer acquire guest execution before returning"); - }); - - tc.Run("recursive guest execution acquisition does not advance the handoff epoch", [](TestCase &t) - { - PS2Runtime runtime; - const uint64_t initial = runtime.guestExecutionHandoffEpochSnapshot(); - - PS2Runtime::GuestExecutionScope outer(&runtime); - const uint64_t afterOuter = runtime.guestExecutionHandoffEpochSnapshot(); - t.Equals(afterOuter, initial + 1u, "outer acquisition should advance the epoch exactly once"); - - { - PS2Runtime::GuestExecutionScope inner(&runtime); - t.Equals(runtime.guestExecutionHandoffEpochSnapshot(), afterOuter, - "recursive acquisition must not advance the epoch"); - - PS2Runtime::GuestExecutionScope innermost(&runtime); - t.Equals(runtime.guestExecutionHandoffEpochSnapshot(), afterOuter, - "deeper recursive acquisitions must not advance the epoch either"); - } - - t.Equals(runtime.guestExecutionHandoffEpochSnapshot(), afterOuter, - "releasing recursive acquisitions must not advance the epoch"); - }); - - tc.Run("reacquiring a depth-4 release advances the handoff epoch exactly once", [](TestCase &t) - { - PS2Runtime runtime; - - PS2Runtime::GuestExecutionScope s1(&runtime); - PS2Runtime::GuestExecutionScope s2(&runtime); - PS2Runtime::GuestExecutionScope s3(&runtime); - PS2Runtime::GuestExecutionScope s4(&runtime); - - const uint64_t before = runtime.guestExecutionHandoffEpochSnapshot(); - { - PS2Runtime::GuestExecutionReleaseScope release(&runtime); - t.Equals(runtime.guestExecutionHandoffEpochSnapshot(), before, - "releasing guest execution must not advance the epoch"); - } - - t.Equals(runtime.guestExecutionHandoffEpochSnapshot(), before + 1u, - "reacquiring a depth-4 release should advance the epoch exactly once"); - }); - - tc.Run("handoff completed before the wait does not count as a timeout", [](TestCase &t) - { - PS2Runtime runtime; - const uint64_t timeoutsBefore = runtime.guestExecutionHandoffTimeouts(); - - std::atomic holderAcquired{false}; - std::atomic releaseHolder{false}; - uint64_t baseline = 0u; - std::thread holder; - - { - PS2Runtime::GuestExecutionScope mainScope(&runtime); - - holder = std::thread([&]() - { - PS2Runtime::GuestExecutionScope scope(&runtime); - holderAcquired.store(true, std::memory_order_release); - while (!releaseHolder.load(std::memory_order_acquire)) - { - std::this_thread::sleep_for(std::chrono::microseconds(100)); - } - }); - - const bool holderContending = waitUntil([&]() - { - return runtime.guestExecutionWaiterCountForTesting() > 0u; - }, std::chrono::milliseconds(250)); - t.IsTrue(holderContending, "holder thread should be queued before the release"); - - // Token captured BEFORE releasing guest execution, like the dispatchers do - baseline = runtime.guestExecutionHandoffEpochSnapshot(); - } - - const bool acquired = waitUntil([&]() - { - return holderAcquired.load(std::memory_order_acquire); - }, std::chrono::milliseconds(250)); - t.IsTrue(acquired, "holder should acquire guest execution after the release"); - - // Second waiter keeps waiters > 0 so the wait below cannot take the - // no-waiters fast path: it must recognize the epoch advance instead. - std::thread secondWaiter([&]() - { - PS2Runtime::GuestExecutionScope scope(&runtime); - }); - const bool secondContending = waitUntil([&]() - { - return runtime.guestExecutionWaiterCountForTesting() > 0u; - }, std::chrono::milliseconds(250)); - t.IsTrue(secondContending, "second waiter should be queued while the holder owns guest execution"); - - runtime.waitForGuestExecutionHandoff(baseline); - - t.Equals(runtime.guestExecutionHandoffTimeouts(), timeoutsBefore, - "a handoff that completed before the wait must not count as a timeout"); - - releaseHolder.store(true, std::memory_order_release); - if (holder.joinable()) - { - holder.join(); - } - if (secondWaiter.joinable()) - { - secondWaiter.join(); - } - }); - - tc.Run("nested DeferredGuestYieldScope delivers pending only to the outermost scope", [](TestCase &t) - { - PS2Runtime runtime; - bool outerPending = false; - bool innerPending = false; - - { - PS2Runtime::DeferredGuestYieldScope outer(outerPending); - { - PS2Runtime::DeferredGuestYieldScope inner(innerPending); - runtime.yieldGuestExecutionAfterWake(); // must defer instead of yielding - } - t.IsFalse(innerPending, "inner scope must not consume the deferred yield"); - t.IsFalse(outerPending, "pending must only be delivered when the outermost scope closes"); - } - - t.IsTrue(outerPending, "outermost scope should deliver the deferred yield"); - t.IsFalse(innerPending, "inner scope must stay untouched"); - }); - - tc.Run("guest preemption policy requests a dispatcher handoff when another guest thread contends", [](TestCase &t) - { - PS2Runtime runtime; - std::vector rdram(PS2_RAM_SIZE, 0u); - constexpr uint32_t kFirstEntry = 0x190000u; - constexpr uint32_t kSecondEntry = 0x1A0000u; - - gPreemptionPolicyEntryCount.store(0, std::memory_order_release); - gPreemptionPolicyAllowFirstProbe.store(false, std::memory_order_release); - gPreemptionPolicyPeerRan.store(false, std::memory_order_release); - - runtime.registerFunction(kFirstEntry, &testPreemptionPolicyStep); - runtime.registerFunction(kSecondEntry, &testPreemptionPolicyStep); - - R5900Context firstCtx{}; - R5900Context secondCtx{}; - firstCtx.pc = kFirstEntry; - secondCtx.pc = kSecondEntry; - - std::thread firstWorker([&]() - { - runtime.dispatchLoop(rdram.data(), &firstCtx); - }); - - const bool firstEntered = waitUntil([&]() - { - return gPreemptionPolicyEntryCount.load(std::memory_order_acquire) >= 1; - }, std::chrono::milliseconds(100)); - - std::thread secondWorker([&]() - { - runtime.dispatchLoop(rdram.data(), &secondCtx); - }); - - const bool secondContending = waitUntil([&]() - { - return runtime.guestExecutionWaiterCountForTesting() > 0u; - }, std::chrono::milliseconds(100)); - - gPreemptionPolicyAllowFirstProbe.store(true, std::memory_order_release); - - if (firstWorker.joinable()) - { - firstWorker.join(); - } - if (secondWorker.joinable()) - { - secondWorker.join(); - } - - t.IsTrue(firstEntered, "first guest worker should enter before probing for preemption"); - t.IsTrue(secondContending, "second guest worker should contend for guest execution before the first returns"); - t.IsTrue(gPreemptionPolicyPeerRan.load(std::memory_order_acquire), - "second guest worker should run after the first returns to the dispatcher"); - t.Equals(getRegU32(&firstCtx, 2), 1u, - "first guest worker should observe that the runtime requested preemption under contention"); - }); - tc.Run("lookupFunction rejects internal resume PCs without exact registration", [](TestCase &t) { PS2Runtime runtime; @@ -739,114 +422,6 @@ void register_ps2_runtime_expansion_tests() "missing target should remain visible in ctx->pc for diagnostics"); }); - tc.Run("vblank intc handlers can preempt serialized guest execution", [](TestCase &t) - { - notifyRuntimeStop(); - - PS2Runtime runtime; - std::vector rdram(PS2_RAM_SIZE, 0u); - constexpr uint32_t kBusyEntry = 0x160000u; - constexpr uint32_t kIntcHandlerEntry = 0x170000u; - - runtime.registerFunction(kBusyEntry, &testWaitForAsyncCounter); - runtime.registerFunction(kIntcHandlerEntry, &testSignalAsyncCounter); - - R5900Context addCtx{}; - setRegU32(addCtx, 4, 2u); - setRegU32(addCtx, 5, kIntcHandlerEntry); - setRegU32(addCtx, 6, 0u); - setRegU32(addCtx, 7, 0u); - AddIntcHandler(rdram.data(), &addCtx, &runtime); - t.IsTrue(getRegS32(addCtx, 2) > 0, "AddIntcHandler should register a VBlank handler"); - - R5900Context busyCtx{}; - busyCtx.pc = kBusyEntry; - std::atomic workerDone{false}; - std::atomic workerThrew{false}; - - std::thread worker([&]() - { - try - { - runtime.dispatchLoop(rdram.data(), &busyCtx); - } - catch (...) - { - workerThrew.store(true, std::memory_order_release); - } - workerDone.store(true, std::memory_order_release); - }); - - ps2_syscalls::EnsureVSyncWorkerRunning(rdram.data(), &runtime); - - const bool finished = waitUntil([&]() - { - return workerDone.load(std::memory_order_acquire); - }, std::chrono::milliseconds(250)); - - if (!finished) - { - const uint32_t counter = 1u; - std::memcpy(rdram.data() + kAsyncCounterAddr, &counter, sizeof(counter)); - } - - if (worker.joinable()) - { - worker.join(); - } - - runtime.requestStop(); - notifyRuntimeStop(); - - uint32_t counter = 0u; - std::memcpy(&counter, rdram.data() + kAsyncCounterAddr, sizeof(counter)); - - t.IsFalse(workerThrew.load(std::memory_order_acquire), - "busy dispatch worker should not throw while VBlank handlers fire"); - t.IsTrue(finished, - "VBlank interrupt handlers should run even while a guest thread is spinning"); - t.Equals(counter, 1u, "VBlank handler should publish the awaited counter value"); - }); - - tc.Run("GS async callbacks keep a dedicated stack when guest heap is exhausted", [](TestCase &t) - { - notifyRuntimeStop(); - - PS2Runtime runtime; - std::vector rdram(PS2_RAM_SIZE, 0u); - constexpr uint32_t kCallbackEntry = 0x180000u; - constexpr uint32_t kCallerGp = 0x0036A7F0u; - constexpr uint32_t kCallerSp = 0x00123450u; - constexpr uint32_t kAsyncStackFloor = 0x01F00000u; - - runtime.configureGuestHeap(kAsyncStackFloor, kAsyncStackFloor); - runtime.registerFunction(kCallbackEntry, &testRecordAsyncCallbackStack); - ps2_stubs::resetGsSyncVCallbackState(); - gAsyncCallbackObservedSp.store(0u, std::memory_order_release); - gAsyncCallbackObservedGp.store(0u, std::memory_order_release); - - R5900Context registerCtx{}; - registerCtx.pc = 0x00101900u; - setRegU32(registerCtx, 4, kCallbackEntry); - setRegU32(registerCtx, 28, kCallerGp); - setRegU32(registerCtx, 29, kCallerSp); - ps2_stubs::sceGsSyncVCallback(rdram.data(), ®isterCtx, &runtime); - - ps2_stubs::dispatchGsSyncVCallback(rdram.data(), &runtime, 1u); - - const uint32_t observedSp = gAsyncCallbackObservedSp.load(std::memory_order_acquire); - const uint32_t observedGp = gAsyncCallbackObservedGp.load(std::memory_order_acquire); - - t.IsTrue(observedSp != 0u, "callback should execute"); - t.Equals(observedGp, kCallerGp, "callback should preserve the registered GP"); - t.IsTrue(observedSp != kCallerSp, "callback should not reuse the registering thread stack"); - t.IsTrue(observedSp >= kAsyncStackFloor, - "callback should switch to the reserved async stack pool"); - - runtime.requestStop(); - notifyRuntimeStop(); - }); - tc.Run("MPEG init and callback stubs return success instead of TODO errors", [](TestCase &t) { std::vector rdram(PS2_RAM_SIZE, 0u); @@ -902,6 +477,13 @@ void register_ps2_runtime_expansion_tests() constexpr uint32_t kAudioPacketAddr = 0x00129000u; runtime.registerFunction(kCallbackEntry, &testRecordMpegStreamCallback); + runtime.registerFunction(kMpegCallbackStopPc, &testStopAfterMpegCallback); + auto prepareCallbackDispatch = [&]() + { + R5900Context idleContext{}; + idleContext.pc = kMpegCallbackStopPc; + runtime.eeScheduler().reset(rdram.data(), idleContext); + }; auto registerGenericCallback = [&](uint32_t callbackType, uint32_t userData) { @@ -947,6 +529,7 @@ void register_ps2_runtime_expansion_tests() const uint32_t videoPacketSize = writePesPacket(kVideoPacketAddr, 0xE0u, videoPayload); gMpegStreamCallbackCount.store(0u, std::memory_order_release); + prepareCallbackDispatch(); R5900Context videoDemuxCtx{}; setRegU32(videoDemuxCtx, 4, kMpegAddr); setRegU32(videoDemuxCtx, 5, kVideoPacketAddr); @@ -954,6 +537,7 @@ void register_ps2_runtime_expansion_tests() setRegU32(videoDemuxCtx, 7, kVideoPacketAddr); setRegU32(videoDemuxCtx, 8, videoPacketSize); ps2_stubs::sceMpegDemuxPssRing(rdram.data(), &videoDemuxCtx, &runtime); + runtime.eeScheduler().run(); t.Equals(getRegS32(videoDemuxCtx, 2), static_cast(videoPacketSize), "sceMpegDemuxPssRing should consume the video PES packet"); @@ -975,6 +559,7 @@ void register_ps2_runtime_expansion_tests() const uint32_t audioPacketSize = writePesPacket(kAudioPacketAddr, 0xBDu, audioPayload); gMpegStreamCallbackCount.store(0u, std::memory_order_release); + prepareCallbackDispatch(); R5900Context audioDemuxCtx{}; setRegU32(audioDemuxCtx, 4, kMpegAddr); setRegU32(audioDemuxCtx, 5, kAudioPacketAddr); @@ -982,6 +567,7 @@ void register_ps2_runtime_expansion_tests() setRegU32(audioDemuxCtx, 7, kAudioPacketAddr); setRegU32(audioDemuxCtx, 8, audioPacketSize); ps2_stubs::sceMpegDemuxPssRing(rdram.data(), &audioDemuxCtx, &runtime); + runtime.eeScheduler().run(); t.Equals(getRegS32(audioDemuxCtx, 2), static_cast(audioPacketSize), "sceMpegDemuxPssRing should consume the audio PES packet"); @@ -1034,6 +620,7 @@ void register_ps2_runtime_expansion_tests() ps2_stubs::notifyMpegCdStreamStart(); gMpegStreamCallbackCount.store(0u, std::memory_order_release); + prepareCallbackDispatch(); R5900Context afterNewStreamDemuxCtx{}; setRegU32(afterNewStreamDemuxCtx, 4, kMpegAddr); setRegU32(afterNewStreamDemuxCtx, 5, kVideoPacketAddr); @@ -1041,6 +628,7 @@ void register_ps2_runtime_expansion_tests() setRegU32(afterNewStreamDemuxCtx, 7, kVideoPacketAddr); setRegU32(afterNewStreamDemuxCtx, 8, videoPacketSize); ps2_stubs::sceMpegDemuxPssRing(rdram.data(), &afterNewStreamDemuxCtx, &runtime); + runtime.eeScheduler().run(); t.Equals(getRegS32(afterNewStreamDemuxCtx, 2), static_cast(videoPacketSize), "new CD stream demux should reopen an ended MPEG handle"); @@ -1057,6 +645,7 @@ void register_ps2_runtime_expansion_tests() "sceMpegCreate should reopen the MPEG handle after an ended reset"); gMpegStreamCallbackCount.store(0u, std::memory_order_release); + prepareCallbackDispatch(); R5900Context afterCreateDemuxCtx{}; setRegU32(afterCreateDemuxCtx, 4, kMpegAddr); setRegU32(afterCreateDemuxCtx, 5, kVideoPacketAddr); @@ -1064,6 +653,7 @@ void register_ps2_runtime_expansion_tests() setRegU32(afterCreateDemuxCtx, 7, kVideoPacketAddr); setRegU32(afterCreateDemuxCtx, 8, videoPacketSize); ps2_stubs::sceMpegDemuxPssRing(rdram.data(), &afterCreateDemuxCtx, &runtime); + runtime.eeScheduler().run(); t.Equals(gMpegStreamCallbackCount.load(std::memory_order_acquire), 1u, "new MPEG create should allow callbacks for the next stream"); @@ -1071,312 +661,69 @@ void register_ps2_runtime_expansion_tests() runtime.requestStop(); }); - tc.Run("MPEG playback stays active during a temporary demux pause before CD EOF", [](TestCase &t) - { - std::vector rdram(PS2_RAM_SIZE, 0u); - ps2_stubs::resetMpegStubState(); - - constexpr uint32_t kMpegAddr = 0x00123000u; - constexpr uint32_t kPacketAddr = 0x00128000u; - constexpr uint32_t kImageAddr = 0x00130000u; - const std::vector es = { - 0x00u, 0x00u, 0x01u, 0xB3u, 0x01u, 0x00u, 0x10u, 0x12u, 0xFFu, 0xFFu, 0xE0u, 0x18u, - 0x00u, 0x00u, 0x01u, 0xB5u, 0x14u, 0x8Au, 0x00u, 0x01u, 0x00u, 0x17u, 0x00u, 0x00u, - 0x01u, 0xB8u, 0x00u, 0x08u, 0x00u, 0x40u, 0x00u, 0x00u, 0x01u, 0x00u, 0x00u, 0x0Fu, - 0xFFu, 0xF8u, 0x00u, 0x00u, 0x01u, 0xB5u, 0x8Fu, 0xFFu, 0xF3u, 0x41u, 0x80u, 0x00u, - 0x00u, 0x01u, 0x01u, 0x13u, 0xF8u, 0x7Du, 0x29u, 0x48u, 0x88u, 0x00u, 0x00u, 0x01u, - 0xB3u, 0x01u, 0x00u, 0x10u, 0x12u, 0xFFu, 0xFFu, 0xE0u, 0x18u, 0x00u, 0x00u, 0x01u, - 0xB5u, 0x14u, 0x8Au, 0x00u, 0x01u, 0x00u, 0x17u, 0x00u, 0x00u, 0x01u, 0xB8u, 0x00u, - 0x08u, 0x00u, 0xC0u, 0x00u, 0x00u, 0x01u, 0x00u, 0x00u, 0x0Fu, 0xFFu, 0xF8u, 0x00u, - 0x00u, 0x01u, 0xB5u, 0x8Fu, 0xFFu, 0xF3u, 0x41u, 0x80u, 0x00u, 0x00u, 0x01u, 0x01u, - 0x13u, 0xF8u, 0x7Du, 0x29u, 0x48u, 0x88u, 0x00u, 0x00u, 0x01u, 0xB3u, 0x01u, 0x00u, - 0x10u, 0x12u, 0xFFu, 0xFFu, 0xE0u, 0x18u, 0x00u, 0x00u, 0x01u, 0xB5u, 0x14u, 0x8Au, - 0x00u, 0x01u, 0x00u, 0x17u, 0x00u, 0x00u, 0x01u, 0xB8u, 0x00u, 0x08u, 0x01u, 0x40u, - 0x00u, 0x00u, 0x01u, 0x00u, 0x00u, 0x0Fu, 0xFFu, 0xF8u, 0x00u, 0x00u, 0x01u, 0xB5u, - 0x8Fu, 0xFFu, 0xF3u, 0x41u, 0x80u, 0x00u, 0x00u, 0x01u, 0x01u, 0x13u, 0xF8u, 0x7Du, - 0x29u, 0x48u, 0x88u}; - - std::vector packet = { - 0x00u, 0x00u, 0x01u, 0xE0u, - 0x00u, static_cast(es.size() + 3u), - 0x80u, 0x00u, 0x00u}; - packet.insert(packet.end(), es.begin(), es.end()); - std::memcpy(rdram.data() + kPacketAddr, packet.data(), packet.size()); - - R5900Context demuxCtx{}; - setRegU32(demuxCtx, 4, kMpegAddr); - setRegU32(demuxCtx, 5, kPacketAddr); - setRegU32(demuxCtx, 6, static_cast(packet.size())); - setRegU32(demuxCtx, 7, kPacketAddr); - setRegU32(demuxCtx, 8, static_cast(packet.size())); - ps2_stubs::sceMpegDemuxPssRing(rdram.data(), &demuxCtx, nullptr); - - R5900Context pictureCtx{}; - setRegU32(pictureCtx, 4, kMpegAddr); - setRegU32(pictureCtx, 5, kImageAddr); - ps2_stubs::sceMpegGetPicture(rdram.data(), &pictureCtx, nullptr); - t.Equals(Ps2FastRead32(rdram.data(), kMpegAddr + 0x00u), 16u, - "test stream should decode one frame before the pause"); - t.Equals(Ps2FastRead32(rdram.data(), kMpegAddr + 0x08u), 0u, - "first decoded frame should report frame index zero"); - - std::this_thread::sleep_for(std::chrono::milliseconds(650)); - - R5900Context isEndCtx{}; - setRegU32(isEndCtx, 4, kMpegAddr); - ps2_stubs::sceMpegIsEnd(rdram.data(), &isEndCtx, nullptr); - t.Equals(getRegS32(isEndCtx, 2), 0, - "a temporary demux pause must not end an active stream before CD EOF"); - - ps2_stubs::sceMpegGetPicture(rdram.data(), &pictureCtx, nullptr); - t.Equals(Ps2FastRead32(rdram.data(), kMpegAddr + 0x08u), 1u, - "temporary non-EOF starvation should keep movie frame progress moving"); - - ps2_stubs::sceMpegGetPicture(rdram.data(), &pictureCtx, nullptr); - t.Equals(Ps2FastRead32(rdram.data(), kMpegAddr + 0x08u), 2u, - "repeated temporary starvation should continue advancing from the held frame"); - }); - - tc.Run("sceMpegGetPicture releases an old waiter when the CD stream restarts", [](TestCase &t) + tc.Run("sceMpegGetPicture blocks as a typed scheduler wait and resumes on EOF", [](TestCase &t) { PS2Runtime runtime; std::vector rdram(PS2_RAM_SIZE, 0u); ps2_stubs::resetMpegStubState(); ps2_stubs::notifyMpegCdStreamStart(); - - constexpr uint32_t kMpegAddr = 0x00123000u; - constexpr uint32_t kImageAddr = 0x00130000u; - R5900Context pictureCtx{}; - setRegU32(pictureCtx, 4, kMpegAddr); - setRegU32(pictureCtx, 5, kImageAddr); - - std::atomic returned{false}; - std::thread waiter([&]() - { - ps2_stubs::sceMpegGetPicture(rdram.data(), &pictureCtx, &runtime); - returned.store(true, std::memory_order_release); - }); - - std::this_thread::sleep_for(std::chrono::milliseconds(20)); - t.IsFalse(returned.load(std::memory_order_acquire), - "sceMpegGetPicture should wait while the current stream still has no frame"); - - ps2_stubs::notifyMpegCdStreamStart(); - const bool released = waitUntil( - [&]() { return returned.load(std::memory_order_acquire); }, - std::chrono::milliseconds(30)); - - runtime.requestStop(); - waiter.join(); - t.IsTrue(released, - "a new sceCdStStart generation should release a waiter owned by the previous movie"); + runtime.registerFunction(kMpegWaitMainPc, testMpegWaitMain); + runtime.registerFunction(kMpegWaitResumePc, testMpegWaitResume); + runtime.registerFunction(kMpegWaitProducerPc, testMpegWaitProducer); + gMpegWaitResult.store(-999, std::memory_order_release); + gMpegWaitStage.store(0u, std::memory_order_release); + + R5900Context mainContext{}; + mainContext.pc = kMpegWaitMainPc; + EeScheduler &ee = runtime.eeScheduler(); + ee.reset(rdram.data(), mainContext); + const int producerId = ee.createThread(EeThreadCreateParams{ + 0u, kMpegWaitProducerPc, 0u, 0u, 0u, 10, 0u}); + t.IsTrue(producerId > 1, "MPEG producer guest thread should be created"); + t.Equals(ee.startThread(producerId, 0u, mainContext, false), 0, + "MPEG producer guest thread should become ready"); + ee.run(); + + t.Equals(gMpegWaitResult.load(std::memory_order_acquire), 0, + "EOF completion should resume GetPicture with success"); + t.Equals(gMpegWaitStage.load(std::memory_order_acquire), 3u, + "MPEG waiter should reach its continuation after the producer posts EOF"); + t.Equals(Ps2FastRead32(rdram.data(), kMpegWaitHandle + 0x00u), 320u, + "resumed GetPicture should publish the configured width"); + t.Equals(Ps2FastRead32(rdram.data(), kMpegWaitHandle + 0x04u), 240u, + "resumed GetPicture should publish the configured height"); }); - tc.Run("sceMpegGetPicture yields during active stream starvation before CD EOF", [](TestCase &t) + tc.Run("sceMpegGetPicture waits for new decoder output instead of duplicating the last frame", [](TestCase &t) { PS2Runtime runtime; std::vector rdram(PS2_RAM_SIZE, 0u); ps2_stubs::resetMpegStubState(); ps2_stubs::notifyMpegCdStreamStart(); - - constexpr uint32_t kMpegAddr = 0x00123000u; - constexpr uint32_t kPssAddr = 0x0012C000u; - constexpr uint32_t kImageAddr = 0x00130000u; - const uint8_t incompletePssStart[] = {0x00u, 0x00u, 0x01u}; - std::memcpy(rdram.data() + kPssAddr, incompletePssStart, sizeof(incompletePssStart)); - - R5900Context demuxCtx{}; - setRegU32(demuxCtx, 4, kMpegAddr); - setRegU32(demuxCtx, 5, kPssAddr); - setRegU32(demuxCtx, 6, sizeof(incompletePssStart)); - setRegU32(demuxCtx, 7, kPssAddr); - setRegU32(demuxCtx, 8, sizeof(incompletePssStart)); - ps2_stubs::sceMpegDemuxPssRing(rdram.data(), &demuxCtx, &runtime); - - R5900Context pictureCtx{}; - setRegU32(pictureCtx, 4, kMpegAddr); - setRegU32(pictureCtx, 5, kImageAddr); - - std::atomic returned{false}; - std::thread waiter([&]() - { - ps2_stubs::sceMpegGetPicture(rdram.data(), &pictureCtx, &runtime); - returned.store(true, std::memory_order_release); - }); - - const bool yielded = waitUntil( - [&]() { return returned.load(std::memory_order_acquire); }, - std::chrono::milliseconds(200)); - - runtime.requestStop(); - waiter.join(); - t.IsTrue(yielded, - "active non-EOF streams must return control when no decoded frame is currently available"); - - R5900Context isEndCtx{}; - setRegU32(isEndCtx, 4, kMpegAddr); - ps2_stubs::sceMpegIsEnd(rdram.data(), &isEndCtx, nullptr); - t.Equals(getRegS32(isEndCtx, 2), 0, - "yielding without a frame must not mark the active stream ended"); - }); - - tc.Run("movie startup MPEG and audio stubs return safe progress values", [](TestCase &t) - { - std::vector rdram(PS2_RAM_SIZE, 0u); - ps2_stubs::resetMpegStubState(); - ps2_stubs::resetAudioStubState(); - - R5900Context firstIsEndCtx{}; - setRegU32(firstIsEndCtx, 4, 0x00123000u); - ps2_stubs::sceMpegIsEnd(rdram.data(), &firstIsEndCtx, nullptr); - t.Equals(getRegS32(firstIsEndCtx, 2), 0, - "sceMpegIsEnd should allow one synthetic frame before reporting end"); - - R5900Context demuxCtx{}; - setRegU32(demuxCtx, 4, 0x00123000u); - setRegU32(demuxCtx, 5, 0x00400000u); - setRegU32(demuxCtx, 6, 0x00004000u); - setRegU32(demuxCtx, 7, 0x00410000u); - ps2_stubs::sceMpegDemuxPssRing(rdram.data(), &demuxCtx, nullptr); - t.Equals(getRegS32(demuxCtx, 2), 0x4000, - "sceMpegDemuxPssRing should consume the provided input instead of trapping"); - - R5900Context getPictureCtx{}; - setRegU32(getPictureCtx, 4, 0x00123000u); - setRegU32(getPictureCtx, 5, 0x00124000u); - setRegU32(getPictureCtx, 6, 440u); - ps2_stubs::sceMpegGetPicture(rdram.data(), &getPictureCtx, nullptr); - t.Equals(Ps2FastRead32(rdram.data(), 0x00123000u + 0x00u), 320u, - "sceMpegGetPicture should seed a safe movie width"); - t.Equals(Ps2FastRead32(rdram.data(), 0x00123000u + 0x04u), 240u, - "sceMpegGetPicture should seed a safe movie height"); - t.Equals(Ps2FastRead32(rdram.data(), 0x00123000u + 0x08u), 0u, - "first synthetic picture should preserve frameCount==0 for guest setup"); - - R5900Context secondIsEndCtx{}; - setRegU32(secondIsEndCtx, 4, 0x00123000u); - ps2_stubs::sceMpegIsEnd(rdram.data(), &secondIsEndCtx, nullptr); - t.Equals(getRegS32(secondIsEndCtx, 2), 0, - "sceMpegIsEnd should keep the decode thread alive and let the guest stop playback"); - - constexpr uint32_t pssEndAddr = 0x00128000u; - constexpr uint32_t stackAddr = 0x00129000u; - const uint8_t programEnd[] = {0x00u, 0x00u, 0x01u, 0xB9u}; - std::memcpy(rdram.data() + pssEndAddr, programEnd, sizeof(programEnd)); - std::memcpy(rdram.data() + stackAddr + 0x10u, "\x04\x00\x00\x00", 4u); - - R5900Context endDemuxCtx{}; - setRegU32(endDemuxCtx, 29, stackAddr); - setRegU32(endDemuxCtx, 4, 0x00123000u); - setRegU32(endDemuxCtx, 5, pssEndAddr); - setRegU32(endDemuxCtx, 6, sizeof(programEnd)); - setRegU32(endDemuxCtx, 7, pssEndAddr); - ps2_stubs::sceMpegDemuxPssRing(rdram.data(), &endDemuxCtx, nullptr); - - R5900Context endIsEndCtx{}; - setRegU32(endIsEndCtx, 4, 0x00123000u); - ps2_stubs::sceMpegIsEnd(rdram.data(), &endIsEndCtx, nullptr); - t.Equals(getRegS32(endIsEndCtx, 2), 1, - "sceMpegIsEnd should report end after a demuxed MPEG program end code"); - - ps2_stubs::resetMpegStubState(); - constexpr uint32_t wrappedEndBase = 0x0012A000u; - rdram[wrappedEndBase + 0u] = 0x00u; - rdram[wrappedEndBase + 1u] = 0x01u; - rdram[wrappedEndBase + 2u] = 0xB9u; - rdram[wrappedEndBase + 3u] = 0x00u; - - R5900Context wrappedEndDemuxCtx{}; - setRegU32(wrappedEndDemuxCtx, 4, 0x00123000u); - setRegU32(wrappedEndDemuxCtx, 5, wrappedEndBase + 3u); - setRegU32(wrappedEndDemuxCtx, 6, 4u); - setRegU32(wrappedEndDemuxCtx, 7, wrappedEndBase); - setRegU32(wrappedEndDemuxCtx, 8, 4u); - ps2_stubs::sceMpegDemuxPssRing(rdram.data(), &wrappedEndDemuxCtx, nullptr); - - R5900Context wrappedEndIsEndCtx{}; - setRegU32(wrappedEndIsEndCtx, 4, 0x00123000u); - ps2_stubs::sceMpegIsEnd(rdram.data(), &wrappedEndIsEndCtx, nullptr); - t.Equals(getRegS32(wrappedEndIsEndCtx, 2), 1, - "sceMpegDemuxPssRing should use the ABI fifth argument in t0 for wrapped rings"); - - ps2_stubs::resetMpegStubState(); - constexpr uint32_t eofMpegAddr = 0x0012B000u; - constexpr uint32_t eofPssAddr = 0x0012C000u; - const uint8_t incompletePssStart[] = {0x00u, 0x00u, 0x01u}; - std::memcpy(rdram.data() + eofPssAddr, incompletePssStart, sizeof(incompletePssStart)); - - R5900Context eofDemuxCtx{}; - setRegU32(eofDemuxCtx, 4, eofMpegAddr); - setRegU32(eofDemuxCtx, 5, eofPssAddr); - setRegU32(eofDemuxCtx, 6, sizeof(incompletePssStart)); - setRegU32(eofDemuxCtx, 7, eofPssAddr); - setRegU32(eofDemuxCtx, 8, sizeof(incompletePssStart)); - ps2_stubs::sceMpegDemuxPssRing(rdram.data(), &eofDemuxCtx, nullptr); - t.Equals(getRegS32(eofDemuxCtx, 2), static_cast(sizeof(incompletePssStart)), - "sceMpegDemuxPssRing should accept partial trailing stream data"); - - R5900Context eofBeforeStopCtx{}; - setRegU32(eofBeforeStopCtx, 4, eofMpegAddr); - ps2_stubs::sceMpegIsEnd(rdram.data(), &eofBeforeStopCtx, nullptr); - t.Equals(getRegS32(eofBeforeStopCtx, 2), 0, - "sceMpegIsEnd should not report end until the CD stream terminates"); - - R5900Context cdStopCtx{}; - ps2_stubs::sceCdStStop(rdram.data(), &cdStopCtx, nullptr); - - R5900Context eofAfterStopCtx{}; - setRegU32(eofAfterStopCtx, 4, eofMpegAddr); - ps2_stubs::sceMpegIsEnd(rdram.data(), &eofAfterStopCtx, nullptr); - t.Equals(getRegS32(eofAfterStopCtx, 2), 1, - "sceCdStStop should finalize active MPEG playback so movie threads can advance"); - - R5900Context remoteInitCtx{}; - ps2_stubs::sceSdRemoteInit(rdram.data(), &remoteInitCtx, nullptr); - t.Equals(getRegS32(remoteInitCtx, 2), 0, - "sceSdRemoteInit should succeed so Veronica can set up movie audio"); - - R5900Context blockTransCtx{}; - const uint32_t blockTransSp = 0x00100000u; - setRegU32(blockTransCtx, 29, blockTransSp); - setRegU32(blockTransCtx, 4, 1u); - setRegU32(blockTransCtx, 5, 0x80E0u); - setRegU32(blockTransCtx, 6, 1u); - setRegU32(blockTransCtx, 7, 0x13u); - std::memcpy(rdram.data() + blockTransSp + 0x10u, "\x40\x23\x01\x00", 4u); - std::memcpy(rdram.data() + blockTransSp + 0x14u, "\x00\x30\x00\x00", 4u); - std::memcpy(rdram.data() + blockTransSp + 0x18u, "\x40\x27\x01\x00", 4u); - ps2_stubs::sceSdRemote(rdram.data(), &blockTransCtx, nullptr); - t.Equals(getRegU32(&blockTransCtx, 2), 0u, - "sceSdRemote block-transfer start should report libsd success"); - - R5900Context statusCtx{}; - setRegU32(statusCtx, 29, blockTransSp); - setRegU32(statusCtx, 4, 1u); - setRegU32(statusCtx, 5, 0x8100u); - setRegU32(statusCtx, 6, 1u); - setRegU32(statusCtx, 7, 0u); - std::memset(rdram.data() + blockTransSp + 0x10u, 0, 12u); - ps2_stubs::sceSdRemote(rdram.data(), &statusCtx, nullptr); - t.Equals(getRegU32(&statusCtx, 2), 0x00012B40u, - "sceSdRemote status polling should advance the emulated SPU transfer head"); - - for (uint32_t i = 0u; i < 11u; ++i) - { - ps2_stubs::sceSdRemote(rdram.data(), &statusCtx, nullptr); - } - t.Equals(getRegU32(&statusCtx, 2), 0x00012740u, - "sceSdRemote status polling should wrap inside the configured IOP ring"); - - R5900Context setParamCtx{}; - setRegU32(setParamCtx, 29, blockTransSp); - setRegU32(setParamCtx, 4, 1u); - setRegU32(setParamCtx, 5, 0x8010u); - setRegU32(setParamCtx, 6, 0x0F81u); - setRegU32(setParamCtx, 7, 0u); - ps2_stubs::sceSdRemote(rdram.data(), &setParamCtx, nullptr); - t.Equals(getRegU32(&setParamCtx, 2), 0u, - "sceSdRemote set-param calls should not trap or disturb the movie audio state"); + ps2_stubs::enqueueMpegDecodedFrameForTesting(kMpegNoDuplicateHandle); + runtime.registerFunction(kMpegNoDuplicateMainPc, testMpegNoDuplicateMain); + runtime.registerFunction(kMpegNoDuplicateResumePc, testMpegNoDuplicateResume); + runtime.registerFunction(kMpegNoDuplicateProducerPc, testMpegNoDuplicateProducer); + gMpegNoDuplicateStage.store(0u, std::memory_order_release); + gMpegNoDuplicateProducerStage.store(0u, std::memory_order_release); + + R5900Context mainContext{}; + mainContext.pc = kMpegNoDuplicateMainPc; + EeScheduler &ee = runtime.eeScheduler(); + ee.reset(rdram.data(), mainContext); + const int producerId = ee.createThread(EeThreadCreateParams{ + 0u, kMpegNoDuplicateProducerPc, 0u, 0u, 0u, 10, 0u}); + t.IsTrue(producerId > 1, "MPEG producer guest thread should be created"); + t.Equals(ee.startThread(producerId, 0u, mainContext, false), 0, + "MPEG producer guest thread should become ready"); + ee.run(); + + t.Equals(gMpegNoDuplicateProducerStage.load(std::memory_order_acquire), 1u, + "the producer should run while the second GetPicture is waiting"); + t.Equals(gMpegNoDuplicateStage.load(std::memory_order_acquire), 3u, + "EOF should resume the blocked GetPicture continuation"); + t.Equals(Ps2FastRead32(rdram.data(), kMpegNoDuplicateHandle + 0x08u), 1u, + "only the injected decoder frame should be counted as served"); }); tc.Run("sceSdRemote isolates voice transfers from block streaming state", [](TestCase &t) @@ -1510,6 +857,32 @@ void register_ps2_runtime_expansion_tests() "sceIpuInit should leave IPU_CMD reset after initialization"); }); + tc.Run("IPU init executes its guest helper as a scheduler invocation", [](TestCase &t) + { + PS2Runtime runtime; + std::vector rdram(PS2_RAM_SIZE, 0u); + runtime.registerFunction(kIpuInitMainPc, testIpuInitMain); + runtime.registerFunction(kIpuInitResumePc, testIpuInitResume); + runtime.registerFunction(kIpuSetD4Pc, testIpuSetD4); + gIpuSetD4Hits.store(0u, std::memory_order_release); + gIpuSetD4Argument.store(0u, std::memory_order_release); + gIpuInitResult.store(-999, std::memory_order_release); + + R5900Context context{}; + context.pc = kIpuInitMainPc; + runtime.eeScheduler().reset(rdram.data(), context); + runtime.eeScheduler().run(); + + t.Equals(gIpuSetD4Hits.load(std::memory_order_acquire), 1u, + "the optional guest helper should execute exactly once through the dispatcher"); + t.Equals(gIpuSetD4Argument.load(std::memory_order_acquire), 1u, + "the invocation should receive the SetD4 enable argument"); + t.Equals(gIpuInitResult.load(std::memory_order_acquire), 0, + "the HLE completion should resume the preserved base context with success"); + t.Equals(runtime.memory().read32(0x10002010u), 0x40000000u, + "IPU initialization should finish only after the guest invocation completes"); + }); + tc.Run("sprintf consumes EE varargs from a2 a3 t0 and preserves width formatting", [](TestCase &t) { PS2Runtime runtime; @@ -1812,291 +1185,6 @@ void register_ps2_runtime_expansion_tests() t.Equals(vram[pxOff + 2u], static_cast(120u), "alpha blend should update B with FIX factor"); }); - tc.Run("notifyRuntimeStop joins guest worker threads before teardown", [](TestCase &t) - { - notifyRuntimeStop(); - PS2Runtime runtime; - std::vector rdram(PS2_RAM_SIZE, 0u); - - constexpr uint32_t kEntry = 0x250000u; - constexpr uint32_t kThreadParamAddr = 0x2600u; - const uint32_t threadParam[7] = { - 0u, // attr - kEntry, // entry - 0x00100000u, // stack - 0x00000400u, // stack size - 0x00110000u, // gp - 8u, // priority - 0u // option - }; - - runtime.registerFunction(kEntry, &testRuntimeWorkerLoop); - std::memcpy(rdram.data() + kThreadParamAddr, threadParam, sizeof(threadParam)); - - R5900Context createCtx{}; - setRegU32(createCtx, 4, kThreadParamAddr); - CreateThread(rdram.data(), &createCtx, &runtime); - const int32_t tid = getRegS32(createCtx, 2); - t.IsTrue(tid > 0, "CreateThread should succeed for teardown-join test"); - - R5900Context startCtx{}; - setRegU32(startCtx, 4, static_cast(tid)); - setRegU32(startCtx, 5, 0u); - StartThread(rdram.data(), &startCtx, &runtime); - t.Equals(getRegS32(startCtx, 2), KE_OK, "StartThread should launch worker"); - - const bool started = waitUntil([&]() - { - return g_activeThreads.load(std::memory_order_relaxed) > 0; - }, std::chrono::milliseconds(500)); - t.IsTrue(started, "worker thread should become active"); - - runtime.requestStop(); - const bool drained = waitUntil([&]() - { - return g_activeThreads.load(std::memory_order_relaxed) == 0; - }, std::chrono::milliseconds(2000)); - t.IsTrue(drained, "requestStop should drain all guest worker threads"); - - notifyRuntimeStop(); - }); - - tc.Run("Semaphore poll/signal remains stable under host-thread contention", [](TestCase &t) - { - notifyRuntimeStop(); - PS2Runtime runtime; - std::vector rdram(PS2_RAM_SIZE, 0u); - - constexpr uint32_t kParamAddr = 0x2000u; - // init=1 < max=2 headroom makes both first calls succeed - // regardless of scheduling: poller is the sole decrementer - // (count>=1 at first poll), signaler the sole incrementer - // (count 0, "CreateSema should return a valid sid"); - - std::atomic pollOkCount{0}; - std::atomic signalOkCount{0}; - std::atomic pollerThrew{false}; - std::atomic signalerThrew{false}; - std::atomic readyCount{0}; - - // Release both workers together so their 64-iteration loops start at - // the same instant, maximizing the opportunity to interleave instead - // of one thread running to completion before the other is scheduled. - const auto waitForStart = [&]() - { - readyCount.fetch_add(1, std::memory_order_acq_rel); - while (readyCount.load(std::memory_order_acquire) < 2) - { - std::this_thread::yield(); - } - }; - - std::thread poller([&]() - { - try - { - waitForStart(); - for (int i = 0; i < 64; ++i) - { - R5900Context pollCtx{}; - setRegU32(pollCtx, 4, static_cast(sid)); - PollSema(rdram.data(), &pollCtx, &runtime); - if (getRegS32(pollCtx, 2) == sid) - { - pollOkCount.fetch_add(1, std::memory_order_relaxed); - } - } - } - catch (...) - { - pollerThrew.store(true, std::memory_order_release); - } - }); - - std::thread signaler([&]() - { - try - { - waitForStart(); - for (int i = 0; i < 64; ++i) - { - R5900Context signalCtx{}; - setRegU32(signalCtx, 4, static_cast(sid)); - SignalSema(rdram.data(), &signalCtx, &runtime); - if (getRegS32(signalCtx, 2) == sid) - { - signalOkCount.fetch_add(1, std::memory_order_relaxed); - } - } - } - catch (...) - { - signalerThrew.store(true, std::memory_order_release); - } - }); - - if (poller.joinable()) - { - poller.join(); - } - if (signaler.joinable()) - { - signaler.join(); - } - - t.IsFalse(pollerThrew.load(std::memory_order_acquire), - "PollSema worker thread should not throw"); - t.IsFalse(signalerThrew.load(std::memory_order_acquire), - "SignalSema worker thread should not throw"); - t.IsTrue(pollOkCount.load(std::memory_order_relaxed) > 0, - "contended PollSema should observe at least one successful acquire"); - t.IsTrue(signalOkCount.load(std::memory_order_relaxed) > 0, - "contended SignalSema should observe successful releases"); - - constexpr uint32_t kStatusAddr = 0x2100u; - R5900Context referCtx{}; - setRegU32(referCtx, 4, static_cast(sid)); - setRegU32(referCtx, 5, kStatusAddr); - ReferSemaStatus(rdram.data(), &referCtx, &runtime); - t.Equals(getRegS32(referCtx, 2), KE_OK, "ReferSemaStatus should succeed after contention"); - - int32_t finalCount = 0; - std::memcpy(&finalCount, rdram.data() + kStatusAddr + 0u, sizeof(finalCount)); - t.IsTrue(finalCount >= 0 && finalCount <= 2, "semaphore count should remain within [0, max_count]"); - - runtime.requestStop(); - notifyRuntimeStop(); - }); - - tc.Run("WaitEventFlag AND-mode is stable under concurrent setters", [](TestCase &t) - { - notifyRuntimeStop(); - PS2Runtime runtime; - std::vector rdram(PS2_RAM_SIZE, 0u); - - constexpr uint32_t kEventParamAddr = 0x2400u; - constexpr uint32_t kResBitsAddr = 0x2410u; - const uint32_t eventParam[3] = {0u, 0u, 0u}; - std::memcpy(rdram.data() + kEventParamAddr, eventParam, sizeof(eventParam)); - - R5900Context createCtx{}; - setRegU32(createCtx, 4, kEventParamAddr); - CreateEventFlag(rdram.data(), &createCtx, &runtime); - const int32_t eid = getRegS32(createCtx, 2); - t.IsTrue(eid > 0, "CreateEventFlag should return a valid id"); - - std::atomic waiterDone{false}; - std::atomic waiterRet{-9999}; - std::atomic waiterBits{0u}; - std::atomic waiterThrew{false}; - std::atomic setterAThrew{false}; - std::atomic setterBThrew{false}; - - std::thread waiter([&]() - { - try - { - R5900Context waitCtx{}; - setRegU32(waitCtx, 4, static_cast(eid)); - setRegU32(waitCtx, 5, 0x3u); // wait for bit0 and bit1 (AND mode) - setRegU32(waitCtx, 6, 0u); // AND, no clear - setRegU32(waitCtx, 7, kResBitsAddr); - WaitEventFlag(rdram.data(), &waitCtx, &runtime); - waiterRet.store(getRegS32(waitCtx, 2), std::memory_order_relaxed); - uint32_t bits = 0u; - std::memcpy(&bits, rdram.data() + kResBitsAddr, sizeof(bits)); - waiterBits.store(bits, std::memory_order_relaxed); - } - catch (...) - { - waiterThrew.store(true, std::memory_order_release); - } - waiterDone.store(true, std::memory_order_release); - }); - - std::thread setterA([&]() - { - try - { - std::this_thread::sleep_for(std::chrono::milliseconds(10)); - R5900Context setCtx{}; - setRegU32(setCtx, 4, static_cast(eid)); - setRegU32(setCtx, 5, 0x1u); - SetEventFlag(rdram.data(), &setCtx, &runtime); - } - catch (...) - { - setterAThrew.store(true, std::memory_order_release); - } - }); - - std::thread setterB([&]() - { - try - { - std::this_thread::sleep_for(std::chrono::milliseconds(15)); - R5900Context setCtx{}; - setRegU32(setCtx, 4, static_cast(eid)); - setRegU32(setCtx, 5, 0x2u); - SetEventFlag(rdram.data(), &setCtx, &runtime); - } - catch (...) - { - setterBThrew.store(true, std::memory_order_release); - } - }); - - const bool woke = waitUntil([&]() - { - return waiterDone.load(std::memory_order_acquire); - }, std::chrono::milliseconds(500)); - - if (setterA.joinable()) - { - setterA.join(); - } - if (setterB.joinable()) - { - setterB.join(); - } - if (waiter.joinable()) - { - waiter.join(); - } - - t.IsFalse(waiterThrew.load(std::memory_order_acquire), - "WaitEventFlag waiter thread should not throw"); - t.IsFalse(setterAThrew.load(std::memory_order_acquire), - "SetEventFlag setterA thread should not throw"); - t.IsFalse(setterBThrew.load(std::memory_order_acquire), - "SetEventFlag setterB thread should not throw"); - t.IsTrue(woke, "WaitEventFlag AND waiter should wake after both bits are published"); - t.Equals(waiterRet.load(std::memory_order_relaxed), KE_OK, "WaitEventFlag should return KE_OK"); - t.IsTrue((waiterBits.load(std::memory_order_relaxed) & 0x3u) == 0x3u, - "WaitEventFlag result bits should include both concurrently-set bits"); - - R5900Context deleteCtx{}; - setRegU32(deleteCtx, 4, static_cast(eid)); - DeleteEventFlag(rdram.data(), &deleteCtx, &runtime); - runtime.requestStop(); - notifyRuntimeStop(); - }); - tc.Run("sceVu0ApplyMatrix uses libvux matrix math with the imported EE ABI", [](TestCase &t) { std::vector rdram(PS2_RAM_SIZE, 0u); diff --git a/ps2xTest/src/ps2_runtime_interrupt_tests.cpp b/ps2xTest/src/ps2_runtime_interrupt_tests.cpp index b91b9d9bd..be4c1ad7e 100644 --- a/ps2xTest/src/ps2_runtime_interrupt_tests.cpp +++ b/ps2xTest/src/ps2_runtime_interrupt_tests.cpp @@ -1,8 +1,7 @@ #include "MiniTest.h" #include "ps2_runtime.h" #include "ps2_syscalls.h" -#include "Stubs/DMA.h" -#include "runtime/ps2_gs_gpu.h" +#include "runtime/ee_scheduler.h" #include #include @@ -46,12 +45,32 @@ namespace } }; - std::atomic g_vblankStartHits{0u}; - std::atomic g_vblankEndHits{0u}; std::atomic g_lastIntcArg{0u}; - std::atomic g_dmacSendHits{0u}; - std::atomic g_dmacSendLastCause{0u}; - std::atomic g_dmacSendLastChcr{0u}; + constexpr uint32_t kIdleVSyncWaitPc = 0x00160000u; + constexpr uint32_t kVSyncWaitPc = 0x00160100u; + constexpr uint32_t kVSyncResumePc = 0x00160110u; + constexpr uint32_t kIrqWaitPc = 0x00160200u; + constexpr uint32_t kIrqResumePc = 0x00160210u; + constexpr uint32_t kIntcHandlerPc = 0x00160220u; + constexpr uint32_t kISemaWaitPc = 0x00160300u; + constexpr uint32_t kISemaResumePc = 0x00160310u; + constexpr uint32_t kISemaDriverPc = 0x00160320u; + constexpr uint32_t kISemaHandlerPc = 0x00160330u; + constexpr uint32_t kEventWaitPc = 0x00160400u; + constexpr uint32_t kEventResumePc = 0x00160410u; + constexpr uint32_t kEventProducerPc = 0x00160420u; + + constexpr uint32_t kVSyncFlagAddr = 0x1800u; + constexpr uint32_t kVSyncTickAddr = 0x1810u; + constexpr uint32_t kEventResultAddr = 0x1820u; + + std::vector g_dispatchTrace; + int g_testSemaphoreId = 0; + int g_testEventFlagId = 0; + int32_t g_resumedResult = 0; + uint32_t g_vsyncFlag = 0; + uint64_t g_vsyncTick = 0; + uint64_t g_vsyncCsr = 0; void setRegU32(R5900Context &ctx, int reg, uint32_t value) { @@ -73,25 +92,6 @@ namespace std::memcpy(rdram + addr, &value, sizeof(value)); } - void writeGuestU64(uint8_t *rdram, uint32_t addr, uint64_t value) - { - std::memcpy(rdram + addr, &value, sizeof(value)); - } - - uint64_t makeDmaTag(uint16_t qwc, uint8_t id, uint32_t addr, bool irq = false) - { - return static_cast(qwc) | - (static_cast(id & 0x7u) << 28) | - (irq ? (1ull << 31) : 0ull) | - (static_cast(addr & 0x7FFFFFFFu) << 32); - } - - void writeDmaTag(uint8_t *rdram, uint32_t tagAddr, uint64_t tagLo) - { - std::memset(rdram + tagAddr, 0, 16); - std::memcpy(rdram + tagAddr, &tagLo, sizeof(tagLo)); - } - uint32_t readGuestU32(const uint8_t *rdram, uint32_t addr) { uint32_t value = 0; @@ -124,502 +124,137 @@ namespace void cleanupRuntime(TestEnv &env) { env.runtime.requestStop(); - notifyRuntimeStop(); } - void testIntcHandler(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) + void idleVSyncWait(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { - (void)rdram; - (void)runtime; - - const uint32_t cause = getRegU32(ctx, 4); - const uint32_t arg = getRegU32(ctx, 5); - g_lastIntcArg.store(arg, std::memory_order_relaxed); + WaitVSyncTick(rdram, ctx, runtime, -1); + } - if (cause == 2u) - { - g_vblankStartHits.fetch_add(1u, std::memory_order_relaxed); - } - else if (cause == 3u) - { - g_vblankEndHits.fetch_add(1u, std::memory_order_relaxed); - } + void schedulerVSyncWait(uint8_t *, R5900Context *ctx, PS2Runtime *runtime) + { + EeScheduler &scheduler = runtime->eeScheduler(); + scheduler.setVSyncFlag(kVSyncFlagAddr, kVSyncTickAddr); + ctx->pc = kVSyncResumePc; + scheduler.waitVSync(scheduler.currentVSyncTick()); + } + void schedulerVSyncResume(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) + { + g_vsyncFlag = readGuestU32(rdram, kVSyncFlagAddr); + g_vsyncTick = readGuestU64(rdram, kVSyncTickAddr); + g_vsyncCsr = runtime->memory().gs().csr.load(std::memory_order_acquire); + g_resumedResult = getRegS32(*ctx, 2); ctx->pc = 0u; + runtime->requestStop(); } - void testDmacSendHandler(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) + void schedulerIntcHandler(uint8_t *, R5900Context *ctx, PS2Runtime *) { - (void)rdram; - - const uint32_t cause = getRegU32(ctx, 4); - g_dmacSendHits.fetch_add(1u, std::memory_order_relaxed); - g_dmacSendLastCause.store(cause, std::memory_order_relaxed); - - uint32_t channelBase = 0u; - if (cause == 0u) - { - channelBase = 0x10008000u; - } - else if (cause == 1u) - { - channelBase = 0x10009000u; - } - else if (cause == 2u) - { - channelBase = 0x1000A000u; - } - - if (runtime && channelBase != 0u) - { - g_dmacSendLastChcr.store(runtime->memory().readIORegister(channelBase + 0x00u), std::memory_order_relaxed); - } - + g_dispatchTrace.push_back(2); + g_lastIntcArg.store(getRegU32(ctx, 5), std::memory_order_relaxed); ctx->pc = 0u; } -} -void register_ps2_runtime_interrupt_tests() -{ - MiniTest::Case("PS2RuntimeInterrupt", [](TestCase &tc) + void schedulerIrqWait(uint8_t *, R5900Context *ctx, PS2Runtime *runtime) { - tc.Run("SetVSyncFlag arms a one-shot vblank notification", [](TestCase &t) - { - notifyRuntimeStop(); - TestEnv env; - - constexpr uint32_t kFlagAddr = 0x1000u; - constexpr uint32_t kTickAddr = 0x1010u; - - writeGuestU32(env.rdram.data(), kFlagAddr, 0xDEADBEEFu); - writeGuestU32(env.rdram.data(), kTickAddr + 0u, 0xAAAAAAAAu); - writeGuestU32(env.rdram.data(), kTickAddr + 4u, 0xBBBBBBBBu); - - R5900Context ctx{}; - setRegU32(ctx, 4, kFlagAddr); - setRegU32(ctx, 5, kTickAddr); - t.IsTrue(callSyscall(0x73u, env.rdram.data(), &ctx, &env.runtime), "SetVSyncFlag syscall should dispatch"); - t.Equals(getRegS32(ctx, 2), KE_OK, "SetVSyncFlag should return KE_OK"); - t.Equals(readGuestU32(env.rdram.data(), kFlagAddr), 0u, "SetVSyncFlag should reset flag to zero"); - t.Equals(readGuestU64(env.rdram.data(), kTickAddr), 0ull, "SetVSyncFlag should reset tick counter to zero"); - - const bool firstTickSeen = waitUntil([&]() { - return readGuestU64(env.rdram.data(), kTickAddr) > 0u; - }, std::chrono::milliseconds(300)); - t.IsTrue(firstTickSeen, "VSync worker should update tick value"); - - const uint64_t firstTick = readGuestU64(env.rdram.data(), kTickAddr); - t.IsTrue(firstTick > 0u, "First observed VSync tick should be positive"); - t.Equals(readGuestU32(env.rdram.data(), kFlagAddr), 1u, "VSync worker should set flag to one"); - - const bool tickRewritten = waitUntil([&]() { - return readGuestU64(env.rdram.data(), kTickAddr) != firstTick; - }, std::chrono::milliseconds(100)); - t.IsTrue(!tickRewritten, "consumed registration should not be written again"); - - // Re-arming registers a fresh one-shot notification. - writeGuestU32(env.rdram.data(), kFlagAddr, 0u); - R5900Context rearmCtx{}; - setRegU32(rearmCtx, 4, kFlagAddr); - setRegU32(rearmCtx, 5, kTickAddr); - t.IsTrue(callSyscall(0x73u, env.rdram.data(), &rearmCtx, &env.runtime), "SetVSyncFlag re-arm should dispatch"); - const bool rearmedTickSeen = waitUntil([&]() { - return readGuestU64(env.rdram.data(), kTickAddr) > firstTick; - }, std::chrono::milliseconds(300)); - t.IsTrue(rearmedTickSeen, "re-armed registration should observe a later tick"); - t.Equals(readGuestU32(env.rdram.data(), kFlagAddr), 1u, "re-armed registration should set flag to one"); - - cleanupRuntime(env); - }); - - tc.Run("VSync worker updates GS CSR FIELD bit for MMIO polling loops", [](TestCase &t) - { - notifyRuntimeStop(); - TestEnv env; - t.IsTrue(env.runtime.memory().initialize(), "runtime memory initialize should succeed"); - - constexpr uint32_t kFlagAddr = 0x1080u; - constexpr uint32_t kTickAddr = 0x1090u; - constexpr uint64_t kGsCsrFieldMask = 0x2000ull; - - env.runtime.memory().gs().csr = 0x3ull; - - R5900Context ctx{}; - setRegU32(ctx, 4, kFlagAddr); - setRegU32(ctx, 5, kTickAddr); - t.IsTrue(callSyscall(0x73u, env.rdram.data(), &ctx, &env.runtime), "SetVSyncFlag syscall should dispatch"); - - const uint64_t initialField = env.runtime.memory().gs().csr & kGsCsrFieldMask; - const bool firstFieldFlip = waitUntil([&]() { - return (env.runtime.memory().gs().csr & kGsCsrFieldMask) != initialField; - }, std::chrono::milliseconds(300)); - t.IsTrue(firstFieldFlip, "VSync worker should toggle GS CSR FIELD for direct CSR polling"); - t.Equals(env.runtime.memory().gs().csr & 0x3ull, 0x3ull, "VSync FIELD update should preserve CSR status bits"); - - const uint64_t fieldAfterFirstFlip = env.runtime.memory().gs().csr & kGsCsrFieldMask; - const bool secondFieldFlip = waitUntil([&]() { - return (env.runtime.memory().gs().csr & kGsCsrFieldMask) != fieldAfterFirstFlip; - }, std::chrono::milliseconds(300)); - t.IsTrue(secondFieldFlip, "VSync worker should keep alternating GS CSR FIELD"); - - cleanupRuntime(env); - }); - - // Regression test for the GS CSR data race: a two-writer word-level - // lost-update guard. Pre-fix, every CSR update was a plain (non-atomic) - // 64-bit load-modify-store of the WHOLE word, so two threads that own - // logically disjoint bits could still clobber each other: thread A's - // read-modify-write of the word can overwrite thread B's bit with the - // stale value A loaded before B's update landed. - // - // Two racer threads with disjoint bit ownership run concurrently: - // - racer A owns SIGNAL (bit 0): sets it via the GIF register path - // (GS_REG_SIGNAL) then W1C-clears ONLY bit 0 via the MMIO write path; - // - racer B owns FINISH (bit 1): same protocol with GS_REG_FINISH and - // a W1C write of only bit 1. - // Each racer checks only its own bit after each half-op. With the fix - // (std::atomic CSR, every update a single atomic RMW) each racer is the - // sole writer of its bit, so its bit deterministically reflects its own - // last operation: zero anomalies are possible. Pre-fix, the racers' - // whole-word W1C RMWs constantly interleave and lose each other's - // set/clear, lighting up the anomaly counters. - // - // Why racer-vs-racer instead of racer-vs-vsync: the vsync worker (which - // motivated the fix) writes CSR only once per ~16.7ms tick, a window far - // too narrow to hit deterministically in a bounded test. The corrupting - // mechanism -- a non-atomic whole-word RMW clobbering a concurrently - // written disjoint bit -- is identical, so guarding it with two - // high-frequency writers also guards the vsync FIELD interleaving. The - // real vsync worker still runs throughout (started via the same - // SetVSyncFlag syscall production uses) and its FIELD (bit 13) toggling - // is asserted when at least two ticks were observed. - tc.Run("Disjoint-bit GS CSR writers (SIGNAL vs FINISH vs vsync FIELD) never lose word-level updates", [](TestCase &t) - { - notifyRuntimeStop(); - TestEnv env; - t.IsTrue(env.runtime.memory().initialize(), "runtime memory initialize should succeed"); - - constexpr uint32_t kFlagAddr = 0x1180u; - constexpr uint32_t kTickAddr = 0x1190u; - constexpr uint64_t kGsCsrFieldMask = 0x2000ull; - constexpr uint32_t kCsrAddr = PS2_GS_PRIV_REG_BASE + 0x1000u; - constexpr uint32_t kIterations = 80000u; - - GS gs; - gs.init(env.runtime.memory().getGSVRAM(), static_cast(PS2_GS_VRAM_SIZE), - &env.runtime.memory().gs()); - - // Drive the real vsync worker via the same syscall path production - // code uses; it runs on its own thread and toggles CSR.FIELD once - // per tick via updateGsCsrFieldForVSync. - R5900Context ctx{}; - setRegU32(ctx, 4, kFlagAddr); - setRegU32(ctx, 5, kTickAddr); - t.IsTrue(callSyscall(0x73u, env.rdram.data(), &ctx, &env.runtime), "SetVSyncFlag syscall should dispatch"); - const uint64_t tickBefore = GetCurrentVSyncTick(); - - std::atomic setAnomaliesA{0u}, clearAnomaliesA{0u}; - std::atomic setAnomaliesB{0u}, clearAnomaliesB{0u}; - std::atomic racersDone{0u}; - - // ownBit: the single CSR status bit this racer exclusively owns. - // Each iteration: raise the bit via the GIF register-write path, - // verify it reads back set, W1C-clear only that bit via the guest - // MMIO path, verify it reads back clear. The other racer and the - // vsync worker never touch this bit, so under atomic RMWs both - // checks are exact -- any anomaly is a lost word-level update. - auto racerBody = [&](uint8_t gifReg, uint64_t gifValue, uint64_t ownBit, - std::atomic &setAnomalies, std::atomic &clearAnomalies) { - for (uint32_t i = 0; i < kIterations; ++i) - { - gs.writeRegister(gifReg, gifValue); - if ((env.runtime.memory().gs().csr.load() & ownBit) == 0ull) - { - setAnomalies.fetch_add(1u, std::memory_order_relaxed); - } - - env.runtime.memory().write64(kCsrAddr, ownBit); - if ((env.runtime.memory().gs().csr.load() & ownBit) != 0ull) - { - clearAnomalies.fetch_add(1u, std::memory_order_relaxed); - } - } - racersDone.fetch_add(1u, std::memory_order_relaxed); - }; - - const uint64_t signalValue = (0xFFFFFFFFull << 32) | 0x11223344ull; - std::thread racerA(racerBody, GS_REG_SIGNAL, signalValue, 0x1ull, - std::ref(setAnomaliesA), std::ref(clearAnomaliesA)); - std::thread racerB(racerBody, GS_REG_FINISH, 0ull, 0x2ull, - std::ref(setAnomaliesB), std::ref(clearAnomaliesB)); - - // While the racers hammer bits 0..1, watch for CSR.FIELD (bit 13) - // flips from the vsync worker. Polling ends when both racers finish, - // so this adds no fixed wall-clock cost. - const uint64_t initialField = env.runtime.memory().gs().csr.load() & kGsCsrFieldMask; - bool fieldFlipped = false; - while (racersDone.load(std::memory_order_relaxed) < 2u) - { - if ((env.runtime.memory().gs().csr.load() & kGsCsrFieldMask) != initialField) - { - fieldFlipped = true; - } - std::this_thread::sleep_for(std::chrono::milliseconds(1)); - } - - racerA.join(); - racerB.join(); - const uint64_t ticksElapsed = GetCurrentVSyncTick() - tickBefore; - - t.Equals(setAnomaliesA.load(), 0u, "racer A: SIGNAL set must never be lost to a concurrent whole-word CSR RMW"); - t.Equals(clearAnomaliesA.load(), 0u, "racer A: SIGNAL W1C-clear must never be lost to a concurrent whole-word CSR RMW"); - t.Equals(setAnomaliesB.load(), 0u, "racer B: FINISH set must never be lost to a concurrent whole-word CSR RMW"); - t.Equals(clearAnomaliesB.load(), 0u, "racer B: FINISH W1C-clear must never be lost to a concurrent whole-word CSR RMW"); - t.Equals(env.runtime.memory().gs().csr.load() & 0x3ull, 0x0ull, - "final CSR status bits must match both racers' ledgers (last op on each bit was a clear)"); - if (ticksElapsed >= 2u) - { - t.IsTrue(fieldFlipped, "VSync worker should toggle GS CSR FIELD while the racers run"); - } - - cleanupRuntime(env); - }); - - tc.Run("INTC VBLANK handlers respect EnableIntc and DisableIntc masks", [](TestCase &t) - { - notifyRuntimeStop(); - TestEnv env; - - g_vblankStartHits.store(0u, std::memory_order_relaxed); - g_vblankEndHits.store(0u, std::memory_order_relaxed); - g_lastIntcArg.store(0u, std::memory_order_relaxed); - - constexpr uint32_t kFlagAddr = 0x1100u; - constexpr uint32_t kTickAddr = 0x1110u; - constexpr uint32_t kHandlerAddr = 0x00ABC100u; - - env.runtime.registerFunction(kHandlerAddr, &testIntcHandler); - - R5900Context addStart{}; - setRegU32(addStart, 4, 2u); // VBLANK start - setRegU32(addStart, 5, kHandlerAddr); - setRegU32(addStart, 6, 0u); - setRegU32(addStart, 7, 0xCAFE0002u); - setRegU32(addStart, 28, 0x12340000u); - setRegU32(addStart, 29, 0x001FFFE0u); - t.IsTrue(callSyscall(0x10u, env.rdram.data(), &addStart, &env.runtime), "AddIntcHandler syscall should dispatch"); - t.IsTrue(getRegS32(addStart, 2) > 0, "AddIntcHandler for cause 2 should return handler id"); - - R5900Context addEnd{}; - setRegU32(addEnd, 4, 3u); // VBLANK end - setRegU32(addEnd, 5, kHandlerAddr); - setRegU32(addEnd, 6, 0u); - setRegU32(addEnd, 7, 0xCAFE0003u); - setRegU32(addEnd, 28, 0x12340000u); - setRegU32(addEnd, 29, 0x001FFFE0u); - t.IsTrue(callSyscall(0x10u, env.rdram.data(), &addEnd, &env.runtime), "AddIntcHandler syscall should dispatch"); - t.IsTrue(getRegS32(addEnd, 2) > 0, "AddIntcHandler for cause 3 should return handler id"); - - R5900Context vsyncCtx{}; - setRegU32(vsyncCtx, 4, kFlagAddr); - setRegU32(vsyncCtx, 5, kTickAddr); - t.IsTrue(callSyscall(0x73u, env.rdram.data(), &vsyncCtx, &env.runtime), "SetVSyncFlag syscall should dispatch"); - t.Equals(getRegS32(vsyncCtx, 2), KE_OK, "SetVSyncFlag should succeed"); - - const bool startSeen = waitUntil([&]() { - return g_vblankStartHits.load(std::memory_order_relaxed) > 0u; - }, std::chrono::milliseconds(400)); - const bool endSeen = waitUntil([&]() { - return g_vblankEndHits.load(std::memory_order_relaxed) > 0u; - }, std::chrono::milliseconds(400)); - - t.IsTrue(startSeen, "VBLANK start handler should fire while cause 2 is enabled"); - t.IsTrue(endSeen, "VBLANK end handler should fire while cause 3 is enabled"); - - R5900Context disableStart{}; - setRegU32(disableStart, 4, 2u); - t.IsTrue(callSyscall(0x15u, env.rdram.data(), &disableStart, &env.runtime), "DisableIntc syscall should dispatch"); - t.Equals(getRegS32(disableStart, 2), KE_OK, "DisableIntc should return KE_OK"); - - std::this_thread::sleep_for(std::chrono::milliseconds(40)); - const uint32_t startAfterDisable = g_vblankStartHits.load(std::memory_order_relaxed); - const uint32_t endAfterDisable = g_vblankEndHits.load(std::memory_order_relaxed); - - std::this_thread::sleep_for(std::chrono::milliseconds(80)); - const uint32_t startLater = g_vblankStartHits.load(std::memory_order_relaxed); - const uint32_t endLater = g_vblankEndHits.load(std::memory_order_relaxed); - - t.Equals(startLater, startAfterDisable, "cause 2 handler count should stop increasing while cause 2 is disabled"); - t.IsTrue(endLater > endAfterDisable, "cause 3 handler should keep firing while still enabled"); - - R5900Context enableStart{}; - setRegU32(enableStart, 4, 2u); - t.IsTrue(callSyscall(0x14u, env.rdram.data(), &enableStart, &env.runtime), "EnableIntc syscall should dispatch"); - t.Equals(getRegS32(enableStart, 2), KE_OK, "EnableIntc should return KE_OK"); - - const bool startResumed = waitUntil([&]() { - return g_vblankStartHits.load(std::memory_order_relaxed) > startLater; - }, std::chrono::milliseconds(300)); - t.IsTrue(startResumed, "cause 2 handler should resume after re-enable"); - - const uint32_t lastArg = g_lastIntcArg.load(std::memory_order_relaxed); - t.IsTrue(lastArg == 0xCAFE0002u || lastArg == 0xCAFE0003u, - "handler should receive configured argument value"); - - cleanupRuntime(env); - }); - - tc.Run("sceDmaSend dispatches completed VIF1 DMAC handler with latched END tag", [](TestCase &t) - { - notifyRuntimeStop(); - TestEnv env; - t.IsTrue(env.runtime.memory().initialize(), "runtime memory initialize should succeed"); + g_dispatchTrace.push_back(1); + EeScheduler &scheduler = runtime->eeScheduler(); + scheduler.addIrqHandler(false, 2u, kIntcHandlerPc, true, 0xCAFEu, 0u, 0u); + ctx->pc = kIrqResumePc; + scheduler.waitVSync(scheduler.currentVSyncTick()); + } - constexpr uint32_t kHandlerAddr = 0x00ABD100u; - constexpr uint32_t kVif1Ch = 0x10009000u; - constexpr uint32_t kTag0 = 0x00028000u; - constexpr uint32_t kTag1 = kTag0 + 0x20u; - - uint8_t *rdram = env.runtime.memory().getRDRAM(); - writeDmaTag(rdram, kTag0, makeDmaTag(1u, 1u, 0u, false)); // CNT - writeGuestU64(rdram, kTag0 + 0x10u, 0u); - writeGuestU64(rdram, kTag0 + 0x18u, 0u); - writeDmaTag(rdram, kTag1, makeDmaTag(0u, 7u, 0u, false)); // END - - g_dmacSendHits.store(0u, std::memory_order_relaxed); - g_dmacSendLastCause.store(0u, std::memory_order_relaxed); - g_dmacSendLastChcr.store(0u, std::memory_order_relaxed); - env.runtime.registerFunction(kHandlerAddr, &testDmacSendHandler); - - R5900Context addCtx{}; - setRegU32(addCtx, 4, 1u); - setRegU32(addCtx, 5, kHandlerAddr); - setRegU32(addCtx, 6, 0u); - setRegU32(addCtx, 7, 0u); - ps2_syscalls::AddDmacHandler(rdram, &addCtx, &env.runtime); - t.IsTrue(getRegS32(addCtx, 2) > 0, "AddDmacHandler should register VIF1 handler"); - - R5900Context enableCtx{}; - setRegU32(enableCtx, 4, 1u); - ps2_syscalls::EnableDmac(rdram, &enableCtx, &env.runtime); - t.Equals(getRegS32(enableCtx, 2), KE_OK, "EnableDmac should enable VIF1 cause"); - - R5900Context sendCtx{}; - setRegU32(sendCtx, 4, kVif1Ch); - setRegU32(sendCtx, 5, kTag0); - ps2_stubs::sceDmaSend(rdram, &sendCtx, &env.runtime); - - t.Equals(getRegS32(sendCtx, 2), 0, "sceDmaSend should succeed"); - t.Equals(g_dmacSendHits.load(std::memory_order_relaxed), 1u, "sceDmaSend should dispatch the VIF1 DMAC handler"); - t.Equals(g_dmacSendLastCause.load(std::memory_order_relaxed), 1u, "DMAC handler should observe VIF1 cause"); - t.Equals(g_dmacSendLastChcr.load(std::memory_order_relaxed) & 0x100u, 0u, "handler should see VIF1 STR cleared"); - t.Equals(g_dmacSendLastChcr.load(std::memory_order_relaxed) & 0x70000000u, 0x70000000u, "handler should see the latched END tag id"); + void schedulerIrqResume(uint8_t *, R5900Context *ctx, PS2Runtime *runtime) + { + g_dispatchTrace.push_back(3); + ctx->pc = 0u; + runtime->requestStop(); + } - cleanupRuntime(env); - }); + void schedulerISemaHandler(uint8_t *, R5900Context *ctx, PS2Runtime *runtime) + { + g_dispatchTrace.push_back(3); + runtime->eeScheduler().signalSemaphore(g_testSemaphoreId, true); + g_dispatchTrace.push_back(4); + ctx->pc = 0u; + } - tc.Run("MMIO VIF1 chain completion dispatches DMAC handler after CHCR store", [](TestCase &t) - { - notifyRuntimeStop(); - TestEnv env; - t.IsTrue(env.runtime.memory().initialize(), "runtime memory initialize should succeed"); + void schedulerISemaDriver(uint8_t *, R5900Context *ctx, PS2Runtime *runtime) + { + g_dispatchTrace.push_back(2); + ctx->pc = 0u; + runtime->eeScheduler().dispatchIrq(true, 5u); + } - constexpr uint32_t kHandlerAddr = 0x00ABD180u; - constexpr uint32_t kVif1Ch = 0x10009000u; - constexpr uint32_t kTag0 = 0x00028200u; - constexpr uint32_t kTag1 = kTag0 + 0x20u; - - uint8_t *rdram = env.runtime.memory().getRDRAM(); - writeDmaTag(rdram, kTag0, makeDmaTag(1u, 1u, 0u, false)); // CNT - writeGuestU64(rdram, kTag0 + 0x10u, 0u); - writeGuestU64(rdram, kTag0 + 0x18u, 0u); - writeDmaTag(rdram, kTag1, makeDmaTag(0u, 7u, 0u, false)); // END - - g_dmacSendHits.store(0u, std::memory_order_relaxed); - g_dmacSendLastCause.store(0u, std::memory_order_relaxed); - g_dmacSendLastChcr.store(0u, std::memory_order_relaxed); - env.runtime.registerFunction(kHandlerAddr, &testDmacSendHandler); - - R5900Context addCtx{}; - setRegU32(addCtx, 4, 1u); - setRegU32(addCtx, 5, kHandlerAddr); - setRegU32(addCtx, 6, 0u); - setRegU32(addCtx, 7, 0u); - ps2_syscalls::AddDmacHandler(rdram, &addCtx, &env.runtime); - t.IsTrue(getRegS32(addCtx, 2) > 0, "AddDmacHandler should register VIF1 handler"); - - R5900Context enableCtx{}; - setRegU32(enableCtx, 4, 1u); - ps2_syscalls::EnableDmac(rdram, &enableCtx, &env.runtime); - t.Equals(getRegS32(enableCtx, 2), KE_OK, "EnableDmac should enable VIF1 cause"); - - R5900Context storeCtx{}; - env.runtime.Store32(rdram, &storeCtx, kVif1Ch + 0x30u, kTag0); - env.runtime.Store32(rdram, &storeCtx, kVif1Ch + 0x00u, 0x185u); - - t.Equals(g_dmacSendHits.load(std::memory_order_relaxed), 1u, "CHCR store should dispatch the VIF1 DMAC handler"); - t.Equals(g_dmacSendLastCause.load(std::memory_order_relaxed), 1u, "DMAC handler should observe VIF1 cause"); - t.Equals(g_dmacSendLastChcr.load(std::memory_order_relaxed) & 0x100u, 0u, "handler should see VIF1 STR cleared"); - t.Equals(g_dmacSendLastChcr.load(std::memory_order_relaxed) & 0x70000000u, 0x70000000u, "handler should see the latched END tag id"); + void schedulerISemaWait(uint8_t *, R5900Context *ctx, PS2Runtime *runtime) + { + g_dispatchTrace.push_back(1); + EeScheduler &scheduler = runtime->eeScheduler(); + g_testSemaphoreId = scheduler.createSemaphore(0, 1, 0u, 0u); + scheduler.addIrqHandler(true, 5u, kISemaHandlerPc, true, 0u, 0u, 0u); + + EeThreadCreateParams driver{}; + driver.entry = kISemaDriverPc; + driver.stack = 0x1C000u; + driver.stackSize = 0x1000u; + driver.priority = 10; + const int driverId = scheduler.createThread(driver); + scheduler.startThread(driverId, 0u, *ctx, false); + + ctx->pc = kISemaResumePc; + scheduler.waitSemaphore(g_testSemaphoreId); + } - cleanupRuntime(env); - }); + void schedulerISemaResume(uint8_t *, R5900Context *ctx, PS2Runtime *runtime) + { + g_dispatchTrace.push_back(5); + g_resumedResult = getRegS32(*ctx, 2); + ctx->pc = 0u; + runtime->requestStop(); + } - tc.Run("native GIF DMA MMIO kick dispatches completed DMAC handler", [](TestCase &t) - { - notifyRuntimeStop(); - TestEnv env; - t.IsTrue(env.runtime.memory().initialize(), "runtime memory initialize should succeed"); + void schedulerEventProducer(uint8_t *, R5900Context *ctx, PS2Runtime *runtime) + { + g_dispatchTrace.push_back(2); + ctx->pc = 0u; + runtime->eeScheduler().setEventFlag(g_testEventFlagId, 0x6u, false); + runtime->eeScheduler().transferIfRequested(false); + } - constexpr uint32_t kHandlerAddr = 0x00ABD1C0u; - constexpr uint32_t kDStat = 0x1000E010u; - constexpr uint32_t kDPcr = 0x1000E020u; - constexpr uint32_t kTag0 = 0x00028400u; - - uint8_t *rdram = env.runtime.memory().getRDRAM(); - writeDmaTag(rdram, kTag0, makeDmaTag(1u, 7u, 0u, false)); // END - writeGuestU64(rdram, kTag0 + 0x10u, 0x1122334455667788ull); - writeGuestU64(rdram, kTag0 + 0x18u, 0x99AABBCCDDEEFF00ull); - - g_dmacSendHits.store(0u, std::memory_order_relaxed); - g_dmacSendLastCause.store(0u, std::memory_order_relaxed); - g_dmacSendLastChcr.store(0u, std::memory_order_relaxed); - env.runtime.registerFunction(kHandlerAddr, &testDmacSendHandler); - - R5900Context addCtx{}; - setRegU32(addCtx, 4, 2u); - setRegU32(addCtx, 5, kHandlerAddr); - setRegU32(addCtx, 6, 0u); - setRegU32(addCtx, 7, 0u); - ps2_syscalls::AddDmacHandler(rdram, &addCtx, &env.runtime); - t.IsTrue(getRegS32(addCtx, 2) > 0, "AddDmacHandler should register GIF handler"); - - R5900Context enableCtx{}; - setRegU32(enableCtx, 4, 2u); - ps2_syscalls::EnableDmac(rdram, &enableCtx, &env.runtime); - t.Equals(getRegS32(enableCtx, 2), KE_OK, "EnableDmac should enable GIF cause"); - - R5900Context kickCtx{}; - env.runtime.kickGifDmaChainFromMMIO(rdram, &kickCtx, 4u, 4u, kTag0, 0x105u); - - t.Equals(env.runtime.memory().readIORegister(kDPcr), 4u, "native GIF kick should preserve D_PCR write"); - t.IsTrue((env.runtime.memory().readIORegister(kDStat) & (1u << 2)) != 0u, - "native GIF kick should raise D_STAT GIF completion status"); - t.Equals(g_dmacSendHits.load(std::memory_order_relaxed), 1u, - "native GIF kick should dispatch the GIF DMAC handler"); - t.Equals(g_dmacSendLastCause.load(std::memory_order_relaxed), 2u, - "DMAC handler should observe GIF cause"); - t.Equals(g_dmacSendLastChcr.load(std::memory_order_relaxed) & 0x100u, 0u, - "handler should see GIF STR cleared"); - t.Equals(g_dmacSendLastChcr.load(std::memory_order_relaxed) & 0x70000000u, 0x70000000u, - "handler should see the latched END tag id"); + void schedulerEventWait(uint8_t *, R5900Context *ctx, PS2Runtime *runtime) + { + g_dispatchTrace.push_back(1); + EeScheduler &scheduler = runtime->eeScheduler(); + g_testEventFlagId = scheduler.createEventFlag(0u, 0u, 0u); + + EeThreadCreateParams producer{}; + producer.entry = kEventProducerPc; + producer.stack = 0x1D000u; + producer.stackSize = 0x1000u; + producer.priority = 10; + const int producerId = scheduler.createThread(producer); + scheduler.startThread(producerId, 0u, *ctx, false); + + ctx->pc = kEventResumePc; + scheduler.waitEventFlag(g_testEventFlagId, 0x2u, WEF_OR | WEF_CLEAR, kEventResultAddr); + } - cleanupRuntime(env); - }); + void schedulerEventResume(uint8_t *, R5900Context *ctx, PS2Runtime *runtime) + { + g_dispatchTrace.push_back(3); + g_resumedResult = getRegS32(*ctx, 2); + ctx->pc = 0u; + runtime->requestStop(); + } +} +void register_ps2_runtime_interrupt_tests() +{ + MiniTest::Case("PS2RuntimeInterrupt", [](TestCase &tc) + { tc.Run("negative interrupt-safe EE syscall ids dispatch", [](TestCase &t) { - notifyRuntimeStop(); TestEnv env; constexpr uint32_t kEventParamAddr = 0x1200u; @@ -684,97 +319,8 @@ void register_ps2_runtime_interrupt_tests() cleanupRuntime(env); }); - tc.Run("WaitEventFlag blocks and wakes when SetEventFlag publishes bits", [](TestCase &t) - { - notifyRuntimeStop(); - TestEnv env; - - constexpr uint32_t kParamAddr = 0x1200u; - constexpr uint32_t kResBitsAddr = 0x1300u; - - const uint32_t eventParam[3] = { - 0u, // attr - 0u, // option - 0u // init bits - }; - std::memcpy(env.rdram.data() + kParamAddr, eventParam, sizeof(eventParam)); - - R5900Context createCtx{}; - setRegU32(createCtx, 4, kParamAddr); - CreateEventFlag(env.rdram.data(), &createCtx, &env.runtime); - const int32_t eid = getRegS32(createCtx, 2); - t.IsTrue(eid > 0, "CreateEventFlag should return a valid id"); - - writeGuestU32(env.rdram.data(), kResBitsAddr, 0u); - - std::atomic waiterDone{false}; - std::atomic waiterThrew{false}; - std::atomic waiterRet{0x7FFFFFFF}; - std::atomic waiterResBits{0u}; - - std::thread waiter([&]() - { - try - { - R5900Context waitCtx{}; - setRegU32(waitCtx, 4, static_cast(eid)); - setRegU32(waitCtx, 5, 0x4u); // wait bits - setRegU32(waitCtx, 6, WEF_OR); // OR mode - setRegU32(waitCtx, 7, kResBitsAddr); - WaitEventFlag(env.rdram.data(), &waitCtx, &env.runtime); - waiterRet.store(getRegS32(waitCtx, 2), std::memory_order_relaxed); - waiterResBits.store(readGuestU32(env.rdram.data(), kResBitsAddr), std::memory_order_relaxed); - } - catch (...) - { - waiterThrew.store(true, std::memory_order_release); - } - - waiterDone.store(true, std::memory_order_release); - }); - - std::this_thread::sleep_for(std::chrono::milliseconds(20)); - t.IsFalse(waiterDone.load(std::memory_order_acquire), "WaitEventFlag should block before matching bits are set"); - - R5900Context signalCtx{}; - setRegU32(signalCtx, 4, static_cast(eid)); - setRegU32(signalCtx, 5, 0x4u); - SetEventFlag(env.rdram.data(), &signalCtx, &env.runtime); - t.Equals(getRegS32(signalCtx, 2), KE_OK, "SetEventFlag should succeed"); - - const bool woke = waitUntil([&]() { - return waiterDone.load(std::memory_order_acquire); - }, std::chrono::milliseconds(300)); - if (!woke) - { - // Force unblock for deterministic test cleanup. - R5900Context deleteCtx{}; - setRegU32(deleteCtx, 4, static_cast(eid)); - DeleteEventFlag(env.rdram.data(), &deleteCtx, &env.runtime); - } - - if (waiter.joinable()) - { - waiter.join(); - } - - t.IsFalse(waiterThrew.load(std::memory_order_acquire), - "WaitEventFlag waiter thread should not throw"); - t.IsTrue(woke, "WaitEventFlag should wake after SetEventFlag publishes matching bits"); - t.Equals(waiterRet.load(std::memory_order_relaxed), KE_OK, "waiter should return KE_OK"); - t.IsTrue((waiterResBits.load(std::memory_order_relaxed) & 0x4u) != 0u, - "waiter result bits should include published bit"); - - R5900Context deleteCtx{}; - setRegU32(deleteCtx, 4, static_cast(eid)); - DeleteEventFlag(env.rdram.data(), &deleteCtx, &env.runtime); - - cleanupRuntime(env); - }); - tc.Run("PollEventFlag WEF_CLEAR clears only matched bits", [](TestCase &t) { - notifyRuntimeStop(); TestEnv env; constexpr uint32_t kParamAddr = 0x1400u; @@ -830,60 +376,146 @@ void register_ps2_runtime_interrupt_tests() cleanupRuntime(env); }); - tc.Run("WaitVSyncTick returns when runtime stop is requested", [](TestCase &t) + tc.Run("VBlank deadline resumes the waiter and publishes flag tick and FIELD atomically", [](TestCase &t) + { + TestEnv env; + t.IsTrue(env.runtime.memory().initialize(), "runtime memory initialize should succeed"); + env.runtime.registerFunction(kVSyncWaitPc, schedulerVSyncWait); + env.runtime.registerFunction(kVSyncResumePc, schedulerVSyncResume); + + g_resumedResult = -1; + g_vsyncFlag = 0u; + g_vsyncTick = 0u; + g_vsyncCsr = 0u; + R5900Context mainContext{}; + mainContext.pc = kVSyncWaitPc; + env.runtime.eeScheduler().reset(env.rdram.data(), mainContext); + env.runtime.eeScheduler().run(); + + t.Equals(g_vsyncFlag, 1u, "VBlank start should set the registered guest flag"); + t.Equals(g_vsyncTick, 1ull, "the first centralized VBlank deadline should publish tick one"); + t.Equals(g_resumedResult, 0, "the first VBlank field should return even-field parity"); + t.Equals(g_vsyncCsr & 0x2000ull, 0x2000ull, + "the first VBlank should publish GS CSR.FIELD before resuming guest code"); + }); + + tc.Run("VBlank IRQ invocation completes before the resumed base context", [](TestCase &t) + { + TestEnv env; + env.runtime.registerFunction(kIrqWaitPc, schedulerIrqWait); + env.runtime.registerFunction(kIrqResumePc, schedulerIrqResume); + env.runtime.registerFunction(kIntcHandlerPc, schedulerIntcHandler); + + g_dispatchTrace.clear(); + g_lastIntcArg.store(0u, std::memory_order_relaxed); + R5900Context mainContext{}; + mainContext.pc = kIrqWaitPc; + env.runtime.eeScheduler().reset(env.rdram.data(), mainContext); + env.runtime.eeScheduler().run(); + + const std::vector expected{1, 2, 3}; + t.IsTrue(g_dispatchTrace == expected, + "the dispatcher should run wait, IRQ frame, then the resumed base context in exact order"); + t.Equals(g_lastIntcArg.load(std::memory_order_relaxed), 0xCAFEu, + "the IRQ frame should receive its registered argument"); + }); + + tc.Run("iSignalSema defers selection until IRQ return", [](TestCase &t) { - notifyRuntimeStop(); TestEnv env; + env.runtime.registerFunction(kISemaWaitPc, schedulerISemaWait); + env.runtime.registerFunction(kISemaResumePc, schedulerISemaResume); + env.runtime.registerFunction(kISemaDriverPc, schedulerISemaDriver); + env.runtime.registerFunction(kISemaHandlerPc, schedulerISemaHandler); + + g_dispatchTrace.clear(); + g_resumedResult = -1; + R5900Context mainContext{}; + mainContext.pc = kISemaWaitPc; + env.runtime.eeScheduler().reset(env.rdram.data(), mainContext); + env.runtime.eeScheduler().run(); + + const std::vector expected{1, 2, 3, 4, 5}; + t.IsTrue(g_dispatchTrace == expected, + "iSignalSema should make the waiter ready but finish the IRQ frame before selecting it"); + t.Equals(g_resumedResult, g_testSemaphoreId, + "the resumed waiter should receive the semaphore id from the direct FIFO handoff"); + const EeSemaphore *semaphore = env.runtime.eeScheduler().semaphore(g_testSemaphoreId); + t.IsTrue(semaphore != nullptr, "the signaled semaphore should still exist"); + if (semaphore) + { + t.Equals(semaphore->count, 0, "direct handoff must not increment the semaphore count"); + t.Equals(static_cast(semaphore->waiters.size()), 0u, + "the awakened waiter must be removed from the semaphore queue"); + } + }); - std::atomic waiterDone{false}; - std::atomic waiterThrew{false}; - std::thread waiter([&]() + tc.Run("event-flag completion writes observed bits before strict-priority resume", [](TestCase &t) + { + TestEnv env; + env.runtime.registerFunction(kEventWaitPc, schedulerEventWait); + env.runtime.registerFunction(kEventResumePc, schedulerEventResume); + env.runtime.registerFunction(kEventProducerPc, schedulerEventProducer); + + g_dispatchTrace.clear(); + g_resumedResult = -1; + R5900Context mainContext{}; + mainContext.pc = kEventWaitPc; + env.runtime.eeScheduler().reset(env.rdram.data(), mainContext); + env.runtime.eeScheduler().run(); + + const std::vector expected{1, 2, 3}; + t.IsTrue(g_dispatchTrace == expected, + "the higher-priority event waiter should resume at the producer scheduling point"); + t.Equals(g_resumedResult, KE_OK, "the resumed event waiter should receive KE_OK"); + t.Equals(readGuestU32(env.rdram.data(), kEventResultAddr), 0x6u, + "the event output should contain the bits observed before clear mode is applied"); + const EeEventFlag *flag = env.runtime.eeScheduler().eventFlag(g_testEventFlagId); + t.IsTrue(flag != nullptr, "the event flag should still exist"); + if (flag) + { + t.Equals(flag->bits, 0x4u, "WEF_CLEAR should remove only the requested matched bit"); + } + }); + + tc.Run("scheduler stop wakes an idle VSync wait without a timeout", [](TestCase &t) + { + TestEnv env; + env.runtime.registerFunction(kIdleVSyncWaitPc, idleVSyncWait); + + R5900Context mainContext{}; + mainContext.pc = kIdleVSyncWaitPc; + std::atomic schedulerDone{false}; + std::atomic schedulerThrew{false}; + std::thread gameThread([&]() { try { - WaitVSyncTick(env.rdram.data(), &env.runtime); + env.runtime.eeScheduler().reset(env.rdram.data(), mainContext); + env.runtime.eeScheduler().run(); } catch (...) { - waiterThrew.store(true, std::memory_order_release); + schedulerThrew.store(true, std::memory_order_release); } - waiterDone.store(true, std::memory_order_release); + schedulerDone.store(true, std::memory_order_release); }); - std::this_thread::sleep_for(std::chrono::milliseconds(2)); - env.runtime.requestStop(); - - bool wokeOnStop = waitUntil([&]() { - return waiterDone.load(std::memory_order_acquire); + const bool becameIdle = waitUntil([&]() { + const EeKernelSnapshot snapshot = env.runtime.eeScheduler().snapshot(); + return snapshot.runningThreadId == 0 && + !snapshot.threads.empty() && + snapshot.threads.front().waitReason == EeWaitReason::VSync; }, std::chrono::milliseconds(80)); - if (!wokeOnStop) - { - // Fallback wake-up for deterministic cleanup: one extra tick on fresh runtime. - TestEnv wakeEnv; - R5900Context setCtx{}; - constexpr uint32_t kWakeFlagAddr = 0x1500u; - constexpr uint32_t kWakeTickAddr = 0x1510u; - setRegU32(setCtx, 4, kWakeFlagAddr); - setRegU32(setCtx, 5, kWakeTickAddr); - (void)callSyscall(0x73u, wakeEnv.rdram.data(), &setCtx, &wakeEnv.runtime); - (void)waitUntil([&]() { - return readGuestU64(wakeEnv.rdram.data(), kWakeTickAddr) > 0u; - }, std::chrono::milliseconds(300)); - wakeEnv.runtime.requestStop(); - wokeOnStop = waitUntil([&]() { - return waiterDone.load(std::memory_order_acquire); - }, std::chrono::milliseconds(80)); - } - - if (waiter.joinable()) - { - waiter.join(); - } + env.runtime.requestStop(); + gameThread.join(); - t.IsFalse(waiterThrew.load(std::memory_order_acquire), - "WaitVSyncTick waiter thread should not throw"); - t.IsTrue(wokeOnStop, "WaitVSyncTick waiter should unblock when runtime is stopping"); + t.IsTrue(becameIdle, "VSync wait should leave the sole guest thread waiting"); + t.IsTrue(schedulerDone.load(std::memory_order_acquire), + "requestStop should wake the scheduler's event wait"); + t.IsFalse(schedulerThrew.load(std::memory_order_acquire), + "the scheduler stop path should not throw"); cleanupRuntime(env); }); diff --git a/ps2xTest/src/ps2_runtime_kernel_tests.cpp b/ps2xTest/src/ps2_runtime_kernel_tests.cpp index 0b75c063f..e552df699 100644 --- a/ps2xTest/src/ps2_runtime_kernel_tests.cpp +++ b/ps2xTest/src/ps2_runtime_kernel_tests.cpp @@ -3,28 +3,16 @@ #include "ps2_runtime_macros.h" #include "ps2_syscalls.h" #include "ps2_stubs.h" +#include "runtime/ee_scheduler.h" -#include #include +#include #include #include #include #include #include -// g_currentThreadId is an `inline thread_local int` defined in the kernel's -// internal State.h (ps2xRuntime/.../Kernel/Syscalls/Helpers/State.h, default 1). -// Only sub-case H of the semaphore-return-value test reaches into it: the worker -// thread sets its own guest tid so ReleaseWaitThread(tid) can target the exact -// ThreadInfo that the worker's WaitSema put into THS_WAIT. -// -// ODR-safety: this declaration MUST stay byte-for-byte type-compatible with that -// definition (`thread_local int`, same name, no namespace). It is an `extern` -// declaration of an existing inline thread_local, NOT a second definition, so the -// linker binds to the runtime's instance. If the runtime ever changes the type or -// moves it into a namespace, update this line in lockstep or the build will break. -extern thread_local int g_currentThreadId; - using namespace ps2_syscalls; namespace @@ -51,11 +39,7 @@ namespace constexpr uint32_t TSW_SEMA = 2u; constexpr uint32_t TSW_EVENT = 3u; - constexpr uint32_t K_EVENT_WAIT_READY_ADDR = 0x1800u; - constexpr uint32_t K_EVENT_WAIT_GATE_ADDR = 0x1804u; - constexpr uint32_t K_TERMINATE_SEMA_WAIT_READY_ADDR = 0x1810u; - - struct EeThreadStatus + struct EeThreadStatusAbi { int32_t status; uint32_t func; @@ -71,6 +55,19 @@ namespace uint32_t wakeupCount; }; + struct EeThreadCreateAbi + { + int32_t status; + uint32_t func; + uint32_t stack; + int32_t stack_size; + uint32_t gp_reg; + int32_t initial_priority; + int32_t current_priority; + uint32_t attr; + uint32_t option; + }; + struct EeSemaStatus { int32_t count; @@ -81,7 +78,8 @@ namespace uint32_t option; }; - static_assert(sizeof(EeThreadStatus) == 0x30u, "Unexpected ee_thread_status_t size."); + static_assert(sizeof(EeThreadStatusAbi) == 0x30u, "Unexpected ee_thread_status_t size."); + static_assert(sizeof(EeThreadCreateAbi) == 0x24u, "Unexpected ee_thread_t size."); static_assert(sizeof(EeSemaStatus) == 0x18u, "Unexpected ee_sema_t size."); void setRegU32(R5900Context &ctx, int reg, uint32_t value) @@ -114,21 +112,6 @@ namespace return value; } - template - bool waitUntil(Predicate pred, std::chrono::milliseconds timeout) - { - const auto deadline = std::chrono::steady_clock::now() + timeout; - while (std::chrono::steady_clock::now() < deadline) - { - if (pred()) - { - return true; - } - std::this_thread::sleep_for(std::chrono::milliseconds(1)); - } - return pred(); - } - bool callSyscall(uint32_t syscallNumber, uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { return dispatchNumericSyscall(syscallNumber, rdram, ctx, runtime); @@ -189,801 +172,698 @@ namespace ctx->pc = ::getRegU32(ctx, 31); } - void waitEventAfterSuspendHandler(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) + constexpr uint32_t K_OVERRIDE_ENTRY = 0x300500u; + constexpr uint32_t K_OVERRIDE_RESUME = 0x300504u; + constexpr uint32_t K_OVERRIDE_BLOCK_ENTRY = 0x300510u; + constexpr uint32_t K_OVERRIDE_BLOCK_HANDLER = 0x300520u; + constexpr uint32_t K_OVERRIDE_BLOCK_HANDLER_RESUME = 0x300524u; + constexpr uint32_t K_OVERRIDE_BLOCK_DRIVER = 0x300530u; + constexpr uint32_t K_OVERRIDE_BLOCK_BASE_RESUME = 0x300540u; + constexpr uint32_t K_EXIT_MAIN = 0x300600u; + constexpr uint32_t K_EXIT_HANDLER_A = 0x300610u; + constexpr uint32_t K_EXIT_HANDLER_B = 0x300620u; + constexpr uint32_t K_EXIT_OBSERVER = 0x300630u; + uint32_t gOverrideSyscall = 0u; + R5900Context gOverrideResult{}; + std::vector gInvocationTrace; + + void schedulerOverrideEntry(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { - if (!rdram || !ctx) - { - return; - } - - writeGuestU32(rdram, K_EVENT_WAIT_READY_ADDR, 1u); - while (readGuestU32(rdram, K_EVENT_WAIT_GATE_ADDR) == 0u) - { - if (runtime && runtime->isStopRequested()) - { - ctx->pc = 0u; - return; - } - std::this_thread::yield(); - } + ctx->pc = K_OVERRIDE_RESUME; + runtime->handleSyscall(rdram, ctx, gOverrideSyscall); + } - const uint32_t eid = ::getRegU32(ctx, 4); - setRegU32(*ctx, 4, eid); - setRegU32(*ctx, 5, 0x4u); - setRegU32(*ctx, 6, 1u); - setRegU32(*ctx, 7, 0u); - WaitEventFlag(rdram, ctx, runtime); + void schedulerOverrideResume(uint8_t *, R5900Context *ctx, PS2Runtime *runtime) + { + gOverrideResult = *ctx; ctx->pc = 0u; + runtime->requestStop(); } - void waitSemaUntilTerminatedHandler(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) + void schedulerBlockingOverrideEntry(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { - if (!rdram || !ctx) - { - return; - } + gInvocationTrace.push_back(1); + EeThreadCreateParams driver{}; + driver.entry = K_OVERRIDE_BLOCK_DRIVER; + driver.stack = 0x1E000u; + driver.stackSize = 0x1000u; + driver.priority = 10; + const int driverId = runtime->eeScheduler().createThread(driver); + runtime->eeScheduler().startThread(driverId, 0u, *ctx, false); + ctx->pc = K_OVERRIDE_BLOCK_BASE_RESUME; + runtime->handleSyscall(rdram, ctx, gOverrideSyscall); + } - writeGuestU32(rdram, K_TERMINATE_SEMA_WAIT_READY_ADDR, 1u); - WaitSema(rdram, ctx, runtime); - ctx->pc = 0u; + void schedulerBlockingOverrideHandler(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) + { + gInvocationTrace.push_back(2); + ctx->pc = K_OVERRIDE_BLOCK_HANDLER_RESUME; + SleepThread(rdram, ctx, runtime); } - void alarmNoopHandler(uint8_t *, R5900Context *ctx, PS2Runtime *) + void schedulerBlockingOverrideHandlerResume(uint8_t *, R5900Context *ctx, PS2Runtime *) { + gInvocationTrace.push_back(4); + setReturnU32(ctx, 0xB10C0EDu); ctx->pc = 0u; } - struct TestEnv + void schedulerBlockingOverrideDriver(uint8_t *, R5900Context *ctx, PS2Runtime *runtime) { - std::vector rdram; - R5900Context ctx{}; - PS2Runtime runtime; + gInvocationTrace.push_back(3); + ctx->pc = 0u; + runtime->eeScheduler().wakeupThread(EeScheduler::kMainThreadId, false); + runtime->eeScheduler().transferIfRequested(false); + } - TestEnv() : rdram(PS2_RAM_SIZE, 0) - { - std::memset(&ctx, 0, sizeof(ctx)); - } - }; -} + void schedulerBlockingOverrideBaseResume(uint8_t *, R5900Context *ctx, PS2Runtime *runtime) + { + gInvocationTrace.push_back(5); + gOverrideResult = *ctx; + ctx->pc = 0u; + runtime->requestStop(); + } -void register_ps2_runtime_kernel_tests() -{ - MiniTest::Case("PS2RuntimeKernel", [](TestCase &tc) + void schedulerExitHandlerA(uint8_t *, R5900Context *ctx, PS2Runtime *) { - tc.Run("thread create/refer/delete follows EE status layout", [](TestCase &t) - { - TestEnv env; + gInvocationTrace.push_back(getRegS32(*ctx, 4)); + ctx->pc = 0u; + } - const uint32_t threadParam[7] = { - 0x00000002u, // attr - 0x00200000u, // entry - 0x00300000u, // stack - 0x00000800u, // stack size - 0x00120000u, // gp - 5u, // initial priority - 0xABCD0001u // option - }; + void schedulerExitHandlerB(uint8_t *, R5900Context *ctx, PS2Runtime *) + { + gInvocationTrace.push_back(getRegS32(*ctx, 4)); + ctx->pc = 0u; + } - writeGuestWords(env.rdram.data(), K_PARAM_ADDR, threadParam, std::size(threadParam)); - setRegU32(env.ctx, 4, K_PARAM_ADDR); - CreateThread(env.rdram.data(), &env.ctx, &env.runtime); + void schedulerExitObserver(uint8_t *, R5900Context *ctx, PS2Runtime *runtime) + { + const GuestThread *main = runtime->eeScheduler().thread(EeScheduler::kMainThreadId); + gInvocationTrace.push_back(main && main->status == EeThreadStatus::Dormant ? 40 : -40); + ctx->pc = 0u; + runtime->requestStop(); + } - const int32_t tid = getRegS32(env.ctx, 2); - t.IsTrue(tid >= 2, "CreateThread should return a valid non-main thread id"); - - setRegU32(env.ctx, 4, static_cast(tid)); - setRegU32(env.ctx, 5, K_STATUS_ADDR); - ReferThreadStatus(env.rdram.data(), &env.ctx, &env.runtime); - t.Equals(getRegS32(env.ctx, 2), KE_OK, "ReferThreadStatus should succeed for created thread"); - - EeThreadStatus status{}; - std::memcpy(&status, env.rdram.data() + K_STATUS_ADDR, sizeof(status)); - t.Equals(status.status, THS_DORMANT, "new thread should be dormant before StartThread"); - t.Equals(status.func, threadParam[1], "status.func should match entry"); - t.Equals(status.stack, threadParam[2], "status.stack should match configured stack"); - t.Equals(status.stack_size, static_cast(threadParam[3]), "status.stack_size should match thread param"); - t.Equals(status.gp_reg, threadParam[4], "status.gp_reg should match configured gp"); - t.Equals(status.initial_priority, 5, "status.initial_priority should match thread param"); - t.Equals(status.current_priority, 5, "status.current_priority should start at initial priority"); - t.Equals(status.attr, threadParam[0], "status.attr should match thread param"); - t.Equals(status.option, threadParam[6], "status.option should match thread param"); - - setRegU32(env.ctx, 4, static_cast(tid)); - DeleteThread(env.rdram.data(), &env.ctx, &env.runtime); - t.Equals(getRegS32(env.ctx, 2), KE_OK, "DeleteThread should succeed for dormant thread"); + void schedulerExitMain(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) + { + gInvocationTrace.push_back(10); + EeThreadCreateParams observer{}; + observer.entry = K_EXIT_OBSERVER; + observer.stack = 0x1F000u; + observer.stackSize = 0x1000u; + observer.priority = 10; + const int observerId = runtime->eeScheduler().createThread(observer); + runtime->eeScheduler().startThread(observerId, 0u, *ctx, false); + runtime->addEeExitHandler(EeScheduler::kMainThreadId, K_EXIT_HANDLER_A, 20u); + runtime->addEeExitHandler(EeScheduler::kMainThreadId, K_EXIT_HANDLER_B, 30u); + ExitThread(rdram, ctx, runtime); + } - setRegU32(env.ctx, 4, static_cast(tid)); - setRegU32(env.ctx, 5, K_STATUS_ADDR); - ReferThreadStatus(env.rdram.data(), &env.ctx, &env.runtime); - t.Equals(getRegS32(env.ctx, 2), KE_UNKNOWN_THID, "deleted thread id should no longer be referable"); - }); + void alarmNoopHandler(uint8_t *, R5900Context *ctx, PS2Runtime *) + { + ctx->pc = 0u; + } - tc.Run("start thread validates target and entry registration", [](TestCase &t) + constexpr uint32_t K_SCHED_MAIN = 0x300000u; + constexpr uint32_t K_SCHED_A = 0x300100u; + constexpr uint32_t K_SCHED_A_RESUME = 0x300104u; + constexpr uint32_t K_SCHED_B = 0x300200u; + constexpr uint32_t K_SCHED_B_RESUME = 0x300204u; + constexpr uint32_t K_SCHED_HIGH = 0x300300u; + constexpr uint32_t K_SCHED_SIGNAL = 0x300400u; + constexpr uint32_t K_SCHED_SIGNAL_RESUME = 0x300404u; + + std::vector *gSchedulerTrace = nullptr; + int gSchedulerCreatedId = 0; + int gSchedulerSemaphoreId = 0; + int gSchedulerWaitResultA = 0; + int gSchedulerWaitResultB = 0; + std::atomic gGuestActive{0}; + std::atomic gGuestMaxActive{0}; + std::atomic gGuestExecutorHash{0u}; + std::atomic gGuestExecutorMismatch{false}; + std::atomic gGuestExecutingFlagMissing{false}; + + struct GuestExecutionProbe + { + explicit GuestExecutionProbe(PS2Runtime *runtime) { - TestEnv env; - - const uint32_t threadParam[7] = { - 0u, - 0x00250000u, // entry not registered in runtime - 0x00300000u, - 0x00000400u, - 0x00110000u, - 8u, - 0u - }; + const int active = gGuestActive.fetch_add(1, std::memory_order_acq_rel) + 1; + int maximum = gGuestMaxActive.load(std::memory_order_acquire); + while (active > maximum && + !gGuestMaxActive.compare_exchange_weak(maximum, active, std::memory_order_acq_rel)) + { + } + const size_t hash = std::hash{}(std::this_thread::get_id()); + size_t expected = 0u; + if (!gGuestExecutorHash.compare_exchange_strong(expected, hash, std::memory_order_acq_rel) && + expected != hash) + { + gGuestExecutorMismatch.store(true, std::memory_order_release); + } + if (!runtime->eeScheduler().isExecutingGuest()) + { + gGuestExecutingFlagMissing.store(true, std::memory_order_release); + } + } - writeGuestWords(env.rdram.data(), K_PARAM_ADDR, threadParam, std::size(threadParam)); - setRegU32(env.ctx, 4, K_PARAM_ADDR); - CreateThread(env.rdram.data(), &env.ctx, &env.runtime); - const int32_t tid = getRegS32(env.ctx, 2); - t.IsTrue(tid >= 2, "CreateThread should return an id before StartThread check"); + ~GuestExecutionProbe() + { + gGuestActive.fetch_sub(1, std::memory_order_acq_rel); + } + }; - setRegU32(env.ctx, 4, static_cast(tid)); - setRegU32(env.ctx, 5, 0x12345678u); - StartThread(env.rdram.data(), &env.ctx, &env.runtime); - t.Equals(getRegS32(env.ctx, 2), KE_ERROR, "StartThread should fail when entry is not registered"); + void schedulerMainExit(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) + { + GuestExecutionProbe probe(runtime); + gSchedulerTrace->push_back(1); + ExitThread(rdram, ctx, runtime); + } - setRegU32(env.ctx, 4, static_cast(tid)); - setRegU32(env.ctx, 5, K_STATUS_ADDR); - ReferThreadStatus(env.rdram.data(), &env.ctx, &env.runtime); - t.Equals(getRegS32(env.ctx, 2), KE_OK, "ReferThreadStatus should still succeed after failed StartThread"); + void schedulerTraceA(uint8_t *, R5900Context *ctx, PS2Runtime *runtime) + { + GuestExecutionProbe probe(runtime); + gSchedulerTrace->push_back(10); + ctx->pc = 0u; + if (gSchedulerTrace->size() >= 4u) + { + runtime->requestStop(); + } + } - EeThreadStatus status{}; - std::memcpy(&status, env.rdram.data() + K_STATUS_ADDR, sizeof(status)); - t.Equals(status.status, THS_DORMANT, "thread should remain dormant when StartThread fails early"); + void schedulerTraceB(uint8_t *, R5900Context *ctx, PS2Runtime *runtime) + { + GuestExecutionProbe probe(runtime); + gSchedulerTrace->push_back(20); + ctx->pc = 0u; + if (gSchedulerTrace->size() >= 4u) + { + runtime->requestStop(); + } + } - setRegU32(env.ctx, 4, static_cast(tid)); - DeleteThread(env.rdram.data(), &env.ctx, &env.runtime); - t.Equals(getRegS32(env.ctx, 2), KE_OK, "DeleteThread should clean up failed-start thread"); - }); + void schedulerRotateA(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) + { + gSchedulerTrace->push_back(10); + ctx->pc = K_SCHED_A_RESUME; + setRegU32(*ctx, 4, 5u); + RotateThreadReadyQueue(rdram, ctx, runtime); + } - tc.Run("thread id and wakeup guard rails match kernel-style errors", [](TestCase &t) - { - TestEnv env; + void schedulerRotateAResume(uint8_t *, R5900Context *ctx, PS2Runtime *runtime) + { + gSchedulerTrace->push_back(11); + ctx->pc = 0u; + runtime->requestStop(); + } - GetThreadId(env.rdram.data(), &env.ctx, &env.runtime); - const int32_t selfTid = getRegS32(env.ctx, 2); - t.IsTrue(selfTid > 0, "GetThreadId should return a positive thread id"); + void schedulerPreemptLow(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) + { + gSchedulerTrace->push_back(30); + ctx->pc = K_SCHED_A_RESUME; + setRegU32(*ctx, 4, static_cast(gSchedulerCreatedId)); + setRegU32(*ctx, 5, 0u); + StartThread(rdram, ctx, runtime); + } - setRegU32(env.ctx, 4, 0u); - WakeupThread(env.rdram.data(), &env.ctx, &env.runtime); - t.Equals(getRegS32(env.ctx, 2), KE_ILLEGAL_THID, "WakeupThread(TH_SELF/0) should be illegal"); + void schedulerPreemptLowResume(uint8_t *, R5900Context *ctx, PS2Runtime *runtime) + { + gSchedulerTrace->push_back(31); + ctx->pc = 0u; + runtime->requestStop(); + } - setRegU32(env.ctx, 4, static_cast(selfTid)); - WakeupThread(env.rdram.data(), &env.ctx, &env.runtime); - t.Equals(getRegS32(env.ctx, 2), KE_ILLEGAL_THID, "WakeupThread(self) should be illegal"); + void schedulerHigh(uint8_t *, R5900Context *ctx, PS2Runtime *) + { + gSchedulerTrace->push_back(5); + ctx->pc = 0u; + } - setRegU32(env.ctx, 4, 0u); - iCancelWakeupThread(env.rdram.data(), &env.ctx, &env.runtime); - t.Equals(getRegS32(env.ctx, 2), KE_ILLEGAL_THID, "iCancelWakeupThread(0) should be illegal"); + void schedulerWaitA(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) + { + if (ctx->pc == K_SCHED_A) + { + gSchedulerTrace->push_back(10); + ctx->pc = K_SCHED_A_RESUME; + setRegU32(*ctx, 4, static_cast(gSchedulerSemaphoreId)); + WaitSema(rdram, ctx, runtime); + return; + } + gSchedulerWaitResultA = getRegS32(*ctx, 2); + gSchedulerTrace->push_back(11); + ctx->pc = 0u; + } - setRegU32(env.ctx, 4, 0u); - CancelWakeupThread(env.rdram.data(), &env.ctx, &env.runtime); - t.Equals(getRegS32(env.ctx, 2), KE_OK, "CancelWakeupThread(TH_SELF) should return previous count (0)"); - }); + void schedulerWaitB(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) + { + if (ctx->pc == K_SCHED_B) + { + gSchedulerTrace->push_back(20); + ctx->pc = K_SCHED_B_RESUME; + setRegU32(*ctx, 4, static_cast(gSchedulerSemaphoreId)); + WaitSema(rdram, ctx, runtime); + return; + } + gSchedulerWaitResultB = getRegS32(*ctx, 2); + gSchedulerTrace->push_back(21); + ctx->pc = 0u; + runtime->requestStop(); + } - tc.Run("semaphore EE layout covers poll, signal overflow, and status", [](TestCase &t) + void schedulerSignalTwice(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) + { + if (ctx->pc == K_SCHED_SIGNAL) { - TestEnv env; + gSchedulerTrace->push_back(30); + ctx->pc = K_SCHED_SIGNAL_RESUME; + setRegU32(*ctx, 4, static_cast(gSchedulerSemaphoreId)); + SignalSema(rdram, ctx, runtime); + return; + } + gSchedulerTrace->push_back(31); + setRegU32(*ctx, 4, static_cast(gSchedulerSemaphoreId)); + SignalSema(rdram, ctx, runtime); + ctx->pc = 0u; + runtime->requestStop(); + } - const uint32_t semaParam[6] = { - 0u, // count (unused by runtime decode) - 2u, // max_count - 1u, // init_count - 0u, // wait_threads - 0x11u, // attr - 0x00202020u // option - }; + constexpr uint32_t K_EVENT_FIFO_MAIN = 0x301000u; + constexpr uint32_t K_EVENT_FIFO_A = 0x301010u; + constexpr uint32_t K_EVENT_FIFO_A_RESUME = 0x301014u; + constexpr uint32_t K_EVENT_FIFO_B = 0x301020u; + constexpr uint32_t K_EVENT_FIFO_B_RESUME = 0x301024u; + constexpr uint32_t K_EVENT_FIFO_SIGNAL = 0x301030u; + constexpr uint32_t K_EVENT_FIFO_SIGNAL_AGAIN = 0x301034u; + constexpr uint32_t K_EVENT_FIFO_DONE = 0x301038u; + constexpr uint32_t K_EVENT_FIFO_RESULT_A = 0x1A00u; + constexpr uint32_t K_EVENT_FIFO_RESULT_B = 0x1A04u; + constexpr uint32_t WEF_OR = 0x01u; + constexpr uint32_t WEF_CLEAR = 0x10u; + constexpr uint32_t WEF_CLEAR_ALL = 0x20u; + int gEventFifoId = 0; + std::vector gEventFifoTrace; + + void schedulerEventFifoWaitA(uint8_t *, R5900Context *ctx, PS2Runtime *runtime) + { + if (ctx->pc == K_EVENT_FIFO_A) + { + gEventFifoTrace.push_back(1); + ctx->pc = K_EVENT_FIFO_A_RESUME; + runtime->eeScheduler().waitEventFlag(gEventFifoId, 1u, WEF_OR | WEF_CLEAR, + K_EVENT_FIFO_RESULT_A); + } + gEventFifoTrace.push_back(4); + ctx->pc = 0u; + } - writeGuestWords(env.rdram.data(), K_PARAM_ADDR, semaParam, std::size(semaParam)); - setRegU32(env.ctx, 4, K_PARAM_ADDR); - CreateSema(env.rdram.data(), &env.ctx, &env.runtime); - const int32_t sid = getRegS32(env.ctx, 2); - t.IsTrue(sid > 0, "CreateSema should return positive semaphore id"); - - setRegU32(env.ctx, 4, static_cast(sid)); - setRegU32(env.ctx, 5, K_STATUS_ADDR); - ReferSemaStatus(env.rdram.data(), &env.ctx, &env.runtime); - t.Equals(getRegS32(env.ctx, 2), KE_OK, "ReferSemaStatus should succeed for valid semaphore"); - - EeSemaStatus semaStatus{}; - std::memcpy(&semaStatus, env.rdram.data() + K_STATUS_ADDR, sizeof(semaStatus)); - t.Equals(semaStatus.count, 1, "initial semaphore count should match init_count"); - t.Equals(semaStatus.max_count, 2, "max_count should match CreateSema params"); - t.Equals(semaStatus.init_count, 1, "init_count should be preserved"); - t.Equals(semaStatus.attr, semaParam[4], "attr should be preserved"); - t.Equals(semaStatus.option, semaParam[5], "option should be preserved"); - - setRegU32(env.ctx, 4, static_cast(sid)); - PollSema(env.rdram.data(), &env.ctx, &env.runtime); - t.Equals(getRegS32(env.ctx, 2), sid, "PollSema should return sid when consuming one available token"); + void schedulerEventFifoWaitB(uint8_t *, R5900Context *ctx, PS2Runtime *runtime) + { + if (ctx->pc == K_EVENT_FIFO_B) + { + gEventFifoTrace.push_back(2); + ctx->pc = K_EVENT_FIFO_B_RESUME; + runtime->eeScheduler().waitEventFlag(gEventFifoId, 1u, WEF_OR | WEF_CLEAR, + K_EVENT_FIFO_RESULT_B); + } + gEventFifoTrace.push_back(6); + ctx->pc = 0u; + } - setRegU32(env.ctx, 4, static_cast(sid)); - PollSema(env.rdram.data(), &env.ctx, &env.runtime); - t.Equals(getRegS32(env.ctx, 2), KE_SEMA_ZERO, "PollSema should fail when count is zero"); + void schedulerEventFifoSignal(uint8_t *, R5900Context *ctx, PS2Runtime *runtime) + { + gEventFifoTrace.push_back(3); + ctx->pc = K_EVENT_FIFO_SIGNAL_AGAIN; + runtime->eeScheduler().setEventFlag(gEventFifoId, 1u, false); + runtime->eeScheduler().transferIfRequested(false); + } - setRegU32(env.ctx, 4, static_cast(sid)); - SignalSema(env.rdram.data(), &env.ctx, &env.runtime); - t.Equals(getRegS32(env.ctx, 2), sid, "SignalSema should return sid when incrementing count below max"); + void schedulerEventFifoSignalAgain(uint8_t *, R5900Context *ctx, PS2Runtime *runtime) + { + gEventFifoTrace.push_back(5); + ctx->pc = K_EVENT_FIFO_DONE; + runtime->eeScheduler().setEventFlag(gEventFifoId, 1u, false); + runtime->eeScheduler().transferIfRequested(false); + } - setRegU32(env.ctx, 4, static_cast(sid)); - SignalSema(env.rdram.data(), &env.ctx, &env.runtime); - t.Equals(getRegS32(env.ctx, 2), sid, "SignalSema should return sid when incrementing up to max"); + void schedulerEventFifoDone(uint8_t *, R5900Context *ctx, PS2Runtime *runtime) + { + gEventFifoTrace.push_back(7); + ctx->pc = 0u; + runtime->requestStop(); + } - setRegU32(env.ctx, 4, static_cast(sid)); - SignalSema(env.rdram.data(), &env.ctx, &env.runtime); - t.Equals(getRegS32(env.ctx, 2), KE_SEMA_OVF, "SignalSema should report overflow at max_count"); + void schedulerEventFifoMain(uint8_t *, R5900Context *ctx, PS2Runtime *runtime) + { + EeScheduler &scheduler = runtime->eeScheduler(); + gEventFifoId = scheduler.createEventFlag(0u, 0x02u, 0u); + const auto create = [&](uint32_t entry, uint32_t stack, int priority) + { + EeThreadCreateParams params{}; + params.entry = entry; + params.stack = stack; + params.stackSize = 0x800u; + params.priority = priority; + const int id = scheduler.createThread(params); + scheduler.startThread(id, 0u, *ctx, false); + }; + create(K_EVENT_FIFO_A, 0x21000u, 5); + create(K_EVENT_FIFO_B, 0x22000u, 5); + create(K_EVENT_FIFO_SIGNAL, 0x23000u, 10); + ctx->pc = 0u; + } - setRegU32(env.ctx, 4, static_cast(sid)); - DeleteSema(env.rdram.data(), &env.ctx, &env.runtime); - t.Equals(getRegS32(env.ctx, 2), sid, "DeleteSema should return sid for existing semaphore"); + struct TestEnv + { + std::vector rdram; + R5900Context ctx{}; + PS2Runtime runtime; - setRegU32(env.ctx, 4, static_cast(sid)); - PollSema(env.rdram.data(), &env.ctx, &env.runtime); - t.Equals(getRegS32(env.ctx, 2), KE_UNKNOWN_SEMID, "deleted semaphore id should be rejected"); - }); + TestEnv() : rdram(PS2_RAM_SIZE, 0) + { + std::memset(&ctx, 0, sizeof(ctx)); + } + }; +} - tc.Run("semaphore legacy layout decode remains supported", [](TestCase &t) +void register_ps2_runtime_kernel_tests() +{ + MiniTest::Case("PS2RuntimeKernel", [](TestCase &tc) + { + tc.Run("CreateThread and CreateSema decode the exact PS2SDK EE layouts", [](TestCase &t) { TestEnv env; - - const uint32_t legacyParam[6] = { - 0x7u, // attr - 0x1234u, // legacy option / ee max_count - 3u, // init - 4u, // max - 0u, // ee attr (ignored if legacy selected) - 0x1FFFFFFFu // ee option (invalid guest pointer to bias decode toward legacy) - }; - writeGuestWords(env.rdram.data(), K_PARAM_ADDR, legacyParam, std::size(legacyParam)); + EeThreadCreateAbi threadParam{}; + threadParam.status = 0x11111111; + threadParam.func = K_SCHED_HIGH; + threadParam.stack = 0x00018000u; + threadParam.stack_size = 0x1000; + threadParam.gp_reg = 0x00123400u; + threadParam.initial_priority = 37; + threadParam.current_priority = 99; + threadParam.attr = 0xABCDEF01u; + threadParam.option = 0x10203040u; + std::memcpy(env.rdram.data() + K_PARAM_ADDR, &threadParam, sizeof(threadParam)); + setRegU32(env.ctx, 4, K_PARAM_ADDR); + CreateThread(env.rdram.data(), &env.ctx, &env.runtime); + const int threadId = getRegS32(env.ctx, 2); + const GuestThread *thread = env.runtime.eeScheduler().thread(threadId); + t.IsTrue(threadId >= 2 && thread != nullptr, "the EE descriptor should create a guest thread"); + t.Equals(thread->entry, threadParam.func, "func must be decoded from offset 0x04"); + t.Equals(thread->stack, threadParam.stack, "stack must be decoded from offset 0x08"); + t.Equals(thread->stackSize, static_cast(threadParam.stack_size), + "stack_size must be decoded from offset 0x0C"); + t.Equals(thread->gp, threadParam.gp_reg, "gp_reg must be decoded from offset 0x10"); + t.Equals(thread->initialPriority, threadParam.initial_priority, + "initial_priority must be decoded from offset 0x14"); + t.Equals(thread->currentPriority, threadParam.initial_priority, + "a new thread starts at its initial priority, not the status-only current_priority field"); + t.Equals(thread->attr, threadParam.attr, "attr must be decoded from offset 0x1C"); + t.Equals(thread->option, threadParam.option, "option must be decoded from offset 0x20"); + t.IsTrue(thread->status == EeThreadStatus::Dormant, "a newly created EE thread must be dormant"); + + setRegU32(env.ctx, 4, PS2_RAM_SIZE - static_cast(sizeof(EeThreadCreateAbi)) + 4u); + CreateThread(env.rdram.data(), &env.ctx, &env.runtime); + t.Equals(getRegS32(env.ctx, 2), KE_ERROR, + "the entire EE descriptor must fit in a valid guest range"); + + EeSemaStatus semaParam{}; + semaParam.count = 91; + semaParam.max_count = 7; + semaParam.init_count = 3; + semaParam.wait_threads = 82; + semaParam.attr = 0x55667788u; + semaParam.option = 0x99AABBCCu; + std::memcpy(env.rdram.data() + K_PARAM_ADDR, &semaParam, sizeof(semaParam)); setRegU32(env.ctx, 4, K_PARAM_ADDR); CreateSema(env.rdram.data(), &env.ctx, &env.runtime); - const int32_t sid = getRegS32(env.ctx, 2); - t.IsTrue(sid > 0, "CreateSema should still accept legacy-style parameter blocks"); - - setRegU32(env.ctx, 4, static_cast(sid)); - setRegU32(env.ctx, 5, K_STATUS_ADDR); - ReferSemaStatus(env.rdram.data(), &env.ctx, &env.runtime); - t.Equals(getRegS32(env.ctx, 2), KE_OK, "ReferSemaStatus should succeed for legacy-decoded semaphore"); - - EeSemaStatus semaStatus{}; - std::memcpy(&semaStatus, env.rdram.data() + K_STATUS_ADDR, sizeof(semaStatus)); - t.Equals(semaStatus.count, 3, "legacy init_count should map to runtime count"); - t.Equals(semaStatus.max_count, 4, "legacy max_count should map to runtime max"); - t.Equals(semaStatus.attr, 0x7u, "legacy attr should be preserved"); - t.Equals(semaStatus.option, 0x1234u, "legacy option should be preserved"); - - setRegU32(env.ctx, 4, static_cast(sid)); - DeleteSema(env.rdram.data(), &env.ctx, &env.runtime); - t.Equals(getRegS32(env.ctx, 2), sid, "DeleteSema should return sid for legacy-decoded semaphore"); + const int semaId = getRegS32(env.ctx, 2); + const EeSemaphore *semaphore = env.runtime.eeScheduler().semaphore(semaId); + t.IsTrue(semaId > 0 && semaphore != nullptr, "the EE semaphore descriptor should create an object"); + t.Equals(semaphore->count, semaParam.init_count, + "CreateSema must use init_count at offset 0x08, not the status count field"); + t.Equals(semaphore->maxCount, semaParam.max_count, "max_count must be decoded from offset 0x04"); + t.Equals(semaphore->attr, semaParam.attr, "semaphore attr must be decoded from offset 0x10"); + t.Equals(semaphore->option, semaParam.option, "semaphore option must be decoded from offset 0x14"); }); - tc.Run("semaphore syscalls return sid on success (EE BIOS convention)", [](TestCase &t) + tc.Run("EE scheduler selects absolute priority then FIFO", [](TestCase &t) { - // Sub-case A: CreateSema returns positive id (regression guard) - { - TestEnv env; - const uint32_t semaParam[6] = { 0u, 2u, 1u, 0u, 0x11u, 0u }; - writeGuestWords(env.rdram.data(), K_PARAM_ADDR, semaParam, std::size(semaParam)); - setRegU32(env.ctx, 4, K_PARAM_ADDR); - CreateSema(env.rdram.data(), &env.ctx, &env.runtime); - const int32_t sid = getRegS32(env.ctx, 2); - t.IsTrue(sid > 0, "CreateSema should return positive semaphore id"); - } - - // Sub-case B: PollSema success returns sid - { - TestEnv env; - const uint32_t semaParam[6] = { 0u, 2u, 1u, 0u, 0u, 0u }; - writeGuestWords(env.rdram.data(), K_PARAM_ADDR, semaParam, std::size(semaParam)); - setRegU32(env.ctx, 4, K_PARAM_ADDR); - CreateSema(env.rdram.data(), &env.ctx, &env.runtime); - const int32_t sid = getRegS32(env.ctx, 2); - t.IsTrue(sid > 0, "CreateSema should return positive id for PollSema test"); - - setRegU32(env.ctx, 4, static_cast(sid)); - PollSema(env.rdram.data(), &env.ctx, &env.runtime); - t.Equals(getRegS32(env.ctx, 2), sid, "PollSema success should return sid"); - - setRegU32(env.ctx, 4, static_cast(sid)); - PollSema(env.rdram.data(), &env.ctx, &env.runtime); - t.Equals(getRegS32(env.ctx, 2), KE_SEMA_ZERO, "PollSema should return KE_SEMA_ZERO when count exhausted"); - } - - // Sub-case C: SignalSema success returns sid + overflow returns KE_SEMA_OVF - { - TestEnv env; - const uint32_t semaParam[6] = { 0u, 1u, 0u, 0u, 0u, 0u }; - writeGuestWords(env.rdram.data(), K_PARAM_ADDR, semaParam, std::size(semaParam)); - setRegU32(env.ctx, 4, K_PARAM_ADDR); - CreateSema(env.rdram.data(), &env.ctx, &env.runtime); - const int32_t sid = getRegS32(env.ctx, 2); - t.IsTrue(sid > 0, "CreateSema should return positive id for SignalSema test"); - - setRegU32(env.ctx, 4, static_cast(sid)); - SignalSema(env.rdram.data(), &env.ctx, &env.runtime); - t.Equals(getRegS32(env.ctx, 2), sid, "SignalSema success should return sid (count 0->1)"); - - setRegU32(env.ctx, 4, static_cast(sid)); - SignalSema(env.rdram.data(), &env.ctx, &env.runtime); - t.Equals(getRegS32(env.ctx, 2), KE_SEMA_OVF, "SignalSema should return KE_SEMA_OVF when count at max=1"); - } - - // Sub-case D: WaitSema success returns sid AND decrements count - { - TestEnv env; - const uint32_t semaParam[6] = { 0u, 2u, 1u, 0u, 0u, 0u }; - writeGuestWords(env.rdram.data(), K_PARAM_ADDR, semaParam, std::size(semaParam)); - setRegU32(env.ctx, 4, K_PARAM_ADDR); - CreateSema(env.rdram.data(), &env.ctx, &env.runtime); - const int32_t sid = getRegS32(env.ctx, 2); - t.IsTrue(sid > 0, "CreateSema should return positive id for WaitSema test"); - - setRegU32(env.ctx, 4, static_cast(sid)); - WaitSema(env.rdram.data(), &env.ctx, &env.runtime); - t.Equals(getRegS32(env.ctx, 2), sid, "WaitSema success should return sid"); - - R5900Context statusCtx{}; - setRegU32(statusCtx, 4, static_cast(sid)); - setRegU32(statusCtx, 5, K_STATUS_ADDR); - ReferSemaStatus(env.rdram.data(), &statusCtx, &env.runtime); - EeSemaStatus semaStatus{}; - std::memcpy(&semaStatus, env.rdram.data() + K_STATUS_ADDR, sizeof(semaStatus)); - t.Equals(semaStatus.count, 0, "WaitSema should decrement count to 0"); - } - - // Sub-case E: WaitSema delete-while-waiting returns KE_WAIT_DELETE - { - TestEnv env; - const uint32_t semaParam[6] = { 0u, 1u, 0u, 0u, 0u, 0u }; - writeGuestWords(env.rdram.data(), K_PARAM_ADDR, semaParam, std::size(semaParam)); - setRegU32(env.ctx, 4, K_PARAM_ADDR); - CreateSema(env.rdram.data(), &env.ctx, &env.runtime); - const int32_t sid = getRegS32(env.ctx, 2); - t.IsTrue(sid > 0, "CreateSema should return positive id for delete-while-waiting test"); - - int32_t workerRet = 0; - writeGuestU32(env.rdram.data(), K_SEMA_WAIT_READY_ADDR, 0u); - - std::thread worker([&]() - { - R5900Context wctx{}; - setRegU32(wctx, 4, static_cast(sid)); - writeGuestU32(env.rdram.data(), K_SEMA_WAIT_READY_ADDR, 1u); - WaitSema(env.rdram.data(), &wctx, &env.runtime); - workerRet = getRegS32(wctx, 2); - }); - - // Wait until the waiter has incremented waiter count (count=0, so it must block) - const bool waiterBlocking = waitUntil([&]() - { - R5900Context statusCtx{}; - setRegU32(statusCtx, 4, static_cast(sid)); - setRegU32(statusCtx, 5, K_STATUS_ADDR); - ReferSemaStatus(env.rdram.data(), &statusCtx, &env.runtime); - EeSemaStatus st{}; - std::memcpy(&st, env.rdram.data() + K_STATUS_ADDR, sizeof(st)); - return st.wait_threads >= 1; - }, std::chrono::milliseconds(500)); - t.IsTrue(waiterBlocking, "worker thread should be blocking on WaitSema"); - - // Delete the semaphore while worker is waiting - setRegU32(env.ctx, 4, static_cast(sid)); - DeleteSema(env.rdram.data(), &env.ctx, &env.runtime); - t.Equals(getRegS32(env.ctx, 2), sid, "DeleteSema should return sid while thread is waiting"); - - worker.join(); - t.Equals(workerRet, KE_WAIT_DELETE, "WaitSema should return KE_WAIT_DELETE when semaphore is deleted"); - } + TestEnv env; + std::vector trace; + gSchedulerTrace = &trace; + gGuestActive.store(0, std::memory_order_release); + gGuestMaxActive.store(0, std::memory_order_release); + gGuestExecutorHash.store(0u, std::memory_order_release); + gGuestExecutorMismatch.store(false, std::memory_order_release); + gGuestExecutingFlagMissing.store(false, std::memory_order_release); + env.runtime.registerFunction(K_SCHED_MAIN, schedulerMainExit); + env.runtime.registerFunction(K_SCHED_A, schedulerTraceA); + env.runtime.registerFunction(K_SCHED_B, schedulerTraceB); + + env.ctx.pc = K_SCHED_MAIN; + EeScheduler &ee = env.runtime.eeScheduler(); + ee.reset(env.rdram.data(), env.ctx); + const int lowA = ee.createThread(EeThreadCreateParams{0, K_SCHED_A, 0x20000u, 0x800u, 0, 20, 0}); + const int highA = ee.createThread(EeThreadCreateParams{0, K_SCHED_A, 0x21000u, 0x800u, 0, 5, 0}); + const int highB = ee.createThread(EeThreadCreateParams{0, K_SCHED_B, 0x22000u, 0x800u, 0, 5, 0}); + ee.startThread(lowA, 0, env.ctx, false); + ee.startThread(highA, 0, env.ctx, false); + ee.startThread(highB, 0, env.ctx, false); + ee.run(); + + t.Equals(trace.size(), size_t{4}, "all runnable contexts should execute once"); + t.Equals(trace[0], 1, "main priority zero executes first"); + t.Equals(trace[1], 10, "first priority-5 thread preserves FIFO order"); + t.Equals(trace[2], 20, "second priority-5 thread follows FIFO order"); + t.Equals(trace[3], 10, "priority-20 thread executes only after priority-5 queue drains"); + t.Equals(gGuestMaxActive.load(std::memory_order_acquire), 1, + "there must never be two simultaneous guest executions"); + t.IsFalse(gGuestExecutorMismatch.load(std::memory_order_acquire), + "all EE guest functions must execute on the single scheduler host thread"); + t.IsFalse(gGuestExecutingFlagMissing.load(std::memory_order_acquire), + "the scheduler must publish guest execution only around the active guest call"); + }); - // Sub-case F: DeleteSema success returns sid + tc.Run("thread lifecycle, nested suspend, WAIT-SUSPEND, and wakeup count are centralized", [](TestCase &t) + { + TestEnv env; + EeScheduler &ee = env.runtime.eeScheduler(); + ee.reset(env.rdram.data(), env.ctx); + ee.bindMainContextForSyscall(env.ctx, env.rdram.data()); + + const int id = ee.createThread(EeThreadCreateParams{0u, K_SCHED_HIGH, 0x24000u, 0x800u, + 0u, 20, 0u}); + t.Equals(ee.startThread(id, 0xCAFEu, env.ctx, false), KE_OK, "StartThread should make a dormant thread ready"); + t.IsTrue(ee.thread(id)->status == EeThreadStatus::Ready, "started thread should be in one ready queue"); + t.Equals(ee.suspendThread(id, false), KE_OK, "first suspend should remove the ready thread"); + t.Equals(ee.suspendThread(id, false), KE_OK, "nested suspend should increment suspendCount"); + t.IsTrue(ee.thread(id)->status == EeThreadStatus::Suspended && ee.thread(id)->suspendCount == 2, + "nested suspension should have one suspended membership and count two"); + t.Equals(ee.resumeThread(id, false), KE_OK, "first resume should only decrement the nested count"); + t.IsTrue(ee.thread(id)->status == EeThreadStatus::Suspended && ee.thread(id)->suspendCount == 1, + "one outstanding suspend keeps the thread suspended"); + t.Equals(ee.resumeThread(id, false), KE_OK, "final resume should restore readiness"); + t.IsTrue(ee.thread(id)->status == EeThreadStatus::Ready && ee.thread(id)->suspendCount == 0, + "final resume should enqueue the thread exactly once"); + + t.Equals(ee.wakeupThread(id, false), KE_OK, "wakeup against a non-sleeping thread should accumulate"); + t.Equals(ee.wakeupThread(id, false), KE_OK, "a second wakeup should accumulate independently"); + t.Equals(ee.cancelWakeup(id), 2, "CancelWakeupThread should return and clear the exact accumulated count"); + t.Equals(ee.cancelWakeup(id), 0, "the wakeup count should remain cleared"); + + uint32_t ownedStack = 0u; + t.Equals(ee.terminateThread(id, ownedStack, false), KE_OK, + "TerminateThread should remove a ready thread and make it dormant"); + t.IsTrue(ee.thread(id)->status == EeThreadStatus::Dormant, "terminated thread should be dormant"); + t.Equals(ee.deleteThread(id, ownedStack), KE_OK, "a dormant thread record should be deletable"); + t.IsTrue(ee.thread(id) == nullptr, "deleted thread must leave every scheduler collection"); + + bool slept = false; + try { - TestEnv env; - const uint32_t semaParam[6] = { 0u, 1u, 0u, 0u, 0u, 0u }; - writeGuestWords(env.rdram.data(), K_PARAM_ADDR, semaParam, std::size(semaParam)); - setRegU32(env.ctx, 4, K_PARAM_ADDR); - CreateSema(env.rdram.data(), &env.ctx, &env.runtime); - const int32_t sid = getRegS32(env.ctx, 2); - t.IsTrue(sid > 0, "CreateSema should return positive id for DeleteSema test"); - - setRegU32(env.ctx, 4, static_cast(sid)); - DeleteSema(env.rdram.data(), &env.ctx, &env.runtime); - t.Equals(getRegS32(env.ctx, 2), sid, "DeleteSema success should return sid"); + ee.sleepCurrent(); } - - // Sub-case G: Invalid sid returns KE_UNKNOWN_SEMID for all four syscalls + catch (const EeDispatcherTransfer &) { - TestEnv env; - constexpr uint32_t kBadSid = 0x7FFFu; - - setRegU32(env.ctx, 4, kBadSid); - PollSema(env.rdram.data(), &env.ctx, &env.runtime); - t.Equals(getRegS32(env.ctx, 2), KE_UNKNOWN_SEMID, "PollSema should return KE_UNKNOWN_SEMID for invalid sid"); - - setRegU32(env.ctx, 4, kBadSid); - SignalSema(env.rdram.data(), &env.ctx, &env.runtime); - t.Equals(getRegS32(env.ctx, 2), KE_UNKNOWN_SEMID, "SignalSema should return KE_UNKNOWN_SEMID for invalid sid"); - - setRegU32(env.ctx, 4, kBadSid); - WaitSema(env.rdram.data(), &env.ctx, &env.runtime); - t.Equals(getRegS32(env.ctx, 2), KE_UNKNOWN_SEMID, "WaitSema should return KE_UNKNOWN_SEMID for invalid sid"); - - setRegU32(env.ctx, 4, kBadSid); - DeleteSema(env.rdram.data(), &env.ctx, &env.runtime); - t.Equals(getRegS32(env.ctx, 2), KE_UNKNOWN_SEMID, "DeleteSema should return KE_UNKNOWN_SEMID for invalid sid"); + slept = true; } + t.IsTrue(slept && ee.thread(EeScheduler::kMainThreadId)->status == EeThreadStatus::Waiting, + "SleepThread should transfer the running context into a typed wait"); + t.Equals(ee.suspendThread(EeScheduler::kMainThreadId, false), KE_OK, + "suspending a waiter should produce WAIT-SUSPEND"); + t.IsTrue(ee.thread(EeScheduler::kMainThreadId)->status == EeThreadStatus::WaitingSuspended, + "the sleeping context should remain in its wait object while suspended"); + t.Equals(ee.wakeupThread(EeScheduler::kMainThreadId, false), KE_OK, + "waking WAIT-SUSPEND should complete the wait without enqueueing yet"); + t.IsTrue(ee.thread(EeScheduler::kMainThreadId)->status == EeThreadStatus::Suspended, + "completed WAIT-SUSPEND should become plain suspended"); + t.Equals(ee.resumeThread(EeScheduler::kMainThreadId, false), KE_OK, + "resuming the final suspend should make the completed waiter ready"); + t.IsTrue(ee.thread(EeScheduler::kMainThreadId)->status == EeThreadStatus::Ready, + "the resumed waiter should re-enter its priority queue once"); + }); - // Sub-case H: WaitSema force-released via ReleaseWaitThread returns KE_RELEASE_WAIT - // and the ret >= 0 guard must NOT consume a token (count stays 0, not -1). + tc.Run("semaphore signal, delete, and release complete blocked contexts with exact results", [](TestCase &t) + { + const auto blockMain = [](TestEnv &env, int &semaId) { - // Use a tid the sequential allocator (range 2..0xFF) will never produce, so the - // worker's WaitSema creates a fresh ThreadInfo that ReleaseWaitThread can target. - // Prior tests leave stale entries at low tids (2, 3, ...), which would make - // ReleaseWaitThread find a non-waiting ThreadInfo and return KE_NOT_WAIT. - constexpr int kWorkerTid = 0x7FFE; - TestEnv env; - const uint32_t semaParam[6] = {0u, 2u, 0u, 0u, 0u, 0u}; - writeGuestWords(env.rdram.data(), K_PARAM_ADDR, semaParam, 6); - setRegU32(env.ctx, 4, K_PARAM_ADDR); - CreateSema(env.rdram.data(), &env.ctx, &env.runtime); - const int sid = getRegS32(env.ctx, 2); - t.IsTrue(sid > 0, "sub-case H: CreateSema must return positive sid"); - - writeGuestU32(env.rdram.data(), K_SEMA_WAIT_READY_ADDR, 0u); - int32_t workerRet = 0; - - std::thread worker([&]() { - g_currentThreadId = kWorkerTid; - R5900Context wctx{}; - setRegU32(wctx, 4, static_cast(sid)); - writeGuestU32(env.rdram.data(), K_SEMA_WAIT_READY_ADDR, 1u); - WaitSema(env.rdram.data(), &wctx, &env.runtime); - workerRet = getRegS32(wctx, 2); - }); - - // Wait until the worker is confirmed blocking in WaitSema. - const bool waiterBlocking = waitUntil([&]() { - R5900Context statusCtx{}; - setRegU32(statusCtx, 4, static_cast(sid)); - setRegU32(statusCtx, 5, K_STATUS_ADDR); - ReferSemaStatus(env.rdram.data(), &statusCtx, &env.runtime); - EeSemaStatus st{}; - std::memcpy(&st, env.rdram.data() + K_STATUS_ADDR, sizeof(st)); - return st.wait_threads >= 1; - }, std::chrono::milliseconds(500)); - t.IsTrue(waiterBlocking, "sub-case H: worker must be blocking in WaitSema before force-release"); - - // Force-release the worker via ReleaseWaitThread. - setRegU32(env.ctx, 4, static_cast(kWorkerTid)); - ReleaseWaitThread(env.rdram.data(), &env.ctx, &env.runtime); - t.Equals(getRegS32(env.ctx, 2), KE_OK, - "sub-case H: ReleaseWaitThread must succeed"); - - worker.join(); - t.Equals(workerRet, KE_RELEASE_WAIT, - "sub-case H: WaitSema force-released must return KE_RELEASE_WAIT, not sid"); - - // Assert the count was NOT decremented (core guard check: ret < 0 skips decrement). + EeScheduler &ee = env.runtime.eeScheduler(); + ee.reset(env.rdram.data(), env.ctx); + ee.bindMainContextForSyscall(env.ctx, env.rdram.data()); + semaId = ee.createSemaphore(0, 1, 0u, 0u); + try { - R5900Context statusCtx{}; - setRegU32(statusCtx, 4, static_cast(sid)); - setRegU32(statusCtx, 5, K_STATUS_ADDR); - ReferSemaStatus(env.rdram.data(), &statusCtx, &env.runtime); - EeSemaStatus st{}; - std::memcpy(&st, env.rdram.data() + K_STATUS_ADDR, sizeof(st)); - t.Equals(st.count, 0, "sub-case H: force-released WaitSema must NOT consume a token (count must stay 0, not -1)"); + ee.waitSemaphore(semaId); } - - // Prove token accounting is intact: signal once, poll twice (one token, clean). - setRegU32(env.ctx, 4, static_cast(sid)); - SignalSema(env.rdram.data(), &env.ctx, &env.runtime); - t.Equals(getRegS32(env.ctx, 2), sid, - "sub-case H: SignalSema after force-release must return sid (count 0->1)"); - - setRegU32(env.ctx, 4, static_cast(sid)); - PollSema(env.rdram.data(), &env.ctx, &env.runtime); - t.Equals(getRegS32(env.ctx, 2), sid, - "sub-case H: PollSema must consume the one token after force-release"); - - setRegU32(env.ctx, 4, static_cast(sid)); - PollSema(env.rdram.data(), &env.ctx, &env.runtime); - t.Equals(getRegS32(env.ctx, 2), KE_SEMA_ZERO, - "sub-case H: count must be exactly 0 after single token consumed (not -1)"); - } - - // Sub-case I: blocking WaitSema woken by SignalSema returns sid (the DQ8 scenario). - // init=0 forces the worker to block; SignalSema uses cv.notify_one() (not - // ReleaseWaitThread), so the worker needs no g_currentThreadId identity. - { - TestEnv env; - const uint32_t semaParam[6] = {0u, 1u, 0u, 0u, 0u, 0u}; - writeGuestWords(env.rdram.data(), K_PARAM_ADDR, semaParam, 6); - setRegU32(env.ctx, 4, K_PARAM_ADDR); - CreateSema(env.rdram.data(), &env.ctx, &env.runtime); - const int sid = getRegS32(env.ctx, 2); - t.IsTrue(sid > 0, "sub-case I: CreateSema must return positive sid"); - - writeGuestU32(env.rdram.data(), K_SEMA_WAIT_READY_ADDR, 0u); - int32_t workerRet = 0; - - std::thread worker([&]() { - R5900Context wctx{}; - setRegU32(wctx, 4, static_cast(sid)); - writeGuestU32(env.rdram.data(), K_SEMA_WAIT_READY_ADDR, 1u); - WaitSema(env.rdram.data(), &wctx, &env.runtime); - workerRet = getRegS32(wctx, 2); - }); - - // Confirm the worker is actually blocking (count==0 forces a block). - const bool waiterBlocking = waitUntil([&]() { - R5900Context statusCtx{}; - setRegU32(statusCtx, 4, static_cast(sid)); - setRegU32(statusCtx, 5, K_STATUS_ADDR); - ReferSemaStatus(env.rdram.data(), &statusCtx, &env.runtime); - EeSemaStatus st{}; - std::memcpy(&st, env.rdram.data() + K_STATUS_ADDR, sizeof(st)); - return st.wait_threads >= 1; - }, std::chrono::milliseconds(500)); - t.IsTrue(waiterBlocking, "sub-case I: worker must be blocking in WaitSema before signal"); - - // Wake the worker; success path must return sid, not KE_OK. - setRegU32(env.ctx, 4, static_cast(sid)); - SignalSema(env.rdram.data(), &env.ctx, &env.runtime); - t.Equals(getRegS32(env.ctx, 2), sid, - "sub-case I: SignalSema that wakes a waiter must return sid (count 0->1)"); - - worker.join(); - t.Equals(workerRet, sid, - "sub-case I: blocking WaitSema woken by signal must return sid, not KE_OK"); - - // Signal incremented to 1, the woken wait consumed it back to 0. + catch (const EeDispatcherTransfer &) { - R5900Context statusCtx{}; - setRegU32(statusCtx, 4, static_cast(sid)); - setRegU32(statusCtx, 5, K_STATUS_ADDR); - ReferSemaStatus(env.rdram.data(), &statusCtx, &env.runtime); - EeSemaStatus st{}; - std::memcpy(&st, env.rdram.data() + K_STATUS_ADDR, sizeof(st)); - t.Equals(st.count, 0, - "sub-case I: woken WaitSema must consume the signaled token (count back to 0)"); } - } + }; - // Reset all global sema/thread state so no entries (e.g. the 0x7FFE ThreadInfo - // from sub-case H) leak into subsequent test cases. - notifyRuntimeStop(); + TestEnv signaled; + int signalId = 0; + blockMain(signaled, signalId); + t.Equals(signaled.runtime.eeScheduler().signalSemaphore(signalId, false), signalId, + "SignalSema should transfer directly to the FIFO waiter"); + t.Equals(getRegS32(signaled.runtime.eeScheduler().thread(1)->context, 2), signalId, + "the resumed semaphore waiter should receive the semaphore id"); + t.Equals(signaled.runtime.eeScheduler().semaphore(signalId)->count, 0, + "direct semaphore handoff must not increment count"); + + TestEnv deleted; + int deleteId = 0; + blockMain(deleted, deleteId); + t.Equals(deleted.runtime.eeScheduler().deleteSemaphore(deleteId, false), deleteId, + "DeleteSema should remove the semaphore object"); + t.Equals(getRegS32(deleted.runtime.eeScheduler().thread(1)->context, 2), KE_WAIT_DELETE, + "DeleteSema should resume its waiter with KE_WAIT_DELETE"); + t.IsTrue(deleted.runtime.eeScheduler().semaphore(deleteId) == nullptr, + "deleted semaphore must no longer own a waiter queue"); + + TestEnv released; + int releaseId = 0; + blockMain(released, releaseId); + t.Equals(released.runtime.eeScheduler().releaseWait(EeScheduler::kMainThreadId, false), KE_OK, + "ReleaseWaitThread should detach the context from its wait object"); + t.Equals(getRegS32(released.runtime.eeScheduler().thread(1)->context, 2), KE_RELEASE_WAIT, + "released waiter should resume with KE_RELEASE_WAIT"); + t.Equals(released.runtime.eeScheduler().semaphore(releaseId)->waiters.size(), size_t{0}, + "ReleaseWaitThread must remove the exact semaphore waiter"); }); - tc.Run("WaitEventFlag preserves waitsuspend state when a suspended thread blocks", [](TestCase &t) + tc.Run("event waiters are FIFO and clear modes apply before testing the next waiter", [](TestCase &t) { TestEnv env; - - constexpr uint32_t kEventParamAddr = 0x1600u; - constexpr uint32_t kWaitThreadEntry = 0x00260000u; - - const uint32_t eventParam[3] = { - 0u, - 0u, - 0u - }; - std::memcpy(env.rdram.data() + kEventParamAddr, eventParam, sizeof(eventParam)); - writeGuestU32(env.rdram.data(), K_EVENT_WAIT_READY_ADDR, 0u); - writeGuestU32(env.rdram.data(), K_EVENT_WAIT_GATE_ADDR, 0u); - - R5900Context createEventCtx{}; - setRegU32(createEventCtx, 4, kEventParamAddr); - CreateEventFlag(env.rdram.data(), &createEventCtx, &env.runtime); - const int32_t eid = getRegS32(createEventCtx, 2); - t.IsTrue(eid > 0, "CreateEventFlag should return a valid event id"); - - env.runtime.registerFunction(kWaitThreadEntry, &waitEventAfterSuspendHandler); - - const uint32_t threadParam[7] = { - 0u, - kWaitThreadEntry, - 0x00310000u, - 0x00000800u, - 0x00120000u, - 6u, - 0u - }; - - writeGuestWords(env.rdram.data(), K_PARAM_ADDR, threadParam, std::size(threadParam)); - setRegU32(env.ctx, 4, K_PARAM_ADDR); - CreateThread(env.rdram.data(), &env.ctx, &env.runtime); - const int32_t tid = getRegS32(env.ctx, 2); - t.IsTrue(tid >= 2, "CreateThread should return a valid worker thread id"); - - setRegU32(env.ctx, 4, static_cast(tid)); - setRegU32(env.ctx, 5, static_cast(eid)); - StartThread(env.rdram.data(), &env.ctx, &env.runtime); - t.Equals(getRegS32(env.ctx, 2), KE_OK, "StartThread should launch the event waiter"); - - const bool ready = waitUntil([&]() - { - return readGuestU32(env.rdram.data(), K_EVENT_WAIT_READY_ADDR) == 1u; - }, std::chrono::milliseconds(200)); - t.IsTrue(ready, "waiter thread should reach the suspend gate before blocking"); - - setRegU32(env.ctx, 4, static_cast(tid)); - SuspendThread(env.rdram.data(), &env.ctx, &env.runtime); - t.Equals(getRegS32(env.ctx, 2), KE_OK, "SuspendThread should succeed for the running waiter"); - - writeGuestU32(env.rdram.data(), K_EVENT_WAIT_GATE_ADDR, 1u); - - const bool waiting = waitUntil([&]() - { - R5900Context statusCtx{}; - setRegU32(statusCtx, 4, static_cast(tid)); - setRegU32(statusCtx, 5, K_STATUS_ADDR); - ReferThreadStatus(env.rdram.data(), &statusCtx, &env.runtime); - if (getRegS32(statusCtx, 2) != KE_OK) - { - return false; - } - - EeThreadStatus status{}; - std::memcpy(&status, env.rdram.data() + K_STATUS_ADDR, sizeof(status)); - return status.waitType == TSW_EVENT; - }, std::chrono::milliseconds(200)); - t.IsTrue(waiting, "waiter thread should block on the event flag"); - - EeThreadStatus waitingStatus{}; - std::memcpy(&waitingStatus, env.rdram.data() + K_STATUS_ADDR, sizeof(waitingStatus)); - t.Equals(waitingStatus.status, THS_WAITSUSPEND, - "event-flag wait should report THS_WAITSUSPEND when the thread is already suspended"); - - R5900Context signalCtx{}; - setRegU32(signalCtx, 4, static_cast(eid)); - setRegU32(signalCtx, 5, 0x4u); - SetEventFlag(env.rdram.data(), &signalCtx, &env.runtime); - t.Equals(getRegS32(signalCtx, 2), KE_OK, "SetEventFlag should wake the waiting thread"); - - const bool suspended = waitUntil([&]() - { - R5900Context statusCtx{}; - setRegU32(statusCtx, 4, static_cast(tid)); - setRegU32(statusCtx, 5, K_STATUS_ADDR); - ReferThreadStatus(env.rdram.data(), &statusCtx, &env.runtime); - if (getRegS32(statusCtx, 2) != KE_OK) - { - return false; - } - - EeThreadStatus status{}; - std::memcpy(&status, env.rdram.data() + K_STATUS_ADDR, sizeof(status)); - return status.status == THS_SUSPEND && status.waitType == 0u; - }, std::chrono::milliseconds(200)); - t.IsTrue(suspended, "after wake, a still-suspended waiter should move to THS_SUSPEND"); - - setRegU32(env.ctx, 4, static_cast(tid)); - ResumeThread(env.rdram.data(), &env.ctx, &env.runtime); - t.Equals(getRegS32(env.ctx, 2), KE_OK, "ResumeThread should release the waiter after the event is set"); - - const bool dormant = waitUntil([&]() - { - R5900Context statusCtx{}; - setRegU32(statusCtx, 4, static_cast(tid)); - setRegU32(statusCtx, 5, K_STATUS_ADDR); - ReferThreadStatus(env.rdram.data(), &statusCtx, &env.runtime); - if (getRegS32(statusCtx, 2) != KE_OK) - { - return false; - } - - EeThreadStatus status{}; - std::memcpy(&status, env.rdram.data() + K_STATUS_ADDR, sizeof(status)); - return status.status == THS_DORMANT; - }, std::chrono::milliseconds(200)); - t.IsTrue(dormant, "waiter thread should return to dormant after the event is signaled and resumed"); - - setRegU32(env.ctx, 4, static_cast(eid)); - DeleteEventFlag(env.rdram.data(), &env.ctx, &env.runtime); - t.Equals(getRegS32(env.ctx, 2), KE_OK, "DeleteEventFlag should clean up the test event flag"); - - setRegU32(env.ctx, 4, static_cast(tid)); - DeleteThread(env.rdram.data(), &env.ctx, &env.runtime); - t.Equals(getRegS32(env.ctx, 2), KE_OK, "DeleteThread should clean up the waiter thread"); + env.runtime.registerFunction(K_EVENT_FIFO_MAIN, schedulerEventFifoMain); + env.runtime.registerFunction(K_EVENT_FIFO_A, schedulerEventFifoWaitA); + env.runtime.registerFunction(K_EVENT_FIFO_A_RESUME, schedulerEventFifoWaitA); + env.runtime.registerFunction(K_EVENT_FIFO_B, schedulerEventFifoWaitB); + env.runtime.registerFunction(K_EVENT_FIFO_B_RESUME, schedulerEventFifoWaitB); + env.runtime.registerFunction(K_EVENT_FIFO_SIGNAL, schedulerEventFifoSignal); + env.runtime.registerFunction(K_EVENT_FIFO_SIGNAL_AGAIN, schedulerEventFifoSignalAgain); + env.runtime.registerFunction(K_EVENT_FIFO_DONE, schedulerEventFifoDone); + gEventFifoTrace.clear(); + env.ctx.pc = K_EVENT_FIFO_MAIN; + env.runtime.eeScheduler().reset(env.rdram.data(), env.ctx); + env.runtime.eeScheduler().run(); + + const std::vector expected{1, 2, 3, 4, 5, 6, 7}; + t.IsTrue(gEventFifoTrace == expected, + "the first clear waiter must consume the first signal before the second FIFO waiter is tested"); + t.Equals(readGuestU32(env.rdram.data(), K_EVENT_FIFO_RESULT_A), 1u, + "first waiter should receive its pre-clear observed bits"); + t.Equals(readGuestU32(env.rdram.data(), K_EVENT_FIFO_RESULT_B), 1u, + "second waiter should require and receive the second signal"); + t.Equals(env.runtime.eeScheduler().eventFlag(gEventFifoId)->bits, 0u, + "both WEF_CLEAR completions should consume their matched bit"); + + const int clearAllId = env.runtime.eeScheduler().createEventFlag(0x7u, 0x02u, 0u); + uint32_t observed = 0u; + t.Equals(env.runtime.eeScheduler().pollEventFlag(clearAllId, 0x2u, WEF_OR | WEF_CLEAR_ALL, observed), KE_OK, + "WEF_CLEAR_ALL poll should complete when any requested bit is present"); + t.Equals(observed, 0x7u, "event result should contain the bits observed before clearing"); + t.Equals(env.runtime.eeScheduler().eventFlag(clearAllId)->bits, 0u, + "WEF_CLEAR_ALL should clear the entire event pattern"); }); - tc.Run("TerminateThread unwinds semaphore wait as a normal thread exit", [](TestCase &t) + tc.Run("RotateThreadReadyQueue is the only same-priority rotation", [](TestCase &t) { TestEnv env; + std::vector trace; + gSchedulerTrace = &trace; + env.runtime.registerFunction(K_SCHED_MAIN, schedulerMainExit); + env.runtime.registerFunction(K_SCHED_A, schedulerRotateA); + env.runtime.registerFunction(K_SCHED_A_RESUME, schedulerRotateAResume); + env.runtime.registerFunction(K_SCHED_B, schedulerTraceB); + env.ctx.pc = K_SCHED_MAIN; + + EeScheduler &ee = env.runtime.eeScheduler(); + ee.reset(env.rdram.data(), env.ctx); + const int first = ee.createThread(EeThreadCreateParams{0, K_SCHED_A, 0x20000u, 0x800u, 0, 5, 0}); + const int second = ee.createThread(EeThreadCreateParams{0, K_SCHED_B, 0x21000u, 0x800u, 0, 5, 0}); + ee.startThread(first, 0, env.ctx, false); + ee.startThread(second, 0, env.ctx, false); + ee.run(); + + const std::vector expected{1, 10, 20, 11}; + t.IsTrue(trace == expected, "explicit rotation should move the current head behind its FIFO peer"); + }); - constexpr uint32_t kWaitThreadEntry = 0x00261000u; - const uint32_t semaParam[6] = { - 0u, - 1u, - 0u, - 0u, - 0u, - 0u - }; - writeGuestWords(env.rdram.data(), K_PARAM_ADDR, semaParam, std::size(semaParam)); - - R5900Context createSemaCtx{}; - setRegU32(createSemaCtx, 4, K_PARAM_ADDR); - CreateSema(env.rdram.data(), &createSemaCtx, &env.runtime); - const int32_t sid = getRegS32(createSemaCtx, 2); - t.IsTrue(sid > 0, "CreateSema should create a zero-count semaphore"); - - env.runtime.registerFunction(kWaitThreadEntry, &waitSemaUntilTerminatedHandler); - - const uint32_t threadParam[7] = { - 0u, - kWaitThreadEntry, - 0x00312000u, - 0x00000800u, - 0x00120000u, - 6u, - 0u - }; - - writeGuestU32(env.rdram.data(), K_TERMINATE_SEMA_WAIT_READY_ADDR, 0u); - writeGuestWords(env.rdram.data(), K_PARAM_ADDR, threadParam, std::size(threadParam)); - setRegU32(env.ctx, 4, K_PARAM_ADDR); - CreateThread(env.rdram.data(), &env.ctx, &env.runtime); - const int32_t tid = getRegS32(env.ctx, 2); - t.IsTrue(tid >= 2, "CreateThread should return a valid semaphore waiter thread id"); - - std::ostringstream capturedErr; - std::streambuf *oldErr = std::cerr.rdbuf(capturedErr.rdbuf()); - - setRegU32(env.ctx, 4, static_cast(tid)); - setRegU32(env.ctx, 5, static_cast(sid)); - StartThread(env.rdram.data(), &env.ctx, &env.runtime); - t.Equals(getRegS32(env.ctx, 2), KE_OK, "StartThread should launch the semaphore waiter"); - - const bool waiting = waitUntil([&]() - { - if (readGuestU32(env.rdram.data(), K_TERMINATE_SEMA_WAIT_READY_ADDR) != 1u) - { - return false; - } - - R5900Context statusCtx{}; - setRegU32(statusCtx, 4, static_cast(tid)); - setRegU32(statusCtx, 5, K_STATUS_ADDR); - ReferThreadStatus(env.rdram.data(), &statusCtx, &env.runtime); - if (getRegS32(statusCtx, 2) != KE_OK) - { - return false; - } - - EeThreadStatus status{}; - std::memcpy(&status, env.rdram.data() + K_STATUS_ADDR, sizeof(status)); - return status.status == THS_WAIT && status.waitType == TSW_SEMA; - }, std::chrono::milliseconds(200)); - t.IsTrue(waiting, "worker should block inside WaitSema before termination"); - - R5900Context terminateCtx{}; - setRegU32(terminateCtx, 4, static_cast(tid)); - TerminateThread(env.rdram.data(), &terminateCtx, &env.runtime); - t.Equals(getRegS32(terminateCtx, 2), KE_OK, "TerminateThread should join the semaphore waiter"); - - std::cerr.rdbuf(oldErr); - const std::string errText = capturedErr.str(); - t.IsTrue(errText.find("PS2 Thread Exit") == std::string::npos, - "thread-exit exceptions from Sync.cpp should be caught as normal exits"); - - R5900Context dormantCtx{}; - setRegU32(dormantCtx, 4, static_cast(tid)); - setRegU32(dormantCtx, 5, K_STATUS_ADDR); - ReferThreadStatus(env.rdram.data(), &dormantCtx, &env.runtime); - t.Equals(getRegS32(dormantCtx, 2), KE_OK, "terminated waiter should still have readable status"); - - EeThreadStatus dormantStatus{}; - std::memcpy(&dormantStatus, env.rdram.data() + K_STATUS_ADDR, sizeof(dormantStatus)); - t.Equals(dormantStatus.status, THS_DORMANT, "terminated waiter should become dormant"); - - setRegU32(env.ctx, 4, static_cast(tid)); - DeleteThread(env.rdram.data(), &env.ctx, &env.runtime); - t.Equals(getRegS32(env.ctx, 2), KE_OK, "DeleteThread should clean up the terminated waiter"); + tc.Run("starting a strictly higher-priority thread preempts immediately", [](TestCase &t) + { + TestEnv env; + std::vector trace; + gSchedulerTrace = &trace; + env.runtime.registerFunction(K_SCHED_MAIN, schedulerMainExit); + env.runtime.registerFunction(K_SCHED_A, schedulerPreemptLow); + env.runtime.registerFunction(K_SCHED_A_RESUME, schedulerPreemptLowResume); + env.runtime.registerFunction(K_SCHED_HIGH, schedulerHigh); + env.ctx.pc = K_SCHED_MAIN; + + EeScheduler &ee = env.runtime.eeScheduler(); + ee.reset(env.rdram.data(), env.ctx); + const int low = ee.createThread(EeThreadCreateParams{0, K_SCHED_A, 0x20000u, 0x800u, 0, 20, 0}); + gSchedulerCreatedId = ee.createThread(EeThreadCreateParams{0, K_SCHED_HIGH, 0x21000u, 0x800u, 0, 5, 0}); + ee.startThread(low, 0, env.ctx, false); + ee.run(); + + const std::vector expected{1, 30, 5, 31}; + t.IsTrue(trace == expected, "higher priority should run before the starter continues"); + }); - setRegU32(env.ctx, 4, static_cast(sid)); - DeleteSema(env.rdram.data(), &env.ctx, &env.runtime); - t.Equals(getRegS32(env.ctx, 2), sid, "DeleteSema should return sid while cleaning up the waiter semaphore"); + tc.Run("semaphore waiters are FIFO and signal transfers one token directly", [](TestCase &t) + { + TestEnv env; + std::vector trace; + gSchedulerTrace = &trace; + gSchedulerWaitResultA = 0; + gSchedulerWaitResultB = 0; + env.runtime.registerFunction(K_SCHED_MAIN, schedulerMainExit); + env.runtime.registerFunction(K_SCHED_A, schedulerWaitA); + env.runtime.registerFunction(K_SCHED_A_RESUME, schedulerWaitA); + env.runtime.registerFunction(K_SCHED_B, schedulerWaitB); + env.runtime.registerFunction(K_SCHED_B_RESUME, schedulerWaitB); + env.runtime.registerFunction(K_SCHED_SIGNAL, schedulerSignalTwice); + env.runtime.registerFunction(K_SCHED_SIGNAL_RESUME, schedulerSignalTwice); + env.ctx.pc = K_SCHED_MAIN; + + EeScheduler &ee = env.runtime.eeScheduler(); + ee.reset(env.rdram.data(), env.ctx); + gSchedulerSemaphoreId = ee.createSemaphore(0, 1, 0, 0); + const int waiterA = ee.createThread(EeThreadCreateParams{0, K_SCHED_A, 0x20000u, 0x800u, 0, 5, 0}); + const int waiterB = ee.createThread(EeThreadCreateParams{0, K_SCHED_B, 0x21000u, 0x800u, 0, 5, 0}); + const int signaler = ee.createThread(EeThreadCreateParams{0, K_SCHED_SIGNAL, 0x22000u, 0x800u, 0, 20, 0}); + ee.startThread(waiterA, 0, env.ctx, false); + ee.startThread(waiterB, 0, env.ctx, false); + ee.startThread(signaler, 0, env.ctx, false); + ee.run(); + + const std::vector expected{1, 10, 20, 30, 11, 31, 21}; + t.IsTrue(trace == expected, "each signal should wake exactly the FIFO head"); + t.Equals(gSchedulerWaitResultA, gSchedulerSemaphoreId, "first waiter receives sid on resume"); + t.Equals(gSchedulerWaitResultB, gSchedulerSemaphoreId, "second waiter receives sid on resume"); + t.Equals(ee.semaphore(gSchedulerSemaphoreId)->count, 0, "direct handoff must not increment count"); }); tc.Run("setup heap and allocator primitives track end-of-heap", [](TestCase &t) @@ -1288,12 +1168,11 @@ void register_ps2_runtime_kernel_tests() tc.Run("SetSyscall mirrors guest kernel table entries into low memory", [](TestCase &t) { - notifyRuntimeStop(); TestEnv env; - initializeGuestKernelState(env.rdram.data()); + initializeGuestKernelState(env.rdram.data(), &env.runtime); constexpr uint32_t kGuestSyscallTableGuestBase = 0x80011F80u; - constexpr uint32_t kSyscallIndex = 0x83u; + constexpr uint32_t kSyscallIndex = 0x82u; constexpr uint32_t kHandler = 0x00383548u; constexpr uint32_t kExpectedGuestAddr = kGuestSyscallTableGuestBase + (kSyscallIndex * 4u); constexpr uint32_t kExpectedPhysAddr = kExpectedGuestAddr & 0x1FFFFFFFu; @@ -1317,15 +1196,12 @@ void register_ps2_runtime_kernel_tests() t.Equals(static_cast(getRegS32(env.ctx, 2)), kExpectedGuestAddr, "FindAddress should discover mirrored SetSyscall entries in low guest memory"); - - notifyRuntimeStop(); }); tc.Run("SetSyscall honors signed kernel-table offsets", [](TestCase &t) { - notifyRuntimeStop(); TestEnv env; - initializeGuestKernelState(env.rdram.data()); + initializeGuestKernelState(env.rdram.data(), &env.runtime); constexpr uint32_t kPatchIndex = 0xFFFFC402u; constexpr uint32_t kHandler = 0xDEADBEEFu; @@ -1342,40 +1218,55 @@ void register_ps2_runtime_kernel_tests() t.Equals(mirrored, kHandler, "SetSyscall should treat the syscall index as a signed offset from the kernel table base"); - - notifyRuntimeStop(); }); - tc.Run("guest kernel syscall mirror resets between runs", [](TestCase &t) + tc.Run("guest kernel syscall overrides and mirrors are isolated per runtime", [](TestCase &t) { - notifyRuntimeStop(); - TestEnv env; - initializeGuestKernelState(env.rdram.data()); + TestEnv first; + TestEnv second; + initializeGuestKernelState(first.rdram.data(), &first.runtime); + initializeGuestKernelState(second.rdram.data(), &second.runtime); constexpr uint32_t kGuestSyscallTableGuestBase = 0x80011F80u; constexpr uint32_t kGuestSyscallTableProbeBase = 0x000002F0u; constexpr uint32_t kSyscallIndex = 0x5Au; - constexpr uint32_t kHandler = 0x00383510u; + constexpr uint32_t kFirstHandler = 0x00383510u; + constexpr uint32_t kSecondHandler = 0x00383520u; constexpr uint32_t kEntryPhysAddr = (kGuestSyscallTableGuestBase + (kSyscallIndex * 4u)) & 0x1FFFFFFFu; - setRegU32(env.ctx, 4, kSyscallIndex); - setRegU32(env.ctx, 5, kHandler); - t.IsTrue(callSyscall(0x74u, env.rdram.data(), &env.ctx, &env.runtime), - "SetSyscall syscall should dispatch"); - - notifyRuntimeStop(); - initializeGuestKernelState(env.rdram.data()); - - uint32_t mirrored = 1u; - std::memcpy(&mirrored, env.rdram.data() + kEntryPhysAddr, sizeof(mirrored)); - t.Equals(mirrored, - 0u, - "Initializing guest kernel state should clear stale mirrored syscall entries"); + setRegU32(first.ctx, 4, kSyscallIndex); + setRegU32(first.ctx, 5, kFirstHandler); + t.IsTrue(callSyscall(0x74u, first.rdram.data(), &first.ctx, &first.runtime), + "SetSyscall should install the first runtime's override"); + + uint32_t firstHandler = 0u; + uint32_t secondHandler = 0u; + t.IsTrue(first.runtime.findEeSyscallOverride(kSyscallIndex, firstHandler), + "the first runtime should own its override"); + t.IsFalse(second.runtime.findEeSyscallOverride(kSyscallIndex, secondHandler), + "a different runtime must not observe the first runtime's override"); + + setRegU32(second.ctx, 4, kSyscallIndex); + setRegU32(second.ctx, 5, kSecondHandler); + t.IsTrue(callSyscall(0x74u, second.rdram.data(), &second.ctx, &second.runtime), + "SetSyscall should install an independent second-runtime override"); + + uint32_t firstMirrored = 0u; + uint32_t secondMirrored = 0u; + std::memcpy(&firstMirrored, first.rdram.data() + kEntryPhysAddr, sizeof(firstMirrored)); + std::memcpy(&secondMirrored, second.rdram.data() + kEntryPhysAddr, sizeof(secondMirrored)); + t.Equals(firstMirrored, kFirstHandler, "the first runtime should retain its own mirror value"); + t.Equals(secondMirrored, kSecondHandler, "the second runtime should publish only its own mirror value"); + + initializeGuestKernelState(first.rdram.data(), &first.runtime); + std::memcpy(&firstMirrored, first.rdram.data() + kEntryPhysAddr, sizeof(firstMirrored)); + t.Equals(firstMirrored, kFirstHandler, + "reinitializing one runtime should rebuild its mirror from its instance-owned overrides"); uint32_t probeHi = 0u; uint32_t probeLo = 0u; - std::memcpy(&probeHi, env.rdram.data() + kGuestSyscallTableProbeBase + 0u, sizeof(probeHi)); - std::memcpy(&probeLo, env.rdram.data() + kGuestSyscallTableProbeBase + 8u, sizeof(probeLo)); + std::memcpy(&probeHi, first.rdram.data() + kGuestSyscallTableProbeBase + 0u, sizeof(probeHi)); + std::memcpy(&probeLo, first.rdram.data() + kGuestSyscallTableProbeBase + 8u, sizeof(probeLo)); t.Equals(probeHi, kGuestSyscallTableGuestBase >> 16, "Guest kernel initialization should seed the syscall table probe high word"); @@ -1384,112 +1275,101 @@ void register_ps2_runtime_kernel_tests() "Guest kernel initialization should seed the syscall table probe low word"); }); - tc.Run("SetSyscall override dispatches guest handlers that return through the sentinel", [](TestCase &t) + tc.Run("SetSyscall override runs as a scheduler invocation", [](TestCase &t) { - notifyRuntimeStop(); TestEnv env; constexpr uint32_t kSyscallIndex = 0x91u; constexpr uint32_t kHandler = 0x00200000u; env.runtime.registerFunction(kHandler, overrideReturnHandler); - setRegU32(env.ctx, 4, kSyscallIndex); - setRegU32(env.ctx, 5, kHandler); - t.IsTrue(callSyscall(0x74u, env.rdram.data(), &env.ctx, &env.runtime), - "SetSyscall syscall should dispatch"); - - setRegU32(env.ctx, 4, 7u); - setRegU32(env.ctx, 5, 5u); - t.IsTrue(callSyscall(kSyscallIndex, env.rdram.data(), &env.ctx, &env.runtime), - "Overridden syscall should dispatch through guest handler"); - t.Equals(static_cast(getRegS32(env.ctx, 2)), + env.runtime.registerFunction(K_OVERRIDE_ENTRY, schedulerOverrideEntry); + env.runtime.registerFunction(K_OVERRIDE_RESUME, schedulerOverrideResume); + env.runtime.setEeSyscallOverride(env.rdram.data(), kSyscallIndex, kHandler); + + gOverrideSyscall = kSyscallIndex; + R5900Context mainContext{}; + mainContext.pc = K_OVERRIDE_ENTRY; + setRegU32(mainContext, 4, 7u); + setRegU32(mainContext, 5, 5u); + env.runtime.eeScheduler().reset(env.rdram.data(), mainContext); + env.runtime.eeScheduler().run(); + + t.Equals(static_cast(getRegS32(gOverrideResult, 2)), 12u, - "Successful override dispatch should propagate guest handler return value"); - - notifyRuntimeStop(); + "the completed invocation should propagate the guest handler return value"); }); tc.Run("SetSyscall override preserves KSEG argument sign extension", [](TestCase &t) { - notifyRuntimeStop(); TestEnv env; constexpr uint32_t kSyscallIndex = 0x92u; constexpr uint32_t kHandler = 0x00200030u; env.runtime.registerFunction(kHandler, overrideKsegCompareHandler); - setRegU32(env.ctx, 4, kSyscallIndex); - setRegU32(env.ctx, 5, kHandler); - t.IsTrue(callSyscall(0x74u, env.rdram.data(), &env.ctx, &env.runtime), - "SetSyscall syscall should dispatch"); - - setRegU32(env.ctx, 4, 0x80000000u); - setRegU32(env.ctx, 5, 0x80080000u); - t.IsTrue(callSyscall(kSyscallIndex, env.rdram.data(), &env.ctx, &env.runtime), - "Override syscall should invoke the guest handler"); - t.Equals(static_cast(getRegS32(env.ctx, 2)), + env.runtime.registerFunction(K_OVERRIDE_ENTRY, schedulerOverrideEntry); + env.runtime.registerFunction(K_OVERRIDE_RESUME, schedulerOverrideResume); + env.runtime.setEeSyscallOverride(env.rdram.data(), kSyscallIndex, kHandler); + + gOverrideSyscall = kSyscallIndex; + R5900Context mainContext{}; + mainContext.pc = K_OVERRIDE_ENTRY; + setRegU32(mainContext, 4, 0x80000000u); + setRegU32(mainContext, 5, 0x80080000u); + env.runtime.eeScheduler().reset(env.rdram.data(), mainContext); + env.runtime.eeScheduler().run(); + + t.Equals(static_cast(getRegS32(gOverrideResult, 2)), 0x80000004u, "Override invocation should preserve KSEG ordering after 32-bit guest writes"); - - notifyRuntimeStop(); }); tc.Run("SetSyscall override preserves upper 64 bits when writing 32-bit args", [](TestCase &t) { - notifyRuntimeStop(); TestEnv env; constexpr uint32_t kSyscallIndex = 0x93u; constexpr uint32_t kHandler = 0x00200040u; env.runtime.registerFunction(kHandler, overridePreserveUpper64Handler); - setRegU32(env.ctx, 4, kSyscallIndex); - setRegU32(env.ctx, 5, kHandler); - t.IsTrue(callSyscall(0x74u, env.rdram.data(), &env.ctx, &env.runtime), - "SetSyscall syscall should dispatch"); - - env.ctx.r[4] = _mm_set_epi64x(static_cast(K_EXPECTED_UPPER64), - static_cast(static_cast(0x80000000u))); - t.IsTrue(callSyscall(kSyscallIndex, env.rdram.data(), &env.ctx, &env.runtime), - "Override syscall should invoke the guest handler"); - t.Equals(static_cast(getRegS32(env.ctx, 2)), + env.runtime.registerFunction(K_OVERRIDE_ENTRY, schedulerOverrideEntry); + env.runtime.registerFunction(K_OVERRIDE_RESUME, schedulerOverrideResume); + env.runtime.setEeSyscallOverride(env.rdram.data(), kSyscallIndex, kHandler); + + gOverrideSyscall = kSyscallIndex; + R5900Context mainContext{}; + mainContext.pc = K_OVERRIDE_ENTRY; + mainContext.r[4] = _mm_set_epi64x(static_cast(K_EXPECTED_UPPER64), + static_cast(static_cast(0x80000000u))); + env.runtime.eeScheduler().reset(env.rdram.data(), mainContext); + env.runtime.eeScheduler().run(); + + t.Equals(static_cast(getRegS32(gOverrideResult, 2)), 1u, "Override invocation should preserve the upper 64 bits of 128-bit GPRs when setting 32-bit args"); - - notifyRuntimeStop(); }); - tc.Run("broken syscall overrides fall back to builtin handlers", [](TestCase &t) + tc.Run("an override that branches to an invalid PC completes without builtin fallback", [](TestCase &t) { - notifyRuntimeStop(); TestEnv env; constexpr uint32_t kHandler = 0x00200010u; - constexpr uint32_t kTableBase = 0x00002000u; - constexpr uint32_t kValues[] = { - 0x11111111u, - 0x11223344u, - 0x55555555u - }; env.runtime.registerFunction(kHandler, overrideBrokenHandler); - setRegU32(env.ctx, 4, 0x83u); - setRegU32(env.ctx, 5, kHandler); - t.IsTrue(callSyscall(0x74u, env.rdram.data(), &env.ctx, &env.runtime), - "SetSyscall syscall should dispatch"); - - writeGuestWords(env.rdram.data(), kTableBase, kValues, std::size(kValues)); - setRegU32(env.ctx, 4, kTableBase); - setRegU32(env.ctx, 5, kTableBase + static_cast(sizeof(kValues))); - setRegU32(env.ctx, 6, 0x11223344u); - t.IsTrue(callSyscall(0x83u, env.rdram.data(), &env.ctx, &env.runtime), - "Builtin syscall should still dispatch when override exits abnormally"); - t.Equals(static_cast(getRegS32(env.ctx, 2)), - kTableBase + 4u, - "Abnormal override exits should fall back to the builtin syscall implementation"); - - notifyRuntimeStop(); + env.runtime.registerFunction(K_OVERRIDE_ENTRY, schedulerOverrideEntry); + env.runtime.registerFunction(K_OVERRIDE_RESUME, schedulerOverrideResume); + env.runtime.setEeSyscallOverride(env.rdram.data(), 0x83u, kHandler); + + gOverrideSyscall = 0x83u; + R5900Context mainContext{}; + mainContext.pc = K_OVERRIDE_ENTRY; + env.runtime.eeScheduler().reset(env.rdram.data(), mainContext); + env.runtime.eeScheduler().run(); + + t.Equals(static_cast(getRegS32(gOverrideResult, 2)), + 0xDEADBEEFu, + "the dispatcher should preserve the invocation result and never call the builtin as a fallback"); }); - tc.Run("reentrant syscall overrides fall back to builtin handlers", [](TestCase &t) + tc.Run("reentrant override invokes the underlying builtin inside its invocation frame", [](TestCase &t) { - notifyRuntimeStop(); TestEnv env; constexpr uint32_t kHandler = 0x00200020u; constexpr uint32_t kTableBase = 0x00003000u; @@ -1500,22 +1380,67 @@ void register_ps2_runtime_kernel_tests() }; env.runtime.registerFunction(kHandler, overrideRecursiveFindAddressHandler); - setRegU32(env.ctx, 4, 0x83u); - setRegU32(env.ctx, 5, kHandler); - t.IsTrue(callSyscall(0x74u, env.rdram.data(), &env.ctx, &env.runtime), - "SetSyscall syscall should dispatch"); + env.runtime.registerFunction(K_OVERRIDE_ENTRY, schedulerOverrideEntry); + env.runtime.registerFunction(K_OVERRIDE_RESUME, schedulerOverrideResume); + env.runtime.setEeSyscallOverride(env.rdram.data(), 0x83u, kHandler); writeGuestWords(env.rdram.data(), kTableBase, kValues, std::size(kValues)); - setRegU32(env.ctx, 4, kTableBase); - setRegU32(env.ctx, 5, kTableBase + static_cast(sizeof(kValues))); - setRegU32(env.ctx, 6, 0x11223344u); - t.IsTrue(callSyscall(0x83u, env.rdram.data(), &env.ctx, &env.runtime), - "Reentrant override should resolve through builtin fallback"); - t.Equals(static_cast(getRegS32(env.ctx, 2)), + gOverrideSyscall = 0x83u; + R5900Context mainContext{}; + mainContext.pc = K_OVERRIDE_ENTRY; + setRegU32(mainContext, 4, kTableBase); + setRegU32(mainContext, 5, kTableBase + static_cast(sizeof(kValues))); + setRegU32(mainContext, 6, 0x11223344u); + env.runtime.eeScheduler().reset(env.rdram.data(), mainContext); + env.runtime.eeScheduler().run(); + + t.Equals(static_cast(getRegS32(gOverrideResult, 2)), kTableBase + 4u, - "Reentrant override dispatch should use builtin syscall implementation"); + "only the recursive call should bypass the active override frame and reach the builtin"); + }); - notifyRuntimeStop(); + tc.Run("a syscall invocation can block and resume without losing its base context", [](TestCase &t) + { + TestEnv env; + constexpr uint32_t kSyscallIndex = 0x94u; + env.runtime.registerFunction(K_OVERRIDE_BLOCK_ENTRY, schedulerBlockingOverrideEntry); + env.runtime.registerFunction(K_OVERRIDE_BLOCK_HANDLER, schedulerBlockingOverrideHandler); + env.runtime.registerFunction(K_OVERRIDE_BLOCK_HANDLER_RESUME, schedulerBlockingOverrideHandlerResume); + env.runtime.registerFunction(K_OVERRIDE_BLOCK_DRIVER, schedulerBlockingOverrideDriver); + env.runtime.registerFunction(K_OVERRIDE_BLOCK_BASE_RESUME, schedulerBlockingOverrideBaseResume); + env.runtime.setEeSyscallOverride(env.rdram.data(), kSyscallIndex, K_OVERRIDE_BLOCK_HANDLER); + + gOverrideSyscall = kSyscallIndex; + gInvocationTrace.clear(); + R5900Context mainContext{}; + mainContext.pc = K_OVERRIDE_BLOCK_ENTRY; + env.runtime.eeScheduler().reset(env.rdram.data(), mainContext); + env.runtime.eeScheduler().run(); + + const std::vector expected{1, 2, 3, 4, 5}; + t.IsTrue(gInvocationTrace == expected, + "the sleeping invocation should yield to the driver, resume its own frame, then restore the base frame"); + t.Equals(static_cast(getRegS32(gOverrideResult, 2)), 0xB10C0EDu, + "the invocation result should reach the preserved base context after the wait"); + }); + + tc.Run("exit handlers run as ordered invocation frames before the thread becomes dormant", [](TestCase &t) + { + TestEnv env; + env.runtime.registerFunction(K_EXIT_MAIN, schedulerExitMain); + env.runtime.registerFunction(K_EXIT_HANDLER_A, schedulerExitHandlerA); + env.runtime.registerFunction(K_EXIT_HANDLER_B, schedulerExitHandlerB); + env.runtime.registerFunction(K_EXIT_OBSERVER, schedulerExitObserver); + + gInvocationTrace.clear(); + R5900Context mainContext{}; + mainContext.pc = K_EXIT_MAIN; + env.runtime.eeScheduler().reset(env.rdram.data(), mainContext); + env.runtime.eeScheduler().run(); + + const std::vector expected{10, 20, 30, 40}; + t.IsTrue(gInvocationTrace == expected, + "exit handlers should retain registration order and complete before another guest thread observes dormancy"); }); tc.Run("Copy syscall (0x5A) performs a memory copy", [](TestCase &t) @@ -1549,9 +1474,8 @@ void register_ps2_runtime_kernel_tests() tc.Run("GetEntryAddress syscall (0x5B) returns handler from guest table", [](TestCase &t) { - notifyRuntimeStop(); TestEnv env; - initializeGuestKernelState(env.rdram.data()); + initializeGuestKernelState(env.rdram.data(), &env.runtime); constexpr uint32_t kGuestSyscallTableGuestBase = 0x80011F80u; constexpr uint32_t kSyscallIndex = 0x5Au; @@ -1568,8 +1492,6 @@ void register_ps2_runtime_kernel_tests() t.Equals(static_cast(getRegS32(env.ctx, 2)), kExpectedHandler, "GetEntryAddress should read and return the handler address from the table"); - - notifyRuntimeStop(); }); }); } diff --git a/ps2xTest/src/ps2_sif_dma_tests.cpp b/ps2xTest/src/ps2_sif_dma_tests.cpp index 852054554..9198d1754 100644 --- a/ps2xTest/src/ps2_sif_dma_tests.cpp +++ b/ps2xTest/src/ps2_sif_dma_tests.cpp @@ -3,6 +3,7 @@ #include "ps2_iop_transport.h" #include "ps2_syscalls.h" #include "ps2_stubs.h" +#include "runtime/ee_scheduler.h" #include #include @@ -112,6 +113,13 @@ namespace uint32_t g_dmacHandlerValue = 0u; uint32_t g_dmacHandlerLastCause = 0u; uint32_t g_dmacHandlerLastArg = 0u; + int32_t g_sifDmaResult = 0; + + constexpr uint32_t kSchedulerSifDmaEntryPc = 0x00101000u; + constexpr uint32_t kSchedulerSifDmaResumePc = 0x00101010u; + constexpr uint32_t kSchedulerSifDmaHandlerPc = 0x00101020u; + constexpr uint32_t kSchedulerSifDmaDescAddr = 0x00020300u; + constexpr uint32_t kSchedulerSifDmaHandlerArg = 0x12345678u; void testDmacHandler(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { @@ -124,6 +132,28 @@ namespace } ctx->pc = 0u; } + + void schedulerSifDmaEntry(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) + { + runtime->eeScheduler().addIrqHandler(true, + 5u, + kSchedulerSifDmaHandlerPc, + true, + kSchedulerSifDmaHandlerArg, + 0u, + 0u); + setRegU32(*ctx, 4, kSchedulerSifDmaDescAddr); + setRegU32(*ctx, 5, 1u); + ctx->pc = kSchedulerSifDmaResumePc; + ps2_stubs::sceSifSetDma(rdram, ctx, runtime); + } + + void schedulerSifDmaResume(uint8_t *, R5900Context *ctx, PS2Runtime *runtime) + { + g_sifDmaResult = getRegS32(*ctx, 2); + ctx->pc = 0u; + runtime->requestStop(); + } } void register_ps2_sif_dma_tests() @@ -205,30 +235,18 @@ void register_ps2_sif_dma_tests() { TestEnv env; - constexpr uint32_t kDescAddr = 0x00020300u; constexpr uint32_t kSrcAddr = 0x00020400u; constexpr uint32_t kDstAddr = 0x00020500u; - constexpr uint32_t kHandlerAddr = 0x00100000u; constexpr uint32_t kHandlerWriteAddr = 0x00020600u; - constexpr uint32_t kHandlerArg = 0x12345678u; g_dmacHandlerWriteAddr = kHandlerWriteAddr; g_dmacHandlerValue = 0xCAFEBABEu; g_dmacHandlerLastCause = 0u; g_dmacHandlerLastArg = 0u; - env.runtime.registerFunction(kHandlerAddr, &testDmacHandler); - - setRegU32(env.ctx, 4, 5u); - setRegU32(env.ctx, 5, kHandlerAddr); - setRegU32(env.ctx, 6, 0u); - setRegU32(env.ctx, 7, kHandlerArg); - ps2_syscalls::AddDmacHandler(env.rdram.data(), &env.ctx, &env.runtime); - const int32_t handlerId = getRegS32(env.ctx, 2); - t.IsTrue(handlerId > 0, "AddDmacHandler should register a handler"); - - setRegU32(env.ctx, 4, 5u); - ps2_syscalls::EnableDmac(env.rdram.data(), &env.ctx, &env.runtime); - t.Equals(getRegS32(env.ctx, 2), 0, "EnableDmac should succeed"); + g_sifDmaResult = 0; + env.runtime.registerFunction(kSchedulerSifDmaEntryPc, schedulerSifDmaEntry); + env.runtime.registerFunction(kSchedulerSifDmaResumePc, schedulerSifDmaResume); + env.runtime.registerFunction(kSchedulerSifDmaHandlerPc, testDmacHandler); std::array payload{}; for (size_t i = 0; i < payload.size(); ++i) @@ -242,17 +260,19 @@ void register_ps2_sif_dma_tests() kDstAddr, static_cast(payload.size()), 0}; - std::memcpy(env.rdram.data() + kDescAddr, &desc, sizeof(desc)); + std::memcpy(env.rdram.data() + kSchedulerSifDmaDescAddr, &desc, sizeof(desc)); - setRegU32(env.ctx, 4, kDescAddr); - setRegU32(env.ctx, 5, 1u); - ps2_stubs::sceSifSetDma(env.rdram.data(), &env.ctx, &env.runtime); + R5900Context mainContext{}; + mainContext.pc = kSchedulerSifDmaEntryPc; + env.runtime.eeScheduler().reset(env.rdram.data(), mainContext); + env.runtime.eeScheduler().run(); - t.IsTrue(getRegS32(env.ctx, 2) > 0, "sceSifSetDma should still report success"); + t.IsTrue(g_sifDmaResult > 0, "sceSifSetDma should still report success"); t.Equals(readGuestU32(env.rdram.data(), kHandlerWriteAddr), g_dmacHandlerValue, - "sceSifSetDma should invoke registered DMAC handlers"); + "the scheduler should execute the queued DMAC invocation"); t.Equals(g_dmacHandlerLastCause, 5u, "DMAC handler should observe cause 5"); - t.Equals(g_dmacHandlerLastArg, kHandlerArg, "DMAC handler should receive registered argument"); + t.Equals(g_dmacHandlerLastArg, kSchedulerSifDmaHandlerArg, + "DMAC handler should receive registered argument"); }); tc.Run("sceSifSetDma acknowledges DTX work-buffer transfers by advancing the EE footer ticket", [](TestCase &t) diff --git a/ps2xTest/src/ps2_sif_rpc_tests.cpp b/ps2xTest/src/ps2_sif_rpc_tests.cpp index 7a4371fbf..d49274c47 100644 --- a/ps2xTest/src/ps2_sif_rpc_tests.cpp +++ b/ps2xTest/src/ps2_sif_rpc_tests.cpp @@ -1,8 +1,10 @@ #include "MiniTest.h" #include "ps2_runtime.h" +#include "ps2_runtime_macros.h" #include "ps2_iop_transport.h" #include "ps2_syscalls.h" #include "ps2_stubs.h" +#include "runtime/ee_scheduler.h" #include #include @@ -161,6 +163,13 @@ namespace constexpr uint32_t K_DTX_DISPATCH_RESULT_ADDR = 0x0002D800u; constexpr uint32_t K_DTX_DISPATCH_RESULT_MARKER = 0xD15CA7C1u; + constexpr uint32_t K_DTX_SCHEDULER_CALL = 0x00102000u; + constexpr uint32_t K_DTX_SCHEDULER_RESUME = 0x00102010u; + uint32_t g_schedulerRpcClient = 0u; + uint32_t g_schedulerRpcNumber = 0u; + uint32_t g_schedulerRpcSend = 0u; + uint32_t g_schedulerRpcReceive = 0u; + uint32_t g_schedulerRpcResult = 0u; void lotrSoundEndCallbackShouldNotRun(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { @@ -178,6 +187,27 @@ namespace ctx->pc = ::getRegU32(ctx, 31); } + void schedulerDtxRpcCall(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) + { + SET_GPR_U32(ctx, 4, g_schedulerRpcClient); + SET_GPR_U32(ctx, 5, g_schedulerRpcNumber); + SET_GPR_U32(ctx, 6, 0u); + SET_GPR_U32(ctx, 7, g_schedulerRpcSend); + SET_GPR_U32(ctx, 8, 8u); + SET_GPR_U32(ctx, 9, g_schedulerRpcReceive); + SET_GPR_U32(ctx, 10, sizeof(uint32_t)); + SET_GPR_U32(ctx, 11, 0u); + ctx->pc = K_DTX_SCHEDULER_RESUME; + SifCallRpc(rdram, ctx, runtime); + } + + void schedulerDtxRpcResume(uint8_t *, R5900Context *ctx, PS2Runtime *runtime) + { + g_schedulerRpcResult = ::getRegU32(ctx, 2); + ctx->pc = 0u; + runtime->requestStop(); + } + void recvxDtxDispatcher(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { (void)runtime; @@ -1156,7 +1186,22 @@ void register_ps2_sif_rpc_tests() writeGuestU32(env.rdram.data(), kFnTableSlot, kRegisteredHandlerAddr); writeGuestU32(env.rdram.data(), kRecvAddr, 0u); - callUrpc(); + env.runtime.registerFunction(K_DTX_SCHEDULER_CALL, schedulerDtxRpcCall); + env.runtime.registerFunction(K_DTX_SCHEDULER_RESUME, schedulerDtxRpcResume); + g_schedulerRpcClient = kClientAddr; + g_schedulerRpcNumber = kRpcNum; + g_schedulerRpcSend = kSendAddr; + g_schedulerRpcReceive = kRecvAddr; + g_schedulerRpcResult = static_cast(-1); + R5900Context mainContext{}; + mainContext.pc = K_DTX_SCHEDULER_CALL; + setRegU32(mainContext, 29, K_STACK_ADDR); + writeGuestU32(env.rdram.data(), K_STACK_ADDR + 0x00u, 0u); + env.runtime.eeScheduler().reset(env.rdram.data(), mainContext); + env.runtime.eeScheduler().run(); + + t.Equals(g_schedulerRpcResult, static_cast(KE_OK), + "DTX URPC should resume its base context with KE_OK"); t.Equals(g_dtxDispatcherHits.load(), 1u, "registered DTX function-table slot should enter the guest dispatcher"); From 9f99d615c5d7022eab9b16cc79c89a95ab0e1556 Mon Sep 17 00:00:00 2001 From: Ran-j Date: Sat, 25 Jul 2026 21:26:31 -0300 Subject: [PATCH 2/8] feat: bad wip mpeg fix for code veronica --- ps2xRuntime/include/ps2_runtime.h | 2 + ps2xRuntime/include/runtime/ee_scheduler.h | 7 +- ps2xRuntime/include/runtime/ps2_memory.h | 2 - ps2xRuntime/src/lib/Kernel/EeScheduler.cpp | 26 +-- ps2xRuntime/src/lib/Kernel/Stubs/CD.cpp | 7 +- ps2xRuntime/src/lib/Kernel/Stubs/MPEG.cpp | 183 ++++++++++++++++-- ps2xRuntime/src/lib/Kernel/Stubs/MPEG.h | 1 + ps2xTest/src/ps2_runtime_expansion_tests.cpp | 186 +++++++++++++++++++ 8 files changed, 375 insertions(+), 39 deletions(-) diff --git a/ps2xRuntime/include/ps2_runtime.h b/ps2xRuntime/include/ps2_runtime.h index da4a81b7a..585e44682 100644 --- a/ps2xRuntime/include/ps2_runtime.h +++ b/ps2xRuntime/include/ps2_runtime.h @@ -249,6 +249,7 @@ inline void ps2TraceGuestWrite(uint8_t *rdram, (void)valueHi; (void)op; (void)ctx; + // TODO we dont need this anymore so on next release it will be deleted } inline void ps2TraceGuestRangeWrite(uint8_t *rdram, @@ -262,6 +263,7 @@ inline void ps2TraceGuestRangeWrite(uint8_t *rdram, (void)size; (void)op; (void)ctx; + // TODO we dont need this anymore so on next release it will be deleted } class PS2Runtime diff --git a/ps2xRuntime/include/runtime/ee_scheduler.h b/ps2xRuntime/include/runtime/ee_scheduler.h index 8fb1e263a..03ac89aca 100644 --- a/ps2xRuntime/include/runtime/ee_scheduler.h +++ b/ps2xRuntime/include/runtime/ee_scheduler.h @@ -322,13 +322,10 @@ class EeScheduler [[nodiscard]] uint64_t currentVSyncTick() const noexcept; uint32_t setGsVSyncCallback(uint32_t callback, uint32_t gp, uint32_t sp); - [[noreturn]] void waitVSync(uint64_t afterTick, int fixedResult = -1); + [[noreturn]] void waitVSync(uint64_t afterTick, int fixedResult = -1, std::function completion = {}); void completeVSync(uint64_t tick); void completeExternalWait(uint32_t type, uint64_t token, int result); - [[noreturn]] void waitExternal(EeWaitReason reason, - uint32_t type, - uint64_t token, - std::function completion = {}); + [[noreturn]] void waitExternal(EeWaitReason reason, uint32_t type, uint64_t token, std::function completion = {}); [[nodiscard]] GuestThread *thread(int id); [[nodiscard]] const GuestThread *thread(int id) const; diff --git a/ps2xRuntime/include/runtime/ps2_memory.h b/ps2xRuntime/include/runtime/ps2_memory.h index cd96b5a74..dae74b4ed 100644 --- a/ps2xRuntime/include/runtime/ps2_memory.h +++ b/ps2xRuntime/include/runtime/ps2_memory.h @@ -204,8 +204,6 @@ struct GSRegisters uint64_t extdata; // External data uint64_t extwrite; // External write uint64_t bgcolor; // Background color - // Status remains atomic because the renderer/UI can observe it while the - // single EE executor updates SIGNAL, FINISH and FIELD. std::atomic csr; std::atomic vsyncTick; uint64_t imr; // Interrupt mask diff --git a/ps2xRuntime/src/lib/Kernel/EeScheduler.cpp b/ps2xRuntime/src/lib/Kernel/EeScheduler.cpp index 9901f0147..551bc95ad 100644 --- a/ps2xRuntime/src/lib/Kernel/EeScheduler.cpp +++ b/ps2xRuntime/src/lib/Kernel/EeScheduler.cpp @@ -1004,10 +1004,8 @@ int EeScheduler::cancelAlarm(int id) { std::lock_guard lock(m_eventMutex); std::erase_if(m_deadlines, [id](const ScheduledEvent &scheduled) - { - return scheduled.event.type == EeEventType::Alarm && - scheduled.event.id == static_cast(id); - }); + { return scheduled.event.type == EeEventType::Alarm && + scheduled.event.id == static_cast(id); }); updateNextDeadline(); } return KE_OK; @@ -1235,9 +1233,12 @@ uint32_t EeScheduler::setGsVSyncCallback(uint32_t callback, uint32_t gp, uint32_ return previous; } -[[noreturn]] void EeScheduler::waitVSync(uint64_t afterTick, int fixedResult) +[[noreturn]] void EeScheduler::waitVSync(uint64_t afterTick, int fixedResult, std::function completion) { - blockCurrent(EeWaitState{EeWaitReason::VSync, EeVSyncWait{afterTick, fixedResult}}); + blockCurrent(EeWaitState{ + EeWaitReason::VSync, + EeVSyncWait{afterTick, fixedResult}, + std::move(completion)}); } void EeScheduler::completeVSync(uint64_t tick) @@ -1438,10 +1439,10 @@ void EeScheduler::publishSnapshot() for (const auto &[id, item] : m_eventFlags) { next.eventFlags.push_back(EeEventFlagSnapshot{id, - item.bits, - item.initBits, - item.attr, - static_cast(item.waiters.size())}); + item.bits, + item.initBits, + item.attr, + static_cast(item.waiters.size())}); } std::sort(next.eventFlags.begin(), next.eventFlags.end(), [](const auto &left, const auto &right) { return left.id < right.id; }); @@ -1686,8 +1687,7 @@ void EeScheduler::processDueDeadlines() { return left.event.id < right.event.id; } - return left.sequence < right.sequence; - }); + return left.sequence < right.sequence; }); for (ScheduledEvent &scheduled : due) { if (scheduled.event.type == EeEventType::VBlankStart) @@ -1806,7 +1806,7 @@ void EeScheduler::finishEventWaiters(EeEventFlag &flag, bool interruptSafe) bool EeScheduler::eventCondition(uint32_t current, uint32_t requested, uint32_t mode) { return (mode & WEF_OR) != 0u ? (current & requested) != 0u - : (current & requested) == requested; + : (current & requested) == requested; } int EeScheduler::waitObjectId(const EeWaitState &wait) diff --git a/ps2xRuntime/src/lib/Kernel/Stubs/CD.cpp b/ps2xRuntime/src/lib/Kernel/Stubs/CD.cpp index 1d6db890e..4c20a21d0 100644 --- a/ps2xRuntime/src/lib/Kernel/Stubs/CD.cpp +++ b/ps2xRuntime/src/lib/Kernel/Stubs/CD.cpp @@ -571,10 +571,9 @@ namespace ps2_stubs { std::memset(rdram + offset + bytes, 0, requestedBytes - bytes); } - if (hitStreamEnd || g_cdStreamingLbn == g_cdStreamingEndLbn) - { - notifyMpegCdStreamEof(runtime); - } + notifyMpegCdStreamDataProduced( + static_cast(bytes), + hitStreamEnd || g_cdStreamingLbn == g_cdStreamingEndLbn); } else { diff --git a/ps2xRuntime/src/lib/Kernel/Stubs/MPEG.cpp b/ps2xRuntime/src/lib/Kernel/Stubs/MPEG.cpp index 8e1e2ddc1..caa84a205 100644 --- a/ps2xRuntime/src/lib/Kernel/Stubs/MPEG.cpp +++ b/ps2xRuntime/src/lib/Kernel/Stubs/MPEG.cpp @@ -477,6 +477,8 @@ namespace ps2_stubs std::vector pssGuestAddrs; std::deque decodedFrames; std::unique_ptr decoder; + uint64_t pictureIntervalQ32 = 0u; + uint64_t nextPictureTickQ32 = std::numeric_limits::max(); }; struct MpegStreamCallbackEvent @@ -495,6 +497,9 @@ namespace ps2_stubs bool initialized = false; uint32_t nextCallbackHandle = 1u; uint64_t cdStreamGeneration = 0u; + uint64_t cdStreamBytesProduced = 0u; + uint64_t cdStreamBytesDemuxed = 0u; + bool cdStreamEofPending = false; bool currentCdStreamEofSeen = false; uint32_t feedEsTraceCount = 0u; uint32_t demuxPssTraceCount = 0u; @@ -523,6 +528,51 @@ namespace ps2_stubs constexpr uint8_t kMpegPrivateStream1 = 0xBDu; constexpr size_t kStartCodeNotFound = std::numeric_limits::max(); constexpr uint32_t kMpegCallbackDataSize = 0x20u; + constexpr uint64_t kPictureClockOne = 1ull << 32u; + + uint64_t mpegPictureIntervalQ32(uint8_t frameRateCode) + { + uint64_t frameRateNumerator = 0u; + uint64_t frameRateDenominator = 1u; + switch (frameRateCode) + { + case 1u: + frameRateNumerator = 24000u; + frameRateDenominator = 1001u; + break; + case 2u: + frameRateNumerator = 24u; + break; + case 3u: + frameRateNumerator = 25u; + break; + case 4u: + frameRateNumerator = 30000u; + frameRateDenominator = 1001u; + break; + case 5u: + frameRateNumerator = 30u; + break; + case 6u: + frameRateNumerator = 50u; + break; + case 7u: + frameRateNumerator = 60000u; + frameRateDenominator = 1001u; + break; + case 8u: + frameRateNumerator = 60u; + break; + default: + return 0u; + } + + // EE VSync runs at the NTSC field rate. Q32 preserves fractional + // cadences such as 24 fps without accumulating host-time drift. + const uint64_t denominator = 1001u * frameRateNumerator; + const uint64_t numerator = (60000u * frameRateDenominator) << 32u; + return std::max(kPictureClockOne, (numerator + denominator / 2u) / denominator); + } uint32_t align16(uint32_t value) { @@ -644,12 +694,12 @@ namespace ps2_stubs size_t findMpegSequenceHeader(const uint8_t *data, size_t size) { - if (!data || size < 7u) + if (!data || size < 8u) { return kStartCodeNotFound; } - for (size_t i = 0; i + 6u < size; ++i) + for (size_t i = 0; i + 7u < size; ++i) { if (data[i] == 0x00u && data[i + 1u] == 0x00u && @@ -660,7 +710,9 @@ namespace ps2_stubs (static_cast(data[i + 5u]) >> 4u); const uint32_t height = ((static_cast(data[i + 5u]) & 0x0Fu) << 8u) | static_cast(data[i + 6u]); - if (width != 0u && height != 0u && width <= 4096u && height <= 4096u) + const uint8_t frameRateCode = data[i + 7u] & 0x0Fu; + if (width != 0u && height != 0u && width <= 4096u && height <= 4096u && + mpegPictureIntervalQ32(frameRateCode) != 0u) { return i; } @@ -781,6 +833,8 @@ namespace ps2_stubs data = playback.videoSequenceSyncBuffer.data(); size = playback.videoSequenceSyncBuffer.size(); + playback.pictureIntervalQ32 = mpegPictureIntervalQ32(data[7u] & 0x0Fu); + playback.nextPictureTickQ32 = std::numeric_limits::max(); playback.waitingForVideoSequenceHeader = false; playback.decoderFailed = false; playback.decoder.reset(); @@ -1064,6 +1118,36 @@ namespace ps2_stubs flushDecoderIfEnded(playback); } + void finalizeCdStreamEofUnlocked(std::vector &completedMpegIds, bool &changed) + { + g_mpeg_stub_state.cdStreamEofPending = false; + g_mpeg_stub_state.currentCdStreamEofSeen = true; + for (auto &[mpegAddr, playback] : g_mpeg_stub_state.playbackByMpeg) + { + completedMpegIds.push_back(mpegAddr); + if (!playback.sawInput || playback.streamEnded) + { + continue; + } + + finishPlaybackStream(mpegAddr, playback); + changed = true; + } + } + + void recordCdStreamBytesDemuxedUnlocked( + size_t consumed, + std::vector &completedMpegIds, + bool &changed) + { + g_mpeg_stub_state.cdStreamBytesDemuxed += consumed; + if (g_mpeg_stub_state.cdStreamEofPending && + g_mpeg_stub_state.cdStreamBytesDemuxed >= g_mpeg_stub_state.cdStreamBytesProduced) + { + finalizeCdStreamEofUnlocked(completedMpegIds, changed); + } + } + void appendPssBytes(uint32_t mpegAddr, MpegPlaybackState &playback, const uint8_t *data, @@ -1385,6 +1469,9 @@ namespace ps2_stubs g_mpeg_stub_state.initialized = false; g_mpeg_stub_state.nextCallbackHandle = 1u; g_mpeg_stub_state.cdStreamGeneration = 0u; + g_mpeg_stub_state.cdStreamBytesProduced = 0u; + g_mpeg_stub_state.cdStreamBytesDemuxed = 0u; + g_mpeg_stub_state.cdStreamEofPending = false; g_mpeg_stub_state.currentCdStreamEofSeen = false; g_mpeg_stub_state.feedEsTraceCount = 0u; g_mpeg_stub_state.demuxPssTraceCount = 0u; @@ -1424,6 +1511,9 @@ namespace ps2_stubs (void)runtime; std::lock_guard lock(g_mpeg_stub_mutex); ++g_mpeg_stub_state.cdStreamGeneration; + g_mpeg_stub_state.cdStreamBytesProduced = 0u; + g_mpeg_stub_state.cdStreamBytesDemuxed = 0u; + g_mpeg_stub_state.cdStreamEofPending = false; g_mpeg_stub_state.currentCdStreamEofSeen = false; g_mpeg_stub_state.feedEsTraceCount = 0u; g_mpeg_stub_state.demuxPssTraceCount = 0u; @@ -1442,24 +1532,23 @@ namespace ps2_stubs }); } + void notifyMpegCdStreamDataProduced(uint32_t byteCount, bool endOfStream) + { + std::lock_guard lock(g_mpeg_stub_mutex); + g_mpeg_stub_state.cdStreamBytesProduced += byteCount; + if (endOfStream) + { + g_mpeg_stub_state.cdStreamEofPending = true; + } + } + void notifyMpegCdStreamEof(PS2Runtime *runtime) { std::vector completedMpegIds; bool changed = false; { std::lock_guard lock(g_mpeg_stub_mutex); - g_mpeg_stub_state.currentCdStreamEofSeen = true; - for (auto &[mpegAddr, playback] : g_mpeg_stub_state.playbackByMpeg) - { - completedMpegIds.push_back(mpegAddr); - if (!playback.sawInput || playback.streamEnded) - { - continue; - } - - finishPlaybackStream(mpegAddr, playback); - changed = true; - } + finalizeCdStreamEofUnlocked(completedMpegIds, changed); } if (changed) @@ -1702,17 +1791,28 @@ namespace ps2_stubs const uint32_t byteCount = getRegU32(ctx, 6); std::vector callbackEvents; + std::vector completedMpegIds; size_t consumed = 0u; size_t decodedCount = 0u; uint32_t traceIdx = 0u; + bool eofChanged = false; { std::lock_guard lock(g_mpeg_stub_mutex); MpegPlaybackState &playback = getPlaybackState(mpegAddr); consumed = appendGuestBytes(mpegAddr, playback, rdram, dataAddr, byteCount, callbackEvents); + recordCdStreamBytesDemuxedUnlocked(consumed, completedMpegIds, eofChanged); decodedCount = playback.decodedFrames.size(); traceIdx = g_mpeg_stub_state.demuxPssTraceCount++; } runtime->eeScheduler().completeExternalWait(kMpegPictureWaitType, mpegAddr, KE_OK); + for (const uint32_t completedMpegId : completedMpegIds) + { + if (completedMpegId != mpegAddr) + { + runtime->eeScheduler().completeExternalWait( + kMpegPictureWaitType, completedMpegId, KE_OK); + } + } if (traceIdx < 32u) { @@ -1752,9 +1852,11 @@ namespace ps2_stubs const uint32_t ringSize = readAbiArg4(rdram, ctx); std::vector callbackEvents; + std::vector completedMpegIds; size_t consumed = 0u; size_t decodedCount = 0u; uint32_t traceIdx = 0u; + bool eofChanged = false; { std::lock_guard lock(g_mpeg_stub_mutex); MpegPlaybackState &playback = getPlaybackState(mpegAddr); @@ -1767,10 +1869,19 @@ namespace ps2_stubs ringBaseAddr, ringSize, callbackEvents); + recordCdStreamBytesDemuxedUnlocked(consumed, completedMpegIds, eofChanged); decodedCount = playback.decodedFrames.size(); traceIdx = g_mpeg_stub_state.demuxRingTraceCount++; } runtime->eeScheduler().completeExternalWait(kMpegPictureWaitType, mpegAddr, KE_OK); + for (const uint32_t completedMpegId : completedMpegIds) + { + if (completedMpegId != mpegAddr) + { + runtime->eeScheduler().completeExternalWait( + kMpegPictureWaitType, completedMpegId, KE_OK); + } + } if (traceIdx < 32u) { @@ -1875,6 +1986,42 @@ namespace ps2_stubs if (!playback.decodedFrames.empty()) { + if (playback.pictureIntervalQ32 != 0u) + { + const uint64_t currentTick = runtime->eeScheduler().currentVSyncTick(); + const uint64_t currentTickQ32 = currentTick << 32u; + if (playback.nextPictureTickQ32 == std::numeric_limits::max()) + { + playback.nextPictureTickQ32 = currentTickQ32; + } + + if (currentTickQ32 < playback.nextPictureTickQ32) + { + const uint64_t eligibleTick = + (playback.nextPictureTickQ32 + kPictureClockOne - 1u) >> 32u; + lock.unlock(); + runtime->eeScheduler().waitVSync( + eligibleTick - 1u, + -1, + [rdram, runtime](R5900Context &resumeContext) + { + if (static_cast(getRegU32(&resumeContext, 2)) < 0) + { + return; + } + sceMpegGetPicture(rdram, &resumeContext, runtime); + }); + } + + // If decoding fell more than one frame behind, resume from the + // current field instead of releasing a burst of stale pictures. + if (currentTickQ32 - playback.nextPictureTickQ32 >= playback.pictureIntervalQ32) + { + playback.nextPictureTickQ32 = currentTickQ32; + } + playback.nextPictureTickQ32 += playback.pictureIntervalQ32; + } + frame = std::move(playback.decodedFrames.front()); playback.decodedFrames.pop_front(); playback.width = static_cast(frame.width); @@ -1948,10 +2095,16 @@ namespace ps2_stubs (void)rdram; std::lock_guard lock(g_mpeg_stub_mutex); const uint64_t cdStreamGeneration = g_mpeg_stub_state.cdStreamGeneration; + const uint64_t cdStreamBytesProduced = g_mpeg_stub_state.cdStreamBytesProduced; + const uint64_t cdStreamBytesDemuxed = g_mpeg_stub_state.cdStreamBytesDemuxed; + const bool cdStreamEofPending = g_mpeg_stub_state.cdStreamEofPending; const bool currentCdStreamEofSeen = g_mpeg_stub_state.currentCdStreamEofSeen; resetMpegStubStateUnlocked(); g_mpeg_stub_state.initialized = true; g_mpeg_stub_state.cdStreamGeneration = cdStreamGeneration; + g_mpeg_stub_state.cdStreamBytesProduced = cdStreamBytesProduced; + g_mpeg_stub_state.cdStreamBytesDemuxed = cdStreamBytesDemuxed; + g_mpeg_stub_state.cdStreamEofPending = cdStreamEofPending; g_mpeg_stub_state.currentCdStreamEofSeen = currentCdStreamEofSeen; setReturnU32(ctx, 0u); } diff --git a/ps2xRuntime/src/lib/Kernel/Stubs/MPEG.h b/ps2xRuntime/src/lib/Kernel/Stubs/MPEG.h index 76225e990..bbf7edf76 100644 --- a/ps2xRuntime/src/lib/Kernel/Stubs/MPEG.h +++ b/ps2xRuntime/src/lib/Kernel/Stubs/MPEG.h @@ -7,6 +7,7 @@ namespace ps2_stubs void resetMpegStubState(); void enqueueMpegDecodedFrameForTesting(uint32_t mpegAddr); void notifyMpegCdStreamStart(PS2Runtime *runtime = nullptr); + void notifyMpegCdStreamDataProduced(uint32_t byteCount, bool endOfStream); void notifyMpegCdStreamEof(PS2Runtime *runtime = nullptr); void sceMpegFlush(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime); void sceMpegAddBs(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime); diff --git a/ps2xTest/src/ps2_runtime_expansion_tests.cpp b/ps2xTest/src/ps2_runtime_expansion_tests.cpp index bc8d8bf86..fba12b8da 100644 --- a/ps2xTest/src/ps2_runtime_expansion_tests.cpp +++ b/ps2xTest/src/ps2_runtime_expansion_tests.cpp @@ -151,6 +151,10 @@ namespace std::atomic gMpegWaitStage{0u}; std::atomic gMpegNoDuplicateStage{0u}; std::atomic gMpegNoDuplicateProducerStage{0u}; + std::atomic gMpegPacingStage{0u}; + std::atomic gMpegPacingFirstProducerStage{0u}; + std::atomic gMpegPacingSecondProducerStage{0u}; + std::atomic gMpegPacingResumeTick{0u}; constexpr uint32_t kMpegWaitMainPc = 0x00125000u; constexpr uint32_t kMpegWaitResumePc = 0x00125010u; @@ -162,6 +166,13 @@ namespace constexpr uint32_t kMpegNoDuplicateProducerPc = 0x00125050u; constexpr uint32_t kMpegNoDuplicateHandle = 0x00124000u; constexpr uint32_t kMpegNoDuplicateImage = 0x00131000u; + constexpr uint32_t kMpegPacingMainPc = 0x00125060u; + constexpr uint32_t kMpegPacingAfterFirstPc = 0x00125070u; + constexpr uint32_t kMpegPacingAfterSecondPc = 0x00125080u; + constexpr uint32_t kMpegPacingFirstProducerPc = 0x00125090u; + constexpr uint32_t kMpegPacingSecondProducerPc = 0x001250A0u; + constexpr uint32_t kMpegPacingHandle = 0x00124800u; + constexpr uint32_t kMpegPacingImage = 0x00132000u; constexpr uint32_t kIpuInitMainPc = 0x00125100u; constexpr uint32_t kIpuInitResumePc = 0x00125104u; constexpr uint32_t kIpuSetD4Pc = 0x00126428u; @@ -251,6 +262,51 @@ namespace ctx->pc = 0u; } + void testMpegPacingMain(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) + { + setRegU32(*ctx, 4, kMpegPacingHandle); + setRegU32(*ctx, 5, kMpegPacingImage); + ctx->pc = kMpegPacingAfterFirstPc; + ps2_stubs::sceMpegGetPicture(rdram, ctx, runtime); + } + + void testMpegPacingAfterFirst(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) + { + gMpegPacingStage.store(1u, std::memory_order_release); + setRegU32(*ctx, 4, kMpegPacingHandle); + setRegU32(*ctx, 5, kMpegPacingImage); + ctx->pc = kMpegPacingAfterSecondPc; + ps2_stubs::sceMpegGetPicture(rdram, ctx, runtime); + } + + void testMpegPacingAfterSecond(uint8_t *, R5900Context *ctx, PS2Runtime *runtime) + { + gMpegPacingResumeTick.store( + runtime->eeScheduler().currentVSyncTick(), + std::memory_order_release); + gMpegPacingStage.store(3u, std::memory_order_release); + ctx->pc = 0u; + runtime->requestStop(); + } + + void testMpegPacingFirstProducer(uint8_t *, R5900Context *ctx, PS2Runtime *runtime) + { + gMpegPacingFirstProducerStage.store( + gMpegPacingStage.load(std::memory_order_acquire), + std::memory_order_release); + runtime->eeScheduler().postEvent(EeEvent{EeEventType::VBlankStart, 0u, 0u}); + ctx->pc = 0u; + } + + void testMpegPacingSecondProducer(uint8_t *, R5900Context *ctx, PS2Runtime *runtime) + { + gMpegPacingSecondProducerStage.store( + gMpegPacingStage.load(std::memory_order_acquire), + std::memory_order_release); + runtime->eeScheduler().postEvent(EeEvent{EeEventType::VBlankStart, 0u, 0u}); + ctx->pc = 0u; + } + void testRecordMpegStreamCallback(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { if (!rdram || !ctx) @@ -694,6 +750,66 @@ void register_ps2_runtime_expansion_tests() "resumed GetPicture should publish the configured height"); }); + tc.Run("CD EOF becomes visible only after the final guest MPEG demux", [](TestCase &t) + { + PS2Runtime runtime; + std::vector rdram(PS2_RAM_SIZE, 0u); + ps2_stubs::resetMpegStubState(); + ps2_stubs::notifyMpegCdStreamStart(); + + constexpr uint32_t kMpegAddr = 0x00126000u; + constexpr uint32_t kPacketAddr = 0x00127000u; + const std::vector finalPacket = { + 0x00u, 0x00u, 0x01u, 0xE0u, + 0x00u, 0x04u, + 0x80u, 0x00u, 0x00u, + 0x00u}; + std::memcpy(rdram.data() + kPacketAddr, finalPacket.data(), finalPacket.size()); + + ps2_stubs::notifyMpegCdStreamDataProduced( + static_cast(finalPacket.size()), true); + + R5900Context beforeDemuxCtx{}; + setRegU32(beforeDemuxCtx, 4, kMpegAddr); + ps2_stubs::sceMpegIsEnd(rdram.data(), &beforeDemuxCtx, &runtime); + t.Equals(getRegS32(beforeDemuxCtx, 2), 0, + "physical CD EOF must not end MPEG before the final guest buffer is demuxed"); + + constexpr uint32_t kFirstPartSize = 5u; + R5900Context firstDemuxCtx{}; + setRegU32(firstDemuxCtx, 4, kMpegAddr); + setRegU32(firstDemuxCtx, 5, kPacketAddr); + setRegU32(firstDemuxCtx, 6, kFirstPartSize); + setRegU32(firstDemuxCtx, 7, kPacketAddr); + setRegU32(firstDemuxCtx, 8, static_cast(finalPacket.size())); + ps2_stubs::sceMpegDemuxPssRing(rdram.data(), &firstDemuxCtx, &runtime); + t.Equals(getRegS32(firstDemuxCtx, 2), static_cast(kFirstPartSize), + "the partial final MPEG buffer should be consumed"); + + R5900Context midwayCtx{}; + setRegU32(midwayCtx, 4, kMpegAddr); + ps2_stubs::sceMpegIsEnd(rdram.data(), &midwayCtx, &runtime); + t.Equals(getRegS32(midwayCtx, 2), 0, + "a partial final MPEG demux must keep physical CD EOF pending"); + + const uint32_t remainingSize = static_cast(finalPacket.size()) - kFirstPartSize; + R5900Context finalDemuxCtx{}; + setRegU32(finalDemuxCtx, 4, kMpegAddr); + setRegU32(finalDemuxCtx, 5, kPacketAddr + kFirstPartSize); + setRegU32(finalDemuxCtx, 6, remainingSize); + setRegU32(finalDemuxCtx, 7, kPacketAddr); + setRegU32(finalDemuxCtx, 8, static_cast(finalPacket.size())); + ps2_stubs::sceMpegDemuxPssRing(rdram.data(), &finalDemuxCtx, &runtime); + t.Equals(getRegS32(finalDemuxCtx, 2), static_cast(remainingSize), + "the final guest MPEG bytes should be consumed before EOF is committed"); + + R5900Context afterDemuxCtx{}; + setRegU32(afterDemuxCtx, 4, kMpegAddr); + ps2_stubs::sceMpegIsEnd(rdram.data(), &afterDemuxCtx, &runtime); + t.Equals(getRegS32(afterDemuxCtx, 2), 1, + "MPEG should end after the pending final guest buffer is demuxed"); + }); + tc.Run("sceMpegGetPicture waits for new decoder output instead of duplicating the last frame", [](TestCase &t) { PS2Runtime runtime; @@ -726,6 +842,76 @@ void register_ps2_runtime_expansion_tests() "only the injected decoder frame should be counted as served"); }); + tc.Run("sceMpegGetPicture resumes its HLE operation at the MPEG frame cadence", [](TestCase &t) + { + PS2Runtime runtime; + std::vector rdram(PS2_RAM_SIZE, 0u); + ps2_stubs::resetMpegStubState(); + ps2_stubs::notifyMpegCdStreamStart(); + + constexpr uint32_t kSequencePacketAddr = 0x00127000u; + const std::vector sequencePacket = { + 0x00u, 0x00u, 0x01u, 0xE0u, + 0x00u, 0x0Bu, + 0x80u, 0x00u, 0x00u, + 0x00u, 0x00u, 0x01u, 0xB3u, + 0x14u, 0x01u, 0x60u, 0x14u}; + std::memcpy( + rdram.data() + kSequencePacketAddr, + sequencePacket.data(), + sequencePacket.size()); + + R5900Context demuxContext{}; + runtime.eeScheduler().reset(rdram.data(), demuxContext); + setRegU32(demuxContext, 4, kMpegPacingHandle); + setRegU32(demuxContext, 5, kSequencePacketAddr); + setRegU32(demuxContext, 6, static_cast(sequencePacket.size())); + setRegU32(demuxContext, 7, kSequencePacketAddr); + setRegU32(demuxContext, 8, static_cast(sequencePacket.size())); + ps2_stubs::sceMpegDemuxPssRing(rdram.data(), &demuxContext, &runtime); + t.Equals( + getRegS32(demuxContext, 2), + static_cast(sequencePacket.size()), + "the 29.97 fps MPEG sequence header should be consumed"); + + ps2_stubs::enqueueMpegDecodedFrameForTesting(kMpegPacingHandle); + ps2_stubs::enqueueMpegDecodedFrameForTesting(kMpegPacingHandle); + runtime.registerFunction(kMpegPacingMainPc, testMpegPacingMain); + runtime.registerFunction(kMpegPacingAfterFirstPc, testMpegPacingAfterFirst); + runtime.registerFunction(kMpegPacingAfterSecondPc, testMpegPacingAfterSecond); + runtime.registerFunction(kMpegPacingFirstProducerPc, testMpegPacingFirstProducer); + runtime.registerFunction(kMpegPacingSecondProducerPc, testMpegPacingSecondProducer); + gMpegPacingStage.store(0u, std::memory_order_release); + gMpegPacingFirstProducerStage.store(0u, std::memory_order_release); + gMpegPacingSecondProducerStage.store(0u, std::memory_order_release); + gMpegPacingResumeTick.store(0u, std::memory_order_release); + + R5900Context mainContext{}; + mainContext.pc = kMpegPacingMainPc; + EeScheduler &ee = runtime.eeScheduler(); + ee.reset(rdram.data(), mainContext); + const int firstProducerId = ee.createThread(EeThreadCreateParams{ + 0u, kMpegPacingFirstProducerPc, 0u, 0u, 0u, 10, 0u}); + const int secondProducerId = ee.createThread(EeThreadCreateParams{ + 0u, kMpegPacingSecondProducerPc, 0u, 0u, 0u, 11, 0u}); + t.IsTrue(firstProducerId > 1 && secondProducerId > firstProducerId, + "two VSync producer guest threads should be created"); + t.Equals(ee.startThread(firstProducerId, 0u, mainContext, false), 0, + "the first VSync producer should become ready"); + t.Equals(ee.startThread(secondProducerId, 0u, mainContext, false), 0, + "the second VSync producer should become ready"); + ee.run(); + + t.Equals(gMpegPacingFirstProducerStage.load(std::memory_order_acquire), 1u, + "the second GetPicture should wait before the first VSync"); + t.Equals(gMpegPacingSecondProducerStage.load(std::memory_order_acquire), 1u, + "29.97 fps must still be waiting after one 59.94 Hz VSync"); + t.Equals(gMpegPacingResumeTick.load(std::memory_order_acquire), 2ull, + "the pending GetPicture should complete after two VSync ticks"); + t.Equals(gMpegPacingStage.load(std::memory_order_acquire), 3u, + "VSync completion must re-enter GetPicture before its guest continuation"); + }); + tc.Run("sceSdRemote isolates voice transfers from block streaming state", [](TestCase &t) { std::vector rdram(PS2_RAM_SIZE, 0u); From 3e5fb2b3b49f1d9d6d244401506e274bff5cbf46 Mon Sep 17 00:00:00 2001 From: Ran-j Date: Wed, 5 Aug 2026 19:03:03 -0300 Subject: [PATCH 3/8] feat: cheap copy from host feat: small perf o vsync tick --- ps2xRuntime/include/ps2_runtime.h | 1 + ps2xRuntime/include/runtime/ee_scheduler.h | 1 + ps2xRuntime/include/runtime/ps2_gs_gpu.h | 8 + ps2xRuntime/src/lib/Kernel/EeScheduler.cpp | 14 +- ps2xRuntime/src/lib/ps2_gs_gpu.cpp | 167 +++++++++++++++++---- ps2xRuntime/src/lib/ps2_runtime.cpp | 38 ++++- 6 files changed, 192 insertions(+), 37 deletions(-) diff --git a/ps2xRuntime/include/ps2_runtime.h b/ps2xRuntime/include/ps2_runtime.h index d691e8170..94be0589d 100644 --- a/ps2xRuntime/include/ps2_runtime.h +++ b/ps2xRuntime/include/ps2_runtime.h @@ -383,6 +383,7 @@ class PS2Runtime const EeScheduler &eeScheduler() const; void postEeEvent(EeEvent event); bool eeCheckpointDue() const noexcept; + [[noreturn]] void eeWaitVSyncTicks(uint32_t ticks, uint32_t resumePc); struct EeExitHandlerRegistration { diff --git a/ps2xRuntime/include/runtime/ee_scheduler.h b/ps2xRuntime/include/runtime/ee_scheduler.h index 03ac89aca..454cd9477 100644 --- a/ps2xRuntime/include/runtime/ee_scheduler.h +++ b/ps2xRuntime/include/runtime/ee_scheduler.h @@ -409,6 +409,7 @@ class EeScheduler std::atomic m_guestExecuting{false}; std::atomic m_stopRequested{false}; std::atomic m_checkpointPending{false}; + uint32_t m_debugPublishCountdown = 0u; mutable std::mutex m_eventMutex; std::condition_variable m_eventCv; diff --git a/ps2xRuntime/include/runtime/ps2_gs_gpu.h b/ps2xRuntime/include/runtime/ps2_gs_gpu.h index bb0b1404d..d968326f8 100644 --- a/ps2xRuntime/include/runtime/ps2_gs_gpu.h +++ b/ps2xRuntime/include/runtime/ps2_gs_gpu.h @@ -364,7 +364,14 @@ class GS private: void snapshotVRAM(); + void writeRegisterUnlocked(uint8_t regAddr, uint64_t value); void writeRegisterPacked(uint8_t regDesc, uint64_t lo, uint64_t hi); + void uploadImageNativeUnlocked(uint64_t bitbltbuf, + uint64_t trxpos, + uint64_t trxreg, + uint64_t trxdir, + const uint8_t *data, + uint32_t sizeBytes); void vertexKick(bool drawing); void latchHostPresentationFrameUnlocked(); @@ -396,6 +403,7 @@ class GS uint32_t m_vramSize = 0; struct GSRegisters *m_privRegs = nullptr; mutable std::recursive_mutex m_stateMutex; + mutable std::mutex m_presentationMutex; GSContext m_ctx[2]; GSPrimReg m_prim{}; diff --git a/ps2xRuntime/src/lib/Kernel/EeScheduler.cpp b/ps2xRuntime/src/lib/Kernel/EeScheduler.cpp index 551bc95ad..3adde696b 100644 --- a/ps2xRuntime/src/lib/Kernel/EeScheduler.cpp +++ b/ps2xRuntime/src/lib/Kernel/EeScheduler.cpp @@ -34,6 +34,7 @@ namespace constexpr auto kVBlankPeriod = std::chrono::microseconds(16667); constexpr auto kVBlankDuration = std::chrono::microseconds(500); constexpr uint64_t kAlarmTickMicroseconds = 64u; + constexpr uint32_t kDebugPublishDispatchInterval = 4096u; template int allocatePositiveId(int &nextId, const Map &objects) @@ -92,6 +93,7 @@ void EeScheduler::reset(uint8_t *rdram, const R5900Context &mainContext) m_insideInterrupt = false; m_stopRequested.store(false, std::memory_order_release); m_checkpointPending.store(false, std::memory_order_release); + m_debugPublishCountdown = 0u; { std::lock_guard lock(m_eventMutex); m_events.clear(); @@ -184,8 +186,16 @@ void EeScheduler::run() } } R5900Context &context = running->activeContext(); - copyMainContextToRuntime(); - publishSnapshot(); + if (m_debugPublishCountdown == 0u) + { + copyMainContextToRuntime(); + publishSnapshot(); + m_debugPublishCountdown = kDebugPublishDispatchInterval - 1u; + } + else + { + --m_debugPublishCountdown; + } m_runtime.m_debugPc.store(context.pc, std::memory_order_relaxed); m_runtime.m_debugRa.store(getRegU32(&context, 31), std::memory_order_relaxed); diff --git a/ps2xRuntime/src/lib/ps2_gs_gpu.cpp b/ps2xRuntime/src/lib/ps2_gs_gpu.cpp index d9bc64899..d444ad84c 100644 --- a/ps2xRuntime/src/lib/ps2_gs_gpu.cpp +++ b/ps2xRuntime/src/lib/ps2_gs_gpu.cpp @@ -490,13 +490,16 @@ void GS::reset() m_preferredDisplaySourceFrame = {}; m_preferredDisplayDestFbp = 0; m_hasPreferredDisplaySource = false; - m_hostPresentationFrame.clear(); - m_hostPresentationWidth = 0u; - m_hostPresentationHeight = 0u; - m_hostPresentationDisplayFbp = 0u; - m_hostPresentationSourceFbp = 0u; - m_hostPresentationUsedPreferred = false; - m_hasHostPresentationFrame = false; + { + std::lock_guard presentationLock(m_presentationMutex); + m_hostPresentationFrame.clear(); + m_hostPresentationWidth = 0u; + m_hostPresentationHeight = 0u; + m_hostPresentationDisplayFbp = 0u; + m_hostPresentationSourceFbp = 0u; + m_hostPresentationUsedPreferred = false; + m_hasHostPresentationFrame = false; + } m_debugHistoryWrite = 0; m_debugHistoryCount = 0; @@ -562,12 +565,15 @@ GSDebugSnapshot GS::getDebugSnapshot() const snapshot.preferredDisplaySourceFrame = m_preferredDisplaySourceFrame; snapshot.preferredDisplayDestFbp = m_preferredDisplayDestFbp; snapshot.hasPreferredDisplaySource = m_hasPreferredDisplaySource; - snapshot.hostPresentationWidth = m_hostPresentationWidth; - snapshot.hostPresentationHeight = m_hostPresentationHeight; - snapshot.hostPresentationDisplayFbp = m_hostPresentationDisplayFbp; - snapshot.hostPresentationSourceFbp = m_hostPresentationSourceFbp; - snapshot.hostPresentationUsedPreferred = m_hostPresentationUsedPreferred; - snapshot.hasHostPresentationFrame = m_hasHostPresentationFrame; + { + std::lock_guard presentationLock(m_presentationMutex); + snapshot.hostPresentationWidth = m_hostPresentationWidth; + snapshot.hostPresentationHeight = m_hostPresentationHeight; + snapshot.hostPresentationDisplayFbp = m_hostPresentationDisplayFbp; + snapshot.hostPresentationSourceFbp = m_hostPresentationSourceFbp; + snapshot.hostPresentationUsedPreferred = m_hostPresentationUsedPreferred; + snapshot.hasHostPresentationFrame = m_hasHostPresentationFrame; + } snapshot.localToHostPendingBytes = (m_localToHostReadPos < m_localToHostBuffer.size()) ? (m_localToHostBuffer.size() - m_localToHostReadPos) : 0u; @@ -959,8 +965,100 @@ bool GS::copyFrameToHostRgbaUnlocked(const GSFrameReg &frame, void GS::latchHostPresentationFrame() { - std::lock_guard lock(m_stateMutex); - latchHostPresentationFrameUnlocked(); + thread_local std::vector vramSnapshot; + thread_local GS presentationGs; + + thread_local GSRegisters privateRegisters{}; + GSFrameReg contextFrames[2]{}; + GSFrameReg preferredSource{}; + uint32_t preferredDestFbp = 0u; + bool hasPreferredSource = false; + uint32_t vramSize = 0u; + + { + std::lock_guard lock(m_stateMutex); + if (!m_privRegs || !m_vram || m_vramSize == 0u) + { + std::lock_guard presentationLock(m_presentationMutex); + m_hostPresentationFrame.clear(); + m_hostPresentationWidth = 0u; + m_hostPresentationHeight = 0u; + m_hostPresentationDisplayFbp = 0u; + m_hostPresentationSourceFbp = 0u; + m_hostPresentationUsedPreferred = false; + m_hasHostPresentationFrame = false; + return; + } + + vramSize = m_vramSize; + vramSnapshot.resize(vramSize); + std::memcpy(vramSnapshot.data(), m_vram, vramSize); + + privateRegisters.pmode = m_privRegs->pmode; + privateRegisters.smode1 = m_privRegs->smode1; + privateRegisters.smode2 = m_privRegs->smode2; + privateRegisters.srfsh = m_privRegs->srfsh; + privateRegisters.synch1 = m_privRegs->synch1; + privateRegisters.synch2 = m_privRegs->synch2; + privateRegisters.syncv = m_privRegs->syncv; + privateRegisters.dispfb1 = m_privRegs->dispfb1; + privateRegisters.display1 = m_privRegs->display1; + privateRegisters.dispfb2 = m_privRegs->dispfb2; + privateRegisters.display2 = m_privRegs->display2; + privateRegisters.extbuf = m_privRegs->extbuf; + privateRegisters.extdata = m_privRegs->extdata; + privateRegisters.extwrite = m_privRegs->extwrite; + privateRegisters.bgcolor = m_privRegs->bgcolor; + privateRegisters.csr.store(m_privRegs->csr.load(std::memory_order_acquire), std::memory_order_relaxed); + privateRegisters.vsyncTick.store(m_privRegs->vsyncTick.load(std::memory_order_acquire), std::memory_order_relaxed); + privateRegisters.imr = m_privRegs->imr; + privateRegisters.busdir = m_privRegs->busdir; + privateRegisters.siglblid = m_privRegs->siglblid; + + contextFrames[0] = m_ctx[0].frame; + contextFrames[1] = m_ctx[1].frame; + preferredSource = m_preferredDisplaySourceFrame; + preferredDestFbp = m_preferredDisplayDestFbp; + hasPreferredSource = m_hasPreferredDisplaySource; + } + + presentationGs.init(vramSnapshot.data(), vramSize, &privateRegisters); + presentationGs.m_ctx[0].frame = contextFrames[0]; + presentationGs.m_ctx[1].frame = contextFrames[1]; + presentationGs.m_preferredDisplaySourceFrame = preferredSource; + presentationGs.m_preferredDisplayDestFbp = preferredDestFbp; + presentationGs.m_hasPreferredDisplaySource = hasPreferredSource; + presentationGs.latchHostPresentationFrameUnlocked(); + + uint32_t displayFbp = 0u; + uint32_t sourceFbp = 0u; + uint32_t width = 0u; + uint32_t height = 0u; + bool usedPreferred = false; + bool hasFrame = false; + { + std::lock_guard presentationLock(m_presentationMutex); + m_hostPresentationFrame.swap(presentationGs.m_hostPresentationFrame); + m_hostPresentationWidth = presentationGs.m_hostPresentationWidth; + m_hostPresentationHeight = presentationGs.m_hostPresentationHeight; + m_hostPresentationDisplayFbp = presentationGs.m_hostPresentationDisplayFbp; + m_hostPresentationSourceFbp = presentationGs.m_hostPresentationSourceFbp; + m_hostPresentationUsedPreferred = presentationGs.m_hostPresentationUsedPreferred; + m_hasHostPresentationFrame = presentationGs.m_hasHostPresentationFrame; + + displayFbp = m_hostPresentationDisplayFbp; + sourceFbp = m_hostPresentationSourceFbp; + width = m_hostPresentationWidth; + height = m_hostPresentationHeight; + usedPreferred = m_hostPresentationUsedPreferred; + hasFrame = m_hasHostPresentationFrame; + } + + if (hasFrame) + { + std::lock_guard lock(m_stateMutex); + recordPresentDebugEventUnlocked(displayFbp, sourceFbp, width, height, usedPreferred); + } } void GS::latchHostPresentationFrameUnlocked() @@ -1249,7 +1347,7 @@ bool GS::copyLatchedHostPresentationFrame(std::vector &outPixels, uint32_t *outSourceFbp, bool *outUsedPreferred) const { - std::lock_guard lock(m_stateMutex); + std::lock_guard lock(m_presentationMutex); if (!m_hasHostPresentationFrame || m_hostPresentationFrame.empty()) { outPixels.clear(); @@ -1355,7 +1453,7 @@ void GS::processGIFPacket(const uint8_t *data, uint32_t sizeBytes) bool pre = ((tagLo >> 46) & 1) != 0; if (pre) { - writeRegister(GS_REG_PRIM, (tagLo >> 47) & 0x7FF); + writeRegisterUnlocked(GS_REG_PRIM, (tagLo >> 47) & 0x7FF); } uint8_t regs[16]; @@ -1385,7 +1483,7 @@ void GS::processGIFPacket(const uint8_t *data, uint32_t sizeBytes) { if (offset + 8 > sizeBytes) return; - writeRegister(regs[r], loadLE64(data + offset)); + writeRegisterUnlocked(regs[r], loadLE64(data + offset)); offset += 8; } } @@ -1420,7 +1518,7 @@ bool GS::processNativePackedGIFPacket(const uint8_t *data, uint32_t sizeBytes) const bool pre = ((tag.lo >> 46u) & 1u) != 0u; if (pre) - writeRegister(GS_REG_PRIM, (tag.lo >> 47u) & 0x7FFu); + writeRegisterUnlocked(GS_REG_PRIM, (tag.lo >> 47u) & 0x7FFu); uint32_t offset = tag.payloadOffset; for (uint32_t loop = 0u; loop < tag.nloop; ++loop) @@ -1451,13 +1549,23 @@ void GS::uploadImageNative(uint64_t bitbltbuf, uint32_t sizeBytes) { std::lock_guard lock(m_stateMutex); + uploadImageNativeUnlocked(bitbltbuf, trxpos, trxreg, trxdir, data, sizeBytes); +} + +void GS::uploadImageNativeUnlocked(uint64_t bitbltbuf, + uint64_t trxpos, + uint64_t trxreg, + uint64_t trxdir, + const uint8_t *data, + uint32_t sizeBytes) +{ if (!data || sizeBytes == 0 || !m_vram) return; - writeRegister(GS_REG_BITBLTBUF, bitbltbuf); - writeRegister(GS_REG_TRXPOS, trxpos); - writeRegister(GS_REG_TRXREG, trxreg); - writeRegister(GS_REG_TRXDIR, trxdir); + writeRegisterUnlocked(GS_REG_BITBLTBUF, bitbltbuf); + writeRegisterUnlocked(GS_REG_TRXPOS, trxpos); + writeRegisterUnlocked(GS_REG_TRXREG, trxreg); + writeRegisterUnlocked(GS_REG_TRXDIR, trxdir); processImageData(data, sizeBytes); ++m_nativeImageUploadCount; } @@ -1528,7 +1636,7 @@ bool GS::tryProcessNativeImageUploadPacket(const uint8_t *data, uint32_t sizeByt if (offset + imageBytes != sizeBytes) return false; - uploadImageNative(regs[0], regs[1], regs[2], regs[3], data + offset, imageBytes); + uploadImageNativeUnlocked(regs[0], regs[1], regs[2], regs[3], data + offset, imageBytes); return true; } @@ -1537,7 +1645,7 @@ void GS::writeRegisterPacked(uint8_t regDesc, uint64_t lo, uint64_t hi) switch (regDesc) { case 0x00: - writeRegister(GS_REG_PRIM, lo & 0x7FF); + writeRegisterUnlocked(GS_REG_PRIM, lo & 0x7FF); break; case 0x01: m_curR = static_cast(lo & 0xFF); @@ -1705,13 +1813,13 @@ void GS::writeRegisterPacked(uint8_t regDesc, uint64_t lo, uint64_t hi) case 0x0E: { uint8_t addr = static_cast(hi & 0xFF); - writeRegister(addr, lo); + writeRegisterUnlocked(addr, lo); break; } case 0x0F: break; default: - writeRegister(regDesc, lo); + writeRegisterUnlocked(regDesc, lo); break; } } @@ -1719,6 +1827,11 @@ void GS::writeRegisterPacked(uint8_t regDesc, uint64_t lo, uint64_t hi) void GS::writeRegister(uint8_t regAddr, uint64_t value) { std::lock_guard lock(m_stateMutex); + writeRegisterUnlocked(regAddr, value); +} + +void GS::writeRegisterUnlocked(uint8_t regAddr, uint64_t value) +{ const bool interestingReg = regAddr == GS_REG_PRIM || regAddr == GS_REG_RGBAQ || diff --git a/ps2xRuntime/src/lib/ps2_runtime.cpp b/ps2xRuntime/src/lib/ps2_runtime.cpp index e59a847dd..ae0b2b0e9 100644 --- a/ps2xRuntime/src/lib/ps2_runtime.cpp +++ b/ps2xRuntime/src/lib/ps2_runtime.cpp @@ -622,28 +622,38 @@ bool PS2Runtime::syncCoreSubsystems() m_memory.setGifArbiter(&m_gifArbiter); m_memory.setVu1MscalCallback([this](uint32_t startPC, uint32_t top, uint32_t itop) { + R5900Context *cpuContext = m_eeScheduler ? m_eeScheduler->currentContext() : nullptr; + if (!cpuContext) + { + cpuContext = &m_cpuContext; + } m_vu1.state().dBitEnabled = - (m_cpuContext.vu0_fbrst & (1u << 10)) != 0u; + (cpuContext->vu0_fbrst & (1u << 10)) != 0u; m_vu1.state().tBitEnabled = - (m_cpuContext.vu0_fbrst & (1u << 11)) != 0u; + (cpuContext->vu0_fbrst & (1u << 11)) != 0u; m_vu1.execute(m_memory.getVU1Code(), PS2_VU1_CODE_SIZE, m_memory.getVU1Data(), PS2_VU1_DATA_SIZE, m_gs, &m_memory, startPC, top, itop, 65536); - m_cpuContext.vu0_vpu_stat = - (m_cpuContext.vu0_vpu_stat & ~0x0600u) | + cpuContext->vu0_vpu_stat = + (cpuContext->vu0_vpu_stat & ~0x0600u) | (m_vu1.state().stoppedByD ? 0x0200u : 0u) | (m_vu1.state().stoppedByT ? 0x0400u : 0u); }); m_memory.setVu1MscntCallback([this](uint32_t top, uint32_t itop) { + R5900Context *cpuContext = m_eeScheduler ? m_eeScheduler->currentContext() : nullptr; + if (!cpuContext) + { + cpuContext = &m_cpuContext; + } m_vu1.state().dBitEnabled = - (m_cpuContext.vu0_fbrst & (1u << 10)) != 0u; + (cpuContext->vu0_fbrst & (1u << 10)) != 0u; m_vu1.state().tBitEnabled = - (m_cpuContext.vu0_fbrst & (1u << 11)) != 0u; + (cpuContext->vu0_fbrst & (1u << 11)) != 0u; m_vu1.resume(m_memory.getVU1Code(), PS2_VU1_CODE_SIZE, m_memory.getVU1Data(), PS2_VU1_DATA_SIZE, m_gs, &m_memory, top, itop, 65536); - m_cpuContext.vu0_vpu_stat = - (m_cpuContext.vu0_vpu_stat & ~0x0600u) | + cpuContext->vu0_vpu_stat = + (cpuContext->vu0_vpu_stat & ~0x0600u) | (m_vu1.state().stoppedByD ? 0x0200u : 0u) | (m_vu1.state().stoppedByT ? 0x0400u : 0u); }); resetIop(); @@ -2160,6 +2170,18 @@ bool PS2Runtime::eeCheckpointDue() const noexcept return m_eeScheduler->checkpointDue(); } +[[noreturn]] void PS2Runtime::eeWaitVSyncTicks(uint32_t ticks, uint32_t resumePc) +{ + const uint64_t currentTick = m_eeScheduler->currentVSyncTick(); + const uint64_t waitTicks = std::max(1u, ticks); + m_eeScheduler->waitVSync(currentTick + waitTicks - 1u, + 0, + [resumePc](R5900Context &context) + { + context.pc = resumePc; + }); +} + void PS2Runtime::addEeExitHandler(int threadId, uint32_t function, uint32_t argument) { std::lock_guard lock(m_eeKernelStateMutex); From d91d2c1b752b30ce0dd688ca748d7b446b681f9c Mon Sep 17 00:00:00 2001 From: Ran-j Date: Fri, 7 Aug 2026 21:54:33 -0300 Subject: [PATCH 4/8] feat: added EE clock Hz fix: fix MPEG out of sync with new EE refactor --- ps2xRuntime/include/ps2_runtime.h | 2 +- ps2xRuntime/include/runtime/ee_scheduler.h | 22 +- ps2xRuntime/src/lib/Kernel/EeScheduler.cpp | 268 +++++++--- ps2xRuntime/src/lib/Kernel/Stubs/CD.cpp | 452 ++++++++++++++--- ps2xRuntime/src/lib/Kernel/Stubs/MPEG.cpp | 562 +++++++++++++++++---- ps2xRuntime/src/lib/ps2_debug_panel.cpp | 4 + ps2xRuntime/src/lib/ps2_runtime.cpp | 12 +- 7 files changed, 1083 insertions(+), 239 deletions(-) diff --git a/ps2xRuntime/include/ps2_runtime.h b/ps2xRuntime/include/ps2_runtime.h index 94be0589d..4259e12d2 100644 --- a/ps2xRuntime/include/ps2_runtime.h +++ b/ps2xRuntime/include/ps2_runtime.h @@ -382,7 +382,7 @@ class PS2Runtime EeScheduler &eeScheduler(); const EeScheduler &eeScheduler() const; void postEeEvent(EeEvent event); - bool eeCheckpointDue() const noexcept; + bool eeCheckpointDue(uint32_t cycles = 32u) noexcept; [[noreturn]] void eeWaitVSyncTicks(uint32_t ticks, uint32_t resumePc); struct EeExitHandlerRegistration diff --git a/ps2xRuntime/include/runtime/ee_scheduler.h b/ps2xRuntime/include/runtime/ee_scheduler.h index 454cd9477..a9ecc28b8 100644 --- a/ps2xRuntime/include/runtime/ee_scheduler.h +++ b/ps2xRuntime/include/runtime/ee_scheduler.h @@ -214,6 +214,9 @@ struct EeEventFlagSnapshot struct EeKernelSnapshot { uint64_t sequence = 0; + uint64_t eeCycle = 0; + uint64_t sliceEndCycle = 0; + uint64_t nextEventCycle = 0; int runningThreadId = 0; std::vector threads; std::vector semaphores; @@ -255,6 +258,10 @@ class EeScheduler static constexpr int kFirstThreadId = 2; static constexpr int kLastThreadId = 255; static constexpr int kPriorityCount = 128; + static constexpr uint64_t kEeClockHz = 294912000ull; + static constexpr uint32_t kGeneratedCheckpointCycles = 32u; + static constexpr uint32_t kGuestDispatchCycles = 8u; + static constexpr uint64_t kDefaultTimeSliceCycles = 65536ull; explicit EeScheduler(PS2Runtime &runtime); ~EeScheduler(); @@ -266,7 +273,8 @@ class EeScheduler void run(); void requestStop(); void postEvent(EeEvent event); - [[nodiscard]] bool checkpointDue() const noexcept; + [[nodiscard]] bool checkpointDue(uint32_t cycles = kGeneratedCheckpointCycles) noexcept; + void accountCycles(uint32_t cycles) noexcept; [[nodiscard]] bool isExecutingGuest() const noexcept; // Kernel object API. All calls except postEvent/requestStop execute on the @@ -349,7 +357,8 @@ class EeScheduler private: struct ScheduledEvent { - std::chrono::steady_clock::time_point deadline{}; + uint64_t deadlineCycle = 0; + std::chrono::steady_clock::time_point hostDeadline{}; EeEvent event{}; uint64_t sequence = 0; }; @@ -375,8 +384,10 @@ class EeScheduler static int waitObjectId(const EeWaitState &wait); void writeGuestU32(uint32_t address, uint32_t value); void waitForEvent(); - void scheduleEvent(std::chrono::steady_clock::time_point deadline, EeEvent event); + void scheduleEvent(uint64_t deadlineCycle, std::chrono::steady_clock::time_point hostDeadline, EeEvent event); void updateNextDeadline(); + [[nodiscard]] bool hasReadyAtOrAbovePriority(int priority) const; + void renewTimeSlice(); void copyMainContextToRuntime(); PS2Runtime &m_runtime; @@ -403,7 +414,10 @@ class EeScheduler uint32_t m_enabledDmacMask = 0xFFFFFFFFu; int m_currentThreadId = 0; bool m_rescheduleRequested = false; + bool m_timeSliceExpired = false; bool m_insideInterrupt = false; + uint64_t m_eeCycle = 0; + uint64_t m_sliceEndCycle = kDefaultTimeSliceCycles; std::thread::id m_executorThread{}; std::atomic m_running{false}; std::atomic m_guestExecuting{false}; @@ -425,7 +439,7 @@ class EeScheduler uint32_t m_gsVSyncCallbackGp = 0; uint32_t m_gsVSyncCallbackSp = 0; std::unordered_map m_invocationStackTops; - std::atomic m_nextDeadlineNanoseconds{0}; + std::atomic m_nextDeadlineCycle{0}; mutable std::mutex m_snapshotMutex; EeKernelSnapshot m_snapshot; diff --git a/ps2xRuntime/src/lib/Kernel/EeScheduler.cpp b/ps2xRuntime/src/lib/Kernel/EeScheduler.cpp index 3adde696b..116720750 100644 --- a/ps2xRuntime/src/lib/Kernel/EeScheduler.cpp +++ b/ps2xRuntime/src/lib/Kernel/EeScheduler.cpp @@ -36,6 +36,15 @@ namespace constexpr uint64_t kAlarmTickMicroseconds = 64u; constexpr uint32_t kDebugPublishDispatchInterval = 4096u; + constexpr uint64_t microsecondsToEeCycles(uint64_t microseconds) + { + return (microseconds * EeScheduler::kEeClockHz + 999999ull) / 1000000ull; + } + + constexpr uint64_t kVBlankPeriodCycles = microsecondsToEeCycles(16667u); + constexpr uint64_t kVBlankDurationCycles = microsecondsToEeCycles(500u); + constexpr uint64_t kAlarmTickCycles = microsecondsToEeCycles(kAlarmTickMicroseconds); + template int allocatePositiveId(int &nextId, const Map &objects) { @@ -90,7 +99,10 @@ void EeScheduler::reset(uint8_t *rdram, const R5900Context &mainContext) m_enabledDmacMask = 0xFFFFFFFFu; m_currentThreadId = 0; m_rescheduleRequested = false; + m_timeSliceExpired = false; m_insideInterrupt = false; + m_eeCycle = 0u; + m_sliceEndCycle = kDefaultTimeSliceCycles; m_stopRequested.store(false, std::memory_order_release); m_checkpointPending.store(false, std::memory_order_release); m_debugPublishCountdown = 0u; @@ -121,7 +133,8 @@ void EeScheduler::reset(uint8_t *rdram, const R5900Context &mainContext) main.status = EeThreadStatus::Ready; m_threads.emplace(main.id, std::move(main)); m_readyQueues[0].push_back(kMainThreadId); - scheduleEvent(std::chrono::steady_clock::now() + kVBlankPeriod, + scheduleEvent(m_eeCycle + kVBlankPeriodCycles, + std::chrono::steady_clock::now() + kVBlankPeriod, EeEvent{EeEventType::VBlankStart, 0, 0}); publishSnapshot(); } @@ -159,6 +172,7 @@ void EeScheduler::run() m_pendingInvocations.pop_front(); owner->status = EeThreadStatus::Running; m_currentThreadId = owner->id; + renewTimeSlice(); if (getRegU32(&invocation.context, 29) == 0u) { SET_GPR_U32(&invocation.context, 29, invocationStackTop()); @@ -258,11 +272,14 @@ void EeScheduler::run() } PS2Runtime::RecompiledFunction function = m_runtime.lookupFunction(context.pc); + if (checkpointDue(kGuestDispatchCycles)) + { + continue; + } + try { - m_insideInterrupt = !running->invocations.empty() && - running->invocations.back().kind == GuestInvocationKind::Interrupt; - m_checkpointPending.store(false, std::memory_order_release); + m_insideInterrupt = !running->invocations.empty() && running->invocations.back().kind == GuestInvocationKind::Interrupt; m_guestExecuting.store(true, std::memory_order_release); function(m_rdram, &context, &m_runtime); m_guestExecuting.store(false, std::memory_order_release); @@ -286,9 +303,10 @@ void EeScheduler::run() { GuestThread *preempted = currentThread(); assert(preempted != nullptr); - enqueueReady(*preempted, true); + enqueueReady(*preempted, !m_timeSliceExpired); m_currentThreadId = 0; m_rescheduleRequested = false; + m_timeSliceExpired = false; } } @@ -316,27 +334,48 @@ void EeScheduler::postEvent(EeEvent event) { std::lock_guard lock(m_eventMutex); m_events.push_back(event); + m_checkpointPending.store(true, std::memory_order_release); } - m_checkpointPending.store(true, std::memory_order_release); m_eventCv.notify_one(); } -bool EeScheduler::checkpointDue() const noexcept +bool EeScheduler::checkpointDue(uint32_t cycles) noexcept { + accountCycles(cycles); + if (m_checkpointPending.load(std::memory_order_acquire) || m_stopRequested.load(std::memory_order_acquire)) { return true; } - const int64_t deadline = m_nextDeadlineNanoseconds.load(std::memory_order_acquire); - if (deadline == 0) + + const uint64_t nextEventCycle = m_nextDeadlineCycle.load(std::memory_order_acquire); + if (nextEventCycle != 0u && m_eeCycle >= nextEventCycle) + { + m_checkpointPending.store(true, std::memory_order_release); + return true; + } + + if (m_eeCycle < m_sliceEndCycle) { return false; } - const int64_t now = std::chrono::duration_cast( - std::chrono::steady_clock::now().time_since_epoch()) - .count(); - return now >= deadline; + + const GuestThread *running = currentThread(); + if (running != nullptr && hasReadyAtOrAbovePriority(running->currentPriority)) + { + m_rescheduleRequested = true; + m_timeSliceExpired = true; + return true; + } + + renewTimeSlice(); + return false; +} + +void EeScheduler::accountCycles(uint32_t cycles) noexcept +{ + m_eeCycle += std::max(1u, cycles); } bool EeScheduler::isExecutingGuest() const noexcept @@ -737,6 +776,7 @@ void EeScheduler::transferIfRequested(bool interruptSafe) m_currentThreadId = 0; } m_rescheduleRequested = false; + m_timeSliceExpired = false; publishSnapshot(); throw EeDispatcherTransfer{}; } @@ -998,8 +1038,8 @@ int EeScheduler::setAlarm(uint16_t ticks, } m_alarms.emplace(id, EeAlarm{id, ticks, handler, argument, gp, sp}); const uint64_t tickCount = ticks == 0u ? 1u : static_cast(ticks); - scheduleEvent(std::chrono::steady_clock::now() + - std::chrono::microseconds(tickCount * kAlarmTickMicroseconds), + scheduleEvent(m_eeCycle + tickCount * kAlarmTickCycles, + std::chrono::steady_clock::now() + std::chrono::microseconds(tickCount * kAlarmTickMicroseconds), EeEvent{EeEventType::Alarm, static_cast(id), 0}); return id; } @@ -1409,6 +1449,9 @@ void EeScheduler::publishSnapshot() { EeKernelSnapshot next{}; next.sequence = ++m_snapshotSequence; + next.eeCycle = m_eeCycle; + next.sliceEndCycle = m_sliceEndCycle; + next.nextEventCycle = m_nextDeadlineCycle.load(std::memory_order_acquire); next.runningThreadId = m_currentThreadId; next.threads.reserve(m_threads.size()); for (const auto &[id, item] : m_threads) @@ -1550,6 +1593,7 @@ void EeScheduler::makeRunning(GuestThread &item) assert(item.status == EeThreadStatus::Ready); item.status = EeThreadStatus::Running; m_currentThreadId = item.id; + renewTimeSlice(); } void EeScheduler::makeDormant(GuestThread &item) @@ -1643,13 +1687,15 @@ void EeScheduler::applyPendingPreemption() if (m_currentThreadId == 0) { m_rescheduleRequested = false; + m_timeSliceExpired = false; return; } GuestThread *self = currentThread(); assert(self != nullptr); - enqueueReady(*self, true); + enqueueReady(*self, !m_timeSliceExpired); m_currentThreadId = 0; m_rescheduleRequested = false; + m_timeSliceExpired = false; } void EeScheduler::processPendingEvents() @@ -1665,49 +1711,100 @@ void EeScheduler::processPendingEvents() { processEvent(event); } - m_checkpointPending.store(false, std::memory_order_release); + + { + std::lock_guard lock(m_eventMutex); + const uint64_t nextEventCycle = m_nextDeadlineCycle.load(std::memory_order_acquire); + const bool cycleEventDue = nextEventCycle != 0u && m_eeCycle >= nextEventCycle; + const bool pendingWork = !m_events.empty() || cycleEventDue || m_stopRequested.load(std::memory_order_acquire); + m_checkpointPending.store(pendingWork, std::memory_order_release); + } applyPendingPreemption(); } void EeScheduler::processDueDeadlines() { - const auto now = std::chrono::steady_clock::now(); - std::vector due; + for (;;) { - std::lock_guard lock(m_eventMutex); - auto firstFuture = std::partition(m_deadlines.begin(), m_deadlines.end(), [now](const ScheduledEvent &item) - { return item.deadline <= now; }); - due.insert(due.end(), - std::make_move_iterator(m_deadlines.begin()), - std::make_move_iterator(firstFuture)); - m_deadlines.erase(m_deadlines.begin(), firstFuture); - updateNextDeadline(); - } - std::sort(due.begin(), due.end(), [](const ScheduledEvent &left, const ScheduledEvent &right) - { - if (left.deadline != right.deadline) - { - return left.deadline < right.deadline; - } - if (left.event.type != right.event.type) - { - return left.event.type < right.event.type; - } - if (left.event.id != right.event.id) + std::vector due; + std::chrono::steady_clock::time_point pacingDeadline{}; + { + std::unique_lock lock(m_eventMutex); + const auto now = std::chrono::steady_clock::now(); + for (const ScheduledEvent &item : m_deadlines) + { + if (item.deadlineCycle <= m_eeCycle && + (pacingDeadline == std::chrono::steady_clock::time_point{} || + item.hostDeadline < pacingDeadline)) + { + pacingDeadline = item.hostDeadline; + } + } + + if (pacingDeadline == std::chrono::steady_clock::time_point{}) + { + updateNextDeadline(); + return; + } + + if (now < pacingDeadline) + { + m_eventCv.wait_until(lock, pacingDeadline, [this]() + { return !m_events.empty() || + m_stopRequested.load(std::memory_order_acquire); }); + if (!m_events.empty() || m_stopRequested.load(std::memory_order_acquire)) + { + updateNextDeadline(); + return; + } + } + + const auto pacedNow = std::chrono::steady_clock::now(); + auto firstFuture = std::partition(m_deadlines.begin(), m_deadlines.end(), + [this, pacedNow](const ScheduledEvent &item) + { return item.deadlineCycle <= m_eeCycle && + item.hostDeadline <= pacedNow; }); + due.insert(due.end(), + std::make_move_iterator(m_deadlines.begin()), + std::make_move_iterator(firstFuture)); + m_deadlines.erase(m_deadlines.begin(), firstFuture); + updateNextDeadline(); + } + + std::sort(due.begin(), due.end(), [](const ScheduledEvent &left, const ScheduledEvent &right) { - return left.event.id < right.event.id; - } - return left.sequence < right.sequence; }); - for (ScheduledEvent &scheduled : due) - { - if (scheduled.event.type == EeEventType::VBlankStart) + if (left.deadlineCycle != right.deadlineCycle) + { + return left.deadlineCycle < right.deadlineCycle; + } + if (left.event.type != right.event.type) + { + return left.event.type < right.event.type; + } + if (left.event.id != right.event.id) + { + return left.event.id < right.event.id; + } + return left.sequence < right.sequence; }); + + if (due.empty()) { - scheduleEvent(scheduled.deadline + kVBlankDuration, - EeEvent{EeEventType::VBlankEnd, 0, m_vsyncTick + 1u}); - scheduleEvent(scheduled.deadline + kVBlankPeriod, - EeEvent{EeEventType::VBlankStart, 0, 0}); + return; + } + + for (ScheduledEvent &scheduled : due) + { + if (scheduled.event.type == EeEventType::VBlankStart) + { + scheduleEvent(scheduled.deadlineCycle + kVBlankDurationCycles, + scheduled.hostDeadline + kVBlankDuration, + EeEvent{EeEventType::VBlankEnd, 0, m_vsyncTick + 1u}); + scheduleEvent(scheduled.deadlineCycle + kVBlankPeriodCycles, + scheduled.hostDeadline + kVBlankPeriod, + EeEvent{EeEventType::VBlankStart, 0, 0}); + } + processEvent(scheduled.event); } - processEvent(scheduled.event); } } @@ -1849,23 +1946,45 @@ void EeScheduler::writeGuestU32(uint32_t address, uint32_t value) void EeScheduler::waitForEvent() { std::unique_lock lock(m_eventMutex); + if (!m_events.empty() || m_stopRequested.load(std::memory_order_acquire)) + { + return; + } if (m_deadlines.empty()) { m_eventCv.wait(lock, [this]() { return !m_events.empty() || m_stopRequested.load(std::memory_order_acquire); }); return; } - const auto next = std::min_element(m_deadlines.begin(), m_deadlines.end(), [](const ScheduledEvent &left, const ScheduledEvent &right) - { return left.deadline < right.deadline; }) - ->deadline; - m_eventCv.wait_until(lock, next); + + const auto next = std::min_element(m_deadlines.begin(), m_deadlines.end(), + [](const ScheduledEvent &left, const ScheduledEvent &right) + { + if (left.deadlineCycle != right.deadlineCycle) + { + return left.deadlineCycle < right.deadlineCycle; + } + return left.sequence < right.sequence; + }); + const uint64_t deadlineCycle = next->deadlineCycle; + const auto hostDeadline = next->hostDeadline; + const bool signaled = m_eventCv.wait_until(lock, hostDeadline, [this]() + { return !m_events.empty() || + m_stopRequested.load(std::memory_order_acquire); }); + if (!signaled) + { + m_eeCycle = std::max(m_eeCycle, deadlineCycle); + m_checkpointPending.store(true, std::memory_order_release); + } } -void EeScheduler::scheduleEvent(std::chrono::steady_clock::time_point deadline, EeEvent event) +void EeScheduler::scheduleEvent(uint64_t deadlineCycle, + std::chrono::steady_clock::time_point hostDeadline, + EeEvent event) { { std::lock_guard lock(m_eventMutex); - m_deadlines.push_back(ScheduledEvent{deadline, event, ++m_eventSequence}); + m_deadlines.push_back(ScheduledEvent{deadlineCycle, hostDeadline, event, ++m_eventSequence}); updateNextDeadline(); } m_eventCv.notify_one(); @@ -1875,15 +1994,38 @@ void EeScheduler::updateNextDeadline() { if (m_deadlines.empty()) { - m_nextDeadlineNanoseconds.store(0, std::memory_order_release); + m_nextDeadlineCycle.store(0u, std::memory_order_release); return; } - const auto it = std::min_element(m_deadlines.begin(), m_deadlines.end(), [](const ScheduledEvent &left, const ScheduledEvent &right) - { return left.deadline < right.deadline; }); - const int64_t nanoseconds = std::chrono::duration_cast( - it->deadline.time_since_epoch()) - .count(); - m_nextDeadlineNanoseconds.store(nanoseconds, std::memory_order_release); + const auto it = std::min_element(m_deadlines.begin(), m_deadlines.end(), + [](const ScheduledEvent &left, const ScheduledEvent &right) + { + if (left.deadlineCycle != right.deadlineCycle) + { + return left.deadlineCycle < right.deadlineCycle; + } + return left.sequence < right.sequence; + }); + m_nextDeadlineCycle.store(it->deadlineCycle, std::memory_order_release); +} + +bool EeScheduler::hasReadyAtOrAbovePriority(int priority) const +{ + const int last = std::clamp(priority, 0, kPriorityCount - 1); + for (int p = 0; p <= last; ++p) + { + if (!m_readyQueues[static_cast(p)].empty()) + { + return true; + } + } + return false; +} + +void EeScheduler::renewTimeSlice() +{ + m_sliceEndCycle = m_eeCycle + kDefaultTimeSliceCycles; + m_timeSliceExpired = false; } void EeScheduler::copyMainContextToRuntime() diff --git a/ps2xRuntime/src/lib/Kernel/Stubs/CD.cpp b/ps2xRuntime/src/lib/Kernel/Stubs/CD.cpp index 4c20a21d0..56a978eae 100644 --- a/ps2xRuntime/src/lib/Kernel/Stubs/CD.cpp +++ b/ps2xRuntime/src/lib/Kernel/Stubs/CD.cpp @@ -1,14 +1,173 @@ #include "Common.h" #include "CD.h" #include "MPEG.h" +#include "runtime/ee_scheduler.h" namespace ps2_stubs { namespace { + constexpr uint32_t kCdStreamBlocking = 1u; + constexpr uint32_t kDvdSectorsPerSecondX1 = 675u; + constexpr uint32_t kDvdSectorsPerSecondX4 = kDvdSectorsPerSecondX1 * 4u; + constexpr uint64_t kNtScFieldsPerSecondNumerator = 60000u; + constexpr uint64_t kNtScFieldsPerSecondDenominator = 1001u; + + struct CdStreamTimingState + { + bool initialized = false; + bool active = false; + bool paused = false; + uint32_t capacitySectors = 64u; + uint32_t bankCount = 4u; + uint32_t sectorsPerBank = 16u; + uint32_t sectorsPerSecond = kDvdSectorsPerSecondX4; + uint64_t producedSectors = 0u; + uint64_t consumedSectors = 0u; + uint64_t productionRemainder = 0u; + uint64_t lastVSyncTick = 0u; + }; + uint32_t g_cdStReadTraceCount = 0u; - } + CdStreamTimingState g_cdStreamTiming; + + uint64_t currentCdStreamTick(PS2Runtime *runtime) + { + return runtime != nullptr ? runtime->eeScheduler().currentVSyncTick() : 0u; + } + + uint32_t dvdStreamSectorsPerSecond(uint8_t spindleControl) + { + switch (spindleControl) + { + case 2u: // SCECdSpinX1 + return kDvdSectorsPerSecondX1; + case 3u: // SCECdSpinX2 + return kDvdSectorsPerSecondX1 * 2u; + case 11u: // SCECdSpin1p6 + return 1080u; + case 4u: // SCECdSpinX4 + case 0u: // SCECdSpinStm / max + case 1u: // optimized + case 20u: // max + default: + return kDvdSectorsPerSecondX4; + } + } + + void resetCdStreamProduction(PS2Runtime *runtime) + { + g_cdStreamTiming.producedSectors = 0u; + g_cdStreamTiming.consumedSectors = 0u; + g_cdStreamTiming.productionRemainder = 0u; + g_cdStreamTiming.lastVSyncTick = currentCdStreamTick(runtime); + } + + uint64_t totalCdStreamSectors() + { + if (g_cdStreamingEndLbn == 0xFFFFFFFFu || g_cdStreamingEndLbn < g_cdStreamingLbn) + { + return std::numeric_limits::max(); + } + return g_cdStreamTiming.consumedSectors + static_cast(g_cdStreamingEndLbn - g_cdStreamingLbn); + } + + void updateCdStreamProduction(PS2Runtime *runtime) + { + if (!g_cdStreamTiming.active || g_cdStreamTiming.paused || runtime == nullptr) + { + return; + } + + const uint64_t tick = currentCdStreamTick(runtime); + if (tick <= g_cdStreamTiming.lastVSyncTick) + { + return; + } + + const uint64_t elapsedTicks = tick - g_cdStreamTiming.lastVSyncTick; + g_cdStreamTiming.lastVSyncTick = tick; + + // 59.94 Hz field clock: sectors = fields * sectors/s * 1001 / 60000. + const uint64_t unitsPerTick = static_cast(g_cdStreamTiming.sectorsPerSecond) * kNtScFieldsPerSecondDenominator; + const uint64_t accumulated = g_cdStreamTiming.productionRemainder + elapsedTicks * unitsPerTick; + const uint64_t elapsedProduction = accumulated / kNtScFieldsPerSecondNumerator; + g_cdStreamTiming.productionRemainder = accumulated % kNtScFieldsPerSecondNumerator; + if (elapsedProduction == 0u) + { + return; + } + + const uint64_t buffered = g_cdStreamTiming.producedSectors - g_cdStreamTiming.consumedSectors; + const uint64_t effectiveCapacity = std::max(1u, g_cdStreamTiming.capacitySectors); + const uint64_t space = buffered < effectiveCapacity ? effectiveCapacity - buffered : 0u; + uint64_t newlyProduced = std::min(elapsedProduction, space); + + const uint64_t streamTotal = totalCdStreamSectors(); + if (streamTotal != std::numeric_limits::max()) + { + const uint64_t remainingToProduce = streamTotal > g_cdStreamTiming.producedSectors + ? streamTotal - g_cdStreamTiming.producedSectors + : 0u; + newlyProduced = std::min(newlyProduced, remainingToProduce); + } + + g_cdStreamTiming.producedSectors += newlyProduced; + if (elapsedProduction > newlyProduced) + { + g_cdStreamTiming.productionRemainder = 0u; + } + } + + uint32_t bufferedCdStreamSectors(PS2Runtime *runtime) + { + updateCdStreamProduction(runtime); + const uint64_t buffered = g_cdStreamTiming.producedSectors - g_cdStreamTiming.consumedSectors; + return static_cast(std::min(buffered, std::numeric_limits::max())); + } + + uint32_t readableCdStreamSectors(PS2Runtime *runtime) + { + const uint32_t buffered = bufferedCdStreamSectors(runtime); + if (buffered == 0u) + { + return 0u; + } + const uint64_t streamTotal = totalCdStreamSectors(); + if (streamTotal != std::numeric_limits::max() && g_cdStreamTiming.producedSectors >= streamTotal) + { + return buffered; + } + + const uint32_t bank = std::max(1u, g_cdStreamTiming.sectorsPerBank); + return (buffered / bank) * bank; + } + + uint64_t cdStreamWakeTickForSectors(PS2Runtime *runtime, uint32_t sectorsNeeded) + { + const uint64_t now = currentCdStreamTick(runtime); + if (sectorsNeeded == 0u || g_cdStreamTiming.sectorsPerSecond == 0u) + { + return now; + } + + const uint64_t requiredUnits = static_cast(sectorsNeeded) * kNtScFieldsPerSecondNumerator; + const uint64_t remainingUnits = requiredUnits > g_cdStreamTiming.productionRemainder + ? requiredUnits - g_cdStreamTiming.productionRemainder + : 0u; + const uint64_t unitsPerTick = static_cast(g_cdStreamTiming.sectorsPerSecond) * kNtScFieldsPerSecondDenominator; + const uint64_t ticks = std::max(1u, (remainingUnits + unitsPerTick - 1u) / unitsPerTick); + return now + ticks; + } + + void restartCdStreamAt(uint32_t lbn, PS2Runtime *runtime) + { + g_cdStreamingLbn = lbn; + g_cdStreamingEndLbn = cdStreamingEndLbnForStart(lbn); + resetCdStreamProduction(runtime); + } + } CdDebugSnapshot getCdDebugSnapshot() { @@ -41,9 +200,7 @@ namespace ps2_stubs snapshot.files.push_back(std::move(row)); } std::sort(snapshot.files.begin(), snapshot.files.end(), [](const CdDebugFileEntry &a, const CdDebugFileEntry &b) - { - return a.baseLbn < b.baseLbn; - }); + { return a.baseLbn < b.baseLbn; }); return snapshot; } @@ -241,6 +398,7 @@ namespace ps2_stubs { g_cdInitialized = true; g_lastCdError = 0; + g_cdStreamTiming = {}; setReturnS32(ctx, 1); } @@ -492,8 +650,7 @@ namespace ps2_stubs void sceCdSeek(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { - g_cdStreamingLbn = getRegU32(ctx, 4); - g_cdStreamingEndLbn = cdStreamingEndLbnForStart(g_cdStreamingLbn); + restartCdStreamAt(getRegU32(ctx, 4), runtime); setReturnS32(ctx, 1); } @@ -509,6 +666,23 @@ namespace ps2_stubs void sceCdStInit(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { + const uint32_t bufferSectors = getRegU32(ctx, 4); + const uint32_t bankCount = getRegU32(ctx, 5); + const uint32_t bufferAddr = getRegU32(ctx, 6); + + if (bufferSectors == 0u || bankCount == 0u || bufferAddr == 0u || bufferSectors / bankCount == 0u) + { + setReturnS32(ctx, 0); + return; + } + + g_cdStreamTiming.initialized = true; + g_cdStreamTiming.active = false; + g_cdStreamTiming.paused = false; + g_cdStreamTiming.capacitySectors = bufferSectors; + g_cdStreamTiming.bankCount = bankCount; + g_cdStreamTiming.sectorsPerBank = std::max(1u, bufferSectors / bankCount); + resetCdStreamProduction(runtime); setReturnS32(ctx, 1); } @@ -519,89 +693,216 @@ namespace ps2_stubs void sceCdStPause(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { + updateCdStreamProduction(runtime); + g_cdStreamTiming.paused = true; setReturnS32(ctx, 1); } - void sceCdStRead(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) + namespace { - uint32_t requestedSectors = getRegU32(ctx, 4); - uint32_t sectors = requestedSectors; - uint32_t buf = getRegU32(ctx, 5); - uint32_t errAddr = getRegU32(ctx, 7); + struct CdStReadContinuation + { + uint32_t requestedSectors = 0u; + uint32_t buffer = 0u; + uint32_t errorAddress = 0u; + uint32_t sectorsRead = 0u; + }; - uint32_t offset = buf & PS2_RAM_MASK; - size_t requestedBytes = static_cast(requestedSectors) * kCdSectorSize; - const size_t maxBytes = PS2_RAM_SIZE - offset; - if (requestedBytes > maxBytes) + void finishCdStRead(uint8_t *rdram, R5900Context *ctx, const CdStReadContinuation &state, int32_t error) { - requestedBytes = maxBytes; + if (int32_t *errorOut = reinterpret_cast(getMemPtr(rdram, state.errorAddress)); errorOut) + { + *errorOut = error; + } + setReturnS32(ctx, static_cast(state.sectorsRead)); } - bool hitStreamEnd = false; - if (g_cdStreamingEndLbn != 0xFFFFFFFFu) + void continueCdStRead(uint8_t *rdram, + R5900Context *ctx, + PS2Runtime *runtime, + CdStReadContinuation state) { - if (g_cdStreamingLbn >= g_cdStreamingEndLbn) + if (!g_cdStreamTiming.active || state.requestedSectors == 0u) { - sectors = 0u; - hitStreamEnd = true; + finishCdStRead(rdram, ctx, state, 0); + return; } - else + + for (;;) { - const uint32_t remaining = g_cdStreamingEndLbn - g_cdStreamingLbn; - if (sectors > remaining) + uint32_t remaining = state.requestedSectors - state.sectorsRead; + bool atEnd = false; + if (g_cdStreamingEndLbn != 0xFFFFFFFFu) + { + if (g_cdStreamingLbn >= g_cdStreamingEndLbn) + { + remaining = 0u; + atEnd = true; + } + else + { + const uint32_t streamRemaining = g_cdStreamingEndLbn - g_cdStreamingLbn; + if (remaining > streamRemaining) + { + remaining = streamRemaining; + atEnd = true; + } + } + } + + if (remaining == 0u) + { + if (atEnd || (g_cdStreamingEndLbn != 0xFFFFFFFFu && g_cdStreamingLbn >= g_cdStreamingEndLbn)) + { + notifyMpegCdStreamEof(runtime); + } + finishCdStRead(rdram, ctx, state, 0); + return; + } + + uint32_t available = readableCdStreamSectors(runtime); + if (runtime == nullptr) + { + available = remaining; + } + + if (available == 0u) + { + if (!runtime) + { + finishCdStRead(rdram, ctx, state, 0); + return; + } + + const uint32_t bank = std::max(1u, g_cdStreamTiming.sectorsPerBank); + const uint32_t wakeSectors = std::min(remaining, bank); + const uint32_t buffered = bufferedCdStreamSectors(runtime); + const uint32_t needed = wakeSectors > buffered ? wakeSectors - buffered : 1u; + const uint64_t wakeTick = cdStreamWakeTickForSectors(runtime, needed); + runtime->eeScheduler().waitVSync( + wakeTick - 1u, + -1, + [rdram, runtime, state](R5900Context &resumeContext) + { + if (static_cast(getRegU32(&resumeContext, 2)) < 0) + { + return; + } + continueCdStRead(rdram, &resumeContext, runtime, state); + }); + } + + uint32_t sectors = std::min(remaining, available); + const uint64_t destination64 = static_cast(state.buffer) + static_cast(state.sectorsRead) * kCdSectorSize; + const uint32_t destination = static_cast(destination64); + const uint32_t offset = destination & PS2_RAM_MASK; + const size_t maxBytes = PS2_RAM_SIZE - offset; + sectors = std::min(sectors, static_cast(maxBytes / kCdSectorSize)); + + if (sectors == 0u) + { + g_lastCdError = -1; + finishCdStRead(rdram, ctx, state, g_lastCdError); + return; + } + + const uint32_t readLbn = g_cdStreamingLbn; + const size_t readBytes = static_cast(sectors) * kCdSectorSize; + if (!readCdSectors(readLbn, sectors, rdram + offset, readBytes)) { - sectors = remaining; - hitStreamEnd = true; + finishCdStRead(rdram, ctx, state, g_lastCdError); + return; } + + g_cdStreamingLbn += sectors; + if (runtime == nullptr) + { + g_cdStreamTiming.producedSectors += sectors; + } + g_cdStreamTiming.consumedSectors += sectors; + state.sectorsRead += sectors; + + const bool hitStreamEnd = g_cdStreamingEndLbn != 0xFFFFFFFFu && g_cdStreamingLbn >= g_cdStreamingEndLbn; + notifyMpegCdStreamDataProduced(static_cast(readBytes), hitStreamEnd); + + if (g_cdStReadTraceCount < 32u) + { + std::cerr << "[sceCdStRead] requested=" << state.requestedSectors + << " accumulated=" << state.sectorsRead + << " chunk=" << sectors + << " buffered=" << readableCdStreamSectors(runtime) + << " lbn=0x" << std::hex << readLbn + << " end=0x" << g_cdStreamingEndLbn + << std::dec << std::endl; + ++g_cdStReadTraceCount; + } + + if (state.sectorsRead >= state.requestedSectors || hitStreamEnd) + { + finishCdStRead(rdram, ctx, state, 0); + return; + } + + // STMBLK is implemented by repeatedly consuming the stream ring. + // If a complete bank is still available, keep draining it before + // yielding. Otherwise the next iteration parks on the producer. } } + } + + void sceCdStRead(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) + { + const uint32_t requestedSectors = getRegU32(ctx, 4); + const uint32_t buffer = getRegU32(ctx, 5); + const uint32_t mode = getRegU32(ctx, 6); + const uint32_t errorAddress = getRegU32(ctx, 7); - size_t bytes = static_cast(sectors) * kCdSectorSize; - if (bytes > maxBytes) + CdStReadContinuation state{}; + state.requestedSectors = requestedSectors; + state.buffer = buffer; + state.errorAddress = errorAddress; + + if (int32_t *errorOut = reinterpret_cast(getMemPtr(rdram, errorAddress)); errorOut) { - bytes = maxBytes; + *errorOut = 0; } - const uint32_t readLbn = g_cdStreamingLbn; - const bool ok = (sectors > 0u) && readCdSectors(readLbn, sectors, rdram + offset, bytes); - if (ok) + if (!g_cdStreamTiming.active || requestedSectors == 0u) { - g_cdStreamingLbn += sectors; - if (requestedBytes > bytes) - { - std::memset(rdram + offset + bytes, 0, requestedBytes - bytes); - } - notifyMpegCdStreamDataProduced( - static_cast(bytes), - hitStreamEnd || g_cdStreamingLbn == g_cdStreamingEndLbn); + setReturnS32(ctx, 0); + return; } - else + + if (mode == kCdStreamBlocking) { - if (requestedBytes > 0u) - { - std::memset(rdram + offset, 0, requestedBytes); - } - notifyMpegCdStreamEof(runtime); + continueCdStRead(rdram, ctx, runtime, state); + return; } - if (int32_t *err = reinterpret_cast(getMemPtr(rdram, errAddr)); err) + uint32_t remaining = requestedSectors; + if (g_cdStreamingEndLbn != 0xFFFFFFFFu) { - *err = ok ? 0 : g_lastCdError; + remaining = g_cdStreamingLbn < g_cdStreamingEndLbn + ? std::min(remaining, g_cdStreamingEndLbn - g_cdStreamingLbn) + : 0u; } - if (g_cdStReadTraceCount < 32u) + const uint32_t available = runtime != nullptr + ? readableCdStreamSectors(runtime) + : remaining; + const uint32_t sectors = std::min(remaining, available); + if (sectors == 0u) { - std::cerr << "[sceCdStRead] sectors=" << requestedSectors - << " read=" << sectors - << " buf=0x" << std::hex << buf - << " lbn=0x" << readLbn - << " end=0x" << g_cdStreamingEndLbn - << std::dec << " ok=" << ok - << " bytes=" << bytes << std::endl; - ++g_cdStReadTraceCount; + if (g_cdStreamingEndLbn != 0xFFFFFFFFu && g_cdStreamingLbn >= g_cdStreamingEndLbn) + { + notifyMpegCdStreamEof(runtime); + } + setReturnS32(ctx, 0); + return; } - setReturnS32(ctx, ok ? static_cast(sectors) : 0); + state.requestedSectors = sectors; + continueCdStRead(rdram, ctx, runtime, state); } void sceCdStream(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) @@ -611,43 +912,62 @@ namespace ps2_stubs void sceCdStResume(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { + g_cdStreamTiming.paused = false; + g_cdStreamTiming.lastVSyncTick = currentCdStreamTick(runtime); setReturnS32(ctx, 1); } void sceCdStSeek(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { - g_cdStreamingLbn = getRegU32(ctx, 4); - g_cdStreamingEndLbn = cdStreamingEndLbnForStart(g_cdStreamingLbn); + restartCdStreamAt(getRegU32(ctx, 4), runtime); setReturnS32(ctx, 1); } void sceCdStSeekF(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { - g_cdStreamingLbn = getRegU32(ctx, 4); - g_cdStreamingEndLbn = cdStreamingEndLbnForStart(g_cdStreamingLbn); + restartCdStreamAt(getRegU32(ctx, 4), runtime); setReturnS32(ctx, 1); } void sceCdStStart(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { - g_cdStreamingLbn = getRegU32(ctx, 4); - g_cdStreamingEndLbn = cdStreamingEndLbnForStart(g_cdStreamingLbn); + const uint32_t lbn = getRegU32(ctx, 4); + const uint32_t modeAddr = getRegU32(ctx, 5); + uint8_t spindleControl = 0u; + if (const uint8_t *mode = getConstMemPtr(rdram, modeAddr); mode) + { + spindleControl = mode[1u]; + } + + restartCdStreamAt(lbn, runtime); + g_cdStreamTiming.active = true; + g_cdStreamTiming.paused = false; + g_cdStreamTiming.sectorsPerSecond = dvdStreamSectorsPerSecond(spindleControl); g_cdStReadTraceCount = 0u; notifyMpegCdStreamStart(runtime); std::cerr << "[sceCdStStart] lbn=0x" << std::hex << g_cdStreamingLbn - << " endLbn=0x" << g_cdStreamingEndLbn << std::dec << std::endl; + << " endLbn=0x" << g_cdStreamingEndLbn << std::dec + << " rate=" << g_cdStreamTiming.sectorsPerSecond << " sectors/s" + << " buffer=" << g_cdStreamTiming.capacitySectors << " sectors" + << " bank=" << g_cdStreamTiming.sectorsPerBank << " sectors" + << std::endl; setReturnS32(ctx, 1); } void sceCdStStat(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { - setReturnS32(ctx, 0); + const uint32_t buffered = bufferedCdStreamSectors(runtime); + const uint32_t bankSize = std::max(1u, g_cdStreamTiming.sectorsPerBank); + setReturnS32(ctx, static_cast((buffered / bankSize) * bankSize)); } void sceCdStStop(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { + updateCdStreamProduction(runtime); + g_cdStreamTiming.active = false; + g_cdStreamTiming.paused = false; notifyMpegCdStreamEof(runtime); setReturnS32(ctx, 1); } diff --git a/ps2xRuntime/src/lib/Kernel/Stubs/MPEG.cpp b/ps2xRuntime/src/lib/Kernel/Stubs/MPEG.cpp index caa84a205..44eaef4d9 100644 --- a/ps2xRuntime/src/lib/Kernel/Stubs/MPEG.cpp +++ b/ps2xRuntime/src/lib/Kernel/Stubs/MPEG.cpp @@ -29,6 +29,8 @@ namespace ps2_stubs { int width = 0; int height = 0; + int repeatPict = 0; + int64_t pts90k = -1; std::vector rgba; }; @@ -46,13 +48,14 @@ namespace ps2_stubs void configureFfmpegLogLevel() { static std::once_flag s_once; - std::call_once(s_once, [] { + std::call_once(s_once, [] + { #if AGRESSIVE_LOGS - av_log_set_level(AV_LOG_WARNING); + av_log_set_level(AV_LOG_WARNING); #else - av_log_set_level(AV_LOG_ERROR); + av_log_set_level(AV_LOG_ERROR); #endif - }); + }); } class MpegFfmpegDecoder @@ -68,7 +71,7 @@ namespace ps2_stubs MpegFfmpegDecoder(const MpegFfmpegDecoder &) = delete; MpegFfmpegDecoder &operator=(const MpegFfmpegDecoder &) = delete; - bool feed(const uint8_t *data, size_t size, std::deque &frames) + bool feed(const uint8_t *data, size_t size, std::deque &frames, int64_t pts90k = -1, int64_t dts90k = -1) { if (!data || size == 0) { @@ -91,6 +94,8 @@ namespace ps2_stubs const uint8_t *cursor = data; size_t remaining = size; + int64_t parserPts = pts90k >= 0 ? pts90k : AV_NOPTS_VALUE; + int64_t parserDts = dts90k >= 0 ? dts90k : AV_NOPTS_VALUE; while (remaining > 0) { uint8_t *packetData = nullptr; @@ -104,8 +109,8 @@ namespace ps2_stubs &packetSize, cursor, chunk, - AV_NOPTS_VALUE, - AV_NOPTS_VALUE, + parserPts, + parserDts, 0); if (used < 0) { @@ -121,10 +126,16 @@ namespace ps2_stubs cursor += used; remaining -= static_cast(used); + if (used > 0) + { + parserPts = AV_NOPTS_VALUE; + parserDts = AV_NOPTS_VALUE; + } + if (packetSize > 0) { ++totalPacketsSent; - if (!sendPacket(packetData, static_cast(packetSize), frames)) + if (!sendPacket(packetData, static_cast(packetSize), frames, m_parser->pts, m_parser->dts)) { return false; } @@ -168,7 +179,7 @@ namespace ps2_stubs AV_NOPTS_VALUE, 0); (void)used; - if (packetSize > 0 && !sendPacket(packetData, static_cast(packetSize), frames)) + if (packetSize > 0 && !sendPacket(packetData, static_cast(packetSize), frames, m_parser->pts, m_parser->dts)) { return false; } @@ -253,7 +264,12 @@ namespace ps2_stubs } m_codecCtx->thread_count = 1; - m_codecCtx->skip_frame = AVDISCARD_NONKEY; + m_codecCtx->pkt_timebase = AVRational{1, 90000}; + // feedElementaryStream() does not create the decoder until a valid + // MPEG sequence header has been found. Dropping non-key pictures + // here therefore throws away real presentation frames and makes + // movies finish early once the EE is fast enough to drain them. + m_codecCtx->skip_frame = AVDISCARD_DEFAULT; m_codecCtx->err_recognition = 0; const int ret = avcodec_open2(m_codecCtx, codec, nullptr); if (ret < 0) @@ -265,11 +281,14 @@ namespace ps2_stubs m_initialized = true; m_drained = false; - m_seenKeyframe = false; return true; } - bool sendPacket(const uint8_t *data, size_t size, std::deque &frames) + bool sendPacket(const uint8_t *data, + size_t size, + std::deque &frames, + int64_t pts = AV_NOPTS_VALUE, + int64_t dts = AV_NOPTS_VALUE) { if (!data || size == 0) { @@ -284,6 +303,8 @@ namespace ps2_stubs return false; } std::memcpy(m_packet->data, data, size); + m_packet->pts = pts; + m_packet->dts = dts; int ret = avcodec_send_packet(m_codecCtx, m_packet); if (ret == AVERROR(EAGAIN)) @@ -332,12 +353,6 @@ namespace ps2_stubs return true; } - if (!m_seenKeyframe) - { - m_seenKeyframe = true; - m_codecCtx->skip_frame = AVDISCARD_DEFAULT; - } - if (!convertFrame(frames)) { av_frame_unref(m_frame); @@ -391,6 +406,10 @@ namespace ps2_stubs MpegDecodedFrame decoded; decoded.width = width; decoded.height = height; + decoded.repeatPict = std::max(0, m_frame->repeat_pict); + decoded.pts90k = m_frame->best_effort_timestamp != AV_NOPTS_VALUE + ? m_frame->best_effort_timestamp + : -1; decoded.rgba.resize(static_cast(width) * static_cast(height) * 4u); uint8_t *dstData[4] = {decoded.rgba.data(), nullptr, nullptr, nullptr}; @@ -423,14 +442,13 @@ namespace ps2_stubs AVPixelFormat m_swsFormat = AV_PIX_FMT_NONE; bool m_initialized = false; bool m_drained = false; - bool m_seenKeyframe = false; }; #else // TODO class MpegFfmpegDecoder { public: - bool feed(const uint8_t *, size_t, std::deque &) + bool feed(const uint8_t *, size_t, std::deque &, int64_t = -1, int64_t = -1) { static bool s_warnedNoFfmpeg = false; if (!s_warnedNoFfmpeg) @@ -460,6 +478,12 @@ namespace ps2_stubs bool stream = false; }; + constexpr uint64_t kPictureClockOne = 1ull << 32u; + // NTSC-style fields at ~59.94 Hz to keep MPEG timing yet (29.97 fps). + constexpr uint64_t kDefaultPictureIntervalQ32 = 2ull * kPictureClockOne; + constexpr size_t kMpegTimingScanLimit = 4096u; + constexpr size_t kMaxDecodedPicturesAhead = 8u; + struct MpegPlaybackState { uint32_t picturesServed = 0u; @@ -468,6 +492,7 @@ namespace ps2_stubs uint32_t decodeMode = 0u; uint32_t imageBufferAddr = 0u; bool sawInput = false; + bool sawSequenceEnd = false; bool streamEnded = false; bool decoderFailed = false; uint64_t cdStreamGeneration = 0u; @@ -477,8 +502,16 @@ namespace ps2_stubs std::vector pssGuestAddrs; std::deque decodedFrames; std::unique_ptr decoder; - uint64_t pictureIntervalQ32 = 0u; + uint8_t frameRateCode = 0u; + uint8_t frameRateExtensionN = 0u; + uint8_t frameRateExtensionD = 0u; + bool hasFrameRateExtension = false; + std::vector videoTimingScanBuffer; + uint64_t pictureIntervalQ32 = kDefaultPictureIntervalQ32; uint64_t nextPictureTickQ32 = std::numeric_limits::max(); + uint64_t presentationEndTickQ32 = std::numeric_limits::max(); + int64_t firstPresentedPts90k = -1; + uint64_t ptsPresentationBaseTickQ32 = 0u; }; struct MpegStreamCallbackEvent @@ -528,9 +561,8 @@ namespace ps2_stubs constexpr uint8_t kMpegPrivateStream1 = 0xBDu; constexpr size_t kStartCodeNotFound = std::numeric_limits::max(); constexpr uint32_t kMpegCallbackDataSize = 0x20u; - constexpr uint64_t kPictureClockOne = 1ull << 32u; - uint64_t mpegPictureIntervalQ32(uint8_t frameRateCode) + uint64_t mpegPictureIntervalQ32(uint8_t frameRateCode, uint8_t frameRateExtensionN = 0u, uint8_t frameRateExtensionD = 0u) { uint64_t frameRateNumerator = 0u; uint64_t frameRateDenominator = 1u; @@ -567,13 +599,179 @@ namespace ps2_stubs return 0u; } - // EE VSync runs at the NTSC field rate. Q32 preserves fractional - // cadences such as 24 fps without accumulating host-time drift. - const uint64_t denominator = 1001u * frameRateNumerator; - const uint64_t numerator = (60000u * frameRateDenominator) << 32u; + const uint64_t extensionNumerator = static_cast(frameRateExtensionN) + 1u; + const uint64_t extensionDenominator = static_cast(frameRateExtensionD) + 1u; + const uint64_t denominator = 1001u * frameRateNumerator * extensionNumerator; + const uint64_t numerator = (60000u * frameRateDenominator * extensionDenominator) << 32u; return std::max(kPictureClockOne, (numerator + denominator / 2u) / denominator); } + uint32_t readMpegBits(const uint8_t *data, size_t bitOffset, uint32_t bitCount) + { + uint32_t value = 0u; + for (uint32_t bit = 0u; bit < bitCount; ++bit) + { + const size_t absoluteBit = bitOffset + bit; + const uint8_t source = data[absoluteBit >> 3u]; + value = (value << 1u) | ((source >> (7u - static_cast(absoluteBit & 7u))) & 1u); + } + return value; + } + + void updateMpegPictureTiming(MpegPlaybackState &playback, const uint8_t *data, size_t size) + { + if (!data || size == 0u) + { + return; + } + + playback.videoTimingScanBuffer.insert(playback.videoTimingScanBuffer.end(), data, data + size); + if (playback.videoTimingScanBuffer.size() > kMpegTimingScanLimit) + { + const size_t discard = playback.videoTimingScanBuffer.size() - kMpegTimingScanLimit; + playback.videoTimingScanBuffer.erase(playback.videoTimingScanBuffer.begin(), playback.videoTimingScanBuffer.begin() + static_cast(discard)); + } + + const std::vector &buffer = playback.videoTimingScanBuffer; + size_t lastSequenceHeader = kStartCodeNotFound; + for (size_t i = 0u; i + 7u < buffer.size(); ++i) + { + if (buffer[i + 0u] == 0x00u && + buffer[i + 1u] == 0x00u && + buffer[i + 2u] == 0x01u && + buffer[i + 3u] == 0xB3u) + { + const uint8_t frameRateCode = buffer[i + 7u] & 0x0Fu; + if (mpegPictureIntervalQ32(frameRateCode) != 0u) + { + lastSequenceHeader = i; + } + } + } + + if (lastSequenceHeader == kStartCodeNotFound) + { + return; + } + + playback.frameRateCode = buffer[lastSequenceHeader + 7u] & 0x0Fu; + playback.frameRateExtensionN = 0u; + playback.frameRateExtensionD = 0u; + playback.hasFrameRateExtension = false; + playback.pictureIntervalQ32 = mpegPictureIntervalQ32(playback.frameRateCode); + + for (size_t i = lastSequenceHeader + 8u; i + 9u < buffer.size(); ++i) + { + if (buffer[i + 0u] != 0x00u || + buffer[i + 1u] != 0x00u || + buffer[i + 2u] != 0x01u) + { + continue; + } + + if (buffer[i + 3u] == 0xB3u) + { + break; + } + if (buffer[i + 3u] != 0xB5u) + { + continue; + } + + const uint8_t *extension = buffer.data() + i + 4u; + if (readMpegBits(extension, 0u, 4u) != 1u) + { + continue; + } + + playback.frameRateExtensionN = static_cast(readMpegBits(extension, 41u, 2u)); + playback.frameRateExtensionD = static_cast(readMpegBits(extension, 43u, 5u)); + playback.hasFrameRateExtension = true; + playback.pictureIntervalQ32 = mpegPictureIntervalQ32( + playback.frameRateCode, + playback.frameRateExtensionN, + playback.frameRateExtensionD); + break; + } + + if (playback.pictureIntervalQ32 == 0u) + { + playback.pictureIntervalQ32 = kDefaultPictureIntervalQ32; + } + } + + uint64_t decodedFrameIntervalQ32(const MpegPlaybackState &playback, + const MpegDecodedFrame &frame) + { + const uint64_t base = playback.pictureIntervalQ32 != 0u + ? playback.pictureIntervalQ32 + : kDefaultPictureIntervalQ32; + const uint64_t fields = static_cast(2 + std::max(0, frame.repeatPict)); + return std::max(kPictureClockOne, (base * fields + 1u) / 2u); + } + + constexpr uint64_t kMpegPtsWrap = 1ull << 33u; + constexpr uint64_t kMpegPtsHalfWrap = 1ull << 32u; + + int64_t mpegPtsDelta90k(int64_t fromPts, int64_t toPts) + { + if (fromPts < 0 || toPts < 0) + { + return 0; + } + + uint64_t from = static_cast(fromPts) & (kMpegPtsWrap - 1u); + uint64_t to = static_cast(toPts) & (kMpegPtsWrap - 1u); + uint64_t delta = (to - from) & (kMpegPtsWrap - 1u); + if (delta >= kMpegPtsHalfWrap) + { + return -static_cast(kMpegPtsWrap - delta); + } + return static_cast(delta); + } + + uint64_t mpegPtsDeltaToVSyncQ32(uint64_t delta90k) + { + // 90 kHz MPEG clock -> NTSC field clock (60000/1001 Hz): + // fields = pts * 60000 / (90000 * 1001) = pts * 2 / 3003. + constexpr uint64_t kPtsDivisor = 3003u; + const uint64_t whole = delta90k / kPtsDivisor; + const uint64_t remainder = delta90k % kPtsDivisor; + const uint64_t wholeQ32 = whole * 2u * kPictureClockOne; + const uint64_t remainderQ32 = ((remainder * 2u * kPictureClockOne) + kPtsDivisor / 2u) / kPtsDivisor; + return wholeQ32 + remainderQ32; + } + + uint64_t presentationTickForFrame(MpegPlaybackState &playback, const MpegDecodedFrame &frame, uint64_t currentTickQ32) + { + if (frame.pts90k < 0) + { + if (playback.nextPictureTickQ32 == std::numeric_limits::max()) + { + playback.nextPictureTickQ32 = currentTickQ32; + } + return playback.nextPictureTickQ32; + } + + if (playback.firstPresentedPts90k < 0) + { + playback.firstPresentedPts90k = frame.pts90k; + playback.ptsPresentationBaseTickQ32 = currentTickQ32; + return currentTickQ32; + } + + const int64_t delta = mpegPtsDelta90k(playback.firstPresentedPts90k, frame.pts90k); + if (delta >= 0) + { + return playback.ptsPresentationBaseTickQ32 + mpegPtsDeltaToVSyncQ32(static_cast(delta)); + } + + const uint64_t backwards = mpegPtsDeltaToVSyncQ32(static_cast(-delta)); + return playback.ptsPresentationBaseTickQ32 > backwards + ? playback.ptsPresentationBaseTickQ32 - backwards + : 0u; + } + uint32_t align16(uint32_t value) { return (value + 15u) & ~15u; @@ -622,8 +820,7 @@ namespace ps2_stubs uint16_t readBe16(const uint8_t *p) { - return static_cast((static_cast(p[0]) << 8u) | - static_cast(p[1])); + return static_cast((static_cast(p[0]) << 8u) | static_cast(p[1])); } bool isVideoStreamId(uint8_t streamId) @@ -721,49 +918,90 @@ namespace ps2_stubs return kStartCodeNotFound; } - size_t parsePesPayloadOffset(const uint8_t *packet, size_t packetSize) + struct MpegPesHeader + { + size_t payloadOffset = 0u; + int64_t pts90k = -1; + int64_t dts90k = -1; + }; + + int64_t decodePesTimestamp90k(const uint8_t *p, size_t remaining) + { + if (!p || remaining < 5u) + { + return -1; + } + + const uint64_t value = + (static_cast((p[0] >> 1u) & 0x07u) << 30u) | + (static_cast(p[1]) << 22u) | + (static_cast((p[2] >> 1u) & 0x7Fu) << 15u) | + (static_cast(p[3]) << 7u) | + static_cast((p[4] >> 1u) & 0x7Fu); + return static_cast(value & (kMpegPtsWrap - 1u)); + } + + MpegPesHeader parsePesHeader(const uint8_t *packet, size_t packetSize) { + MpegPesHeader result{}; + result.payloadOffset = packetSize; if (!packet || packetSize <= 6u) { - return packetSize; + return result; } size_t pos = 6u; if (packetSize >= 9u && (packet[pos] & 0xC0u) == 0x80u) { - return std::min(packetSize, 9u + static_cast(packet[pos + 2u])); + const uint8_t ptsDtsFlags = packet[pos + 1u] & 0xC0u; + const size_t headerDataLength = static_cast(packet[pos + 2u]); + const size_t optionalStart = 9u; + const size_t optionalEnd = std::min(packetSize, optionalStart + headerDataLength); + if ((ptsDtsFlags == 0x80u || ptsDtsFlags == 0xC0u) && optionalEnd >= optionalStart + 5u) + { + result.pts90k = decodePesTimestamp90k(packet + optionalStart, optionalEnd - optionalStart); + } + if (ptsDtsFlags == 0xC0u && optionalEnd >= optionalStart + 10u) + { + result.dts90k = decodePesTimestamp90k(packet + optionalStart + 5u, optionalEnd - optionalStart - 5u); + } + result.payloadOffset = optionalEnd; + return result; } + // MPEG-1 PES. while (pos < packetSize && packet[pos] == 0xFFu) { ++pos; } - if (pos + 1u < packetSize && (packet[pos] & 0xC0u) == 0x40u) { pos += 2u; } - if (pos >= packetSize) { - return packetSize; + return result; } - const uint8_t flags = packet[pos]; - if ((flags & 0xF0u) == 0x20u) + const uint8_t marker = packet[pos] & 0xF0u; + if (marker == 0x20u && pos + 5u <= packetSize) { + result.pts90k = decodePesTimestamp90k(packet + pos, packetSize - pos); pos += 5u; } - else if ((flags & 0xF0u) == 0x30u) + else if (marker == 0x30u && pos + 10u <= packetSize) { + result.pts90k = decodePesTimestamp90k(packet + pos, packetSize - pos); + result.dts90k = decodePesTimestamp90k(packet + pos + 5u, packetSize - pos - 5u); pos += 10u; } - else if (flags == 0x0Fu) + else if (packet[pos] == 0x0Fu) { - pos += 1u; + ++pos; } - return std::min(packetSize, pos); + result.payloadOffset = std::min(packetSize, pos); + return result; } void flushDecoderIfEnded(MpegPlaybackState &playback) @@ -774,7 +1012,7 @@ namespace ps2_stubs } } - void feedElementaryStream(MpegPlaybackState &playback, const uint8_t *data, size_t size) + void feedElementaryStream(MpegPlaybackState &playback, const uint8_t *data, size_t size, int64_t pts90k = -1, int64_t dts90k = -1) { if (!data || size == 0) { @@ -800,6 +1038,7 @@ namespace ps2_stubs } playback.sawInput = true; + updateMpegPictureTiming(playback, data, size); if (playback.waitingForVideoSequenceHeader) { playback.videoSequenceSyncBuffer.insert( @@ -833,8 +1072,14 @@ namespace ps2_stubs data = playback.videoSequenceSyncBuffer.data(); size = playback.videoSequenceSyncBuffer.size(); - playback.pictureIntervalQ32 = mpegPictureIntervalQ32(data[7u] & 0x0Fu); + if (playback.pictureIntervalQ32 == 0u) + { + playback.pictureIntervalQ32 = kDefaultPictureIntervalQ32; + } playback.nextPictureTickQ32 = std::numeric_limits::max(); + playback.presentationEndTickQ32 = std::numeric_limits::max(); + playback.firstPresentedPts90k = -1; + playback.ptsPresentationBaseTickQ32 = 0u; playback.waitingForVideoSequenceHeader = false; playback.decoderFailed = false; playback.decoder.reset(); @@ -843,7 +1088,7 @@ namespace ps2_stubs if (containsMpegSequenceEnd(data, size)) { - playback.streamEnded = true; + playback.sawSequenceEnd = true; playback.cdStreamGeneration = g_mpeg_stub_state.cdStreamGeneration; } @@ -852,7 +1097,7 @@ namespace ps2_stubs playback.decoder = std::make_unique(); } - if (!playback.decoder->feed(data, size, playback.decodedFrames)) + if (!playback.decoder->feed(data, size, playback.decodedFrames, pts90k, dts90k)) { playback.decoder.reset(); playback.waitingForVideoSequenceHeader = true; @@ -909,13 +1154,17 @@ namespace ps2_stubs uint32_t streamType, uint32_t dataAddr, uint32_t len, - std::vector &callbackEvents) + std::vector &callbackEvents, + int64_t pts90k = -1, + int64_t dts90k = -1) { MpegStreamCallbackEvent event{}; event.mpegAddr = mpegAddr; event.streamType = streamType; event.dataAddr = dataAddr; event.len = len; + event.pts = pts90k >= 0 ? static_cast(pts90k) : 0xFFFFFFFFFFFFFFFFull; + event.dts = dts90k >= 0 ? static_cast(dts90k) : 0xFFFFFFFFFFFFFFFFull; event.callbacks = matchingStreamCallbacks(mpegAddr, streamType); if (!event.callbacks.empty()) { @@ -1067,7 +1316,8 @@ namespace ps2_stubs if (isVideoStreamId(streamId)) { - const size_t payloadStart = parsePesPayloadOffset(buffer.data(), packetEnd); + const MpegPesHeader pes = parsePesHeader(buffer.data(), packetEnd); + const size_t payloadStart = pes.payloadOffset; if (payloadStart < packetEnd) { if (payloadStart < playback.pssGuestAddrs.size()) @@ -1077,17 +1327,22 @@ namespace ps2_stubs kMpegStrM2V, playback.pssGuestAddrs[payloadStart], static_cast(packetEnd - payloadStart), - callbackEvents); + callbackEvents, + pes.pts90k, + pes.dts90k); } feedElementaryStream( playback, buffer.data() + payloadStart, - packetEnd - payloadStart); + packetEnd - payloadStart, + pes.pts90k, + pes.dts90k); } } else if (isAudioStreamId(streamId)) { - const size_t payloadStart = parsePesPayloadOffset(buffer.data(), packetEnd); + const MpegPesHeader pes = parsePesHeader(buffer.data(), packetEnd); + const size_t payloadStart = pes.payloadOffset; if (payloadStart < packetEnd && payloadStart < playback.pssGuestAddrs.size()) { queueStreamCallbackEvent( @@ -1095,13 +1350,17 @@ namespace ps2_stubs kMpegStrPCM, playback.pssGuestAddrs[payloadStart], static_cast(packetEnd - payloadStart), - callbackEvents); + callbackEvents, + pes.pts90k, + pes.dts90k); queueStreamCallbackEvent( mpegAddr, kMpegStrADPCM, playback.pssGuestAddrs[payloadStart], static_cast(packetEnd - payloadStart), - callbackEvents); + callbackEvents, + pes.pts90k, + pes.dts90k); } } @@ -1135,6 +1394,25 @@ namespace ps2_stubs } } + bool mpegDemuxBackpressured(const MpegPlaybackState &playback) + { + // Let EOF finalization drain any tail that is already in the guest + // ring, otherwise bound decode lead to a handful of pictures. + // + // Important: do not park sceMpegDemuxPss/Ring here. Code Veronica + // explicitly wakes its video thread before every demux call and that + // thread sleeps again after presenting one picture. A single host + // decoder feed can enqueue more than kMaxDecodedPicturesAhead frames; + // parking the producer then leaves the consumer asleep after draining + // just one frame, with nobody left to issue the next WakeupThread. + // Returning 0 bytes consumed instead leaves the guest ring intact and + // lets the game's producer loop wake the consumer again. Backpressure + // still propagates naturally to sceCdStRead because the ring does not + // advance while this is true. + return !g_mpeg_stub_state.currentCdStreamEofSeen && + playback.decodedFrames.size() >= kMaxDecodedPicturesAhead; + } + void recordCdStreamBytesDemuxedUnlocked( size_t consumed, std::vector &completedMpegIds, @@ -1575,15 +1853,23 @@ namespace ps2_stubs { (void)rdram; const uint32_t mpegAddr = getRegU32(ctx, 4); + bool wakePictureWaiter = false; { std::lock_guard lock(g_mpeg_stub_mutex); MpegPlaybackState &playback = getPlaybackState(mpegAddr); + const size_t framesBefore = playback.decodedFrames.size(); if (playback.decoder) { playback.decoder->flush(playback.decodedFrames); } + wakePictureWaiter = playback.decodedFrames.size() != framesBefore || + playback.streamEnded || + playback.decoderFailed; + } + if (wakePictureWaiter) + { + runtime->eeScheduler().completeExternalWait(kMpegPictureWaitType, mpegAddr, KE_OK); } - runtime->eeScheduler().completeExternalWait(kMpegPictureWaitType, mpegAddr, KE_OK); setReturnS32(ctx, 0); } @@ -1594,9 +1880,11 @@ namespace ps2_stubs const uint32_t byteCount = getRegU32(ctx, 6); size_t copied = 0u; + bool wakePictureWaiter = false; { std::lock_guard lock(g_mpeg_stub_mutex); MpegPlaybackState &playback = getPlaybackState(mpegAddr); + const size_t framesBefore = playback.decodedFrames.size(); while (copied < byteCount) { const uint32_t curAddr = dataAddr + static_cast(copied); @@ -1610,9 +1898,13 @@ namespace ps2_stubs feedElementaryStream(playback, src, chunk); copied += chunk; } + wakePictureWaiter = playback.decodedFrames.size() != framesBefore || playback.streamEnded || playback.decoderFailed; } - runtime->eeScheduler().completeExternalWait(kMpegPictureWaitType, mpegAddr, KE_OK); + if (wakePictureWaiter) + { + runtime->eeScheduler().completeExternalWait(kMpegPictureWaitType, mpegAddr, KE_OK); + } setReturnS32(ctx, static_cast(copied)); } @@ -1793,24 +2085,46 @@ namespace ps2_stubs std::vector callbackEvents; std::vector completedMpegIds; size_t consumed = 0u; + size_t decodedBefore = 0u; size_t decodedCount = 0u; uint32_t traceIdx = 0u; bool eofChanged = false; + bool backpressured = false; { std::lock_guard lock(g_mpeg_stub_mutex); MpegPlaybackState &playback = getPlaybackState(mpegAddr); - consumed = appendGuestBytes(mpegAddr, playback, rdram, dataAddr, byteCount, callbackEvents); - recordCdStreamBytesDemuxedUnlocked(consumed, completedMpegIds, eofChanged); + decodedBefore = playback.decodedFrames.size(); + backpressured = mpegDemuxBackpressured(playback); + if (!backpressured) + { + consumed = appendGuestBytes(mpegAddr, playback, rdram, dataAddr, byteCount, callbackEvents); + recordCdStreamBytesDemuxedUnlocked(consumed, completedMpegIds, eofChanged); + } decodedCount = playback.decodedFrames.size(); traceIdx = g_mpeg_stub_state.demuxPssTraceCount++; } - runtime->eeScheduler().completeExternalWait(kMpegPictureWaitType, mpegAddr, KE_OK); + + if (backpressured) + { + if (traceIdx < 32u) + { + PS2_IF_AGRESSIVE_LOGS({ + std::cerr << "[MPEG:DemuxPss:BACKPRESSURE] mpeg=0x" << std::hex << mpegAddr << std::dec << " decoded=" << decodedCount << std::endl; + }); + } + setReturnS32(ctx, 0); + return; + } + const bool currentStreamCompleted = std::find(completedMpegIds.begin(), completedMpegIds.end(), mpegAddr) != completedMpegIds.end(); + if (decodedCount != decodedBefore || eofChanged || currentStreamCompleted) + { + runtime->eeScheduler().completeExternalWait(kMpegPictureWaitType, mpegAddr, KE_OK); + } for (const uint32_t completedMpegId : completedMpegIds) { if (completedMpegId != mpegAddr) { - runtime->eeScheduler().completeExternalWait( - kMpegPictureWaitType, completedMpegId, KE_OK); + runtime->eeScheduler().completeExternalWait(kMpegPictureWaitType, completedMpegId, KE_OK); } } @@ -1854,32 +2168,56 @@ namespace ps2_stubs std::vector callbackEvents; std::vector completedMpegIds; size_t consumed = 0u; + size_t decodedBefore = 0u; size_t decodedCount = 0u; uint32_t traceIdx = 0u; bool eofChanged = false; + bool backpressured = false; { std::lock_guard lock(g_mpeg_stub_mutex); MpegPlaybackState &playback = getPlaybackState(mpegAddr); - consumed = appendGuestRingBytes( - mpegAddr, - playback, - rdram, - dataAddr, - availableBytes, - ringBaseAddr, - ringSize, - callbackEvents); - recordCdStreamBytesDemuxedUnlocked(consumed, completedMpegIds, eofChanged); + decodedBefore = playback.decodedFrames.size(); + backpressured = mpegDemuxBackpressured(playback); + if (!backpressured) + { + consumed = appendGuestRingBytes( + mpegAddr, + playback, + rdram, + dataAddr, + availableBytes, + ringBaseAddr, + ringSize, + callbackEvents); + recordCdStreamBytesDemuxedUnlocked(consumed, completedMpegIds, eofChanged); + } decodedCount = playback.decodedFrames.size(); traceIdx = g_mpeg_stub_state.demuxRingTraceCount++; } - runtime->eeScheduler().completeExternalWait(kMpegPictureWaitType, mpegAddr, KE_OK); + + if (backpressured) + { + if (traceIdx < 32u) + { + PS2_IF_AGRESSIVE_LOGS({ + std::cerr << "[MPEG:DemuxPssRing:BACKPRESSURE] mpeg=0x" << std::hex << mpegAddr + << std::dec << " decoded=" << decodedCount + << " avail=" << availableBytes << std::endl; + }); + } + setReturnS32(ctx, 0); + return; + } + const bool currentStreamCompleted = std::find(completedMpegIds.begin(), completedMpegIds.end(), mpegAddr) != completedMpegIds.end(); + if (decodedCount != decodedBefore || eofChanged || currentStreamCompleted) + { + runtime->eeScheduler().completeExternalWait(kMpegPictureWaitType, mpegAddr, KE_OK); + } for (const uint32_t completedMpegId : completedMpegIds) { if (completedMpegId != mpegAddr) { - runtime->eeScheduler().completeExternalWait( - kMpegPictureWaitType, completedMpegId, KE_OK); + runtime->eeScheduler().completeExternalWait(kMpegPictureWaitType, completedMpegId, KE_OK); } } @@ -1986,40 +2324,38 @@ namespace ps2_stubs if (!playback.decodedFrames.empty()) { - if (playback.pictureIntervalQ32 != 0u) + const uint64_t currentTick = runtime->eeScheduler().currentVSyncTick(); + const uint64_t currentTickQ32 = currentTick << 32u; + const MpegDecodedFrame &nextFrame = playback.decodedFrames.front(); + const uint64_t frameIntervalQ32 = decodedFrameIntervalQ32(playback, nextFrame); + uint64_t presentationTargetQ32 = presentationTickForFrame(playback, nextFrame, currentTickQ32); + + if (currentTickQ32 > presentationTargetQ32 && currentTickQ32 - presentationTargetQ32 >= frameIntervalQ32) { - const uint64_t currentTick = runtime->eeScheduler().currentVSyncTick(); - const uint64_t currentTickQ32 = currentTick << 32u; - if (playback.nextPictureTickQ32 == std::numeric_limits::max()) + const uint64_t correction = currentTickQ32 - presentationTargetQ32; + presentationTargetQ32 = currentTickQ32; + if (nextFrame.pts90k >= 0 && playback.firstPresentedPts90k >= 0) { - playback.nextPictureTickQ32 = currentTickQ32; + playback.ptsPresentationBaseTickQ32 += correction; } + playback.nextPictureTickQ32 = currentTickQ32; + } - if (currentTickQ32 < playback.nextPictureTickQ32) - { - const uint64_t eligibleTick = - (playback.nextPictureTickQ32 + kPictureClockOne - 1u) >> 32u; - lock.unlock(); - runtime->eeScheduler().waitVSync( - eligibleTick - 1u, - -1, - [rdram, runtime](R5900Context &resumeContext) + if (currentTickQ32 < presentationTargetQ32) + { + const uint64_t eligibleTick = (presentationTargetQ32 + kPictureClockOne - 1u) >> 32u; + lock.unlock(); + runtime->eeScheduler().waitVSync( + eligibleTick - 1u, + -1, + [rdram, runtime](R5900Context &resumeContext) + { + if (static_cast(getRegU32(&resumeContext, 2)) < 0) { - if (static_cast(getRegU32(&resumeContext, 2)) < 0) - { - return; - } - sceMpegGetPicture(rdram, &resumeContext, runtime); - }); - } - - // If decoding fell more than one frame behind, resume from the - // current field instead of releasing a burst of stale pictures. - if (currentTickQ32 - playback.nextPictureTickQ32 >= playback.pictureIntervalQ32) - { - playback.nextPictureTickQ32 = currentTickQ32; - } - playback.nextPictureTickQ32 += playback.pictureIntervalQ32; + return; + } + sceMpegGetPicture(rdram, &resumeContext, runtime); + }); } frame = std::move(playback.decodedFrames.front()); @@ -2030,6 +2366,8 @@ namespace ps2_stubs height = playback.height; frameCount = playback.picturesServed; playback.picturesServed += 1u; + playback.nextPictureTickQ32 = presentationTargetQ32 + frameIntervalQ32; + playback.presentationEndTickQ32 = playback.nextPictureTickQ32; haveFrame = true; if (g_mpeg_stub_state.pictureTraceCount < 32u) { @@ -2117,20 +2455,38 @@ namespace ps2_stubs std::lock_guard lock(g_mpeg_stub_mutex); g_mpeg_stub_state.initialized = true; MpegPlaybackState &playback = getPlaybackState(mpegAddr); - const bool ended = playback.streamEnded || (playback.decoderFailed && playback.sawInput); + // Only the producer/demux EOF is authoritative. A sequence_end_code can + // be observed while more PSS data is still buffered, and a decoder + // failure before producer EOF may still recover on a later sequence. + const bool producerEnded = + g_mpeg_stub_state.currentCdStreamEofSeen && + playback.cdStreamGeneration == g_mpeg_stub_state.cdStreamGeneration; + const bool ended = producerEnded && + (playback.streamEnded || (playback.decoderFailed && playback.sawInput)); + const uint64_t presentationEnd = playback.presentationEndTickQ32; + const uint64_t currentTickQ32 = runtime != nullptr + ? (runtime->eeScheduler().currentVSyncTick() << 32u) + : std::numeric_limits::max(); + const bool presentationComplete = + presentationEnd == std::numeric_limits::max() || + currentTickQ32 >= presentationEnd; if (g_mpeg_stub_state.isEndTraceCount < 16u) { PS2_IF_AGRESSIVE_LOGS({ std::cerr << "[MPEG:IsEnd] mpeg=0x" << std::hex << mpegAddr << std::dec << " ended=" << ended + << " producerEof=" << producerEnded + << " seqEnd=" << playback.sawSequenceEnd + << " streamEnded=" << playback.streamEnded + << " presentationComplete=" << presentationComplete << " frames=" << playback.decodedFrames.size() << " sawInput=" << playback.sawInput << std::endl; }); ++g_mpeg_stub_state.isEndTraceCount; } - setReturnS32(ctx, (ended && playback.decodedFrames.empty()) ? 1 : 0); + setReturnS32(ctx, (ended && playback.decodedFrames.empty() && presentationComplete) ? 1 : 0); } void sceMpegIsRefBuffEmpty(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) diff --git a/ps2xRuntime/src/lib/ps2_debug_panel.cpp b/ps2xRuntime/src/lib/ps2_debug_panel.cpp index 71c647943..cf0b43965 100644 --- a/ps2xRuntime/src/lib/ps2_debug_panel.cpp +++ b/ps2xRuntime/src/lib/ps2_debug_panel.cpp @@ -767,6 +767,10 @@ namespace { const EeKernelSnapshot snapshot = runtime.eeScheduler().snapshot(); ImGui::Text("Threads: %zu running=%d", snapshot.threads.size(), snapshot.runningThreadId); + ImGui::Text("EE cycle: %llu slice end: %llu next event: %llu", + static_cast(snapshot.eeCycle), + static_cast(snapshot.sliceEndCycle), + static_cast(snapshot.nextEventCycle)); if (ImGui::BeginTable("threads", 11, ImGuiTableFlags_Borders | ImGuiTableFlags_RowBg | ImGuiTableFlags_Resizable | ImGuiTableFlags_ScrollY, ImVec2(0, 320))) { ImGui::TableSetupColumn("ID"); diff --git a/ps2xRuntime/src/lib/ps2_runtime.cpp b/ps2xRuntime/src/lib/ps2_runtime.cpp index ae0b2b0e9..38bc945fc 100644 --- a/ps2xRuntime/src/lib/ps2_runtime.cpp +++ b/ps2xRuntime/src/lib/ps2_runtime.cpp @@ -1312,6 +1312,14 @@ bool PS2Runtime::dispatchGuestBranch(uint8_t *rdram, ctx->pc = targetPc; const bool isCall = (kind == GuestBranchKind::DirectCall || kind == GuestBranchKind::IndirectCall); + // Every inter-function transfer is also a deterministic EE safe point. + // Backward edges inside generated functions use eeCheckpointDue(), while + // this charge bounds straight-line call chains that have no local loop. + if (m_eeScheduler && m_eeScheduler->checkpointDue(EeScheduler::kGuestDispatchCycles)) + { + return false; + } + if (kind == GuestBranchKind::Return) { if (!hasFunction(targetPc)) @@ -2165,9 +2173,9 @@ void PS2Runtime::postEeEvent(EeEvent event) m_eeScheduler->postEvent(event); } -bool PS2Runtime::eeCheckpointDue() const noexcept +bool PS2Runtime::eeCheckpointDue(uint32_t cycles) noexcept { - return m_eeScheduler->checkpointDue(); + return m_eeScheduler->checkpointDue(cycles); } [[noreturn]] void PS2Runtime::eeWaitVSyncTicks(uint32_t ticks, uint32_t resumePc) From f9332d6df1b64ce13ff516e4a116980a201f1494 Mon Sep 17 00:00:00 2001 From: Ran-j Date: Tue, 11 Aug 2026 11:21:56 -0300 Subject: [PATCH 5/8] fix: fix lotr tests --- ps2xTest/src/ps2_sif_rpc_tests.cpp | 75 +++++++++++++++++++++--------- 1 file changed, 52 insertions(+), 23 deletions(-) diff --git a/ps2xTest/src/ps2_sif_rpc_tests.cpp b/ps2xTest/src/ps2_sif_rpc_tests.cpp index cb4d3f0cd..eefb495d1 100644 --- a/ps2xTest/src/ps2_sif_rpc_tests.cpp +++ b/ps2xTest/src/ps2_sif_rpc_tests.cpp @@ -165,11 +165,21 @@ namespace constexpr uint32_t K_DTX_DISPATCH_RESULT_MARKER = 0xD15CA7C1u; constexpr uint32_t K_DTX_SCHEDULER_CALL = 0x00102000u; constexpr uint32_t K_DTX_SCHEDULER_RESUME = 0x00102010u; + constexpr uint32_t K_LOTR_SOUND_SCHEDULER_CALL = 0x00102020u; + constexpr uint32_t K_LOTR_SOUND_SCHEDULER_RESUME = 0x00102030u; uint32_t g_schedulerRpcClient = 0u; uint32_t g_schedulerRpcNumber = 0u; uint32_t g_schedulerRpcSend = 0u; uint32_t g_schedulerRpcReceive = 0u; uint32_t g_schedulerRpcResult = 0u; + uint32_t g_schedulerLotrSoundClient = 0u; + uint32_t g_schedulerLotrSoundSend = 0u; + uint32_t g_schedulerLotrSoundReceive = 0u; + uint32_t g_schedulerLotrSoundEndFunction = 0u; + uint32_t g_schedulerLotrSoundSemaphore = 0u; + uint32_t g_schedulerLotrSoundResult = 0u; + + void writeGuestU32(uint8_t *rdram, uint32_t addr, uint32_t value); void lotrSoundEndCallback(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { @@ -187,6 +197,28 @@ namespace ctx->pc = ::getRegU32(ctx, 31); } + void schedulerLotrSoundRpcCall(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) + { + SET_GPR_U32(ctx, 4, g_schedulerLotrSoundClient); + SET_GPR_U32(ctx, 5, 0u); + SET_GPR_U32(ctx, 6, K_SIF_RPC_MODE_NOWAIT); + SET_GPR_U32(ctx, 7, g_schedulerLotrSoundSend); + SET_GPR_U32(ctx, 8, 0x2000u); + SET_GPR_U32(ctx, 9, g_schedulerLotrSoundReceive); + SET_GPR_U32(ctx, 10, 0x2000u); + SET_GPR_U32(ctx, 11, g_schedulerLotrSoundEndFunction); + writeGuestU32(rdram, ::getRegU32(ctx, 29), g_schedulerLotrSoundSemaphore); + ctx->pc = K_LOTR_SOUND_SCHEDULER_RESUME; + SifCallRpc(rdram, ctx, runtime); + } + + void schedulerLotrSoundRpcResume(uint8_t *, R5900Context *ctx, PS2Runtime *runtime) + { + g_schedulerLotrSoundResult = ::getRegU32(ctx, 2); + ctx->pc = 0u; + runtime->requestStop(); + } + void schedulerDtxRpcCall(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime) { SET_GPR_U32(ctx, 4, g_schedulerRpcClient); @@ -673,7 +705,6 @@ void register_ps2_sif_rpc_tests() configureProfile(env, "SLUS_205.78"); constexpr uint32_t kClientAddr = 0x00039000u; - constexpr uint32_t kSemaParamAddr = 0x00039100u; constexpr uint32_t kSendAddr = 0x0003A000u; constexpr uint32_t kRecvAddr = 0x0003C000u; constexpr uint32_t kEndFunc = 0x001FFD70u; @@ -683,13 +714,6 @@ void register_ps2_sif_rpc_tests() SifInitRpc(env.rdram.data(), &env.ctx, &env.runtime); - const uint32_t semaParam[6] = {0u, 1u, 0u, 0u, 0u, 0u}; - std::memcpy(env.rdram.data() + kSemaParamAddr, semaParam, sizeof(semaParam)); - setRegU32(env.ctx, 4, kSemaParamAddr); - CreateSema(env.rdram.data(), &env.ctx, &env.runtime); - const int32_t semaId = getRegS32(env.ctx, 2); - t.IsTrue(semaId > 0, "CreateSema should return a positive semaphore id"); - setRegU32(env.ctx, 4, kClientAddr); setRegU32(env.ctx, 5, IOP_SID_LOTR_SOUND); setRegU32(env.ctx, 6, 0u); @@ -698,19 +722,25 @@ void register_ps2_sif_rpc_tests() writeGuestU32(env.rdram.data(), kSendAddr, 3u); std::memset(env.rdram.data() + kRecvAddr, 0xAA, 0x2000u); - setRegU32(env.ctx, 4, kClientAddr); - setRegU32(env.ctx, 5, 0u); - setRegU32(env.ctx, 6, K_SIF_RPC_MODE_NOWAIT); - setRegU32(env.ctx, 7, kSendAddr); - setRegU32(env.ctx, 8, 0x2000u); - setRegU32(env.ctx, 9, kRecvAddr); - setRegU32(env.ctx, 10, 0x2000u); - setRegU32(env.ctx, 11, kEndFunc); - setRegU32(env.ctx, 29, K_STACK_ADDR); - writeGuestU32(env.rdram.data(), K_STACK_ADDR + 0x00u, static_cast(semaId)); - SifCallRpc(env.rdram.data(), &env.ctx, &env.runtime); + env.runtime.registerFunction(K_LOTR_SOUND_SCHEDULER_CALL, schedulerLotrSoundRpcCall); + env.runtime.registerFunction(K_LOTR_SOUND_SCHEDULER_RESUME, schedulerLotrSoundRpcResume); + g_schedulerLotrSoundClient = kClientAddr; + g_schedulerLotrSoundSend = kSendAddr; + g_schedulerLotrSoundReceive = kRecvAddr; + g_schedulerLotrSoundEndFunction = kEndFunc; + g_schedulerLotrSoundResult = static_cast(-1); - t.Equals(getRegS32(env.ctx, 2), KE_OK, "SifCallRpc should succeed for LotR sound RPC"); + R5900Context mainContext{}; + mainContext.pc = K_LOTR_SOUND_SCHEDULER_CALL; + setRegU32(mainContext, 29, K_STACK_ADDR); + env.runtime.eeScheduler().reset(env.rdram.data(), mainContext); + const int32_t semaId = env.runtime.eeScheduler().createSemaphore(0, 1, 0u, 0u); + t.IsTrue(semaId > 0, "scheduler should create a positive semaphore id"); + g_schedulerLotrSoundSemaphore = static_cast(semaId); + env.runtime.eeScheduler().run(); + + t.Equals(g_schedulerLotrSoundResult, static_cast(KE_OK), + "SifCallRpc should resume with KE_OK for LotR sound RPC"); t.Equals(g_lotrSoundCallbackHits.load(), 1u, "LotR SOUND_JP callback should consume the HLE response"); t.Equals(readGuestStruct(env.rdram.data(), kRecvAddr + 0u), 0u, @@ -718,9 +748,8 @@ void register_ps2_sif_rpc_tests() t.IsTrue(readGuestStruct(env.rdram.data(), kRecvAddr + 4u) != 0u, "LotR sound response should advance the IOP update counter"); - setRegU32(env.ctx, 4, static_cast(semaId)); - PollSema(env.rdram.data(), &env.ctx, &env.runtime); - t.Equals(getRegS32(env.ctx, 2), semaId, "LotR sound callback completion should signal the sema"); + t.Equals(env.runtime.eeScheduler().pollSemaphore(semaId), semaId, + "LotR sound callback completion should signal the sema"); }); tc.Run("RECVX sound callbacks complete in HLE and only clear busy on designated callbacks", [](TestCase &t) From 4fff58373c75388c9ac3f204370365f0a9dec8a4 Mon Sep 17 00:00:00 2001 From: Ran-j Date: Wed, 12 Aug 2026 11:49:30 -0300 Subject: [PATCH 6/8] fix: fix cri dtx loading fix: fix wrong mmi instruction translation fix: fix thread info params feat: added EE timers decoder and consumer feat: split SFI and IOP memory to prevent collision and overrides --- ps2xIOP/src/modules/cri_dtx.cpp | 9 +- .../src/lib/mmi_translation_helpers.cpp | 14 +- ps2xRuntime/include/runtime/ee_scheduler.h | 2 + ps2xRuntime/include/runtime/ps2_memory.h | 20 +- ps2xRuntime/src/lib/Kernel/EeScheduler.cpp | 96 ++++++- .../src/lib/Kernel/Stubs/Helpers/Support.h | 4 +- ps2xRuntime/src/lib/Kernel/Stubs/SIF.cpp | 168 +++++++++-- ps2xRuntime/src/lib/Kernel/Stubs/SIF.h | 8 + .../src/lib/Kernel/Syscalls/System.cpp | 16 ++ ps2xRuntime/src/lib/ps2_iop_host.cpp | 22 ++ ps2xRuntime/src/lib/ps2_memory.cpp | 261 +++++++++++++----- ps2xRuntime/src/lib/ps2_runtime.cpp | 8 +- ps2xTest/src/code_generator_tests.cpp | 51 +++- ps2xTest/src/ps2_memory_tests.cpp | 110 +++++++- ps2xTest/src/ps2_runtime_expansion_tests.cpp | 33 +++ ps2xTest/src/ps2_runtime_interrupt_tests.cpp | 93 +++++++ ps2xTest/src/ps2_runtime_kernel_tests.cpp | 40 +++ ps2xTest/src/ps2_sif_dma_tests.cpp | 77 ++++++ 18 files changed, 892 insertions(+), 140 deletions(-) diff --git a/ps2xIOP/src/modules/cri_dtx.cpp b/ps2xIOP/src/modules/cri_dtx.cpp index 8014d3873..55386f555 100644 --- a/ps2xIOP/src/modules/cri_dtx.cpp +++ b/ps2xIOP/src/modules/cri_dtx.cpp @@ -1181,13 +1181,10 @@ namespace ps2x::iop::detail continue; } - appendToSjrmtData(sjrmt->second, - chunkDataAddress, - chunkLength); + appendToSjrmtData(sjrmt->second, chunkDataAddress, chunkLength); + (void)writeGuestPod(m_host, commandAddress + 4u, sjx->second.eeObjectAddress); constexpr uint8_t roomLine = 0u; - (void)m_host.writeGuest(commandAddress + 1u, - &roomLine, - sizeof(roomLine)); + (void)m_host.writeGuest(commandAddress + 1u, &roomLine, sizeof(roomLine)); } consumeActivePs2RnaStreamsLocked(); } diff --git a/ps2xRecomp/src/lib/mmi_translation_helpers.cpp b/ps2xRecomp/src/lib/mmi_translation_helpers.cpp index 4f7a36640..a2bcb777f 100644 --- a/ps2xRecomp/src/lib/mmi_translation_helpers.cpp +++ b/ps2xRecomp/src/lib/mmi_translation_helpers.cpp @@ -456,7 +456,7 @@ namespace ps2recomp { // Swaps halfwords 1<->3 and 5<->7 within the 128-bit register return fmt::format("SET_GPR_VEC(ctx, {}, _mm_shufflelo_epi16(_mm_shufflehi_epi16(GPR_VEC(ctx, {}), _MM_SHUFFLE(2,3,0,1)), _MM_SHUFFLE(2,3,0,1)));", - inst.rd, inst.rs); + inst.rd, inst.rt); } @@ -465,7 +465,7 @@ namespace ps2recomp // Reverses the order of the 8 halfwords return fmt::format("{{ __m128i mask = _mm_setr_epi8(14,15, 12,13, 10,11, 8,9, 6,7, 4,5, 2,3, 0,1); " "SET_GPR_VEC(ctx, {}, PS2_SHUFFLE_EPI8(GPR_VEC(ctx, {}), mask)); }}", - inst.rd, inst.rs); + inst.rd, inst.rt); } @@ -514,7 +514,7 @@ namespace ps2recomp std::string CodeGenerator::translatePEXEW(const Instruction &inst) { return fmt::format("SET_GPR_VEC(ctx, {}, PS2_PEXEW(GPR_VEC(ctx, {})));", - inst.rd, inst.rs); + inst.rd, inst.rt); } @@ -522,7 +522,7 @@ namespace ps2recomp { // Rotates words left by 3: [d,c,b,a] -> [a,d,c,b] return fmt::format("SET_GPR_VEC(ctx, {}, _mm_shuffle_epi32(GPR_VEC(ctx, {}), _MM_SHUFFLE(0,3,2,1)));", - inst.rd, inst.rs); + inst.rd, inst.rt); } @@ -562,7 +562,7 @@ namespace ps2recomp { // Parallel Exchange Center Halfword (same as MMI2 PEXEH) return fmt::format("SET_GPR_VEC(ctx, {}, _mm_shufflelo_epi16(_mm_shufflehi_epi16(GPR_VEC(ctx, {}), _MM_SHUFFLE(2,3,0,1)), _MM_SHUFFLE(2,3,0,1)));", - inst.rd, inst.rs); + inst.rd, inst.rt); } @@ -571,7 +571,7 @@ namespace ps2recomp // Parallel Copy Halfword (Broadcast lower 16 bits of each 64-bit half) return fmt::format("{{ __m128i src = GPR_VEC(ctx, {}); uint16_t l = _mm_extract_epi16(src, 0); uint16_t h = _mm_extract_epi16(src, 4); \n" " SET_GPR_VEC(ctx, {}, _mm_set_epi16(h,h,h,h, l,l,l,l)); }}", - inst.rs, inst.rd); + inst.rt, inst.rd); } @@ -579,7 +579,7 @@ namespace ps2recomp { // Parallel Exchange Center Word (Swaps words 0<>2, 1<>3) return fmt::format("SET_GPR_VEC(ctx, {}, _mm_shuffle_epi32(GPR_VEC(ctx, {}), _MM_SHUFFLE(1,0,3,2)));", - inst.rd, inst.rs); + inst.rd, inst.rt); } diff --git a/ps2xRuntime/include/runtime/ee_scheduler.h b/ps2xRuntime/include/runtime/ee_scheduler.h index a9ecc28b8..fae8b8540 100644 --- a/ps2xRuntime/include/runtime/ee_scheduler.h +++ b/ps2xRuntime/include/runtime/ee_scheduler.h @@ -279,6 +279,7 @@ class EeScheduler // Kernel object API. All calls except postEvent/requestStop execute on the // EE executor and therefore need no host synchronization. + void setupCurrentThread(uint32_t stack, uint32_t stackSize, uint32_t gp); int createThread(const EeThreadCreateParams ¶ms); int deleteThread(int id, uint32_t &ownedStack); int startThread(int id, uint32_t arg, const R5900Context &caller, bool interruptSafe); @@ -416,6 +417,7 @@ class EeScheduler bool m_rescheduleRequested = false; bool m_timeSliceExpired = false; bool m_insideInterrupt = false; + uint32_t m_pendingEeTimerInterrupts = 0; uint64_t m_eeCycle = 0; uint64_t m_sliceEndCycle = kDefaultTimeSliceCycles; std::thread::id m_executorThread{}; diff --git a/ps2xRuntime/include/runtime/ps2_memory.h b/ps2xRuntime/include/runtime/ps2_memory.h index 3bd87289a..9972e4221 100644 --- a/ps2xRuntime/include/runtime/ps2_memory.h +++ b/ps2xRuntime/include/runtime/ps2_memory.h @@ -3,6 +3,7 @@ #include #include +#include #include #include #include @@ -306,6 +307,12 @@ class PS2Memory bool writeIORegister(uint32_t address, uint32_t value); uint32_t readIORegister(uint32_t address); + // EE timers advance from the scheduler's emulated EE-cycle clock. The + // returned mask uses bits 0..3 for newly raised TIM0..TIM3 interrupts. + uint32_t advanceEeTimers(uint64_t eeCycles) noexcept; + [[nodiscard]] uint64_t cyclesUntilNextEeTimerInterrupt() const noexcept; + void resetEeTimers() noexcept; + using GifPacketCallback = std::function; void setGifPacketCallback(GifPacketCallback cb) { m_gifPacketCallback = std::move(cb); } void setGifArbiter(GifArbiter *arbiter) { m_gifArbiter = arbiter; } @@ -432,10 +439,17 @@ class PS2Memory bool isScratchpad(uint32_t address) const; uint8_t *mapVuMemory(uint32_t physAddr, uint32_t size, uint32_t &offset, uint32_t &limit); const uint8_t *mapVuMemory(uint32_t physAddr, uint32_t size, uint32_t &offset, uint32_t &limit) const; - void updateEeTimer0Counter(); + struct EeTimer + { + uint32_t count = 0; + uint32_t mode = 0; + uint32_t compare = 0; + uint32_t hold = 0; + uint64_t clockRemainder = 0; + }; + + std::array m_eeTimers{}; void queueCompletedDmacCause(uint32_t cause); - uint64_t m_timer0LastHostNs = 0; - uint64_t m_timer0FractionNs = 0; }; #endif // PS2_MEMORY_H diff --git a/ps2xRuntime/src/lib/Kernel/EeScheduler.cpp b/ps2xRuntime/src/lib/Kernel/EeScheduler.cpp index 116720750..3a6ec7d94 100644 --- a/ps2xRuntime/src/lib/Kernel/EeScheduler.cpp +++ b/ps2xRuntime/src/lib/Kernel/EeScheduler.cpp @@ -41,6 +41,15 @@ namespace return (microseconds * EeScheduler::kEeClockHz + 999999ull) / 1000000ull; } + std::chrono::nanoseconds eeCyclesToHostDuration(uint64_t cycles) + { + constexpr uint64_t kNanosecondsPerSecond = 1000000000ull; + const uint64_t wholeSeconds = cycles / EeScheduler::kEeClockHz; + const uint64_t remainingCycles = cycles % EeScheduler::kEeClockHz; + const uint64_t remainingNanoseconds = (remainingCycles * kNanosecondsPerSecond + EeScheduler::kEeClockHz - 1u) / EeScheduler::kEeClockHz; + return std::chrono::seconds(wholeSeconds) + std::chrono::nanoseconds(remainingNanoseconds); + } + constexpr uint64_t kVBlankPeriodCycles = microsecondsToEeCycles(16667u); constexpr uint64_t kVBlankDurationCycles = microsecondsToEeCycles(500u); constexpr uint64_t kAlarmTickCycles = microsecondsToEeCycles(kAlarmTickMicroseconds); @@ -101,6 +110,7 @@ void EeScheduler::reset(uint8_t *rdram, const R5900Context &mainContext) m_rescheduleRequested = false; m_timeSliceExpired = false; m_insideInterrupt = false; + m_pendingEeTimerInterrupts = 0u; m_eeCycle = 0u; m_sliceEndCycle = kDefaultTimeSliceCycles; m_stopRequested.store(false, std::memory_order_release); @@ -121,12 +131,15 @@ void EeScheduler::reset(uint8_t *rdram, const R5900Context &mainContext) m_gsVSyncCallbackGp = 0; m_gsVSyncCallbackSp = 0; m_runtime.memory().gs().vsyncTick.store(0u, std::memory_order_release); + m_runtime.memory().resetEeTimers(); GuestThread main{}; main.id = kMainThreadId; main.context = mainContext; main.entry = mainContext.pc; - main.stack = getRegU32(&mainContext, 29); + // $sp is live execution state, not the stable initial stack descriptor + // returned by ReferThreadStatus. SetupThread records that metadata. + main.stack = 0u; main.gp = getRegU32(&mainContext, 28); main.initialPriority = 0; main.currentPriority = 0; @@ -375,7 +388,13 @@ bool EeScheduler::checkpointDue(uint32_t cycles) noexcept void EeScheduler::accountCycles(uint32_t cycles) noexcept { - m_eeCycle += std::max(1u, cycles); + const uint64_t elapsed = std::max(1u, cycles); + m_eeCycle += elapsed; + m_pendingEeTimerInterrupts |= m_runtime.memory().advanceEeTimers(elapsed); + if (m_pendingEeTimerInterrupts != 0u) + { + m_checkpointPending.store(true, std::memory_order_release); + } } bool EeScheduler::isExecutingGuest() const noexcept @@ -383,6 +402,21 @@ bool EeScheduler::isExecutingGuest() const noexcept return m_guestExecuting.load(std::memory_order_acquire); } +void EeScheduler::setupCurrentThread(uint32_t stack, uint32_t stackSize, uint32_t gp) +{ + assertExecutor(); + GuestThread *target = currentThread(); + if (!target) + { + return; + } + + target->stack = stack; + target->stackSize = stackSize; + target->gp = gp; + publishSnapshot(); +} + int EeScheduler::createThread(const EeThreadCreateParams ¶ms) { assertExecutor(); @@ -1702,6 +1736,15 @@ void EeScheduler::processPendingEvents() { assertExecutor(); processDueDeadlines(); + const uint32_t timerInterrupts = m_pendingEeTimerInterrupts; + m_pendingEeTimerInterrupts = 0u; + for (uint32_t timer = 0u; timer < 4u; ++timer) + { + if ((timerInterrupts & (1u << timer)) != 0u) + { + dispatchIrq(false, 9u + timer); + } + } std::deque pending; { std::lock_guard lock(m_eventMutex); @@ -1950,30 +1993,55 @@ void EeScheduler::waitForEvent() { return; } - if (m_deadlines.empty()) + const uint64_t timerCycles = m_runtime.memory().cyclesUntilNextEeTimerInterrupt(); + const bool hasTimerDeadline = timerCycles != std::numeric_limits::max(); + if (m_deadlines.empty() && !hasTimerDeadline) { m_eventCv.wait(lock, [this]() { return !m_events.empty() || m_stopRequested.load(std::memory_order_acquire); }); return; } - const auto next = std::min_element(m_deadlines.begin(), m_deadlines.end(), - [](const ScheduledEvent &left, const ScheduledEvent &right) - { - if (left.deadlineCycle != right.deadlineCycle) + uint64_t deadlineCycle = 0u; + auto hostDeadline = std::chrono::steady_clock::time_point::max(); + if (!m_deadlines.empty()) + { + const auto next = std::min_element(m_deadlines.begin(), m_deadlines.end(), + [](const ScheduledEvent &left, const ScheduledEvent &right) { - return left.deadlineCycle < right.deadlineCycle; - } - return left.sequence < right.sequence; - }); - const uint64_t deadlineCycle = next->deadlineCycle; - const auto hostDeadline = next->hostDeadline; + if (left.deadlineCycle != right.deadlineCycle) + { + return left.deadlineCycle < right.deadlineCycle; + } + return left.sequence < right.sequence; + }); + deadlineCycle = next->deadlineCycle; + hostDeadline = next->hostDeadline; + } + if (hasTimerDeadline) + { + const auto timerHostDeadline = std::chrono::steady_clock::now() + eeCyclesToHostDuration(timerCycles); + if (timerHostDeadline < hostDeadline) + { + deadlineCycle = m_eeCycle + timerCycles; + hostDeadline = timerHostDeadline; + } + } + const bool signaled = m_eventCv.wait_until(lock, hostDeadline, [this]() { return !m_events.empty() || m_stopRequested.load(std::memory_order_acquire); }); if (!signaled) { - m_eeCycle = std::max(m_eeCycle, deadlineCycle); + const uint64_t elapsed = deadlineCycle > m_eeCycle ? deadlineCycle - m_eeCycle : 0u; + lock.unlock(); + uint64_t remaining = elapsed; + while (remaining > 0u) + { + const uint32_t step = static_cast(std::min(remaining, std::numeric_limits::max())); + accountCycles(step); + remaining -= step; + } m_checkpointPending.store(true, std::memory_order_release); } } diff --git a/ps2xRuntime/src/lib/Kernel/Stubs/Helpers/Support.h b/ps2xRuntime/src/lib/Kernel/Stubs/Helpers/Support.h index 52fa84a45..a7fae20ca 100644 --- a/ps2xRuntime/src/lib/Kernel/Stubs/Helpers/Support.h +++ b/ps2xRuntime/src/lib/Kernel/Stubs/Helpers/Support.h @@ -29,8 +29,8 @@ namespace uint32_t g_cdStreamingEndLbn = 0xFFFFFFFFu; bool g_cdInitialized = false; - constexpr uint32_t kIopHeapBase = 0x01A00000; - constexpr uint32_t kIopHeapLimit = 0x01F00000; + constexpr uint32_t kIopHeapBase = 0x04000000; + constexpr uint32_t kIopHeapLimit = 0x04500000; constexpr uint32_t kIopHeapAlign = 64; uint32_t g_iopHeapNext = kIopHeapBase; diff --git a/ps2xRuntime/src/lib/Kernel/Stubs/SIF.cpp b/ps2xRuntime/src/lib/Kernel/Stubs/SIF.cpp index b48633ba7..6a07fe278 100644 --- a/ps2xRuntime/src/lib/Kernel/Stubs/SIF.cpp +++ b/ps2xRuntime/src/lib/Kernel/Stubs/SIF.cpp @@ -4,7 +4,10 @@ #include "../../ps2_iop_transport.h" #include "runtime/ps2_address.h" +#include +#include #include +#include namespace ps2_stubs { @@ -59,6 +62,7 @@ namespace ps2_stubs std::unordered_map g_sifSregs; std::unordered_map g_sifCmdHandlers; std::map g_sifHeapAllocations; + std::array g_sifHeapStorage{}; uint32_t g_sifCmdBuffer = 0u; uint32_t g_sifSysCmdBuffer = 0u; bool g_sifCmdInitialized = false; @@ -158,6 +162,9 @@ namespace ps2_stubs } g_sifHeapAllocations[candidate] = alignedSize; + std::fill_n(g_sifHeapStorage.data() + (candidate - kIopHeapBase), + alignedSize, + uint8_t{0}); g_iopHeapNext = candidate + alignedSize; return candidate; } @@ -183,9 +190,29 @@ namespace ps2_stubs { std::lock_guard lock(g_sifHeapMutex); g_sifHeapAllocations.clear(); + g_sifHeapStorage.fill(0u); g_iopHeapNext = kIopHeapBase; } + bool isAllocatedSifHeapRangeLocked(uint32_t address, size_t size) + { + if (address < kIopHeapBase || address >= kIopHeapLimit || size > static_cast(kIopHeapLimit - address)) + { + return false; + } + + auto it = g_sifHeapAllocations.upper_bound(address); + if (it == g_sifHeapAllocations.begin()) + { + return false; + } + --it; + + const uint64_t allocationEnd = static_cast(it->first) + it->second; + const uint64_t rangeEnd = static_cast(address) + size; + return address >= it->first && rangeEnd <= allocationEnd; + } + bool isCopyableGuestAddress(uint32_t addr) { if (Ps2AddressInRange(addr, PS2_SCRATCHPAD_BASE, PS2_SCRATCHPAD_SIZE)) @@ -211,39 +238,40 @@ namespace ps2_stubs return false; } - bool canCopyGuestByteRange(const uint8_t *rdram, uint32_t dstAddr, uint32_t srcAddr, uint32_t sizeBytes) + bool canCopyAddressRange(const uint8_t *rdram, uint32_t address, uint32_t sizeBytes) { - if (!rdram) + if (isSifIopHeapRange(address, sizeBytes)) + { + return true; + } + if (isSifIopHeapAddress(address) || !rdram) { return false; } - if (sizeBytes == 0u) { return true; } - + if (sizeBytes - 1u > std::numeric_limits::max() - address) + { + return false; + } for (uint32_t i = 0u; i < sizeBytes; ++i) { - const uint32_t srcByteAddr = srcAddr + i; - const uint32_t dstByteAddr = dstAddr + i; - - if (!isCopyableGuestAddress(srcByteAddr) || !isCopyableGuestAddress(dstByteAddr)) - { - return false; - } - - const uint8_t *src = getConstMemPtr(rdram, srcByteAddr); - const uint8_t *dst = getConstMemPtr(rdram, dstByteAddr); - if (!src || !dst) + const uint32_t byteAddress = address + i; + if (!isCopyableGuestAddress(byteAddress) ||getConstMemPtr(rdram, byteAddress) == nullptr) { return false; } } - return true; } + bool canCopyGuestByteRange(const uint8_t *rdram, uint32_t dstAddr, uint32_t srcAddr, uint32_t sizeBytes) + { + return canCopyAddressRange(rdram, srcAddr, sizeBytes) && canCopyAddressRange(rdram, dstAddr, sizeBytes); + } + bool copyGuestByteRange(uint8_t *rdram, uint32_t dstAddr, uint32_t srcAddr, uint32_t sizeBytes) { if (!canCopyGuestByteRange(rdram, dstAddr, srcAddr, sizeBytes)) @@ -256,6 +284,49 @@ namespace ps2_stubs return true; } + const bool sourceIsIop = isSifIopHeapRange(srcAddr, sizeBytes); + const bool destinationIsIop = isSifIopHeapRange(dstAddr, sizeBytes); + if (sourceIsIop || destinationIsIop) + { + std::vector payload(sizeBytes); + if (sourceIsIop) + { + if (!readSifIopHeap(srcAddr, payload.data(), payload.size())) + { + return false; + } + } + else + { + for (uint32_t i = 0u; i < sizeBytes; ++i) + { + const uint8_t *src = getConstMemPtr(rdram, srcAddr + i); + if (!src) + { + return false; + } + payload[i] = *src; + } + } + + if (destinationIsIop) + { + return writeSifIopHeap(dstAddr, payload.data(), payload.size()); + } + + ps2TraceGuestRangeWrite(rdram, dstAddr, sizeBytes, "sifCopyGuestByteRange", nullptr); + for (uint32_t i = 0u; i < sizeBytes; ++i) + { + uint8_t *dst = getMemPtr(rdram, dstAddr + i); + if (!dst) + { + return false; + } + *dst = payload[i]; + } + return true; + } + ps2TraceGuestRangeWrite(rdram, dstAddr, sizeBytes, "sifCopyGuestByteRange", nullptr); const uint64_t srcBegin = srcAddr; @@ -293,6 +364,71 @@ namespace ps2_stubs } } + bool isSifIopHeapAddress(uint32_t address) + { + return address >= kIopHeapBase && address < kIopHeapLimit; + } + + bool isSifIopHeapRange(uint32_t address, size_t size) + { + std::lock_guard lock(g_sifHeapMutex); + return isAllocatedSifHeapRangeLocked(address, size); + } + + bool readSifIopHeap(uint32_t address, void *destination, size_t size) + { + if (!destination && size != 0u) + { + return false; + } + std::lock_guard lock(g_sifHeapMutex); + if (!isAllocatedSifHeapRangeLocked(address, size)) + { + return false; + } + if (size != 0u) + { + std::memcpy(destination, + g_sifHeapStorage.data() + (address - kIopHeapBase), + size); + } + return true; + } + + bool writeSifIopHeap(uint32_t address, const void *source, size_t size) + { + if (!source && size != 0u) + { + return false; + } + std::lock_guard lock(g_sifHeapMutex); + if (!isAllocatedSifHeapRangeLocked(address, size)) + { + return false; + } + if (size != 0u) + { + std::memcpy(g_sifHeapStorage.data() + (address - kIopHeapBase), + source, + size); + } + return true; + } + + bool zeroSifIopHeap(uint32_t address, size_t size) + { + std::lock_guard lock(g_sifHeapMutex); + if (!isAllocatedSifHeapRangeLocked(address, size)) + { + return false; + } + if (size != 0u) + { + std::memset(g_sifHeapStorage.data() + (address - kIopHeapBase), 0, size); + } + return true; + } + void resetSifState() { std::lock_guard lock(g_sifCmdStateMutex); diff --git a/ps2xRuntime/src/lib/Kernel/Stubs/SIF.h b/ps2xRuntime/src/lib/Kernel/Stubs/SIF.h index 7d7f35c31..777e1cb39 100644 --- a/ps2xRuntime/src/lib/Kernel/Stubs/SIF.h +++ b/ps2xRuntime/src/lib/Kernel/Stubs/SIF.h @@ -2,8 +2,16 @@ #include "ps2_stubs.h" +#include + namespace ps2_stubs { + bool isSifIopHeapAddress(uint32_t address); + bool isSifIopHeapRange(uint32_t address, size_t size); + bool readSifIopHeap(uint32_t address, void *destination, size_t size); + bool writeSifIopHeap(uint32_t address, const void *source, size_t size); + bool zeroSifIopHeap(uint32_t address, size_t size); + void sceSifCmdIntrHdlr(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime); void sceSifLoadModule(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime); void sceSifSendCmd(uint8_t *rdram, R5900Context *ctx, PS2Runtime *runtime); diff --git a/ps2xRuntime/src/lib/Kernel/Syscalls/System.cpp b/ps2xRuntime/src/lib/Kernel/Syscalls/System.cpp index e6819b6fe..3530e65bb 100644 --- a/ps2xRuntime/src/lib/Kernel/Syscalls/System.cpp +++ b/ps2xRuntime/src/lib/Kernel/Syscalls/System.cpp @@ -495,6 +495,8 @@ namespace ps2_syscalls const uint32_t stack = getRegU32(ctx, 5); const int32_t stackSizeSigned = static_cast(getRegU32(ctx, 6)); const uint32_t currentSp = getRegU32(ctx, 29); + EeScheduler &scheduler = runtime->eeScheduler(); + scheduler.bindMainContextForSyscall(*ctx, rdram); if (gp != 0u) { @@ -502,6 +504,10 @@ namespace ps2_syscalls } uint32_t sp = currentSp; + uint32_t initialStack = 0u; + const uint32_t stackSize = stackSizeSigned > 0 + ? static_cast(stackSizeSigned) + : 0u; if (stack == 0xFFFFFFFFu) { if (stackSizeSigned > 0) @@ -534,6 +540,16 @@ namespace ps2_syscalls } sp &= ~0xFu; + if (stack == 0xFFFFFFFFu) + { + initialStack = sp; + } + else if (stack != 0u) + { + initialStack = stack; + } + + scheduler.setupCurrentThread(initialStack, stackSize, getRegU32(ctx, 28)); setReturnU32(ctx, sp); } diff --git a/ps2xRuntime/src/lib/ps2_iop_host.cpp b/ps2xRuntime/src/lib/ps2_iop_host.cpp index 1a165a686..8709ed1d7 100644 --- a/ps2xRuntime/src/lib/ps2_iop_host.cpp +++ b/ps2xRuntime/src/lib/ps2_iop_host.cpp @@ -2,6 +2,7 @@ #include "ps2_runtime.h" #include "ps2_stubs.h" +#include "Kernel/Stubs/SIF.h" #include "runtime/ps2_memory.h" #include "Kernel/Stubs/MemoryCard.h" #include "Kernel/Syscalls/Common.h" @@ -134,6 +135,11 @@ bool PS2IopHostAdapter::readGuest(uint32_t address, void *destination, size_t si { return false; } + if (ps2_stubs::isSifIopHeapAddress(address)) + { + return ps2_stubs::readSifIopHeap(address, destination, size); + } + uint8_t *source = nullptr; if (!guestRange(address, size, source)) { @@ -152,6 +158,11 @@ bool PS2IopHostAdapter::writeGuest(uint32_t address, const void *source, size_t { return false; } + if (ps2_stubs::isSifIopHeapAddress(address)) + { + return ps2_stubs::writeSifIopHeap(address, source, size); + } + uint8_t *destination = nullptr; if (!guestRange(address, size, destination)) { @@ -168,6 +179,11 @@ bool PS2IopHostAdapter::writeGuest(uint32_t address, const void *source, size_t bool PS2IopHostAdapter::zeroGuest(uint32_t address, size_t size) { + if (ps2_stubs::isSifIopHeapAddress(address)) + { + return ps2_stubs::zeroSifIopHeap(address, size); + } + uint8_t *destination = nullptr; if (!guestRange(address, size, destination)) { @@ -184,6 +200,12 @@ bool PS2IopHostAdapter::zeroGuest(uint32_t address, size_t size) bool PS2IopHostAdapter::normalizeGuestAddress(uint32_t address, uint32_t &normalized) const { + if (ps2_stubs::isSifIopHeapAddress(address)) + { + normalized = address; + return ps2_stubs::isSifIopHeapRange(address, 0u); + } + bool scratchpad = false; if (!ps2ResolveGuestPointer(address, normalized, scratchpad) || scratchpad) { diff --git a/ps2xRuntime/src/lib/ps2_memory.cpp b/ps2xRuntime/src/lib/ps2_memory.cpp index aabacfc85..01bbcc25f 100644 --- a/ps2xRuntime/src/lib/ps2_memory.cpp +++ b/ps2xRuntime/src/lib/ps2_memory.cpp @@ -3,8 +3,8 @@ #include "runtime/ps2_gs_gpu.h" #include "ps2_log.h" #include -#include #include +#include #include #include #include @@ -141,26 +141,55 @@ namespace } while (!csr.compare_exchange_weak(expected, desired)); } - constexpr uint32_t kEeTimer0Count = 0x10000000u; - constexpr uint32_t kEeTimer0Mode = 0x10000010u; - constexpr uint32_t kEeTimer0Compare = 0x10000020u; - constexpr uint32_t kEeTimer0Hold = 0x10000030u; + constexpr std::array kEeTimerBases = { + 0x10000000u, + 0x10000800u, + 0x10001000u, + 0x10001800u, + }; + constexpr uint32_t kEeTimerCountOffset = 0x00u; + constexpr uint32_t kEeTimerModeOffset = 0x10u; + constexpr uint32_t kEeTimerCompareOffset = 0x20u; + constexpr uint32_t kEeTimerHoldOffset = 0x30u; + constexpr uint32_t kEeTimerModeClksMask = 0x3u; + constexpr uint32_t kEeTimerModeConfigMask = 0x3FFu; + constexpr uint32_t kEeTimerModeStatusMask = 0xC00u; + constexpr uint32_t kEeTimerModeZret = 1u << 6; constexpr uint32_t kEeTimerModeCue = 1u << 7; - constexpr uint64_t kEeTimer0TicksPerSecond = 15720ull; - constexpr uint64_t kNanosecondsPerSecond = 1000000000ull; + constexpr uint32_t kEeTimerModeCmpe = 1u << 8; + constexpr uint32_t kEeTimerModeOvfe = 1u << 9; + constexpr uint32_t kEeTimerModeEquf = 1u << 10; + constexpr uint32_t kEeTimerModeOvff = 1u << 11; + constexpr uint64_t kEeClockHz = 294912000ull; + constexpr std::array kEeTimerClockHz = { + 147456000ull, + 9216000ull, + 576000ull, + 15734ull, + }; - inline bool isEeTimer0Register(uint32_t address) + inline bool decodeEeTimerRegister(uint32_t address, size_t &timerIndex, uint32_t &offset) { - return address == kEeTimer0Count || - address == kEeTimer0Mode || - address == kEeTimer0Compare || - address == kEeTimer0Hold; + for (size_t index = 0; index < kEeTimerBases.size(); ++index) + { + const uint32_t candidateOffset = address - kEeTimerBases[index]; + if (candidateOffset == kEeTimerCountOffset || + candidateOffset == kEeTimerModeOffset || + candidateOffset == kEeTimerCompareOffset || + (index < 2u && candidateOffset == kEeTimerHoldOffset)) + { + timerIndex = index; + offset = candidateOffset; + return true; + } + } + return false; } - inline uint64_t steadyClockNs() + constexpr uint64_t ticksUntilMatch(uint32_t count, uint32_t target) { - using namespace std::chrono; - return static_cast(duration_cast(steady_clock::now().time_since_epoch()).count()); + const uint32_t distance = (target - count) & 0xFFFFu; + return distance == 0u ? 0x10000ull : static_cast(distance); } struct DmaTagView @@ -302,8 +331,7 @@ bool PS2Memory::initialize(size_t ramSize) m_path3MaskedFifo.clear(); m_vif1PendingPath2ImageQwc = 0u; m_vif1PendingPath2DirectHl = false; - m_timer0LastHostNs = 0; - m_timer0FractionNs = 0; + resetEeTimers(); try { @@ -371,37 +399,121 @@ bool PS2Memory::initialize(size_t ramSize) } } -void PS2Memory::updateEeTimer0Counter() +void PS2Memory::resetEeTimers() noexcept { - const uint64_t nowNs = steadyClockNs(); - if (m_timer0LastHostNs == 0u) - { - m_timer0LastHostNs = nowNs; - return; - } + m_eeTimers = {}; +} - const uint32_t mode = m_ioRegisters.count(kEeTimer0Mode) ? m_ioRegisters[kEeTimer0Mode] : 0u; - if ((mode & kEeTimerModeCue) == 0u) +uint32_t PS2Memory::advanceEeTimers(uint64_t eeCycles) noexcept +{ + if (eeCycles == 0u) { - m_timer0LastHostNs = nowNs; - m_timer0FractionNs = 0u; - return; + return 0u; } - const uint64_t elapsedNs = nowNs - m_timer0LastHostNs; - m_timer0LastHostNs = nowNs; - if (elapsedNs == 0u) + uint32_t interruptMask = 0u; + for (size_t index = 0; index < m_eeTimers.size(); ++index) { - return; + EeTimer &timer = m_eeTimers[index]; + if ((timer.mode & kEeTimerModeCue) == 0u) + { + continue; + } + + const uint64_t clockHz = kEeTimerClockHz[timer.mode & kEeTimerModeClksMask]; + const uint64_t wholeSeconds = eeCycles / kEeClockHz; + const uint64_t remainingCycles = eeCycles % kEeClockHz; + const uint64_t scaled = remainingCycles * clockHz + timer.clockRemainder; + const uint64_t ticks = wholeSeconds * clockHz + scaled / kEeClockHz; + timer.clockRemainder = scaled % kEeClockHz; + if (ticks == 0u) + { + continue; + } + + const uint32_t oldCount = timer.count & 0xFFFFu; + const uint32_t compare = timer.compare & 0xFFFFu; + const uint64_t compareDistance = ticksUntilMatch(oldCount, compare); + const uint64_t overflowDistance = 0x10000ull - oldCount; + const bool zeroReturn = (timer.mode & kEeTimerModeZret) != 0u; + const bool compareReached = ticks >= compareDistance; + bool overflowReached = false; + + if (zeroReturn) + { + overflowReached = ticks >= overflowDistance && overflowDistance <= compareDistance; + if (compareReached) + { + const uint64_t remaining = ticks - compareDistance; + timer.count = compare == 0u + ? static_cast(remaining & 0xFFFFu) + : static_cast(remaining % compare); + } + else + { + timer.count = static_cast((oldCount + ticks) & 0xFFFFu); + } + } + else + { + overflowReached = ticks >= overflowDistance; + timer.count = static_cast((oldCount + ticks) & 0xFFFFu); + } + + if (compareReached && (timer.mode & kEeTimerModeCmpe) != 0u && (timer.mode & kEeTimerModeEquf) == 0u) + { + timer.mode |= kEeTimerModeEquf; + interruptMask |= 1u << index; + } + if (overflowReached && (timer.mode & kEeTimerModeOvfe) != 0u && (timer.mode & kEeTimerModeOvff) == 0u) + { + timer.mode |= kEeTimerModeOvff; + interruptMask |= 1u << index; + } } + return interruptMask; +} - const uint64_t scaled = elapsedNs * kEeTimer0TicksPerSecond + m_timer0FractionNs; - const uint64_t ticks = scaled / kNanosecondsPerSecond; - m_timer0FractionNs = scaled % kNanosecondsPerSecond; - if (ticks != 0u) +uint64_t PS2Memory::cyclesUntilNextEeTimerInterrupt() const noexcept +{ + uint64_t nearest = std::numeric_limits::max(); + for (const EeTimer &timer : m_eeTimers) { - m_ioRegisters[kEeTimer0Count] = m_ioRegisters[kEeTimer0Count] + static_cast(ticks); + if ((timer.mode & kEeTimerModeCue) == 0u) + { + continue; + } + + const uint32_t count = timer.count & 0xFFFFu; + const uint32_t compare = timer.compare & 0xFFFFu; + const uint64_t compareDistance = ticksUntilMatch(count, compare); + const uint64_t overflowDistance = 0x10000ull - count; + uint64_t eventTicks = std::numeric_limits::max(); + + if ((timer.mode & kEeTimerModeCmpe) != 0u && + (timer.mode & kEeTimerModeEquf) == 0u) + { + eventTicks = compareDistance; + } + const bool overflowCanOccur = (timer.mode & kEeTimerModeZret) == 0u || + overflowDistance <= compareDistance; + if (overflowCanOccur && + (timer.mode & kEeTimerModeOvfe) != 0u && + (timer.mode & kEeTimerModeOvff) == 0u) + { + eventTicks = std::min(eventTicks, overflowDistance); + } + if (eventTicks == std::numeric_limits::max()) + { + continue; + } + + const uint64_t clockHz = kEeTimerClockHz[timer.mode & kEeTimerModeClksMask]; + const uint64_t numerator = eventTicks * kEeClockHz - timer.clockRemainder; + const uint64_t cycles = (numerator + clockHz - 1u) / clockHz; + nearest = std::min(nearest, std::max(1u, cycles)); } + return nearest; } bool PS2Memory::isScratchpad(uint32_t address) const @@ -991,22 +1103,36 @@ void PS2Memory::write128(uint32_t address, __m128i value) bool PS2Memory::writeIORegister(uint32_t address, uint32_t value) { - if (isEeTimer0Register(address)) + size_t timerIndex = 0u; + uint32_t timerOffset = 0u; + if (decodeEeTimerRegister(address, timerIndex, timerOffset)) { - if (address == kEeTimer0Count) + EeTimer &timer = m_eeTimers[timerIndex]; + switch (timerOffset) { - m_ioRegisters[address] = value; - m_timer0LastHostNs = steadyClockNs(); - m_timer0FractionNs = 0u; - return true; - } - - updateEeTimer0Counter(); - m_ioRegisters[address] = value; - m_timer0LastHostNs = steadyClockNs(); - if (address == kEeTimer0Mode) + case kEeTimerCountOffset: + timer.count = value & 0xFFFFu; + timer.clockRemainder = 0u; + break; + case kEeTimerModeOffset: { - m_timer0FractionNs = 0u; + const uint32_t previousMode = timer.mode; + const uint32_t status = (previousMode & kEeTimerModeStatusMask) &~(value & kEeTimerModeStatusMask); + timer.mode = (value & kEeTimerModeConfigMask) | status; + if (((previousMode ^ timer.mode) & (kEeTimerModeClksMask | kEeTimerModeCue)) != 0u) + { + timer.clockRemainder = 0u; + } + break; + } + case kEeTimerCompareOffset: + timer.compare = value & 0xFFFFu; + break; + case kEeTimerHoldOffset: + timer.hold = value & 0xFFFFu; + break; + default: + return false; } return true; } @@ -2037,6 +2163,26 @@ int PS2Memory::pollDmaRegisters() uint32_t PS2Memory::readIORegister(uint32_t address) { + size_t timerIndex = 0u; + uint32_t timerOffset = 0u; + if (decodeEeTimerRegister(address, timerIndex, timerOffset)) + { + const EeTimer &timer = m_eeTimers[timerIndex]; + switch (timerOffset) + { + case kEeTimerCountOffset: + return timer.count & 0xFFFFu; + case kEeTimerModeOffset: + return timer.mode & (kEeTimerModeConfigMask | kEeTimerModeStatusMask); + case kEeTimerCompareOffset: + return timer.compare & 0xFFFFu; + case kEeTimerHoldOffset: + return timer.hold & 0xFFFFu; + default: + return 0u; + } + } + if (isGsPrivReg(address)) { // NB: unreachable from read8/16/32/64 today, same reasoning as the write @@ -2077,19 +2223,6 @@ uint32_t PS2Memory::readIORegister(uint32_t address) } if (address >= 0x10000000 && address < 0x10010000) { - if (address >= 0x10000000 && address < 0x10000100) - { - if (isEeTimer0Register(address)) - { - if (address == kEeTimer0Count) - { - updateEeTimer0Counter(); - } - auto timerIt = m_ioRegisters.find(address); - return timerIt != m_ioRegisters.end() ? timerIt->second : 0u; - } - } - if (address >= 0x10008000 && address < 0x1000F000) { if ((address & 0xFF) == 0x00) diff --git a/ps2xRuntime/src/lib/ps2_runtime.cpp b/ps2xRuntime/src/lib/ps2_runtime.cpp index 38bc945fc..a6ed05b27 100644 --- a/ps2xRuntime/src/lib/ps2_runtime.cpp +++ b/ps2xRuntime/src/lib/ps2_runtime.cpp @@ -1320,14 +1320,13 @@ bool PS2Runtime::dispatchGuestBranch(uint8_t *rdram, return false; } - if (kind == GuestBranchKind::Return) + if (!isCall) { if (!hasFunction(targetPc)) { reportMissingFunction(rdram, ctx, targetPc, sourcePc, kind, debugName); } - // Prevent nested dispatch. ctx->pc = targetPc; return false; } @@ -1362,11 +1361,6 @@ bool PS2Runtime::dispatchGuestBranch(uint8_t *rdram, return false; } - if (!isCall) - { - return false; - } - if (ctx->pc == entryPc) { ctx->pc = fallthroughPc; diff --git a/ps2xTest/src/code_generator_tests.cpp b/ps2xTest/src/code_generator_tests.cpp index 1dee8db84..2dd9c531f 100644 --- a/ps2xTest/src/code_generator_tests.cpp +++ b/ps2xTest/src/code_generator_tests.cpp @@ -1042,7 +1042,7 @@ void register_code_generator_tests() "QFSRV should map to PS2_QFSRV with rs/rt ordering"); }); - tc.Run("PCPYLD and PEXEW use runtime helper macros", [](TestCase &t) { + tc.Run("PCPYLD uses runtime helper macro", [](TestCase &t) { CodeGenerator gen({}, {}); Instruction pcpyld{}; @@ -1057,18 +1057,45 @@ void register_code_generator_tests() std::string pcpyldOut = gen.translateInstruction(pcpyld); t.IsTrue(pcpyldOut.find("PS2_PCPYLD(GPR_VEC(ctx, 7), GPR_VEC(ctx, 8))") != std::string::npos, "PCPYLD should use PS2_PCPYLD helper"); + }); + + tc.Run("Unary MMI permutations read their source from rt", [](TestCase &t) { + CodeGenerator gen({}, {}); + + struct UnaryMmiCase + { + const char *name; + uint8_t function; + uint8_t subfunction; + }; - Instruction pexew{}; - pexew.isMMI = true; - pexew.opcode = OPCODE_MMI; - pexew.function = MMI_MMI2; - pexew.sa = MMI2_PEXEW; - pexew.rd = 9; - pexew.rs = 10; - - std::string pexewOut = gen.translateInstruction(pexew); - t.IsTrue(pexewOut.find("PS2_PEXEW(GPR_VEC(ctx, 10))") != std::string::npos, - "PEXEW should use PS2_PEXEW helper"); + const std::vector cases = { + {"PEXEH", MMI_MMI2, MMI2_PEXEH}, + {"PREVH", MMI_MMI2, MMI2_PREVH}, + {"PEXEW", MMI_MMI2, MMI2_PEXEW}, + {"PROT3W", MMI_MMI2, MMI2_PROT3W}, + {"PEXCH", MMI_MMI3, MMI3_PEXCH}, + {"PCPYH", MMI_MMI3, MMI3_PCPYH}, + {"PEXCW", MMI_MMI3, MMI3_PEXCW}, + }; + + for (const UnaryMmiCase &item : cases) + { + Instruction inst{}; + inst.isMMI = true; + inst.opcode = OPCODE_MMI; + inst.function = item.function; + inst.sa = item.subfunction; + inst.rd = 3; + inst.rs = 4; + inst.rt = 5; + + const std::string out = gen.translateInstruction(inst); + t.IsTrue(out.find("GPR_VEC(ctx, 5)") != std::string::npos, + std::string(item.name) + " should read its source from rt"); + t.IsTrue(out.find("GPR_VEC(ctx, 4)") == std::string::npos, + std::string(item.name) + " should not read its source from rs"); + } }); tc.Run("VU0 macro mappings cover all S1/S2 enums", [](TestCase &t) { diff --git a/ps2xTest/src/ps2_memory_tests.cpp b/ps2xTest/src/ps2_memory_tests.cpp index 3bcb7a5fd..aa8013c4b 100644 --- a/ps2xTest/src/ps2_memory_tests.cpp +++ b/ps2xTest/src/ps2_memory_tests.cpp @@ -8,10 +8,8 @@ #include "Stubs/GS.h" #include -#include #include #include -#include #include namespace @@ -194,7 +192,7 @@ void register_ps2_memory_tests() t.Equals(mem.translateAddress(PS2_SCRATCHPAD_ALIAS_BASE + 0x123u), 0x123u, "0xF000 scratchpad alias should translate to local offset"); }); - tc.Run("EE timer0 count advances while enabled and can be reset", [](TestCase &t) + tc.Run("EE timer0 count advances from scheduler cycles and can be reset", [](TestCase &t) { PS2Memory mem; t.IsTrue(mem.initialize(), "PS2Memory initialize should succeed"); @@ -204,17 +202,111 @@ void register_ps2_memory_tests() constexpr uint32_t kTimer0Compare = 0x10000020u; t.IsTrue(mem.writeIORegister(kTimer0Count, 0u), "timer count reset write should succeed"); - t.IsTrue(mem.writeIORegister(kTimer0Compare, 1u), "timer compare write should succeed"); - t.IsTrue(mem.writeIORegister(kTimer0Mode, 0x283u), "timer mode write should be retained"); - t.Equals(mem.readIORegister(kTimer0Mode), 0x283u, "timer mode should be readable"); + t.IsTrue(mem.writeIORegister(kTimer0Compare, 0xFFFFu), "timer compare write should succeed"); + t.IsTrue(mem.writeIORegister(kTimer0Mode, 0x82u), "timer mode write should be retained"); + t.Equals(mem.readIORegister(kTimer0Mode), 0x82u, "timer mode should be readable"); - std::this_thread::sleep_for(std::chrono::milliseconds(3)); + mem.advanceEeTimers(8u * 512u); const uint32_t firstCount = mem.readIORegister(kTimer0Count); - t.IsTrue(firstCount > 0u, "enabled timer count should advance from host time"); + t.Equals(firstCount, 8u, "BUSCLK/256 should increment once per 512 EE cycles"); t.IsTrue(mem.writeIORegister(kTimer0Count, 0u), "timer count second reset should succeed"); + mem.advanceEeTimers(512u); const uint32_t resetCount = mem.readIORegister(kTimer0Count); - t.IsTrue(resetCount <= firstCount, "timer reset should restart the count window"); + t.Equals(resetCount, 1u, "timer reset should restart the deterministic count window"); + }); + + tc.Run("EE timers 0 through 3 expose independent COUNT MODE and COMP registers", [](TestCase &t) + { + PS2Memory mem; + t.IsTrue(mem.initialize(), "PS2Memory initialize should succeed"); + + constexpr uint32_t kTimerBases[] = { + 0x10000000u, + 0x10000800u, + 0x10001000u, + 0x10001800u, + }; + constexpr uint32_t kBusClockDiv256Cue = 0x82u; + for (uint32_t index = 0u; index < 4u; ++index) + { + const uint32_t base = kTimerBases[index]; + t.IsTrue(mem.writeIORegister(base, 0x100u + index), "timer COUNT write should succeed"); + t.IsTrue(mem.writeIORegister(base + 0x10u, kBusClockDiv256Cue), "timer MODE write should succeed"); + t.IsTrue(mem.writeIORegister(base + 0x20u, 0x200u + index), "timer COMP write should succeed"); + } + + mem.advanceEeTimers(512u); + for (uint32_t index = 0u; index < 4u; ++index) + { + const uint32_t base = kTimerBases[index]; + t.Equals(mem.readIORegister(base), 0x101u + index, "each timer should advance its own COUNT"); + t.Equals(mem.readIORegister(base + 0x10u), kBusClockDiv256Cue, "each timer should retain MODE"); + t.Equals(mem.readIORegister(base + 0x20u), 0x200u + index, "each timer should retain COMP"); + } + + t.IsTrue(mem.writeIORegister(kTimerBases[0] + 0x30u, 0x12345u), "Timer0 HOLD write should succeed"); + t.IsTrue(mem.writeIORegister(kTimerBases[1] + 0x30u, 0x23456u), "Timer1 HOLD write should succeed"); + t.Equals(mem.readIORegister(kTimerBases[0] + 0x30u), 0x2345u, "Timer0 HOLD should be 16-bit"); + t.Equals(mem.readIORegister(kTimerBases[1] + 0x30u), 0x3456u, "Timer1 HOLD should be 16-bit"); + }); + + tc.Run("EE Timer2 compare and overflow flags raise INTC_TIM2 and clear on write-one", [](TestCase &t) + { + PS2Memory mem; + t.IsTrue(mem.initialize(), "PS2Memory initialize should succeed"); + + constexpr uint32_t kTimer2Count = 0x10001000u; + constexpr uint32_t kTimer2Mode = 0x10001010u; + constexpr uint32_t kTimer2Compare = 0x10001020u; + constexpr uint32_t kCue = 1u << 7u; + constexpr uint32_t kCmpe = 1u << 8u; + constexpr uint32_t kOvfe = 1u << 9u; + constexpr uint32_t kEquf = 1u << 10u; + constexpr uint32_t kOvff = 1u << 11u; + constexpr uint32_t kBusClockDiv256 = 2u; + + mem.writeIORegister(kTimer2Count, 0u); + mem.writeIORegister(kTimer2Compare, 8u); + mem.writeIORegister(kTimer2Mode, kBusClockDiv256 | kCue | kCmpe | kEquf | kOvff); + + t.Equals(mem.advanceEeTimers(7u * 512u), 0u, "compare should not fire before COUNT reaches COMP"); + t.Equals(mem.readIORegister(kTimer2Count), 7u, "Timer2 should expose its live 16-bit count"); + t.Equals(mem.advanceEeTimers(512u), 1u << 2u, "Timer2 compare should raise the TIM2 interrupt bit"); + t.IsTrue((mem.readIORegister(kTimer2Mode) & kEquf) != 0u, "Timer2 compare should latch EQUF"); + + mem.writeIORegister(kTimer2Mode, mem.readIORegister(kTimer2Mode) | kEquf); + t.IsTrue((mem.readIORegister(kTimer2Mode) & kEquf) == 0u, "writing one should clear EQUF"); + + mem.writeIORegister(kTimer2Count, 0xFFFFu); + mem.writeIORegister(kTimer2Mode, kBusClockDiv256 | kCue | kOvfe | kOvff); + t.Equals(mem.advanceEeTimers(512u), 1u << 2u, "Timer2 overflow should raise the TIM2 interrupt bit"); + t.Equals(mem.readIORegister(kTimer2Count), 0u, "Timer2 count should wrap at 16 bits"); + t.IsTrue((mem.readIORegister(kTimer2Mode) & kOvff) != 0u, "Timer2 overflow should latch OVFF"); + + mem.writeIORegister(kTimer2Mode, mem.readIORegister(kTimer2Mode) | kOvff); + t.IsTrue((mem.readIORegister(kTimer2Mode) & kOvff) == 0u, "writing one should clear OVFF"); + }); + + tc.Run("EE timer zero-return clears COUNT on compare", [](TestCase &t) + { + PS2Memory mem; + t.IsTrue(mem.initialize(), "PS2Memory initialize should succeed"); + + constexpr uint32_t kTimer0Count = 0x10000000u; + constexpr uint32_t kTimer0Mode = 0x10000010u; + constexpr uint32_t kTimer0Compare = 0x10000020u; + constexpr uint32_t kZret = 1u << 6u; + constexpr uint32_t kCue = 1u << 7u; + constexpr uint32_t kCmpe = 1u << 8u; + constexpr uint32_t kEquf = 1u << 10u; + + mem.writeIORegister(kTimer0Count, 0u); + mem.writeIORegister(kTimer0Compare, 3u); + mem.writeIORegister(kTimer0Mode, kZret | kCue | kCmpe | kEquf); + + t.Equals(mem.advanceEeTimers(6u), 1u, "Timer0 compare should raise TIM0 after three BUSCLK ticks"); + t.Equals(mem.readIORegister(kTimer0Count), 0u, "ZRET should clear COUNT when it equals COMP"); }); tc.Run("scratchpad alias accesses the same bytes as base", [](TestCase &t) diff --git a/ps2xTest/src/ps2_runtime_expansion_tests.cpp b/ps2xTest/src/ps2_runtime_expansion_tests.cpp index 118cc5c1a..cbf64342e 100644 --- a/ps2xTest/src/ps2_runtime_expansion_tests.cpp +++ b/ps2xTest/src/ps2_runtime_expansion_tests.cpp @@ -166,6 +166,13 @@ namespace } } + std::atomic gGuestJumpTargetCount{0u}; + + void testGuestJumpTargetHandler(uint8_t *, R5900Context *, PS2Runtime *) + { + gGuestJumpTargetCount.fetch_add(1u, std::memory_order_relaxed); + } + std::atomic gMpegStreamCallbackCount{0u}; std::atomic gMpegStreamCallbackMpeg{0u}; std::atomic gMpegStreamCallbackType{0u}; @@ -399,6 +406,32 @@ void register_ps2_runtime_expansion_tests() "callee should still execute normally"); }); + tc.Run("dispatchGuestBranch jump returns to central dispatcher without nesting", [](TestCase &t) + { + PS2Runtime runtime; + runtime.registerFunction(0x3400u, &testGuestJumpTargetHandler); + gGuestJumpTargetCount.store(0u, std::memory_order_relaxed); + + R5900Context ctx{}; + ctx.pc = 0x2000u; + + const bool continuedInCaller = runtime.dispatchGuestBranch( + nullptr, + &ctx, + 0x3400u, + 0x2000u, + 0u, + PS2Runtime::GuestBranchKind::IndirectJump, + "test-jr"); + + t.IsFalse(continuedInCaller, + "jump should stop the current generated wrapper"); + t.Equals(gGuestJumpTargetCount.load(std::memory_order_relaxed), 0u, + "jump target must not execute on a nested host stack frame"); + t.Equals(ctx.pc, 0x3400u, + "central dispatcher should receive the exact jump target"); + }); + tc.Run("dispatchGuestBranch call returns false when callee transfers elsewhere", [](TestCase &t) { PS2Runtime runtime; diff --git a/ps2xTest/src/ps2_runtime_interrupt_tests.cpp b/ps2xTest/src/ps2_runtime_interrupt_tests.cpp index be4c1ad7e..ccf4b703a 100644 --- a/ps2xTest/src/ps2_runtime_interrupt_tests.cpp +++ b/ps2xTest/src/ps2_runtime_interrupt_tests.cpp @@ -59,6 +59,17 @@ namespace constexpr uint32_t kEventWaitPc = 0x00160400u; constexpr uint32_t kEventResumePc = 0x00160410u; constexpr uint32_t kEventProducerPc = 0x00160420u; + constexpr uint32_t kTimer2WaitPc = 0x00160500u; + constexpr uint32_t kTimer2ResumePc = 0x00160510u; + constexpr uint32_t kTimer2HandlerPc = 0x00160520u; + + constexpr uint32_t kTimer2Count = 0x10001000u; + constexpr uint32_t kTimer2Mode = 0x10001010u; + constexpr uint32_t kTimer2Compare = 0x10001020u; + constexpr uint32_t kTimerModeBusClockDiv256 = 2u; + constexpr uint32_t kTimerModeCue = 1u << 7u; + constexpr uint32_t kTimerModeCmpe = 1u << 8u; + constexpr uint32_t kTimerModeEquf = 1u << 10u; constexpr uint32_t kVSyncFlagAddr = 0x1800u; constexpr uint32_t kVSyncTickAddr = 0x1810u; @@ -71,6 +82,7 @@ namespace uint32_t g_vsyncFlag = 0; uint64_t g_vsyncTick = 0; uint64_t g_vsyncCsr = 0; + std::atomic g_timer2Resumed{false}; void setRegU32(R5900Context &ctx, int reg, uint32_t value) { @@ -247,6 +259,41 @@ namespace ctx->pc = 0u; runtime->requestStop(); } + + void schedulerTimer2Handler(uint8_t *, R5900Context *ctx, PS2Runtime *runtime) + { + g_dispatchTrace.push_back(2); + PS2Memory &memory = runtime->memory(); + memory.writeIORegister(kTimer2Mode, memory.readIORegister(kTimer2Mode) | kTimerModeEquf); + runtime->eeScheduler().signalSemaphore(g_testSemaphoreId, true); + ctx->pc = 0u; + } + + void schedulerTimer2Wait(uint8_t *, R5900Context *ctx, PS2Runtime *runtime) + { + g_dispatchTrace.push_back(1); + EeScheduler &scheduler = runtime->eeScheduler(); + g_testSemaphoreId = scheduler.createSemaphore(0, 1, 0u, 0u); + scheduler.addIrqHandler(false, 11u, kTimer2HandlerPc, true, 0u, 0u, 0u); + + PS2Memory &memory = runtime->memory(); + memory.writeIORegister(kTimer2Count, 0u); + memory.writeIORegister(kTimer2Compare, 8u); + memory.writeIORegister(kTimer2Mode, + kTimerModeBusClockDiv256 | kTimerModeCue | kTimerModeCmpe | kTimerModeEquf); + + ctx->pc = kTimer2ResumePc; + scheduler.waitSemaphore(g_testSemaphoreId); + } + + void schedulerTimer2Resume(uint8_t *, R5900Context *ctx, PS2Runtime *runtime) + { + g_dispatchTrace.push_back(3); + g_resumedResult = getRegS32(*ctx, 2); + g_timer2Resumed.store(true, std::memory_order_release); + ctx->pc = 0u; + runtime->requestStop(); + } } void register_ps2_runtime_interrupt_tests() @@ -478,6 +525,52 @@ void register_ps2_runtime_interrupt_tests() } }); + tc.Run("EE Timer2 compare IRQ wakes a DelayThread-style semaphore wait", [](TestCase &t) + { + TestEnv env; + t.IsTrue(env.runtime.memory().initialize(), "runtime memory initialize should succeed"); + env.runtime.registerFunction(kTimer2WaitPc, schedulerTimer2Wait); + env.runtime.registerFunction(kTimer2ResumePc, schedulerTimer2Resume); + env.runtime.registerFunction(kTimer2HandlerPc, schedulerTimer2Handler); + + g_dispatchTrace.clear(); + g_resumedResult = -1; + g_timer2Resumed.store(false, std::memory_order_release); + R5900Context mainContext{}; + mainContext.pc = kTimer2WaitPc; + std::atomic schedulerThrew{false}; + std::thread gameThread([&]() + { + try + { + env.runtime.eeScheduler().reset(env.rdram.data(), mainContext); + env.runtime.eeScheduler().run(); + } + catch (...) + { + schedulerThrew.store(true, std::memory_order_release); + } + }); + + const bool resumed = waitUntil([]() + { + return g_timer2Resumed.load(std::memory_order_acquire); + }, std::chrono::milliseconds(150)); + if (!resumed) + { + env.runtime.requestStop(); + } + gameThread.join(); + + t.IsTrue(resumed, "Timer2 compare should dispatch INTC_TIM2 and wake the semaphore waiter"); + t.IsFalse(schedulerThrew.load(std::memory_order_acquire), "Timer2 IRQ path should not throw"); + const std::vector expected{1, 2, 3}; + t.IsTrue(g_dispatchTrace == expected, + "Timer2 flow should run wait, interrupt handler, then the resumed thread"); + t.Equals(g_resumedResult, g_testSemaphoreId, + "the Timer2 handler should hand the semaphore directly to the waiter"); + }); + tc.Run("scheduler stop wakes an idle VSync wait without a timeout", [](TestCase &t) { TestEnv env; diff --git a/ps2xTest/src/ps2_runtime_kernel_tests.cpp b/ps2xTest/src/ps2_runtime_kernel_tests.cpp index e552df699..2542d486f 100644 --- a/ps2xTest/src/ps2_runtime_kernel_tests.cpp +++ b/ps2xTest/src/ps2_runtime_kernel_tests.cpp @@ -1049,6 +1049,46 @@ void register_ps2_runtime_kernel_tests() t.Equals(setupSp & 0xFu, 0u, "SetupThread should always return a 16-byte aligned stack pointer"); }); + tc.Run("SetupThread exposes stable main stack metadata through ReferThreadStatus", [](TestCase &t) + { + TestEnv env; + constexpr uint32_t kInitialLoaderSp = PS2_RAM_SIZE - 0x10u; + constexpr uint32_t kMainStackSize = 0x00020000u; + constexpr uint32_t kExpectedStack = PS2_RAM_SIZE - kMainStackSize; + constexpr uint32_t kMainGp = 0x0036A7F0u; + + env.ctx.pc = 0x00100000u; + setRegU32(env.ctx, 29, kInitialLoaderSp); + setRegU32(env.ctx, 4, kMainGp); + setRegU32(env.ctx, 5, 0xFFFFFFFFu); + setRegU32(env.ctx, 6, kMainStackSize); + t.IsTrue(callSyscall(0x3Cu, env.rdram.data(), &env.ctx, &env.runtime), + "SetupThread syscall should dispatch"); + t.Equals(::getRegU32(&env.ctx, 2), kExpectedStack, + "automatic main stack should start below the reserved top-of-RDRAM area"); + + // ReferThreadStatus can be called after many nested frames have moved $sp. + // It must report the initial stack recorded by SetupThread, not this live snapshot. + constexpr uint32_t kTransientSp = kExpectedStack - 0x80u; + setRegU32(env.ctx, 29, kTransientSp); + setRegU32(env.ctx, 4, 0u); + setRegU32(env.ctx, 5, K_STATUS_ADDR); + t.IsTrue(callSyscall(0x30u, env.rdram.data(), &env.ctx, &env.runtime), + "ReferThreadStatus syscall should dispatch"); + t.Equals(getRegS32(env.ctx, 2), KE_OK, "ReferThreadStatus should accept the current-thread id alias"); + + EeThreadStatusAbi status{}; + std::memcpy(&status, env.rdram.data() + K_STATUS_ADDR, sizeof(status)); + t.Equals(status.stack, kExpectedStack, + "main thread status must expose SetupThread's stable initial stack"); + t.Equals(status.stack_size, static_cast(kMainStackSize), + "main thread status must preserve SetupThread's stack size"); + t.Equals(status.gp_reg, kMainGp, + "main thread status must preserve SetupThread's global pointer"); + t.IsTrue(status.stack != kInitialLoaderSp && status.stack != kTransientSp, + "main thread status must never expose a live stack-pointer snapshot"); + }); + tc.Run("OSD config2 syscalls round-trip extended config", [](TestCase &t) { TestEnv env; diff --git a/ps2xTest/src/ps2_sif_dma_tests.cpp b/ps2xTest/src/ps2_sif_dma_tests.cpp index 9198d1754..46eddeabf 100644 --- a/ps2xTest/src/ps2_sif_dma_tests.cpp +++ b/ps2xTest/src/ps2_sif_dma_tests.cpp @@ -1,8 +1,10 @@ #include "MiniTest.h" #include "ps2_runtime.h" +#include "ps2_iop_host.h" #include "ps2_iop_transport.h" #include "ps2_syscalls.h" #include "ps2_stubs.h" +#include "Kernel/Stubs/SIF.h" #include "runtime/ee_scheduler.h" #include @@ -197,6 +199,79 @@ void register_ps2_sif_dma_tests() t.IsTrue(getRegS32(env.ctx, 2) < 0, "sceSifDmaStat should be negative when transfer is complete"); }); + tc.Run("IOP heap DMA uses private backing instead of aliasing EE RDRAM", [](TestCase &t) + { + TestEnv env; + + constexpr uint32_t kDescAddr = 0x00020040u; + constexpr uint32_t kSrcAddr = 0x00020140u; + constexpr uint32_t kRoundTripAddr = 0x00020240u; + constexpr uint32_t kFormerAliasAddr = 0x01A53880u; + constexpr uint32_t kIopBlockSize = 0x880u; + + std::array payload{}; + for (size_t i = 0; i < payload.size(); ++i) + { + payload[i] = static_cast(0x80u + i); + } + std::memcpy(env.rdram.data() + kSrcAddr, payload.data(), payload.size()); + std::memset(env.rdram.data() + kRoundTripAddr, 0, payload.size()); + std::memset(env.rdram.data() + kFormerAliasAddr, 0x5Au, payload.size()); + + setRegU32(env.ctx, 4, kIopBlockSize); + ps2_stubs::sceSifAllocIopHeap(env.rdram.data(), &env.ctx, &env.runtime); + const uint32_t iopAddress = ::getRegU32(&env.ctx, 2); + t.IsTrue(iopAddress >= PS2_RAM_SIZE, + "sceSifAllocIopHeap should return an address outside EE RDRAM"); + + Ps2SifDmaTransfer desc{ + kSrcAddr, + iopAddress, + static_cast(payload.size()), + 0}; + std::memcpy(env.rdram.data() + kDescAddr, &desc, sizeof(desc)); + setRegU32(env.ctx, 4, kDescAddr); + setRegU32(env.ctx, 5, 1u); + ps2_stubs::sceSifSetDma(env.rdram.data(), &env.ctx, &env.runtime); + t.IsTrue(getRegS32(env.ctx, 2) > 0, + "EE-to-IOP DMA should accept a private IOP heap destination"); + + const std::array aliasSentinel{ + 0x5A, 0x5A, 0x5A, 0x5A, 0x5A, 0x5A, 0x5A, 0x5A, + 0x5A, 0x5A, 0x5A, 0x5A, 0x5A, 0x5A, 0x5A, 0x5A, + 0x5A, 0x5A, 0x5A, 0x5A, 0x5A, 0x5A, 0x5A, 0x5A, + 0x5A, 0x5A, 0x5A, 0x5A, 0x5A, 0x5A, 0x5A, 0x5A}; + t.IsTrue(std::memcmp(env.rdram.data() + kFormerAliasAddr, + aliasSentinel.data(), aliasSentinel.size()) == 0, + "IOP DMA must not overwrite the old 0x01A00000 EE alias range"); + + PS2IopHostAdapter host(env.runtime); + auto scope = host.enterCall(&env.ctx, env.rdram.data()); + uint32_t normalized = 0u; + std::array hostReadback{}; + t.IsTrue(host.normalizeGuestAddress(iopAddress, normalized) && + normalized == iopAddress, + "IOP modules should preserve private IOP heap addresses"); + t.IsTrue(host.readGuest(iopAddress, hostReadback.data(), hostReadback.size()) && + hostReadback == payload, + "IOP modules should read the private heap backing"); + + desc = { + iopAddress, + kRoundTripAddr, + static_cast(payload.size()), + 0}; + std::memcpy(env.rdram.data() + kDescAddr, &desc, sizeof(desc)); + setRegU32(env.ctx, 4, kDescAddr); + setRegU32(env.ctx, 5, 1u); + ps2_stubs::sceSifSetDma(env.rdram.data(), &env.ctx, &env.runtime); + t.IsTrue(getRegS32(env.ctx, 2) > 0, + "IOP-to-EE DMA should accept a private IOP heap source"); + t.IsTrue(std::memcmp(env.rdram.data() + kRoundTripAddr, + payload.data(), payload.size()) == 0, + "IOP-to-EE DMA should round-trip the payload"); + }); + tc.Run("isceSifSetDma and isceSifSetDChain alias the SIF DMA helpers", [](TestCase &t) { TestEnv env; @@ -438,6 +513,8 @@ void register_ps2_sif_dma_tests() t.IsTrue(getRegS32(env.ctx, 2) > 0, "sceSifSetDma should succeed for the SJX transport"); t.Equals(env.rdram[kEeWorkAddr + 0x11u], static_cast(0u), "SJX DMA ack should rewrite the response line to room so EE recycles the chunk"); + t.Equals(readGuestU32(env.rdram.data(), kEeWorkAddr + 0x14u), 0x12345678u, + "SJX DMA ack should translate the remote handle back to the EE callback object"); t.Equals(readGuestU32(env.rdram.data(), kEeWorkAddr + kWorkLen - sizeof(uint32_t)), 2u, "SJX DMA ack should still advance the EE footer ticket"); From 8b57926df6048a5c0e463caf638d2d41df676358 Mon Sep 17 00:00:00 2001 From: Ran-j Date: Wed, 12 Aug 2026 11:57:50 -0300 Subject: [PATCH 7/8] feat: revert wrong changes --- .gitignore | 15 +- ps2xRuntime/src/runner/register_functions.cpp | 61954 +--------------- 2 files changed, 6 insertions(+), 61963 deletions(-) diff --git a/.gitignore b/.gitignore index 5832e840d..f91d3aeee 100644 --- a/.gitignore +++ b/.gitignore @@ -22,17 +22,4 @@ ps2xRuntime/src/runner android/app/.cxx/ android/local.properties android/.gradle/ -.idea/ - -*.bat -*.md -*.csv -*.toml -*.patch -gs-users-manual.txt - -outvita/ -pcsx2Code/ -ps2sdk/ -lotr/ -recvx-decomp/ \ No newline at end of file +.idea/ \ No newline at end of file diff --git a/ps2xRuntime/src/runner/register_functions.cpp b/ps2xRuntime/src/runner/register_functions.cpp index 5560a6dc1..85cc2e348 100644 --- a/ps2xRuntime/src/runner/register_functions.cpp +++ b/ps2xRuntime/src/runner/register_functions.cpp @@ -1,61951 +1,7 @@ #include "ps2_runtime.h" -#include "ps2_recompiled_functions.h" -#include "ps2_stubs.h" -#include "ps2_recompiled_stubs.h"//this will give duplicated erros because runtime maybe has it define already, just delete the TODOS ones -#include "ps2_syscalls.h" +#include "runtime/ps2_memory.h" -extern const uint32_t g_ps2RecompiledFunctionTableBase = 0x100008u; -extern const uint32_t g_ps2RecompiledFunctionTableEnd = 0x301e54u; -extern const uint32_t g_ps2RecompiledFunctionTableSlotCount = 526227u; -PS2Runtime::RecompiledFunction g_ps2RecompiledFunctionTable[526227u] = {}; - -namespace { -struct GeneratedFunctionTableInitializer { - GeneratedFunctionTableInitializer() { - g_ps2RecompiledFunctionTable[0] = entry_0x100008; // 0x100008 - g_ps2RecompiledFunctionTable[4] = entry_0x100008; // 0x100018 - g_ps2RecompiledFunctionTable[32] = entry_0x100008; // 0x100088 - g_ps2RecompiledFunctionTable[34] = entry_0x100008; // 0x100090 - g_ps2RecompiledFunctionTable[40] = entry_0x100008; // 0x1000a8 - g_ps2RecompiledFunctionTable[42] = _exit_0x1000b0; // 0x1000b0 - g_ps2RecompiledFunctionTable[46] = sceGsResetGraph_0x1000c0; // 0x1000c0 - g_ps2RecompiledFunctionTable[114] = sceGsGetGParam_0x1001d0; // 0x1001d0 - g_ps2RecompiledFunctionTable[118] = sceGsResetPath_0x1001e0; // 0x1001e0 - g_ps2RecompiledFunctionTable[144] = sceGsSetDefDispEnv_0x100248; // 0x100248 - g_ps2RecompiledFunctionTable[300] = sceGsPutDispEnv_0x1004b8; // 0x1004b8 - g_ps2RecompiledFunctionTable[348] = sceGszbufaddr_0x100578; // 0x100578 - g_ps2RecompiledFunctionTable[398] = sceGsSetDefDrawEnv_0x100640; // 0x100640 - g_ps2RecompiledFunctionTable[520] = sceGsSetDefClear_0x100828; // 0x100828 - g_ps2RecompiledFunctionTable[586] = sceGsPutDrawEnv_0x100930; // 0x100930 - g_ps2RecompiledFunctionTable[644] = sceGsSyncV_0x100a18; // 0x100a18 - g_ps2RecompiledFunctionTable[682] = sceGsSyncPath_0x100ab0; // 0x100ab0 - g_ps2RecompiledFunctionTable[880] = sceGsSetDefLoadImage_0x100dc8; // 0x100dc8 - g_ps2RecompiledFunctionTable[1002] = sceGsSetDefStoreImage_0x100fb0; // 0x100fb0 - g_ps2RecompiledFunctionTable[1082] = sceGsExecLoadImage_0x1010f0; // 0x1010f0 - g_ps2RecompiledFunctionTable[1178] = sceGsExecStoreImage_0x101270; // 0x101270 - g_ps2RecompiledFunctionTable[1598] = sceGsSyncVCallback_0x101900; // 0x101900 - g_ps2RecompiledFunctionTable[1622] = sceGsSetDefDrawEnv2_0x101960; // 0x101960 - g_ps2RecompiledFunctionTable[1742] = sceGsSetDefDBuffDc_0x101b40; // 0x101b40 - g_ps2RecompiledFunctionTable[1928] = sceGsSwapDBuffDc_0x101e28; // 0x101e28 - g_ps2RecompiledFunctionTable[1952] = memclr_0x101e88; // 0x101e88 - g_ps2RecompiledFunctionTable[1966] = sceDmaGetChan_0x101ec0; // 0x101ec0 - g_ps2RecompiledFunctionTable[1976] = sceDmaReset_0x101ee8; // 0x101ee8 - g_ps2RecompiledFunctionTable[2032] = sceDmaDebug_0x101fc8; // 0x101fc8 - g_ps2RecompiledFunctionTable[2036] = sceDmaPutEnv_0x101fd8; // 0x101fd8 - g_ps2RecompiledFunctionTable[2154] = sceDmaGetEnv_0x1021b0; // 0x1021b0 - g_ps2RecompiledFunctionTable[2168] = sceDmaPutStallAddr_0x1021e8; // 0x1021e8 - g_ps2RecompiledFunctionTable[2178] = sceDmaSend_0x102210; // 0x102210 - g_ps2RecompiledFunctionTable[2232] = sceDmaSendN_0x1022e8; // 0x1022e8 - g_ps2RecompiledFunctionTable[2290] = sceDmaSendI_0x1023d0; // 0x1023d0 - g_ps2RecompiledFunctionTable[2348] = sceDmaRecv_0x1024b8; // 0x1024b8 - g_ps2RecompiledFunctionTable[2398] = sceDmaRecvN_0x102580; // 0x102580 - g_ps2RecompiledFunctionTable[2458] = sceDmaRecvI_0x102670; // 0x102670 - g_ps2RecompiledFunctionTable[2518] = sceDmaSendM_0x102760; // 0x102760 - g_ps2RecompiledFunctionTable[2522] = sceDmaSync_0x102770; // 0x102770 - g_ps2RecompiledFunctionTable[2572] = sceDmaWatch_0x102838; // 0x102838 - g_ps2RecompiledFunctionTable[2624] = sceDmaSyncN_0x102908; // 0x102908 - g_ps2RecompiledFunctionTable[2634] = sceDmaLastSyncTime_0x102930; // 0x102930 - g_ps2RecompiledFunctionTable[2638] = sceDmaPause_0x102940; // 0x102940 - g_ps2RecompiledFunctionTable[2646] = sceDmaRestart_0x102960; // 0x102960 - g_ps2RecompiledFunctionTable[2654] = sceDmaCallback_0x102980; // 0x102980 - g_ps2RecompiledFunctionTable[2664] = sceVu0ApplyMatrix_0x1029a8; // 0x1029a8 - g_ps2RecompiledFunctionTable[2676] = sceVu0MulMatrix_0x1029d8; // 0x1029d8 - g_ps2RecompiledFunctionTable[2694] = sceVu0OuterProduct_0x102a20; // 0x102a20 - g_ps2RecompiledFunctionTable[2702] = sceVu0InnerProduct_0x102a40; // 0x102a40 - g_ps2RecompiledFunctionTable[2712] = sceVu0Normalize_0x102a68; // 0x102a68 - g_ps2RecompiledFunctionTable[2726] = sceVu0TransposeMatrix_0x102aa0; // 0x102aa0 - g_ps2RecompiledFunctionTable[2744] = sceVu0InversMatrix_0x102ae8; // 0x102ae8 - g_ps2RecompiledFunctionTable[2772] = sceVu0DivVector_0x102b58; // 0x102b58 - g_ps2RecompiledFunctionTable[2780] = sceVu0DivVectorXYZ_0x102b78; // 0x102b78 - g_ps2RecompiledFunctionTable[2788] = sceVu0InterVector_0x102b98; // 0x102b98 - g_ps2RecompiledFunctionTable[2798] = sceVu0AddVector_0x102bc0; // 0x102bc0 - g_ps2RecompiledFunctionTable[2804] = sceVu0SubVector_0x102bd8; // 0x102bd8 - g_ps2RecompiledFunctionTable[2810] = sceVu0MulVector_0x102bf0; // 0x102bf0 - g_ps2RecompiledFunctionTable[2816] = sceVu0ScaleVector_0x102c08; // 0x102c08 - g_ps2RecompiledFunctionTable[2822] = sceVu0TransMatrix_0x102c20; // 0x102c20 - g_ps2RecompiledFunctionTable[2834] = sceVu0CopyVector_0x102c50; // 0x102c50 - g_ps2RecompiledFunctionTable[2838] = sceVu0CopyMatrix_0x102c60; // 0x102c60 - g_ps2RecompiledFunctionTable[2848] = sceVu0FTOI4Vector_0x102c88; // 0x102c88 - g_ps2RecompiledFunctionTable[2852] = sceVu0FTOI0Vector_0x102c98; // 0x102c98 - g_ps2RecompiledFunctionTable[2856] = sceVu0ITOF4Vector_0x102ca8; // 0x102ca8 - g_ps2RecompiledFunctionTable[2860] = sceVu0ITOF0Vector_0x102cb8; // 0x102cb8 - g_ps2RecompiledFunctionTable[2864] = sceVu0UnitMatrix_0x102cc8; // 0x102cc8 - g_ps2RecompiledFunctionTable[2874] = _sceVu0ecossin_0x102cf0; // 0x102cf0 - g_ps2RecompiledFunctionTable[2904] = sceVu0RotMatrixZ_0x102d68; // 0x102d68 - g_ps2RecompiledFunctionTable[2946] = sceVu0RotMatrixX_0x102e10; // 0x102e10 - g_ps2RecompiledFunctionTable[2988] = sceVu0RotMatrixY_0x102eb8; // 0x102eb8 - g_ps2RecompiledFunctionTable[3030] = sceVu0RotMatrix_0x102f60; // 0x102f60 - g_ps2RecompiledFunctionTable[3050] = sceVu0ClampVector_0x102fb0; // 0x102fb0 - g_ps2RecompiledFunctionTable[3060] = sceVu0CameraMatrix_0x102fd8; // 0x102fd8 - g_ps2RecompiledFunctionTable[3104] = sceVu0NormalLightMatrix_0x103088; // 0x103088 - g_ps2RecompiledFunctionTable[3152] = sceVu0LightColorMatrix_0x103148; // 0x103148 - g_ps2RecompiledFunctionTable[3178] = sceVu0ViewScreenMatrix_0x1031b0; // 0x1031b0 - g_ps2RecompiledFunctionTable[3244] = sceVu0DropShadowMatrix_0x1032b8; // 0x1032b8 - g_ps2RecompiledFunctionTable[3344] = sceVu0RotTransPersN_0x103448; // 0x103448 - g_ps2RecompiledFunctionTable[3366] = sceVu0RotTransPers_0x1034a0; // 0x1034a0 - g_ps2RecompiledFunctionTable[3384] = sceVu0CopyVectorXYZ_0x1034e8; // 0x1034e8 - g_ps2RecompiledFunctionTable[3392] = sceVu0InterVectorXYZ_0x103508; // 0x103508 - g_ps2RecompiledFunctionTable[3404] = sceVu0ScaleVectorXYZ_0x103538; // 0x103538 - g_ps2RecompiledFunctionTable[3410] = sceVu0ClipScreen_0x103550; // 0x103550 - g_ps2RecompiledFunctionTable[3428] = sceVu0ClipScreen3_0x103598; // 0x103598 - g_ps2RecompiledFunctionTable[3452] = sceVu0ClipAll_0x1035f8; // 0x1035f8 - g_ps2RecompiledFunctionTable[3488] = sceVpu0Reset_0x103688; // 0x103688 - g_ps2RecompiledFunctionTable[3514] = _motionComp0_0x1036f0; // 0x1036f0 - g_ps2RecompiledFunctionTable[3538] = _motionComp0_0x1036f0; // 0x103750 - g_ps2RecompiledFunctionTable[3560] = _motionComp0_0x1036f0; // 0x1037a8 - g_ps2RecompiledFunctionTable[3567] = _motionComp0_0x1036f0; // 0x1037c4 - g_ps2RecompiledFunctionTable[3572] = _motionComp0_0x1036f0; // 0x1037d8 - g_ps2RecompiledFunctionTable[3594] = _motionComp0_0x1036f0; // 0x103830 - g_ps2RecompiledFunctionTable[3720] = _getAllRefs_0x103a28; // 0x103a28 - g_ps2RecompiledFunctionTable[3791] = _getAllRefs_0x103a28; // 0x103b44 - g_ps2RecompiledFunctionTable[3805] = _getAllRefs_0x103a28; // 0x103b7c - g_ps2RecompiledFunctionTable[3816] = _getAllRefs_0x103a28; // 0x103ba8 - g_ps2RecompiledFunctionTable[3830] = _getAllRefs_0x103a28; // 0x103be0 - g_ps2RecompiledFunctionTable[3843] = _getAllRefs_0x103a28; // 0x103c14 - g_ps2RecompiledFunctionTable[3857] = _getAllRefs_0x103a28; // 0x103c4c - g_ps2RecompiledFunctionTable[3872] = _getAllRefs_0x103a28; // 0x103c88 - g_ps2RecompiledFunctionTable[3939] = _getAllRefs_0x103a28; // 0x103d94 - g_ps2RecompiledFunctionTable[3979] = _getAllRefs_0x103a28; // 0x103e34 - g_ps2RecompiledFunctionTable[3995] = _getAllRefs_0x103a28; // 0x103e74 - g_ps2RecompiledFunctionTable[4012] = _getAllRefs_0x103a28; // 0x103eb8 - g_ps2RecompiledFunctionTable[4017] = _getAllRefs_0x103a28; // 0x103ecc - g_ps2RecompiledFunctionTable[4052] = _getAllRefs_0x103a28; // 0x103f58 - g_ps2RecompiledFunctionTable[4066] = _getAllRefs_0x103a28; // 0x103f90 - g_ps2RecompiledFunctionTable[4089] = _getAllRefs_0x103a28; // 0x103fec - g_ps2RecompiledFunctionTable[4112] = _getAllRefs_0x103a28; // 0x104048 - g_ps2RecompiledFunctionTable[4131] = _getAllRefs_0x103a28; // 0x104094 - g_ps2RecompiledFunctionTable[4136] = _getAllRefs_0x103a28; // 0x1040a8 - g_ps2RecompiledFunctionTable[4148] = _getRef0_0x1040d8; // 0x1040d8 - g_ps2RecompiledFunctionTable[4412] = _doMC_0x1044f8; // 0x1044f8 - g_ps2RecompiledFunctionTable[4413] = _doMC_0x1044f8; // 0x1044fc - g_ps2RecompiledFunctionTable[4414] = _doMC_0x1044f8; // 0x104500 - g_ps2RecompiledFunctionTable[4415] = _doMC_0x1044f8; // 0x104504 - g_ps2RecompiledFunctionTable[4416] = _doMC_0x1044f8; // 0x104508 - g_ps2RecompiledFunctionTable[4417] = _doMC_0x1044f8; // 0x10450c - g_ps2RecompiledFunctionTable[4418] = _doMC_0x1044f8; // 0x104510 - g_ps2RecompiledFunctionTable[4419] = _doMC_0x1044f8; // 0x104514 - g_ps2RecompiledFunctionTable[4420] = _doMC_0x1044f8; // 0x104518 - g_ps2RecompiledFunctionTable[4421] = _doMC_0x1044f8; // 0x10451c - g_ps2RecompiledFunctionTable[4422] = _doMC_0x1044f8; // 0x104520 - g_ps2RecompiledFunctionTable[4423] = _doMC_0x1044f8; // 0x104524 - g_ps2RecompiledFunctionTable[4424] = _doMC_0x1044f8; // 0x104528 - g_ps2RecompiledFunctionTable[4425] = _doMC_0x1044f8; // 0x10452c - g_ps2RecompiledFunctionTable[4426] = _doMC_0x1044f8; // 0x104530 - g_ps2RecompiledFunctionTable[4427] = _doMC_0x1044f8; // 0x104534 - g_ps2RecompiledFunctionTable[4428] = _doMC_0x1044f8; // 0x104538 - g_ps2RecompiledFunctionTable[4429] = _doMC_0x1044f8; // 0x10453c - g_ps2RecompiledFunctionTable[4430] = _doMC_0x1044f8; // 0x104540 - g_ps2RecompiledFunctionTable[4431] = _doMC_0x1044f8; // 0x104544 - g_ps2RecompiledFunctionTable[4432] = _doMC_0x1044f8; // 0x104548 - g_ps2RecompiledFunctionTable[4433] = _doMC_0x1044f8; // 0x10454c - g_ps2RecompiledFunctionTable[4434] = _doMC_0x1044f8; // 0x104550 - g_ps2RecompiledFunctionTable[4435] = _doMC_0x1044f8; // 0x104554 - g_ps2RecompiledFunctionTable[4436] = _doMC_0x1044f8; // 0x104558 - g_ps2RecompiledFunctionTable[4437] = _doMC_0x1044f8; // 0x10455c - g_ps2RecompiledFunctionTable[4438] = _doMC_0x1044f8; // 0x104560 - g_ps2RecompiledFunctionTable[4439] = _doMC_0x1044f8; // 0x104564 - g_ps2RecompiledFunctionTable[4440] = _doMC_0x1044f8; // 0x104568 - g_ps2RecompiledFunctionTable[4441] = _doMC_0x1044f8; // 0x10456c - g_ps2RecompiledFunctionTable[4442] = _doMC_0x1044f8; // 0x104570 - g_ps2RecompiledFunctionTable[4443] = _doMC_0x1044f8; // 0x104574 - g_ps2RecompiledFunctionTable[4444] = _doMC_0x1044f8; // 0x104578 - g_ps2RecompiledFunctionTable[4445] = _doMC_0x1044f8; // 0x10457c - g_ps2RecompiledFunctionTable[4446] = _doMC_0x1044f8; // 0x104580 - g_ps2RecompiledFunctionTable[4447] = _doMC_0x1044f8; // 0x104584 - g_ps2RecompiledFunctionTable[4448] = _doMC_0x1044f8; // 0x104588 - g_ps2RecompiledFunctionTable[4449] = _doMC_0x1044f8; // 0x10458c - g_ps2RecompiledFunctionTable[4450] = _doMC_0x1044f8; // 0x104590 - g_ps2RecompiledFunctionTable[4451] = _doMC_0x1044f8; // 0x104594 - g_ps2RecompiledFunctionTable[4452] = _doMC_0x1044f8; // 0x104598 - g_ps2RecompiledFunctionTable[4453] = _doMC_0x1044f8; // 0x10459c - g_ps2RecompiledFunctionTable[4454] = _doMC_0x1044f8; // 0x1045a0 - g_ps2RecompiledFunctionTable[4455] = _doMC_0x1044f8; // 0x1045a4 - g_ps2RecompiledFunctionTable[4456] = _doMC_0x1044f8; // 0x1045a8 - g_ps2RecompiledFunctionTable[4457] = _doMC_0x1044f8; // 0x1045ac - g_ps2RecompiledFunctionTable[4458] = _doMC_0x1044f8; // 0x1045b0 - g_ps2RecompiledFunctionTable[4459] = _doMC_0x1044f8; // 0x1045b4 - g_ps2RecompiledFunctionTable[4460] = _doMC_0x1044f8; // 0x1045b8 - g_ps2RecompiledFunctionTable[4461] = _doMC_0x1044f8; // 0x1045bc - g_ps2RecompiledFunctionTable[4462] = _doMC_0x1044f8; // 0x1045c0 - g_ps2RecompiledFunctionTable[4463] = _doMC_0x1044f8; // 0x1045c4 - g_ps2RecompiledFunctionTable[4464] = _doMC_0x1044f8; // 0x1045c8 - g_ps2RecompiledFunctionTable[4465] = _doMC_0x1044f8; // 0x1045cc - g_ps2RecompiledFunctionTable[4466] = _doMC_0x1044f8; // 0x1045d0 - g_ps2RecompiledFunctionTable[4467] = _doMC_0x1044f8; // 0x1045d4 - g_ps2RecompiledFunctionTable[4468] = _doMC_0x1044f8; // 0x1045d8 - g_ps2RecompiledFunctionTable[4469] = _doMC_0x1044f8; // 0x1045dc - g_ps2RecompiledFunctionTable[4470] = _doMC_0x1044f8; // 0x1045e0 - g_ps2RecompiledFunctionTable[4471] = _doMC_0x1044f8; // 0x1045e4 - g_ps2RecompiledFunctionTable[4472] = _doMC_0x1044f8; // 0x1045e8 - g_ps2RecompiledFunctionTable[4473] = _doMC_0x1044f8; // 0x1045ec - g_ps2RecompiledFunctionTable[4474] = _doMC_0x1044f8; // 0x1045f0 - g_ps2RecompiledFunctionTable[4475] = _doMC_0x1044f8; // 0x1045f4 - g_ps2RecompiledFunctionTable[4476] = _doMC_0x1044f8; // 0x1045f8 - g_ps2RecompiledFunctionTable[4477] = _doMC_0x1044f8; // 0x1045fc - g_ps2RecompiledFunctionTable[4478] = _doMC_0x1044f8; // 0x104600 - g_ps2RecompiledFunctionTable[4479] = _doMC_0x1044f8; // 0x104604 - g_ps2RecompiledFunctionTable[4480] = _doMC_0x1044f8; // 0x104608 - g_ps2RecompiledFunctionTable[4481] = _doMC_0x1044f8; // 0x10460c - g_ps2RecompiledFunctionTable[4482] = _doMC_0x1044f8; // 0x104610 - g_ps2RecompiledFunctionTable[4483] = _doMC_0x1044f8; // 0x104614 - g_ps2RecompiledFunctionTable[4484] = _doMC_0x1044f8; // 0x104618 - g_ps2RecompiledFunctionTable[4485] = _doMC_0x1044f8; // 0x10461c - g_ps2RecompiledFunctionTable[4486] = _doMC_0x1044f8; // 0x104620 - g_ps2RecompiledFunctionTable[4487] = _doMC_0x1044f8; // 0x104624 - g_ps2RecompiledFunctionTable[4488] = _doMC_0x1044f8; // 0x104628 - g_ps2RecompiledFunctionTable[4489] = _doMC_0x1044f8; // 0x10462c - g_ps2RecompiledFunctionTable[4490] = _doMC_0x1044f8; // 0x104630 - g_ps2RecompiledFunctionTable[4491] = _doMC_0x1044f8; // 0x104634 - g_ps2RecompiledFunctionTable[4492] = _doMC_0x1044f8; // 0x104638 - g_ps2RecompiledFunctionTable[4493] = _doMC_0x1044f8; // 0x10463c - g_ps2RecompiledFunctionTable[4494] = _doMC_0x1044f8; // 0x104640 - g_ps2RecompiledFunctionTable[4495] = _doMC_0x1044f8; // 0x104644 - g_ps2RecompiledFunctionTable[4496] = _doMC_0x1044f8; // 0x104648 - g_ps2RecompiledFunctionTable[4497] = _doMC_0x1044f8; // 0x10464c - g_ps2RecompiledFunctionTable[4498] = _doMC_0x1044f8; // 0x104650 - g_ps2RecompiledFunctionTable[4499] = _doMC_0x1044f8; // 0x104654 - g_ps2RecompiledFunctionTable[4500] = _doMC_0x1044f8; // 0x104658 - g_ps2RecompiledFunctionTable[4501] = _doMC_0x1044f8; // 0x10465c - g_ps2RecompiledFunctionTable[4502] = _doMC_0x1044f8; // 0x104660 - g_ps2RecompiledFunctionTable[4503] = _doMC_0x1044f8; // 0x104664 - g_ps2RecompiledFunctionTable[4504] = _doMC_0x1044f8; // 0x104668 - g_ps2RecompiledFunctionTable[4505] = _doMC_0x1044f8; // 0x10466c - g_ps2RecompiledFunctionTable[4506] = _doMC_0x1044f8; // 0x104670 - g_ps2RecompiledFunctionTable[4507] = _doMC_0x1044f8; // 0x104674 - g_ps2RecompiledFunctionTable[4508] = _doMC_0x1044f8; // 0x104678 - g_ps2RecompiledFunctionTable[4509] = _doMC_0x1044f8; // 0x10467c - g_ps2RecompiledFunctionTable[4510] = _doMC_0x1044f8; // 0x104680 - g_ps2RecompiledFunctionTable[4512] = _rix_000_0x104688; // 0x104688 - g_ps2RecompiledFunctionTable[4521] = _rix_000_0x104688; // 0x1046ac - g_ps2RecompiledFunctionTable[4542] = _ri0_000_0x104700; // 0x104700 - g_ps2RecompiledFunctionTable[4550] = _ri0_000_0x104700; // 0x104720 - g_ps2RecompiledFunctionTable[4552] = _ri0_000_0x104700; // 0x104728 - g_ps2RecompiledFunctionTable[4580] = _rix_001_0x104798; // 0x104798 - g_ps2RecompiledFunctionTable[4597] = _rix_001_0x104798; // 0x1047dc - g_ps2RecompiledFunctionTable[4626] = _ri0_001_0x104850; // 0x104850 - g_ps2RecompiledFunctionTable[4636] = _ri0_001_0x104850; // 0x104878 - g_ps2RecompiledFunctionTable[4644] = _ri0_001_0x104850; // 0x104898 - g_ps2RecompiledFunctionTable[4678] = _rix_010_0x104920; // 0x104920 - g_ps2RecompiledFunctionTable[4689] = _rix_010_0x104920; // 0x10494c - g_ps2RecompiledFunctionTable[4722] = _ri0_010_0x1049d0; // 0x1049d0 - g_ps2RecompiledFunctionTable[4732] = _ri0_010_0x1049d0; // 0x1049f8 - g_ps2RecompiledFunctionTable[4734] = _ri0_010_0x1049d0; // 0x104a00 - g_ps2RecompiledFunctionTable[4768] = _rix_011_0x104a88; // 0x104a88 - g_ps2RecompiledFunctionTable[4793] = _rix_011_0x104a88; // 0x104aec - g_ps2RecompiledFunctionTable[4830] = _ri0_011_0x104b80; // 0x104b80 - g_ps2RecompiledFunctionTable[4840] = _ri0_011_0x104b80; // 0x104ba8 - g_ps2RecompiledFunctionTable[4854] = _ri0_011_0x104b80; // 0x104be0 - g_ps2RecompiledFunctionTable[4894] = _rix_100_0x104c80; // 0x104c80 - g_ps2RecompiledFunctionTable[4903] = _rix_100_0x104c80; // 0x104ca4 - g_ps2RecompiledFunctionTable[4936] = _ri0_100_0x104d28; // 0x104d28 - g_ps2RecompiledFunctionTable[4944] = _ri0_100_0x104d28; // 0x104d48 - g_ps2RecompiledFunctionTable[4946] = _ri0_100_0x104d28; // 0x104d50 - g_ps2RecompiledFunctionTable[4980] = _rix_101_0x104dd8; // 0x104dd8 - g_ps2RecompiledFunctionTable[4997] = _rix_101_0x104dd8; // 0x104e1c - g_ps2RecompiledFunctionTable[5038] = _ri0_101_0x104ec0; // 0x104ec0 - g_ps2RecompiledFunctionTable[5048] = _ri0_101_0x104ec0; // 0x104ee8 - g_ps2RecompiledFunctionTable[5056] = _ri0_101_0x104ec0; // 0x104f08 - g_ps2RecompiledFunctionTable[5096] = _rix_110_0x104fa8; // 0x104fa8 - g_ps2RecompiledFunctionTable[5107] = _rix_110_0x104fa8; // 0x104fd4 - g_ps2RecompiledFunctionTable[5152] = _ri0_110_0x105088; // 0x105088 - g_ps2RecompiledFunctionTable[5162] = _ri0_110_0x105088; // 0x1050b0 - g_ps2RecompiledFunctionTable[5164] = _ri0_110_0x105088; // 0x1050b8 - g_ps2RecompiledFunctionTable[5204] = _rix_111_0x105158; // 0x105158 - g_ps2RecompiledFunctionTable[5229] = _rix_111_0x105158; // 0x1051bc - g_ps2RecompiledFunctionTable[5278] = _ri0_111_0x105280; // 0x105280 - g_ps2RecompiledFunctionTable[5288] = _ri0_111_0x105280; // 0x1052a8 - g_ps2RecompiledFunctionTable[5302] = _ri0_111_0x105280; // 0x1052e0 - g_ps2RecompiledFunctionTable[5348] = _copyAddRefImage_0x105398; // 0x105398 - g_ps2RecompiledFunctionTable[5352] = _copyAddRefImage_0x105398; // 0x1053a8 - g_ps2RecompiledFunctionTable[5372] = _copyRefImage_0x1053f8; // 0x1053f8 - g_ps2RecompiledFunctionTable[5376] = _copyRefImage_0x1053f8; // 0x105408 - g_ps2RecompiledFunctionTable[5396] = _ipuSetMPEG1_0x105458; // 0x105458 - g_ps2RecompiledFunctionTable[5406] = _waitBdecOut_0x105480; // 0x105480 - g_ps2RecompiledFunctionTable[5413] = _waitBdecOut_0x105480; // 0x10549c - g_ps2RecompiledFunctionTable[5424] = _waitBdecOut_0x105480; // 0x1054c8 - g_ps2RecompiledFunctionTable[5440] = _waitBdecOut_0x105480; // 0x105508 - g_ps2RecompiledFunctionTable[5483] = _waitBdecOut_0x105480; // 0x1055b4 - g_ps2RecompiledFunctionTable[5489] = _waitBdecOut_0x105480; // 0x1055cc - g_ps2RecompiledFunctionTable[5497] = _waitBdecOut_0x105480; // 0x1055ec - g_ps2RecompiledFunctionTable[5498] = _waitBdecOut_0x105480; // 0x1055f0 - g_ps2RecompiledFunctionTable[5534] = _dmVector_0x105680; // 0x105680 - g_ps2RecompiledFunctionTable[5538] = _dmVector_0x105680; // 0x105690 - g_ps2RecompiledFunctionTable[5542] = _dualPrimeVector_0x1056a0; // 0x1056a0 - g_ps2RecompiledFunctionTable[5580] = _dualPrimeVector_0x1056a0; // 0x105738 - g_ps2RecompiledFunctionTable[5581] = _dualPrimeVector_0x1056a0; // 0x10573c - g_ps2RecompiledFunctionTable[5640] = _mbAddressIncrement_0x105828; // 0x105828 - g_ps2RecompiledFunctionTable[5660] = _mbAddressIncrement_0x105828; // 0x105878 - g_ps2RecompiledFunctionTable[5662] = _mbAddressIncrement_0x105828; // 0x105880 - g_ps2RecompiledFunctionTable[5678] = _mbAddressIncrement_0x105828; // 0x1058c0 - g_ps2RecompiledFunctionTable[5686] = _mbAddressIncrement_0x105828; // 0x1058e0 - g_ps2RecompiledFunctionTable[5690] = _mbAddressIncrement_0x105828; // 0x1058f0 - g_ps2RecompiledFunctionTable[5708] = _pictureData0_0x105938; // 0x105938 - g_ps2RecompiledFunctionTable[5734] = _pictureData0_0x105938; // 0x1059a0 - g_ps2RecompiledFunctionTable[5735] = _pictureData0_0x105938; // 0x1059a4 - g_ps2RecompiledFunctionTable[5737] = _pictureData0_0x105938; // 0x1059ac - g_ps2RecompiledFunctionTable[5744] = _pictureData0_0x105938; // 0x1059c8 - g_ps2RecompiledFunctionTable[5746] = _pictureData0_0x105938; // 0x1059d0 - g_ps2RecompiledFunctionTable[5752] = _pictureData0_0x105938; // 0x1059e8 - g_ps2RecompiledFunctionTable[5765] = _pictureData0_0x105938; // 0x105a1c - g_ps2RecompiledFunctionTable[5771] = _pictureData0_0x105938; // 0x105a34 - g_ps2RecompiledFunctionTable[5782] = _sliceA0_0x105a60; // 0x105a60 - g_ps2RecompiledFunctionTable[5796] = _sliceA0_0x105a60; // 0x105a98 - g_ps2RecompiledFunctionTable[5798] = _sliceA0_0x105a60; // 0x105aa0 - g_ps2RecompiledFunctionTable[5806] = _sliceA0_0x105a60; // 0x105ac0 - g_ps2RecompiledFunctionTable[5810] = _sliceA0_0x105a60; // 0x105ad0 - g_ps2RecompiledFunctionTable[5812] = _sliceA0_0x105a60; // 0x105ad8 - g_ps2RecompiledFunctionTable[5814] = _sliceA0_0x105a60; // 0x105ae0 - g_ps2RecompiledFunctionTable[5821] = _sliceA0_0x105a60; // 0x105afc - g_ps2RecompiledFunctionTable[5856] = _slice0_0x105b88; // 0x105b88 - g_ps2RecompiledFunctionTable[5872] = _slice0_0x105b88; // 0x105bc8 - g_ps2RecompiledFunctionTable[5878] = _slice0_0x105b88; // 0x105be0 - g_ps2RecompiledFunctionTable[5891] = _slice0_0x105b88; // 0x105c14 - g_ps2RecompiledFunctionTable[5899] = _slice0_0x105b88; // 0x105c34 - g_ps2RecompiledFunctionTable[5908] = _slice0_0x105b88; // 0x105c58 - g_ps2RecompiledFunctionTable[5921] = _slice0_0x105b88; // 0x105c8c - g_ps2RecompiledFunctionTable[5934] = _slice0_0x105b88; // 0x105cc0 - g_ps2RecompiledFunctionTable[5944] = _slice0_0x105b88; // 0x105ce8 - g_ps2RecompiledFunctionTable[5954] = _slice0_0x105b88; // 0x105d10 - g_ps2RecompiledFunctionTable[5964] = _slice0_0x105b88; // 0x105d38 - g_ps2RecompiledFunctionTable[5984] = _skipMB0_0x105d88; // 0x105d88 - g_ps2RecompiledFunctionTable[6025] = _skipMB0_0x105d88; // 0x105e2c - g_ps2RecompiledFunctionTable[6036] = _decMB0_0x105e58; // 0x105e58 - g_ps2RecompiledFunctionTable[6066] = _decMB0_0x105e58; // 0x105ed0 - g_ps2RecompiledFunctionTable[6072] = _decMB0_0x105e58; // 0x105ee8 - g_ps2RecompiledFunctionTable[6075] = _decMB0_0x105e58; // 0x105ef4 - g_ps2RecompiledFunctionTable[6089] = _decMB0_0x105e58; // 0x105f2c - g_ps2RecompiledFunctionTable[6143] = _decMB0_0x105e58; // 0x106004 - g_ps2RecompiledFunctionTable[6154] = _decMB0_0x105e58; // 0x106030 - g_ps2RecompiledFunctionTable[6182] = _decMB0_0x105e58; // 0x1060a0 - g_ps2RecompiledFunctionTable[6195] = _decMB0_0x105e58; // 0x1060d4 - g_ps2RecompiledFunctionTable[6220] = _decMB0_0x105e58; // 0x106138 - g_ps2RecompiledFunctionTable[6233] = _decMB0_0x105e58; // 0x10616c - g_ps2RecompiledFunctionTable[6245] = _decMB0_0x105e58; // 0x10619c - g_ps2RecompiledFunctionTable[6273] = _decMB0_0x105e58; // 0x10620c - g_ps2RecompiledFunctionTable[6290] = _decMB0_0x105e58; // 0x106250 - g_ps2RecompiledFunctionTable[6366] = decode_motion_vector_0x106380; // 0x106380 - g_ps2RecompiledFunctionTable[6400] = _motionVectors_0x106408; // 0x106408 - g_ps2RecompiledFunctionTable[6427] = _motionVectors_0x106408; // 0x106474 - g_ps2RecompiledFunctionTable[6435] = _motionVectors_0x106408; // 0x106494 - g_ps2RecompiledFunctionTable[6446] = _motionVectors_0x106408; // 0x1064c0 - g_ps2RecompiledFunctionTable[6448] = _motionVectors_0x106408; // 0x1064c8 - g_ps2RecompiledFunctionTable[6479] = _motionVectors_0x106408; // 0x106544 - g_ps2RecompiledFunctionTable[6496] = _motionVector_0x106588; // 0x106588 - g_ps2RecompiledFunctionTable[6515] = _motionVector_0x106588; // 0x1065d4 - g_ps2RecompiledFunctionTable[6521] = _motionVector_0x106588; // 0x1065ec - g_ps2RecompiledFunctionTable[6529] = _motionVector_0x106588; // 0x10660c - g_ps2RecompiledFunctionTable[6533] = _motionVector_0x106588; // 0x10661c - g_ps2RecompiledFunctionTable[6536] = _motionVector_0x106588; // 0x106628 - g_ps2RecompiledFunctionTable[6542] = _motionVector_0x106588; // 0x106640 - g_ps2RecompiledFunctionTable[6554] = _motionVector_0x106588; // 0x106670 - g_ps2RecompiledFunctionTable[6563] = _motionVector_0x106588; // 0x106694 - g_ps2RecompiledFunctionTable[6576] = _sendIpuCommand_0x1066c8; // 0x1066c8 - g_ps2RecompiledFunctionTable[6588] = _waitIpuIdle_0x1066f8; // 0x1066f8 - g_ps2RecompiledFunctionTable[6612] = _waitIpuIdle_0x1066f8; // 0x106758 - g_ps2RecompiledFunctionTable[6617] = _waitIpuIdle_0x1066f8; // 0x10676c - g_ps2RecompiledFunctionTable[6630] = _waitIpuIdle64_0x1067a0; // 0x1067a0 - g_ps2RecompiledFunctionTable[6654] = _waitIpuIdle64_0x1067a0; // 0x106800 - g_ps2RecompiledFunctionTable[6659] = _waitIpuIdle64_0x1067a0; // 0x106814 - g_ps2RecompiledFunctionTable[6674] = _ipuVdec_0x106850; // 0x106850 - g_ps2RecompiledFunctionTable[6700] = _ipuVdec_0x106850; // 0x1068b8 - g_ps2RecompiledFunctionTable[6707] = _ipuVdec_0x106850; // 0x1068d4 - g_ps2RecompiledFunctionTable[6742] = _ipuVdec_0x106850; // 0x106960 - g_ps2RecompiledFunctionTable[6748] = _ipuVdec_0x106850; // 0x106978 - g_ps2RecompiledFunctionTable[6784] = _peepBit_0x106a08; // 0x106a08 - g_ps2RecompiledFunctionTable[6814] = _peepBit_0x106a08; // 0x106a80 - g_ps2RecompiledFunctionTable[6821] = _peepBit_0x106a08; // 0x106a9c - g_ps2RecompiledFunctionTable[6843] = _peepBit_0x106a08; // 0x106af4 - g_ps2RecompiledFunctionTable[6862] = _flushBuf_0x106b40; // 0x106b40 - g_ps2RecompiledFunctionTable[6884] = _flushBuf_0x106b40; // 0x106b98 - g_ps2RecompiledFunctionTable[6891] = _flushBuf_0x106b40; // 0x106bb4 - g_ps2RecompiledFunctionTable[6918] = _flushBuf_0x106b40; // 0x106c20 - g_ps2RecompiledFunctionTable[6932] = _nextBit_0x106c58; // 0x106c58 - g_ps2RecompiledFunctionTable[6954] = _nextBit_0x106c58; // 0x106cb0 - g_ps2RecompiledFunctionTable[6961] = _nextBit_0x106c58; // 0x106ccc - g_ps2RecompiledFunctionTable[6990] = _nextBit_0x106c58; // 0x106d40 - g_ps2RecompiledFunctionTable[7010] = _nextBit_0x106c58; // 0x106d90 - g_ps2RecompiledFunctionTable[7022] = _nextStartCode_0x106dc0; // 0x106dc0 - g_ps2RecompiledFunctionTable[7026] = _nextStartCode_0x106dc0; // 0x106dd0 - g_ps2RecompiledFunctionTable[7036] = _nextStartCode_0x106dc0; // 0x106df8 - g_ps2RecompiledFunctionTable[7038] = _nextStartCode_0x106dc0; // 0x106e00 - g_ps2RecompiledFunctionTable[7040] = _nextStartCode_0x106dc0; // 0x106e08 - g_ps2RecompiledFunctionTable[7042] = _nextStartCode_0x106dc0; // 0x106e10 - g_ps2RecompiledFunctionTable[7048] = _sliceB_0x106e28; // 0x106e28 - g_ps2RecompiledFunctionTable[7054] = _sliceB_0x106e28; // 0x106e40 - g_ps2RecompiledFunctionTable[7057] = _sliceB_0x106e28; // 0x106e4c - g_ps2RecompiledFunctionTable[7061] = _sliceB_0x106e28; // 0x106e5c - g_ps2RecompiledFunctionTable[7064] = _sliceB_0x106e28; // 0x106e68 - g_ps2RecompiledFunctionTable[7066] = _sliceB_0x106e28; // 0x106e70 - g_ps2RecompiledFunctionTable[7076] = _nextHeader_0x106e98; // 0x106e98 - g_ps2RecompiledFunctionTable[7096] = _nextHeader_0x106e98; // 0x106ee8 - g_ps2RecompiledFunctionTable[7098] = _nextHeader_0x106e98; // 0x106ef0 - g_ps2RecompiledFunctionTable[7100] = _nextHeader_0x106e98; // 0x106ef8 - g_ps2RecompiledFunctionTable[7117] = _nextHeader_0x106e98; // 0x106f3c - g_ps2RecompiledFunctionTable[7121] = _nextHeader_0x106e98; // 0x106f4c - g_ps2RecompiledFunctionTable[7125] = _nextHeader_0x106e98; // 0x106f5c - g_ps2RecompiledFunctionTable[7131] = _nextHeader_0x106e98; // 0x106f74 - g_ps2RecompiledFunctionTable[7150] = _pictureHeader_0x106fc0; // 0x106fc0 - g_ps2RecompiledFunctionTable[7159] = _pictureHeader_0x106fc0; // 0x106fe4 - g_ps2RecompiledFunctionTable[7162] = _pictureHeader_0x106fc0; // 0x106ff0 - g_ps2RecompiledFunctionTable[7166] = _pictureHeader_0x106fc0; // 0x107000 - g_ps2RecompiledFunctionTable[7175] = _pictureHeader_0x106fc0; // 0x107024 - g_ps2RecompiledFunctionTable[7179] = _pictureHeader_0x106fc0; // 0x107034 - g_ps2RecompiledFunctionTable[7186] = _pictureHeader_0x106fc0; // 0x107050 - g_ps2RecompiledFunctionTable[7190] = _pictureHeader_0x106fc0; // 0x107060 - g_ps2RecompiledFunctionTable[7193] = _pictureHeader_0x106fc0; // 0x10706c - g_ps2RecompiledFunctionTable[7195] = _pictureHeader_0x106fc0; // 0x107074 - g_ps2RecompiledFunctionTable[7202] = _extensionAndUserData_0x107090; // 0x107090 - g_ps2RecompiledFunctionTable[7203] = _extensionAndUserData_0x107090; // 0x107094 - g_ps2RecompiledFunctionTable[7204] = _extensionAndUserData_0x107090; // 0x107098 - g_ps2RecompiledFunctionTable[7205] = _extensionAndUserData_0x107090; // 0x10709c - g_ps2RecompiledFunctionTable[7206] = _extensionAndUserData_0x107090; // 0x1070a0 - g_ps2RecompiledFunctionTable[7207] = _extensionAndUserData_0x107090; // 0x1070a4 - g_ps2RecompiledFunctionTable[7208] = _extensionAndUserData_0x107090; // 0x1070a8 - g_ps2RecompiledFunctionTable[7209] = _extensionAndUserData_0x107090; // 0x1070ac - g_ps2RecompiledFunctionTable[7210] = _extensionAndUserData_0x107090; // 0x1070b0 - g_ps2RecompiledFunctionTable[7211] = _extensionAndUserData_0x107090; // 0x1070b4 - g_ps2RecompiledFunctionTable[7212] = _extensionAndUserData_0x107090; // 0x1070b8 - g_ps2RecompiledFunctionTable[7213] = _extensionAndUserData_0x107090; // 0x1070bc - g_ps2RecompiledFunctionTable[7214] = _extensionAndUserData_0x107090; // 0x1070c0 - g_ps2RecompiledFunctionTable[7215] = _extensionAndUserData_0x107090; // 0x1070c4 - g_ps2RecompiledFunctionTable[7216] = _extensionAndUserData_0x107090; // 0x1070c8 - g_ps2RecompiledFunctionTable[7217] = _extensionAndUserData_0x107090; // 0x1070cc - g_ps2RecompiledFunctionTable[7218] = _extensionAndUserData_0x107090; // 0x1070d0 - g_ps2RecompiledFunctionTable[7219] = _extensionAndUserData_0x107090; // 0x1070d4 - g_ps2RecompiledFunctionTable[7220] = _extensionAndUserData_0x107090; // 0x1070d8 - g_ps2RecompiledFunctionTable[7221] = _extensionAndUserData_0x107090; // 0x1070dc - g_ps2RecompiledFunctionTable[7222] = _extensionAndUserData_0x107090; // 0x1070e0 - g_ps2RecompiledFunctionTable[7223] = _extensionAndUserData_0x107090; // 0x1070e4 - g_ps2RecompiledFunctionTable[7224] = _extensionAndUserData_0x107090; // 0x1070e8 - g_ps2RecompiledFunctionTable[7225] = _extensionAndUserData_0x107090; // 0x1070ec - g_ps2RecompiledFunctionTable[7226] = _extensionAndUserData_0x107090; // 0x1070f0 - g_ps2RecompiledFunctionTable[7227] = _extensionAndUserData_0x107090; // 0x1070f4 - g_ps2RecompiledFunctionTable[7228] = _extensionAndUserData_0x107090; // 0x1070f8 - g_ps2RecompiledFunctionTable[7229] = _extensionAndUserData_0x107090; // 0x1070fc - g_ps2RecompiledFunctionTable[7230] = _extensionAndUserData_0x107090; // 0x107100 - g_ps2RecompiledFunctionTable[7231] = _extensionAndUserData_0x107090; // 0x107104 - g_ps2RecompiledFunctionTable[7232] = _extensionAndUserData_0x107090; // 0x107108 - g_ps2RecompiledFunctionTable[7233] = _extensionAndUserData_0x107090; // 0x10710c - g_ps2RecompiledFunctionTable[7234] = _extensionAndUserData_0x107090; // 0x107110 - g_ps2RecompiledFunctionTable[7235] = _extensionAndUserData_0x107090; // 0x107114 - g_ps2RecompiledFunctionTable[7236] = _extensionAndUserData_0x107090; // 0x107118 - g_ps2RecompiledFunctionTable[7237] = _extensionAndUserData_0x107090; // 0x10711c - g_ps2RecompiledFunctionTable[7238] = _extensionAndUserData_0x107090; // 0x107120 - g_ps2RecompiledFunctionTable[7239] = _extensionAndUserData_0x107090; // 0x107124 - g_ps2RecompiledFunctionTable[7240] = _extensionAndUserData_0x107090; // 0x107128 - g_ps2RecompiledFunctionTable[7241] = _extensionAndUserData_0x107090; // 0x10712c - g_ps2RecompiledFunctionTable[7242] = _extensionAndUserData_0x107090; // 0x107130 - g_ps2RecompiledFunctionTable[7243] = _extensionAndUserData_0x107090; // 0x107134 - g_ps2RecompiledFunctionTable[7244] = _extensionAndUserData_0x107090; // 0x107138 - g_ps2RecompiledFunctionTable[7245] = _extensionAndUserData_0x107090; // 0x10713c - g_ps2RecompiledFunctionTable[7246] = _pictureCodingExtension_0x107140; // 0x107140 - g_ps2RecompiledFunctionTable[7259] = _pictureCodingExtension_0x107140; // 0x107174 - g_ps2RecompiledFunctionTable[7264] = _pictureCodingExtension_0x107140; // 0x107188 - g_ps2RecompiledFunctionTable[7267] = _pictureCodingExtension_0x107140; // 0x107194 - g_ps2RecompiledFunctionTable[7270] = _pictureCodingExtension_0x107140; // 0x1071a0 - g_ps2RecompiledFunctionTable[7273] = _pictureCodingExtension_0x107140; // 0x1071ac - g_ps2RecompiledFunctionTable[7285] = _pictureCodingExtension_0x107140; // 0x1071dc - g_ps2RecompiledFunctionTable[7293] = _pictureCodingExtension_0x107140; // 0x1071fc - g_ps2RecompiledFunctionTable[7297] = _pictureCodingExtension_0x107140; // 0x10720c - g_ps2RecompiledFunctionTable[7301] = _pictureCodingExtension_0x107140; // 0x10721c - g_ps2RecompiledFunctionTable[7305] = _pictureCodingExtension_0x107140; // 0x10722c - g_ps2RecompiledFunctionTable[7319] = _pictureCodingExtension_0x107140; // 0x107264 - g_ps2RecompiledFunctionTable[7333] = _pictureCodingExtension_0x107140; // 0x10729c - g_ps2RecompiledFunctionTable[7345] = _pictureCodingExtension_0x107140; // 0x1072cc - g_ps2RecompiledFunctionTable[7348] = _pictureCodingExtension_0x107140; // 0x1072d8 - g_ps2RecompiledFunctionTable[7352] = _pictureCodingExtension_0x107140; // 0x1072e8 - g_ps2RecompiledFunctionTable[7356] = _pictureCodingExtension_0x107140; // 0x1072f8 - g_ps2RecompiledFunctionTable[7361] = _pictureCodingExtension_0x107140; // 0x10730c - g_ps2RecompiledFunctionTable[7365] = _pictureCodingExtension_0x107140; // 0x10731c - g_ps2RecompiledFunctionTable[7369] = _pictureCodingExtension_0x107140; // 0x10732c - g_ps2RecompiledFunctionTable[7373] = _pictureCodingExtension_0x107140; // 0x10733c - g_ps2RecompiledFunctionTable[7377] = _pictureCodingExtension_0x107140; // 0x10734c - g_ps2RecompiledFunctionTable[7386] = _extrainfo_0x107370; // 0x107370 - g_ps2RecompiledFunctionTable[7390] = _extrainfo_0x107370; // 0x107380 - g_ps2RecompiledFunctionTable[7392] = _extrainfo_0x107370; // 0x107388 - g_ps2RecompiledFunctionTable[7394] = _extrainfo_0x107370; // 0x107390 - g_ps2RecompiledFunctionTable[7400] = _updateTempTackData_0x1073a8; // 0x1073a8 - g_ps2RecompiledFunctionTable[7456] = _groupOfPicturesHeader_0x107488; // 0x107488 - g_ps2RecompiledFunctionTable[7482] = _groupOfPicturesHeader_0x107488; // 0x1074f0 - g_ps2RecompiledFunctionTable[7485] = _groupOfPicturesHeader_0x107488; // 0x1074fc - g_ps2RecompiledFunctionTable[7489] = _groupOfPicturesHeader_0x107488; // 0x10750c - g_ps2RecompiledFunctionTable[7493] = _groupOfPicturesHeader_0x107488; // 0x10751c - g_ps2RecompiledFunctionTable[7495] = _groupOfPicturesHeader_0x107488; // 0x107524 - g_ps2RecompiledFunctionTable[7498] = _groupOfPicturesHeader_0x107488; // 0x107530 - g_ps2RecompiledFunctionTable[7501] = _groupOfPicturesHeader_0x107488; // 0x10753c - g_ps2RecompiledFunctionTable[7504] = _groupOfPicturesHeader_0x107488; // 0x107548 - g_ps2RecompiledFunctionTable[7514] = _quantMatrixExtension_0x107570; // 0x107570 - g_ps2RecompiledFunctionTable[7520] = _quantMatrixExtension_0x107570; // 0x107588 - g_ps2RecompiledFunctionTable[7524] = _quantMatrixExtension_0x107570; // 0x107598 - g_ps2RecompiledFunctionTable[7526] = _quantMatrixExtension_0x107570; // 0x1075a0 - g_ps2RecompiledFunctionTable[7528] = _quantMatrixExtension_0x107570; // 0x1075a8 - g_ps2RecompiledFunctionTable[7531] = _quantMatrixExtension_0x107570; // 0x1075b4 - g_ps2RecompiledFunctionTable[7535] = _quantMatrixExtension_0x107570; // 0x1075c4 - g_ps2RecompiledFunctionTable[7537] = _quantMatrixExtension_0x107570; // 0x1075cc - g_ps2RecompiledFunctionTable[7539] = _quantMatrixExtension_0x107570; // 0x1075d4 - g_ps2RecompiledFunctionTable[7541] = _quantMatrixExtension_0x107570; // 0x1075dc - g_ps2RecompiledFunctionTable[7545] = _quantMatrixExtension_0x107570; // 0x1075ec - g_ps2RecompiledFunctionTable[7547] = _quantMatrixExtension_0x107570; // 0x1075f4 - g_ps2RecompiledFunctionTable[7558] = _pictureDisplayExtension_0x107620; // 0x107620 - g_ps2RecompiledFunctionTable[7592] = _pictureDisplayExtension_0x107620; // 0x1076a8 - g_ps2RecompiledFunctionTable[7594] = _pictureDisplayExtension_0x107620; // 0x1076b0 - g_ps2RecompiledFunctionTable[7600] = _pictureDisplayExtension_0x107620; // 0x1076c8 - g_ps2RecompiledFunctionTable[7602] = _pictureDisplayExtension_0x107620; // 0x1076d0 - g_ps2RecompiledFunctionTable[7607] = _pictureDisplayExtension_0x107620; // 0x1076e4 - g_ps2RecompiledFunctionTable[7618] = _copyrightExtension_0x107710; // 0x107710 - g_ps2RecompiledFunctionTable[7628] = _copyrightExtension_0x107710; // 0x107738 - g_ps2RecompiledFunctionTable[7631] = _copyrightExtension_0x107710; // 0x107744 - g_ps2RecompiledFunctionTable[7635] = _copyrightExtension_0x107710; // 0x107754 - g_ps2RecompiledFunctionTable[7639] = _copyrightExtension_0x107710; // 0x107764 - g_ps2RecompiledFunctionTable[7642] = _copyrightExtension_0x107710; // 0x107770 - g_ps2RecompiledFunctionTable[7644] = _copyrightExtension_0x107710; // 0x107778 - g_ps2RecompiledFunctionTable[7647] = _copyrightExtension_0x107710; // 0x107784 - g_ps2RecompiledFunctionTable[7649] = _copyrightExtension_0x107710; // 0x10778c - g_ps2RecompiledFunctionTable[7652] = _copyrightExtension_0x107710; // 0x107798 - g_ps2RecompiledFunctionTable[7654] = _copyrightExtension_0x107710; // 0x1077a0 - g_ps2RecompiledFunctionTable[7662] = _decPicture_0x1077c0; // 0x1077c0 - g_ps2RecompiledFunctionTable[7679] = _decPicture_0x1077c0; // 0x107804 - g_ps2RecompiledFunctionTable[7705] = _decPicture_0x1077c0; // 0x10786c - g_ps2RecompiledFunctionTable[7707] = _decPicture_0x1077c0; // 0x107874 - g_ps2RecompiledFunctionTable[7718] = _outputFrame_0x1078a0; // 0x1078a0 - g_ps2RecompiledFunctionTable[7740] = _outputFrame_0x1078a0; // 0x1078f8 - g_ps2RecompiledFunctionTable[7755] = _outputFrame_0x1078a0; // 0x107934 - g_ps2RecompiledFunctionTable[7764] = _updateRefImage_0x107958; // 0x107958 - g_ps2RecompiledFunctionTable[8012] = _isOutSizeOK_0x107d38; // 0x107d38 - g_ps2RecompiledFunctionTable[8044] = _isOutSizeOK_0x107d38; // 0x107db8 - g_ps2RecompiledFunctionTable[8046] = _isOutSizeOK_0x107d38; // 0x107dc0 - g_ps2RecompiledFunctionTable[8052] = _cpr8_0x107dd8; // 0x107dd8 - g_ps2RecompiledFunctionTable[8096] = _cpr8_0x107dd8; // 0x107e88 - g_ps2RecompiledFunctionTable[8100] = _cpr8_0x107dd8; // 0x107e98 - g_ps2RecompiledFunctionTable[8118] = _cpr8_0x107dd8; // 0x107ee0 - g_ps2RecompiledFunctionTable[8142] = _cpr8_0x107dd8; // 0x107f40 - g_ps2RecompiledFunctionTable[8152] = _cpr8_0x107dd8; // 0x107f68 - g_ps2RecompiledFunctionTable[8176] = _markOutput_0x107fc8; // 0x107fc8 - g_ps2RecompiledFunctionTable[8190] = _getPtsDtsFlags_0x108000; // 0x108000 - g_ps2RecompiledFunctionTable[8224] = _getPtsDtsFlags_0x108000; // 0x108088 - g_ps2RecompiledFunctionTable[8228] = _getPtsDtsFlags_0x108000; // 0x108098 - g_ps2RecompiledFunctionTable[8233] = _getPtsDtsFlags_0x108000; // 0x1080ac - g_ps2RecompiledFunctionTable[8242] = _getPtsDtsFlags_0x108000; // 0x1080d0 - g_ps2RecompiledFunctionTable[8292] = _dispRefImage_0x108198; // 0x108198 - g_ps2RecompiledFunctionTable[8305] = _dispRefImage_0x108198; // 0x1081cc - g_ps2RecompiledFunctionTable[8336] = _dispRefImage_0x108198; // 0x108248 - g_ps2RecompiledFunctionTable[8346] = _dispRefImage_0x108198; // 0x108270 - g_ps2RecompiledFunctionTable[8350] = _dispRefImage_0x108198; // 0x108280 - g_ps2RecompiledFunctionTable[8362] = _dispRefImageField_0x1082b0; // 0x1082b0 - g_ps2RecompiledFunctionTable[8395] = _dispRefImageField_0x1082b0; // 0x108334 - g_ps2RecompiledFunctionTable[8404] = _dispRefImageField_0x1082b0; // 0x108358 - g_ps2RecompiledFunctionTable[8429] = _dispRefImageField_0x1082b0; // 0x1083bc - g_ps2RecompiledFunctionTable[8445] = _dispRefImageField_0x1082b0; // 0x1083fc - g_ps2RecompiledFunctionTable[8449] = _dispRefImageField_0x1082b0; // 0x10840c - g_ps2RecompiledFunctionTable[8474] = _doCSC_0x108470; // 0x108470 - g_ps2RecompiledFunctionTable[8480] = _doCSC_0x108470; // 0x108488 - g_ps2RecompiledFunctionTable[8503] = _doCSC_0x108470; // 0x1084e4 - g_ps2RecompiledFunctionTable[8509] = _doCSC_0x108470; // 0x1084fc - g_ps2RecompiledFunctionTable[8512] = _doCSC_0x108470; // 0x108508 - g_ps2RecompiledFunctionTable[8522] = _doCSC_0x108470; // 0x108530 - g_ps2RecompiledFunctionTable[8532] = _ch3dmaCSC_0x108558; // 0x108558 - g_ps2RecompiledFunctionTable[8578] = _doCSC2_0x108610; // 0x108610 - g_ps2RecompiledFunctionTable[8606] = _doCSC2_0x108610; // 0x108680 - g_ps2RecompiledFunctionTable[8618] = _doCSC2_0x108610; // 0x1086b0 - g_ps2RecompiledFunctionTable[8625] = _doCSC2_0x108610; // 0x1086cc - g_ps2RecompiledFunctionTable[8649] = _doCSC2_0x108610; // 0x10872c - g_ps2RecompiledFunctionTable[8650] = _doCSC2_0x108610; // 0x108730 - g_ps2RecompiledFunctionTable[8663] = _doCSC2_0x108610; // 0x108764 - g_ps2RecompiledFunctionTable[8666] = _doCSC2_0x108610; // 0x108770 - g_ps2RecompiledFunctionTable[8675] = _doCSC2_0x108610; // 0x108794 - g_ps2RecompiledFunctionTable[8678] = _doCSC2_0x108610; // 0x1087a0 - g_ps2RecompiledFunctionTable[8686] = _csc_storeRefImage_0x1087c0; // 0x1087c0 - g_ps2RecompiledFunctionTable[8704] = _csc_storeRefImage_0x1087c0; // 0x108808 - g_ps2RecompiledFunctionTable[8716] = _csc_storeRefImage_0x1087c0; // 0x108838 - g_ps2RecompiledFunctionTable[8725] = _csc_storeRefImage_0x1087c0; // 0x10885c - g_ps2RecompiledFunctionTable[8728] = _csc_storeRefImage_0x1087c0; // 0x108868 - g_ps2RecompiledFunctionTable[8754] = _csc_storeRefImage_0x1087c0; // 0x1088d0 - g_ps2RecompiledFunctionTable[8758] = _csc_storeRefImage_0x1087c0; // 0x1088e0 - g_ps2RecompiledFunctionTable[8763] = _csc_storeRefImage_0x1087c0; // 0x1088f4 - g_ps2RecompiledFunctionTable[8772] = _sysbitInit_0x108918; // 0x108918 - g_ps2RecompiledFunctionTable[8786] = _sysbitNext_0x108950; // 0x108950 - g_ps2RecompiledFunctionTable[8794] = _sysbitFlush_0x108970; // 0x108970 - g_ps2RecompiledFunctionTable[8806] = _sysbitFlush_0x108970; // 0x1089a0 - g_ps2RecompiledFunctionTable[8832] = _sysbitGet_0x108a08; // 0x108a08 - g_ps2RecompiledFunctionTable[8840] = _sysbitGet_0x108a08; // 0x108a28 - g_ps2RecompiledFunctionTable[8844] = _sysbitGet_0x108a08; // 0x108a38 - g_ps2RecompiledFunctionTable[8852] = _sysbitMarker_0x108a58; // 0x108a58 - g_ps2RecompiledFunctionTable[8859] = _sysbitMarker_0x108a58; // 0x108a74 - g_ps2RecompiledFunctionTable[8863] = _sysbitMarker_0x108a58; // 0x108a84 - g_ps2RecompiledFunctionTable[8870] = _sysbitJump_0x108aa0; // 0x108aa0 - g_ps2RecompiledFunctionTable[8892] = _sysbitPtr_0x108af8; // 0x108af8 - g_ps2RecompiledFunctionTable[8904] = _type2id_0x108b28; // 0x108b28 - g_ps2RecompiledFunctionTable[8938] = _id2type_0x108bb0; // 0x108bb0 - g_ps2RecompiledFunctionTable[8982] = _id2type_0x108bb0; // 0x108c60 - g_ps2RecompiledFunctionTable[9066] = sceMpegDemuxPssRing_0x108db0; // 0x108db0 - g_ps2RecompiledFunctionTable[9254] = sceMpegDemuxPss_0x1090a0; // 0x1090a0 - g_ps2RecompiledFunctionTable[9262] = sceMpegAddStrCallback_0x1090c0; // 0x1090c0 - g_ps2RecompiledFunctionTable[9324] = _pack_header_0x1091b8; // 0x1091b8 - g_ps2RecompiledFunctionTable[9338] = _pack_header_0x1091b8; // 0x1091f0 - g_ps2RecompiledFunctionTable[9341] = _pack_header_0x1091b8; // 0x1091fc - g_ps2RecompiledFunctionTable[9344] = _pack_header_0x1091b8; // 0x109208 - g_ps2RecompiledFunctionTable[9347] = _pack_header_0x1091b8; // 0x109214 - g_ps2RecompiledFunctionTable[9350] = _pack_header_0x1091b8; // 0x109220 - g_ps2RecompiledFunctionTable[9353] = _pack_header_0x1091b8; // 0x10922c - g_ps2RecompiledFunctionTable[9356] = _pack_header_0x1091b8; // 0x109238 - g_ps2RecompiledFunctionTable[9359] = _pack_header_0x1091b8; // 0x109244 - g_ps2RecompiledFunctionTable[9363] = _pack_header_0x1091b8; // 0x109254 - g_ps2RecompiledFunctionTable[9366] = _pack_header_0x1091b8; // 0x109260 - g_ps2RecompiledFunctionTable[9378] = _pack_header_0x1091b8; // 0x109290 - g_ps2RecompiledFunctionTable[9380] = _pack_header_0x1091b8; // 0x109298 - g_ps2RecompiledFunctionTable[9387] = _pack_header_0x1091b8; // 0x1092b4 - g_ps2RecompiledFunctionTable[9395] = _pack_header_0x1091b8; // 0x1092d4 - g_ps2RecompiledFunctionTable[9408] = _system_header_0x109308; // 0x109308 - g_ps2RecompiledFunctionTable[9415] = _system_header_0x109308; // 0x109324 - g_ps2RecompiledFunctionTable[9419] = _system_header_0x109308; // 0x109334 - g_ps2RecompiledFunctionTable[9422] = _system_header_0x109308; // 0x109340 - g_ps2RecompiledFunctionTable[9425] = _system_header_0x109308; // 0x10934c - g_ps2RecompiledFunctionTable[9428] = _system_header_0x109308; // 0x109358 - g_ps2RecompiledFunctionTable[9436] = ps2__PES_packet_0x109378; // 0x109378 - g_ps2RecompiledFunctionTable[9453] = ps2__PES_packet_0x109378; // 0x1093bc - g_ps2RecompiledFunctionTable[9456] = ps2__PES_packet_0x109378; // 0x1093c8 - g_ps2RecompiledFunctionTable[9461] = ps2__PES_packet_0x109378; // 0x1093dc - g_ps2RecompiledFunctionTable[9501] = ps2__PES_packet_0x109378; // 0x10947c - g_ps2RecompiledFunctionTable[9504] = ps2__PES_packet_0x109378; // 0x109488 - g_ps2RecompiledFunctionTable[9508] = ps2__PES_packet_0x109378; // 0x109498 - g_ps2RecompiledFunctionTable[9511] = ps2__PES_packet_0x109378; // 0x1094a4 - g_ps2RecompiledFunctionTable[9515] = ps2__PES_packet_0x109378; // 0x1094b4 - g_ps2RecompiledFunctionTable[9519] = ps2__PES_packet_0x109378; // 0x1094c4 - g_ps2RecompiledFunctionTable[9523] = ps2__PES_packet_0x109378; // 0x1094d4 - g_ps2RecompiledFunctionTable[9527] = ps2__PES_packet_0x109378; // 0x1094e4 - g_ps2RecompiledFunctionTable[9537] = ps2__PES_packet_0x109378; // 0x10950c - g_ps2RecompiledFunctionTable[9540] = ps2__PES_packet_0x109378; // 0x109518 - g_ps2RecompiledFunctionTable[9543] = ps2__PES_packet_0x109378; // 0x109524 - g_ps2RecompiledFunctionTable[9546] = ps2__PES_packet_0x109378; // 0x109530 - g_ps2RecompiledFunctionTable[9549] = ps2__PES_packet_0x109378; // 0x10953c - g_ps2RecompiledFunctionTable[9552] = ps2__PES_packet_0x109378; // 0x109548 - g_ps2RecompiledFunctionTable[9555] = ps2__PES_packet_0x109378; // 0x109554 - g_ps2RecompiledFunctionTable[9572] = ps2__PES_packet_0x109378; // 0x109598 - g_ps2RecompiledFunctionTable[9575] = ps2__PES_packet_0x109378; // 0x1095a4 - g_ps2RecompiledFunctionTable[9578] = ps2__PES_packet_0x109378; // 0x1095b0 - g_ps2RecompiledFunctionTable[9581] = ps2__PES_packet_0x109378; // 0x1095bc - g_ps2RecompiledFunctionTable[9584] = ps2__PES_packet_0x109378; // 0x1095c8 - g_ps2RecompiledFunctionTable[9587] = ps2__PES_packet_0x109378; // 0x1095d4 - g_ps2RecompiledFunctionTable[9590] = ps2__PES_packet_0x109378; // 0x1095e0 - g_ps2RecompiledFunctionTable[9607] = ps2__PES_packet_0x109378; // 0x109624 - g_ps2RecompiledFunctionTable[9614] = ps2__PES_packet_0x109378; // 0x109640 - g_ps2RecompiledFunctionTable[9619] = ps2__PES_packet_0x109378; // 0x109654 - g_ps2RecompiledFunctionTable[9623] = ps2__PES_packet_0x109378; // 0x109664 - g_ps2RecompiledFunctionTable[9627] = ps2__PES_packet_0x109378; // 0x109674 - g_ps2RecompiledFunctionTable[9631] = ps2__PES_packet_0x109378; // 0x109684 - g_ps2RecompiledFunctionTable[9635] = ps2__PES_packet_0x109378; // 0x109694 - g_ps2RecompiledFunctionTable[9638] = ps2__PES_packet_0x109378; // 0x1096a0 - g_ps2RecompiledFunctionTable[9643] = ps2__PES_packet_0x109378; // 0x1096b4 - g_ps2RecompiledFunctionTable[9646] = ps2__PES_packet_0x109378; // 0x1096c0 - g_ps2RecompiledFunctionTable[9649] = ps2__PES_packet_0x109378; // 0x1096cc - g_ps2RecompiledFunctionTable[9653] = ps2__PES_packet_0x109378; // 0x1096dc - g_ps2RecompiledFunctionTable[9659] = ps2__PES_packet_0x109378; // 0x1096f4 - g_ps2RecompiledFunctionTable[9663] = ps2__PES_packet_0x109378; // 0x109704 - g_ps2RecompiledFunctionTable[9668] = ps2__PES_packet_0x109378; // 0x109718 - g_ps2RecompiledFunctionTable[9671] = ps2__PES_packet_0x109378; // 0x109724 - g_ps2RecompiledFunctionTable[9676] = ps2__PES_packet_0x109378; // 0x109738 - g_ps2RecompiledFunctionTable[9678] = ps2__PES_packet_0x109378; // 0x109740 - g_ps2RecompiledFunctionTable[9694] = ps2__PES_packet_0x109378; // 0x109780 - g_ps2RecompiledFunctionTable[9708] = ps2__PES_packet_0x109378; // 0x1097b8 - g_ps2RecompiledFunctionTable[9718] = ps2__PES_packet_0x109378; // 0x1097e0 - g_ps2RecompiledFunctionTable[9755] = ps2__PES_packet_0x109378; // 0x109874 - g_ps2RecompiledFunctionTable[9766] = ps2__PES_packet_0x109378; // 0x1098a0 - g_ps2RecompiledFunctionTable[9777] = ps2__PES_packet_0x109378; // 0x1098cc - g_ps2RecompiledFunctionTable[9790] = sceMpegInit_0x109900; // 0x109900 - g_ps2RecompiledFunctionTable[9832] = sceMpegCreate_0x1099a8; // 0x1099a8 - g_ps2RecompiledFunctionTable[9976] = sceMpegDelete_0x109be8; // 0x109be8 - g_ps2RecompiledFunctionTable[9978] = sceMpegAddBs_0x109bf0; // 0x109bf0 - g_ps2RecompiledFunctionTable[9992] = sceMpegGetPicture_0x109c28; // 0x109c28 - g_ps2RecompiledFunctionTable[10010] = sceMpegGetPictureRAW8_0x109c70; // 0x109c70 - g_ps2RecompiledFunctionTable[10028] = sceMpegGetPictureRAW8xy_0x109cb8; // 0x109cb8 - g_ps2RecompiledFunctionTable[10048] = sceMpegSetDecodeMode_0x109d08; // 0x109d08 - g_ps2RecompiledFunctionTable[10054] = sceMpegGetDecodeMode_0x109d20; // 0x109d20 - g_ps2RecompiledFunctionTable[10062] = sceMpegIsEnd_0x109d40; // 0x109d40 - g_ps2RecompiledFunctionTable[10066] = sceMpegIsRefBuffEmpty_0x109d50; // 0x109d50 - g_ps2RecompiledFunctionTable[10070] = sceMpegReset_0x109d60; // 0x109d60 - g_ps2RecompiledFunctionTable[10086] = sceMpegClearRefBuff_0x109da0; // 0x109da0 - g_ps2RecompiledFunctionTable[10112] = sceMpegAddCallback_0x109e08; // 0x109e08 - g_ps2RecompiledFunctionTable[10122] = _dispatchMpegCallback_0x109e30; // 0x109e30 - g_ps2RecompiledFunctionTable[10123] = _dispatchMpegCallback_0x109e30; // 0x109e34 - g_ps2RecompiledFunctionTable[10124] = _dispatchMpegCallback_0x109e30; // 0x109e38 - g_ps2RecompiledFunctionTable[10125] = _dispatchMpegCallback_0x109e30; // 0x109e3c - g_ps2RecompiledFunctionTable[10126] = _dispatchMpegCallback_0x109e30; // 0x109e40 - g_ps2RecompiledFunctionTable[10127] = _dispatchMpegCallback_0x109e30; // 0x109e44 - g_ps2RecompiledFunctionTable[10128] = _dispatchMpegCallback_0x109e30; // 0x109e48 - g_ps2RecompiledFunctionTable[10129] = _dispatchMpegCallback_0x109e30; // 0x109e4c - g_ps2RecompiledFunctionTable[10130] = _dispatchMpegCallback_0x109e30; // 0x109e50 - g_ps2RecompiledFunctionTable[10131] = _dispatchMpegCallback_0x109e30; // 0x109e54 - g_ps2RecompiledFunctionTable[10132] = _dispatchMpegCallback_0x109e30; // 0x109e58 - g_ps2RecompiledFunctionTable[10133] = _dispatchMpegCallback_0x109e30; // 0x109e5c - g_ps2RecompiledFunctionTable[10134] = _dispatchMpegCallback_0x109e30; // 0x109e60 - g_ps2RecompiledFunctionTable[10135] = _dispatchMpegCallback_0x109e30; // 0x109e64 - g_ps2RecompiledFunctionTable[10136] = _dispatchMpegCallback_0x109e30; // 0x109e68 - g_ps2RecompiledFunctionTable[10137] = _dispatchMpegCallback_0x109e30; // 0x109e6c - g_ps2RecompiledFunctionTable[10138] = _dispatchMpegCallback_0x109e30; // 0x109e70 - g_ps2RecompiledFunctionTable[10139] = _dispatchMpegCallback_0x109e30; // 0x109e74 - g_ps2RecompiledFunctionTable[10140] = _dispatchMpegCallback_0x109e30; // 0x109e78 - g_ps2RecompiledFunctionTable[10141] = _dispatchMpegCallback_0x109e30; // 0x109e7c - g_ps2RecompiledFunctionTable[10142] = _dispatchMpegCbNodata_0x109e80; // 0x109e80 - g_ps2RecompiledFunctionTable[10148] = _dispatchMpegCbNodata_0x109e80; // 0x109e98 - g_ps2RecompiledFunctionTable[10152] = sceMpegSetDefaultPtsGap_0x109ea8; // 0x109ea8 - g_ps2RecompiledFunctionTable[10158] = sceMpegResetDefaultPtsGap_0x109ec0; // 0x109ec0 - g_ps2RecompiledFunctionTable[10162] = sceMpegSetImageBuff_0x109ed0; // 0x109ed0 - g_ps2RecompiledFunctionTable[10168] = sceMpegDispWidth_0x109ee8; // 0x109ee8 - g_ps2RecompiledFunctionTable[10172] = sceMpegDispHeight_0x109ef8; // 0x109ef8 - g_ps2RecompiledFunctionTable[10176] = sceMpegDispCenterOffX_0x109f08; // 0x109f08 - g_ps2RecompiledFunctionTable[10180] = sceMpegDispCenterOffY_0x109f18; // 0x109f18 - g_ps2RecompiledFunctionTable[10184] = sceSetBrokenLink_0x109f28; // 0x109f28 - g_ps2RecompiledFunctionTable[10188] = sceSetPtm_0x109f38; // 0x109f38 - g_ps2RecompiledFunctionTable[10194] = _alalcInit_0x109f50; // 0x109f50 - g_ps2RecompiledFunctionTable[10200] = _alalcSetDynamic_0x109f68; // 0x109f68 - g_ps2RecompiledFunctionTable[10204] = _alalcFree_0x109f78; // 0x109f78 - g_ps2RecompiledFunctionTable[10208] = _alalcAlloc_0x109f88; // 0x109f88 - g_ps2RecompiledFunctionTable[10230] = _alalcAlloc_0x109f88; // 0x109fe0 - g_ps2RecompiledFunctionTable[10234] = _alalcRest_0x109ff0; // 0x109ff0 - g_ps2RecompiledFunctionTable[10240] = _getpic_0x10a008; // 0x10a008 - g_ps2RecompiledFunctionTable[10259] = _getpic_0x10a008; // 0x10a054 - g_ps2RecompiledFunctionTable[10264] = _getpic_0x10a008; // 0x10a068 - g_ps2RecompiledFunctionTable[10268] = _getpic_0x10a008; // 0x10a078 - g_ps2RecompiledFunctionTable[10270] = _getpic_0x10a008; // 0x10a080 - g_ps2RecompiledFunctionTable[10287] = _getpic_0x10a008; // 0x10a0c4 - g_ps2RecompiledFunctionTable[10297] = _getpic_0x10a008; // 0x10a0ec - g_ps2RecompiledFunctionTable[10306] = _getpic_0x10a008; // 0x10a110 - g_ps2RecompiledFunctionTable[10315] = _getpic_0x10a008; // 0x10a134 - g_ps2RecompiledFunctionTable[10332] = _decodeOrSkipFrame_0x10a178; // 0x10a178 - g_ps2RecompiledFunctionTable[10354] = _decodeOrSkipFrame_0x10a178; // 0x10a1d0 - g_ps2RecompiledFunctionTable[10360] = _decodeOrSkipFrame_0x10a178; // 0x10a1e8 - g_ps2RecompiledFunctionTable[10367] = _decodeOrSkipFrame_0x10a178; // 0x10a204 - g_ps2RecompiledFunctionTable[10371] = _decodeOrSkipFrame_0x10a178; // 0x10a214 - g_ps2RecompiledFunctionTable[10374] = _decodeOrSkipFrame_0x10a178; // 0x10a220 - g_ps2RecompiledFunctionTable[10406] = _decodeOrSkip_0x10a2a0; // 0x10a2a0 - g_ps2RecompiledFunctionTable[10414] = _decodeOrSkip_0x10a2a0; // 0x10a2c0 - g_ps2RecompiledFunctionTable[10418] = _decodeOrSkip_0x10a2a0; // 0x10a2d0 - g_ps2RecompiledFunctionTable[10422] = _decodeOrSkipField_0x10a2e0; // 0x10a2e0 - g_ps2RecompiledFunctionTable[10449] = _decodeOrSkipField_0x10a2e0; // 0x10a34c - g_ps2RecompiledFunctionTable[10457] = _decodeOrSkipField_0x10a2e0; // 0x10a36c - g_ps2RecompiledFunctionTable[10460] = _decodeOrSkipField_0x10a2e0; // 0x10a378 - g_ps2RecompiledFunctionTable[10464] = _decodeOrSkipField_0x10a2e0; // 0x10a388 - g_ps2RecompiledFunctionTable[10477] = _decodeOrSkipField_0x10a2e0; // 0x10a3bc - g_ps2RecompiledFunctionTable[10486] = _decodeOrSkipField_0x10a2e0; // 0x10a3e0 - g_ps2RecompiledFunctionTable[10490] = _decodeOrSkipField_0x10a2e0; // 0x10a3f0 - g_ps2RecompiledFunctionTable[10503] = _decodeOrSkipField_0x10a2e0; // 0x10a424 - g_ps2RecompiledFunctionTable[10514] = _sceMpegFlush_0x10a450; // 0x10a450 - g_ps2RecompiledFunctionTable[10542] = _initSeqAgain_0x10a4c0; // 0x10a4c0 - g_ps2RecompiledFunctionTable[10546] = _lastFrame_0x10a4d0; // 0x10a4d0 - g_ps2RecompiledFunctionTable[10556] = _lastFrame_0x10a4d0; // 0x10a4f8 - g_ps2RecompiledFunctionTable[10567] = _lastFrame_0x10a4d0; // 0x10a524 - g_ps2RecompiledFunctionTable[10574] = _lastFrame_0x10a4d0; // 0x10a540 - g_ps2RecompiledFunctionTable[10580] = _clearOnce_0x10a558; // 0x10a558 - g_ps2RecompiledFunctionTable[10584] = _clearOnce_0x10a558; // 0x10a568 - g_ps2RecompiledFunctionTable[10600] = _clearEach_0x10a5a8; // 0x10a5a8 - g_ps2RecompiledFunctionTable[10606] = _clearEach_0x10a5a8; // 0x10a5c0 - g_ps2RecompiledFunctionTable[10652] = ps2__ErrMessage_0x10a678; // 0x10a678 - g_ps2RecompiledFunctionTable[10656] = ps2__Error1_0x10a688; // 0x10a688 - g_ps2RecompiledFunctionTable[10662] = ps2__Error1_0x10a688; // 0x10a6a0 - g_ps2RecompiledFunctionTable[10664] = ps2__Error1_0x10a688; // 0x10a6a8 - g_ps2RecompiledFunctionTable[10668] = ps2__Error_0x10a6b8; // 0x10a6b8 - g_ps2RecompiledFunctionTable[10683] = ps2__Error_0x10a6b8; // 0x10a6f4 - g_ps2RecompiledFunctionTable[10687] = ps2__Error_0x10a6b8; // 0x10a704 - g_ps2RecompiledFunctionTable[10690] = _sendDataToIPU_0x10a710; // 0x10a710 - g_ps2RecompiledFunctionTable[10706] = _sendDataToIPU_0x10a710; // 0x10a750 - g_ps2RecompiledFunctionTable[10744] = ps2__RefImageInit_0x10a7e8; // 0x10a7e8 - g_ps2RecompiledFunctionTable[10752] = _sequenceHeader_0x10a808; // 0x10a808 - g_ps2RecompiledFunctionTable[10762] = _sequenceHeader_0x10a808; // 0x10a830 - g_ps2RecompiledFunctionTable[10782] = _sequenceHeader_0x10a808; // 0x10a880 - g_ps2RecompiledFunctionTable[10785] = _sequenceHeader_0x10a808; // 0x10a88c - g_ps2RecompiledFunctionTable[10798] = _sequenceHeader_0x10a808; // 0x10a8c0 - g_ps2RecompiledFunctionTable[10802] = _sequenceHeader_0x10a808; // 0x10a8d0 - g_ps2RecompiledFunctionTable[10804] = _sequenceHeader_0x10a808; // 0x10a8d8 - g_ps2RecompiledFunctionTable[10806] = _sequenceHeader_0x10a808; // 0x10a8e0 - g_ps2RecompiledFunctionTable[10812] = _sequenceHeader_0x10a808; // 0x10a8f8 - g_ps2RecompiledFunctionTable[10815] = _sequenceHeader_0x10a808; // 0x10a904 - g_ps2RecompiledFunctionTable[10819] = _sequenceHeader_0x10a808; // 0x10a914 - g_ps2RecompiledFunctionTable[10821] = _sequenceHeader_0x10a808; // 0x10a91c - g_ps2RecompiledFunctionTable[10823] = _sequenceHeader_0x10a808; // 0x10a924 - g_ps2RecompiledFunctionTable[10829] = _sequenceHeader_0x10a808; // 0x10a93c - g_ps2RecompiledFunctionTable[10831] = _sequenceHeader_0x10a808; // 0x10a944 - g_ps2RecompiledFunctionTable[10838] = _initSeq_0x10a960; // 0x10a960 - g_ps2RecompiledFunctionTable[10920] = _initSeq_0x10a960; // 0x10aaa8 - g_ps2RecompiledFunctionTable[10924] = _initSeq_0x10a960; // 0x10aab8 - g_ps2RecompiledFunctionTable[10929] = _initSeq_0x10a960; // 0x10aacc - g_ps2RecompiledFunctionTable[10934] = _initSeq_0x10a960; // 0x10aae0 - g_ps2RecompiledFunctionTable[10968] = _initSeq_0x10a960; // 0x10ab68 - g_ps2RecompiledFunctionTable[10972] = _initSeq_0x10a960; // 0x10ab78 - g_ps2RecompiledFunctionTable[10976] = _initSeq_0x10a960; // 0x10ab88 - g_ps2RecompiledFunctionTable[10980] = _initSeq_0x10a960; // 0x10ab98 - g_ps2RecompiledFunctionTable[10987] = _initSeq_0x10a960; // 0x10abb4 - g_ps2RecompiledFunctionTable[10994] = _initSeq_0x10a960; // 0x10abd0 - g_ps2RecompiledFunctionTable[11001] = _initSeq_0x10a960; // 0x10abec - g_ps2RecompiledFunctionTable[11009] = _initSeq_0x10a960; // 0x10ac0c - g_ps2RecompiledFunctionTable[11017] = _initSeq_0x10a960; // 0x10ac2c - g_ps2RecompiledFunctionTable[11048] = _initRefImages_0x10aca8; // 0x10aca8 - g_ps2RecompiledFunctionTable[11106] = _setDefaultQM_0x10ad90; // 0x10ad90 - g_ps2RecompiledFunctionTable[11119] = _setDefaultQM_0x10ad90; // 0x10adc4 - g_ps2RecompiledFunctionTable[11121] = _setDefaultQM_0x10ad90; // 0x10adcc - g_ps2RecompiledFunctionTable[11125] = _setDefaultQM_0x10ad90; // 0x10addc - g_ps2RecompiledFunctionTable[11141] = _setDefaultQM_0x10ad90; // 0x10ae1c - g_ps2RecompiledFunctionTable[11143] = _setDefaultQM_0x10ad90; // 0x10ae24 - g_ps2RecompiledFunctionTable[11148] = _setDefaultQM_0x10ad90; // 0x10ae38 - g_ps2RecompiledFunctionTable[11154] = _sequenceExtension_0x10ae50; // 0x10ae50 - g_ps2RecompiledFunctionTable[11166] = _sequenceExtension_0x10ae50; // 0x10ae80 - g_ps2RecompiledFunctionTable[11168] = _sequenceExtension_0x10ae50; // 0x10ae88 - g_ps2RecompiledFunctionTable[11183] = _sequenceExtension_0x10ae50; // 0x10aec4 - g_ps2RecompiledFunctionTable[11192] = _sequenceExtension_0x10ae50; // 0x10aee8 - g_ps2RecompiledFunctionTable[11213] = _sequenceExtension_0x10ae50; // 0x10af3c - g_ps2RecompiledFunctionTable[11244] = _sequenceDisplayExtension_0x10afb8; // 0x10afb8 - g_ps2RecompiledFunctionTable[11252] = _sequenceDisplayExtension_0x10afb8; // 0x10afd8 - g_ps2RecompiledFunctionTable[11255] = _sequenceDisplayExtension_0x10afb8; // 0x10afe4 - g_ps2RecompiledFunctionTable[11260] = _sequenceDisplayExtension_0x10afb8; // 0x10aff8 - g_ps2RecompiledFunctionTable[11264] = _sequenceDisplayExtension_0x10afb8; // 0x10b008 - g_ps2RecompiledFunctionTable[11268] = _sequenceDisplayExtension_0x10afb8; // 0x10b018 - g_ps2RecompiledFunctionTable[11272] = _sequenceDisplayExtension_0x10afb8; // 0x10b028 - g_ps2RecompiledFunctionTable[11276] = _sequenceDisplayExtension_0x10afb8; // 0x10b038 - g_ps2RecompiledFunctionTable[11278] = _sequenceDisplayExtension_0x10afb8; // 0x10b040 - g_ps2RecompiledFunctionTable[11284] = _sequenceScalableExtension_0x10b058; // 0x10b058 - g_ps2RecompiledFunctionTable[11288] = _unknown_extension_0x10b068; // 0x10b068 - g_ps2RecompiledFunctionTable[11292] = _pictureSpatialScalableExtension_0x10b078; // 0x10b078 - g_ps2RecompiledFunctionTable[11296] = _pictureTemporalScalableExtension_0x10b088; // 0x10b088 - g_ps2RecompiledFunctionTable[11300] = _defStopDMA_0x10b098; // 0x10b098 - g_ps2RecompiledFunctionTable[11304] = _defRestartDMA_0x10b0a8; // 0x10b0a8 - g_ps2RecompiledFunctionTable[11308] = sceIpuStopDMA_0x10b0b8; // 0x10b0b8 - g_ps2RecompiledFunctionTable[11404] = sceIpuRestartDMA_0x10b238; // 0x10b238 - g_ps2RecompiledFunctionTable[11520] = sceIpuSync_0x10b408; // 0x10b408 - g_ps2RecompiledFunctionTable[11546] = sceIpuInit_0x10b470; // 0x10b470 - g_ps2RecompiledFunctionTable[11726] = RFU000_FullReset_0x10b740; // 0x10b740 - g_ps2RecompiledFunctionTable[11730] = ResetEE_0x10b750; // 0x10b750 - g_ps2RecompiledFunctionTable[11734] = SetGsCrt_0x10b760; // 0x10b760 - g_ps2RecompiledFunctionTable[11738] = RFU003_0x10b770; // 0x10b770 - g_ps2RecompiledFunctionTable[11742] = Exit_0x10b780; // 0x10b780 - g_ps2RecompiledFunctionTable[11746] = RFU005_0x10b790; // 0x10b790 - g_ps2RecompiledFunctionTable[11750] = LoadExecPS2_0x10b7a0; // 0x10b7a0 - g_ps2RecompiledFunctionTable[11754] = ExecPS2_0x10b7b0; // 0x10b7b0 - g_ps2RecompiledFunctionTable[11758] = RFU008_0x10b7c0; // 0x10b7c0 - g_ps2RecompiledFunctionTable[11762] = RFU009_0x10b7d0; // 0x10b7d0 - g_ps2RecompiledFunctionTable[11766] = AddSbusIntcHandler_0x10b7e0; // 0x10b7e0 - g_ps2RecompiledFunctionTable[11770] = RemoveSbusIntcHandler_0x10b7f0; // 0x10b7f0 - g_ps2RecompiledFunctionTable[11774] = Interrupt2Iop_0x10b800; // 0x10b800 - g_ps2RecompiledFunctionTable[11778] = SetVTLBRefillHandler_0x10b810; // 0x10b810 - g_ps2RecompiledFunctionTable[11782] = SetVCommonHandler_0x10b820; // 0x10b820 - g_ps2RecompiledFunctionTable[11786] = SetVInterruptHandler_0x10b830; // 0x10b830 - g_ps2RecompiledFunctionTable[11790] = AddIntcHandler_0x10b840; // 0x10b840 - g_ps2RecompiledFunctionTable[11794] = AddIntcHandler2_0x10b850; // 0x10b850 - g_ps2RecompiledFunctionTable[11798] = RemoveIntcHandler_0x10b860; // 0x10b860 - g_ps2RecompiledFunctionTable[11802] = AddDmacHandler_0x10b870; // 0x10b870 - g_ps2RecompiledFunctionTable[11806] = AddDmacHandler2_0x10b880; // 0x10b880 - g_ps2RecompiledFunctionTable[11810] = RemoveDmacHandler_0x10b890; // 0x10b890 - g_ps2RecompiledFunctionTable[11814] = ps2__EnableIntc_0x10b8a0; // 0x10b8a0 - g_ps2RecompiledFunctionTable[11818] = ps2__DisableIntc_0x10b8b0; // 0x10b8b0 - g_ps2RecompiledFunctionTable[11822] = ps2__EnableDmac_0x10b8c0; // 0x10b8c0 - g_ps2RecompiledFunctionTable[11826] = ps2__DisableDmac_0x10b8d0; // 0x10b8d0 - g_ps2RecompiledFunctionTable[11830] = ps2__SetAlarm_0x10b8e0; // 0x10b8e0 - g_ps2RecompiledFunctionTable[11834] = ps2__ReleaseAlarm_0x10b8f0; // 0x10b8f0 - g_ps2RecompiledFunctionTable[11838] = _iEnableIntc_0x10b900; // 0x10b900 - g_ps2RecompiledFunctionTable[11842] = _iDisableIntc_0x10b910; // 0x10b910 - g_ps2RecompiledFunctionTable[11846] = _iEnableDmac_0x10b920; // 0x10b920 - g_ps2RecompiledFunctionTable[11850] = _iDisableDmac_0x10b930; // 0x10b930 - g_ps2RecompiledFunctionTable[11854] = _iSetAlarm_0x10b940; // 0x10b940 - g_ps2RecompiledFunctionTable[11858] = _iReleaseAlarm_0x10b950; // 0x10b950 - g_ps2RecompiledFunctionTable[11862] = CreateThread_0x10b960; // 0x10b960 - g_ps2RecompiledFunctionTable[11866] = DeleteThread_0x10b970; // 0x10b970 - g_ps2RecompiledFunctionTable[11870] = StartThread_0x10b980; // 0x10b980 - g_ps2RecompiledFunctionTable[11874] = ExitThread_0x10b990; // 0x10b990 - g_ps2RecompiledFunctionTable[11878] = ExitDeleteThread_0x10b9a0; // 0x10b9a0 - g_ps2RecompiledFunctionTable[11882] = TerminateThread_0x10b9b0; // 0x10b9b0 - g_ps2RecompiledFunctionTable[11886] = iTerminateThread_0x10b9c0; // 0x10b9c0 - g_ps2RecompiledFunctionTable[11890] = DisableDispatchThread_0x10b9d0; // 0x10b9d0 - g_ps2RecompiledFunctionTable[11894] = EnableDispatchThread_0x10b9e0; // 0x10b9e0 - g_ps2RecompiledFunctionTable[11898] = ChangeThreadPriority_0x10b9f0; // 0x10b9f0 - g_ps2RecompiledFunctionTable[11902] = iChangeThreadPriority_0x10ba00; // 0x10ba00 - g_ps2RecompiledFunctionTable[11906] = RotateThreadReadyQueue_0x10ba10; // 0x10ba10 - g_ps2RecompiledFunctionTable[11910] = _iRotateThreadReadyQueue_0x10ba20; // 0x10ba20 - g_ps2RecompiledFunctionTable[11914] = ReleaseWaitThread_0x10ba30; // 0x10ba30 - g_ps2RecompiledFunctionTable[11918] = iReleaseWaitThread_0x10ba40; // 0x10ba40 - g_ps2RecompiledFunctionTable[11922] = GetThreadId_0x10ba50; // 0x10ba50 - g_ps2RecompiledFunctionTable[11926] = ReferThreadStatus_0x10ba60; // 0x10ba60 - g_ps2RecompiledFunctionTable[11930] = iReferThreadStatus_0x10ba70; // 0x10ba70 - g_ps2RecompiledFunctionTable[11934] = SleepThread_0x10ba80; // 0x10ba80 - g_ps2RecompiledFunctionTable[11938] = WakeupThread_0x10ba90; // 0x10ba90 - g_ps2RecompiledFunctionTable[11942] = _iWakeupThread_0x10baa0; // 0x10baa0 - g_ps2RecompiledFunctionTable[11946] = CancelWakeupThread_0x10bab0; // 0x10bab0 - g_ps2RecompiledFunctionTable[11950] = iCancelWakeupThread_0x10bac0; // 0x10bac0 - g_ps2RecompiledFunctionTable[11954] = SuspendThread_0x10bad0; // 0x10bad0 - g_ps2RecompiledFunctionTable[11958] = _iSuspendThread_0x10bae0; // 0x10bae0 - g_ps2RecompiledFunctionTable[11962] = ResumeThread_0x10baf0; // 0x10baf0 - g_ps2RecompiledFunctionTable[11966] = iResumeThread_0x10bb00; // 0x10bb00 - g_ps2RecompiledFunctionTable[11970] = JoinThread_0x10bb10; // 0x10bb10 - g_ps2RecompiledFunctionTable[11974] = RFU060_0x10bb20; // 0x10bb20 - g_ps2RecompiledFunctionTable[11978] = RFU061_0x10bb30; // 0x10bb30 - g_ps2RecompiledFunctionTable[11982] = EndOfHeap_0x10bb40; // 0x10bb40 - g_ps2RecompiledFunctionTable[11986] = RFU063_0x10bb50; // 0x10bb50 - g_ps2RecompiledFunctionTable[11990] = CreateSema_0x10bb60; // 0x10bb60 - g_ps2RecompiledFunctionTable[11994] = DeleteSema_0x10bb70; // 0x10bb70 - g_ps2RecompiledFunctionTable[11998] = SignalSema_0x10bb80; // 0x10bb80 - g_ps2RecompiledFunctionTable[12002] = iSignalSema_0x10bb90; // 0x10bb90 - g_ps2RecompiledFunctionTable[12006] = WaitSema_0x10bba0; // 0x10bba0 - g_ps2RecompiledFunctionTable[12010] = PollSema_0x10bbb0; // 0x10bbb0 - g_ps2RecompiledFunctionTable[12014] = iPollSema_0x10bbc0; // 0x10bbc0 - g_ps2RecompiledFunctionTable[12018] = ReferSemaStatus_0x10bbd0; // 0x10bbd0 - g_ps2RecompiledFunctionTable[12022] = iReferSemaStatus_0x10bbe0; // 0x10bbe0 - g_ps2RecompiledFunctionTable[12026] = RFU073_0x10bbf0; // 0x10bbf0 - g_ps2RecompiledFunctionTable[12030] = SetOsdConfigParam_0x10bc00; // 0x10bc00 - g_ps2RecompiledFunctionTable[12034] = GetOsdConfigParam_0x10bc10; // 0x10bc10 - g_ps2RecompiledFunctionTable[12038] = GetGsHParam_0x10bc20; // 0x10bc20 - g_ps2RecompiledFunctionTable[12042] = GetGsVParam_0x10bc30; // 0x10bc30 - g_ps2RecompiledFunctionTable[12046] = SetGsHParam_0x10bc40; // 0x10bc40 - g_ps2RecompiledFunctionTable[12050] = SetGsVParam_0x10bc50; // 0x10bc50 - g_ps2RecompiledFunctionTable[12054] = RFU080_CreateEventFlag_0x10bc60; // 0x10bc60 - g_ps2RecompiledFunctionTable[12058] = RFU081_DeleteEventFlag_0x10bc70; // 0x10bc70 - g_ps2RecompiledFunctionTable[12062] = RFU082_SetEventFlag_0x10bc80; // 0x10bc80 - g_ps2RecompiledFunctionTable[12066] = RFU083_iSetEventFlag_0x10bc90; // 0x10bc90 - g_ps2RecompiledFunctionTable[12070] = RFU084_ClearEventFlag_0x10bca0; // 0x10bca0 - g_ps2RecompiledFunctionTable[12074] = RFU085_iClearEventFlag_0x10bcb0; // 0x10bcb0 - g_ps2RecompiledFunctionTable[12078] = RFU086_WaitEvnetFlag_0x10bcc0; // 0x10bcc0 - g_ps2RecompiledFunctionTable[12082] = RFU087_PollEvnetFlag_0x10bcd0; // 0x10bcd0 - g_ps2RecompiledFunctionTable[12086] = RFU088_iPollEvnetFlag_0x10bce0; // 0x10bce0 - g_ps2RecompiledFunctionTable[12090] = RFU089_ReferEventFlagStatus_0x10bcf0; // 0x10bcf0 - g_ps2RecompiledFunctionTable[12094] = RFU090_iReferEventFlagStatus_0x10bd00; // 0x10bd00 - g_ps2RecompiledFunctionTable[12098] = RFU091_0x10bd10; // 0x10bd10 - g_ps2RecompiledFunctionTable[12102] = EnableIntcHandler_0x10bd20; // 0x10bd20 - g_ps2RecompiledFunctionTable[12106] = iEnableIntcHandler_0x10bd30; // 0x10bd30 - g_ps2RecompiledFunctionTable[12110] = DisableIntcHandler_0x10bd40; // 0x10bd40 - g_ps2RecompiledFunctionTable[12114] = iDisableIntcHandler_0x10bd50; // 0x10bd50 - g_ps2RecompiledFunctionTable[12118] = EnableDmacHandler_0x10bd60; // 0x10bd60 - g_ps2RecompiledFunctionTable[12122] = iEnableDmacHandler_0x10bd70; // 0x10bd70 - g_ps2RecompiledFunctionTable[12126] = DisableDmacHandler_0x10bd80; // 0x10bd80 - g_ps2RecompiledFunctionTable[12130] = iDisableDmacHandler_0x10bd90; // 0x10bd90 - g_ps2RecompiledFunctionTable[12134] = KSeg0_0x10bda0; // 0x10bda0 - g_ps2RecompiledFunctionTable[12138] = EnableCache_0x10bdb0; // 0x10bdb0 - g_ps2RecompiledFunctionTable[12142] = DisableCache_0x10bdc0; // 0x10bdc0 - g_ps2RecompiledFunctionTable[12146] = GetCop0_0x10bdd0; // 0x10bdd0 - g_ps2RecompiledFunctionTable[12150] = FlushCache_0x10bde0; // 0x10bde0 - g_ps2RecompiledFunctionTable[12154] = CpuConfig_0x10bdf0; // 0x10bdf0 - g_ps2RecompiledFunctionTable[12158] = iGetCop0_0x10be00; // 0x10be00 - g_ps2RecompiledFunctionTable[12162] = iFlushCache_0x10be10; // 0x10be10 - g_ps2RecompiledFunctionTable[12166] = iCpuConfig_0x10be20; // 0x10be20 - g_ps2RecompiledFunctionTable[12170] = sceSifStopDma_0x10be30; // 0x10be30 - g_ps2RecompiledFunctionTable[12174] = SetCPUTimerHandler_0x10be40; // 0x10be40 - g_ps2RecompiledFunctionTable[12178] = SetCPUTimer_0x10be50; // 0x10be50 - g_ps2RecompiledFunctionTable[12182] = SetOsdConfigParam2_0x10be60; // 0x10be60 - g_ps2RecompiledFunctionTable[12186] = GetOsdConfigParam2_0x10be70; // 0x10be70 - g_ps2RecompiledFunctionTable[12190] = GsGetIMR_0x10be80; // 0x10be80 - g_ps2RecompiledFunctionTable[12194] = iGsGetIMR_0x10be90; // 0x10be90 - g_ps2RecompiledFunctionTable[12198] = GsPutIMR_0x10bea0; // 0x10bea0 - g_ps2RecompiledFunctionTable[12202] = iGsPutIMR_0x10beb0; // 0x10beb0 - g_ps2RecompiledFunctionTable[12206] = SetPgifHandler_0x10bec0; // 0x10bec0 - g_ps2RecompiledFunctionTable[12210] = SetVSyncFlag_0x10bed0; // 0x10bed0 - g_ps2RecompiledFunctionTable[12214] = RFU116_0x10bee0; // 0x10bee0 - g_ps2RecompiledFunctionTable[12218] = print_0x10bef0; // 0x10bef0 - g_ps2RecompiledFunctionTable[12222] = sceSifDmaStat_0x10bf00; // 0x10bf00 - g_ps2RecompiledFunctionTable[12226] = isceSifDmaStat_0x10bf10; // 0x10bf10 - g_ps2RecompiledFunctionTable[12230] = sceSifSetDma_0x10bf20; // 0x10bf20 - g_ps2RecompiledFunctionTable[12234] = isceSifSetDma_0x10bf30; // 0x10bf30 - g_ps2RecompiledFunctionTable[12238] = sceSifSetDChain_0x10bf40; // 0x10bf40 - g_ps2RecompiledFunctionTable[12242] = isceSifSetDChain_0x10bf50; // 0x10bf50 - g_ps2RecompiledFunctionTable[12246] = sceSifSetReg_0x10bf60; // 0x10bf60 - g_ps2RecompiledFunctionTable[12250] = sceSifGetReg_0x10bf70; // 0x10bf70 - g_ps2RecompiledFunctionTable[12254] = ExecOSD_0x10bf80; // 0x10bf80 - g_ps2RecompiledFunctionTable[12258] = Deci2Call_0x10bf90; // 0x10bf90 - g_ps2RecompiledFunctionTable[12262] = PSMode_0x10bfa0; // 0x10bfa0 - g_ps2RecompiledFunctionTable[12266] = MachineType_0x10bfb0; // 0x10bfb0 - g_ps2RecompiledFunctionTable[12270] = GetMemorySize_0x10bfc0; // 0x10bfc0 - g_ps2RecompiledFunctionTable[12274] = sceResetttyinit_0x10bfd0; // 0x10bfd0 - g_ps2RecompiledFunctionTable[12278] = VSync_0x10bfe0; // 0x10bfe0 - g_ps2RecompiledFunctionTable[12282] = VSync_0x10bfe0; // 0x10bff0 - g_ps2RecompiledFunctionTable[12294] = VSync2_0x10c020; // 0x10c020 - g_ps2RecompiledFunctionTable[12299] = VSync2_0x10c020; // 0x10c034 - g_ps2RecompiledFunctionTable[12304] = VSync2_0x10c020; // 0x10c048 - g_ps2RecompiledFunctionTable[12318] = write_0x10c080; // 0x10c080 - g_ps2RecompiledFunctionTable[12350] = read_0x10c100; // 0x10c100 - g_ps2RecompiledFunctionTable[12380] = open_0x10c178; // 0x10c178 - g_ps2RecompiledFunctionTable[12390] = close_0x10c1a0; // 0x10c1a0 - g_ps2RecompiledFunctionTable[12392] = ioctl_0x10c1a8; // 0x10c1a8 - g_ps2RecompiledFunctionTable[12394] = lseek_0x10c1b0; // 0x10c1b0 - g_ps2RecompiledFunctionTable[12396] = sbrk_0x10c1b8; // 0x10c1b8 - g_ps2RecompiledFunctionTable[12406] = sbrk_0x10c1b8; // 0x10c1e0 - g_ps2RecompiledFunctionTable[12418] = sbrk_0x10c1b8; // 0x10c210 - g_ps2RecompiledFunctionTable[12423] = sbrk_0x10c1b8; // 0x10c224 - g_ps2RecompiledFunctionTable[12440] = isatty_0x10c268; // 0x10c268 - g_ps2RecompiledFunctionTable[12442] = fstat_0x10c270; // 0x10c270 - g_ps2RecompiledFunctionTable[12448] = getpid_0x10c288; // 0x10c288 - g_ps2RecompiledFunctionTable[12450] = kill_0x10c290; // 0x10c290 - g_ps2RecompiledFunctionTable[12456] = kill_0x10c290; // 0x10c2a8 - g_ps2RecompiledFunctionTable[12460] = stat_0x10c2b8; // 0x10c2b8 - g_ps2RecompiledFunctionTable[12470] = unlink_0x10c2e0; // 0x10c2e0 - g_ps2RecompiledFunctionTable[12474] = unlink_0x10c2e0; // 0x10c2f0 - g_ps2RecompiledFunctionTable[12480] = putnum_0x10c308; // 0x10c308 - g_ps2RecompiledFunctionTable[12484] = putnum_0x10c308; // 0x10c318 - g_ps2RecompiledFunctionTable[12498] = putnum_0x10c308; // 0x10c350 - g_ps2RecompiledFunctionTable[12502] = get_mem_info_0x10c360; // 0x10c360 - g_ps2RecompiledFunctionTable[12508] = _sceSDC_0x10c378; // 0x10c378 - g_ps2RecompiledFunctionTable[12550] = SyncDCache_0x10c420; // 0x10c420 - g_ps2RecompiledFunctionTable[12560] = SyncDCache_0x10c420; // 0x10c448 - g_ps2RecompiledFunctionTable[12572] = SyncDCache_0x10c420; // 0x10c478 - g_ps2RecompiledFunctionTable[12580] = iSyncDCache_0x10c498; // 0x10c498 - g_ps2RecompiledFunctionTable[12586] = _sceIDC_0x10c4b0; // 0x10c4b0 - g_ps2RecompiledFunctionTable[12628] = InvalidDCache_0x10c558; // 0x10c558 - g_ps2RecompiledFunctionTable[12638] = InvalidDCache_0x10c558; // 0x10c580 - g_ps2RecompiledFunctionTable[12650] = InvalidDCache_0x10c558; // 0x10c5b0 - g_ps2RecompiledFunctionTable[12658] = iInvalidDCache_0x10c5d0; // 0x10c5d0 - g_ps2RecompiledFunctionTable[12664] = DisableIntc_0x10c5e8; // 0x10c5e8 - g_ps2RecompiledFunctionTable[12690] = EnableIntc_0x10c650; // 0x10c650 - g_ps2RecompiledFunctionTable[12716] = DisableDmac_0x10c6b8; // 0x10c6b8 - g_ps2RecompiledFunctionTable[12742] = EnableDmac_0x10c720; // 0x10c720 - g_ps2RecompiledFunctionTable[12768] = SetAlarm_0x10c788; // 0x10c788 - g_ps2RecompiledFunctionTable[12796] = ReleaseAlarm_0x10c7f8; // 0x10c7f8 - g_ps2RecompiledFunctionTable[12822] = iEnableIntc_0x10c860; // 0x10c860 - g_ps2RecompiledFunctionTable[12830] = iDisableIntc_0x10c880; // 0x10c880 - g_ps2RecompiledFunctionTable[12838] = iEnableDmac_0x10c8a0; // 0x10c8a0 - g_ps2RecompiledFunctionTable[12846] = iDisableDmac_0x10c8c0; // 0x10c8c0 - g_ps2RecompiledFunctionTable[12854] = iSetAlarm_0x10c8e0; // 0x10c8e0 - g_ps2RecompiledFunctionTable[12862] = iReleaseAlarm_0x10c900; // 0x10c900 - g_ps2RecompiledFunctionTable[12870] = topThread_0x10c920; // 0x10c920 - g_ps2RecompiledFunctionTable[12886] = topThread_0x10c920; // 0x10c960 - g_ps2RecompiledFunctionTable[12888] = topThread_0x10c920; // 0x10c968 - g_ps2RecompiledFunctionTable[12910] = topThread_0x10c920; // 0x10c9c0 - g_ps2RecompiledFunctionTable[12914] = topThread_0x10c920; // 0x10c9d0 - g_ps2RecompiledFunctionTable[12918] = topThread_0x10c920; // 0x10c9e0 - g_ps2RecompiledFunctionTable[12922] = topThread_0x10c920; // 0x10c9f0 - g_ps2RecompiledFunctionTable[12924] = InitThread_0x10c9f8; // 0x10c9f8 - g_ps2RecompiledFunctionTable[12978] = iWakeupThread_0x10cad0; // 0x10cad0 - g_ps2RecompiledFunctionTable[13016] = iRotateThreadReadyQueue_0x10cb68; // 0x10cb68 - g_ps2RecompiledFunctionTable[13048] = iSuspendThread_0x10cbe8; // 0x10cbe8 - g_ps2RecompiledFunctionTable[13058] = iSuspendThread_0x10cbe8; // 0x10cc10 - g_ps2RecompiledFunctionTable[13081] = iSuspendThread_0x10cbe8; // 0x10cc6c - g_ps2RecompiledFunctionTable[13086] = sceDeci2Open_0x10cc80; // 0x10cc80 - g_ps2RecompiledFunctionTable[13104] = sceDeci2Close_0x10ccc8; // 0x10ccc8 - g_ps2RecompiledFunctionTable[13114] = sceDeci2ReqSend_0x10ccf0; // 0x10ccf0 - g_ps2RecompiledFunctionTable[13126] = sceDeci2Poll_0x10cd20; // 0x10cd20 - g_ps2RecompiledFunctionTable[13136] = sceDeci2ExRecv_0x10cd48; // 0x10cd48 - g_ps2RecompiledFunctionTable[13150] = sceDeci2ExSend_0x10cd80; // 0x10cd80 - g_ps2RecompiledFunctionTable[13164] = sceDeci2ExReqSend_0x10cdb8; // 0x10cdb8 - g_ps2RecompiledFunctionTable[13176] = sceDeci2ExLock_0x10cde8; // 0x10cde8 - g_ps2RecompiledFunctionTable[13186] = sceDeci2ExUnLock_0x10ce10; // 0x10ce10 - g_ps2RecompiledFunctionTable[13196] = kputs_0x10ce38; // 0x10ce38 - g_ps2RecompiledFunctionTable[13202] = kputs_0x10ce38; // 0x10ce50 - g_ps2RecompiledFunctionTable[13206] = QueueInit_0x10ce60; // 0x10ce60 - g_ps2RecompiledFunctionTable[13216] = QueuePeekWriteDone_0x10ce88; // 0x10ce88 - g_ps2RecompiledFunctionTable[13232] = QueuePeekReadDone_0x10cec8; // 0x10cec8 - g_ps2RecompiledFunctionTable[13248] = sceTtyHandler_0x10cf08; // 0x10cf08 - g_ps2RecompiledFunctionTable[13350] = sceTtyWrite_0x10d0a0; // 0x10d0a0 - g_ps2RecompiledFunctionTable[13434] = sceTtyRead_0x10d1f0; // 0x10d1f0 - g_ps2RecompiledFunctionTable[13486] = sceTtyInit_0x10d2c0; // 0x10d2c0 - g_ps2RecompiledFunctionTable[13534] = kputchar_0x10d380; // 0x10d380 - g_ps2RecompiledFunctionTable[13536] = kputchar_0x10d380; // 0x10d388 - g_ps2RecompiledFunctionTable[13548] = deci2Putchar_0x10d3b8; // 0x10d3b8 - g_ps2RecompiledFunctionTable[13564] = deci2Putchar_0x10d3b8; // 0x10d3f8 - g_ps2RecompiledFunctionTable[13592] = serialPutchar_0x10d468; // 0x10d468 - g_ps2RecompiledFunctionTable[13598] = serialPutchar_0x10d468; // 0x10d480 - g_ps2RecompiledFunctionTable[13606] = ftoi_0x10d4a0; // 0x10d4a0 - g_ps2RecompiledFunctionTable[13642] = itof_0x10d530; // 0x10d530 - g_ps2RecompiledFunctionTable[13658] = itof_0x10d530; // 0x10d570 - g_ps2RecompiledFunctionTable[13681] = itof_0x10d530; // 0x10d5cc - g_ps2RecompiledFunctionTable[13686] = itof_0x10d530; // 0x10d5e0 - g_ps2RecompiledFunctionTable[13689] = itof_0x10d530; // 0x10d5ec - g_ps2RecompiledFunctionTable[13692] = printfloat_0x10d5f8; // 0x10d5f8 - g_ps2RecompiledFunctionTable[13693] = printfloat_0x10d5f8; // 0x10d5fc - g_ps2RecompiledFunctionTable[13694] = printfloat_0x10d5f8; // 0x10d600 - g_ps2RecompiledFunctionTable[13695] = printfloat_0x10d5f8; // 0x10d604 - g_ps2RecompiledFunctionTable[13696] = printfloat_0x10d5f8; // 0x10d608 - g_ps2RecompiledFunctionTable[13697] = printfloat_0x10d5f8; // 0x10d60c - g_ps2RecompiledFunctionTable[13698] = printfloat_0x10d5f8; // 0x10d610 - g_ps2RecompiledFunctionTable[13699] = printfloat_0x10d5f8; // 0x10d614 - g_ps2RecompiledFunctionTable[13700] = printfloat_0x10d5f8; // 0x10d618 - g_ps2RecompiledFunctionTable[13701] = printfloat_0x10d5f8; // 0x10d61c - g_ps2RecompiledFunctionTable[13702] = printfloat_0x10d5f8; // 0x10d620 - g_ps2RecompiledFunctionTable[13703] = printfloat_0x10d5f8; // 0x10d624 - g_ps2RecompiledFunctionTable[13704] = printfloat_0x10d5f8; // 0x10d628 - g_ps2RecompiledFunctionTable[13705] = printfloat_0x10d5f8; // 0x10d62c - g_ps2RecompiledFunctionTable[13706] = printfloat_0x10d5f8; // 0x10d630 - g_ps2RecompiledFunctionTable[13707] = printfloat_0x10d5f8; // 0x10d634 - g_ps2RecompiledFunctionTable[13708] = printfloat_0x10d5f8; // 0x10d638 - g_ps2RecompiledFunctionTable[13709] = printfloat_0x10d5f8; // 0x10d63c - g_ps2RecompiledFunctionTable[13710] = printfloat_0x10d5f8; // 0x10d640 - g_ps2RecompiledFunctionTable[13711] = printfloat_0x10d5f8; // 0x10d644 - g_ps2RecompiledFunctionTable[13712] = printfloat_0x10d5f8; // 0x10d648 - g_ps2RecompiledFunctionTable[13713] = printfloat_0x10d5f8; // 0x10d64c - g_ps2RecompiledFunctionTable[13714] = printfloat_0x10d5f8; // 0x10d650 - g_ps2RecompiledFunctionTable[13715] = printfloat_0x10d5f8; // 0x10d654 - g_ps2RecompiledFunctionTable[13716] = printfloat_0x10d5f8; // 0x10d658 - g_ps2RecompiledFunctionTable[13717] = printfloat_0x10d5f8; // 0x10d65c - g_ps2RecompiledFunctionTable[13718] = printfloat_0x10d5f8; // 0x10d660 - g_ps2RecompiledFunctionTable[13719] = printfloat_0x10d5f8; // 0x10d664 - g_ps2RecompiledFunctionTable[13720] = printfloat_0x10d5f8; // 0x10d668 - g_ps2RecompiledFunctionTable[13721] = printfloat_0x10d5f8; // 0x10d66c - g_ps2RecompiledFunctionTable[13722] = printfloat_0x10d5f8; // 0x10d670 - g_ps2RecompiledFunctionTable[13723] = printfloat_0x10d5f8; // 0x10d674 - g_ps2RecompiledFunctionTable[13724] = printfloat_0x10d5f8; // 0x10d678 - g_ps2RecompiledFunctionTable[13725] = printfloat_0x10d5f8; // 0x10d67c - g_ps2RecompiledFunctionTable[13726] = printfloat_0x10d5f8; // 0x10d680 - g_ps2RecompiledFunctionTable[13727] = printfloat_0x10d5f8; // 0x10d684 - g_ps2RecompiledFunctionTable[13728] = printfloat_0x10d5f8; // 0x10d688 - g_ps2RecompiledFunctionTable[13729] = printfloat_0x10d5f8; // 0x10d68c - g_ps2RecompiledFunctionTable[13730] = printfloat_0x10d5f8; // 0x10d690 - g_ps2RecompiledFunctionTable[13731] = printfloat_0x10d5f8; // 0x10d694 - g_ps2RecompiledFunctionTable[13732] = printfloat_0x10d5f8; // 0x10d698 - g_ps2RecompiledFunctionTable[13733] = printfloat_0x10d5f8; // 0x10d69c - g_ps2RecompiledFunctionTable[13734] = printfloat_0x10d5f8; // 0x10d6a0 - g_ps2RecompiledFunctionTable[13735] = printfloat_0x10d5f8; // 0x10d6a4 - g_ps2RecompiledFunctionTable[13736] = printfloat_0x10d5f8; // 0x10d6a8 - g_ps2RecompiledFunctionTable[13737] = printfloat_0x10d5f8; // 0x10d6ac - g_ps2RecompiledFunctionTable[13738] = printfloat_0x10d5f8; // 0x10d6b0 - g_ps2RecompiledFunctionTable[13739] = printfloat_0x10d5f8; // 0x10d6b4 - g_ps2RecompiledFunctionTable[13740] = printfloat_0x10d5f8; // 0x10d6b8 - g_ps2RecompiledFunctionTable[13741] = printfloat_0x10d5f8; // 0x10d6bc - g_ps2RecompiledFunctionTable[13742] = printfloat_0x10d5f8; // 0x10d6c0 - g_ps2RecompiledFunctionTable[13743] = printfloat_0x10d5f8; // 0x10d6c4 - g_ps2RecompiledFunctionTable[13744] = printfloat_0x10d5f8; // 0x10d6c8 - g_ps2RecompiledFunctionTable[13745] = printfloat_0x10d5f8; // 0x10d6cc - g_ps2RecompiledFunctionTable[13746] = printfloat_0x10d5f8; // 0x10d6d0 - g_ps2RecompiledFunctionTable[13747] = printfloat_0x10d5f8; // 0x10d6d4 - g_ps2RecompiledFunctionTable[13748] = printfloat_0x10d5f8; // 0x10d6d8 - g_ps2RecompiledFunctionTable[13749] = printfloat_0x10d5f8; // 0x10d6dc - g_ps2RecompiledFunctionTable[13750] = printfloat_0x10d5f8; // 0x10d6e0 - g_ps2RecompiledFunctionTable[13751] = printfloat_0x10d5f8; // 0x10d6e4 - g_ps2RecompiledFunctionTable[13752] = printfloat_0x10d5f8; // 0x10d6e8 - g_ps2RecompiledFunctionTable[13753] = printfloat_0x10d5f8; // 0x10d6ec - g_ps2RecompiledFunctionTable[13754] = printfloat_0x10d5f8; // 0x10d6f0 - g_ps2RecompiledFunctionTable[13755] = printfloat_0x10d5f8; // 0x10d6f4 - g_ps2RecompiledFunctionTable[13756] = printfloat_0x10d5f8; // 0x10d6f8 - g_ps2RecompiledFunctionTable[13757] = printfloat_0x10d5f8; // 0x10d6fc - g_ps2RecompiledFunctionTable[13758] = printfloat_0x10d5f8; // 0x10d700 - g_ps2RecompiledFunctionTable[13759] = printfloat_0x10d5f8; // 0x10d704 - g_ps2RecompiledFunctionTable[13760] = printfloat_0x10d5f8; // 0x10d708 - g_ps2RecompiledFunctionTable[13761] = printfloat_0x10d5f8; // 0x10d70c - g_ps2RecompiledFunctionTable[13762] = printfloat_0x10d5f8; // 0x10d710 - g_ps2RecompiledFunctionTable[13763] = printfloat_0x10d5f8; // 0x10d714 - g_ps2RecompiledFunctionTable[13764] = printfloat_0x10d5f8; // 0x10d718 - g_ps2RecompiledFunctionTable[13765] = printfloat_0x10d5f8; // 0x10d71c - g_ps2RecompiledFunctionTable[13766] = printfloat_0x10d5f8; // 0x10d720 - g_ps2RecompiledFunctionTable[13767] = printfloat_0x10d5f8; // 0x10d724 - g_ps2RecompiledFunctionTable[13768] = printfloat_0x10d5f8; // 0x10d728 - g_ps2RecompiledFunctionTable[13769] = printfloat_0x10d5f8; // 0x10d72c - g_ps2RecompiledFunctionTable[13770] = printfloat_0x10d5f8; // 0x10d730 - g_ps2RecompiledFunctionTable[13771] = printfloat_0x10d5f8; // 0x10d734 - g_ps2RecompiledFunctionTable[13772] = printfloat_0x10d5f8; // 0x10d738 - g_ps2RecompiledFunctionTable[13773] = printfloat_0x10d5f8; // 0x10d73c - g_ps2RecompiledFunctionTable[13774] = printfloat_0x10d5f8; // 0x10d740 - g_ps2RecompiledFunctionTable[13775] = printfloat_0x10d5f8; // 0x10d744 - g_ps2RecompiledFunctionTable[13776] = printfloat_0x10d5f8; // 0x10d748 - g_ps2RecompiledFunctionTable[13777] = printfloat_0x10d5f8; // 0x10d74c - g_ps2RecompiledFunctionTable[13778] = printfloat_0x10d5f8; // 0x10d750 - g_ps2RecompiledFunctionTable[13779] = printfloat_0x10d5f8; // 0x10d754 - g_ps2RecompiledFunctionTable[13780] = printfloat_0x10d5f8; // 0x10d758 - g_ps2RecompiledFunctionTable[13781] = printfloat_0x10d5f8; // 0x10d75c - g_ps2RecompiledFunctionTable[13782] = _printf_0x10d760; // 0x10d760 - g_ps2RecompiledFunctionTable[14152] = kprintf_0x10dd28; // 0x10dd28 - g_ps2RecompiledFunctionTable[14163] = kprintf_0x10dd28; // 0x10dd54 - g_ps2RecompiledFunctionTable[14166] = scePrintf_0x10dd60; // 0x10dd60 - g_ps2RecompiledFunctionTable[14190] = _set_sreg_0x10ddc0; // 0x10ddc0 - g_ps2RecompiledFunctionTable[14198] = _change_addr_0x10dde0; // 0x10dde0 - g_ps2RecompiledFunctionTable[14202] = sceSifGetSreg_0x10ddf0; // 0x10ddf0 - g_ps2RecompiledFunctionTable[14208] = sceSifSetSreg_0x10de08; // 0x10de08 - g_ps2RecompiledFunctionTable[14216] = sceSifGetDataTable_0x10de28; // 0x10de28 - g_ps2RecompiledFunctionTable[14220] = sceSifInitCmd_0x10de38; // 0x10de38 - g_ps2RecompiledFunctionTable[14388] = sceSifExitCmd_0x10e0d8; // 0x10e0d8 - g_ps2RecompiledFunctionTable[14402] = sceSifSetCmdBuffer_0x10e110; // 0x10e110 - g_ps2RecompiledFunctionTable[14408] = sceSifSetSysCmdBuffer_0x10e128; // 0x10e128 - g_ps2RecompiledFunctionTable[14414] = sceSifAddCmdHandler_0x10e140; // 0x10e140 - g_ps2RecompiledFunctionTable[14426] = sceSifRemoveCmdHandler_0x10e170; // 0x10e170 - g_ps2RecompiledFunctionTable[14436] = _sceSifSendCmd_0x10e198; // 0x10e198 - g_ps2RecompiledFunctionTable[14514] = sceSifSendCmd_0x10e2d0; // 0x10e2d0 - g_ps2RecompiledFunctionTable[14530] = isceSifSendCmd_0x10e310; // 0x10e310 - g_ps2RecompiledFunctionTable[14542] = isceSifSendCmd_0x10e310; // 0x10e340 - g_ps2RecompiledFunctionTable[14546] = _sceSifCmdIntrHdlr_0x10e350; // 0x10e350 - g_ps2RecompiledFunctionTable[14618] = sceSifWriteBackDCache_0x10e470; // 0x10e470 - g_ps2RecompiledFunctionTable[14662] = sceSifInitRpc_0x10e520; // 0x10e520 - g_ps2RecompiledFunctionTable[14774] = sceSifExitRpc_0x10e6e0; // 0x10e6e0 - g_ps2RecompiledFunctionTable[14784] = _sceRpcGetPacket_0x10e708; // 0x10e708 - g_ps2RecompiledFunctionTable[14826] = _sceRpcFreePacket_0x10e7b0; // 0x10e7b0 - g_ps2RecompiledFunctionTable[14834] = _sceRpcGetFPacket_0x10e7d0; // 0x10e7d0 - g_ps2RecompiledFunctionTable[14846] = _sceRpcGetFPacket2_0x10e800; // 0x10e800 - g_ps2RecompiledFunctionTable[14862] = _request_end_0x10e840; // 0x10e840 - g_ps2RecompiledFunctionTable[14863] = _request_end_0x10e840; // 0x10e844 - g_ps2RecompiledFunctionTable[14864] = _request_end_0x10e840; // 0x10e848 - g_ps2RecompiledFunctionTable[14865] = _request_end_0x10e840; // 0x10e84c - g_ps2RecompiledFunctionTable[14866] = _request_end_0x10e840; // 0x10e850 - g_ps2RecompiledFunctionTable[14867] = _request_end_0x10e840; // 0x10e854 - g_ps2RecompiledFunctionTable[14868] = _request_end_0x10e840; // 0x10e858 - g_ps2RecompiledFunctionTable[14869] = _request_end_0x10e840; // 0x10e85c - g_ps2RecompiledFunctionTable[14870] = _request_end_0x10e840; // 0x10e860 - g_ps2RecompiledFunctionTable[14871] = _request_end_0x10e840; // 0x10e864 - g_ps2RecompiledFunctionTable[14872] = _request_end_0x10e840; // 0x10e868 - g_ps2RecompiledFunctionTable[14873] = _request_end_0x10e840; // 0x10e86c - g_ps2RecompiledFunctionTable[14874] = _request_end_0x10e840; // 0x10e870 - g_ps2RecompiledFunctionTable[14875] = _request_end_0x10e840; // 0x10e874 - g_ps2RecompiledFunctionTable[14876] = _request_end_0x10e840; // 0x10e878 - g_ps2RecompiledFunctionTable[14877] = _request_end_0x10e840; // 0x10e87c - g_ps2RecompiledFunctionTable[14878] = _request_end_0x10e840; // 0x10e880 - g_ps2RecompiledFunctionTable[14879] = _request_end_0x10e840; // 0x10e884 - g_ps2RecompiledFunctionTable[14880] = _request_end_0x10e840; // 0x10e888 - g_ps2RecompiledFunctionTable[14881] = _request_end_0x10e840; // 0x10e88c - g_ps2RecompiledFunctionTable[14882] = _request_end_0x10e840; // 0x10e890 - g_ps2RecompiledFunctionTable[14883] = _request_end_0x10e840; // 0x10e894 - g_ps2RecompiledFunctionTable[14884] = _request_end_0x10e840; // 0x10e898 - g_ps2RecompiledFunctionTable[14885] = _request_end_0x10e840; // 0x10e89c - g_ps2RecompiledFunctionTable[14886] = _request_end_0x10e840; // 0x10e8a0 - g_ps2RecompiledFunctionTable[14887] = _request_end_0x10e840; // 0x10e8a4 - g_ps2RecompiledFunctionTable[14888] = _request_end_0x10e840; // 0x10e8a8 - g_ps2RecompiledFunctionTable[14889] = _request_end_0x10e840; // 0x10e8ac - g_ps2RecompiledFunctionTable[14890] = _request_end_0x10e840; // 0x10e8b0 - g_ps2RecompiledFunctionTable[14891] = _request_end_0x10e840; // 0x10e8b4 - g_ps2RecompiledFunctionTable[14892] = _request_end_0x10e840; // 0x10e8b8 - g_ps2RecompiledFunctionTable[14893] = _request_end_0x10e840; // 0x10e8bc - g_ps2RecompiledFunctionTable[14894] = _request_end_0x10e840; // 0x10e8c0 - g_ps2RecompiledFunctionTable[14895] = _request_end_0x10e840; // 0x10e8c4 - g_ps2RecompiledFunctionTable[14896] = _request_end_0x10e840; // 0x10e8c8 - g_ps2RecompiledFunctionTable[14897] = _request_end_0x10e840; // 0x10e8cc - g_ps2RecompiledFunctionTable[14898] = _request_end_0x10e840; // 0x10e8d0 - g_ps2RecompiledFunctionTable[14899] = _request_end_0x10e840; // 0x10e8d4 - g_ps2RecompiledFunctionTable[14900] = _request_end_0x10e840; // 0x10e8d8 - g_ps2RecompiledFunctionTable[14901] = _request_end_0x10e840; // 0x10e8dc - g_ps2RecompiledFunctionTable[14902] = _request_end_0x10e840; // 0x10e8e0 - g_ps2RecompiledFunctionTable[14903] = _request_end_0x10e840; // 0x10e8e4 - g_ps2RecompiledFunctionTable[14904] = _request_end_0x10e840; // 0x10e8e8 - g_ps2RecompiledFunctionTable[14905] = _request_end_0x10e840; // 0x10e8ec - g_ps2RecompiledFunctionTable[14906] = _request_end_0x10e840; // 0x10e8f0 - g_ps2RecompiledFunctionTable[14908] = _request_rdata_0x10e8f8; // 0x10e8f8 - g_ps2RecompiledFunctionTable[14914] = _request_rdata_0x10e8f8; // 0x10e910 - g_ps2RecompiledFunctionTable[14932] = sceSifGetOtherData_0x10e958; // 0x10e958 - g_ps2RecompiledFunctionTable[15018] = _search_svdata_0x10eab0; // 0x10eab0 - g_ps2RecompiledFunctionTable[15022] = _search_svdata_0x10eab0; // 0x10eac0 - g_ps2RecompiledFunctionTable[15026] = _search_svdata_0x10eab0; // 0x10ead0 - g_ps2RecompiledFunctionTable[15038] = _request_bind_0x10eb00; // 0x10eb00 - g_ps2RecompiledFunctionTable[15047] = _request_bind_0x10eb00; // 0x10eb24 - g_ps2RecompiledFunctionTable[15058] = _request_bind_0x10eb00; // 0x10eb50 - g_ps2RecompiledFunctionTable[15082] = sceSifBindRpc_0x10ebb0; // 0x10ebb0 - g_ps2RecompiledFunctionTable[15162] = _request_call_0x10ecf0; // 0x10ecf0 - g_ps2RecompiledFunctionTable[15198] = sceSifCallRpc_0x10ed80; // 0x10ed80 - g_ps2RecompiledFunctionTable[15322] = sceSifCheckStatRpc_0x10ef70; // 0x10ef70 - g_ps2RecompiledFunctionTable[15338] = sceSifSetRpcQueue_0x10efb0; // 0x10efb0 - g_ps2RecompiledFunctionTable[15374] = sceSifRegisterRpc_0x10f040; // 0x10f040 - g_ps2RecompiledFunctionTable[15410] = sceSifRemoveRpc_0x10f0d0; // 0x10f0d0 - g_ps2RecompiledFunctionTable[15442] = sceSifRemoveRpcQueue_0x10f150; // 0x10f150 - g_ps2RecompiledFunctionTable[15476] = sceSifGetNextRequest_0x10f1d8; // 0x10f1d8 - g_ps2RecompiledFunctionTable[15496] = sceSifExecRequest_0x10f228; // 0x10f228 - g_ps2RecompiledFunctionTable[15616] = sceSifRpcLoop_0x10f408; // 0x10f408 - g_ps2RecompiledFunctionTable[15632] = new_iob_0x10f448; // 0x10f448 - g_ps2RecompiledFunctionTable[15634] = new_iob_0x10f448; // 0x10f450 - g_ps2RecompiledFunctionTable[15648] = new_iob_0x10f448; // 0x10f488 - g_ps2RecompiledFunctionTable[15660] = get_iob_0x10f4b8; // 0x10f4b8 - g_ps2RecompiledFunctionTable[15670] = _sceFsSemInit_0x10f4e0; // 0x10f4e0 - g_ps2RecompiledFunctionTable[15672] = _sceFsSemExit_0x10f4e8; // 0x10f4e8 - g_ps2RecompiledFunctionTable[15674] = _sceFsDbChk_0x10f4f0; // 0x10f4f0 - g_ps2RecompiledFunctionTable[15676] = _sceFsSigSema_0x10f4f8; // 0x10f4f8 - g_ps2RecompiledFunctionTable[15678] = _sceFsIntrSigSema_0x10f500; // 0x10f500 - g_ps2RecompiledFunctionTable[15680] = sceFsInit_0x10f508; // 0x10f508 - g_ps2RecompiledFunctionTable[15762] = _fs_version_0x10f650; // 0x10f650 - g_ps2RecompiledFunctionTable[15774] = _fs_version_0x10f650; // 0x10f680 - g_ps2RecompiledFunctionTable[15780] = _fs_version_0x10f650; // 0x10f698 - g_ps2RecompiledFunctionTable[15788] = sceFsReset_0x10f6b8; // 0x10f6b8 - g_ps2RecompiledFunctionTable[15802] = sceOpen_0x10f6f0; // 0x10f6f0 - g_ps2RecompiledFunctionTable[15914] = sceClose_0x10f8b0; // 0x10f8b0 - g_ps2RecompiledFunctionTable[15976] = sceLseek_0x10f9a8; // 0x10f9a8 - g_ps2RecompiledFunctionTable[16060] = fs_read_intr_0x10faf8; // 0x10faf8 - g_ps2RecompiledFunctionTable[16072] = fs_read_intr_0x10faf8; // 0x10fb28 - g_ps2RecompiledFunctionTable[16088] = fs_read_intr_0x10faf8; // 0x10fb68 - g_ps2RecompiledFunctionTable[16098] = sceRead_0x10fb90; // 0x10fb90 - g_ps2RecompiledFunctionTable[16204] = sceWrite_0x10fd38; // 0x10fd38 - g_ps2RecompiledFunctionTable[16326] = sceIoctl_0x10ff20; // 0x10ff20 - g_ps2RecompiledFunctionTable[16470] = sceSifInitIopHeap_0x110160; // 0x110160 - g_ps2RecompiledFunctionTable[16504] = sceSifAllocIopHeap_0x1101e8; // 0x1101e8 - g_ps2RecompiledFunctionTable[16532] = sceSifFreeIopHeap_0x110258; // 0x110258 - g_ps2RecompiledFunctionTable[16562] = sceSifLoadIopHeap_0x1102d0; // 0x1102d0 - g_ps2RecompiledFunctionTable[16622] = _lf_bind_0x1103c0; // 0x1103c0 - g_ps2RecompiledFunctionTable[16632] = _lf_bind_0x1103c0; // 0x1103e8 - g_ps2RecompiledFunctionTable[16637] = _lf_bind_0x1103c0; // 0x1103fc - g_ps2RecompiledFunctionTable[16654] = _lf_bind_0x1103c0; // 0x110440 - g_ps2RecompiledFunctionTable[16670] = _lf_bind_0x1103c0; // 0x110480 - g_ps2RecompiledFunctionTable[16686] = _lf_version_0x1104c0; // 0x1104c0 - g_ps2RecompiledFunctionTable[16698] = _lf_version_0x1104c0; // 0x1104f0 - g_ps2RecompiledFunctionTable[16704] = _lf_version_0x1104c0; // 0x110508 - g_ps2RecompiledFunctionTable[16712] = sceSifLoadFileReset_0x110528; // 0x110528 - g_ps2RecompiledFunctionTable[16726] = sceSifLoadModuleBuffer_0x110560; // 0x110560 - g_ps2RecompiledFunctionTable[16850] = _sceSifLoadModule_0x110750; // 0x110750 - g_ps2RecompiledFunctionTable[16978] = sceSifLoadModule_0x110950; // 0x110950 - g_ps2RecompiledFunctionTable[16986] = _sceSifLoadElfPart_0x110970; // 0x110970 - g_ps2RecompiledFunctionTable[17052] = sceSifLoadElfPart_0x110a78; // 0x110a78 - g_ps2RecompiledFunctionTable[17060] = sceSifLoadElf_0x110a98; // 0x110a98 - g_ps2RecompiledFunctionTable[17070] = sceSifGetIopAddr_0x110ac0; // 0x110ac0 - g_ps2RecompiledFunctionTable[17130] = sceSifSetIopAddr_0x110bb0; // 0x110bb0 - g_ps2RecompiledFunctionTable[17186] = sceSifResetIop_0x110c90; // 0x110c90 - g_ps2RecompiledFunctionTable[17262] = sceSifIsAliveIop_0x110dc0; // 0x110dc0 - g_ps2RecompiledFunctionTable[17272] = sceSifSyncIop_0x110de8; // 0x110de8 - g_ps2RecompiledFunctionTable[17290] = sceSifRebootIop_0x110e30; // 0x110e30 - g_ps2RecompiledFunctionTable[17354] = _send_to_iop_0x110f30; // 0x110f30 - g_ps2RecompiledFunctionTable[17376] = _send_to_iop_0x110f30; // 0x110f88 - g_ps2RecompiledFunctionTable[17383] = _send_to_iop_0x110f30; // 0x110fa4 - g_ps2RecompiledFunctionTable[17396] = _send_to_iop_0x110f30; // 0x110fd8 - g_ps2RecompiledFunctionTable[17404] = _send_to_iop_0x110f30; // 0x110ff8 - g_ps2RecompiledFunctionTable[17413] = _send_to_iop_0x110f30; // 0x11101c - g_ps2RecompiledFunctionTable[17430] = scePadInit_0x111060; // 0x111060 - g_ps2RecompiledFunctionTable[17510] = scePadInit2_0x1111a0; // 0x1111a0 - g_ps2RecompiledFunctionTable[17550] = scePadEnd_0x111240; // 0x111240 - g_ps2RecompiledFunctionTable[17582] = scePadPortOpen_0x1112c0; // 0x1112c0 - g_ps2RecompiledFunctionTable[17704] = scePadPortClose_0x1114a8; // 0x1114a8 - g_ps2RecompiledFunctionTable[17750] = scePadGetDmaStr_0x111560; // 0x111560 - g_ps2RecompiledFunctionTable[17774] = scePadGetFrameCount_0x1115c0; // 0x1115c0 - g_ps2RecompiledFunctionTable[17794] = scePadRead_0x111610; // 0x111610 - g_ps2RecompiledFunctionTable[17826] = scePadGetState_0x111690; // 0x111690 - g_ps2RecompiledFunctionTable[17856] = scePadStateIntToStr_0x111708; // 0x111708 - g_ps2RecompiledFunctionTable[17870] = scePadSetReqState_0x111740; // 0x111740 - g_ps2RecompiledFunctionTable[17896] = scePadGetReqState_0x1117a8; // 0x1117a8 - g_ps2RecompiledFunctionTable[17916] = scePadReqIntToStr_0x1117f8; // 0x1117f8 - g_ps2RecompiledFunctionTable[17930] = scePadInfoAct_0x111830; // 0x111830 - g_ps2RecompiledFunctionTable[18002] = scePadInfoComb_0x111950; // 0x111950 - g_ps2RecompiledFunctionTable[18074] = scePadInfoMode_0x111a70; // 0x111a70 - g_ps2RecompiledFunctionTable[18152] = scePadSetMainMode_0x111ba8; // 0x111ba8 - g_ps2RecompiledFunctionTable[18198] = scePadSetActDirect_0x111c60; // 0x111c60 - g_ps2RecompiledFunctionTable[18244] = scePadSetActAlign_0x111d18; // 0x111d18 - g_ps2RecompiledFunctionTable[18298] = scePadGetButtonMask_0x111df0; // 0x111df0 - g_ps2RecompiledFunctionTable[18344] = scePadSetButtonInfo_0x111ea8; // 0x111ea8 - g_ps2RecompiledFunctionTable[18388] = scePadInfoPressMode_0x111f58; // 0x111f58 - g_ps2RecompiledFunctionTable[18412] = scePadEnterPressMode_0x111fb8; // 0x111fb8 - g_ps2RecompiledFunctionTable[18434] = scePadExitPressMode_0x112010; // 0x112010 - g_ps2RecompiledFunctionTable[18456] = scePadSetVrefParam_0x112068; // 0x112068 - g_ps2RecompiledFunctionTable[18508] = scePadGetPortMax_0x112138; // 0x112138 - g_ps2RecompiledFunctionTable[18534] = scePadGetSlotMax_0x1121a0; // 0x1121a0 - g_ps2RecompiledFunctionTable[18560] = scePadGetModVersion_0x112208; // 0x112208 - g_ps2RecompiledFunctionTable[18586] = scePadSetWarningLevel_0x112270; // 0x112270 - g_ps2RecompiledFunctionTable[18612] = CB_DelayTh_0x1122d8; // 0x1122d8 - g_ps2RecompiledFunctionTable[18614] = sceCdDelayThread_0x1122e0; // 0x1122e0 - g_ps2RecompiledFunctionTable[18640] = sceCdCallback_0x112348; // 0x112348 - g_ps2RecompiledFunctionTable[18656] = cd_callback_0x112388; // 0x112388 - g_ps2RecompiledFunctionTable[18681] = cd_callback_0x112388; // 0x1123ec - g_ps2RecompiledFunctionTable[18691] = cd_callback_0x112388; // 0x112414 - g_ps2RecompiledFunctionTable[18700] = ps2__Cdvd_cbLoop_0x112438; // 0x112438 - g_ps2RecompiledFunctionTable[18701] = ps2__Cdvd_cbLoop_0x112438; // 0x11243c - g_ps2RecompiledFunctionTable[18702] = ps2__Cdvd_cbLoop_0x112438; // 0x112440 - g_ps2RecompiledFunctionTable[18703] = ps2__Cdvd_cbLoop_0x112438; // 0x112444 - g_ps2RecompiledFunctionTable[18704] = ps2__Cdvd_cbLoop_0x112438; // 0x112448 - g_ps2RecompiledFunctionTable[18705] = ps2__Cdvd_cbLoop_0x112438; // 0x11244c - g_ps2RecompiledFunctionTable[18706] = ps2__Cdvd_cbLoop_0x112438; // 0x112450 - g_ps2RecompiledFunctionTable[18707] = ps2__Cdvd_cbLoop_0x112438; // 0x112454 - g_ps2RecompiledFunctionTable[18708] = ps2__Cdvd_cbLoop_0x112438; // 0x112458 - g_ps2RecompiledFunctionTable[18709] = ps2__Cdvd_cbLoop_0x112438; // 0x11245c - g_ps2RecompiledFunctionTable[18710] = ps2__Cdvd_cbLoop_0x112438; // 0x112460 - g_ps2RecompiledFunctionTable[18711] = ps2__Cdvd_cbLoop_0x112438; // 0x112464 - g_ps2RecompiledFunctionTable[18712] = ps2__Cdvd_cbLoop_0x112438; // 0x112468 - g_ps2RecompiledFunctionTable[18713] = ps2__Cdvd_cbLoop_0x112438; // 0x11246c - g_ps2RecompiledFunctionTable[18714] = ps2__Cdvd_cbLoop_0x112438; // 0x112470 - g_ps2RecompiledFunctionTable[18715] = ps2__Cdvd_cbLoop_0x112438; // 0x112474 - g_ps2RecompiledFunctionTable[18716] = ps2__Cdvd_cbLoop_0x112438; // 0x112478 - g_ps2RecompiledFunctionTable[18717] = ps2__Cdvd_cbLoop_0x112438; // 0x11247c - g_ps2RecompiledFunctionTable[18718] = ps2__Cdvd_cbLoop_0x112438; // 0x112480 - g_ps2RecompiledFunctionTable[18719] = ps2__Cdvd_cbLoop_0x112438; // 0x112484 - g_ps2RecompiledFunctionTable[18720] = ps2__Cdvd_cbLoop_0x112438; // 0x112488 - g_ps2RecompiledFunctionTable[18721] = ps2__Cdvd_cbLoop_0x112438; // 0x11248c - g_ps2RecompiledFunctionTable[18722] = ps2__Cdvd_cbLoop_0x112438; // 0x112490 - g_ps2RecompiledFunctionTable[18723] = ps2__Cdvd_cbLoop_0x112438; // 0x112494 - g_ps2RecompiledFunctionTable[18724] = ps2__Cdvd_cbLoop_0x112438; // 0x112498 - g_ps2RecompiledFunctionTable[18725] = ps2__Cdvd_cbLoop_0x112438; // 0x11249c - g_ps2RecompiledFunctionTable[18726] = ps2__Cdvd_cbLoop_0x112438; // 0x1124a0 - g_ps2RecompiledFunctionTable[18727] = ps2__Cdvd_cbLoop_0x112438; // 0x1124a4 - g_ps2RecompiledFunctionTable[18728] = ps2__Cdvd_cbLoop_0x112438; // 0x1124a8 - g_ps2RecompiledFunctionTable[18729] = ps2__Cdvd_cbLoop_0x112438; // 0x1124ac - g_ps2RecompiledFunctionTable[18730] = ps2__Cdvd_cbLoop_0x112438; // 0x1124b0 - g_ps2RecompiledFunctionTable[18731] = ps2__Cdvd_cbLoop_0x112438; // 0x1124b4 - g_ps2RecompiledFunctionTable[18732] = ps2__Cdvd_cbLoop_0x112438; // 0x1124b8 - g_ps2RecompiledFunctionTable[18733] = ps2__Cdvd_cbLoop_0x112438; // 0x1124bc - g_ps2RecompiledFunctionTable[18734] = ps2__Cdvd_cbLoop_0x112438; // 0x1124c0 - g_ps2RecompiledFunctionTable[18735] = ps2__Cdvd_cbLoop_0x112438; // 0x1124c4 - g_ps2RecompiledFunctionTable[18736] = ps2__Cdvd_cbLoop_0x112438; // 0x1124c8 - g_ps2RecompiledFunctionTable[18737] = ps2__Cdvd_cbLoop_0x112438; // 0x1124cc - g_ps2RecompiledFunctionTable[18738] = ps2__Cdvd_cbLoop_0x112438; // 0x1124d0 - g_ps2RecompiledFunctionTable[18739] = ps2__Cdvd_cbLoop_0x112438; // 0x1124d4 - g_ps2RecompiledFunctionTable[18740] = ps2__Cdvd_cbLoop_0x112438; // 0x1124d8 - g_ps2RecompiledFunctionTable[18741] = ps2__Cdvd_cbLoop_0x112438; // 0x1124dc - g_ps2RecompiledFunctionTable[18742] = ps2__Cdvd_cbLoop_0x112438; // 0x1124e0 - g_ps2RecompiledFunctionTable[18743] = ps2__Cdvd_cbLoop_0x112438; // 0x1124e4 - g_ps2RecompiledFunctionTable[18744] = ps2__Cdvd_cbLoop_0x112438; // 0x1124e8 - g_ps2RecompiledFunctionTable[18745] = ps2__Cdvd_cbLoop_0x112438; // 0x1124ec - g_ps2RecompiledFunctionTable[18746] = ps2__Cdvd_cbLoop_0x112438; // 0x1124f0 - g_ps2RecompiledFunctionTable[18747] = ps2__Cdvd_cbLoop_0x112438; // 0x1124f4 - g_ps2RecompiledFunctionTable[18748] = ps2__Cdvd_cbLoop_0x112438; // 0x1124f8 - g_ps2RecompiledFunctionTable[18749] = ps2__Cdvd_cbLoop_0x112438; // 0x1124fc - g_ps2RecompiledFunctionTable[18750] = sceCdInitEeCB_0x112500; // 0x112500 - g_ps2RecompiledFunctionTable[18804] = cd_read_intr_0x1125d8; // 0x1125d8 - g_ps2RecompiledFunctionTable[18816] = cd_read_intr_0x1125d8; // 0x112608 - g_ps2RecompiledFunctionTable[18834] = cd_read_intr_0x1125d8; // 0x112650 - g_ps2RecompiledFunctionTable[18844] = cmd_sem_init_0x112678; // 0x112678 - g_ps2RecompiledFunctionTable[18865] = cmd_sem_init_0x112678; // 0x1126cc - g_ps2RecompiledFunctionTable[18868] = cmd_sem_init_0x112678; // 0x1126d8 - g_ps2RecompiledFunctionTable[18872] = cmd_sem_init_0x112678; // 0x1126e8 - g_ps2RecompiledFunctionTable[18882] = cdvd_exit_0x112710; // 0x112710 - g_ps2RecompiledFunctionTable[18894] = cdvd_exit_0x112710; // 0x112740 - g_ps2RecompiledFunctionTable[18900] = cdvd_exit_0x112710; // 0x112758 - g_ps2RecompiledFunctionTable[18903] = cdvd_exit_0x112710; // 0x112764 - g_ps2RecompiledFunctionTable[18908] = sceCdIntToPos_0x112778; // 0x112778 - g_ps2RecompiledFunctionTable[18958] = sceCdPosToInt_0x112840; // 0x112840 - g_ps2RecompiledFunctionTable[18982] = PowerOffCB_0x1128a0; // 0x1128a0 - g_ps2RecompiledFunctionTable[18991] = PowerOffCB_0x1128a0; // 0x1128c4 - g_ps2RecompiledFunctionTable[18996] = PowerOffCB_0x1128a0; // 0x1128d8 - g_ps2RecompiledFunctionTable[18998] = PowerOffCB_0x1128a0; // 0x1128e0 - g_ps2RecompiledFunctionTable[19012] = PowerOffCB_0x1128a0; // 0x112918 - g_ps2RecompiledFunctionTable[19017] = PowerOffCB_0x1128a0; // 0x11292c - g_ps2RecompiledFunctionTable[19026] = PowerOffCB_0x1128a0; // 0x112950 - g_ps2RecompiledFunctionTable[19028] = PowerOffCB_0x1128a0; // 0x112958 - g_ps2RecompiledFunctionTable[19055] = PowerOffCB_0x1128a0; // 0x1129c4 - g_ps2RecompiledFunctionTable[19064] = sceCdSearchFile_0x1129e8; // 0x1129e8 - g_ps2RecompiledFunctionTable[19252] = ncmd_prechk_0x112cd8; // 0x112cd8 - g_ps2RecompiledFunctionTable[19260] = ncmd_prechk_0x112cd8; // 0x112cf8 - g_ps2RecompiledFunctionTable[19263] = ncmd_prechk_0x112cd8; // 0x112d04 - g_ps2RecompiledFunctionTable[19274] = ncmd_prechk_0x112cd8; // 0x112d30 - g_ps2RecompiledFunctionTable[19283] = ncmd_prechk_0x112cd8; // 0x112d54 - g_ps2RecompiledFunctionTable[19285] = ncmd_prechk_0x112cd8; // 0x112d5c - g_ps2RecompiledFunctionTable[19290] = ncmd_prechk_0x112cd8; // 0x112d70 - g_ps2RecompiledFunctionTable[19294] = ncmd_prechk_0x112cd8; // 0x112d80 - g_ps2RecompiledFunctionTable[19300] = ncmd_prechk_0x112cd8; // 0x112d98 - g_ps2RecompiledFunctionTable[19302] = ncmd_prechk_0x112cd8; // 0x112da0 - g_ps2RecompiledFunctionTable[19310] = ncmd_prechk_0x112cd8; // 0x112dc0 - g_ps2RecompiledFunctionTable[19315] = ncmd_prechk_0x112cd8; // 0x112dd4 - g_ps2RecompiledFunctionTable[19324] = ncmd_prechk_0x112cd8; // 0x112df8 - g_ps2RecompiledFunctionTable[19326] = ncmd_prechk_0x112cd8; // 0x112e00 - g_ps2RecompiledFunctionTable[19344] = sceCdNcmdDiskReady_0x112e48; // 0x112e48 - g_ps2RecompiledFunctionTable[19382] = sceCdGetReadPos_0x112ee0; // 0x112ee0 - g_ps2RecompiledFunctionTable[19394] = sceCdReadChain_0x112f10; // 0x112f10 - g_ps2RecompiledFunctionTable[19580] = sceCdRead_0x1131f8; // 0x1131f8 - g_ps2RecompiledFunctionTable[19694] = sceCdReadIOPm_0x1133c0; // 0x1133c0 - g_ps2RecompiledFunctionTable[19774] = sceCdGetToc_0x113500; // 0x113500 - g_ps2RecompiledFunctionTable[19938] = sceCdSeek_0x113790; // 0x113790 - g_ps2RecompiledFunctionTable[19990] = sceCdStandby_0x113860; // 0x113860 - g_ps2RecompiledFunctionTable[20034] = sceCdStop_0x113910; // 0x113910 - g_ps2RecompiledFunctionTable[20078] = sceCdPause_0x1139c0; // 0x1139c0 - g_ps2RecompiledFunctionTable[20122] = sceCdSync_0x113a70; // 0x113a70 - g_ps2RecompiledFunctionTable[20162] = sceCdSyncS_0x113b10; // 0x113b10 - g_ps2RecompiledFunctionTable[20190] = scmd_prechk_0x113b80; // 0x113b80 - g_ps2RecompiledFunctionTable[20198] = scmd_prechk_0x113b80; // 0x113ba0 - g_ps2RecompiledFunctionTable[20201] = scmd_prechk_0x113b80; // 0x113bac - g_ps2RecompiledFunctionTable[20212] = scmd_prechk_0x113b80; // 0x113bd8 - g_ps2RecompiledFunctionTable[20221] = scmd_prechk_0x113b80; // 0x113bfc - g_ps2RecompiledFunctionTable[20223] = scmd_prechk_0x113b80; // 0x113c04 - g_ps2RecompiledFunctionTable[20228] = scmd_prechk_0x113b80; // 0x113c18 - g_ps2RecompiledFunctionTable[20232] = scmd_prechk_0x113b80; // 0x113c28 - g_ps2RecompiledFunctionTable[20238] = scmd_prechk_0x113b80; // 0x113c40 - g_ps2RecompiledFunctionTable[20240] = scmd_prechk_0x113b80; // 0x113c48 - g_ps2RecompiledFunctionTable[20248] = scmd_prechk_0x113b80; // 0x113c68 - g_ps2RecompiledFunctionTable[20253] = scmd_prechk_0x113b80; // 0x113c7c - g_ps2RecompiledFunctionTable[20262] = scmd_prechk_0x113b80; // 0x113ca0 - g_ps2RecompiledFunctionTable[20264] = scmd_prechk_0x113b80; // 0x113ca8 - g_ps2RecompiledFunctionTable[20282] = sceCdInit_0x113cf0; // 0x113cf0 - g_ps2RecompiledFunctionTable[20468] = sceCdDiskReady_0x113fd8; // 0x113fd8 - g_ps2RecompiledFunctionTable[20594] = sceCdBreak_0x1141d0; // 0x1141d0 - g_ps2RecompiledFunctionTable[20640] = sceCdGetDiskType_0x114288; // 0x114288 - g_ps2RecompiledFunctionTable[20678] = sceCdStatus_0x114320; // 0x114320 - g_ps2RecompiledFunctionTable[20724] = sceCdGetError_0x1143d8; // 0x1143d8 - g_ps2RecompiledFunctionTable[20762] = _sceCdRI_0x114470; // 0x114470 - g_ps2RecompiledFunctionTable[20816] = _sceCdRM_0x114548; // 0x114548 - g_ps2RecompiledFunctionTable[20874] = sceCdMmode_0x114630; // 0x114630 - g_ps2RecompiledFunctionTable[20922] = sceCdChangeThreadPriority_0x1146f0; // 0x1146f0 - g_ps2RecompiledFunctionTable[20970] = sceCdReadClock_0x1147b0; // 0x1147b0 - g_ps2RecompiledFunctionTable[21032] = sceCdApplyNCmd_0x1148a8; // 0x1148a8 - g_ps2RecompiledFunctionTable[21160] = sceCdTrayReq_0x114aa8; // 0x114aa8 - g_ps2RecompiledFunctionTable[21218] = sceCdStInit_0x114b90; // 0x114b90 - g_ps2RecompiledFunctionTable[21230] = sceCdStStart_0x114bc0; // 0x114bc0 - g_ps2RecompiledFunctionTable[21244] = sceCdStSeekF_0x114bf8; // 0x114bf8 - g_ps2RecompiledFunctionTable[21256] = sceCdStSeek_0x114c28; // 0x114c28 - g_ps2RecompiledFunctionTable[21268] = sceCdStStop_0x114c58; // 0x114c58 - g_ps2RecompiledFunctionTable[21282] = sceCdStRead_0x114c90; // 0x114c90 - g_ps2RecompiledFunctionTable[21374] = sceCdStPause_0x114e00; // 0x114e00 - g_ps2RecompiledFunctionTable[21394] = sceCdStResume_0x114e50; // 0x114e50 - g_ps2RecompiledFunctionTable[21416] = sceCdStStat_0x114ea8; // 0x114ea8 - g_ps2RecompiledFunctionTable[21434] = sceCdStream_0x114ef0; // 0x114ef0 - g_ps2RecompiledFunctionTable[21522] = sceMcInit_0x115050; // 0x115050 - g_ps2RecompiledFunctionTable[21608] = _lmcGetClientPtr_0x1151a8; // 0x1151a8 - g_ps2RecompiledFunctionTable[21618] = sceMcChangeThreadPriority_0x1151d0; // 0x1151d0 - g_ps2RecompiledFunctionTable[21654] = sceMcGetSlotMax_0x115260; // 0x115260 - g_ps2RecompiledFunctionTable[21688] = sceMcOpen_0x1152e8; // 0x1152e8 - g_ps2RecompiledFunctionTable[21746] = sceMcMkdir_0x1153d0; // 0x1153d0 - g_ps2RecompiledFunctionTable[21760] = sceMcClose_0x115408; // 0x115408 - g_ps2RecompiledFunctionTable[21796] = sceMcSeek_0x115498; // 0x115498 - g_ps2RecompiledFunctionTable[21832] = mceIntrReadFixAlign_0x115528; // 0x115528 - g_ps2RecompiledFunctionTable[21868] = sceMcRead_0x1155b8; // 0x1155b8 - g_ps2RecompiledFunctionTable[21922] = sceMcWrite_0x115690; // 0x115690 - g_ps2RecompiledFunctionTable[22002] = sceMcSync_0x1157d0; // 0x1157d0 - g_ps2RecompiledFunctionTable[22060] = mceGetInfoApdx_0x1158b8; // 0x1158b8 - g_ps2RecompiledFunctionTable[22082] = sceMcGetInfo_0x115910; // 0x115910 - g_ps2RecompiledFunctionTable[22160] = sceMcGetDir_0x115a48; // 0x115a48 - g_ps2RecompiledFunctionTable[22218] = mceStorePwd_0x115b30; // 0x115b30 - g_ps2RecompiledFunctionTable[22252] = sceMcChdir_0x115bb8; // 0x115bb8 - g_ps2RecompiledFunctionTable[22310] = sceMcFormat_0x115ca0; // 0x115ca0 - g_ps2RecompiledFunctionTable[22346] = sceMcDelete_0x115d30; // 0x115d30 - g_ps2RecompiledFunctionTable[22400] = sceMcFlush_0x115e08; // 0x115e08 - g_ps2RecompiledFunctionTable[22436] = sceMcSetFileInfo_0x115e98; // 0x115e98 - g_ps2RecompiledFunctionTable[22522] = sceMcRename_0x115ff0; // 0x115ff0 - g_ps2RecompiledFunctionTable[22586] = sceMcUnformat_0x1160f0; // 0x1160f0 - g_ps2RecompiledFunctionTable[22622] = sceMcGetEntSpace_0x116180; // 0x116180 - g_ps2RecompiledFunctionTable[22668] = sceSdRemoteInit_0x116238; // 0x116238 - g_ps2RecompiledFunctionTable[22716] = sceSdTransToIOP_0x1162f8; // 0x1162f8 - g_ps2RecompiledFunctionTable[22744] = sceSdCallBack_0x116368; // 0x116368 - g_ps2RecompiledFunctionTable[22748] = sceSdRemote_0x116378; // 0x116378 - g_ps2RecompiledFunctionTable[22878] = sceSSyn_SetMasterVolume_0x116580; // 0x116580 - g_ps2RecompiledFunctionTable[22898] = sceSSyn_SetOutPortVolume_0x1165d0; // 0x1165d0 - g_ps2RecompiledFunctionTable[22926] = sceSSyn_SetOutputAssign_0x116640; // 0x116640 - g_ps2RecompiledFunctionTable[23008] = sceSSyn_SetPortVolume_0x116788; // 0x116788 - g_ps2RecompiledFunctionTable[23056] = sceSSyn_SendShortMsg_0x116848; // 0x116848 - g_ps2RecompiledFunctionTable[23072] = sceSSyn_SendExcMsg_0x116888; // 0x116888 - g_ps2RecompiledFunctionTable[23084] = sceSSyn_SendRpnMsg_0x1168b8; // 0x1168b8 - g_ps2RecompiledFunctionTable[23116] = sceSSyn_SendNrpnMsg_0x116938; // 0x116938 - g_ps2RecompiledFunctionTable[23130] = sceSSyn_SetChPriority_0x116970; // 0x116970 - g_ps2RecompiledFunctionTable[23156] = sceSSyn_SetPortMaxPoly_0x1169d8; // 0x1169d8 - g_ps2RecompiledFunctionTable[23172] = sceSSyn_ClearBreakAtick_0x116a18; // 0x116a18 - g_ps2RecompiledFunctionTable[23182] = sceSSyn_BreakAtick_0x116a40; // 0x116a40 - g_ps2RecompiledFunctionTable[23190] = sceSSyn_SetOutputMode_0x116a60; // 0x116a60 - g_ps2RecompiledFunctionTable[23202] = sceSSyn_SetTvaEnvMode_0x116a90; // 0x116a90 - g_ps2RecompiledFunctionTable[23214] = sceSynthesizerSendShortMessage_0x116ac0; // 0x116ac0 - g_ps2RecompiledFunctionTable[23294] = ControlChangeMessage_0x116c00; // 0x116c00 - g_ps2RecompiledFunctionTable[23534] = ControlChangeMessage_0x116c00; // 0x116fc0 - g_ps2RecompiledFunctionTable[23537] = ControlChangeMessage_0x116c00; // 0x116fcc - g_ps2RecompiledFunctionTable[23540] = ControlChangeMessage_0x116c00; // 0x116fd8 - g_ps2RecompiledFunctionTable[23543] = ControlChangeMessage_0x116c00; // 0x116fe4 - g_ps2RecompiledFunctionTable[23546] = ControlChangeMessage_0x116c00; // 0x116ff0 - g_ps2RecompiledFunctionTable[23549] = ControlChangeMessage_0x116c00; // 0x116ffc - g_ps2RecompiledFunctionTable[23570] = sceSynthesizerSetMasterVolume_0x117050; // 0x117050 - g_ps2RecompiledFunctionTable[23578] = sceSynthesizerHsMessage_0x117070; // 0x117070 - g_ps2RecompiledFunctionTable[23692] = sceSynthesizerTransposeMatrix_0x117238; // 0x117238 - g_ps2RecompiledFunctionTable[23722] = sceSynthesizerCopyOutput_0x1172b0; // 0x1172b0 - g_ps2RecompiledFunctionTable[23772] = sceSynthesizerClearSpr_0x117378; // 0x117378 - g_ps2RecompiledFunctionTable[23806] = sceSynthesizerCent2PhaseInc_0x117400; // 0x117400 - g_ps2RecompiledFunctionTable[23828] = sceSynthesizerCalcPortamentPitch_0x117458; // 0x117458 - g_ps2RecompiledFunctionTable[23842] = sceSynthesizerReadNoise_0x117490; // 0x117490 - g_ps2RecompiledFunctionTable[23868] = sceSynthesizerReadNoiseAdd_0x1174f8; // 0x1174f8 - g_ps2RecompiledFunctionTable[23896] = sceSynthesizerReadSample16_0x117568; // 0x117568 - g_ps2RecompiledFunctionTable[23934] = sceSynthesizerReadSample16Add_0x117600; // 0x117600 - g_ps2RecompiledFunctionTable[23974] = sceSynthesizerReadSample8_0x1176a0; // 0x1176a0 - g_ps2RecompiledFunctionTable[24010] = sceSynthesizerReadSample8Add_0x117730; // 0x117730 - g_ps2RecompiledFunctionTable[24048] = sceSynthesizerSetupNewNoise_0x1177c8; // 0x1177c8 - g_ps2RecompiledFunctionTable[24068] = sceSynthesizerSetuptEnv_0x117818; // 0x117818 - g_ps2RecompiledFunctionTable[24148] = sceSynthesizerCalcEnv_0x117958; // 0x117958 - g_ps2RecompiledFunctionTable[24180] = sceSynthesizerSetupReleaseEnv_0x1179d8; // 0x1179d8 - g_ps2RecompiledFunctionTable[24244] = sceSynthesizerSetupTruncateTvaEnv_0x117ad8; // 0x117ad8 - g_ps2RecompiledFunctionTable[24288] = sceSynthesizerSetupTruncateTvfPitchEnv_0x117b88; // 0x117b88 - g_ps2RecompiledFunctionTable[24292] = sceSynthesizerAmpProcNI_0x117b98; // 0x117b98 - g_ps2RecompiledFunctionTable[24336] = sceSynthesizerAmpProcI_0x117c48; // 0x117c48 - g_ps2RecompiledFunctionTable[24390] = sceSynthesizerLfoNone_0x117d20; // 0x117d20 - g_ps2RecompiledFunctionTable[24394] = sceSynthesizerLfoSawUp_0x117d30; // 0x117d30 - g_ps2RecompiledFunctionTable[24400] = sceSynthesizerLfoSawDown_0x117d48; // 0x117d48 - g_ps2RecompiledFunctionTable[24406] = sceSynthSizerLfoTriangle_0x117d60; // 0x117d60 - g_ps2RecompiledFunctionTable[24426] = sceSynthesizerLfoSquare_0x117db0; // 0x117db0 - g_ps2RecompiledFunctionTable[24438] = sceSynthsizerLfoNoise_0x117de0; // 0x117de0 - g_ps2RecompiledFunctionTable[24456] = sceSynthesizerLfoProc_0x117e28; // 0x117e28 - g_ps2RecompiledFunctionTable[24496] = sceSynthesizerSetupLfo_0x117ec8; // 0x117ec8 - g_ps2RecompiledFunctionTable[24600] = sceSynthesizerCalcTvfCoefAll_0x118068; // 0x118068 - g_ps2RecompiledFunctionTable[24616] = sceSynthesizerCalcTvfCoefF0_0x1180a8; // 0x1180a8 - g_ps2RecompiledFunctionTable[24688] = sceSynthesizerTvfProcNI_0x1181c8; // 0x1181c8 - g_ps2RecompiledFunctionTable[24754] = sceSynthesizerTvfProcI_0x1182d0; // 0x1182d0 - g_ps2RecompiledFunctionTable[24856] = log2lin_0x118468; // 0x118468 - g_ps2RecompiledFunctionTable[24870] = log2lin_0x118468; // 0x1184a0 - g_ps2RecompiledFunctionTable[24894] = log2lin_0x118468; // 0x118500 - g_ps2RecompiledFunctionTable[24934] = clrMem_0x1185a0; // 0x1185a0 - g_ps2RecompiledFunctionTable[24946] = clrMem_0x1185a0; // 0x1185d0 - g_ps2RecompiledFunctionTable[24964] = clrMem_0x1185a0; // 0x118618 - g_ps2RecompiledFunctionTable[24982] = clrMem_0x1185a0; // 0x118660 - g_ps2RecompiledFunctionTable[24998] = clrMem_0x1185a0; // 0x1186a0 - g_ps2RecompiledFunctionTable[25008] = procVoiceStop_0x1186c8; // 0x1186c8 - g_ps2RecompiledFunctionTable[25043] = procVoiceStop_0x1186c8; // 0x118754 - g_ps2RecompiledFunctionTable[25062] = phaseChange2Release_0x1187a0; // 0x1187a0 - g_ps2RecompiledFunctionTable[25070] = phaseChange2Release_0x1187a0; // 0x1187c0 - g_ps2RecompiledFunctionTable[25082] = phaseChange2Release_0x1187a0; // 0x1187f0 - g_ps2RecompiledFunctionTable[25104] = breakVoice_0x118848; // 0x118848 - g_ps2RecompiledFunctionTable[25112] = breakVoice_0x118848; // 0x118868 - g_ps2RecompiledFunctionTable[25118] = breakVoice_0x118848; // 0x118880 - g_ps2RecompiledFunctionTable[25126] = procParaVoices_0x1188a0; // 0x1188a0 - g_ps2RecompiledFunctionTable[25127] = procParaVoices_0x1188a0; // 0x1188a4 - g_ps2RecompiledFunctionTable[25128] = procParaVoices_0x1188a0; // 0x1188a8 - g_ps2RecompiledFunctionTable[25129] = procParaVoices_0x1188a0; // 0x1188ac - g_ps2RecompiledFunctionTable[25130] = procParaVoices_0x1188a0; // 0x1188b0 - g_ps2RecompiledFunctionTable[25131] = procParaVoices_0x1188a0; // 0x1188b4 - g_ps2RecompiledFunctionTable[25132] = procParaVoices_0x1188a0; // 0x1188b8 - g_ps2RecompiledFunctionTable[25133] = procParaVoices_0x1188a0; // 0x1188bc - g_ps2RecompiledFunctionTable[25134] = procParaVoices_0x1188a0; // 0x1188c0 - g_ps2RecompiledFunctionTable[25135] = procParaVoices_0x1188a0; // 0x1188c4 - g_ps2RecompiledFunctionTable[25136] = procParaVoices_0x1188a0; // 0x1188c8 - g_ps2RecompiledFunctionTable[25137] = procParaVoices_0x1188a0; // 0x1188cc - g_ps2RecompiledFunctionTable[25138] = procParaVoices_0x1188a0; // 0x1188d0 - g_ps2RecompiledFunctionTable[25139] = procParaVoices_0x1188a0; // 0x1188d4 - g_ps2RecompiledFunctionTable[25140] = procParaVoices_0x1188a0; // 0x1188d8 - g_ps2RecompiledFunctionTable[25141] = procParaVoices_0x1188a0; // 0x1188dc - g_ps2RecompiledFunctionTable[25142] = procParaVoices_0x1188a0; // 0x1188e0 - g_ps2RecompiledFunctionTable[25143] = procParaVoices_0x1188a0; // 0x1188e4 - g_ps2RecompiledFunctionTable[25144] = procParaVoices_0x1188a0; // 0x1188e8 - g_ps2RecompiledFunctionTable[25145] = procParaVoices_0x1188a0; // 0x1188ec - g_ps2RecompiledFunctionTable[25146] = procParaVoices_0x1188a0; // 0x1188f0 - g_ps2RecompiledFunctionTable[25147] = procParaVoices_0x1188a0; // 0x1188f4 - g_ps2RecompiledFunctionTable[25148] = procParaVoices_0x1188a0; // 0x1188f8 - g_ps2RecompiledFunctionTable[25149] = procParaVoices_0x1188a0; // 0x1188fc - g_ps2RecompiledFunctionTable[25150] = procParaVoices_0x1188a0; // 0x118900 - g_ps2RecompiledFunctionTable[25151] = procParaVoices_0x1188a0; // 0x118904 - g_ps2RecompiledFunctionTable[25152] = procParaVoices_0x1188a0; // 0x118908 - g_ps2RecompiledFunctionTable[25153] = procParaVoices_0x1188a0; // 0x11890c - g_ps2RecompiledFunctionTable[25154] = procParaVoices_0x1188a0; // 0x118910 - g_ps2RecompiledFunctionTable[25155] = procParaVoices_0x1188a0; // 0x118914 - g_ps2RecompiledFunctionTable[25156] = procParaVoices_0x1188a0; // 0x118918 - g_ps2RecompiledFunctionTable[25157] = procParaVoices_0x1188a0; // 0x11891c - g_ps2RecompiledFunctionTable[25158] = procParaVoices_0x1188a0; // 0x118920 - g_ps2RecompiledFunctionTable[25159] = procParaVoices_0x1188a0; // 0x118924 - g_ps2RecompiledFunctionTable[25160] = procParaVoices_0x1188a0; // 0x118928 - g_ps2RecompiledFunctionTable[25161] = procParaVoices_0x1188a0; // 0x11892c - g_ps2RecompiledFunctionTable[25162] = procParaVoices_0x1188a0; // 0x118930 - g_ps2RecompiledFunctionTable[25163] = procParaVoices_0x1188a0; // 0x118934 - g_ps2RecompiledFunctionTable[25164] = procParaVoices_0x1188a0; // 0x118938 - g_ps2RecompiledFunctionTable[25165] = procParaVoices_0x1188a0; // 0x11893c - g_ps2RecompiledFunctionTable[25166] = procParaVoices_0x1188a0; // 0x118940 - g_ps2RecompiledFunctionTable[25167] = procParaVoices_0x1188a0; // 0x118944 - g_ps2RecompiledFunctionTable[25168] = procParaVoices_0x1188a0; // 0x118948 - g_ps2RecompiledFunctionTable[25169] = procParaVoices_0x1188a0; // 0x11894c - g_ps2RecompiledFunctionTable[25170] = procParaVoices_0x1188a0; // 0x118950 - g_ps2RecompiledFunctionTable[25171] = procParaVoices_0x1188a0; // 0x118954 - g_ps2RecompiledFunctionTable[25172] = procParaVoices_0x1188a0; // 0x118958 - g_ps2RecompiledFunctionTable[25173] = procParaVoices_0x1188a0; // 0x11895c - g_ps2RecompiledFunctionTable[25174] = procParaVoices_0x1188a0; // 0x118960 - g_ps2RecompiledFunctionTable[25175] = procParaVoices_0x1188a0; // 0x118964 - g_ps2RecompiledFunctionTable[25176] = procParaVoices_0x1188a0; // 0x118968 - g_ps2RecompiledFunctionTable[25177] = procParaVoices_0x1188a0; // 0x11896c - g_ps2RecompiledFunctionTable[25178] = procParaVoices_0x1188a0; // 0x118970 - g_ps2RecompiledFunctionTable[25179] = procParaVoices_0x1188a0; // 0x118974 - g_ps2RecompiledFunctionTable[25180] = procParaVoices_0x1188a0; // 0x118978 - g_ps2RecompiledFunctionTable[25181] = procParaVoices_0x1188a0; // 0x11897c - g_ps2RecompiledFunctionTable[25182] = procParaVoices_0x1188a0; // 0x118980 - g_ps2RecompiledFunctionTable[25183] = procParaVoices_0x1188a0; // 0x118984 - g_ps2RecompiledFunctionTable[25184] = procParaVoices_0x1188a0; // 0x118988 - g_ps2RecompiledFunctionTable[25185] = procParaVoices_0x1188a0; // 0x11898c - g_ps2RecompiledFunctionTable[25186] = procParaVoices_0x1188a0; // 0x118990 - g_ps2RecompiledFunctionTable[25187] = procParaVoices_0x1188a0; // 0x118994 - g_ps2RecompiledFunctionTable[25188] = procParaVoices_0x1188a0; // 0x118998 - g_ps2RecompiledFunctionTable[25189] = procParaVoices_0x1188a0; // 0x11899c - g_ps2RecompiledFunctionTable[25190] = procParaVoices_0x1188a0; // 0x1189a0 - g_ps2RecompiledFunctionTable[25191] = procParaVoices_0x1188a0; // 0x1189a4 - g_ps2RecompiledFunctionTable[25192] = procParaVoices_0x1188a0; // 0x1189a8 - g_ps2RecompiledFunctionTable[25193] = procParaVoices_0x1188a0; // 0x1189ac - g_ps2RecompiledFunctionTable[25194] = procParaVoices_0x1188a0; // 0x1189b0 - g_ps2RecompiledFunctionTable[25195] = procParaVoices_0x1188a0; // 0x1189b4 - g_ps2RecompiledFunctionTable[25196] = procParaVoices_0x1188a0; // 0x1189b8 - g_ps2RecompiledFunctionTable[25197] = procParaVoices_0x1188a0; // 0x1189bc - g_ps2RecompiledFunctionTable[25198] = procParaVoices_0x1188a0; // 0x1189c0 - g_ps2RecompiledFunctionTable[25199] = procParaVoices_0x1188a0; // 0x1189c4 - g_ps2RecompiledFunctionTable[25200] = procParaVoices_0x1188a0; // 0x1189c8 - g_ps2RecompiledFunctionTable[25201] = procParaVoices_0x1188a0; // 0x1189cc - g_ps2RecompiledFunctionTable[25202] = procParaVoices_0x1188a0; // 0x1189d0 - g_ps2RecompiledFunctionTable[25203] = procParaVoices_0x1188a0; // 0x1189d4 - g_ps2RecompiledFunctionTable[25204] = procParaVoices_0x1188a0; // 0x1189d8 - g_ps2RecompiledFunctionTable[25205] = procParaVoices_0x1188a0; // 0x1189dc - g_ps2RecompiledFunctionTable[25206] = procParaVoices_0x1188a0; // 0x1189e0 - g_ps2RecompiledFunctionTable[25207] = procParaVoices_0x1188a0; // 0x1189e4 - g_ps2RecompiledFunctionTable[25208] = procParaVoices_0x1188a0; // 0x1189e8 - g_ps2RecompiledFunctionTable[25209] = procParaVoices_0x1188a0; // 0x1189ec - g_ps2RecompiledFunctionTable[25210] = procParaVoices_0x1188a0; // 0x1189f0 - g_ps2RecompiledFunctionTable[25211] = procParaVoices_0x1188a0; // 0x1189f4 - g_ps2RecompiledFunctionTable[25212] = procParaVoices_0x1188a0; // 0x1189f8 - g_ps2RecompiledFunctionTable[25213] = procParaVoices_0x1188a0; // 0x1189fc - g_ps2RecompiledFunctionTable[25214] = procParaVoices_0x1188a0; // 0x118a00 - g_ps2RecompiledFunctionTable[25215] = procParaVoices_0x1188a0; // 0x118a04 - g_ps2RecompiledFunctionTable[25216] = procParaVoices_0x1188a0; // 0x118a08 - g_ps2RecompiledFunctionTable[25217] = procParaVoices_0x1188a0; // 0x118a0c - g_ps2RecompiledFunctionTable[25218] = procParaVoices_0x1188a0; // 0x118a10 - g_ps2RecompiledFunctionTable[25219] = procParaVoices_0x1188a0; // 0x118a14 - g_ps2RecompiledFunctionTable[25220] = procParaVoices_0x1188a0; // 0x118a18 - g_ps2RecompiledFunctionTable[25221] = procParaVoices_0x1188a0; // 0x118a1c - g_ps2RecompiledFunctionTable[25222] = procParaVoices_0x1188a0; // 0x118a20 - g_ps2RecompiledFunctionTable[25223] = procParaVoices_0x1188a0; // 0x118a24 - g_ps2RecompiledFunctionTable[25224] = procParaVoices_0x1188a0; // 0x118a28 - g_ps2RecompiledFunctionTable[25225] = procParaVoices_0x1188a0; // 0x118a2c - g_ps2RecompiledFunctionTable[25226] = procParaVoices_0x1188a0; // 0x118a30 - g_ps2RecompiledFunctionTable[25227] = procParaVoices_0x1188a0; // 0x118a34 - g_ps2RecompiledFunctionTable[25228] = procParaVoices_0x1188a0; // 0x118a38 - g_ps2RecompiledFunctionTable[25229] = procParaVoices_0x1188a0; // 0x118a3c - g_ps2RecompiledFunctionTable[25230] = procParaVoices_0x1188a0; // 0x118a40 - g_ps2RecompiledFunctionTable[25231] = procParaVoices_0x1188a0; // 0x118a44 - g_ps2RecompiledFunctionTable[25232] = procParaVoices_0x1188a0; // 0x118a48 - g_ps2RecompiledFunctionTable[25233] = procParaVoices_0x1188a0; // 0x118a4c - g_ps2RecompiledFunctionTable[25234] = procParaVoices_0x1188a0; // 0x118a50 - g_ps2RecompiledFunctionTable[25235] = procParaVoices_0x1188a0; // 0x118a54 - g_ps2RecompiledFunctionTable[25236] = procParaVoices_0x1188a0; // 0x118a58 - g_ps2RecompiledFunctionTable[25237] = procParaVoices_0x1188a0; // 0x118a5c - g_ps2RecompiledFunctionTable[25238] = procParaVoices_0x1188a0; // 0x118a60 - g_ps2RecompiledFunctionTable[25239] = procParaVoices_0x1188a0; // 0x118a64 - g_ps2RecompiledFunctionTable[25240] = procParaVoices_0x1188a0; // 0x118a68 - g_ps2RecompiledFunctionTable[25241] = procParaVoices_0x1188a0; // 0x118a6c - g_ps2RecompiledFunctionTable[25242] = procParaVoices_0x1188a0; // 0x118a70 - g_ps2RecompiledFunctionTable[25243] = procParaVoices_0x1188a0; // 0x118a74 - g_ps2RecompiledFunctionTable[25244] = procParaVoices_0x1188a0; // 0x118a78 - g_ps2RecompiledFunctionTable[25245] = procParaVoices_0x1188a0; // 0x118a7c - g_ps2RecompiledFunctionTable[25246] = procParaVoices_0x1188a0; // 0x118a80 - g_ps2RecompiledFunctionTable[25247] = procParaVoices_0x1188a0; // 0x118a84 - g_ps2RecompiledFunctionTable[25248] = procParaVoices_0x1188a0; // 0x118a88 - g_ps2RecompiledFunctionTable[25249] = procParaVoices_0x1188a0; // 0x118a8c - g_ps2RecompiledFunctionTable[25250] = procParaVoices_0x1188a0; // 0x118a90 - g_ps2RecompiledFunctionTable[25251] = procParaVoices_0x1188a0; // 0x118a94 - g_ps2RecompiledFunctionTable[25252] = procParaVoices_0x1188a0; // 0x118a98 - g_ps2RecompiledFunctionTable[25253] = procParaVoices_0x1188a0; // 0x118a9c - g_ps2RecompiledFunctionTable[25254] = procParaVoices_0x1188a0; // 0x118aa0 - g_ps2RecompiledFunctionTable[25255] = procParaVoices_0x1188a0; // 0x118aa4 - g_ps2RecompiledFunctionTable[25256] = procParaVoices_0x1188a0; // 0x118aa8 - g_ps2RecompiledFunctionTable[25257] = procParaVoices_0x1188a0; // 0x118aac - g_ps2RecompiledFunctionTable[25258] = procParaVoices_0x1188a0; // 0x118ab0 - g_ps2RecompiledFunctionTable[25259] = procParaVoices_0x1188a0; // 0x118ab4 - g_ps2RecompiledFunctionTable[25260] = procParaVoices_0x1188a0; // 0x118ab8 - g_ps2RecompiledFunctionTable[25261] = procParaVoices_0x1188a0; // 0x118abc - g_ps2RecompiledFunctionTable[25262] = procParaVoices_0x1188a0; // 0x118ac0 - g_ps2RecompiledFunctionTable[25263] = procParaVoices_0x1188a0; // 0x118ac4 - g_ps2RecompiledFunctionTable[25264] = procParaVoices_0x1188a0; // 0x118ac8 - g_ps2RecompiledFunctionTable[25265] = procParaVoices_0x1188a0; // 0x118acc - g_ps2RecompiledFunctionTable[25266] = procParaVoices_0x1188a0; // 0x118ad0 - g_ps2RecompiledFunctionTable[25267] = procParaVoices_0x1188a0; // 0x118ad4 - g_ps2RecompiledFunctionTable[25268] = procParaVoices_0x1188a0; // 0x118ad8 - g_ps2RecompiledFunctionTable[25269] = procParaVoices_0x1188a0; // 0x118adc - g_ps2RecompiledFunctionTable[25270] = procParaVoices_0x1188a0; // 0x118ae0 - g_ps2RecompiledFunctionTable[25271] = procParaVoices_0x1188a0; // 0x118ae4 - g_ps2RecompiledFunctionTable[25272] = procParaVoices_0x1188a0; // 0x118ae8 - g_ps2RecompiledFunctionTable[25273] = procParaVoices_0x1188a0; // 0x118aec - g_ps2RecompiledFunctionTable[25274] = procParaVoices_0x1188a0; // 0x118af0 - g_ps2RecompiledFunctionTable[25275] = procParaVoices_0x1188a0; // 0x118af4 - g_ps2RecompiledFunctionTable[25276] = procParaVoices_0x1188a0; // 0x118af8 - g_ps2RecompiledFunctionTable[25277] = procParaVoices_0x1188a0; // 0x118afc - g_ps2RecompiledFunctionTable[25278] = procParaVoices_0x1188a0; // 0x118b00 - g_ps2RecompiledFunctionTable[25279] = procParaVoices_0x1188a0; // 0x118b04 - g_ps2RecompiledFunctionTable[25280] = procParaVoices_0x1188a0; // 0x118b08 - g_ps2RecompiledFunctionTable[25281] = procParaVoices_0x1188a0; // 0x118b0c - g_ps2RecompiledFunctionTable[25282] = procParaVoices_0x1188a0; // 0x118b10 - g_ps2RecompiledFunctionTable[25283] = procParaVoices_0x1188a0; // 0x118b14 - g_ps2RecompiledFunctionTable[25284] = procParaVoices_0x1188a0; // 0x118b18 - g_ps2RecompiledFunctionTable[25285] = procParaVoices_0x1188a0; // 0x118b1c - g_ps2RecompiledFunctionTable[25286] = procParaVoices_0x1188a0; // 0x118b20 - g_ps2RecompiledFunctionTable[25287] = procParaVoices_0x1188a0; // 0x118b24 - g_ps2RecompiledFunctionTable[25288] = procParaVoices_0x1188a0; // 0x118b28 - g_ps2RecompiledFunctionTable[25289] = procParaVoices_0x1188a0; // 0x118b2c - g_ps2RecompiledFunctionTable[25290] = procParaVoices_0x1188a0; // 0x118b30 - g_ps2RecompiledFunctionTable[25291] = procParaVoices_0x1188a0; // 0x118b34 - g_ps2RecompiledFunctionTable[25292] = procParaVoices_0x1188a0; // 0x118b38 - g_ps2RecompiledFunctionTable[25293] = procParaVoices_0x1188a0; // 0x118b3c - g_ps2RecompiledFunctionTable[25294] = procParaVoices_0x1188a0; // 0x118b40 - g_ps2RecompiledFunctionTable[25295] = procParaVoices_0x1188a0; // 0x118b44 - g_ps2RecompiledFunctionTable[25296] = procParaVoices_0x1188a0; // 0x118b48 - g_ps2RecompiledFunctionTable[25297] = procParaVoices_0x1188a0; // 0x118b4c - g_ps2RecompiledFunctionTable[25298] = procParaVoices_0x1188a0; // 0x118b50 - g_ps2RecompiledFunctionTable[25299] = procParaVoices_0x1188a0; // 0x118b54 - g_ps2RecompiledFunctionTable[25300] = procParaVoices_0x1188a0; // 0x118b58 - g_ps2RecompiledFunctionTable[25301] = procParaVoices_0x1188a0; // 0x118b5c - g_ps2RecompiledFunctionTable[25302] = procParaVoices_0x1188a0; // 0x118b60 - g_ps2RecompiledFunctionTable[25303] = procParaVoices_0x1188a0; // 0x118b64 - g_ps2RecompiledFunctionTable[25304] = procParaVoices_0x1188a0; // 0x118b68 - g_ps2RecompiledFunctionTable[25305] = procParaVoices_0x1188a0; // 0x118b6c - g_ps2RecompiledFunctionTable[25306] = procParaVoices_0x1188a0; // 0x118b70 - g_ps2RecompiledFunctionTable[25307] = procParaVoices_0x1188a0; // 0x118b74 - g_ps2RecompiledFunctionTable[25308] = procParaVoices_0x1188a0; // 0x118b78 - g_ps2RecompiledFunctionTable[25309] = procParaVoices_0x1188a0; // 0x118b7c - g_ps2RecompiledFunctionTable[25310] = procParaVoices_0x1188a0; // 0x118b80 - g_ps2RecompiledFunctionTable[25311] = procParaVoices_0x1188a0; // 0x118b84 - g_ps2RecompiledFunctionTable[25312] = procParaVoices_0x1188a0; // 0x118b88 - g_ps2RecompiledFunctionTable[25313] = procParaVoices_0x1188a0; // 0x118b8c - g_ps2RecompiledFunctionTable[25314] = procParaVoices_0x1188a0; // 0x118b90 - g_ps2RecompiledFunctionTable[25315] = procParaVoices_0x1188a0; // 0x118b94 - g_ps2RecompiledFunctionTable[25316] = procParaVoices_0x1188a0; // 0x118b98 - g_ps2RecompiledFunctionTable[25317] = procParaVoices_0x1188a0; // 0x118b9c - g_ps2RecompiledFunctionTable[25318] = procParaVoices_0x1188a0; // 0x118ba0 - g_ps2RecompiledFunctionTable[25319] = procParaVoices_0x1188a0; // 0x118ba4 - g_ps2RecompiledFunctionTable[25320] = procParaVoices_0x1188a0; // 0x118ba8 - g_ps2RecompiledFunctionTable[25321] = procParaVoices_0x1188a0; // 0x118bac - g_ps2RecompiledFunctionTable[25322] = procParaVoices_0x1188a0; // 0x118bb0 - g_ps2RecompiledFunctionTable[25323] = procParaVoices_0x1188a0; // 0x118bb4 - g_ps2RecompiledFunctionTable[25324] = procParaVoices_0x1188a0; // 0x118bb8 - g_ps2RecompiledFunctionTable[25325] = procParaVoices_0x1188a0; // 0x118bbc - g_ps2RecompiledFunctionTable[25326] = procParaVoices_0x1188a0; // 0x118bc0 - g_ps2RecompiledFunctionTable[25327] = procParaVoices_0x1188a0; // 0x118bc4 - g_ps2RecompiledFunctionTable[25328] = procParaVoices_0x1188a0; // 0x118bc8 - g_ps2RecompiledFunctionTable[25329] = procParaVoices_0x1188a0; // 0x118bcc - g_ps2RecompiledFunctionTable[25330] = procParaVoices_0x1188a0; // 0x118bd0 - g_ps2RecompiledFunctionTable[25331] = procParaVoices_0x1188a0; // 0x118bd4 - g_ps2RecompiledFunctionTable[25332] = procParaVoices_0x1188a0; // 0x118bd8 - g_ps2RecompiledFunctionTable[25333] = procParaVoices_0x1188a0; // 0x118bdc - g_ps2RecompiledFunctionTable[25334] = procParaVoices_0x1188a0; // 0x118be0 - g_ps2RecompiledFunctionTable[25335] = procParaVoices_0x1188a0; // 0x118be4 - g_ps2RecompiledFunctionTable[25336] = procParaVoices_0x1188a0; // 0x118be8 - g_ps2RecompiledFunctionTable[25337] = procParaVoices_0x1188a0; // 0x118bec - g_ps2RecompiledFunctionTable[25338] = procParaVoices_0x1188a0; // 0x118bf0 - g_ps2RecompiledFunctionTable[25339] = procParaVoices_0x1188a0; // 0x118bf4 - g_ps2RecompiledFunctionTable[25340] = procParaVoices_0x1188a0; // 0x118bf8 - g_ps2RecompiledFunctionTable[25341] = procParaVoices_0x1188a0; // 0x118bfc - g_ps2RecompiledFunctionTable[25342] = procParaVoices_0x1188a0; // 0x118c00 - g_ps2RecompiledFunctionTable[25343] = procParaVoices_0x1188a0; // 0x118c04 - g_ps2RecompiledFunctionTable[25344] = procParaVoices_0x1188a0; // 0x118c08 - g_ps2RecompiledFunctionTable[25345] = procParaVoices_0x1188a0; // 0x118c0c - g_ps2RecompiledFunctionTable[25346] = procParaVoices_0x1188a0; // 0x118c10 - g_ps2RecompiledFunctionTable[25347] = procParaVoices_0x1188a0; // 0x118c14 - g_ps2RecompiledFunctionTable[25348] = procParaVoices_0x1188a0; // 0x118c18 - g_ps2RecompiledFunctionTable[25349] = procParaVoices_0x1188a0; // 0x118c1c - g_ps2RecompiledFunctionTable[25350] = procParaVoices_0x1188a0; // 0x118c20 - g_ps2RecompiledFunctionTable[25351] = procParaVoices_0x1188a0; // 0x118c24 - g_ps2RecompiledFunctionTable[25352] = procParaVoices_0x1188a0; // 0x118c28 - g_ps2RecompiledFunctionTable[25353] = procParaVoices_0x1188a0; // 0x118c2c - g_ps2RecompiledFunctionTable[25354] = procParaVoices_0x1188a0; // 0x118c30 - g_ps2RecompiledFunctionTable[25355] = procParaVoices_0x1188a0; // 0x118c34 - g_ps2RecompiledFunctionTable[25356] = procParaVoices_0x1188a0; // 0x118c38 - g_ps2RecompiledFunctionTable[25357] = procParaVoices_0x1188a0; // 0x118c3c - g_ps2RecompiledFunctionTable[25358] = procParaVoices_0x1188a0; // 0x118c40 - g_ps2RecompiledFunctionTable[25359] = procParaVoices_0x1188a0; // 0x118c44 - g_ps2RecompiledFunctionTable[25360] = procParaVoices_0x1188a0; // 0x118c48 - g_ps2RecompiledFunctionTable[25361] = procParaVoices_0x1188a0; // 0x118c4c - g_ps2RecompiledFunctionTable[25362] = procParaVoices_0x1188a0; // 0x118c50 - g_ps2RecompiledFunctionTable[25363] = procParaVoices_0x1188a0; // 0x118c54 - g_ps2RecompiledFunctionTable[25364] = procParaVoices_0x1188a0; // 0x118c58 - g_ps2RecompiledFunctionTable[25365] = procParaVoices_0x1188a0; // 0x118c5c - g_ps2RecompiledFunctionTable[25366] = procParaVoices_0x1188a0; // 0x118c60 - g_ps2RecompiledFunctionTable[25367] = procParaVoices_0x1188a0; // 0x118c64 - g_ps2RecompiledFunctionTable[25368] = procParaVoices_0x1188a0; // 0x118c68 - g_ps2RecompiledFunctionTable[25369] = procParaVoices_0x1188a0; // 0x118c6c - g_ps2RecompiledFunctionTable[25370] = procParaVoices_0x1188a0; // 0x118c70 - g_ps2RecompiledFunctionTable[25371] = procParaVoices_0x1188a0; // 0x118c74 - g_ps2RecompiledFunctionTable[25372] = procParaVoices_0x1188a0; // 0x118c78 - g_ps2RecompiledFunctionTable[25373] = procParaVoices_0x1188a0; // 0x118c7c - g_ps2RecompiledFunctionTable[25374] = procParaVoices_0x1188a0; // 0x118c80 - g_ps2RecompiledFunctionTable[25375] = procParaVoices_0x1188a0; // 0x118c84 - g_ps2RecompiledFunctionTable[25376] = procParaVoices_0x1188a0; // 0x118c88 - g_ps2RecompiledFunctionTable[25377] = procParaVoices_0x1188a0; // 0x118c8c - g_ps2RecompiledFunctionTable[25378] = procParaVoices_0x1188a0; // 0x118c90 - g_ps2RecompiledFunctionTable[25379] = procParaVoices_0x1188a0; // 0x118c94 - g_ps2RecompiledFunctionTable[25380] = procParaVoices_0x1188a0; // 0x118c98 - g_ps2RecompiledFunctionTable[25381] = procParaVoices_0x1188a0; // 0x118c9c - g_ps2RecompiledFunctionTable[25382] = procParaVoices_0x1188a0; // 0x118ca0 - g_ps2RecompiledFunctionTable[25383] = procParaVoices_0x1188a0; // 0x118ca4 - g_ps2RecompiledFunctionTable[25384] = procParaVoices_0x1188a0; // 0x118ca8 - g_ps2RecompiledFunctionTable[25385] = procParaVoices_0x1188a0; // 0x118cac - g_ps2RecompiledFunctionTable[25386] = procParaVoices_0x1188a0; // 0x118cb0 - g_ps2RecompiledFunctionTable[25387] = procParaVoices_0x1188a0; // 0x118cb4 - g_ps2RecompiledFunctionTable[25388] = procParaVoices_0x1188a0; // 0x118cb8 - g_ps2RecompiledFunctionTable[25389] = procParaVoices_0x1188a0; // 0x118cbc - g_ps2RecompiledFunctionTable[25390] = procParaVoices_0x1188a0; // 0x118cc0 - g_ps2RecompiledFunctionTable[25391] = procParaVoices_0x1188a0; // 0x118cc4 - g_ps2RecompiledFunctionTable[25392] = procParaVoices_0x1188a0; // 0x118cc8 - g_ps2RecompiledFunctionTable[25393] = procParaVoices_0x1188a0; // 0x118ccc - g_ps2RecompiledFunctionTable[25394] = procParaVoices_0x1188a0; // 0x118cd0 - g_ps2RecompiledFunctionTable[25395] = procParaVoices_0x1188a0; // 0x118cd4 - g_ps2RecompiledFunctionTable[25396] = procParaVoices_0x1188a0; // 0x118cd8 - g_ps2RecompiledFunctionTable[25397] = procParaVoices_0x1188a0; // 0x118cdc - g_ps2RecompiledFunctionTable[25398] = procParaVoices_0x1188a0; // 0x118ce0 - g_ps2RecompiledFunctionTable[25399] = procParaVoices_0x1188a0; // 0x118ce4 - g_ps2RecompiledFunctionTable[25400] = procParaVoices_0x1188a0; // 0x118ce8 - g_ps2RecompiledFunctionTable[25401] = procParaVoices_0x1188a0; // 0x118cec - g_ps2RecompiledFunctionTable[25402] = procParaVoices_0x1188a0; // 0x118cf0 - g_ps2RecompiledFunctionTable[25403] = procParaVoices_0x1188a0; // 0x118cf4 - g_ps2RecompiledFunctionTable[25404] = procParaVoices_0x1188a0; // 0x118cf8 - g_ps2RecompiledFunctionTable[25405] = procParaVoices_0x1188a0; // 0x118cfc - g_ps2RecompiledFunctionTable[25406] = procParaVoices_0x1188a0; // 0x118d00 - g_ps2RecompiledFunctionTable[25407] = procParaVoices_0x1188a0; // 0x118d04 - g_ps2RecompiledFunctionTable[25408] = procParaVoices_0x1188a0; // 0x118d08 - g_ps2RecompiledFunctionTable[25409] = procParaVoices_0x1188a0; // 0x118d0c - g_ps2RecompiledFunctionTable[25410] = procParaVoices_0x1188a0; // 0x118d10 - g_ps2RecompiledFunctionTable[25411] = procParaVoices_0x1188a0; // 0x118d14 - g_ps2RecompiledFunctionTable[25412] = procParaVoices_0x1188a0; // 0x118d18 - g_ps2RecompiledFunctionTable[25413] = procParaVoices_0x1188a0; // 0x118d1c - g_ps2RecompiledFunctionTable[25414] = procParaVoices_0x1188a0; // 0x118d20 - g_ps2RecompiledFunctionTable[25415] = procParaVoices_0x1188a0; // 0x118d24 - g_ps2RecompiledFunctionTable[25416] = procParaVoices_0x1188a0; // 0x118d28 - g_ps2RecompiledFunctionTable[25417] = procParaVoices_0x1188a0; // 0x118d2c - g_ps2RecompiledFunctionTable[25418] = procParaVoices_0x1188a0; // 0x118d30 - g_ps2RecompiledFunctionTable[25419] = procParaVoices_0x1188a0; // 0x118d34 - g_ps2RecompiledFunctionTable[25420] = procParaVoices_0x1188a0; // 0x118d38 - g_ps2RecompiledFunctionTable[25421] = procParaVoices_0x1188a0; // 0x118d3c - g_ps2RecompiledFunctionTable[25422] = procParaVoices_0x1188a0; // 0x118d40 - g_ps2RecompiledFunctionTable[25423] = procParaVoices_0x1188a0; // 0x118d44 - g_ps2RecompiledFunctionTable[25424] = procParaVoices_0x1188a0; // 0x118d48 - g_ps2RecompiledFunctionTable[25425] = procParaVoices_0x1188a0; // 0x118d4c - g_ps2RecompiledFunctionTable[25426] = procParaVoices_0x1188a0; // 0x118d50 - g_ps2RecompiledFunctionTable[25427] = procParaVoices_0x1188a0; // 0x118d54 - g_ps2RecompiledFunctionTable[25428] = procParaVoices_0x1188a0; // 0x118d58 - g_ps2RecompiledFunctionTable[25429] = procParaVoices_0x1188a0; // 0x118d5c - g_ps2RecompiledFunctionTable[25430] = procParaVoices_0x1188a0; // 0x118d60 - g_ps2RecompiledFunctionTable[25431] = procParaVoices_0x1188a0; // 0x118d64 - g_ps2RecompiledFunctionTable[25432] = procParaVoices_0x1188a0; // 0x118d68 - g_ps2RecompiledFunctionTable[25433] = procParaVoices_0x1188a0; // 0x118d6c - g_ps2RecompiledFunctionTable[25434] = procParaVoices_0x1188a0; // 0x118d70 - g_ps2RecompiledFunctionTable[25435] = procParaVoices_0x1188a0; // 0x118d74 - g_ps2RecompiledFunctionTable[25436] = procParaVoices_0x1188a0; // 0x118d78 - g_ps2RecompiledFunctionTable[25437] = procParaVoices_0x1188a0; // 0x118d7c - g_ps2RecompiledFunctionTable[25438] = procParaVoices_0x1188a0; // 0x118d80 - g_ps2RecompiledFunctionTable[25439] = procParaVoices_0x1188a0; // 0x118d84 - g_ps2RecompiledFunctionTable[25440] = procParaVoices_0x1188a0; // 0x118d88 - g_ps2RecompiledFunctionTable[25441] = procParaVoices_0x1188a0; // 0x118d8c - g_ps2RecompiledFunctionTable[25442] = procParaVoices_0x1188a0; // 0x118d90 - g_ps2RecompiledFunctionTable[25443] = procParaVoices_0x1188a0; // 0x118d94 - g_ps2RecompiledFunctionTable[25444] = procParaVoices_0x1188a0; // 0x118d98 - g_ps2RecompiledFunctionTable[25445] = procParaVoices_0x1188a0; // 0x118d9c - g_ps2RecompiledFunctionTable[25446] = procParaVoices_0x1188a0; // 0x118da0 - g_ps2RecompiledFunctionTable[25447] = procParaVoices_0x1188a0; // 0x118da4 - g_ps2RecompiledFunctionTable[25448] = procParaVoices_0x1188a0; // 0x118da8 - g_ps2RecompiledFunctionTable[25449] = procParaVoices_0x1188a0; // 0x118dac - g_ps2RecompiledFunctionTable[25450] = procParaVoices_0x1188a0; // 0x118db0 - g_ps2RecompiledFunctionTable[25451] = procParaVoices_0x1188a0; // 0x118db4 - g_ps2RecompiledFunctionTable[25452] = procParaVoices_0x1188a0; // 0x118db8 - g_ps2RecompiledFunctionTable[25453] = procParaVoices_0x1188a0; // 0x118dbc - g_ps2RecompiledFunctionTable[25454] = procParaVoices_0x1188a0; // 0x118dc0 - g_ps2RecompiledFunctionTable[25455] = procParaVoices_0x1188a0; // 0x118dc4 - g_ps2RecompiledFunctionTable[25456] = procParaVoices_0x1188a0; // 0x118dc8 - g_ps2RecompiledFunctionTable[25457] = procParaVoices_0x1188a0; // 0x118dcc - g_ps2RecompiledFunctionTable[25458] = procParaVoices_0x1188a0; // 0x118dd0 - g_ps2RecompiledFunctionTable[25459] = procParaVoices_0x1188a0; // 0x118dd4 - g_ps2RecompiledFunctionTable[25460] = procParaVoices_0x1188a0; // 0x118dd8 - g_ps2RecompiledFunctionTable[25461] = procParaVoices_0x1188a0; // 0x118ddc - g_ps2RecompiledFunctionTable[25462] = procParaVoices_0x1188a0; // 0x118de0 - g_ps2RecompiledFunctionTable[25463] = procParaVoices_0x1188a0; // 0x118de4 - g_ps2RecompiledFunctionTable[25464] = procParaVoices_0x1188a0; // 0x118de8 - g_ps2RecompiledFunctionTable[25465] = procParaVoices_0x1188a0; // 0x118dec - g_ps2RecompiledFunctionTable[25466] = procParaVoices_0x1188a0; // 0x118df0 - g_ps2RecompiledFunctionTable[25467] = procParaVoices_0x1188a0; // 0x118df4 - g_ps2RecompiledFunctionTable[25468] = procParaVoices_0x1188a0; // 0x118df8 - g_ps2RecompiledFunctionTable[25469] = procParaVoices_0x1188a0; // 0x118dfc - g_ps2RecompiledFunctionTable[25470] = procParaVoices_0x1188a0; // 0x118e00 - g_ps2RecompiledFunctionTable[25471] = procParaVoices_0x1188a0; // 0x118e04 - g_ps2RecompiledFunctionTable[25472] = procParaVoices_0x1188a0; // 0x118e08 - g_ps2RecompiledFunctionTable[25473] = procParaVoices_0x1188a0; // 0x118e0c - g_ps2RecompiledFunctionTable[25474] = procParaVoices_0x1188a0; // 0x118e10 - g_ps2RecompiledFunctionTable[25475] = procParaVoices_0x1188a0; // 0x118e14 - g_ps2RecompiledFunctionTable[25476] = procParaVoices_0x1188a0; // 0x118e18 - g_ps2RecompiledFunctionTable[25477] = procParaVoices_0x1188a0; // 0x118e1c - g_ps2RecompiledFunctionTable[25478] = procParaVoices_0x1188a0; // 0x118e20 - g_ps2RecompiledFunctionTable[25479] = procParaVoices_0x1188a0; // 0x118e24 - g_ps2RecompiledFunctionTable[25480] = procParaVoices_0x1188a0; // 0x118e28 - g_ps2RecompiledFunctionTable[25481] = procParaVoices_0x1188a0; // 0x118e2c - g_ps2RecompiledFunctionTable[25482] = procParaVoices_0x1188a0; // 0x118e30 - g_ps2RecompiledFunctionTable[25483] = procParaVoices_0x1188a0; // 0x118e34 - g_ps2RecompiledFunctionTable[25484] = procParaVoices_0x1188a0; // 0x118e38 - g_ps2RecompiledFunctionTable[25485] = procParaVoices_0x1188a0; // 0x118e3c - g_ps2RecompiledFunctionTable[25486] = procParaVoices_0x1188a0; // 0x118e40 - g_ps2RecompiledFunctionTable[25487] = procParaVoices_0x1188a0; // 0x118e44 - g_ps2RecompiledFunctionTable[25488] = procParaVoices_0x1188a0; // 0x118e48 - g_ps2RecompiledFunctionTable[25489] = procParaVoices_0x1188a0; // 0x118e4c - g_ps2RecompiledFunctionTable[25490] = procParaVoices_0x1188a0; // 0x118e50 - g_ps2RecompiledFunctionTable[25491] = procParaVoices_0x1188a0; // 0x118e54 - g_ps2RecompiledFunctionTable[25492] = procParaVoices_0x1188a0; // 0x118e58 - g_ps2RecompiledFunctionTable[25493] = procParaVoices_0x1188a0; // 0x118e5c - g_ps2RecompiledFunctionTable[25494] = procParaVoices_0x1188a0; // 0x118e60 - g_ps2RecompiledFunctionTable[25495] = procParaVoices_0x1188a0; // 0x118e64 - g_ps2RecompiledFunctionTable[25496] = procParaVoices_0x1188a0; // 0x118e68 - g_ps2RecompiledFunctionTable[25497] = procParaVoices_0x1188a0; // 0x118e6c - g_ps2RecompiledFunctionTable[25498] = procParaVoices_0x1188a0; // 0x118e70 - g_ps2RecompiledFunctionTable[25499] = procParaVoices_0x1188a0; // 0x118e74 - g_ps2RecompiledFunctionTable[25500] = procParaVoices_0x1188a0; // 0x118e78 - g_ps2RecompiledFunctionTable[25501] = procParaVoices_0x1188a0; // 0x118e7c - g_ps2RecompiledFunctionTable[25502] = procParaVoices_0x1188a0; // 0x118e80 - g_ps2RecompiledFunctionTable[25503] = procParaVoices_0x1188a0; // 0x118e84 - g_ps2RecompiledFunctionTable[25504] = procParaVoices_0x1188a0; // 0x118e88 - g_ps2RecompiledFunctionTable[25505] = procParaVoices_0x1188a0; // 0x118e8c - g_ps2RecompiledFunctionTable[25506] = procParaVoices_0x1188a0; // 0x118e90 - g_ps2RecompiledFunctionTable[25507] = procParaVoices_0x1188a0; // 0x118e94 - g_ps2RecompiledFunctionTable[25508] = procParaVoices_0x1188a0; // 0x118e98 - g_ps2RecompiledFunctionTable[25509] = procParaVoices_0x1188a0; // 0x118e9c - g_ps2RecompiledFunctionTable[25510] = procParaVoices_0x1188a0; // 0x118ea0 - g_ps2RecompiledFunctionTable[25511] = procParaVoices_0x1188a0; // 0x118ea4 - g_ps2RecompiledFunctionTable[25512] = procParaVoices_0x1188a0; // 0x118ea8 - g_ps2RecompiledFunctionTable[25513] = procParaVoices_0x1188a0; // 0x118eac - g_ps2RecompiledFunctionTable[25514] = procParaVoices_0x1188a0; // 0x118eb0 - g_ps2RecompiledFunctionTable[25515] = procParaVoices_0x1188a0; // 0x118eb4 - g_ps2RecompiledFunctionTable[25516] = procParaVoices_0x1188a0; // 0x118eb8 - g_ps2RecompiledFunctionTable[25517] = procParaVoices_0x1188a0; // 0x118ebc - g_ps2RecompiledFunctionTable[25518] = procParaVoices_0x1188a0; // 0x118ec0 - g_ps2RecompiledFunctionTable[25519] = procParaVoices_0x1188a0; // 0x118ec4 - g_ps2RecompiledFunctionTable[25520] = procParaVoices_0x1188a0; // 0x118ec8 - g_ps2RecompiledFunctionTable[25521] = procParaVoices_0x1188a0; // 0x118ecc - g_ps2RecompiledFunctionTable[25522] = procParaVoices_0x1188a0; // 0x118ed0 - g_ps2RecompiledFunctionTable[25523] = procParaVoices_0x1188a0; // 0x118ed4 - g_ps2RecompiledFunctionTable[25524] = procParaVoices_0x1188a0; // 0x118ed8 - g_ps2RecompiledFunctionTable[25525] = procParaVoices_0x1188a0; // 0x118edc - g_ps2RecompiledFunctionTable[25526] = procParaVoices_0x1188a0; // 0x118ee0 - g_ps2RecompiledFunctionTable[25527] = procParaVoices_0x1188a0; // 0x118ee4 - g_ps2RecompiledFunctionTable[25528] = procParaVoices_0x1188a0; // 0x118ee8 - g_ps2RecompiledFunctionTable[25529] = procParaVoices_0x1188a0; // 0x118eec - g_ps2RecompiledFunctionTable[25530] = procParaVoices_0x1188a0; // 0x118ef0 - g_ps2RecompiledFunctionTable[25531] = procParaVoices_0x1188a0; // 0x118ef4 - g_ps2RecompiledFunctionTable[25532] = procParaVoices_0x1188a0; // 0x118ef8 - g_ps2RecompiledFunctionTable[25533] = procParaVoices_0x1188a0; // 0x118efc - g_ps2RecompiledFunctionTable[25534] = procParaVoices_0x1188a0; // 0x118f00 - g_ps2RecompiledFunctionTable[25535] = procParaVoices_0x1188a0; // 0x118f04 - g_ps2RecompiledFunctionTable[25536] = procParaVoices_0x1188a0; // 0x118f08 - g_ps2RecompiledFunctionTable[25537] = procParaVoices_0x1188a0; // 0x118f0c - g_ps2RecompiledFunctionTable[25538] = procParaVoices_0x1188a0; // 0x118f10 - g_ps2RecompiledFunctionTable[25539] = procParaVoices_0x1188a0; // 0x118f14 - g_ps2RecompiledFunctionTable[25540] = procParaVoices_0x1188a0; // 0x118f18 - g_ps2RecompiledFunctionTable[25541] = procParaVoices_0x1188a0; // 0x118f1c - g_ps2RecompiledFunctionTable[25542] = procParaVoices_0x1188a0; // 0x118f20 - g_ps2RecompiledFunctionTable[25543] = procParaVoices_0x1188a0; // 0x118f24 - g_ps2RecompiledFunctionTable[25544] = procParaVoices_0x1188a0; // 0x118f28 - g_ps2RecompiledFunctionTable[25545] = procParaVoices_0x1188a0; // 0x118f2c - g_ps2RecompiledFunctionTable[25546] = procParaVoices_0x1188a0; // 0x118f30 - g_ps2RecompiledFunctionTable[25547] = procParaVoices_0x1188a0; // 0x118f34 - g_ps2RecompiledFunctionTable[25548] = procParaVoices_0x1188a0; // 0x118f38 - g_ps2RecompiledFunctionTable[25549] = procParaVoices_0x1188a0; // 0x118f3c - g_ps2RecompiledFunctionTable[25550] = procParaVoices_0x1188a0; // 0x118f40 - g_ps2RecompiledFunctionTable[25551] = procParaVoices_0x1188a0; // 0x118f44 - g_ps2RecompiledFunctionTable[25552] = procParaVoices_0x1188a0; // 0x118f48 - g_ps2RecompiledFunctionTable[25553] = procParaVoices_0x1188a0; // 0x118f4c - g_ps2RecompiledFunctionTable[25554] = procParaVoices_0x1188a0; // 0x118f50 - g_ps2RecompiledFunctionTable[25555] = procParaVoices_0x1188a0; // 0x118f54 - g_ps2RecompiledFunctionTable[25556] = procParaVoices_0x1188a0; // 0x118f58 - g_ps2RecompiledFunctionTable[25557] = procParaVoices_0x1188a0; // 0x118f5c - g_ps2RecompiledFunctionTable[25558] = procParaVoices_0x1188a0; // 0x118f60 - g_ps2RecompiledFunctionTable[25559] = procParaVoices_0x1188a0; // 0x118f64 - g_ps2RecompiledFunctionTable[25560] = procParaVoices_0x1188a0; // 0x118f68 - g_ps2RecompiledFunctionTable[25561] = procParaVoices_0x1188a0; // 0x118f6c - g_ps2RecompiledFunctionTable[25562] = procParaVoices_0x1188a0; // 0x118f70 - g_ps2RecompiledFunctionTable[25563] = procParaVoices_0x1188a0; // 0x118f74 - g_ps2RecompiledFunctionTable[25564] = procParaVoices_0x1188a0; // 0x118f78 - g_ps2RecompiledFunctionTable[25565] = procParaVoices_0x1188a0; // 0x118f7c - g_ps2RecompiledFunctionTable[25566] = procParaVoices_0x1188a0; // 0x118f80 - g_ps2RecompiledFunctionTable[25567] = procParaVoices_0x1188a0; // 0x118f84 - g_ps2RecompiledFunctionTable[25568] = procParaVoices_0x1188a0; // 0x118f88 - g_ps2RecompiledFunctionTable[25569] = procParaVoices_0x1188a0; // 0x118f8c - g_ps2RecompiledFunctionTable[25570] = procParaVoices_0x1188a0; // 0x118f90 - g_ps2RecompiledFunctionTable[25571] = procParaVoices_0x1188a0; // 0x118f94 - g_ps2RecompiledFunctionTable[25572] = procParaVoices_0x1188a0; // 0x118f98 - g_ps2RecompiledFunctionTable[25573] = procParaVoices_0x1188a0; // 0x118f9c - g_ps2RecompiledFunctionTable[25574] = procParaVoices_0x1188a0; // 0x118fa0 - g_ps2RecompiledFunctionTable[25575] = procParaVoices_0x1188a0; // 0x118fa4 - g_ps2RecompiledFunctionTable[25576] = procParaVoices_0x1188a0; // 0x118fa8 - g_ps2RecompiledFunctionTable[25577] = procParaVoices_0x1188a0; // 0x118fac - g_ps2RecompiledFunctionTable[25578] = procParaVoices_0x1188a0; // 0x118fb0 - g_ps2RecompiledFunctionTable[25579] = procParaVoices_0x1188a0; // 0x118fb4 - g_ps2RecompiledFunctionTable[25580] = procParaVoices_0x1188a0; // 0x118fb8 - g_ps2RecompiledFunctionTable[25581] = procParaVoices_0x1188a0; // 0x118fbc - g_ps2RecompiledFunctionTable[25582] = procParaVoices_0x1188a0; // 0x118fc0 - g_ps2RecompiledFunctionTable[25583] = procParaVoices_0x1188a0; // 0x118fc4 - g_ps2RecompiledFunctionTable[25584] = procParaVoices_0x1188a0; // 0x118fc8 - g_ps2RecompiledFunctionTable[25585] = procParaVoices_0x1188a0; // 0x118fcc - g_ps2RecompiledFunctionTable[25586] = procParaVoices_0x1188a0; // 0x118fd0 - g_ps2RecompiledFunctionTable[25587] = procParaVoices_0x1188a0; // 0x118fd4 - g_ps2RecompiledFunctionTable[25588] = procParaVoices_0x1188a0; // 0x118fd8 - g_ps2RecompiledFunctionTable[25589] = procParaVoices_0x1188a0; // 0x118fdc - g_ps2RecompiledFunctionTable[25590] = procParaVoices_0x1188a0; // 0x118fe0 - g_ps2RecompiledFunctionTable[25591] = procParaVoices_0x1188a0; // 0x118fe4 - g_ps2RecompiledFunctionTable[25592] = procParaVoices_0x1188a0; // 0x118fe8 - g_ps2RecompiledFunctionTable[25593] = procParaVoices_0x1188a0; // 0x118fec - g_ps2RecompiledFunctionTable[25594] = procParaVoices_0x1188a0; // 0x118ff0 - g_ps2RecompiledFunctionTable[25595] = procParaVoices_0x1188a0; // 0x118ff4 - g_ps2RecompiledFunctionTable[25596] = procParaVoices_0x1188a0; // 0x118ff8 - g_ps2RecompiledFunctionTable[25597] = procParaVoices_0x1188a0; // 0x118ffc - g_ps2RecompiledFunctionTable[25598] = procParaVoices_0x1188a0; // 0x119000 - g_ps2RecompiledFunctionTable[25599] = procParaVoices_0x1188a0; // 0x119004 - g_ps2RecompiledFunctionTable[25600] = procParaVoices_0x1188a0; // 0x119008 - g_ps2RecompiledFunctionTable[25601] = procParaVoices_0x1188a0; // 0x11900c - g_ps2RecompiledFunctionTable[25602] = procParaVoices_0x1188a0; // 0x119010 - g_ps2RecompiledFunctionTable[25603] = procParaVoices_0x1188a0; // 0x119014 - g_ps2RecompiledFunctionTable[25604] = procParaVoices_0x1188a0; // 0x119018 - g_ps2RecompiledFunctionTable[25605] = procParaVoices_0x1188a0; // 0x11901c - g_ps2RecompiledFunctionTable[25606] = procParaVoices_0x1188a0; // 0x119020 - g_ps2RecompiledFunctionTable[25607] = procParaVoices_0x1188a0; // 0x119024 - g_ps2RecompiledFunctionTable[25608] = procParaVoices_0x1188a0; // 0x119028 - g_ps2RecompiledFunctionTable[25609] = procParaVoices_0x1188a0; // 0x11902c - g_ps2RecompiledFunctionTable[25610] = procParaVoices_0x1188a0; // 0x119030 - g_ps2RecompiledFunctionTable[25611] = procParaVoices_0x1188a0; // 0x119034 - g_ps2RecompiledFunctionTable[25612] = procParaVoices_0x1188a0; // 0x119038 - g_ps2RecompiledFunctionTable[25613] = procParaVoices_0x1188a0; // 0x11903c - g_ps2RecompiledFunctionTable[25614] = procParaVoices_0x1188a0; // 0x119040 - g_ps2RecompiledFunctionTable[25615] = procParaVoices_0x1188a0; // 0x119044 - g_ps2RecompiledFunctionTable[25616] = procParaVoices_0x1188a0; // 0x119048 - g_ps2RecompiledFunctionTable[25617] = procParaVoices_0x1188a0; // 0x11904c - g_ps2RecompiledFunctionTable[25618] = procParaVoices_0x1188a0; // 0x119050 - g_ps2RecompiledFunctionTable[25619] = procParaVoices_0x1188a0; // 0x119054 - g_ps2RecompiledFunctionTable[25620] = procParaVoices_0x1188a0; // 0x119058 - g_ps2RecompiledFunctionTable[25621] = procParaVoices_0x1188a0; // 0x11905c - g_ps2RecompiledFunctionTable[25622] = procParaVoices_0x1188a0; // 0x119060 - g_ps2RecompiledFunctionTable[25624] = clrSprWorkCurVoice_0x119068; // 0x119068 - g_ps2RecompiledFunctionTable[25628] = clrSprWorkCurVoice_0x119068; // 0x119078 - g_ps2RecompiledFunctionTable[25638] = toneGeneratorProc_0x1190a0; // 0x1190a0 - g_ps2RecompiledFunctionTable[25654] = toneGeneratorProc_0x1190a0; // 0x1190e0 - g_ps2RecompiledFunctionTable[25665] = toneGeneratorProc_0x1190a0; // 0x11910c - g_ps2RecompiledFunctionTable[25669] = toneGeneratorProc_0x1190a0; // 0x11911c - g_ps2RecompiledFunctionTable[25671] = toneGeneratorProc_0x1190a0; // 0x119124 - g_ps2RecompiledFunctionTable[25686] = sceSynthesizerTonegenerator_0x119160; // 0x119160 - g_ps2RecompiledFunctionTable[25892] = setupStartVoiceOutput_0x119498; // 0x119498 - g_ps2RecompiledFunctionTable[25908] = setupStartVoiceOutput_0x119498; // 0x1194d8 - g_ps2RecompiledFunctionTable[25926] = setupStartVoiceOutput_0x119498; // 0x119520 - g_ps2RecompiledFunctionTable[25940] = setupStartVoiceNoise_0x119558; // 0x119558 - g_ps2RecompiledFunctionTable[25965] = setupStartVoiceNoise_0x119558; // 0x1195bc - g_ps2RecompiledFunctionTable[25976] = setupStartVoicePcm_0x1195e8; // 0x1195e8 - g_ps2RecompiledFunctionTable[26144] = setupStartVoicePcm_0x1195e8; // 0x119888 - g_ps2RecompiledFunctionTable[26156] = setupStartVoiceEnv_0x1198b8; // 0x1198b8 - g_ps2RecompiledFunctionTable[26206] = setupStartVoiceEnv_0x1198b8; // 0x119980 - g_ps2RecompiledFunctionTable[26253] = setupStartVoiceEnv_0x1198b8; // 0x119a3c - g_ps2RecompiledFunctionTable[26256] = setupStartVoiceLfo_0x119a48; // 0x119a48 - g_ps2RecompiledFunctionTable[26298] = setupStartVoiceLfo_0x119a48; // 0x119af0 - g_ps2RecompiledFunctionTable[26302] = setupStartVoiceTvf_0x119b00; // 0x119b00 - g_ps2RecompiledFunctionTable[26316] = setupStartVoiceTvf_0x119b00; // 0x119b38 - g_ps2RecompiledFunctionTable[26363] = setupStartVoiceTvf_0x119b00; // 0x119bf4 - g_ps2RecompiledFunctionTable[26414] = sceSynthesizerSetupMidiPanpot_0x119cc0; // 0x119cc0 - g_ps2RecompiledFunctionTable[26446] = setupStartVoicePanpot_0x119d40; // 0x119d40 - g_ps2RecompiledFunctionTable[26458] = setupStartVoicePanpot_0x119d40; // 0x119d70 - g_ps2RecompiledFunctionTable[26524] = setupStartVoicePortamento_0x119e78; // 0x119e78 - g_ps2RecompiledFunctionTable[26554] = sceSynthesizerSetupMidiModuration_0x119ef0; // 0x119ef0 - g_ps2RecompiledFunctionTable[26628] = setupStartVoice_0x11a018; // 0x11a018 - g_ps2RecompiledFunctionTable[26647] = setupStartVoice_0x11a018; // 0x11a064 - g_ps2RecompiledFunctionTable[26650] = setupStartVoice_0x11a018; // 0x11a070 - g_ps2RecompiledFunctionTable[26660] = setupStartVoice_0x11a018; // 0x11a098 - g_ps2RecompiledFunctionTable[26664] = setupStartVoice_0x11a018; // 0x11a0a8 - g_ps2RecompiledFunctionTable[26672] = setupStartVoice_0x11a018; // 0x11a0c8 - g_ps2RecompiledFunctionTable[26681] = setupStartVoice_0x11a018; // 0x11a0ec - g_ps2RecompiledFunctionTable[26694] = setupStartVoice_0x11a018; // 0x11a120 - g_ps2RecompiledFunctionTable[26701] = setupStartVoice_0x11a018; // 0x11a13c - g_ps2RecompiledFunctionTable[26717] = setupStartVoice_0x11a018; // 0x11a17c - g_ps2RecompiledFunctionTable[26747] = setupStartVoice_0x11a018; // 0x11a1f4 - g_ps2RecompiledFunctionTable[26759] = setupStartVoice_0x11a018; // 0x11a224 - g_ps2RecompiledFunctionTable[26767] = setupStartVoice_0x11a018; // 0x11a244 - g_ps2RecompiledFunctionTable[26777] = setupStartVoice_0x11a018; // 0x11a26c - g_ps2RecompiledFunctionTable[26784] = setupStartVoice_0x11a018; // 0x11a288 - g_ps2RecompiledFunctionTable[26802] = setupStartVoice_0x11a018; // 0x11a2d0 - g_ps2RecompiledFunctionTable[26809] = setupStartVoice_0x11a018; // 0x11a2ec - g_ps2RecompiledFunctionTable[26813] = setupStartVoice_0x11a018; // 0x11a2fc - g_ps2RecompiledFunctionTable[26839] = setupStartVoice_0x11a018; // 0x11a364 - g_ps2RecompiledFunctionTable[26865] = setupStartVoice_0x11a018; // 0x11a3cc - g_ps2RecompiledFunctionTable[26869] = setupStartVoice_0x11a018; // 0x11a3dc - g_ps2RecompiledFunctionTable[26886] = popVoiceFromLink_0x11a420; // 0x11a420 - g_ps2RecompiledFunctionTable[26894] = putVoiceToTop_0x11a440; // 0x11a440 - g_ps2RecompiledFunctionTable[26900] = putVoiceToBottom_0x11a458; // 0x11a458 - g_ps2RecompiledFunctionTable[26906] = sceSynthesizerDmaSpr_0x11a470; // 0x11a470 - g_ps2RecompiledFunctionTable[26920] = sceSynthesizerDmaFromSPR_0x11a4a8; // 0x11a4a8 - g_ps2RecompiledFunctionTable[26958] = sceSynthesizerDmaToSPR_0x11a540; // 0x11a540 - g_ps2RecompiledFunctionTable[26998] = sceSynthesizerWaitDmaFromSPR_0x11a5e0; // 0x11a5e0 - g_ps2RecompiledFunctionTable[27004] = sceSynthesizerWaitDmaToSPR_0x11a5f8; // 0x11a5f8 - g_ps2RecompiledFunctionTable[27010] = sceSynthesizerSetupDma_0x11a610; // 0x11a610 - g_ps2RecompiledFunctionTable[27024] = sceSynthesizerRestorDma_0x11a648; // 0x11a648 - g_ps2RecompiledFunctionTable[27036] = clr_nrpm_mod_0x11a678; // 0x11a678 - g_ps2RecompiledFunctionTable[27048] = clr_nrpm_allmod_0x11a6a8; // 0x11a6a8 - g_ps2RecompiledFunctionTable[27052] = sceSynthesizerResetPart_0x11a6b8; // 0x11a6b8 - g_ps2RecompiledFunctionTable[27078] = sceSynthesizerClearKeyMap_0x11a720; // 0x11a720 - g_ps2RecompiledFunctionTable[27080] = fillkmap_0x11a728; // 0x11a728 - g_ps2RecompiledFunctionTable[27082] = fillkmap_0x11a728; // 0x11a730 - g_ps2RecompiledFunctionTable[27092] = clr_drum_nrpn_0x11a758; // 0x11a758 - g_ps2RecompiledFunctionTable[27098] = clr_drum_nrpn_0x11a758; // 0x11a770 - g_ps2RecompiledFunctionTable[27100] = clr_drum_nrpn_0x11a758; // 0x11a778 - g_ps2RecompiledFunctionTable[27102] = clr_drum_nrpn_0x11a758; // 0x11a780 - g_ps2RecompiledFunctionTable[27108] = sceSynthsizerGetMeloPatch_0x11a798; // 0x11a798 - g_ps2RecompiledFunctionTable[27132] = sceSynthsizerGetDrumPatch_0x11a7f8; // 0x11a7f8 - g_ps2RecompiledFunctionTable[27152] = sceSynthesizerGetPartial_0x11a848; // 0x11a848 - g_ps2RecompiledFunctionTable[27164] = sceSynthesizerGetSampleParam_0x11a878; // 0x11a878 - g_ps2RecompiledFunctionTable[27208] = sceSynthesizerSelectPatch_0x11a928; // 0x11a928 - g_ps2RecompiledFunctionTable[27246] = changeVoiceFloatStateOnMyPart_0x11a9c0; // 0x11a9c0 - g_ps2RecompiledFunctionTable[27247] = changeVoiceFloatStateOnMyPart_0x11a9c0; // 0x11a9c4 - g_ps2RecompiledFunctionTable[27248] = changeVoiceFloatStateOnMyPart_0x11a9c0; // 0x11a9c8 - g_ps2RecompiledFunctionTable[27249] = changeVoiceFloatStateOnMyPart_0x11a9c0; // 0x11a9cc - g_ps2RecompiledFunctionTable[27250] = changeVoiceFloatStateOnMyPart_0x11a9c0; // 0x11a9d0 - g_ps2RecompiledFunctionTable[27251] = changeVoiceFloatStateOnMyPart_0x11a9c0; // 0x11a9d4 - g_ps2RecompiledFunctionTable[27252] = changeVoiceFloatStateOnMyPart_0x11a9c0; // 0x11a9d8 - g_ps2RecompiledFunctionTable[27253] = changeVoiceFloatStateOnMyPart_0x11a9c0; // 0x11a9dc - g_ps2RecompiledFunctionTable[27254] = changeVoiceFloatStateOnMyPart_0x11a9c0; // 0x11a9e0 - g_ps2RecompiledFunctionTable[27255] = changeVoiceFloatStateOnMyPart_0x11a9c0; // 0x11a9e4 - g_ps2RecompiledFunctionTable[27256] = changeVoiceFloatStateOnMyPart_0x11a9c0; // 0x11a9e8 - g_ps2RecompiledFunctionTable[27257] = changeVoiceFloatStateOnMyPart_0x11a9c0; // 0x11a9ec - g_ps2RecompiledFunctionTable[27258] = changeVoiceFloatStateOnMyPart_0x11a9c0; // 0x11a9f0 - g_ps2RecompiledFunctionTable[27259] = changeVoiceFloatStateOnMyPart_0x11a9c0; // 0x11a9f4 - g_ps2RecompiledFunctionTable[27260] = changeVoiceFloatStateOnMyPart_0x11a9c0; // 0x11a9f8 - g_ps2RecompiledFunctionTable[27261] = changeVoiceFloatStateOnMyPart_0x11a9c0; // 0x11a9fc - g_ps2RecompiledFunctionTable[27262] = changeVoiceFloatStateOnMyPart_0x11a9c0; // 0x11aa00 - g_ps2RecompiledFunctionTable[27263] = changeVoiceFloatStateOnMyPart_0x11a9c0; // 0x11aa04 - g_ps2RecompiledFunctionTable[27264] = changeVoiceFloatStateOnMyPart_0x11a9c0; // 0x11aa08 - g_ps2RecompiledFunctionTable[27265] = changeVoiceFloatStateOnMyPart_0x11a9c0; // 0x11aa0c - g_ps2RecompiledFunctionTable[27266] = changeVoiceFloatStateOnMyPart_0x11a9c0; // 0x11aa10 - g_ps2RecompiledFunctionTable[27267] = changeVoiceFloatStateOnMyPart_0x11a9c0; // 0x11aa14 - g_ps2RecompiledFunctionTable[27268] = changeVoiceFloatStateOnMyPart_0x11a9c0; // 0x11aa18 - g_ps2RecompiledFunctionTable[27269] = changeVoiceFloatStateOnMyPart_0x11a9c0; // 0x11aa1c - g_ps2RecompiledFunctionTable[27270] = changeVoiceFloatStateOnMyPart_0x11a9c0; // 0x11aa20 - g_ps2RecompiledFunctionTable[27271] = changeVoiceFloatStateOnMyPart_0x11a9c0; // 0x11aa24 - g_ps2RecompiledFunctionTable[27272] = changeVoiceFloatStateOnMyPart_0x11a9c0; // 0x11aa28 - g_ps2RecompiledFunctionTable[27273] = changeVoiceFloatStateOnMyPart_0x11a9c0; // 0x11aa2c - g_ps2RecompiledFunctionTable[27274] = changeVoiceFloatStateOnMyPart_0x11a9c0; // 0x11aa30 - g_ps2RecompiledFunctionTable[27275] = changeVoiceFloatStateOnMyPart_0x11a9c0; // 0x11aa34 - g_ps2RecompiledFunctionTable[27276] = changeVoiceFloatStateOnMyPart_0x11a9c0; // 0x11aa38 - g_ps2RecompiledFunctionTable[27277] = changeVoiceFloatStateOnMyPart_0x11a9c0; // 0x11aa3c - g_ps2RecompiledFunctionTable[27278] = changeVoiceFloatStateOnMyPart_0x11a9c0; // 0x11aa40 - g_ps2RecompiledFunctionTable[27279] = changeVoiceFloatStateOnMyPart_0x11a9c0; // 0x11aa44 - g_ps2RecompiledFunctionTable[27280] = changeVoiceFloatStateOnMyPart_0x11a9c0; // 0x11aa48 - g_ps2RecompiledFunctionTable[27281] = changeVoiceFloatStateOnMyPart_0x11a9c0; // 0x11aa4c - g_ps2RecompiledFunctionTable[27282] = changeVoiceFloatStateOnMyPart_0x11a9c0; // 0x11aa50 - g_ps2RecompiledFunctionTable[27283] = changeVoiceFloatStateOnMyPart_0x11a9c0; // 0x11aa54 - g_ps2RecompiledFunctionTable[27284] = changeVoiceFloatStateOnMyPart_0x11a9c0; // 0x11aa58 - g_ps2RecompiledFunctionTable[27285] = changeVoiceFloatStateOnMyPart_0x11a9c0; // 0x11aa5c - g_ps2RecompiledFunctionTable[27286] = changeVoiceFloatStateOnMyPart_0x11a9c0; // 0x11aa60 - g_ps2RecompiledFunctionTable[27287] = changeVoiceFloatStateOnMyPart_0x11a9c0; // 0x11aa64 - g_ps2RecompiledFunctionTable[27288] = changeVoiceFloatStateOnMyPart_0x11a9c0; // 0x11aa68 - g_ps2RecompiledFunctionTable[27289] = changeVoiceFloatStateOnMyPart_0x11a9c0; // 0x11aa6c - g_ps2RecompiledFunctionTable[27290] = changeVoiceFloatStateOnMyPart_0x11a9c0; // 0x11aa70 - g_ps2RecompiledFunctionTable[27291] = changeVoiceFloatStateOnMyPart_0x11a9c0; // 0x11aa74 - g_ps2RecompiledFunctionTable[27292] = changeVoiceFloatStateOnMyPart_0x11a9c0; // 0x11aa78 - g_ps2RecompiledFunctionTable[27293] = changeVoiceFloatStateOnMyPart_0x11a9c0; // 0x11aa7c - g_ps2RecompiledFunctionTable[27294] = changeVoiceFloatStateOnMyPart_0x11a9c0; // 0x11aa80 - g_ps2RecompiledFunctionTable[27295] = changeVoiceFloatStateOnMyPart_0x11a9c0; // 0x11aa84 - g_ps2RecompiledFunctionTable[27296] = changeVoiceFloatStateOnMyPart_0x11a9c0; // 0x11aa88 - g_ps2RecompiledFunctionTable[27297] = changeVoiceFloatStateOnMyPart_0x11a9c0; // 0x11aa8c - g_ps2RecompiledFunctionTable[27298] = changeVoiceFloatStateOnMyPart_0x11a9c0; // 0x11aa90 - g_ps2RecompiledFunctionTable[27299] = changeVoiceFloatStateOnMyPart_0x11a9c0; // 0x11aa94 - g_ps2RecompiledFunctionTable[27300] = changeVoiceFloatStateOnMyPart_0x11a9c0; // 0x11aa98 - g_ps2RecompiledFunctionTable[27301] = changeVoiceFloatStateOnMyPart_0x11a9c0; // 0x11aa9c - g_ps2RecompiledFunctionTable[27302] = changeVoiceFloatStateOnMyPart_0x11a9c0; // 0x11aaa0 - g_ps2RecompiledFunctionTable[27303] = changeVoiceFloatStateOnMyPart_0x11a9c0; // 0x11aaa4 - g_ps2RecompiledFunctionTable[27304] = changeVoiceFloatStateOnMyPart_0x11a9c0; // 0x11aaa8 - g_ps2RecompiledFunctionTable[27305] = changeVoiceFloatStateOnMyPart_0x11a9c0; // 0x11aaac - g_ps2RecompiledFunctionTable[27306] = changeVoiceFloatStateOnMyPart_0x11a9c0; // 0x11aab0 - g_ps2RecompiledFunctionTable[27307] = changeVoiceFloatStateOnMyPart_0x11a9c0; // 0x11aab4 - g_ps2RecompiledFunctionTable[27308] = changeVoiceFloatStateOnMyPart_0x11a9c0; // 0x11aab8 - g_ps2RecompiledFunctionTable[27309] = changeVoiceFloatStateOnMyPart_0x11a9c0; // 0x11aabc - g_ps2RecompiledFunctionTable[27310] = changeVoiceFloatStateOnMyPart_0x11a9c0; // 0x11aac0 - g_ps2RecompiledFunctionTable[27311] = changeVoiceFloatStateOnMyPart_0x11a9c0; // 0x11aac4 - g_ps2RecompiledFunctionTable[27312] = _callback_sceSynthesizerChangePartPitchBend_0x11aac8; // 0x11aac8 - g_ps2RecompiledFunctionTable[27314] = ChangePitchBendAndDepth_0x11aad0; // 0x11aad0 - g_ps2RecompiledFunctionTable[27322] = sceSynthesizerChangePartPitchBend_0x11aaf0; // 0x11aaf0 - g_ps2RecompiledFunctionTable[27338] = sceSynthesizerChangePartBendSens_0x11ab30; // 0x11ab30 - g_ps2RecompiledFunctionTable[27354] = _callback_sceSynthesizerChangePartVolumeExpression_0x11ab70; // 0x11ab70 - g_ps2RecompiledFunctionTable[27356] = ChangePartVolumeExpression_0x11ab78; // 0x11ab78 - g_ps2RecompiledFunctionTable[27382] = sceSynthesizerChangePartVolume_0x11abe0; // 0x11abe0 - g_ps2RecompiledFunctionTable[27390] = sceSynthesizerChangePartExpression_0x11ac00; // 0x11ac00 - g_ps2RecompiledFunctionTable[27398] = sceSynthesizerChangePartModuration_0x11ac20; // 0x11ac20 - g_ps2RecompiledFunctionTable[27470] = sceSynthesizerChangePortamento_0x11ad40; // 0x11ad40 - g_ps2RecompiledFunctionTable[27484] = sceSynthesizerChangePortamentoTime_0x11ad78; // 0x11ad78 - g_ps2RecompiledFunctionTable[27490] = sceSynthesizerChangePanpot_0x11ad90; // 0x11ad90 - g_ps2RecompiledFunctionTable[27508] = _callback_sceSynthesizerChangeEffectSend0_0x11add8; // 0x11add8 - g_ps2RecompiledFunctionTable[27510] = _callback_sceSynthesizerChangeEffectSend1_0x11ade0; // 0x11ade0 - g_ps2RecompiledFunctionTable[27512] = _callback_sceSynthesizerChangeEffectSend2_0x11ade8; // 0x11ade8 - g_ps2RecompiledFunctionTable[27514] = _callback_sceSynthesizerChangeEffectSend3_0x11adf0; // 0x11adf0 - g_ps2RecompiledFunctionTable[27516] = sceSynthesizerChangeEffectSend_0x11adf8; // 0x11adf8 - g_ps2RecompiledFunctionTable[27558] = sceSynthesizerChangeOutAttrib_0x11aea0; // 0x11aea0 - g_ps2RecompiledFunctionTable[27564] = sceSynthesizerChangeOutVol_0x11aeb8; // 0x11aeb8 - g_ps2RecompiledFunctionTable[27566] = sceSynthesizerSetRVoice_0x11aec0; // 0x11aec0 - g_ps2RecompiledFunctionTable[27568] = _callback_sceSynthesizerChangeNrpnCutOff_0x11aec8; // 0x11aec8 - g_ps2RecompiledFunctionTable[27570] = sceSynthesizerChangeNrpnCutOff_0x11aed0; // 0x11aed0 - g_ps2RecompiledFunctionTable[27590] = sceSynthesizerChangeNrpnLfoRate_0x11af20; // 0x11af20 - g_ps2RecompiledFunctionTable[27644] = _callback_sceSynthesizerChangeNrpnLfoDepth_0x11aff8; // 0x11aff8 - g_ps2RecompiledFunctionTable[27646] = sceSynthesizerChangeNrpnLfoDepth_0x11b000; // 0x11b000 - g_ps2RecompiledFunctionTable[27662] = changeVoiceFloatHsStateOnMyPart_0x11b040; // 0x11b040 - g_ps2RecompiledFunctionTable[27663] = changeVoiceFloatHsStateOnMyPart_0x11b040; // 0x11b044 - g_ps2RecompiledFunctionTable[27664] = changeVoiceFloatHsStateOnMyPart_0x11b040; // 0x11b048 - g_ps2RecompiledFunctionTable[27665] = changeVoiceFloatHsStateOnMyPart_0x11b040; // 0x11b04c - g_ps2RecompiledFunctionTable[27666] = changeVoiceFloatHsStateOnMyPart_0x11b040; // 0x11b050 - g_ps2RecompiledFunctionTable[27667] = changeVoiceFloatHsStateOnMyPart_0x11b040; // 0x11b054 - g_ps2RecompiledFunctionTable[27668] = changeVoiceFloatHsStateOnMyPart_0x11b040; // 0x11b058 - g_ps2RecompiledFunctionTable[27669] = changeVoiceFloatHsStateOnMyPart_0x11b040; // 0x11b05c - g_ps2RecompiledFunctionTable[27670] = changeVoiceFloatHsStateOnMyPart_0x11b040; // 0x11b060 - g_ps2RecompiledFunctionTable[27671] = changeVoiceFloatHsStateOnMyPart_0x11b040; // 0x11b064 - g_ps2RecompiledFunctionTable[27672] = changeVoiceFloatHsStateOnMyPart_0x11b040; // 0x11b068 - g_ps2RecompiledFunctionTable[27673] = changeVoiceFloatHsStateOnMyPart_0x11b040; // 0x11b06c - g_ps2RecompiledFunctionTable[27674] = changeVoiceFloatHsStateOnMyPart_0x11b040; // 0x11b070 - g_ps2RecompiledFunctionTable[27675] = changeVoiceFloatHsStateOnMyPart_0x11b040; // 0x11b074 - g_ps2RecompiledFunctionTable[27676] = changeVoiceFloatHsStateOnMyPart_0x11b040; // 0x11b078 - g_ps2RecompiledFunctionTable[27677] = changeVoiceFloatHsStateOnMyPart_0x11b040; // 0x11b07c - g_ps2RecompiledFunctionTable[27678] = changeVoiceFloatHsStateOnMyPart_0x11b040; // 0x11b080 - g_ps2RecompiledFunctionTable[27679] = changeVoiceFloatHsStateOnMyPart_0x11b040; // 0x11b084 - g_ps2RecompiledFunctionTable[27680] = changeVoiceFloatHsStateOnMyPart_0x11b040; // 0x11b088 - g_ps2RecompiledFunctionTable[27681] = changeVoiceFloatHsStateOnMyPart_0x11b040; // 0x11b08c - g_ps2RecompiledFunctionTable[27682] = changeVoiceFloatHsStateOnMyPart_0x11b040; // 0x11b090 - g_ps2RecompiledFunctionTable[27683] = changeVoiceFloatHsStateOnMyPart_0x11b040; // 0x11b094 - g_ps2RecompiledFunctionTable[27684] = changeVoiceFloatHsStateOnMyPart_0x11b040; // 0x11b098 - g_ps2RecompiledFunctionTable[27685] = changeVoiceFloatHsStateOnMyPart_0x11b040; // 0x11b09c - g_ps2RecompiledFunctionTable[27686] = changeVoiceFloatHsStateOnMyPart_0x11b040; // 0x11b0a0 - g_ps2RecompiledFunctionTable[27687] = changeVoiceFloatHsStateOnMyPart_0x11b040; // 0x11b0a4 - g_ps2RecompiledFunctionTable[27688] = changeVoiceFloatHsStateOnMyPart_0x11b040; // 0x11b0a8 - g_ps2RecompiledFunctionTable[27689] = changeVoiceFloatHsStateOnMyPart_0x11b040; // 0x11b0ac - g_ps2RecompiledFunctionTable[27690] = changeVoiceFloatHsStateOnMyPart_0x11b040; // 0x11b0b0 - g_ps2RecompiledFunctionTable[27691] = changeVoiceFloatHsStateOnMyPart_0x11b040; // 0x11b0b4 - g_ps2RecompiledFunctionTable[27692] = changeVoiceFloatHsStateOnMyPart_0x11b040; // 0x11b0b8 - g_ps2RecompiledFunctionTable[27693] = changeVoiceFloatHsStateOnMyPart_0x11b040; // 0x11b0bc - g_ps2RecompiledFunctionTable[27694] = changeVoiceFloatHsStateOnMyPart_0x11b040; // 0x11b0c0 - g_ps2RecompiledFunctionTable[27695] = changeVoiceFloatHsStateOnMyPart_0x11b040; // 0x11b0c4 - g_ps2RecompiledFunctionTable[27696] = changeVoiceFloatHsStateOnMyPart_0x11b040; // 0x11b0c8 - g_ps2RecompiledFunctionTable[27697] = changeVoiceFloatHsStateOnMyPart_0x11b040; // 0x11b0cc - g_ps2RecompiledFunctionTable[27698] = changeVoiceFloatHsStateOnMyPart_0x11b040; // 0x11b0d0 - g_ps2RecompiledFunctionTable[27699] = changeVoiceFloatHsStateOnMyPart_0x11b040; // 0x11b0d4 - g_ps2RecompiledFunctionTable[27700] = changeVoiceFloatHsStateOnMyPart_0x11b040; // 0x11b0d8 - g_ps2RecompiledFunctionTable[27701] = changeVoiceFloatHsStateOnMyPart_0x11b040; // 0x11b0dc - g_ps2RecompiledFunctionTable[27702] = changeVoiceFloatHsStateOnMyPart_0x11b040; // 0x11b0e0 - g_ps2RecompiledFunctionTable[27703] = changeVoiceFloatHsStateOnMyPart_0x11b040; // 0x11b0e4 - g_ps2RecompiledFunctionTable[27704] = changeVoiceFloatHsStateOnMyPart_0x11b040; // 0x11b0e8 - g_ps2RecompiledFunctionTable[27705] = changeVoiceFloatHsStateOnMyPart_0x11b040; // 0x11b0ec - g_ps2RecompiledFunctionTable[27706] = changeVoiceFloatHsStateOnMyPart_0x11b040; // 0x11b0f0 - g_ps2RecompiledFunctionTable[27707] = changeVoiceFloatHsStateOnMyPart_0x11b040; // 0x11b0f4 - g_ps2RecompiledFunctionTable[27708] = changeVoiceFloatHsStateOnMyPart_0x11b040; // 0x11b0f8 - g_ps2RecompiledFunctionTable[27709] = changeVoiceFloatHsStateOnMyPart_0x11b040; // 0x11b0fc - g_ps2RecompiledFunctionTable[27710] = changeVoiceFloatHsStateOnMyPart_0x11b040; // 0x11b100 - g_ps2RecompiledFunctionTable[27711] = changeVoiceFloatHsStateOnMyPart_0x11b040; // 0x11b104 - g_ps2RecompiledFunctionTable[27712] = changeVoiceFloatHsStateOnMyPart_0x11b040; // 0x11b108 - g_ps2RecompiledFunctionTable[27713] = changeVoiceFloatHsStateOnMyPart_0x11b040; // 0x11b10c - g_ps2RecompiledFunctionTable[27714] = changeVoiceFloatHsStateOnMyPart_0x11b040; // 0x11b110 - g_ps2RecompiledFunctionTable[27715] = changeVoiceFloatHsStateOnMyPart_0x11b040; // 0x11b114 - g_ps2RecompiledFunctionTable[27716] = changeVoiceFloatHsStateOnMyPart_0x11b040; // 0x11b118 - g_ps2RecompiledFunctionTable[27717] = changeVoiceFloatHsStateOnMyPart_0x11b040; // 0x11b11c - g_ps2RecompiledFunctionTable[27718] = changeVoiceFloatHsStateOnMyPart_0x11b040; // 0x11b120 - g_ps2RecompiledFunctionTable[27719] = changeVoiceFloatHsStateOnMyPart_0x11b040; // 0x11b124 - g_ps2RecompiledFunctionTable[27720] = changeVoiceFloatHsStateOnMyPart_0x11b040; // 0x11b128 - g_ps2RecompiledFunctionTable[27721] = changeVoiceFloatHsStateOnMyPart_0x11b040; // 0x11b12c - g_ps2RecompiledFunctionTable[27722] = changeVoiceFloatHsStateOnMyPart_0x11b040; // 0x11b130 - g_ps2RecompiledFunctionTable[27723] = changeVoiceFloatHsStateOnMyPart_0x11b040; // 0x11b134 - g_ps2RecompiledFunctionTable[27724] = changeVoiceFloatHsStateOnMyPart_0x11b040; // 0x11b138 - g_ps2RecompiledFunctionTable[27725] = changeVoiceFloatHsStateOnMyPart_0x11b040; // 0x11b13c - g_ps2RecompiledFunctionTable[27726] = changeVoiceFloatHsStateOnMyPart_0x11b040; // 0x11b140 - g_ps2RecompiledFunctionTable[27727] = changeVoiceFloatHsStateOnMyPart_0x11b040; // 0x11b144 - g_ps2RecompiledFunctionTable[27728] = changeVoiceFloatHsStateOnMyPart_0x11b040; // 0x11b148 - g_ps2RecompiledFunctionTable[27729] = changeVoiceFloatHsStateOnMyPart_0x11b040; // 0x11b14c - g_ps2RecompiledFunctionTable[27730] = changeVoiceFloatHsStateOnMyPart_0x11b040; // 0x11b150 - g_ps2RecompiledFunctionTable[27731] = changeVoiceFloatHsStateOnMyPart_0x11b040; // 0x11b154 - g_ps2RecompiledFunctionTable[27732] = changeVoiceFloatHsStateOnMyPart_0x11b040; // 0x11b158 - g_ps2RecompiledFunctionTable[27733] = changeVoiceFloatHsStateOnMyPart_0x11b040; // 0x11b15c - g_ps2RecompiledFunctionTable[27734] = sceSynthesizerChangeHsPanpot_0x11b160; // 0x11b160 - g_ps2RecompiledFunctionTable[27748] = sceSynthesizerGetPartOutLevel_0x11b198; // 0x11b198 - g_ps2RecompiledFunctionTable[27766] = sceSynthesizerChangePartHsExpression_0x11b1e0; // 0x11b1e0 - g_ps2RecompiledFunctionTable[27792] = sceSynthesizerChangePartHsPitchBend_0x11b248; // 0x11b248 - g_ps2RecompiledFunctionTable[27808] = popVoiceFromPLink_0x11b288; // 0x11b288 - g_ps2RecompiledFunctionTable[27822] = sceSynthesizerAssignNoteOn_0x11b2c0; // 0x11b2c0 - g_ps2RecompiledFunctionTable[28124] = sceSynthesizerAssignNoteOff_0x11b778; // 0x11b778 - g_ps2RecompiledFunctionTable[28270] = sceSynthesizerAssignHoldChange_0x11b9c0; // 0x11b9c0 - g_ps2RecompiledFunctionTable[28278] = sceSynthesizerAssignAllNoteOff_0x11b9e0; // 0x11b9e0 - g_ps2RecompiledFunctionTable[28302] = sceSynthesizerAssignAllSoundOff_0x11ba40; // 0x11ba40 - g_ps2RecompiledFunctionTable[28336] = truncateVoice_0x11bac8; // 0x11bac8 - g_ps2RecompiledFunctionTable[28348] = truncateVoice_0x11bac8; // 0x11baf8 - g_ps2RecompiledFunctionTable[28350] = truncateVoice_0x11bac8; // 0x11bb00 - g_ps2RecompiledFunctionTable[28352] = truncateVoice_0x11bac8; // 0x11bb08 - g_ps2RecompiledFunctionTable[28358] = truncateVoice_0x11bac8; // 0x11bb20 - g_ps2RecompiledFunctionTable[28365] = truncateVoice_0x11bac8; // 0x11bb3c - g_ps2RecompiledFunctionTable[28382] = turnOffVoice_0x11bb80; // 0x11bb80 - g_ps2RecompiledFunctionTable[28397] = turnOffVoice_0x11bb80; // 0x11bbbc - g_ps2RecompiledFunctionTable[28403] = turnOffVoice_0x11bb80; // 0x11bbd4 - g_ps2RecompiledFunctionTable[28410] = turnOffVoice_0x11bb80; // 0x11bbf0 - g_ps2RecompiledFunctionTable[28414] = turnOffVoice_0x11bb80; // 0x11bc00 - g_ps2RecompiledFunctionTable[28418] = turnOffVoice_0x11bb80; // 0x11bc10 - g_ps2RecompiledFunctionTable[28426] = mkAssPartInfo_0x11bc30; // 0x11bc30 - g_ps2RecompiledFunctionTable[28432] = mkAssPartInfo_0x11bc30; // 0x11bc48 - g_ps2RecompiledFunctionTable[28448] = mkAssPartInfo_0x11bc30; // 0x11bc88 - g_ps2RecompiledFunctionTable[28529] = mkAssPartInfo_0x11bc30; // 0x11bdcc - g_ps2RecompiledFunctionTable[28604] = mkAssPartInfo_0x11bc30; // 0x11bef8 - g_ps2RecompiledFunctionTable[28614] = getLowestPriorityVoice_0x11bf20; // 0x11bf20 - g_ps2RecompiledFunctionTable[28628] = getLowestPriorityVoice_0x11bf20; // 0x11bf58 - g_ps2RecompiledFunctionTable[28638] = getLowestPriorityVoice_0x11bf20; // 0x11bf80 - g_ps2RecompiledFunctionTable[28646] = getLowestPriorityVoice_0x11bf20; // 0x11bfa0 - g_ps2RecompiledFunctionTable[28659] = getLowestPriorityVoice_0x11bf20; // 0x11bfd4 - g_ps2RecompiledFunctionTable[28691] = getLowestPriorityVoice_0x11bf20; // 0x11c054 - g_ps2RecompiledFunctionTable[28698] = getLowestPriorityVoice_0x11bf20; // 0x11c070 - g_ps2RecompiledFunctionTable[28728] = turnOffSameKeyAList_0x11c0e8; // 0x11c0e8 - g_ps2RecompiledFunctionTable[28744] = turnOffSameKeyAList_0x11c0e8; // 0x11c128 - g_ps2RecompiledFunctionTable[28755] = turnOffSameKeyAList_0x11c0e8; // 0x11c154 - g_ps2RecompiledFunctionTable[28768] = turnOffSameKey_0x11c188; // 0x11c188 - g_ps2RecompiledFunctionTable[28782] = turnOffSameKey_0x11c188; // 0x11c1c0 - g_ps2RecompiledFunctionTable[28787] = turnOffSameKey_0x11c188; // 0x11c1d4 - g_ps2RecompiledFunctionTable[28792] = turnOffSameKey_0x11c188; // 0x11c1e8 - g_ps2RecompiledFunctionTable[28816] = turnOffExcGroupAList_0x11c248; // 0x11c248 - g_ps2RecompiledFunctionTable[28832] = turnOffExcGroupAList_0x11c248; // 0x11c288 - g_ps2RecompiledFunctionTable[28845] = turnOffExcGroupAList_0x11c248; // 0x11c2bc - g_ps2RecompiledFunctionTable[28858] = turnOffExcGroup_0x11c2f0; // 0x11c2f0 - g_ps2RecompiledFunctionTable[28869] = turnOffExcGroup_0x11c2f0; // 0x11c31c - g_ps2RecompiledFunctionTable[28874] = turnOffExcGroup_0x11c2f0; // 0x11c330 - g_ps2RecompiledFunctionTable[28879] = turnOffExcGroup_0x11c2f0; // 0x11c344 - g_ps2RecompiledFunctionTable[28904] = phaseChange2ReleaseAll_0x11c3a8; // 0x11c3a8 - g_ps2RecompiledFunctionTable[28920] = phaseChange2ReleaseAll_0x11c3a8; // 0x11c3e8 - g_ps2RecompiledFunctionTable[28923] = phaseChange2ReleaseAll_0x11c3a8; // 0x11c3f4 - g_ps2RecompiledFunctionTable[28925] = phaseChange2ReleaseAll_0x11c3a8; // 0x11c3fc - g_ps2RecompiledFunctionTable[28954] = phaseChange2HoldAll_0x11c470; // 0x11c470 - g_ps2RecompiledFunctionTable[28964] = phaseChange2HoldAll_0x11c470; // 0x11c498 - g_ps2RecompiledFunctionTable[28968] = phaseChange2HoldAll_0x11c470; // 0x11c4a8 - g_ps2RecompiledFunctionTable[28982] = phaseChange2TruncateAll_0x11c4e0; // 0x11c4e0 - g_ps2RecompiledFunctionTable[28992] = phaseChange2TruncateAll_0x11c4e0; // 0x11c508 - g_ps2RecompiledFunctionTable[28995] = phaseChange2TruncateAll_0x11c4e0; // 0x11c514 - g_ps2RecompiledFunctionTable[29004] = velMod0_0x11c538; // 0x11c538 - g_ps2RecompiledFunctionTable[29014] = velMod1_0x11c560; // 0x11c560 - g_ps2RecompiledFunctionTable[29024] = velMod2_0x11c588; // 0x11c588 - g_ps2RecompiledFunctionTable[29042] = velMod3_0x11c5d0; // 0x11c5d0 - g_ps2RecompiledFunctionTable[29064] = velMod4_0x11c628; // 0x11c628 - g_ps2RecompiledFunctionTable[29088] = velMod5_0x11c688; // 0x11c688 - g_ps2RecompiledFunctionTable[29110] = velMod6_0x11c6e0; // 0x11c6e0 - g_ps2RecompiledFunctionTable[29132] = velMod7_0x11c738; // 0x11c738 - g_ps2RecompiledFunctionTable[29154] = velMod8_0x11c790; // 0x11c790 - g_ps2RecompiledFunctionTable[29184] = velMod9_0x11c808; // 0x11c808 - g_ps2RecompiledFunctionTable[29220] = getVelocityModify_0x11c898; // 0x11c898 - g_ps2RecompiledFunctionTable[29221] = getVelocityModify_0x11c898; // 0x11c89c - g_ps2RecompiledFunctionTable[29222] = getVelocityModify_0x11c898; // 0x11c8a0 - g_ps2RecompiledFunctionTable[29223] = getVelocityModify_0x11c898; // 0x11c8a4 - g_ps2RecompiledFunctionTable[29224] = getVelocityModify_0x11c898; // 0x11c8a8 - g_ps2RecompiledFunctionTable[29225] = getVelocityModify_0x11c898; // 0x11c8ac - g_ps2RecompiledFunctionTable[29226] = getVelocityModify_0x11c898; // 0x11c8b0 - g_ps2RecompiledFunctionTable[29227] = getVelocityModify_0x11c898; // 0x11c8b4 - g_ps2RecompiledFunctionTable[29228] = getVelocityModify_0x11c898; // 0x11c8b8 - g_ps2RecompiledFunctionTable[29229] = getVelocityModify_0x11c898; // 0x11c8bc - g_ps2RecompiledFunctionTable[29230] = getVelocityModify_0x11c898; // 0x11c8c0 - g_ps2RecompiledFunctionTable[29231] = getVelocityModify_0x11c898; // 0x11c8c4 - g_ps2RecompiledFunctionTable[29232] = getVelocityModify_0x11c898; // 0x11c8c8 - g_ps2RecompiledFunctionTable[29233] = getVelocityModify_0x11c898; // 0x11c8cc - g_ps2RecompiledFunctionTable[29234] = getVelocityModify_0x11c898; // 0x11c8d0 - g_ps2RecompiledFunctionTable[29235] = getVelocityModify_0x11c898; // 0x11c8d4 - g_ps2RecompiledFunctionTable[29236] = getVelocityModify_0x11c898; // 0x11c8d8 - g_ps2RecompiledFunctionTable[29237] = getVelocityModify_0x11c898; // 0x11c8dc - g_ps2RecompiledFunctionTable[29238] = getVelocityModify_0x11c898; // 0x11c8e0 - g_ps2RecompiledFunctionTable[29239] = getVelocityModify_0x11c898; // 0x11c8e4 - g_ps2RecompiledFunctionTable[29240] = getVelocityModify_0x11c898; // 0x11c8e8 - g_ps2RecompiledFunctionTable[29241] = getVelocityModify_0x11c898; // 0x11c8ec - g_ps2RecompiledFunctionTable[29242] = getVelocityModify_0x11c898; // 0x11c8f0 - g_ps2RecompiledFunctionTable[29243] = getVelocityModify_0x11c898; // 0x11c8f4 - g_ps2RecompiledFunctionTable[29244] = getVelocityModify_0x11c898; // 0x11c8f8 - g_ps2RecompiledFunctionTable[29246] = velMod0Amp_0x11c900; // 0x11c900 - g_ps2RecompiledFunctionTable[29250] = velMod1Amp_0x11c910; // 0x11c910 - g_ps2RecompiledFunctionTable[29256] = velMod2Amp_0x11c928; // 0x11c928 - g_ps2RecompiledFunctionTable[29266] = velMod3Amp_0x11c950; // 0x11c950 - g_ps2RecompiledFunctionTable[29270] = velMod3Amp_0x11c950; // 0x11c960 - g_ps2RecompiledFunctionTable[29276] = velMod4Amp_0x11c978; // 0x11c978 - g_ps2RecompiledFunctionTable[29283] = velMod4Amp_0x11c978; // 0x11c994 - g_ps2RecompiledFunctionTable[29290] = velMod5Amp_0x11c9b0; // 0x11c9b0 - g_ps2RecompiledFunctionTable[29297] = velMod5Amp_0x11c9b0; // 0x11c9cc - g_ps2RecompiledFunctionTable[29300] = getAmpVelocity_0x11c9d8; // 0x11c9d8 - g_ps2RecompiledFunctionTable[29301] = getAmpVelocity_0x11c9d8; // 0x11c9dc - g_ps2RecompiledFunctionTable[29302] = getAmpVelocity_0x11c9d8; // 0x11c9e0 - g_ps2RecompiledFunctionTable[29303] = getAmpVelocity_0x11c9d8; // 0x11c9e4 - g_ps2RecompiledFunctionTable[29304] = getAmpVelocity_0x11c9d8; // 0x11c9e8 - g_ps2RecompiledFunctionTable[29305] = getAmpVelocity_0x11c9d8; // 0x11c9ec - g_ps2RecompiledFunctionTable[29306] = getAmpVelocity_0x11c9d8; // 0x11c9f0 - g_ps2RecompiledFunctionTable[29307] = getAmpVelocity_0x11c9d8; // 0x11c9f4 - g_ps2RecompiledFunctionTable[29308] = getAmpVelocity_0x11c9d8; // 0x11c9f8 - g_ps2RecompiledFunctionTable[29309] = getAmpVelocity_0x11c9d8; // 0x11c9fc - g_ps2RecompiledFunctionTable[29310] = getAmpVelocity_0x11c9d8; // 0x11ca00 - g_ps2RecompiledFunctionTable[29311] = getAmpVelocity_0x11c9d8; // 0x11ca04 - g_ps2RecompiledFunctionTable[29312] = getAmpVelocity_0x11c9d8; // 0x11ca08 - g_ps2RecompiledFunctionTable[29313] = getAmpVelocity_0x11c9d8; // 0x11ca0c - g_ps2RecompiledFunctionTable[29314] = getAmpVelocity_0x11c9d8; // 0x11ca10 - g_ps2RecompiledFunctionTable[29315] = getAmpVelocity_0x11c9d8; // 0x11ca14 - g_ps2RecompiledFunctionTable[29316] = getAmpVelocity_0x11c9d8; // 0x11ca18 - g_ps2RecompiledFunctionTable[29317] = getAmpVelocity_0x11c9d8; // 0x11ca1c - g_ps2RecompiledFunctionTable[29318] = getAmpVelocity_0x11c9d8; // 0x11ca20 - g_ps2RecompiledFunctionTable[29319] = getAmpVelocity_0x11c9d8; // 0x11ca24 - g_ps2RecompiledFunctionTable[29320] = getAmpVelocity_0x11c9d8; // 0x11ca28 - g_ps2RecompiledFunctionTable[29321] = getAmpVelocity_0x11c9d8; // 0x11ca2c - g_ps2RecompiledFunctionTable[29322] = getAmpVelocity_0x11c9d8; // 0x11ca30 - g_ps2RecompiledFunctionTable[29323] = getAmpVelocity_0x11c9d8; // 0x11ca34 - g_ps2RecompiledFunctionTable[29324] = getAmpVelocity_0x11c9d8; // 0x11ca38 - g_ps2RecompiledFunctionTable[29325] = getAmpVelocity_0x11c9d8; // 0x11ca3c - g_ps2RecompiledFunctionTable[29326] = getAmpVelocity_0x11c9d8; // 0x11ca40 - g_ps2RecompiledFunctionTable[29327] = getAmpVelocity_0x11c9d8; // 0x11ca44 - g_ps2RecompiledFunctionTable[29328] = getAmpVelocity_0x11c9d8; // 0x11ca48 - g_ps2RecompiledFunctionTable[29329] = getAmpVelocity_0x11c9d8; // 0x11ca4c - g_ps2RecompiledFunctionTable[29330] = getAmpVelocity_0x11c9d8; // 0x11ca50 - g_ps2RecompiledFunctionTable[29331] = getAmpVelocity_0x11c9d8; // 0x11ca54 - g_ps2RecompiledFunctionTable[29332] = ps2___ieee754_atan2_0x11ca58; // 0x11ca58 - g_ps2RecompiledFunctionTable[29365] = ps2___ieee754_atan2_0x11ca58; // 0x11cadc - g_ps2RecompiledFunctionTable[29373] = ps2___ieee754_atan2_0x11ca58; // 0x11cafc - g_ps2RecompiledFunctionTable[29487] = ps2___ieee754_atan2_0x11ca58; // 0x11ccc4 - g_ps2RecompiledFunctionTable[29489] = ps2___ieee754_atan2_0x11ca58; // 0x11cccc - g_ps2RecompiledFunctionTable[29491] = ps2___ieee754_atan2_0x11ca58; // 0x11ccd4 - g_ps2RecompiledFunctionTable[29520] = ps2___ieee754_atan2_0x11ca58; // 0x11cd48 - g_ps2RecompiledFunctionTable[29528] = ps2___ieee754_atan2_0x11ca58; // 0x11cd68 - g_ps2RecompiledFunctionTable[29533] = ps2___ieee754_atan2_0x11ca58; // 0x11cd7c - g_ps2RecompiledFunctionTable[29538] = ps2___ieee754_acosf_0x11cd90; // 0x11cd90 - g_ps2RecompiledFunctionTable[29706] = ps2___ieee754_acosf_0x11cd90; // 0x11d030 - g_ps2RecompiledFunctionTable[29730] = ps2___ieee754_acosf_0x11cd90; // 0x11d090 - g_ps2RecompiledFunctionTable[29806] = ps2___ieee754_asinf_0x11d1c0; // 0x11d1c0 - g_ps2RecompiledFunctionTable[29918] = ps2___ieee754_asinf_0x11d1c0; // 0x11d380 - g_ps2RecompiledFunctionTable[29975] = ps2___ieee754_asinf_0x11d1c0; // 0x11d464 - g_ps2RecompiledFunctionTable[30038] = ps2___ieee754_atan2f_0x11d560; // 0x11d560 - g_ps2RecompiledFunctionTable[30063] = ps2___ieee754_atan2f_0x11d560; // 0x11d5c4 - g_ps2RecompiledFunctionTable[30082] = ps2___ieee754_atan2f_0x11d560; // 0x11d610 - g_ps2RecompiledFunctionTable[30180] = ps2___ieee754_atan2f_0x11d560; // 0x11d798 - g_ps2RecompiledFunctionTable[30182] = ps2___ieee754_atan2f_0x11d560; // 0x11d7a0 - g_ps2RecompiledFunctionTable[30224] = ps2___ieee754_powf_0x11d848; // 0x11d848 - g_ps2RecompiledFunctionTable[30319] = ps2___ieee754_powf_0x11d848; // 0x11d9c4 - g_ps2RecompiledFunctionTable[30323] = ps2___ieee754_powf_0x11d848; // 0x11d9d4 - g_ps2RecompiledFunctionTable[30374] = ps2___ieee754_powf_0x11d848; // 0x11daa0 - g_ps2RecompiledFunctionTable[30755] = ps2___ieee754_powf_0x11d848; // 0x11e094 - g_ps2RecompiledFunctionTable[30772] = ps2___ieee754_rem_pio2f_0x11e0d8; // 0x11e0d8 - g_ps2RecompiledFunctionTable[31020] = ps2___ieee754_sqrtf_0x11e4b8; // 0x11e4b8 - g_ps2RecompiledFunctionTable[31052] = ps2___ieee754_sqrtf_0x11e4b8; // 0x11e538 - g_ps2RecompiledFunctionTable[31078] = ps2___ieee754_sqrtf_0x11e4b8; // 0x11e5a0 - g_ps2RecompiledFunctionTable[31098] = ps2___kernel_cosf_0x11e5f0; // 0x11e5f0 - g_ps2RecompiledFunctionTable[31184] = ps2___kernel_rem_pio2f_0x11e748; // 0x11e748 - g_ps2RecompiledFunctionTable[31228] = ps2___kernel_rem_pio2f_0x11e748; // 0x11e7f8 - g_ps2RecompiledFunctionTable[31256] = ps2___kernel_rem_pio2f_0x11e748; // 0x11e868 - g_ps2RecompiledFunctionTable[31264] = ps2___kernel_rem_pio2f_0x11e748; // 0x11e888 - g_ps2RecompiledFunctionTable[31287] = ps2___kernel_rem_pio2f_0x11e748; // 0x11e8e4 - g_ps2RecompiledFunctionTable[31300] = ps2___kernel_rem_pio2f_0x11e748; // 0x11e918 - g_ps2RecompiledFunctionTable[31318] = ps2___kernel_rem_pio2f_0x11e748; // 0x11e960 - g_ps2RecompiledFunctionTable[31324] = ps2___kernel_rem_pio2f_0x11e748; // 0x11e978 - g_ps2RecompiledFunctionTable[31376] = ps2___kernel_rem_pio2f_0x11e748; // 0x11ea48 - g_ps2RecompiledFunctionTable[31417] = ps2___kernel_rem_pio2f_0x11e748; // 0x11eaec - g_ps2RecompiledFunctionTable[31428] = ps2___kernel_rem_pio2f_0x11e748; // 0x11eb18 - g_ps2RecompiledFunctionTable[31444] = ps2___kernel_rem_pio2f_0x11e748; // 0x11eb58 - g_ps2RecompiledFunctionTable[31462] = ps2___kernel_rem_pio2f_0x11e748; // 0x11eba0 - g_ps2RecompiledFunctionTable[31478] = ps2___kernel_rem_pio2f_0x11e748; // 0x11ebe0 - g_ps2RecompiledFunctionTable[31514] = ps2___kernel_rem_pio2f_0x11e748; // 0x11ec70 - g_ps2RecompiledFunctionTable[31525] = ps2___kernel_rem_pio2f_0x11e748; // 0x11ec9c - g_ps2RecompiledFunctionTable[31561] = ps2___kernel_rem_pio2f_0x11e748; // 0x11ed2c - g_ps2RecompiledFunctionTable[31570] = ps2___kernel_rem_pio2f_0x11e748; // 0x11ed50 - g_ps2RecompiledFunctionTable[31584] = ps2___kernel_rem_pio2f_0x11e748; // 0x11ed88 - g_ps2RecompiledFunctionTable[31594] = ps2___kernel_rem_pio2f_0x11e748; // 0x11edb0 - g_ps2RecompiledFunctionTable[31640] = ps2___kernel_rem_pio2f_0x11e748; // 0x11ee68 - g_ps2RecompiledFunctionTable[31660] = ps2___kernel_rem_pio2f_0x11e748; // 0x11eeb8 - g_ps2RecompiledFunctionTable[31680] = ps2___kernel_rem_pio2f_0x11e748; // 0x11ef08 - g_ps2RecompiledFunctionTable[31700] = ps2___kernel_rem_pio2f_0x11e748; // 0x11ef58 - g_ps2RecompiledFunctionTable[31720] = ps2___kernel_rem_pio2f_0x11e748; // 0x11efa8 - g_ps2RecompiledFunctionTable[31742] = ps2___kernel_rem_pio2f_0x11e748; // 0x11f000 - g_ps2RecompiledFunctionTable[31780] = ps2___kernel_sinf_0x11f098; // 0x11f098 - g_ps2RecompiledFunctionTable[31846] = ps2___kernel_tanf_0x11f1a0; // 0x11f1a0 - g_ps2RecompiledFunctionTable[31868] = ps2___kernel_tanf_0x11f1a0; // 0x11f1f8 - g_ps2RecompiledFunctionTable[32012] = atan_0x11f438; // 0x11f438 - g_ps2RecompiledFunctionTable[32272] = fabs_0x11f848; // 0x11f848 - g_ps2RecompiledFunctionTable[32286] = isinf_0x11f880; // 0x11f880 - g_ps2RecompiledFunctionTable[32304] = isnan_0x11f8c8; // 0x11f8c8 - g_ps2RecompiledFunctionTable[32318] = matherr_0x11f900; // 0x11f900 - g_ps2RecompiledFunctionTable[32323] = matherr_0x11f900; // 0x11f914 - g_ps2RecompiledFunctionTable[32328] = rint_0x11f928; // 0x11f928 - g_ps2RecompiledFunctionTable[32377] = rint_0x11f928; // 0x11f9ec - g_ps2RecompiledFunctionTable[32380] = rint_0x11f928; // 0x11f9f8 - g_ps2RecompiledFunctionTable[32417] = rint_0x11f928; // 0x11fa8c - g_ps2RecompiledFunctionTable[32445] = rint_0x11f928; // 0x11fafc - g_ps2RecompiledFunctionTable[32448] = rint_0x11f928; // 0x11fb08 - g_ps2RecompiledFunctionTable[32456] = atanf_0x11fb28; // 0x11fb28 - g_ps2RecompiledFunctionTable[32512] = atanf_0x11fb28; // 0x11fc08 - g_ps2RecompiledFunctionTable[32626] = ceilf_0x11fdd0; // 0x11fdd0 - g_ps2RecompiledFunctionTable[32655] = ceilf_0x11fdd0; // 0x11fe44 - g_ps2RecompiledFunctionTable[32680] = copysignf_0x11fea8; // 0x11fea8 - g_ps2RecompiledFunctionTable[32692] = cosf_0x11fed8; // 0x11fed8 - g_ps2RecompiledFunctionTable[32706] = cosf_0x11fed8; // 0x11ff10 - g_ps2RecompiledFunctionTable[32717] = cosf_0x11fed8; // 0x11ff3c - g_ps2RecompiledFunctionTable[32733] = cosf_0x11fed8; // 0x11ff7c - g_ps2RecompiledFunctionTable[32739] = cosf_0x11fed8; // 0x11ff94 - g_ps2RecompiledFunctionTable[32743] = cosf_0x11fed8; // 0x11ffa4 - g_ps2RecompiledFunctionTable[32747] = cosf_0x11fed8; // 0x11ffb4 - g_ps2RecompiledFunctionTable[32750] = fabsf_0x11ffc0; // 0x11ffc0 - g_ps2RecompiledFunctionTable[32758] = finitef_0x11ffe0; // 0x11ffe0 - g_ps2RecompiledFunctionTable[32768] = floorf_0x120008; // 0x120008 - g_ps2RecompiledFunctionTable[32800] = floorf_0x120008; // 0x120088 - g_ps2RecompiledFunctionTable[32826] = frexpf_0x1200f0; // 0x1200f0 - g_ps2RecompiledFunctionTable[32868] = isnanf_0x120198; // 0x120198 - g_ps2RecompiledFunctionTable[32878] = scalbnf_0x1201c0; // 0x1201c0 - g_ps2RecompiledFunctionTable[32949] = scalbnf_0x1201c0; // 0x1202dc - g_ps2RecompiledFunctionTable[32966] = sinf_0x120320; // 0x120320 - g_ps2RecompiledFunctionTable[32980] = sinf_0x120320; // 0x120358 - g_ps2RecompiledFunctionTable[32991] = sinf_0x120320; // 0x120384 - g_ps2RecompiledFunctionTable[33008] = sinf_0x120320; // 0x1203c8 - g_ps2RecompiledFunctionTable[33013] = sinf_0x120320; // 0x1203dc - g_ps2RecompiledFunctionTable[33018] = sinf_0x120320; // 0x1203f0 - g_ps2RecompiledFunctionTable[33022] = sinf_0x120320; // 0x120400 - g_ps2RecompiledFunctionTable[33026] = tanf_0x120410; // 0x120410 - g_ps2RecompiledFunctionTable[33049] = tanf_0x120410; // 0x12046c - g_ps2RecompiledFunctionTable[33057] = tanf_0x120410; // 0x12048c - g_ps2RecompiledFunctionTable[33060] = atan2_0x120498; // 0x120498 - g_ps2RecompiledFunctionTable[33130] = acosf_0x1205b0; // 0x1205b0 - g_ps2RecompiledFunctionTable[33137] = acosf_0x1205b0; // 0x1205cc - g_ps2RecompiledFunctionTable[33144] = acosf_0x1205b0; // 0x1205e8 - g_ps2RecompiledFunctionTable[33148] = acosf_0x1205b0; // 0x1205f8 - g_ps2RecompiledFunctionTable[33161] = acosf_0x1205b0; // 0x12062c - g_ps2RecompiledFunctionTable[33169] = acosf_0x1205b0; // 0x12064c - g_ps2RecompiledFunctionTable[33173] = acosf_0x1205b0; // 0x12065c - g_ps2RecompiledFunctionTable[33180] = acosf_0x1205b0; // 0x120678 - g_ps2RecompiledFunctionTable[33184] = acosf_0x1205b0; // 0x120688 - g_ps2RecompiledFunctionTable[33194] = asinf_0x1206b0; // 0x1206b0 - g_ps2RecompiledFunctionTable[33201] = asinf_0x1206b0; // 0x1206cc - g_ps2RecompiledFunctionTable[33208] = asinf_0x1206b0; // 0x1206e8 - g_ps2RecompiledFunctionTable[33212] = asinf_0x1206b0; // 0x1206f8 - g_ps2RecompiledFunctionTable[33225] = asinf_0x1206b0; // 0x12072c - g_ps2RecompiledFunctionTable[33233] = asinf_0x1206b0; // 0x12074c - g_ps2RecompiledFunctionTable[33237] = asinf_0x1206b0; // 0x12075c - g_ps2RecompiledFunctionTable[33244] = asinf_0x1206b0; // 0x120778 - g_ps2RecompiledFunctionTable[33248] = asinf_0x1206b0; // 0x120788 - g_ps2RecompiledFunctionTable[33258] = atan2f_0x1207b0; // 0x1207b0 - g_ps2RecompiledFunctionTable[33267] = atan2f_0x1207b0; // 0x1207d4 - g_ps2RecompiledFunctionTable[33274] = atan2f_0x1207b0; // 0x1207f0 - g_ps2RecompiledFunctionTable[33278] = atan2f_0x1207b0; // 0x120800 - g_ps2RecompiledFunctionTable[33291] = atan2f_0x1207b0; // 0x120834 - g_ps2RecompiledFunctionTable[33294] = atan2f_0x1207b0; // 0x120840 - g_ps2RecompiledFunctionTable[33307] = atan2f_0x1207b0; // 0x120874 - g_ps2RecompiledFunctionTable[33311] = atan2f_0x1207b0; // 0x120884 - g_ps2RecompiledFunctionTable[33318] = atan2f_0x1207b0; // 0x1208a0 - g_ps2RecompiledFunctionTable[33322] = atan2f_0x1207b0; // 0x1208b0 - g_ps2RecompiledFunctionTable[33332] = powf_0x1208d8; // 0x1208d8 - g_ps2RecompiledFunctionTable[33346] = powf_0x1208d8; // 0x120910 - g_ps2RecompiledFunctionTable[33352] = powf_0x1208d8; // 0x120928 - g_ps2RecompiledFunctionTable[33356] = powf_0x1208d8; // 0x120938 - g_ps2RecompiledFunctionTable[33370] = powf_0x1208d8; // 0x120970 - g_ps2RecompiledFunctionTable[33373] = powf_0x1208d8; // 0x12097c - g_ps2RecompiledFunctionTable[33376] = powf_0x1208d8; // 0x120988 - g_ps2RecompiledFunctionTable[33380] = powf_0x1208d8; // 0x120998 - g_ps2RecompiledFunctionTable[33386] = powf_0x1208d8; // 0x1209b0 - g_ps2RecompiledFunctionTable[33390] = powf_0x1208d8; // 0x1209c0 - g_ps2RecompiledFunctionTable[33407] = powf_0x1208d8; // 0x120a04 - g_ps2RecompiledFunctionTable[33410] = powf_0x1208d8; // 0x120a10 - g_ps2RecompiledFunctionTable[33416] = powf_0x1208d8; // 0x120a28 - g_ps2RecompiledFunctionTable[33420] = powf_0x1208d8; // 0x120a38 - g_ps2RecompiledFunctionTable[33424] = powf_0x1208d8; // 0x120a48 - g_ps2RecompiledFunctionTable[33437] = powf_0x1208d8; // 0x120a7c - g_ps2RecompiledFunctionTable[33440] = powf_0x1208d8; // 0x120a88 - g_ps2RecompiledFunctionTable[33449] = powf_0x1208d8; // 0x120aac - g_ps2RecompiledFunctionTable[33456] = powf_0x1208d8; // 0x120ac8 - g_ps2RecompiledFunctionTable[33460] = powf_0x1208d8; // 0x120ad8 - g_ps2RecompiledFunctionTable[33464] = powf_0x1208d8; // 0x120ae8 - g_ps2RecompiledFunctionTable[33468] = powf_0x1208d8; // 0x120af8 - g_ps2RecompiledFunctionTable[33472] = powf_0x1208d8; // 0x120b08 - g_ps2RecompiledFunctionTable[33476] = powf_0x1208d8; // 0x120b18 - g_ps2RecompiledFunctionTable[33485] = powf_0x1208d8; // 0x120b3c - g_ps2RecompiledFunctionTable[33488] = powf_0x1208d8; // 0x120b48 - g_ps2RecompiledFunctionTable[33502] = powf_0x1208d8; // 0x120b80 - g_ps2RecompiledFunctionTable[33506] = powf_0x1208d8; // 0x120b90 - g_ps2RecompiledFunctionTable[33515] = powf_0x1208d8; // 0x120bb4 - g_ps2RecompiledFunctionTable[33518] = powf_0x1208d8; // 0x120bc0 - g_ps2RecompiledFunctionTable[33525] = powf_0x1208d8; // 0x120bdc - g_ps2RecompiledFunctionTable[33529] = powf_0x1208d8; // 0x120bec - g_ps2RecompiledFunctionTable[33531] = powf_0x1208d8; // 0x120bf4 - g_ps2RecompiledFunctionTable[33534] = powf_0x1208d8; // 0x120c00 - g_ps2RecompiledFunctionTable[33537] = powf_0x1208d8; // 0x120c0c - g_ps2RecompiledFunctionTable[33541] = powf_0x1208d8; // 0x120c1c - g_ps2RecompiledFunctionTable[33543] = powf_0x1208d8; // 0x120c24 - g_ps2RecompiledFunctionTable[33546] = powf_0x1208d8; // 0x120c30 - g_ps2RecompiledFunctionTable[33549] = powf_0x1208d8; // 0x120c3c - g_ps2RecompiledFunctionTable[33561] = powf_0x1208d8; // 0x120c6c - g_ps2RecompiledFunctionTable[33565] = powf_0x1208d8; // 0x120c7c - g_ps2RecompiledFunctionTable[33567] = powf_0x1208d8; // 0x120c84 - g_ps2RecompiledFunctionTable[33570] = powf_0x1208d8; // 0x120c90 - g_ps2RecompiledFunctionTable[33573] = powf_0x1208d8; // 0x120c9c - g_ps2RecompiledFunctionTable[33577] = powf_0x1208d8; // 0x120cac - g_ps2RecompiledFunctionTable[33579] = powf_0x1208d8; // 0x120cb4 - g_ps2RecompiledFunctionTable[33582] = powf_0x1208d8; // 0x120cc0 - g_ps2RecompiledFunctionTable[33585] = powf_0x1208d8; // 0x120ccc - g_ps2RecompiledFunctionTable[33589] = powf_0x1208d8; // 0x120cdc - g_ps2RecompiledFunctionTable[33600] = powf_0x1208d8; // 0x120d08 - g_ps2RecompiledFunctionTable[33604] = powf_0x1208d8; // 0x120d18 - g_ps2RecompiledFunctionTable[33613] = powf_0x1208d8; // 0x120d3c - g_ps2RecompiledFunctionTable[33616] = powf_0x1208d8; // 0x120d48 - g_ps2RecompiledFunctionTable[33625] = powf_0x1208d8; // 0x120d6c - g_ps2RecompiledFunctionTable[33629] = powf_0x1208d8; // 0x120d7c - g_ps2RecompiledFunctionTable[33636] = powf_0x1208d8; // 0x120d98 - g_ps2RecompiledFunctionTable[33640] = powf_0x1208d8; // 0x120da8 - g_ps2RecompiledFunctionTable[33654] = sqrtf_0x120de0; // 0x120de0 - g_ps2RecompiledFunctionTable[33663] = sqrtf_0x120de0; // 0x120e04 - g_ps2RecompiledFunctionTable[33669] = sqrtf_0x120de0; // 0x120e1c - g_ps2RecompiledFunctionTable[33683] = sqrtf_0x120de0; // 0x120e54 - g_ps2RecompiledFunctionTable[33698] = sqrtf_0x120de0; // 0x120e90 - g_ps2RecompiledFunctionTable[33702] = sqrtf_0x120de0; // 0x120ea0 - g_ps2RecompiledFunctionTable[33709] = sqrtf_0x120de0; // 0x120ebc - g_ps2RecompiledFunctionTable[33713] = sqrtf_0x120de0; // 0x120ecc - g_ps2RecompiledFunctionTable[33724] = abs_0x120ef8; // 0x120ef8 - g_ps2RecompiledFunctionTable[33730] = _calloc_r_0x120f10; // 0x120f10 - g_ps2RecompiledFunctionTable[33778] = _close_r_0x120fd0; // 0x120fd0 - g_ps2RecompiledFunctionTable[33787] = _close_r_0x120fd0; // 0x120ff4 - g_ps2RecompiledFunctionTable[33800] = quorem_0x121028; // 0x121028 - g_ps2RecompiledFunctionTable[33836] = quorem_0x121028; // 0x1210b8 - g_ps2RecompiledFunctionTable[33866] = quorem_0x121028; // 0x121130 - g_ps2RecompiledFunctionTable[33877] = quorem_0x121028; // 0x12115c - g_ps2RecompiledFunctionTable[33884] = quorem_0x121028; // 0x121178 - g_ps2RecompiledFunctionTable[33914] = quorem_0x121028; // 0x1211f0 - g_ps2RecompiledFunctionTable[33934] = _dtoa_r_0x121240; // 0x121240 - g_ps2RecompiledFunctionTable[33962] = _dtoa_r_0x121240; // 0x1212b0 - g_ps2RecompiledFunctionTable[34008] = _dtoa_r_0x121240; // 0x121368 - g_ps2RecompiledFunctionTable[34026] = _dtoa_r_0x121240; // 0x1213b0 - g_ps2RecompiledFunctionTable[34070] = _dtoa_r_0x121240; // 0x121460 - g_ps2RecompiledFunctionTable[34076] = _dtoa_r_0x121240; // 0x121478 - g_ps2RecompiledFunctionTable[34092] = _dtoa_r_0x121240; // 0x1214b8 - g_ps2RecompiledFunctionTable[34096] = _dtoa_r_0x121240; // 0x1214c8 - g_ps2RecompiledFunctionTable[34100] = _dtoa_r_0x121240; // 0x1214d8 - g_ps2RecompiledFunctionTable[34103] = _dtoa_r_0x121240; // 0x1214e4 - g_ps2RecompiledFunctionTable[34107] = _dtoa_r_0x121240; // 0x1214f4 - g_ps2RecompiledFunctionTable[34110] = _dtoa_r_0x121240; // 0x121500 - g_ps2RecompiledFunctionTable[34113] = _dtoa_r_0x121240; // 0x12150c - g_ps2RecompiledFunctionTable[34117] = _dtoa_r_0x121240; // 0x12151c - g_ps2RecompiledFunctionTable[34121] = _dtoa_r_0x121240; // 0x12152c - g_ps2RecompiledFunctionTable[34124] = _dtoa_r_0x121240; // 0x121538 - g_ps2RecompiledFunctionTable[34138] = _dtoa_r_0x121240; // 0x121570 - g_ps2RecompiledFunctionTable[34218] = _dtoa_r_0x121240; // 0x1216b0 - g_ps2RecompiledFunctionTable[34233] = _dtoa_r_0x121240; // 0x1216ec - g_ps2RecompiledFunctionTable[34259] = _dtoa_r_0x121240; // 0x121754 - g_ps2RecompiledFunctionTable[34264] = _dtoa_r_0x121240; // 0x121768 - g_ps2RecompiledFunctionTable[34270] = _dtoa_r_0x121240; // 0x121780 - g_ps2RecompiledFunctionTable[34277] = _dtoa_r_0x121240; // 0x12179c - g_ps2RecompiledFunctionTable[34290] = _dtoa_r_0x121240; // 0x1217d0 - g_ps2RecompiledFunctionTable[34294] = _dtoa_r_0x121240; // 0x1217e0 - g_ps2RecompiledFunctionTable[34300] = _dtoa_r_0x121240; // 0x1217f8 - g_ps2RecompiledFunctionTable[34311] = _dtoa_r_0x121240; // 0x121824 - g_ps2RecompiledFunctionTable[34325] = _dtoa_r_0x121240; // 0x12185c - g_ps2RecompiledFunctionTable[34328] = _dtoa_r_0x121240; // 0x121868 - g_ps2RecompiledFunctionTable[34331] = _dtoa_r_0x121240; // 0x121874 - g_ps2RecompiledFunctionTable[34335] = _dtoa_r_0x121240; // 0x121884 - g_ps2RecompiledFunctionTable[34353] = _dtoa_r_0x121240; // 0x1218cc - g_ps2RecompiledFunctionTable[34357] = _dtoa_r_0x121240; // 0x1218dc - g_ps2RecompiledFunctionTable[34362] = _dtoa_r_0x121240; // 0x1218f0 - g_ps2RecompiledFunctionTable[34365] = _dtoa_r_0x121240; // 0x1218fc - g_ps2RecompiledFunctionTable[34381] = _dtoa_r_0x121240; // 0x12193c - g_ps2RecompiledFunctionTable[34384] = _dtoa_r_0x121240; // 0x121948 - g_ps2RecompiledFunctionTable[34386] = _dtoa_r_0x121240; // 0x121950 - g_ps2RecompiledFunctionTable[34390] = _dtoa_r_0x121240; // 0x121960 - g_ps2RecompiledFunctionTable[34395] = _dtoa_r_0x121240; // 0x121974 - g_ps2RecompiledFunctionTable[34398] = _dtoa_r_0x121240; // 0x121980 - g_ps2RecompiledFunctionTable[34401] = _dtoa_r_0x121240; // 0x12198c - g_ps2RecompiledFunctionTable[34404] = _dtoa_r_0x121240; // 0x121998 - g_ps2RecompiledFunctionTable[34411] = _dtoa_r_0x121240; // 0x1219b4 - g_ps2RecompiledFunctionTable[34417] = _dtoa_r_0x121240; // 0x1219cc - g_ps2RecompiledFunctionTable[34420] = _dtoa_r_0x121240; // 0x1219d8 - g_ps2RecompiledFunctionTable[34437] = _dtoa_r_0x121240; // 0x121a1c - g_ps2RecompiledFunctionTable[34440] = _dtoa_r_0x121240; // 0x121a28 - g_ps2RecompiledFunctionTable[34445] = _dtoa_r_0x121240; // 0x121a3c - g_ps2RecompiledFunctionTable[34448] = _dtoa_r_0x121240; // 0x121a48 - g_ps2RecompiledFunctionTable[34451] = _dtoa_r_0x121240; // 0x121a54 - g_ps2RecompiledFunctionTable[34454] = _dtoa_r_0x121240; // 0x121a60 - g_ps2RecompiledFunctionTable[34464] = _dtoa_r_0x121240; // 0x121a88 - g_ps2RecompiledFunctionTable[34467] = _dtoa_r_0x121240; // 0x121a94 - g_ps2RecompiledFunctionTable[34473] = _dtoa_r_0x121240; // 0x121aac - g_ps2RecompiledFunctionTable[34476] = _dtoa_r_0x121240; // 0x121ab8 - g_ps2RecompiledFunctionTable[34480] = _dtoa_r_0x121240; // 0x121ac8 - g_ps2RecompiledFunctionTable[34515] = _dtoa_r_0x121240; // 0x121b54 - g_ps2RecompiledFunctionTable[34518] = _dtoa_r_0x121240; // 0x121b60 - g_ps2RecompiledFunctionTable[34526] = _dtoa_r_0x121240; // 0x121b80 - g_ps2RecompiledFunctionTable[34530] = _dtoa_r_0x121240; // 0x121b90 - g_ps2RecompiledFunctionTable[34534] = _dtoa_r_0x121240; // 0x121ba0 - g_ps2RecompiledFunctionTable[34539] = _dtoa_r_0x121240; // 0x121bb4 - g_ps2RecompiledFunctionTable[34541] = _dtoa_r_0x121240; // 0x121bbc - g_ps2RecompiledFunctionTable[34544] = _dtoa_r_0x121240; // 0x121bc8 - g_ps2RecompiledFunctionTable[34547] = _dtoa_r_0x121240; // 0x121bd4 - g_ps2RecompiledFunctionTable[34550] = _dtoa_r_0x121240; // 0x121be0 - g_ps2RecompiledFunctionTable[34558] = _dtoa_r_0x121240; // 0x121c00 - g_ps2RecompiledFunctionTable[34562] = _dtoa_r_0x121240; // 0x121c10 - g_ps2RecompiledFunctionTable[34567] = _dtoa_r_0x121240; // 0x121c24 - g_ps2RecompiledFunctionTable[34577] = _dtoa_r_0x121240; // 0x121c4c - g_ps2RecompiledFunctionTable[34630] = _dtoa_r_0x121240; // 0x121d20 - g_ps2RecompiledFunctionTable[34662] = _dtoa_r_0x121240; // 0x121da0 - g_ps2RecompiledFunctionTable[34667] = _dtoa_r_0x121240; // 0x121db4 - g_ps2RecompiledFunctionTable[34671] = _dtoa_r_0x121240; // 0x121dc4 - g_ps2RecompiledFunctionTable[34678] = _dtoa_r_0x121240; // 0x121de0 - g_ps2RecompiledFunctionTable[34683] = _dtoa_r_0x121240; // 0x121df4 - g_ps2RecompiledFunctionTable[34687] = _dtoa_r_0x121240; // 0x121e04 - g_ps2RecompiledFunctionTable[34694] = _dtoa_r_0x121240; // 0x121e20 - g_ps2RecompiledFunctionTable[34725] = _dtoa_r_0x121240; // 0x121e9c - g_ps2RecompiledFunctionTable[34761] = _dtoa_r_0x121240; // 0x121f2c - g_ps2RecompiledFunctionTable[34768] = _dtoa_r_0x121240; // 0x121f48 - g_ps2RecompiledFunctionTable[34774] = _dtoa_r_0x121240; // 0x121f60 - g_ps2RecompiledFunctionTable[34781] = _dtoa_r_0x121240; // 0x121f7c - g_ps2RecompiledFunctionTable[34790] = _dtoa_r_0x121240; // 0x121fa0 - g_ps2RecompiledFunctionTable[34806] = _dtoa_r_0x121240; // 0x121fe0 - g_ps2RecompiledFunctionTable[34810] = _dtoa_r_0x121240; // 0x121ff0 - g_ps2RecompiledFunctionTable[34828] = _dtoa_r_0x121240; // 0x122038 - g_ps2RecompiledFunctionTable[34836] = _dtoa_r_0x121240; // 0x122058 - g_ps2RecompiledFunctionTable[34845] = _dtoa_r_0x121240; // 0x12207c - g_ps2RecompiledFunctionTable[34849] = _dtoa_r_0x121240; // 0x12208c - g_ps2RecompiledFunctionTable[34854] = _dtoa_r_0x121240; // 0x1220a0 - g_ps2RecompiledFunctionTable[34859] = _dtoa_r_0x121240; // 0x1220b4 - g_ps2RecompiledFunctionTable[34868] = _dtoa_r_0x121240; // 0x1220d8 - g_ps2RecompiledFunctionTable[34876] = _dtoa_r_0x121240; // 0x1220f8 - g_ps2RecompiledFunctionTable[34882] = _dtoa_r_0x121240; // 0x122110 - g_ps2RecompiledFunctionTable[34887] = _dtoa_r_0x121240; // 0x122124 - g_ps2RecompiledFunctionTable[34891] = _dtoa_r_0x121240; // 0x122134 - g_ps2RecompiledFunctionTable[34896] = _dtoa_r_0x121240; // 0x122148 - g_ps2RecompiledFunctionTable[34903] = _dtoa_r_0x121240; // 0x122164 - g_ps2RecompiledFunctionTable[34907] = _dtoa_r_0x121240; // 0x122174 - g_ps2RecompiledFunctionTable[34937] = _dtoa_r_0x121240; // 0x1221ec - g_ps2RecompiledFunctionTable[34941] = _dtoa_r_0x121240; // 0x1221fc - g_ps2RecompiledFunctionTable[34974] = _dtoa_r_0x121240; // 0x122280 - g_ps2RecompiledFunctionTable[34979] = _dtoa_r_0x121240; // 0x122294 - g_ps2RecompiledFunctionTable[34984] = _dtoa_r_0x121240; // 0x1222a8 - g_ps2RecompiledFunctionTable[34994] = _dtoa_r_0x121240; // 0x1222d0 - g_ps2RecompiledFunctionTable[34998] = _dtoa_r_0x121240; // 0x1222e0 - g_ps2RecompiledFunctionTable[35010] = _dtoa_r_0x121240; // 0x122310 - g_ps2RecompiledFunctionTable[35026] = _dtoa_r_0x121240; // 0x122350 - g_ps2RecompiledFunctionTable[35037] = _dtoa_r_0x121240; // 0x12237c - g_ps2RecompiledFunctionTable[35046] = _dtoa_r_0x121240; // 0x1223a0 - g_ps2RecompiledFunctionTable[35049] = _dtoa_r_0x121240; // 0x1223ac - g_ps2RecompiledFunctionTable[35054] = _dtoa_r_0x121240; // 0x1223c0 - g_ps2RecompiledFunctionTable[35074] = ps2___errno_0x122410; // 0x122410 - g_ps2RecompiledFunctionTable[35078] = exit_0x122420; // 0x122420 - g_ps2RecompiledFunctionTable[35122] = fflush_0x1224d0; // 0x1224d0 - g_ps2RecompiledFunctionTable[35188] = std_0x1225d8; // 0x1225d8 - g_ps2RecompiledFunctionTable[35210] = ps2___sfmoreglue_0x122630; // 0x122630 - g_ps2RecompiledFunctionTable[35220] = ps2___sfmoreglue_0x122630; // 0x122658 - g_ps2RecompiledFunctionTable[35231] = ps2___sfmoreglue_0x122630; // 0x122684 - g_ps2RecompiledFunctionTable[35238] = ps2___sfp_0x1226a0; // 0x1226a0 - g_ps2RecompiledFunctionTable[35248] = ps2___sfp_0x1226a0; // 0x1226c8 - g_ps2RecompiledFunctionTable[35250] = ps2___sfp_0x1226a0; // 0x1226d0 - g_ps2RecompiledFunctionTable[35251] = ps2___sfp_0x1226a0; // 0x1226d4 - g_ps2RecompiledFunctionTable[35256] = ps2___sfp_0x1226a0; // 0x1226e8 - g_ps2RecompiledFunctionTable[35267] = ps2___sfp_0x1226a0; // 0x122714 - g_ps2RecompiledFunctionTable[35294] = _cleanup_r_0x122780; // 0x122780 - g_ps2RecompiledFunctionTable[35298] = _cleanup_0x122790; // 0x122790 - g_ps2RecompiledFunctionTable[35302] = ps2___sinit_0x1227a0; // 0x1227a0 - g_ps2RecompiledFunctionTable[35318] = ps2___sinit_0x1227a0; // 0x1227e0 - g_ps2RecompiledFunctionTable[35323] = ps2___sinit_0x1227a0; // 0x1227f4 - g_ps2RecompiledFunctionTable[35328] = ps2___sinit_0x1227a0; // 0x122808 - g_ps2RecompiledFunctionTable[35338] = _free_r_0x122830; // 0x122830 - g_ps2RecompiledFunctionTable[35538] = _malloc_trim_r_0x122b50; // 0x122b50 - g_ps2RecompiledFunctionTable[35630] = _fstat_r_0x122cc0; // 0x122cc0 - g_ps2RecompiledFunctionTable[35640] = _fstat_r_0x122cc0; // 0x122ce8 - g_ps2RecompiledFunctionTable[35654] = ps2___sfvwrite_0x122d20; // 0x122d20 - g_ps2RecompiledFunctionTable[35655] = ps2___sfvwrite_0x122d20; // 0x122d24 - g_ps2RecompiledFunctionTable[35656] = ps2___sfvwrite_0x122d20; // 0x122d28 - g_ps2RecompiledFunctionTable[35657] = ps2___sfvwrite_0x122d20; // 0x122d2c - g_ps2RecompiledFunctionTable[35658] = ps2___sfvwrite_0x122d20; // 0x122d30 - g_ps2RecompiledFunctionTable[35659] = ps2___sfvwrite_0x122d20; // 0x122d34 - g_ps2RecompiledFunctionTable[35660] = ps2___sfvwrite_0x122d20; // 0x122d38 - g_ps2RecompiledFunctionTable[35661] = ps2___sfvwrite_0x122d20; // 0x122d3c - g_ps2RecompiledFunctionTable[35662] = ps2___sfvwrite_0x122d20; // 0x122d40 - g_ps2RecompiledFunctionTable[35663] = ps2___sfvwrite_0x122d20; // 0x122d44 - g_ps2RecompiledFunctionTable[35664] = ps2___sfvwrite_0x122d20; // 0x122d48 - g_ps2RecompiledFunctionTable[35665] = ps2___sfvwrite_0x122d20; // 0x122d4c - g_ps2RecompiledFunctionTable[35666] = ps2___sfvwrite_0x122d20; // 0x122d50 - g_ps2RecompiledFunctionTable[35667] = ps2___sfvwrite_0x122d20; // 0x122d54 - g_ps2RecompiledFunctionTable[35668] = ps2___sfvwrite_0x122d20; // 0x122d58 - g_ps2RecompiledFunctionTable[35669] = ps2___sfvwrite_0x122d20; // 0x122d5c - g_ps2RecompiledFunctionTable[35670] = ps2___sfvwrite_0x122d20; // 0x122d60 - g_ps2RecompiledFunctionTable[35671] = ps2___sfvwrite_0x122d20; // 0x122d64 - g_ps2RecompiledFunctionTable[35672] = ps2___sfvwrite_0x122d20; // 0x122d68 - g_ps2RecompiledFunctionTable[35673] = ps2___sfvwrite_0x122d20; // 0x122d6c - g_ps2RecompiledFunctionTable[35674] = ps2___sfvwrite_0x122d20; // 0x122d70 - g_ps2RecompiledFunctionTable[35675] = ps2___sfvwrite_0x122d20; // 0x122d74 - g_ps2RecompiledFunctionTable[35676] = ps2___sfvwrite_0x122d20; // 0x122d78 - g_ps2RecompiledFunctionTable[35677] = ps2___sfvwrite_0x122d20; // 0x122d7c - g_ps2RecompiledFunctionTable[35678] = ps2___sfvwrite_0x122d20; // 0x122d80 - g_ps2RecompiledFunctionTable[35679] = ps2___sfvwrite_0x122d20; // 0x122d84 - g_ps2RecompiledFunctionTable[35680] = ps2___sfvwrite_0x122d20; // 0x122d88 - g_ps2RecompiledFunctionTable[35681] = ps2___sfvwrite_0x122d20; // 0x122d8c - g_ps2RecompiledFunctionTable[35682] = ps2___sfvwrite_0x122d20; // 0x122d90 - g_ps2RecompiledFunctionTable[35683] = ps2___sfvwrite_0x122d20; // 0x122d94 - g_ps2RecompiledFunctionTable[35684] = ps2___sfvwrite_0x122d20; // 0x122d98 - g_ps2RecompiledFunctionTable[35685] = ps2___sfvwrite_0x122d20; // 0x122d9c - g_ps2RecompiledFunctionTable[35686] = ps2___sfvwrite_0x122d20; // 0x122da0 - g_ps2RecompiledFunctionTable[35687] = ps2___sfvwrite_0x122d20; // 0x122da4 - g_ps2RecompiledFunctionTable[35688] = ps2___sfvwrite_0x122d20; // 0x122da8 - g_ps2RecompiledFunctionTable[35689] = ps2___sfvwrite_0x122d20; // 0x122dac - g_ps2RecompiledFunctionTable[35690] = ps2___sfvwrite_0x122d20; // 0x122db0 - g_ps2RecompiledFunctionTable[35691] = ps2___sfvwrite_0x122d20; // 0x122db4 - g_ps2RecompiledFunctionTable[35692] = ps2___sfvwrite_0x122d20; // 0x122db8 - g_ps2RecompiledFunctionTable[35693] = ps2___sfvwrite_0x122d20; // 0x122dbc - g_ps2RecompiledFunctionTable[35694] = ps2___sfvwrite_0x122d20; // 0x122dc0 - g_ps2RecompiledFunctionTable[35695] = ps2___sfvwrite_0x122d20; // 0x122dc4 - g_ps2RecompiledFunctionTable[35696] = ps2___sfvwrite_0x122d20; // 0x122dc8 - g_ps2RecompiledFunctionTable[35697] = ps2___sfvwrite_0x122d20; // 0x122dcc - g_ps2RecompiledFunctionTable[35698] = ps2___sfvwrite_0x122d20; // 0x122dd0 - g_ps2RecompiledFunctionTable[35699] = ps2___sfvwrite_0x122d20; // 0x122dd4 - g_ps2RecompiledFunctionTable[35700] = ps2___sfvwrite_0x122d20; // 0x122dd8 - g_ps2RecompiledFunctionTable[35701] = ps2___sfvwrite_0x122d20; // 0x122ddc - g_ps2RecompiledFunctionTable[35702] = ps2___sfvwrite_0x122d20; // 0x122de0 - g_ps2RecompiledFunctionTable[35703] = ps2___sfvwrite_0x122d20; // 0x122de4 - g_ps2RecompiledFunctionTable[35704] = ps2___sfvwrite_0x122d20; // 0x122de8 - g_ps2RecompiledFunctionTable[35705] = ps2___sfvwrite_0x122d20; // 0x122dec - g_ps2RecompiledFunctionTable[35706] = ps2___sfvwrite_0x122d20; // 0x122df0 - g_ps2RecompiledFunctionTable[35707] = ps2___sfvwrite_0x122d20; // 0x122df4 - g_ps2RecompiledFunctionTable[35708] = ps2___sfvwrite_0x122d20; // 0x122df8 - g_ps2RecompiledFunctionTable[35709] = ps2___sfvwrite_0x122d20; // 0x122dfc - g_ps2RecompiledFunctionTable[35710] = ps2___sfvwrite_0x122d20; // 0x122e00 - g_ps2RecompiledFunctionTable[35711] = ps2___sfvwrite_0x122d20; // 0x122e04 - g_ps2RecompiledFunctionTable[35712] = ps2___sfvwrite_0x122d20; // 0x122e08 - g_ps2RecompiledFunctionTable[35713] = ps2___sfvwrite_0x122d20; // 0x122e0c - g_ps2RecompiledFunctionTable[35714] = ps2___sfvwrite_0x122d20; // 0x122e10 - g_ps2RecompiledFunctionTable[35715] = ps2___sfvwrite_0x122d20; // 0x122e14 - g_ps2RecompiledFunctionTable[35716] = ps2___sfvwrite_0x122d20; // 0x122e18 - g_ps2RecompiledFunctionTable[35717] = ps2___sfvwrite_0x122d20; // 0x122e1c - g_ps2RecompiledFunctionTable[35718] = ps2___sfvwrite_0x122d20; // 0x122e20 - g_ps2RecompiledFunctionTable[35719] = ps2___sfvwrite_0x122d20; // 0x122e24 - g_ps2RecompiledFunctionTable[35720] = ps2___sfvwrite_0x122d20; // 0x122e28 - g_ps2RecompiledFunctionTable[35721] = ps2___sfvwrite_0x122d20; // 0x122e2c - g_ps2RecompiledFunctionTable[35722] = ps2___sfvwrite_0x122d20; // 0x122e30 - g_ps2RecompiledFunctionTable[35723] = ps2___sfvwrite_0x122d20; // 0x122e34 - g_ps2RecompiledFunctionTable[35724] = ps2___sfvwrite_0x122d20; // 0x122e38 - g_ps2RecompiledFunctionTable[35725] = ps2___sfvwrite_0x122d20; // 0x122e3c - g_ps2RecompiledFunctionTable[35726] = ps2___sfvwrite_0x122d20; // 0x122e40 - g_ps2RecompiledFunctionTable[35727] = ps2___sfvwrite_0x122d20; // 0x122e44 - g_ps2RecompiledFunctionTable[35728] = ps2___sfvwrite_0x122d20; // 0x122e48 - g_ps2RecompiledFunctionTable[35729] = ps2___sfvwrite_0x122d20; // 0x122e4c - g_ps2RecompiledFunctionTable[35730] = ps2___sfvwrite_0x122d20; // 0x122e50 - g_ps2RecompiledFunctionTable[35731] = ps2___sfvwrite_0x122d20; // 0x122e54 - g_ps2RecompiledFunctionTable[35732] = ps2___sfvwrite_0x122d20; // 0x122e58 - g_ps2RecompiledFunctionTable[35733] = ps2___sfvwrite_0x122d20; // 0x122e5c - g_ps2RecompiledFunctionTable[35734] = ps2___sfvwrite_0x122d20; // 0x122e60 - g_ps2RecompiledFunctionTable[35735] = ps2___sfvwrite_0x122d20; // 0x122e64 - g_ps2RecompiledFunctionTable[35736] = ps2___sfvwrite_0x122d20; // 0x122e68 - g_ps2RecompiledFunctionTable[35737] = ps2___sfvwrite_0x122d20; // 0x122e6c - g_ps2RecompiledFunctionTable[35738] = ps2___sfvwrite_0x122d20; // 0x122e70 - g_ps2RecompiledFunctionTable[35739] = ps2___sfvwrite_0x122d20; // 0x122e74 - g_ps2RecompiledFunctionTable[35740] = ps2___sfvwrite_0x122d20; // 0x122e78 - g_ps2RecompiledFunctionTable[35741] = ps2___sfvwrite_0x122d20; // 0x122e7c - g_ps2RecompiledFunctionTable[35742] = ps2___sfvwrite_0x122d20; // 0x122e80 - g_ps2RecompiledFunctionTable[35743] = ps2___sfvwrite_0x122d20; // 0x122e84 - g_ps2RecompiledFunctionTable[35744] = ps2___sfvwrite_0x122d20; // 0x122e88 - g_ps2RecompiledFunctionTable[35745] = ps2___sfvwrite_0x122d20; // 0x122e8c - g_ps2RecompiledFunctionTable[35746] = ps2___sfvwrite_0x122d20; // 0x122e90 - g_ps2RecompiledFunctionTable[35747] = ps2___sfvwrite_0x122d20; // 0x122e94 - g_ps2RecompiledFunctionTable[35748] = ps2___sfvwrite_0x122d20; // 0x122e98 - g_ps2RecompiledFunctionTable[35749] = ps2___sfvwrite_0x122d20; // 0x122e9c - g_ps2RecompiledFunctionTable[35750] = ps2___sfvwrite_0x122d20; // 0x122ea0 - g_ps2RecompiledFunctionTable[35751] = ps2___sfvwrite_0x122d20; // 0x122ea4 - g_ps2RecompiledFunctionTable[35752] = ps2___sfvwrite_0x122d20; // 0x122ea8 - g_ps2RecompiledFunctionTable[35753] = ps2___sfvwrite_0x122d20; // 0x122eac - g_ps2RecompiledFunctionTable[35754] = ps2___sfvwrite_0x122d20; // 0x122eb0 - g_ps2RecompiledFunctionTable[35755] = ps2___sfvwrite_0x122d20; // 0x122eb4 - g_ps2RecompiledFunctionTable[35756] = ps2___sfvwrite_0x122d20; // 0x122eb8 - g_ps2RecompiledFunctionTable[35757] = ps2___sfvwrite_0x122d20; // 0x122ebc - g_ps2RecompiledFunctionTable[35758] = ps2___sfvwrite_0x122d20; // 0x122ec0 - g_ps2RecompiledFunctionTable[35759] = ps2___sfvwrite_0x122d20; // 0x122ec4 - g_ps2RecompiledFunctionTable[35760] = ps2___sfvwrite_0x122d20; // 0x122ec8 - g_ps2RecompiledFunctionTable[35761] = ps2___sfvwrite_0x122d20; // 0x122ecc - g_ps2RecompiledFunctionTable[35762] = ps2___sfvwrite_0x122d20; // 0x122ed0 - g_ps2RecompiledFunctionTable[35763] = ps2___sfvwrite_0x122d20; // 0x122ed4 - g_ps2RecompiledFunctionTable[35764] = ps2___sfvwrite_0x122d20; // 0x122ed8 - g_ps2RecompiledFunctionTable[35765] = ps2___sfvwrite_0x122d20; // 0x122edc - g_ps2RecompiledFunctionTable[35766] = ps2___sfvwrite_0x122d20; // 0x122ee0 - g_ps2RecompiledFunctionTable[35767] = ps2___sfvwrite_0x122d20; // 0x122ee4 - g_ps2RecompiledFunctionTable[35768] = ps2___sfvwrite_0x122d20; // 0x122ee8 - g_ps2RecompiledFunctionTable[35769] = ps2___sfvwrite_0x122d20; // 0x122eec - g_ps2RecompiledFunctionTable[35770] = ps2___sfvwrite_0x122d20; // 0x122ef0 - g_ps2RecompiledFunctionTable[35771] = ps2___sfvwrite_0x122d20; // 0x122ef4 - g_ps2RecompiledFunctionTable[35772] = ps2___sfvwrite_0x122d20; // 0x122ef8 - g_ps2RecompiledFunctionTable[35773] = ps2___sfvwrite_0x122d20; // 0x122efc - g_ps2RecompiledFunctionTable[35774] = ps2___sfvwrite_0x122d20; // 0x122f00 - g_ps2RecompiledFunctionTable[35775] = ps2___sfvwrite_0x122d20; // 0x122f04 - g_ps2RecompiledFunctionTable[35776] = ps2___sfvwrite_0x122d20; // 0x122f08 - g_ps2RecompiledFunctionTable[35777] = ps2___sfvwrite_0x122d20; // 0x122f0c - g_ps2RecompiledFunctionTable[35778] = ps2___sfvwrite_0x122d20; // 0x122f10 - g_ps2RecompiledFunctionTable[35779] = ps2___sfvwrite_0x122d20; // 0x122f14 - g_ps2RecompiledFunctionTable[35780] = ps2___sfvwrite_0x122d20; // 0x122f18 - g_ps2RecompiledFunctionTable[35781] = ps2___sfvwrite_0x122d20; // 0x122f1c - g_ps2RecompiledFunctionTable[35782] = ps2___sfvwrite_0x122d20; // 0x122f20 - g_ps2RecompiledFunctionTable[35783] = ps2___sfvwrite_0x122d20; // 0x122f24 - g_ps2RecompiledFunctionTable[35784] = ps2___sfvwrite_0x122d20; // 0x122f28 - g_ps2RecompiledFunctionTable[35785] = ps2___sfvwrite_0x122d20; // 0x122f2c - g_ps2RecompiledFunctionTable[35786] = ps2___sfvwrite_0x122d20; // 0x122f30 - g_ps2RecompiledFunctionTable[35787] = ps2___sfvwrite_0x122d20; // 0x122f34 - g_ps2RecompiledFunctionTable[35788] = ps2___sfvwrite_0x122d20; // 0x122f38 - g_ps2RecompiledFunctionTable[35789] = ps2___sfvwrite_0x122d20; // 0x122f3c - g_ps2RecompiledFunctionTable[35790] = ps2___sfvwrite_0x122d20; // 0x122f40 - g_ps2RecompiledFunctionTable[35791] = ps2___sfvwrite_0x122d20; // 0x122f44 - g_ps2RecompiledFunctionTable[35792] = ps2___sfvwrite_0x122d20; // 0x122f48 - g_ps2RecompiledFunctionTable[35793] = ps2___sfvwrite_0x122d20; // 0x122f4c - g_ps2RecompiledFunctionTable[35794] = ps2___sfvwrite_0x122d20; // 0x122f50 - g_ps2RecompiledFunctionTable[35795] = ps2___sfvwrite_0x122d20; // 0x122f54 - g_ps2RecompiledFunctionTable[35796] = ps2___sfvwrite_0x122d20; // 0x122f58 - g_ps2RecompiledFunctionTable[35797] = ps2___sfvwrite_0x122d20; // 0x122f5c - g_ps2RecompiledFunctionTable[35798] = ps2___sfvwrite_0x122d20; // 0x122f60 - g_ps2RecompiledFunctionTable[35799] = ps2___sfvwrite_0x122d20; // 0x122f64 - g_ps2RecompiledFunctionTable[35800] = ps2___sfvwrite_0x122d20; // 0x122f68 - g_ps2RecompiledFunctionTable[35801] = ps2___sfvwrite_0x122d20; // 0x122f6c - g_ps2RecompiledFunctionTable[35802] = ps2___sfvwrite_0x122d20; // 0x122f70 - g_ps2RecompiledFunctionTable[35803] = ps2___sfvwrite_0x122d20; // 0x122f74 - g_ps2RecompiledFunctionTable[35804] = ps2___sfvwrite_0x122d20; // 0x122f78 - g_ps2RecompiledFunctionTable[35805] = ps2___sfvwrite_0x122d20; // 0x122f7c - g_ps2RecompiledFunctionTable[35806] = ps2___sfvwrite_0x122d20; // 0x122f80 - g_ps2RecompiledFunctionTable[35807] = ps2___sfvwrite_0x122d20; // 0x122f84 - g_ps2RecompiledFunctionTable[35808] = ps2___sfvwrite_0x122d20; // 0x122f88 - g_ps2RecompiledFunctionTable[35809] = ps2___sfvwrite_0x122d20; // 0x122f8c - g_ps2RecompiledFunctionTable[35810] = ps2___sfvwrite_0x122d20; // 0x122f90 - g_ps2RecompiledFunctionTable[35811] = ps2___sfvwrite_0x122d20; // 0x122f94 - g_ps2RecompiledFunctionTable[35812] = ps2___sfvwrite_0x122d20; // 0x122f98 - g_ps2RecompiledFunctionTable[35813] = ps2___sfvwrite_0x122d20; // 0x122f9c - g_ps2RecompiledFunctionTable[35814] = ps2___sfvwrite_0x122d20; // 0x122fa0 - g_ps2RecompiledFunctionTable[35815] = ps2___sfvwrite_0x122d20; // 0x122fa4 - g_ps2RecompiledFunctionTable[35816] = ps2___sfvwrite_0x122d20; // 0x122fa8 - g_ps2RecompiledFunctionTable[35817] = ps2___sfvwrite_0x122d20; // 0x122fac - g_ps2RecompiledFunctionTable[35818] = ps2___sfvwrite_0x122d20; // 0x122fb0 - g_ps2RecompiledFunctionTable[35819] = ps2___sfvwrite_0x122d20; // 0x122fb4 - g_ps2RecompiledFunctionTable[35820] = ps2___sfvwrite_0x122d20; // 0x122fb8 - g_ps2RecompiledFunctionTable[35821] = ps2___sfvwrite_0x122d20; // 0x122fbc - g_ps2RecompiledFunctionTable[35822] = ps2___sfvwrite_0x122d20; // 0x122fc0 - g_ps2RecompiledFunctionTable[35823] = ps2___sfvwrite_0x122d20; // 0x122fc4 - g_ps2RecompiledFunctionTable[35824] = ps2___sfvwrite_0x122d20; // 0x122fc8 - g_ps2RecompiledFunctionTable[35825] = ps2___sfvwrite_0x122d20; // 0x122fcc - g_ps2RecompiledFunctionTable[35826] = ps2___sfvwrite_0x122d20; // 0x122fd0 - g_ps2RecompiledFunctionTable[35827] = ps2___sfvwrite_0x122d20; // 0x122fd4 - g_ps2RecompiledFunctionTable[35828] = ps2___sfvwrite_0x122d20; // 0x122fd8 - g_ps2RecompiledFunctionTable[35829] = ps2___sfvwrite_0x122d20; // 0x122fdc - g_ps2RecompiledFunctionTable[35830] = ps2___sfvwrite_0x122d20; // 0x122fe0 - g_ps2RecompiledFunctionTable[35831] = ps2___sfvwrite_0x122d20; // 0x122fe4 - g_ps2RecompiledFunctionTable[35832] = ps2___sfvwrite_0x122d20; // 0x122fe8 - g_ps2RecompiledFunctionTable[35833] = ps2___sfvwrite_0x122d20; // 0x122fec - g_ps2RecompiledFunctionTable[35834] = ps2___sfvwrite_0x122d20; // 0x122ff0 - g_ps2RecompiledFunctionTable[35835] = ps2___sfvwrite_0x122d20; // 0x122ff4 - g_ps2RecompiledFunctionTable[35836] = ps2___sfvwrite_0x122d20; // 0x122ff8 - g_ps2RecompiledFunctionTable[35837] = ps2___sfvwrite_0x122d20; // 0x122ffc - g_ps2RecompiledFunctionTable[35838] = ps2___sfvwrite_0x122d20; // 0x123000 - g_ps2RecompiledFunctionTable[35839] = ps2___sfvwrite_0x122d20; // 0x123004 - g_ps2RecompiledFunctionTable[35840] = ps2___sfvwrite_0x122d20; // 0x123008 - g_ps2RecompiledFunctionTable[35841] = ps2___sfvwrite_0x122d20; // 0x12300c - g_ps2RecompiledFunctionTable[35842] = ps2___sfvwrite_0x122d20; // 0x123010 - g_ps2RecompiledFunctionTable[35843] = ps2___sfvwrite_0x122d20; // 0x123014 - g_ps2RecompiledFunctionTable[35844] = ps2___sfvwrite_0x122d20; // 0x123018 - g_ps2RecompiledFunctionTable[35845] = ps2___sfvwrite_0x122d20; // 0x12301c - g_ps2RecompiledFunctionTable[35846] = ps2___sfvwrite_0x122d20; // 0x123020 - g_ps2RecompiledFunctionTable[35847] = ps2___sfvwrite_0x122d20; // 0x123024 - g_ps2RecompiledFunctionTable[35848] = ps2___sfvwrite_0x122d20; // 0x123028 - g_ps2RecompiledFunctionTable[35849] = ps2___sfvwrite_0x122d20; // 0x12302c - g_ps2RecompiledFunctionTable[35850] = ps2___sfvwrite_0x122d20; // 0x123030 - g_ps2RecompiledFunctionTable[35851] = ps2___sfvwrite_0x122d20; // 0x123034 - g_ps2RecompiledFunctionTable[35852] = ps2___sfvwrite_0x122d20; // 0x123038 - g_ps2RecompiledFunctionTable[35853] = ps2___sfvwrite_0x122d20; // 0x12303c - g_ps2RecompiledFunctionTable[35854] = ps2___sfvwrite_0x122d20; // 0x123040 - g_ps2RecompiledFunctionTable[35855] = ps2___sfvwrite_0x122d20; // 0x123044 - g_ps2RecompiledFunctionTable[35856] = ps2___sfvwrite_0x122d20; // 0x123048 - g_ps2RecompiledFunctionTable[35857] = ps2___sfvwrite_0x122d20; // 0x12304c - g_ps2RecompiledFunctionTable[35858] = ps2___sfvwrite_0x122d20; // 0x123050 - g_ps2RecompiledFunctionTable[35859] = ps2___sfvwrite_0x122d20; // 0x123054 - g_ps2RecompiledFunctionTable[35860] = ps2___sfvwrite_0x122d20; // 0x123058 - g_ps2RecompiledFunctionTable[35861] = ps2___sfvwrite_0x122d20; // 0x12305c - g_ps2RecompiledFunctionTable[35862] = ps2___sfvwrite_0x122d20; // 0x123060 - g_ps2RecompiledFunctionTable[35863] = ps2___sfvwrite_0x122d20; // 0x123064 - g_ps2RecompiledFunctionTable[35864] = ps2___sfvwrite_0x122d20; // 0x123068 - g_ps2RecompiledFunctionTable[35865] = ps2___sfvwrite_0x122d20; // 0x12306c - g_ps2RecompiledFunctionTable[35866] = ps2___sfvwrite_0x122d20; // 0x123070 - g_ps2RecompiledFunctionTable[35867] = ps2___sfvwrite_0x122d20; // 0x123074 - g_ps2RecompiledFunctionTable[35868] = ps2___sfvwrite_0x122d20; // 0x123078 - g_ps2RecompiledFunctionTable[35869] = ps2___sfvwrite_0x122d20; // 0x12307c - g_ps2RecompiledFunctionTable[35870] = ps2___sfvwrite_0x122d20; // 0x123080 - g_ps2RecompiledFunctionTable[35871] = ps2___sfvwrite_0x122d20; // 0x123084 - g_ps2RecompiledFunctionTable[35872] = ps2___sfvwrite_0x122d20; // 0x123088 - g_ps2RecompiledFunctionTable[35873] = ps2___sfvwrite_0x122d20; // 0x12308c - g_ps2RecompiledFunctionTable[35874] = ps2___sfvwrite_0x122d20; // 0x123090 - g_ps2RecompiledFunctionTable[35875] = ps2___sfvwrite_0x122d20; // 0x123094 - g_ps2RecompiledFunctionTable[35876] = ps2___sfvwrite_0x122d20; // 0x123098 - g_ps2RecompiledFunctionTable[35877] = ps2___sfvwrite_0x122d20; // 0x12309c - g_ps2RecompiledFunctionTable[35878] = ps2___sfvwrite_0x122d20; // 0x1230a0 - g_ps2RecompiledFunctionTable[35879] = ps2___sfvwrite_0x122d20; // 0x1230a4 - g_ps2RecompiledFunctionTable[35880] = ps2___sfvwrite_0x122d20; // 0x1230a8 - g_ps2RecompiledFunctionTable[35881] = ps2___sfvwrite_0x122d20; // 0x1230ac - g_ps2RecompiledFunctionTable[35882] = ps2___sfvwrite_0x122d20; // 0x1230b0 - g_ps2RecompiledFunctionTable[35883] = ps2___sfvwrite_0x122d20; // 0x1230b4 - g_ps2RecompiledFunctionTable[35884] = ps2___sfvwrite_0x122d20; // 0x1230b8 - g_ps2RecompiledFunctionTable[35885] = ps2___sfvwrite_0x122d20; // 0x1230bc - g_ps2RecompiledFunctionTable[35886] = ps2___sfvwrite_0x122d20; // 0x1230c0 - g_ps2RecompiledFunctionTable[35887] = ps2___sfvwrite_0x122d20; // 0x1230c4 - g_ps2RecompiledFunctionTable[35888] = ps2___sfvwrite_0x122d20; // 0x1230c8 - g_ps2RecompiledFunctionTable[35889] = ps2___sfvwrite_0x122d20; // 0x1230cc - g_ps2RecompiledFunctionTable[35890] = ps2___sfvwrite_0x122d20; // 0x1230d0 - g_ps2RecompiledFunctionTable[35891] = ps2___sfvwrite_0x122d20; // 0x1230d4 - g_ps2RecompiledFunctionTable[35892] = ps2___sfvwrite_0x122d20; // 0x1230d8 - g_ps2RecompiledFunctionTable[35893] = ps2___sfvwrite_0x122d20; // 0x1230dc - g_ps2RecompiledFunctionTable[35894] = ps2___sfvwrite_0x122d20; // 0x1230e0 - g_ps2RecompiledFunctionTable[35895] = ps2___sfvwrite_0x122d20; // 0x1230e4 - g_ps2RecompiledFunctionTable[35896] = ps2___sfvwrite_0x122d20; // 0x1230e8 - g_ps2RecompiledFunctionTable[35897] = ps2___sfvwrite_0x122d20; // 0x1230ec - g_ps2RecompiledFunctionTable[35898] = ps2___sfvwrite_0x122d20; // 0x1230f0 - g_ps2RecompiledFunctionTable[35899] = ps2___sfvwrite_0x122d20; // 0x1230f4 - g_ps2RecompiledFunctionTable[35900] = _fwalk_0x1230f8; // 0x1230f8 - g_ps2RecompiledFunctionTable[35901] = _fwalk_0x1230f8; // 0x1230fc - g_ps2RecompiledFunctionTable[35902] = _fwalk_0x1230f8; // 0x123100 - g_ps2RecompiledFunctionTable[35903] = _fwalk_0x1230f8; // 0x123104 - g_ps2RecompiledFunctionTable[35904] = _fwalk_0x1230f8; // 0x123108 - g_ps2RecompiledFunctionTable[35905] = _fwalk_0x1230f8; // 0x12310c - g_ps2RecompiledFunctionTable[35906] = _fwalk_0x1230f8; // 0x123110 - g_ps2RecompiledFunctionTable[35907] = _fwalk_0x1230f8; // 0x123114 - g_ps2RecompiledFunctionTable[35908] = _fwalk_0x1230f8; // 0x123118 - g_ps2RecompiledFunctionTable[35909] = _fwalk_0x1230f8; // 0x12311c - g_ps2RecompiledFunctionTable[35910] = _fwalk_0x1230f8; // 0x123120 - g_ps2RecompiledFunctionTable[35911] = _fwalk_0x1230f8; // 0x123124 - g_ps2RecompiledFunctionTable[35912] = _fwalk_0x1230f8; // 0x123128 - g_ps2RecompiledFunctionTable[35913] = _fwalk_0x1230f8; // 0x12312c - g_ps2RecompiledFunctionTable[35914] = _fwalk_0x1230f8; // 0x123130 - g_ps2RecompiledFunctionTable[35915] = _fwalk_0x1230f8; // 0x123134 - g_ps2RecompiledFunctionTable[35916] = _fwalk_0x1230f8; // 0x123138 - g_ps2RecompiledFunctionTable[35917] = _fwalk_0x1230f8; // 0x12313c - g_ps2RecompiledFunctionTable[35918] = _fwalk_0x1230f8; // 0x123140 - g_ps2RecompiledFunctionTable[35919] = _fwalk_0x1230f8; // 0x123144 - g_ps2RecompiledFunctionTable[35920] = _fwalk_0x1230f8; // 0x123148 - g_ps2RecompiledFunctionTable[35921] = _fwalk_0x1230f8; // 0x12314c - g_ps2RecompiledFunctionTable[35922] = _fwalk_0x1230f8; // 0x123150 - g_ps2RecompiledFunctionTable[35923] = _fwalk_0x1230f8; // 0x123154 - g_ps2RecompiledFunctionTable[35924] = _fwalk_0x1230f8; // 0x123158 - g_ps2RecompiledFunctionTable[35925] = _fwalk_0x1230f8; // 0x12315c - g_ps2RecompiledFunctionTable[35926] = _fwalk_0x1230f8; // 0x123160 - g_ps2RecompiledFunctionTable[35927] = _fwalk_0x1230f8; // 0x123164 - g_ps2RecompiledFunctionTable[35928] = _fwalk_0x1230f8; // 0x123168 - g_ps2RecompiledFunctionTable[35929] = _fwalk_0x1230f8; // 0x12316c - g_ps2RecompiledFunctionTable[35930] = _fwalk_0x1230f8; // 0x123170 - g_ps2RecompiledFunctionTable[35931] = _fwalk_0x1230f8; // 0x123174 - g_ps2RecompiledFunctionTable[35932] = _fwalk_0x1230f8; // 0x123178 - g_ps2RecompiledFunctionTable[35933] = _fwalk_0x1230f8; // 0x12317c - g_ps2RecompiledFunctionTable[35934] = _fwalk_0x1230f8; // 0x123180 - g_ps2RecompiledFunctionTable[35935] = _fwalk_0x1230f8; // 0x123184 - g_ps2RecompiledFunctionTable[35936] = _fwalk_0x1230f8; // 0x123188 - g_ps2RecompiledFunctionTable[35938] = index_0x123190; // 0x123190 - g_ps2RecompiledFunctionTable[35942] = index_0x123190; // 0x1231a0 - g_ps2RecompiledFunctionTable[35946] = _setlocale_r_0x1231b0; // 0x1231b0 - g_ps2RecompiledFunctionTable[35960] = _setlocale_r_0x1231b0; // 0x1231e8 - g_ps2RecompiledFunctionTable[35965] = _setlocale_r_0x1231b0; // 0x1231fc - g_ps2RecompiledFunctionTable[35980] = _localeconv_r_0x123238; // 0x123238 - g_ps2RecompiledFunctionTable[35984] = setlocale_0x123248; // 0x123248 - g_ps2RecompiledFunctionTable[35992] = setlocale_0x123248; // 0x123268 - g_ps2RecompiledFunctionTable[35996] = localeconv_0x123278; // 0x123278 - g_ps2RecompiledFunctionTable[36002] = localeconv_0x123278; // 0x123290 - g_ps2RecompiledFunctionTable[36006] = _lseek_r_0x1232a0; // 0x1232a0 - g_ps2RecompiledFunctionTable[36017] = _lseek_r_0x1232a0; // 0x1232cc - g_ps2RecompiledFunctionTable[36030] = ps2___smakebuf_0x123300; // 0x123300 - g_ps2RecompiledFunctionTable[36051] = ps2___smakebuf_0x123300; // 0x123354 - g_ps2RecompiledFunctionTable[36080] = ps2___smakebuf_0x123300; // 0x1233c8 - g_ps2RecompiledFunctionTable[36103] = ps2___smakebuf_0x123300; // 0x123424 - g_ps2RecompiledFunctionTable[36114] = malloc_extend_top_0x123450; // 0x123450 - g_ps2RecompiledFunctionTable[36264] = _malloc_r_0x1236a8; // 0x1236a8 - g_ps2RecompiledFunctionTable[36742] = _mbtowc_r_0x123e20; // 0x123e20 - g_ps2RecompiledFunctionTable[36758] = memchr_0x123e60; // 0x123e60 - g_ps2RecompiledFunctionTable[36814] = memcmp_0x123f40; // 0x123f40 - g_ps2RecompiledFunctionTable[36852] = memcpy_0x123fd8; // 0x123fd8 - g_ps2RecompiledFunctionTable[36896] = memmove_0x124088; // 0x124088 - g_ps2RecompiledFunctionTable[36962] = memset_0x124190; // 0x124190 - g_ps2RecompiledFunctionTable[37010] = ps2___malloc_lock_0x124250; // 0x124250 - g_ps2RecompiledFunctionTable[37012] = ps2___malloc_unlock_0x124258; // 0x124258 - g_ps2RecompiledFunctionTable[37014] = ps2__Balloc_0x124260; // 0x124260 - g_ps2RecompiledFunctionTable[37025] = ps2__Balloc_0x124260; // 0x12428c - g_ps2RecompiledFunctionTable[37042] = ps2__Balloc_0x124260; // 0x1242d0 - g_ps2RecompiledFunctionTable[37056] = ps2__Bfree_0x124308; // 0x124308 - g_ps2RecompiledFunctionTable[37068] = _multadd_0x124338; // 0x124338 - g_ps2RecompiledFunctionTable[37084] = _multadd_0x124338; // 0x124378 - g_ps2RecompiledFunctionTable[37111] = _multadd_0x124338; // 0x1243e4 - g_ps2RecompiledFunctionTable[37118] = _multadd_0x124338; // 0x124400 - g_ps2RecompiledFunctionTable[37121] = _multadd_0x124338; // 0x12440c - g_ps2RecompiledFunctionTable[37138] = _s2b_0x124450; // 0x124450 - g_ps2RecompiledFunctionTable[37164] = _s2b_0x124450; // 0x1244b8 - g_ps2RecompiledFunctionTable[37177] = _s2b_0x124450; // 0x1244ec - g_ps2RecompiledFunctionTable[37184] = _s2b_0x124450; // 0x124508 - g_ps2RecompiledFunctionTable[37190] = _s2b_0x124450; // 0x124520 - g_ps2RecompiledFunctionTable[37200] = _s2b_0x124450; // 0x124548 - g_ps2RecompiledFunctionTable[37207] = _s2b_0x124450; // 0x124564 - g_ps2RecompiledFunctionTable[37220] = _hi0bits_0x124598; // 0x124598 - g_ps2RecompiledFunctionTable[37254] = _lo0bits_0x124620; // 0x124620 - g_ps2RecompiledFunctionTable[37302] = _i2b_0x1246e0; // 0x1246e0 - g_ps2RecompiledFunctionTable[37308] = _i2b_0x1246e0; // 0x1246f8 - g_ps2RecompiledFunctionTable[37316] = _multiply_0x124718; // 0x124718 - g_ps2RecompiledFunctionTable[37341] = _multiply_0x124718; // 0x12477c - g_ps2RecompiledFunctionTable[37352] = _multiply_0x124718; // 0x1247a8 - g_ps2RecompiledFunctionTable[37372] = _multiply_0x124718; // 0x1247f8 - g_ps2RecompiledFunctionTable[37380] = _multiply_0x124718; // 0x124818 - g_ps2RecompiledFunctionTable[37412] = _multiply_0x124718; // 0x124898 - g_ps2RecompiledFunctionTable[37438] = _multiply_0x124718; // 0x124900 - g_ps2RecompiledFunctionTable[37456] = _pow5mult_0x124948; // 0x124948 - g_ps2RecompiledFunctionTable[37475] = _pow5mult_0x124948; // 0x124994 - g_ps2RecompiledFunctionTable[37485] = _pow5mult_0x124948; // 0x1249bc - g_ps2RecompiledFunctionTable[37490] = _pow5mult_0x124948; // 0x1249d0 - g_ps2RecompiledFunctionTable[37496] = _pow5mult_0x124948; // 0x1249e8 - g_ps2RecompiledFunctionTable[37505] = _pow5mult_0x124948; // 0x124a0c - g_ps2RecompiledFunctionTable[37509] = _pow5mult_0x124948; // 0x124a1c - g_ps2RecompiledFunctionTable[37520] = _lshift_0x124a48; // 0x124a48 - g_ps2RecompiledFunctionTable[37542] = _lshift_0x124a48; // 0x124aa0 - g_ps2RecompiledFunctionTable[37555] = _lshift_0x124a48; // 0x124ad4 - g_ps2RecompiledFunctionTable[37560] = _lshift_0x124a48; // 0x124ae8 - g_ps2RecompiledFunctionTable[37576] = _lshift_0x124a48; // 0x124b28 - g_ps2RecompiledFunctionTable[37592] = _lshift_0x124a48; // 0x124b68 - g_ps2RecompiledFunctionTable[37603] = _lshift_0x124a48; // 0x124b94 - g_ps2RecompiledFunctionTable[37614] = ps2___mcmp_0x124bc0; // 0x124bc0 - g_ps2RecompiledFunctionTable[37621] = ps2___mcmp_0x124bc0; // 0x124bdc - g_ps2RecompiledFunctionTable[37630] = ps2___mcmp_0x124bc0; // 0x124c00 - g_ps2RecompiledFunctionTable[37640] = ps2___mdiff_0x124c28; // 0x124c28 - g_ps2RecompiledFunctionTable[37652] = ps2___mdiff_0x124c28; // 0x124c58 - g_ps2RecompiledFunctionTable[37657] = ps2___mdiff_0x124c28; // 0x124c6c - g_ps2RecompiledFunctionTable[37671] = ps2___mdiff_0x124c28; // 0x124ca4 - g_ps2RecompiledFunctionTable[37684] = ps2___mdiff_0x124c28; // 0x124cd8 - g_ps2RecompiledFunctionTable[37706] = ps2___mdiff_0x124c28; // 0x124d30 - g_ps2RecompiledFunctionTable[37724] = ps2___mdiff_0x124c28; // 0x124d78 - g_ps2RecompiledFunctionTable[37740] = _ulp_0x124db8; // 0x124db8 - g_ps2RecompiledFunctionTable[37778] = _b2d_0x124e50; // 0x124e50 - g_ps2RecompiledFunctionTable[37794] = _b2d_0x124e50; // 0x124e90 - g_ps2RecompiledFunctionTable[37874] = _d2b_0x124fd0; // 0x124fd0 - g_ps2RecompiledFunctionTable[37887] = _d2b_0x124fd0; // 0x125004 - g_ps2RecompiledFunctionTable[37913] = _d2b_0x124fd0; // 0x12506c - g_ps2RecompiledFunctionTable[37938] = _d2b_0x124fd0; // 0x1250d0 - g_ps2RecompiledFunctionTable[37956] = _d2b_0x124fd0; // 0x125118 - g_ps2RecompiledFunctionTable[37970] = _ratio_0x125150; // 0x125150 - g_ps2RecompiledFunctionTable[37979] = _ratio_0x125150; // 0x125174 - g_ps2RecompiledFunctionTable[37983] = _ratio_0x125150; // 0x125184 - g_ps2RecompiledFunctionTable[38012] = _ratio_0x125150; // 0x1251f8 - g_ps2RecompiledFunctionTable[38018] = _mprec_log10_0x125210; // 0x125210 - g_ps2RecompiledFunctionTable[38034] = _mprec_log10_0x125210; // 0x125250 - g_ps2RecompiledFunctionTable[38038] = _mprec_log10_0x125210; // 0x125260 - g_ps2RecompiledFunctionTable[38046] = _printf_r_0x125280; // 0x125280 - g_ps2RecompiledFunctionTable[38062] = printf_0x1252c0; // 0x1252c0 - g_ps2RecompiledFunctionTable[38082] = srand_0x125310; // 0x125310 - g_ps2RecompiledFunctionTable[38086] = rand_0x125320; // 0x125320 - g_ps2RecompiledFunctionTable[38098] = _read_r_0x125350; // 0x125350 - g_ps2RecompiledFunctionTable[38109] = _read_r_0x125350; // 0x12537c - g_ps2RecompiledFunctionTable[38122] = _sbrk_r_0x1253b0; // 0x1253b0 - g_ps2RecompiledFunctionTable[38131] = _sbrk_r_0x1253b0; // 0x1253d4 - g_ps2RecompiledFunctionTable[38146] = _sprintf_r_0x125410; // 0x125410 - g_ps2RecompiledFunctionTable[38167] = _sprintf_r_0x125410; // 0x125464 - g_ps2RecompiledFunctionTable[38172] = sprintf_0x125478; // 0x125478 - g_ps2RecompiledFunctionTable[38200] = ps2___sread_0x1254e8; // 0x1254e8 - g_ps2RecompiledFunctionTable[38210] = ps2___sread_0x1254e8; // 0x125510 - g_ps2RecompiledFunctionTable[38226] = ps2___swrite_0x125550; // 0x125550 - g_ps2RecompiledFunctionTable[38242] = ps2___swrite_0x125550; // 0x125590 - g_ps2RecompiledFunctionTable[38250] = ps2___swrite_0x125550; // 0x1255b0 - g_ps2RecompiledFunctionTable[38258] = ps2___sseek_0x1255d0; // 0x1255d0 - g_ps2RecompiledFunctionTable[38268] = ps2___sseek_0x1255d0; // 0x1255f8 - g_ps2RecompiledFunctionTable[38284] = ps2___sclose_0x125638; // 0x125638 - g_ps2RecompiledFunctionTable[38289] = ps2___sclose_0x125638; // 0x12564c - g_ps2RecompiledFunctionTable[38292] = strcasecmp_0x125658; // 0x125658 - g_ps2RecompiledFunctionTable[38338] = strcat_0x125710; // 0x125710 - g_ps2RecompiledFunctionTable[38414] = strchr_0x125840; // 0x125840 - g_ps2RecompiledFunctionTable[38514] = strcmp_0x1259d0; // 0x1259d0 - g_ps2RecompiledFunctionTable[38596] = strcpy_0x125b18; // 0x125b18 - g_ps2RecompiledFunctionTable[38666] = strlen_0x125c30; // 0x125c30 - g_ps2RecompiledFunctionTable[38744] = strncat_0x125d68; // 0x125d68 - g_ps2RecompiledFunctionTable[38852] = strncmp_0x125f18; // 0x125f18 - g_ps2RecompiledFunctionTable[38962] = strncpy_0x1260d0; // 0x1260d0 - g_ps2RecompiledFunctionTable[39074] = ps2___sprint_0x126290; // 0x126290 - g_ps2RecompiledFunctionTable[39085] = ps2___sprint_0x126290; // 0x1262bc - g_ps2RecompiledFunctionTable[39092] = ps2___sbprintf_0x1262d8; // 0x1262d8 - g_ps2RecompiledFunctionTable[39117] = ps2___sbprintf_0x1262d8; // 0x12633c - g_ps2RecompiledFunctionTable[39122] = ps2___sbprintf_0x1262d8; // 0x126350 - g_ps2RecompiledFunctionTable[39138] = vfprintf_0x126390; // 0x126390 - g_ps2RecompiledFunctionTable[39168] = _vfprintf_r_0x126408; // 0x126408 - g_ps2RecompiledFunctionTable[39184] = _vfprintf_r_0x126408; // 0x126448 - g_ps2RecompiledFunctionTable[39197] = _vfprintf_r_0x126408; // 0x12647c - g_ps2RecompiledFunctionTable[39212] = _vfprintf_r_0x126408; // 0x1264b8 - g_ps2RecompiledFunctionTable[39224] = _vfprintf_r_0x126408; // 0x1264e8 - g_ps2RecompiledFunctionTable[39226] = _vfprintf_r_0x126408; // 0x1264f0 - g_ps2RecompiledFunctionTable[39234] = _vfprintf_r_0x126408; // 0x126510 - g_ps2RecompiledFunctionTable[39261] = _vfprintf_r_0x126408; // 0x12657c - g_ps2RecompiledFunctionTable[39277] = _vfprintf_r_0x126408; // 0x1265bc - g_ps2RecompiledFunctionTable[39279] = _vfprintf_r_0x126408; // 0x1265c4 - g_ps2RecompiledFunctionTable[39280] = _vfprintf_r_0x126408; // 0x1265c8 - g_ps2RecompiledFunctionTable[39281] = _vfprintf_r_0x126408; // 0x1265cc - g_ps2RecompiledFunctionTable[39286] = _vfprintf_r_0x126408; // 0x1265e0 - g_ps2RecompiledFunctionTable[39340] = _vfprintf_r_0x126408; // 0x1266b8 - g_ps2RecompiledFunctionTable[39360] = _vfprintf_r_0x126408; // 0x126708 - g_ps2RecompiledFunctionTable[39444] = _vfprintf_r_0x126408; // 0x126858 - g_ps2RecompiledFunctionTable[39448] = _vfprintf_r_0x126408; // 0x126868 - g_ps2RecompiledFunctionTable[39458] = _vfprintf_r_0x126408; // 0x126890 - g_ps2RecompiledFunctionTable[39473] = _vfprintf_r_0x126408; // 0x1268cc - g_ps2RecompiledFunctionTable[39498] = _vfprintf_r_0x126408; // 0x126930 - g_ps2RecompiledFunctionTable[39589] = _vfprintf_r_0x126408; // 0x126a9c - g_ps2RecompiledFunctionTable[39598] = _vfprintf_r_0x126408; // 0x126ac0 - g_ps2RecompiledFunctionTable[39658] = _vfprintf_r_0x126408; // 0x126bb0 - g_ps2RecompiledFunctionTable[39664] = _vfprintf_r_0x126408; // 0x126bc8 - g_ps2RecompiledFunctionTable[39684] = _vfprintf_r_0x126408; // 0x126c18 - g_ps2RecompiledFunctionTable[39687] = _vfprintf_r_0x126408; // 0x126c24 - g_ps2RecompiledFunctionTable[39694] = _vfprintf_r_0x126408; // 0x126c40 - g_ps2RecompiledFunctionTable[39710] = _vfprintf_r_0x126408; // 0x126c80 - g_ps2RecompiledFunctionTable[39760] = _vfprintf_r_0x126408; // 0x126d48 - g_ps2RecompiledFunctionTable[39777] = _vfprintf_r_0x126408; // 0x126d8c - g_ps2RecompiledFunctionTable[39799] = _vfprintf_r_0x126408; // 0x126de4 - g_ps2RecompiledFunctionTable[39843] = _vfprintf_r_0x126408; // 0x126e94 - g_ps2RecompiledFunctionTable[39860] = _vfprintf_r_0x126408; // 0x126ed8 - g_ps2RecompiledFunctionTable[39876] = _vfprintf_r_0x126408; // 0x126f18 - g_ps2RecompiledFunctionTable[39897] = _vfprintf_r_0x126408; // 0x126f6c - g_ps2RecompiledFunctionTable[39910] = _vfprintf_r_0x126408; // 0x126fa0 - g_ps2RecompiledFunctionTable[39926] = _vfprintf_r_0x126408; // 0x126fe0 - g_ps2RecompiledFunctionTable[39947] = _vfprintf_r_0x126408; // 0x127034 - g_ps2RecompiledFunctionTable[39967] = _vfprintf_r_0x126408; // 0x127084 - g_ps2RecompiledFunctionTable[39986] = _vfprintf_r_0x126408; // 0x1270d0 - g_ps2RecompiledFunctionTable[40011] = _vfprintf_r_0x126408; // 0x127134 - g_ps2RecompiledFunctionTable[40020] = _vfprintf_r_0x126408; // 0x127158 - g_ps2RecompiledFunctionTable[40036] = _vfprintf_r_0x126408; // 0x127198 - g_ps2RecompiledFunctionTable[40075] = _vfprintf_r_0x126408; // 0x127234 - g_ps2RecompiledFunctionTable[40092] = _vfprintf_r_0x126408; // 0x127278 - g_ps2RecompiledFunctionTable[40100] = _vfprintf_r_0x126408; // 0x127298 - g_ps2RecompiledFunctionTable[40116] = _vfprintf_r_0x126408; // 0x1272d8 - g_ps2RecompiledFunctionTable[40139] = _vfprintf_r_0x126408; // 0x127334 - g_ps2RecompiledFunctionTable[40174] = _vfprintf_r_0x126408; // 0x1273c0 - g_ps2RecompiledFunctionTable[40184] = _vfprintf_r_0x126408; // 0x1273e8 - g_ps2RecompiledFunctionTable[40200] = _vfprintf_r_0x126408; // 0x127428 - g_ps2RecompiledFunctionTable[40223] = _vfprintf_r_0x126408; // 0x127484 - g_ps2RecompiledFunctionTable[40255] = _vfprintf_r_0x126408; // 0x127504 - g_ps2RecompiledFunctionTable[40276] = _vfprintf_r_0x126408; // 0x127558 - g_ps2RecompiledFunctionTable[40323] = _vfprintf_r_0x126408; // 0x127614 - g_ps2RecompiledFunctionTable[40328] = _vfprintf_r_0x126408; // 0x127628 - g_ps2RecompiledFunctionTable[40352] = _vfprintf_r_0x126408; // 0x127688 - g_ps2RecompiledFunctionTable[40368] = _vfprintf_r_0x126408; // 0x1276c8 - g_ps2RecompiledFunctionTable[40403] = _vfprintf_r_0x126408; // 0x127754 - g_ps2RecompiledFunctionTable[40421] = _vfprintf_r_0x126408; // 0x12779c - g_ps2RecompiledFunctionTable[40432] = _vfprintf_r_0x126408; // 0x1277c8 - g_ps2RecompiledFunctionTable[40449] = _vfprintf_r_0x126408; // 0x12780c - g_ps2RecompiledFunctionTable[40472] = _vfprintf_r_0x126408; // 0x127868 - g_ps2RecompiledFunctionTable[40487] = _vfprintf_r_0x126408; // 0x1278a4 - g_ps2RecompiledFunctionTable[40497] = _vfprintf_r_0x126408; // 0x1278cc - g_ps2RecompiledFunctionTable[40518] = cvt_0x127920; // 0x127920 - g_ps2RecompiledFunctionTable[40555] = cvt_0x127920; // 0x1279b4 - g_ps2RecompiledFunctionTable[40566] = cvt_0x127920; // 0x1279e0 - g_ps2RecompiledFunctionTable[40584] = cvt_0x127920; // 0x127a28 - g_ps2RecompiledFunctionTable[40593] = cvt_0x127920; // 0x127a4c - g_ps2RecompiledFunctionTable[40600] = cvt_0x127920; // 0x127a68 - g_ps2RecompiledFunctionTable[40626] = exponent_0x127ad0; // 0x127ad0 - g_ps2RecompiledFunctionTable[40644] = exponent_0x127ad0; // 0x127b18 - g_ps2RecompiledFunctionTable[40664] = exponent_0x127ad0; // 0x127b68 - g_ps2RecompiledFunctionTable[40682] = vsprintf_0x127bb0; // 0x127bb0 - g_ps2RecompiledFunctionTable[40704] = _write_r_0x127c08; // 0x127c08 - g_ps2RecompiledFunctionTable[40715] = _write_r_0x127c08; // 0x127c34 - g_ps2RecompiledFunctionTable[40728] = ps2___swsetup_0x127c68; // 0x127c68 - g_ps2RecompiledFunctionTable[40744] = ps2___swsetup_0x127c68; // 0x127ca8 - g_ps2RecompiledFunctionTable[40762] = ps2___swsetup_0x127c68; // 0x127cf0 - g_ps2RecompiledFunctionTable[40777] = ps2___swsetup_0x127c68; // 0x127d2c - g_ps2RecompiledFunctionTable[40796] = ps2___divdi3_0x127d78; // 0x127d78 - g_ps2RecompiledFunctionTable[41240] = ps2___fixunsdfdi_0x128468; // 0x128468 - g_ps2RecompiledFunctionTable[41248] = ps2___fixunsdfdi_0x128468; // 0x128488 - g_ps2RecompiledFunctionTable[41254] = ps2___fixunsdfdi_0x128468; // 0x1284a0 - g_ps2RecompiledFunctionTable[41256] = ps2___fixunsdfdi_0x128468; // 0x1284a8 - g_ps2RecompiledFunctionTable[41261] = ps2___fixunsdfdi_0x128468; // 0x1284bc - g_ps2RecompiledFunctionTable[41266] = ps2___fixunsdfdi_0x128468; // 0x1284d0 - g_ps2RecompiledFunctionTable[41269] = ps2___fixunsdfdi_0x128468; // 0x1284dc - g_ps2RecompiledFunctionTable[41272] = ps2___fixunsdfdi_0x128468; // 0x1284e8 - g_ps2RecompiledFunctionTable[41277] = ps2___fixunsdfdi_0x128468; // 0x1284fc - g_ps2RecompiledFunctionTable[41281] = ps2___fixunsdfdi_0x128468; // 0x12850c - g_ps2RecompiledFunctionTable[41283] = ps2___fixunsdfdi_0x128468; // 0x128514 - g_ps2RecompiledFunctionTable[41289] = ps2___fixunsdfdi_0x128468; // 0x12852c - g_ps2RecompiledFunctionTable[41300] = ps2___floatdidf_0x128558; // 0x128558 - g_ps2RecompiledFunctionTable[41310] = ps2___floatdidf_0x128558; // 0x128580 - g_ps2RecompiledFunctionTable[41313] = ps2___floatdidf_0x128558; // 0x12858c - g_ps2RecompiledFunctionTable[41316] = ps2___floatdidf_0x128558; // 0x128598 - g_ps2RecompiledFunctionTable[41324] = ps2___floatdidf_0x128558; // 0x1285b8 - g_ps2RecompiledFunctionTable[41330] = ps2___floatdidf_0x128558; // 0x1285d0 - g_ps2RecompiledFunctionTable[41333] = ps2___floatdidf_0x128558; // 0x1285dc - g_ps2RecompiledFunctionTable[41338] = ps2___moddi3_0x1285f0; // 0x1285f0 - g_ps2RecompiledFunctionTable[41748] = ps2___muldi3_0x128c58; // 0x128c58 - g_ps2RecompiledFunctionTable[41772] = ps2___udivdi3_0x128cb8; // 0x128cb8 - g_ps2RecompiledFunctionTable[42144] = ps2___umoddi3_0x129288; // 0x129288 - g_ps2RecompiledFunctionTable[42480] = ps2___pack_d_0x1297c8; // 0x1297c8 - g_ps2RecompiledFunctionTable[42556] = ps2___unpack_d_0x1298f8; // 0x1298f8 - g_ps2RecompiledFunctionTable[42596] = _fpadd_parts_0x129998; // 0x129998 - g_ps2RecompiledFunctionTable[42601] = _fpadd_parts_0x129998; // 0x1299ac - g_ps2RecompiledFunctionTable[42606] = _fpadd_parts_0x129998; // 0x1299c0 - g_ps2RecompiledFunctionTable[42652] = _fpadd_parts_0x129998; // 0x129a78 - g_ps2RecompiledFunctionTable[42666] = _fpadd_parts_0x129998; // 0x129ab0 - g_ps2RecompiledFunctionTable[42710] = _fpadd_parts_0x129998; // 0x129b60 - g_ps2RecompiledFunctionTable[42740] = dpadd_0x129bd8; // 0x129bd8 - g_ps2RecompiledFunctionTable[42748] = dpadd_0x129bd8; // 0x129bf8 - g_ps2RecompiledFunctionTable[42752] = dpadd_0x129bd8; // 0x129c08 - g_ps2RecompiledFunctionTable[42756] = dpadd_0x129bd8; // 0x129c18 - g_ps2RecompiledFunctionTable[42758] = dpadd_0x129bd8; // 0x129c20 - g_ps2RecompiledFunctionTable[42762] = dpsub_0x129c30; // 0x129c30 - g_ps2RecompiledFunctionTable[42770] = dpsub_0x129c30; // 0x129c50 - g_ps2RecompiledFunctionTable[42774] = dpsub_0x129c30; // 0x129c60 - g_ps2RecompiledFunctionTable[42781] = dpsub_0x129c30; // 0x129c7c - g_ps2RecompiledFunctionTable[42783] = dpsub_0x129c30; // 0x129c84 - g_ps2RecompiledFunctionTable[42788] = dpmul_0x129c98; // 0x129c98 - g_ps2RecompiledFunctionTable[42803] = dpmul_0x129c98; // 0x129cd4 - g_ps2RecompiledFunctionTable[42807] = dpmul_0x129c98; // 0x129ce4 - g_ps2RecompiledFunctionTable[42858] = dpmul_0x129c98; // 0x129db0 - g_ps2RecompiledFunctionTable[42862] = dpmul_0x129c98; // 0x129dc0 - g_ps2RecompiledFunctionTable[42866] = dpmul_0x129c98; // 0x129dd0 - g_ps2RecompiledFunctionTable[42870] = dpmul_0x129c98; // 0x129de0 - g_ps2RecompiledFunctionTable[42900] = dpmul_0x129c98; // 0x129e58 - g_ps2RecompiledFunctionTable[42922] = dpmul_0x129c98; // 0x129eb0 - g_ps2RecompiledFunctionTable[42947] = dpmul_0x129c98; // 0x129f14 - g_ps2RecompiledFunctionTable[42958] = dpdiv_0x129f40; // 0x129f40 - g_ps2RecompiledFunctionTable[42966] = dpdiv_0x129f40; // 0x129f60 - g_ps2RecompiledFunctionTable[42970] = dpdiv_0x129f40; // 0x129f70 - g_ps2RecompiledFunctionTable[43022] = dpdiv_0x129f40; // 0x12a040 - g_ps2RecompiledFunctionTable[43044] = dpdiv_0x129f40; // 0x12a098 - g_ps2RecompiledFunctionTable[43048] = ps2___fpcmp_parts_d_0x12a0a8; // 0x12a0a8 - g_ps2RecompiledFunctionTable[43066] = ps2___fpcmp_parts_d_0x12a0a8; // 0x12a0f0 - g_ps2RecompiledFunctionTable[43094] = ps2___fpcmp_parts_d_0x12a0a8; // 0x12a160 - g_ps2RecompiledFunctionTable[43105] = ps2___fpcmp_parts_d_0x12a0a8; // 0x12a18c - g_ps2RecompiledFunctionTable[43118] = dpcmp_0x12a1c0; // 0x12a1c0 - g_ps2RecompiledFunctionTable[43126] = dpcmp_0x12a1c0; // 0x12a1e0 - g_ps2RecompiledFunctionTable[43130] = dpcmp_0x12a1c0; // 0x12a1f0 - g_ps2RecompiledFunctionTable[43133] = dpcmp_0x12a1c0; // 0x12a1fc - g_ps2RecompiledFunctionTable[43138] = litodp_0x12a210; // 0x12a210 - g_ps2RecompiledFunctionTable[43170] = litodp_0x12a210; // 0x12a290 - g_ps2RecompiledFunctionTable[43181] = litodp_0x12a210; // 0x12a2bc - g_ps2RecompiledFunctionTable[43184] = dptoli_0x12a2c8; // 0x12a2c8 - g_ps2RecompiledFunctionTable[43190] = dptoli_0x12a2c8; // 0x12a2e0 - g_ps2RecompiledFunctionTable[43196] = dptoli_0x12a2c8; // 0x12a2f8 - g_ps2RecompiledFunctionTable[43222] = dptoul_0x12a360; // 0x12a360 - g_ps2RecompiledFunctionTable[43228] = dptoul_0x12a360; // 0x12a378 - g_ps2RecompiledFunctionTable[43234] = dptoul_0x12a360; // 0x12a390 - g_ps2RecompiledFunctionTable[43262] = ps2___negdf2_0x12a400; // 0x12a400 - g_ps2RecompiledFunctionTable[43268] = ps2___negdf2_0x12a400; // 0x12a418 - g_ps2RecompiledFunctionTable[43273] = ps2___negdf2_0x12a400; // 0x12a42c - g_ps2RecompiledFunctionTable[43276] = ps2___make_dp_0x12a438; // 0x12a438 - g_ps2RecompiledFunctionTable[43284] = ps2___make_dp_0x12a438; // 0x12a458 - g_ps2RecompiledFunctionTable[43288] = dptofp_0x12a468; // 0x12a468 - g_ps2RecompiledFunctionTable[43294] = dptofp_0x12a468; // 0x12a480 - g_ps2RecompiledFunctionTable[43306] = dptofp_0x12a468; // 0x12a4b0 - g_ps2RecompiledFunctionTable[43310] = ps2___pack_f_0x12a4c0; // 0x12a4c0 - g_ps2RecompiledFunctionTable[43378] = ps2___unpack_f_0x12a5d0; // 0x12a5d0 - g_ps2RecompiledFunctionTable[43414] = _fpadd_parts_0x12a660; // 0x12a660 - g_ps2RecompiledFunctionTable[43419] = _fpadd_parts_0x12a660; // 0x12a674 - g_ps2RecompiledFunctionTable[43424] = _fpadd_parts_0x12a660; // 0x12a688 - g_ps2RecompiledFunctionTable[43472] = _fpadd_parts_0x12a660; // 0x12a748 - g_ps2RecompiledFunctionTable[43486] = _fpadd_parts_0x12a660; // 0x12a780 - g_ps2RecompiledFunctionTable[43528] = _fpadd_parts_0x12a660; // 0x12a828 - g_ps2RecompiledFunctionTable[43556] = fpadd_0x12a898; // 0x12a898 - g_ps2RecompiledFunctionTable[43564] = fpadd_0x12a898; // 0x12a8b8 - g_ps2RecompiledFunctionTable[43568] = fpadd_0x12a898; // 0x12a8c8 - g_ps2RecompiledFunctionTable[43572] = fpadd_0x12a898; // 0x12a8d8 - g_ps2RecompiledFunctionTable[43574] = fpadd_0x12a898; // 0x12a8e0 - g_ps2RecompiledFunctionTable[43578] = fpsub_0x12a8f0; // 0x12a8f0 - g_ps2RecompiledFunctionTable[43586] = fpsub_0x12a8f0; // 0x12a910 - g_ps2RecompiledFunctionTable[43590] = fpsub_0x12a8f0; // 0x12a920 - g_ps2RecompiledFunctionTable[43597] = fpsub_0x12a8f0; // 0x12a93c - g_ps2RecompiledFunctionTable[43599] = fpsub_0x12a8f0; // 0x12a944 - g_ps2RecompiledFunctionTable[43604] = fpmul_0x12a958; // 0x12a958 - g_ps2RecompiledFunctionTable[43612] = fpmul_0x12a958; // 0x12a978 - g_ps2RecompiledFunctionTable[43616] = fpmul_0x12a958; // 0x12a988 - g_ps2RecompiledFunctionTable[43682] = fpmul_0x12a958; // 0x12aa90 - g_ps2RecompiledFunctionTable[43700] = fpmul_0x12a958; // 0x12aad8 - g_ps2RecompiledFunctionTable[43725] = fpmul_0x12a958; // 0x12ab3c - g_ps2RecompiledFunctionTable[43730] = fpdiv_0x12ab50; // 0x12ab50 - g_ps2RecompiledFunctionTable[43738] = fpdiv_0x12ab50; // 0x12ab70 - g_ps2RecompiledFunctionTable[43742] = fpdiv_0x12ab50; // 0x12ab80 - g_ps2RecompiledFunctionTable[43792] = fpdiv_0x12ab50; // 0x12ac48 - g_ps2RecompiledFunctionTable[43814] = fpdiv_0x12ab50; // 0x12aca0 - g_ps2RecompiledFunctionTable[43818] = ps2___fpcmp_parts_f_0x12acb0; // 0x12acb0 - g_ps2RecompiledFunctionTable[43836] = ps2___fpcmp_parts_f_0x12acb0; // 0x12acf8 - g_ps2RecompiledFunctionTable[43864] = ps2___fpcmp_parts_f_0x12acb0; // 0x12ad68 - g_ps2RecompiledFunctionTable[43875] = ps2___fpcmp_parts_f_0x12acb0; // 0x12ad94 - g_ps2RecompiledFunctionTable[43888] = fpcmp_0x12adc8; // 0x12adc8 - g_ps2RecompiledFunctionTable[43896] = fpcmp_0x12adc8; // 0x12ade8 - g_ps2RecompiledFunctionTable[43900] = fpcmp_0x12adc8; // 0x12adf8 - g_ps2RecompiledFunctionTable[43903] = fpcmp_0x12adc8; // 0x12ae04 - g_ps2RecompiledFunctionTable[43908] = sitofp_0x12ae18; // 0x12ae18 - g_ps2RecompiledFunctionTable[43940] = sitofp_0x12ae18; // 0x12ae98 - g_ps2RecompiledFunctionTable[43951] = sitofp_0x12ae18; // 0x12aec4 - g_ps2RecompiledFunctionTable[43954] = fptosi_0x12aed0; // 0x12aed0 - g_ps2RecompiledFunctionTable[43960] = fptosi_0x12aed0; // 0x12aee8 - g_ps2RecompiledFunctionTable[43966] = fptosi_0x12aed0; // 0x12af00 - g_ps2RecompiledFunctionTable[43990] = fptoui_0x12af60; // 0x12af60 - g_ps2RecompiledFunctionTable[43996] = fptoui_0x12af60; // 0x12af78 - g_ps2RecompiledFunctionTable[44002] = fptoui_0x12af60; // 0x12af90 - g_ps2RecompiledFunctionTable[44028] = ps2___negsf2_0x12aff8; // 0x12aff8 - g_ps2RecompiledFunctionTable[44034] = ps2___negsf2_0x12aff8; // 0x12b010 - g_ps2RecompiledFunctionTable[44039] = ps2___negsf2_0x12aff8; // 0x12b024 - g_ps2RecompiledFunctionTable[44042] = ps2___make_fp_0x12b030; // 0x12b030 - g_ps2RecompiledFunctionTable[44050] = ps2___make_fp_0x12b030; // 0x12b050 - g_ps2RecompiledFunctionTable[44054] = fptodp_0x12b060; // 0x12b060 - g_ps2RecompiledFunctionTable[44060] = fptodp_0x12b060; // 0x12b078 - g_ps2RecompiledFunctionTable[44067] = fptodp_0x12b060; // 0x12b094 - g_ps2RecompiledFunctionTable[44070] = ps2_main_0x12b0a0; // 0x12b0a0 - g_ps2RecompiledFunctionTable[44074] = ps2_main_0x12b0a0; // 0x12b0b0 - g_ps2RecompiledFunctionTable[44076] = ps2_main_0x12b0a0; // 0x12b0b8 - g_ps2RecompiledFunctionTable[44080] = ps2_main_0x12b0a0; // 0x12b0c8 - g_ps2RecompiledFunctionTable[44084] = ps2_main_0x12b0a0; // 0x12b0d8 - g_ps2RecompiledFunctionTable[44090] = njUserInit_0x12b0f0; // 0x12b0f0 - g_ps2RecompiledFunctionTable[44094] = njUserInit_0x12b0f0; // 0x12b100 - g_ps2RecompiledFunctionTable[44156] = njUserInit_0x12b0f0; // 0x12b1f8 - g_ps2RecompiledFunctionTable[44160] = njUserInit_0x12b0f0; // 0x12b208 - g_ps2RecompiledFunctionTable[44162] = njUserInit_0x12b0f0; // 0x12b210 - g_ps2RecompiledFunctionTable[44168] = njUserInit_0x12b0f0; // 0x12b228 - g_ps2RecompiledFunctionTable[44170] = njUserInit_0x12b0f0; // 0x12b230 - g_ps2RecompiledFunctionTable[44176] = njUserInit_0x12b0f0; // 0x12b248 - g_ps2RecompiledFunctionTable[44182] = njUserInit_0x12b0f0; // 0x12b260 - g_ps2RecompiledFunctionTable[44216] = njUserInit_0x12b0f0; // 0x12b2e8 - g_ps2RecompiledFunctionTable[44222] = njUserInit_0x12b0f0; // 0x12b300 - g_ps2RecompiledFunctionTable[44230] = njUserInit_0x12b0f0; // 0x12b320 - g_ps2RecompiledFunctionTable[44234] = njUserInit_0x12b0f0; // 0x12b330 - g_ps2RecompiledFunctionTable[44239] = njUserInit_0x12b0f0; // 0x12b344 - g_ps2RecompiledFunctionTable[44243] = njUserInit_0x12b0f0; // 0x12b354 - g_ps2RecompiledFunctionTable[44245] = njUserInit_0x12b0f0; // 0x12b35c - g_ps2RecompiledFunctionTable[44247] = njUserInit_0x12b0f0; // 0x12b364 - g_ps2RecompiledFunctionTable[44250] = njUserInit_0x12b0f0; // 0x12b370 - g_ps2RecompiledFunctionTable[44253] = njUserInit_0x12b0f0; // 0x12b37c - g_ps2RecompiledFunctionTable[44256] = njUserInit_0x12b0f0; // 0x12b388 - g_ps2RecompiledFunctionTable[44258] = njUserInit_0x12b0f0; // 0x12b390 - g_ps2RecompiledFunctionTable[44262] = njUserInit_0x12b0f0; // 0x12b3a0 - g_ps2RecompiledFunctionTable[44264] = njUserInit_0x12b0f0; // 0x12b3a8 - g_ps2RecompiledFunctionTable[44266] = njUserInit_0x12b0f0; // 0x12b3b0 - g_ps2RecompiledFunctionTable[44271] = njUserInit_0x12b0f0; // 0x12b3c4 - g_ps2RecompiledFunctionTable[44278] = njUserInit_0x12b0f0; // 0x12b3e0 - g_ps2RecompiledFunctionTable[44282] = njUserInit_0x12b0f0; // 0x12b3f0 - g_ps2RecompiledFunctionTable[44290] = njUserInit_0x12b0f0; // 0x12b410 - g_ps2RecompiledFunctionTable[44292] = njUserInit_0x12b0f0; // 0x12b418 - g_ps2RecompiledFunctionTable[44294] = njUserInit_0x12b0f0; // 0x12b420 - g_ps2RecompiledFunctionTable[44298] = njUserMain_0x12b430; // 0x12b430 - g_ps2RecompiledFunctionTable[44299] = njUserMain_0x12b430; // 0x12b434 - g_ps2RecompiledFunctionTable[44300] = njUserMain_0x12b430; // 0x12b438 - g_ps2RecompiledFunctionTable[44301] = njUserMain_0x12b430; // 0x12b43c - g_ps2RecompiledFunctionTable[44302] = njUserMain_0x12b430; // 0x12b440 - g_ps2RecompiledFunctionTable[44303] = njUserMain_0x12b430; // 0x12b444 - g_ps2RecompiledFunctionTable[44304] = njUserMain_0x12b430; // 0x12b448 - g_ps2RecompiledFunctionTable[44305] = njUserMain_0x12b430; // 0x12b44c - g_ps2RecompiledFunctionTable[44306] = njUserMain_0x12b430; // 0x12b450 - g_ps2RecompiledFunctionTable[44307] = njUserMain_0x12b430; // 0x12b454 - g_ps2RecompiledFunctionTable[44308] = njUserMain_0x12b430; // 0x12b458 - g_ps2RecompiledFunctionTable[44309] = njUserMain_0x12b430; // 0x12b45c - g_ps2RecompiledFunctionTable[44310] = njUserMain_0x12b430; // 0x12b460 - g_ps2RecompiledFunctionTable[44311] = njUserMain_0x12b430; // 0x12b464 - g_ps2RecompiledFunctionTable[44312] = njUserMain_0x12b430; // 0x12b468 - g_ps2RecompiledFunctionTable[44313] = njUserMain_0x12b430; // 0x12b46c - g_ps2RecompiledFunctionTable[44314] = njUserMain_0x12b430; // 0x12b470 - g_ps2RecompiledFunctionTable[44315] = njUserMain_0x12b430; // 0x12b474 - g_ps2RecompiledFunctionTable[44316] = njUserMain_0x12b430; // 0x12b478 - g_ps2RecompiledFunctionTable[44317] = njUserMain_0x12b430; // 0x12b47c - g_ps2RecompiledFunctionTable[44318] = njUserMain_0x12b430; // 0x12b480 - g_ps2RecompiledFunctionTable[44319] = njUserMain_0x12b430; // 0x12b484 - g_ps2RecompiledFunctionTable[44320] = njUserMain_0x12b430; // 0x12b488 - g_ps2RecompiledFunctionTable[44321] = njUserMain_0x12b430; // 0x12b48c - g_ps2RecompiledFunctionTable[44322] = njUserMain_0x12b430; // 0x12b490 - g_ps2RecompiledFunctionTable[44323] = njUserMain_0x12b430; // 0x12b494 - g_ps2RecompiledFunctionTable[44324] = njUserMain_0x12b430; // 0x12b498 - g_ps2RecompiledFunctionTable[44325] = njUserMain_0x12b430; // 0x12b49c - g_ps2RecompiledFunctionTable[44326] = njUserMain_0x12b430; // 0x12b4a0 - g_ps2RecompiledFunctionTable[44327] = njUserMain_0x12b430; // 0x12b4a4 - g_ps2RecompiledFunctionTable[44328] = njUserMain_0x12b430; // 0x12b4a8 - g_ps2RecompiledFunctionTable[44329] = njUserMain_0x12b430; // 0x12b4ac - g_ps2RecompiledFunctionTable[44330] = njUserMain_0x12b430; // 0x12b4b0 - g_ps2RecompiledFunctionTable[44331] = njUserMain_0x12b430; // 0x12b4b4 - g_ps2RecompiledFunctionTable[44332] = njUserMain_0x12b430; // 0x12b4b8 - g_ps2RecompiledFunctionTable[44333] = njUserMain_0x12b430; // 0x12b4bc - g_ps2RecompiledFunctionTable[44334] = njUserMain_0x12b430; // 0x12b4c0 - g_ps2RecompiledFunctionTable[44335] = njUserMain_0x12b430; // 0x12b4c4 - g_ps2RecompiledFunctionTable[44336] = njUserMain_0x12b430; // 0x12b4c8 - g_ps2RecompiledFunctionTable[44337] = njUserMain_0x12b430; // 0x12b4cc - g_ps2RecompiledFunctionTable[44338] = njUserMain_0x12b430; // 0x12b4d0 - g_ps2RecompiledFunctionTable[44339] = njUserMain_0x12b430; // 0x12b4d4 - g_ps2RecompiledFunctionTable[44342] = njUserExit_0x12b4e0; // 0x12b4e0 - g_ps2RecompiledFunctionTable[44346] = njUserExit_0x12b4e0; // 0x12b4f0 - g_ps2RecompiledFunctionTable[44348] = njUserExit_0x12b4e0; // 0x12b4f8 - g_ps2RecompiledFunctionTable[44350] = njUserExit_0x12b4e0; // 0x12b500 - g_ps2RecompiledFunctionTable[44352] = njUserExit_0x12b4e0; // 0x12b508 - g_ps2RecompiledFunctionTable[44354] = njUserExit_0x12b4e0; // 0x12b510 - g_ps2RecompiledFunctionTable[44356] = njUserExit_0x12b4e0; // 0x12b518 - g_ps2RecompiledFunctionTable[44362] = sbInitSystem_0x12b530; // 0x12b530 - g_ps2RecompiledFunctionTable[44372] = sbInitSystem_0x12b530; // 0x12b558 - g_ps2RecompiledFunctionTable[44374] = sbInitSystem_0x12b530; // 0x12b560 - g_ps2RecompiledFunctionTable[44387] = sbInitSystem_0x12b530; // 0x12b594 - g_ps2RecompiledFunctionTable[44389] = sbInitSystem_0x12b530; // 0x12b59c - g_ps2RecompiledFunctionTable[44393] = sbInitSystem_0x12b530; // 0x12b5ac - g_ps2RecompiledFunctionTable[44395] = sbInitSystem_0x12b530; // 0x12b5b4 - g_ps2RecompiledFunctionTable[44401] = sbInitSystem_0x12b530; // 0x12b5cc - g_ps2RecompiledFunctionTable[44403] = sbInitSystem_0x12b530; // 0x12b5d4 - g_ps2RecompiledFunctionTable[44405] = sbInitSystem_0x12b530; // 0x12b5dc - g_ps2RecompiledFunctionTable[44407] = sbInitSystem_0x12b530; // 0x12b5e4 - g_ps2RecompiledFunctionTable[44411] = sbInitSystem_0x12b530; // 0x12b5f4 - g_ps2RecompiledFunctionTable[44413] = sbInitSystem_0x12b530; // 0x12b5fc - g_ps2RecompiledFunctionTable[44422] = sbExitSystem_0x12b620; // 0x12b620 - g_ps2RecompiledFunctionTable[44426] = sbExitSystem_0x12b620; // 0x12b630 - g_ps2RecompiledFunctionTable[44428] = sbExitSystem_0x12b620; // 0x12b638 - g_ps2RecompiledFunctionTable[44430] = sbExitSystem_0x12b620; // 0x12b640 - g_ps2RecompiledFunctionTable[44432] = sbExitSystem_0x12b620; // 0x12b648 - g_ps2RecompiledFunctionTable[44434] = sbExitSystem_0x12b620; // 0x12b650 - g_ps2RecompiledFunctionTable[44436] = sbExitSystem_0x12b620; // 0x12b658 - g_ps2RecompiledFunctionTable[44438] = sbExitSystem_0x12b620; // 0x12b660 - g_ps2RecompiledFunctionTable[44442] = npPlusInit_0x12b670; // 0x12b670 - g_ps2RecompiledFunctionTable[44461] = npPlusInit_0x12b670; // 0x12b6bc - g_ps2RecompiledFunctionTable[44464] = npPlusInit_0x12b670; // 0x12b6c8 - g_ps2RecompiledFunctionTable[44482] = npCollisionCheckCC_0x12b710; // 0x12b710 - g_ps2RecompiledFunctionTable[44542] = npCollisionCheckCC_0x12b710; // 0x12b800 - g_ps2RecompiledFunctionTable[44545] = npCollisionCheckCC_0x12b710; // 0x12b80c - g_ps2RecompiledFunctionTable[44577] = npCollisionCheckCC_0x12b710; // 0x12b88c - g_ps2RecompiledFunctionTable[44600] = npCollisionCheckCC_0x12b710; // 0x12b8e8 - g_ps2RecompiledFunctionTable[44603] = npCollisionCheckCC_0x12b710; // 0x12b8f4 - g_ps2RecompiledFunctionTable[44605] = npCollisionCheckCC_0x12b710; // 0x12b8fc - g_ps2RecompiledFunctionTable[44608] = npCollisionCheckCC_0x12b710; // 0x12b908 - g_ps2RecompiledFunctionTable[44649] = npCollisionCheckCC_0x12b710; // 0x12b9ac - g_ps2RecompiledFunctionTable[44652] = npCollisionCheckCC_0x12b710; // 0x12b9b8 - g_ps2RecompiledFunctionTable[44654] = npCollisionCheckCC_0x12b710; // 0x12b9c0 - g_ps2RecompiledFunctionTable[44657] = npCollisionCheckCC_0x12b710; // 0x12b9cc - g_ps2RecompiledFunctionTable[44683] = npCollisionCheckCC_0x12b710; // 0x12ba34 - g_ps2RecompiledFunctionTable[44697] = npCollisionCheckCC_0x12b710; // 0x12ba6c - g_ps2RecompiledFunctionTable[44713] = npCollisionCheckCC_0x12b710; // 0x12baac - g_ps2RecompiledFunctionTable[44716] = npCollisionCheckCC_0x12b710; // 0x12bab8 - g_ps2RecompiledFunctionTable[44719] = npCollisionCheckCC_0x12b710; // 0x12bac4 - g_ps2RecompiledFunctionTable[44745] = npCollisionCheckCC_0x12b710; // 0x12bb2c - g_ps2RecompiledFunctionTable[44759] = npCollisionCheckCC_0x12b710; // 0x12bb64 - g_ps2RecompiledFunctionTable[44775] = npCollisionCheckCC_0x12b710; // 0x12bba4 - g_ps2RecompiledFunctionTable[44778] = npCollisionCheckCC_0x12b710; // 0x12bbb0 - g_ps2RecompiledFunctionTable[44781] = npCollisionCheckCC_0x12b710; // 0x12bbbc - g_ps2RecompiledFunctionTable[44807] = npCollisionCheckCC_0x12b710; // 0x12bc24 - g_ps2RecompiledFunctionTable[44826] = npCollisionCheckCCEx_0x12bc70; // 0x12bc70 - g_ps2RecompiledFunctionTable[44889] = npCollisionCheckCCEx_0x12bc70; // 0x12bd6c - g_ps2RecompiledFunctionTable[44892] = npCollisionCheckCCEx_0x12bc70; // 0x12bd78 - g_ps2RecompiledFunctionTable[44924] = npCollisionCheckCCEx_0x12bc70; // 0x12bdf8 - g_ps2RecompiledFunctionTable[44948] = npCollisionCheckCCEx_0x12bc70; // 0x12be58 - g_ps2RecompiledFunctionTable[44951] = npCollisionCheckCCEx_0x12bc70; // 0x12be64 - g_ps2RecompiledFunctionTable[44953] = npCollisionCheckCCEx_0x12bc70; // 0x12be6c - g_ps2RecompiledFunctionTable[44956] = npCollisionCheckCCEx_0x12bc70; // 0x12be78 - g_ps2RecompiledFunctionTable[44999] = npCollisionCheckCCEx_0x12bc70; // 0x12bf24 - g_ps2RecompiledFunctionTable[45002] = npCollisionCheckCCEx_0x12bc70; // 0x12bf30 - g_ps2RecompiledFunctionTable[45004] = npCollisionCheckCCEx_0x12bc70; // 0x12bf38 - g_ps2RecompiledFunctionTable[45007] = npCollisionCheckCCEx_0x12bc70; // 0x12bf44 - g_ps2RecompiledFunctionTable[45033] = npCollisionCheckCCEx_0x12bc70; // 0x12bfac - g_ps2RecompiledFunctionTable[45051] = npCollisionCheckCCEx_0x12bc70; // 0x12bff4 - g_ps2RecompiledFunctionTable[45058] = npCollisionCheckCCEx_0x12bc70; // 0x12c010 - g_ps2RecompiledFunctionTable[45095] = npCollisionCheckCCEx_0x12bc70; // 0x12c0a4 - g_ps2RecompiledFunctionTable[45113] = npCollisionCheckCCEx_0x12bc70; // 0x12c0ec - g_ps2RecompiledFunctionTable[45116] = npCollisionCheckCCEx_0x12bc70; // 0x12c0f8 - g_ps2RecompiledFunctionTable[45119] = npCollisionCheckCCEx_0x12bc70; // 0x12c104 - g_ps2RecompiledFunctionTable[45145] = npCollisionCheckCCEx_0x12bc70; // 0x12c16c - g_ps2RecompiledFunctionTable[45163] = npCollisionCheckCCEx_0x12bc70; // 0x12c1b4 - g_ps2RecompiledFunctionTable[45170] = npCollisionCheckCCEx_0x12bc70; // 0x12c1d0 - g_ps2RecompiledFunctionTable[45207] = npCollisionCheckCCEx_0x12bc70; // 0x12c264 - g_ps2RecompiledFunctionTable[45225] = npCollisionCheckCCEx_0x12bc70; // 0x12c2ac - g_ps2RecompiledFunctionTable[45228] = npCollisionCheckCCEx_0x12bc70; // 0x12c2b8 - g_ps2RecompiledFunctionTable[45231] = npCollisionCheckCCEx_0x12bc70; // 0x12c2c4 - g_ps2RecompiledFunctionTable[45257] = npCollisionCheckCCEx_0x12bc70; // 0x12c32c - g_ps2RecompiledFunctionTable[45275] = npCollisionCheckCCEx_0x12bc70; // 0x12c374 - g_ps2RecompiledFunctionTable[45282] = npCollisionCheckCCEx_0x12bc70; // 0x12c390 - g_ps2RecompiledFunctionTable[45326] = npCollisionCheckSC_0x12c440; // 0x12c440 - g_ps2RecompiledFunctionTable[45367] = npCollisionCheckSC_0x12c440; // 0x12c4e4 - g_ps2RecompiledFunctionTable[45371] = npCollisionCheckSC_0x12c440; // 0x12c4f4 - g_ps2RecompiledFunctionTable[45388] = npCollisionCheckSC_0x12c440; // 0x12c538 - g_ps2RecompiledFunctionTable[45391] = npCollisionCheckSC_0x12c440; // 0x12c544 - g_ps2RecompiledFunctionTable[45393] = npCollisionCheckSC_0x12c440; // 0x12c54c - g_ps2RecompiledFunctionTable[45396] = npCollisionCheckSC_0x12c440; // 0x12c558 - g_ps2RecompiledFunctionTable[45435] = npCollisionCheckSC_0x12c440; // 0x12c5f4 - g_ps2RecompiledFunctionTable[45454] = npDistanceP2C_0x12c640; // 0x12c640 - g_ps2RecompiledFunctionTable[45492] = npDistanceP2C_0x12c640; // 0x12c6d8 - g_ps2RecompiledFunctionTable[45494] = npDistanceP2C_0x12c640; // 0x12c6e0 - g_ps2RecompiledFunctionTable[45511] = npDistanceP2C_0x12c640; // 0x12c724 - g_ps2RecompiledFunctionTable[45514] = npDistanceP2C_0x12c640; // 0x12c730 - g_ps2RecompiledFunctionTable[45516] = npDistanceP2C_0x12c640; // 0x12c738 - g_ps2RecompiledFunctionTable[45519] = npDistanceP2C_0x12c640; // 0x12c744 - g_ps2RecompiledFunctionTable[45556] = npDistanceP2C_0x12c640; // 0x12c7d8 - g_ps2RecompiledFunctionTable[45563] = npDistanceP2C_0x12c640; // 0x12c7f4 - g_ps2RecompiledFunctionTable[45602] = npDrawPlane_0x12c890; // 0x12c890 - g_ps2RecompiledFunctionTable[45651] = npDrawPlane_0x12c890; // 0x12c954 - g_ps2RecompiledFunctionTable[45654] = npCalcMorphing_0x12c960; // 0x12c960 - g_ps2RecompiledFunctionTable[45668] = npCalcMorphing_0x12c960; // 0x12c998 - g_ps2RecompiledFunctionTable[45677] = npCalcMorphing_0x12c960; // 0x12c9bc - g_ps2RecompiledFunctionTable[45730] = npCalcMorphing_0x12c960; // 0x12ca90 - g_ps2RecompiledFunctionTable[45738] = npCalcMorphing_0x12c960; // 0x12cab0 - g_ps2RecompiledFunctionTable[45750] = npTransform_0x12cae0; // 0x12cae0 - g_ps2RecompiledFunctionTable[45782] = npTransform_0x12cae0; // 0x12cb60 - g_ps2RecompiledFunctionTable[45842] = npPushMdlstr_0x12cc50; // 0x12cc50 - g_ps2RecompiledFunctionTable[45847] = npPushMdlstr_0x12cc50; // 0x12cc64 - g_ps2RecompiledFunctionTable[45862] = npPopMdlstr_0x12cca0; // 0x12cca0 - g_ps2RecompiledFunctionTable[45867] = npPopMdlstr_0x12cca0; // 0x12ccb4 - g_ps2RecompiledFunctionTable[45882] = npPushMdlstr2_0x12ccf0; // 0x12ccf0 - g_ps2RecompiledFunctionTable[45887] = npPushMdlstr2_0x12ccf0; // 0x12cd04 - g_ps2RecompiledFunctionTable[45914] = npPopMdlstr2_0x12cd70; // 0x12cd70 - g_ps2RecompiledFunctionTable[45919] = npPopMdlstr2_0x12cd70; // 0x12cd84 - g_ps2RecompiledFunctionTable[45946] = npCnkFlatOff_0x12cdf0; // 0x12cdf0 - g_ps2RecompiledFunctionTable[45957] = npCnkFlatOff_0x12cdf0; // 0x12ce1c - g_ps2RecompiledFunctionTable[46007] = npCnkFlatOff_0x12cdf0; // 0x12cee4 - g_ps2RecompiledFunctionTable[46012] = npCnkFlatOff_0x12cdf0; // 0x12cef8 - g_ps2RecompiledFunctionTable[46018] = npClrTranslate_0x12cf10; // 0x12cf10 - g_ps2RecompiledFunctionTable[46023] = npClrTranslate_0x12cf10; // 0x12cf24 - g_ps2RecompiledFunctionTable[46033] = npClrTranslate_0x12cf10; // 0x12cf4c - g_ps2RecompiledFunctionTable[46038] = npSetMemory_0x12cf60; // 0x12cf60 - g_ps2RecompiledFunctionTable[46041] = npSetMemory_0x12cf60; // 0x12cf6c - g_ps2RecompiledFunctionTable[46050] = npSetMemoryL_0x12cf90; // 0x12cf90 - g_ps2RecompiledFunctionTable[46053] = npSetMemoryL_0x12cf90; // 0x12cf9c - g_ps2RecompiledFunctionTable[46062] = npCopyMemory_0x12cfc0; // 0x12cfc0 - g_ps2RecompiledFunctionTable[46065] = npCopyMemory_0x12cfc0; // 0x12cfcc - g_ps2RecompiledFunctionTable[46074] = npGetWHDSizeSub_0x12cff0; // 0x12cff0 - g_ps2RecompiledFunctionTable[46085] = npGetWHDSizeSub_0x12cff0; // 0x12d01c - g_ps2RecompiledFunctionTable[46090] = npGetWHDSizeSub_0x12cff0; // 0x12d030 - g_ps2RecompiledFunctionTable[46095] = npGetWHDSizeSub_0x12cff0; // 0x12d044 - g_ps2RecompiledFunctionTable[46111] = npGetWHDSizeSub_0x12cff0; // 0x12d084 - g_ps2RecompiledFunctionTable[46115] = npGetWHDSizeSub_0x12cff0; // 0x12d094 - g_ps2RecompiledFunctionTable[46117] = npGetWHDSizeSub_0x12cff0; // 0x12d09c - g_ps2RecompiledFunctionTable[46124] = npGetWHDSizeSub_0x12cff0; // 0x12d0b8 - g_ps2RecompiledFunctionTable[46129] = npGetWHDSizeSub_0x12cff0; // 0x12d0cc - g_ps2RecompiledFunctionTable[46136] = npGetWHDSizeSub_0x12cff0; // 0x12d0e8 - g_ps2RecompiledFunctionTable[46141] = npGetWHDSizeSub_0x12cff0; // 0x12d0fc - g_ps2RecompiledFunctionTable[46148] = npGetWHDSizeSub_0x12cff0; // 0x12d118 - g_ps2RecompiledFunctionTable[46160] = npGetWHDSizeSub_0x12cff0; // 0x12d148 - g_ps2RecompiledFunctionTable[46164] = npGetWHDSizeSub_0x12cff0; // 0x12d158 - g_ps2RecompiledFunctionTable[46166] = npGetWHDSizeSub_0x12cff0; // 0x12d160 - g_ps2RecompiledFunctionTable[46173] = npGetWHDSizeSub_0x12cff0; // 0x12d17c - g_ps2RecompiledFunctionTable[46177] = npGetWHDSizeSub_0x12cff0; // 0x12d18c - g_ps2RecompiledFunctionTable[46184] = npGetWHDSizeSub_0x12cff0; // 0x12d1a8 - g_ps2RecompiledFunctionTable[46189] = npGetWHDSizeSub_0x12cff0; // 0x12d1bc - g_ps2RecompiledFunctionTable[46196] = npGetWHDSizeSub_0x12cff0; // 0x12d1d8 - g_ps2RecompiledFunctionTable[46207] = npGetWHDSizeSub_0x12cff0; // 0x12d204 - g_ps2RecompiledFunctionTable[46210] = npGetWHDSizeSub_0x12cff0; // 0x12d210 - g_ps2RecompiledFunctionTable[46215] = npGetWHDSizeSub_0x12cff0; // 0x12d224 - g_ps2RecompiledFunctionTable[46226] = npGetWHDSize_0x12d250; // 0x12d250 - g_ps2RecompiledFunctionTable[46237] = npGetWHDSize_0x12d250; // 0x12d27c - g_ps2RecompiledFunctionTable[46240] = npGetWHDSize_0x12d250; // 0x12d288 - g_ps2RecompiledFunctionTable[46246] = npSkinConvPreparation_0x12d2a0; // 0x12d2a0 - g_ps2RecompiledFunctionTable[46261] = npSkinConvPreparation_0x12d2a0; // 0x12d2dc - g_ps2RecompiledFunctionTable[46317] = npSkinConvPreparation_0x12d2a0; // 0x12d3bc - g_ps2RecompiledFunctionTable[46330] = npSkinConvPreparation_0x12d2a0; // 0x12d3f0 - g_ps2RecompiledFunctionTable[46335] = npSkinConvPreparation_0x12d2a0; // 0x12d404 - g_ps2RecompiledFunctionTable[46338] = npSkinConvPreparation_0x12d2a0; // 0x12d410 - g_ps2RecompiledFunctionTable[46343] = npSkinConvPreparation_0x12d2a0; // 0x12d424 - g_ps2RecompiledFunctionTable[46350] = npSkinConvSub_0x12d440; // 0x12d440 - g_ps2RecompiledFunctionTable[46411] = npSkinConvSub_0x12d440; // 0x12d534 - g_ps2RecompiledFunctionTable[46420] = npSkinConvSub_0x12d440; // 0x12d558 - g_ps2RecompiledFunctionTable[46441] = npSkinConvSub_0x12d440; // 0x12d5ac - g_ps2RecompiledFunctionTable[46478] = npSkinConvMain_0x12d640; // 0x12d640 - g_ps2RecompiledFunctionTable[46484] = npSkinConvMain_0x12d640; // 0x12d658 - g_ps2RecompiledFunctionTable[46491] = npSkinConvMain_0x12d640; // 0x12d674 - g_ps2RecompiledFunctionTable[46501] = npSkinConvMain_0x12d640; // 0x12d69c - g_ps2RecompiledFunctionTable[46504] = npSkinConvMain_0x12d640; // 0x12d6a8 - g_ps2RecompiledFunctionTable[46509] = npSkinConvMain_0x12d640; // 0x12d6bc - g_ps2RecompiledFunctionTable[46514] = npSkinConvert_0x12d6d0; // 0x12d6d0 - g_ps2RecompiledFunctionTable[46524] = npSkinConvert_0x12d6d0; // 0x12d6f8 - g_ps2RecompiledFunctionTable[46526] = npSkinConvert_0x12d6d0; // 0x12d700 - g_ps2RecompiledFunctionTable[46532] = npSkinConvert_0x12d6d0; // 0x12d718 - g_ps2RecompiledFunctionTable[46534] = npSkinConvert_0x12d6d0; // 0x12d720 - g_ps2RecompiledFunctionTable[46542] = npRetSkinConvMain_0x12d740; // 0x12d740 - g_ps2RecompiledFunctionTable[46556] = npRetSkinConvMain_0x12d740; // 0x12d778 - g_ps2RecompiledFunctionTable[46607] = npRetSkinConvMain_0x12d740; // 0x12d844 - g_ps2RecompiledFunctionTable[46616] = npRetSkinConvMain_0x12d740; // 0x12d868 - g_ps2RecompiledFunctionTable[46637] = npRetSkinConvMain_0x12d740; // 0x12d8bc - g_ps2RecompiledFunctionTable[46676] = npRetSkinConvMain_0x12d740; // 0x12d958 - g_ps2RecompiledFunctionTable[46679] = npRetSkinConvMain_0x12d740; // 0x12d964 - g_ps2RecompiledFunctionTable[46684] = npRetSkinConvMain_0x12d740; // 0x12d978 - g_ps2RecompiledFunctionTable[46694] = npRetSkinConvert_0x12d9a0; // 0x12d9a0 - g_ps2RecompiledFunctionTable[46704] = npRetSkinConvert_0x12d9a0; // 0x12d9c8 - g_ps2RecompiledFunctionTable[46706] = npRetSkinConvert_0x12d9a0; // 0x12d9d0 - g_ps2RecompiledFunctionTable[46712] = npRetSkinConvert_0x12d9a0; // 0x12d9e8 - g_ps2RecompiledFunctionTable[46714] = npRetSkinConvert_0x12d9a0; // 0x12d9f0 - g_ps2RecompiledFunctionTable[46722] = npGetMatColor_0x12da10; // 0x12da10 - g_ps2RecompiledFunctionTable[46725] = npGetMatColor_0x12da10; // 0x12da1c - g_ps2RecompiledFunctionTable[46746] = npSetAllMatColor_0x12da70; // 0x12da70 - g_ps2RecompiledFunctionTable[46770] = npSetAllMatColor_0x12da70; // 0x12dad0 - g_ps2RecompiledFunctionTable[46780] = npSetAllMatColor_0x12da70; // 0x12daf8 - g_ps2RecompiledFunctionTable[46866] = npChangeMatAlphaColor_0x12dc50; // 0x12dc50 - g_ps2RecompiledFunctionTable[46869] = npChangeMatAlphaColor_0x12dc50; // 0x12dc5c - g_ps2RecompiledFunctionTable[46886] = npSetAllMatAlphaColor_0x12dca0; // 0x12dca0 - g_ps2RecompiledFunctionTable[46895] = npSetAllMatAlphaColor_0x12dca0; // 0x12dcc4 - g_ps2RecompiledFunctionTable[46904] = npSetAllMatAlphaColor_0x12dca0; // 0x12dce8 - g_ps2RecompiledFunctionTable[46966] = npSetOffsetUV_0x12dde0; // 0x12dde0 - g_ps2RecompiledFunctionTable[46977] = npSetOffsetUV_0x12dde0; // 0x12de0c - g_ps2RecompiledFunctionTable[46978] = npSetOffsetUV_0x12dde0; // 0x12de10 - g_ps2RecompiledFunctionTable[47000] = npSetOffsetUV_0x12dde0; // 0x12de68 - g_ps2RecompiledFunctionTable[47004] = npSetOffsetUV_0x12dde0; // 0x12de78 - g_ps2RecompiledFunctionTable[47058] = npSetOffsetUV2_0x12df50; // 0x12df50 - g_ps2RecompiledFunctionTable[47062] = npSetOffsetUV2_0x12df50; // 0x12df60 - g_ps2RecompiledFunctionTable[47080] = npSetOffsetUV2_0x12df50; // 0x12dfa8 - g_ps2RecompiledFunctionTable[47084] = npSetOffsetUV2_0x12df50; // 0x12dfb8 - g_ps2RecompiledFunctionTable[47110] = npCopyVlist_0x12e020; // 0x12e020 - g_ps2RecompiledFunctionTable[47125] = npCopyVlist_0x12e020; // 0x12e05c - g_ps2RecompiledFunctionTable[47132] = npCopyVlist_0x12e020; // 0x12e078 - g_ps2RecompiledFunctionTable[47138] = npCutSkin_0x12e090; // 0x12e090 - g_ps2RecompiledFunctionTable[47142] = npInitCalcSkin_0x12e0a0; // 0x12e0a0 - g_ps2RecompiledFunctionTable[47162] = npInitCalcSkin_0x12e0a0; // 0x12e0f0 - g_ps2RecompiledFunctionTable[47168] = npInitCalcSkin_0x12e0a0; // 0x12e108 - g_ps2RecompiledFunctionTable[47258] = npInitCalcSkin_0x12e0a0; // 0x12e270 - g_ps2RecompiledFunctionTable[47274] = npCalcSkin_0x12e2b0; // 0x12e2b0 - g_ps2RecompiledFunctionTable[47285] = npCalcSkin_0x12e2b0; // 0x12e2dc - g_ps2RecompiledFunctionTable[47289] = npCalcSkin_0x12e2b0; // 0x12e2ec - g_ps2RecompiledFunctionTable[47295] = npCalcSkin_0x12e2b0; // 0x12e304 - g_ps2RecompiledFunctionTable[47346] = npCalcSkin_0x12e2b0; // 0x12e3d0 - g_ps2RecompiledFunctionTable[47479] = npCalcSkin_0x12e2b0; // 0x12e5e4 - g_ps2RecompiledFunctionTable[47486] = npInitCalcSkinFM_0x12e600; // 0x12e600 - g_ps2RecompiledFunctionTable[47506] = npInitCalcSkinFM_0x12e600; // 0x12e650 - g_ps2RecompiledFunctionTable[47513] = npInitCalcSkinFM_0x12e600; // 0x12e66c - g_ps2RecompiledFunctionTable[47608] = npInitCalcSkinFM_0x12e600; // 0x12e7e8 - g_ps2RecompiledFunctionTable[47626] = npCalcSkinFM_0x12e830; // 0x12e830 - g_ps2RecompiledFunctionTable[47637] = npCalcSkinFM_0x12e830; // 0x12e85c - g_ps2RecompiledFunctionTable[47641] = npCalcSkinFM_0x12e830; // 0x12e86c - g_ps2RecompiledFunctionTable[47648] = npCalcSkinFM_0x12e830; // 0x12e888 - g_ps2RecompiledFunctionTable[47705] = npCalcSkinFM_0x12e830; // 0x12e96c - g_ps2RecompiledFunctionTable[47843] = npCalcSkinFM_0x12e830; // 0x12eb94 - g_ps2RecompiledFunctionTable[47850] = bhPutModel_0x12ebb0; // 0x12ebb0 - g_ps2RecompiledFunctionTable[47851] = bhPutModel_0x12ebb0; // 0x12ebb4 - g_ps2RecompiledFunctionTable[47852] = bhPutModel_0x12ebb0; // 0x12ebb8 - g_ps2RecompiledFunctionTable[47853] = bhPutModel_0x12ebb0; // 0x12ebbc - g_ps2RecompiledFunctionTable[47854] = bhPutModel_0x12ebb0; // 0x12ebc0 - g_ps2RecompiledFunctionTable[47855] = bhPutModel_0x12ebb0; // 0x12ebc4 - g_ps2RecompiledFunctionTable[47856] = bhPutModel_0x12ebb0; // 0x12ebc8 - g_ps2RecompiledFunctionTable[47857] = bhPutModel_0x12ebb0; // 0x12ebcc - g_ps2RecompiledFunctionTable[47858] = bhPutModel_0x12ebb0; // 0x12ebd0 - g_ps2RecompiledFunctionTable[47859] = bhPutModel_0x12ebb0; // 0x12ebd4 - g_ps2RecompiledFunctionTable[47860] = bhPutModel_0x12ebb0; // 0x12ebd8 - g_ps2RecompiledFunctionTable[47861] = bhPutModel_0x12ebb0; // 0x12ebdc - g_ps2RecompiledFunctionTable[47862] = bhPutModel_0x12ebb0; // 0x12ebe0 - g_ps2RecompiledFunctionTable[47863] = bhPutModel_0x12ebb0; // 0x12ebe4 - g_ps2RecompiledFunctionTable[47864] = bhPutModel_0x12ebb0; // 0x12ebe8 - g_ps2RecompiledFunctionTable[47865] = bhPutModel_0x12ebb0; // 0x12ebec - g_ps2RecompiledFunctionTable[47866] = bhPutModel_0x12ebb0; // 0x12ebf0 - g_ps2RecompiledFunctionTable[47867] = bhPutModel_0x12ebb0; // 0x12ebf4 - g_ps2RecompiledFunctionTable[47868] = bhPutModel_0x12ebb0; // 0x12ebf8 - g_ps2RecompiledFunctionTable[47869] = bhPutModel_0x12ebb0; // 0x12ebfc - g_ps2RecompiledFunctionTable[47870] = bhPutModel_0x12ebb0; // 0x12ec00 - g_ps2RecompiledFunctionTable[47871] = bhPutModel_0x12ebb0; // 0x12ec04 - g_ps2RecompiledFunctionTable[47872] = bhPutModel_0x12ebb0; // 0x12ec08 - g_ps2RecompiledFunctionTable[47873] = bhPutModel_0x12ebb0; // 0x12ec0c - g_ps2RecompiledFunctionTable[47874] = bhPutModel_0x12ebb0; // 0x12ec10 - g_ps2RecompiledFunctionTable[47875] = bhPutModel_0x12ebb0; // 0x12ec14 - g_ps2RecompiledFunctionTable[47876] = bhPutModel_0x12ebb0; // 0x12ec18 - g_ps2RecompiledFunctionTable[47877] = bhPutModel_0x12ebb0; // 0x12ec1c - g_ps2RecompiledFunctionTable[47878] = bhPutModel_0x12ebb0; // 0x12ec20 - g_ps2RecompiledFunctionTable[47879] = bhPutModel_0x12ebb0; // 0x12ec24 - g_ps2RecompiledFunctionTable[47880] = bhPutModel_0x12ebb0; // 0x12ec28 - g_ps2RecompiledFunctionTable[47881] = bhPutModel_0x12ebb0; // 0x12ec2c - g_ps2RecompiledFunctionTable[47882] = bhPutModel_0x12ebb0; // 0x12ec30 - g_ps2RecompiledFunctionTable[47883] = bhPutModel_0x12ebb0; // 0x12ec34 - g_ps2RecompiledFunctionTable[47884] = bhPutModel_0x12ebb0; // 0x12ec38 - g_ps2RecompiledFunctionTable[47885] = bhPutModel_0x12ebb0; // 0x12ec3c - g_ps2RecompiledFunctionTable[47886] = bhPutModel_0x12ebb0; // 0x12ec40 - g_ps2RecompiledFunctionTable[47887] = bhPutModel_0x12ebb0; // 0x12ec44 - g_ps2RecompiledFunctionTable[47888] = bhPutModel_0x12ebb0; // 0x12ec48 - g_ps2RecompiledFunctionTable[47889] = bhPutModel_0x12ebb0; // 0x12ec4c - g_ps2RecompiledFunctionTable[47890] = bhPutModel_0x12ebb0; // 0x12ec50 - g_ps2RecompiledFunctionTable[47891] = bhPutModel_0x12ebb0; // 0x12ec54 - g_ps2RecompiledFunctionTable[47892] = bhPutModel_0x12ebb0; // 0x12ec58 - g_ps2RecompiledFunctionTable[47893] = bhPutModel_0x12ebb0; // 0x12ec5c - g_ps2RecompiledFunctionTable[47894] = bhPutModel_0x12ebb0; // 0x12ec60 - g_ps2RecompiledFunctionTable[47895] = bhPutModel_0x12ebb0; // 0x12ec64 - g_ps2RecompiledFunctionTable[47896] = bhPutModel_0x12ebb0; // 0x12ec68 - g_ps2RecompiledFunctionTable[47897] = bhPutModel_0x12ebb0; // 0x12ec6c - g_ps2RecompiledFunctionTable[47898] = bhPutModel_0x12ebb0; // 0x12ec70 - g_ps2RecompiledFunctionTable[47899] = bhPutModel_0x12ebb0; // 0x12ec74 - g_ps2RecompiledFunctionTable[47900] = bhPutModel_0x12ebb0; // 0x12ec78 - g_ps2RecompiledFunctionTable[47901] = bhPutModel_0x12ebb0; // 0x12ec7c - g_ps2RecompiledFunctionTable[47902] = bhPutModel_0x12ebb0; // 0x12ec80 - g_ps2RecompiledFunctionTable[47903] = bhPutModel_0x12ebb0; // 0x12ec84 - g_ps2RecompiledFunctionTable[47904] = bhPutModel_0x12ebb0; // 0x12ec88 - g_ps2RecompiledFunctionTable[47905] = bhPutModel_0x12ebb0; // 0x12ec8c - g_ps2RecompiledFunctionTable[47906] = bhPutModel_0x12ebb0; // 0x12ec90 - g_ps2RecompiledFunctionTable[47907] = bhPutModel_0x12ebb0; // 0x12ec94 - g_ps2RecompiledFunctionTable[47908] = bhPutModel_0x12ebb0; // 0x12ec98 - g_ps2RecompiledFunctionTable[47909] = bhPutModel_0x12ebb0; // 0x12ec9c - g_ps2RecompiledFunctionTable[47910] = bhPutModel_0x12ebb0; // 0x12eca0 - g_ps2RecompiledFunctionTable[47911] = bhPutModel_0x12ebb0; // 0x12eca4 - g_ps2RecompiledFunctionTable[47912] = bhPutModel_0x12ebb0; // 0x12eca8 - g_ps2RecompiledFunctionTable[47913] = bhPutModel_0x12ebb0; // 0x12ecac - g_ps2RecompiledFunctionTable[47914] = bhPutModel_0x12ebb0; // 0x12ecb0 - g_ps2RecompiledFunctionTable[47915] = bhPutModel_0x12ebb0; // 0x12ecb4 - g_ps2RecompiledFunctionTable[47916] = bhPutModel_0x12ebb0; // 0x12ecb8 - g_ps2RecompiledFunctionTable[47917] = bhPutModel_0x12ebb0; // 0x12ecbc - g_ps2RecompiledFunctionTable[47918] = bhPutModel_0x12ebb0; // 0x12ecc0 - g_ps2RecompiledFunctionTable[47919] = bhPutModel_0x12ebb0; // 0x12ecc4 - g_ps2RecompiledFunctionTable[47920] = bhPutModel_0x12ebb0; // 0x12ecc8 - g_ps2RecompiledFunctionTable[47921] = bhPutModel_0x12ebb0; // 0x12eccc - g_ps2RecompiledFunctionTable[47922] = bhPutModel_0x12ebb0; // 0x12ecd0 - g_ps2RecompiledFunctionTable[47923] = bhPutModel_0x12ebb0; // 0x12ecd4 - g_ps2RecompiledFunctionTable[47924] = bhPutModel_0x12ebb0; // 0x12ecd8 - g_ps2RecompiledFunctionTable[47925] = bhPutModel_0x12ebb0; // 0x12ecdc - g_ps2RecompiledFunctionTable[47926] = bhPutModel_0x12ebb0; // 0x12ece0 - g_ps2RecompiledFunctionTable[47927] = bhPutModel_0x12ebb0; // 0x12ece4 - g_ps2RecompiledFunctionTable[47928] = bhPutModel_0x12ebb0; // 0x12ece8 - g_ps2RecompiledFunctionTable[47929] = bhPutModel_0x12ebb0; // 0x12ecec - g_ps2RecompiledFunctionTable[47930] = bhPutModel_0x12ebb0; // 0x12ecf0 - g_ps2RecompiledFunctionTable[47931] = bhPutModel_0x12ebb0; // 0x12ecf4 - g_ps2RecompiledFunctionTable[47932] = bhPutModel_0x12ebb0; // 0x12ecf8 - g_ps2RecompiledFunctionTable[47933] = bhPutModel_0x12ebb0; // 0x12ecfc - g_ps2RecompiledFunctionTable[47934] = bhPutModel_0x12ebb0; // 0x12ed00 - g_ps2RecompiledFunctionTable[47935] = bhPutModel_0x12ebb0; // 0x12ed04 - g_ps2RecompiledFunctionTable[47936] = bhPutModel_0x12ebb0; // 0x12ed08 - g_ps2RecompiledFunctionTable[47937] = bhPutModel_0x12ebb0; // 0x12ed0c - g_ps2RecompiledFunctionTable[47938] = bhPutModel_0x12ebb0; // 0x12ed10 - g_ps2RecompiledFunctionTable[47939] = bhPutModel_0x12ebb0; // 0x12ed14 - g_ps2RecompiledFunctionTable[47940] = bhPutModel_0x12ebb0; // 0x12ed18 - g_ps2RecompiledFunctionTable[47941] = bhPutModel_0x12ebb0; // 0x12ed1c - g_ps2RecompiledFunctionTable[47942] = bhPutModel_0x12ebb0; // 0x12ed20 - g_ps2RecompiledFunctionTable[47943] = bhPutModel_0x12ebb0; // 0x12ed24 - g_ps2RecompiledFunctionTable[47944] = bhPutModel_0x12ebb0; // 0x12ed28 - g_ps2RecompiledFunctionTable[47945] = bhPutModel_0x12ebb0; // 0x12ed2c - g_ps2RecompiledFunctionTable[47946] = bhPutModel_0x12ebb0; // 0x12ed30 - g_ps2RecompiledFunctionTable[47947] = bhPutModel_0x12ebb0; // 0x12ed34 - g_ps2RecompiledFunctionTable[47948] = bhPutModel_0x12ebb0; // 0x12ed38 - g_ps2RecompiledFunctionTable[47949] = bhPutModel_0x12ebb0; // 0x12ed3c - g_ps2RecompiledFunctionTable[47950] = bhPutModel_0x12ebb0; // 0x12ed40 - g_ps2RecompiledFunctionTable[47951] = bhPutModel_0x12ebb0; // 0x12ed44 - g_ps2RecompiledFunctionTable[47952] = bhPutModel_0x12ebb0; // 0x12ed48 - g_ps2RecompiledFunctionTable[47953] = bhPutModel_0x12ebb0; // 0x12ed4c - g_ps2RecompiledFunctionTable[47954] = bhPutModel_0x12ebb0; // 0x12ed50 - g_ps2RecompiledFunctionTable[47955] = bhPutModel_0x12ebb0; // 0x12ed54 - g_ps2RecompiledFunctionTable[47956] = bhPutModel_0x12ebb0; // 0x12ed58 - g_ps2RecompiledFunctionTable[47957] = bhPutModel_0x12ebb0; // 0x12ed5c - g_ps2RecompiledFunctionTable[47958] = bhPutModel_0x12ebb0; // 0x12ed60 - g_ps2RecompiledFunctionTable[47959] = bhPutModel_0x12ebb0; // 0x12ed64 - g_ps2RecompiledFunctionTable[47960] = bhPutModel_0x12ebb0; // 0x12ed68 - g_ps2RecompiledFunctionTable[47961] = bhPutModel_0x12ebb0; // 0x12ed6c - g_ps2RecompiledFunctionTable[47962] = bhPutModel_0x12ebb0; // 0x12ed70 - g_ps2RecompiledFunctionTable[47963] = bhPutModel_0x12ebb0; // 0x12ed74 - g_ps2RecompiledFunctionTable[47964] = bhPutModel_0x12ebb0; // 0x12ed78 - g_ps2RecompiledFunctionTable[47965] = bhPutModel_0x12ebb0; // 0x12ed7c - g_ps2RecompiledFunctionTable[47966] = bhPutModel_0x12ebb0; // 0x12ed80 - g_ps2RecompiledFunctionTable[47967] = bhPutModel_0x12ebb0; // 0x12ed84 - g_ps2RecompiledFunctionTable[47968] = bhPutModel_0x12ebb0; // 0x12ed88 - g_ps2RecompiledFunctionTable[47969] = bhPutModel_0x12ebb0; // 0x12ed8c - g_ps2RecompiledFunctionTable[47970] = bhPutModel_0x12ebb0; // 0x12ed90 - g_ps2RecompiledFunctionTable[47971] = bhPutModel_0x12ebb0; // 0x12ed94 - g_ps2RecompiledFunctionTable[47972] = bhPutModel_0x12ebb0; // 0x12ed98 - g_ps2RecompiledFunctionTable[47973] = bhPutModel_0x12ebb0; // 0x12ed9c - g_ps2RecompiledFunctionTable[47974] = bhPutModel_0x12ebb0; // 0x12eda0 - g_ps2RecompiledFunctionTable[47975] = bhPutModel_0x12ebb0; // 0x12eda4 - g_ps2RecompiledFunctionTable[47976] = bhPutModel_0x12ebb0; // 0x12eda8 - g_ps2RecompiledFunctionTable[47977] = bhPutModel_0x12ebb0; // 0x12edac - g_ps2RecompiledFunctionTable[47978] = bhPutModel_0x12ebb0; // 0x12edb0 - g_ps2RecompiledFunctionTable[47979] = bhPutModel_0x12ebb0; // 0x12edb4 - g_ps2RecompiledFunctionTable[47980] = bhPutModel_0x12ebb0; // 0x12edb8 - g_ps2RecompiledFunctionTable[47981] = bhPutModel_0x12ebb0; // 0x12edbc - g_ps2RecompiledFunctionTable[47982] = bhPutModel_0x12ebb0; // 0x12edc0 - g_ps2RecompiledFunctionTable[47983] = bhPutModel_0x12ebb0; // 0x12edc4 - g_ps2RecompiledFunctionTable[47984] = bhPutModel_0x12ebb0; // 0x12edc8 - g_ps2RecompiledFunctionTable[47985] = bhPutModel_0x12ebb0; // 0x12edcc - g_ps2RecompiledFunctionTable[47986] = bhPutModel_0x12ebb0; // 0x12edd0 - g_ps2RecompiledFunctionTable[47987] = bhPutModel_0x12ebb0; // 0x12edd4 - g_ps2RecompiledFunctionTable[47988] = bhPutModel_0x12ebb0; // 0x12edd8 - g_ps2RecompiledFunctionTable[47989] = bhPutModel_0x12ebb0; // 0x12eddc - g_ps2RecompiledFunctionTable[47990] = bhPutModel_0x12ebb0; // 0x12ede0 - g_ps2RecompiledFunctionTable[47991] = bhPutModel_0x12ebb0; // 0x12ede4 - g_ps2RecompiledFunctionTable[47992] = bhPutModel_0x12ebb0; // 0x12ede8 - g_ps2RecompiledFunctionTable[47993] = bhPutModel_0x12ebb0; // 0x12edec - g_ps2RecompiledFunctionTable[47994] = bhPutModel_0x12ebb0; // 0x12edf0 - g_ps2RecompiledFunctionTable[47995] = bhPutModel_0x12ebb0; // 0x12edf4 - g_ps2RecompiledFunctionTable[47996] = bhPutModel_0x12ebb0; // 0x12edf8 - g_ps2RecompiledFunctionTable[47997] = bhPutModel_0x12ebb0; // 0x12edfc - g_ps2RecompiledFunctionTable[47998] = bhPutModel_0x12ebb0; // 0x12ee00 - g_ps2RecompiledFunctionTable[47999] = bhPutModel_0x12ebb0; // 0x12ee04 - g_ps2RecompiledFunctionTable[48000] = bhPutModel_0x12ebb0; // 0x12ee08 - g_ps2RecompiledFunctionTable[48001] = bhPutModel_0x12ebb0; // 0x12ee0c - g_ps2RecompiledFunctionTable[48002] = bhPutModel_0x12ebb0; // 0x12ee10 - g_ps2RecompiledFunctionTable[48003] = bhPutModel_0x12ebb0; // 0x12ee14 - g_ps2RecompiledFunctionTable[48004] = bhPutModel_0x12ebb0; // 0x12ee18 - g_ps2RecompiledFunctionTable[48005] = bhPutModel_0x12ebb0; // 0x12ee1c - g_ps2RecompiledFunctionTable[48006] = bhPutModel_0x12ebb0; // 0x12ee20 - g_ps2RecompiledFunctionTable[48007] = bhPutModel_0x12ebb0; // 0x12ee24 - g_ps2RecompiledFunctionTable[48008] = bhPutModel_0x12ebb0; // 0x12ee28 - g_ps2RecompiledFunctionTable[48009] = bhPutModel_0x12ebb0; // 0x12ee2c - g_ps2RecompiledFunctionTable[48010] = bhPutModel_0x12ebb0; // 0x12ee30 - g_ps2RecompiledFunctionTable[48011] = bhPutModel_0x12ebb0; // 0x12ee34 - g_ps2RecompiledFunctionTable[48012] = bhPutModel_0x12ebb0; // 0x12ee38 - g_ps2RecompiledFunctionTable[48013] = bhPutModel_0x12ebb0; // 0x12ee3c - g_ps2RecompiledFunctionTable[48014] = bhPutModel_0x12ebb0; // 0x12ee40 - g_ps2RecompiledFunctionTable[48015] = bhPutModel_0x12ebb0; // 0x12ee44 - g_ps2RecompiledFunctionTable[48016] = bhPutModel_0x12ebb0; // 0x12ee48 - g_ps2RecompiledFunctionTable[48017] = bhPutModel_0x12ebb0; // 0x12ee4c - g_ps2RecompiledFunctionTable[48018] = bhPutModel_0x12ebb0; // 0x12ee50 - g_ps2RecompiledFunctionTable[48019] = bhPutModel_0x12ebb0; // 0x12ee54 - g_ps2RecompiledFunctionTable[48020] = bhPutModel_0x12ebb0; // 0x12ee58 - g_ps2RecompiledFunctionTable[48021] = bhPutModel_0x12ebb0; // 0x12ee5c - g_ps2RecompiledFunctionTable[48022] = bhPutModel_0x12ebb0; // 0x12ee60 - g_ps2RecompiledFunctionTable[48023] = bhPutModel_0x12ebb0; // 0x12ee64 - g_ps2RecompiledFunctionTable[48024] = bhPutModel_0x12ebb0; // 0x12ee68 - g_ps2RecompiledFunctionTable[48025] = bhPutModel_0x12ebb0; // 0x12ee6c - g_ps2RecompiledFunctionTable[48026] = bhPutModel_0x12ebb0; // 0x12ee70 - g_ps2RecompiledFunctionTable[48027] = bhPutModel_0x12ebb0; // 0x12ee74 - g_ps2RecompiledFunctionTable[48028] = bhPutModel_0x12ebb0; // 0x12ee78 - g_ps2RecompiledFunctionTable[48029] = bhPutModel_0x12ebb0; // 0x12ee7c - g_ps2RecompiledFunctionTable[48030] = bhPutModel_0x12ebb0; // 0x12ee80 - g_ps2RecompiledFunctionTable[48031] = bhPutModel_0x12ebb0; // 0x12ee84 - g_ps2RecompiledFunctionTable[48032] = bhPutModel_0x12ebb0; // 0x12ee88 - g_ps2RecompiledFunctionTable[48033] = bhPutModel_0x12ebb0; // 0x12ee8c - g_ps2RecompiledFunctionTable[48034] = bhPutModel_0x12ebb0; // 0x12ee90 - g_ps2RecompiledFunctionTable[48035] = bhPutModel_0x12ebb0; // 0x12ee94 - g_ps2RecompiledFunctionTable[48036] = bhPutModel_0x12ebb0; // 0x12ee98 - g_ps2RecompiledFunctionTable[48037] = bhPutModel_0x12ebb0; // 0x12ee9c - g_ps2RecompiledFunctionTable[48038] = bhPutModel_0x12ebb0; // 0x12eea0 - g_ps2RecompiledFunctionTable[48039] = bhPutModel_0x12ebb0; // 0x12eea4 - g_ps2RecompiledFunctionTable[48040] = bhPutModel_0x12ebb0; // 0x12eea8 - g_ps2RecompiledFunctionTable[48041] = bhPutModel_0x12ebb0; // 0x12eeac - g_ps2RecompiledFunctionTable[48042] = bhPutModel_0x12ebb0; // 0x12eeb0 - g_ps2RecompiledFunctionTable[48043] = bhPutModel_0x12ebb0; // 0x12eeb4 - g_ps2RecompiledFunctionTable[48044] = bhPutModel_0x12ebb0; // 0x12eeb8 - g_ps2RecompiledFunctionTable[48045] = bhPutModel_0x12ebb0; // 0x12eebc - g_ps2RecompiledFunctionTable[48046] = bhPutModel_0x12ebb0; // 0x12eec0 - g_ps2RecompiledFunctionTable[48047] = bhPutModel_0x12ebb0; // 0x12eec4 - g_ps2RecompiledFunctionTable[48048] = bhPutModel_0x12ebb0; // 0x12eec8 - g_ps2RecompiledFunctionTable[48049] = bhPutModel_0x12ebb0; // 0x12eecc - g_ps2RecompiledFunctionTable[48050] = bhPutModel_0x12ebb0; // 0x12eed0 - g_ps2RecompiledFunctionTable[48051] = bhPutModel_0x12ebb0; // 0x12eed4 - g_ps2RecompiledFunctionTable[48052] = bhPutModel_0x12ebb0; // 0x12eed8 - g_ps2RecompiledFunctionTable[48053] = bhPutModel_0x12ebb0; // 0x12eedc - g_ps2RecompiledFunctionTable[48054] = bhPutModel_0x12ebb0; // 0x12eee0 - g_ps2RecompiledFunctionTable[48055] = bhPutModel_0x12ebb0; // 0x12eee4 - g_ps2RecompiledFunctionTable[48056] = bhPutModel_0x12ebb0; // 0x12eee8 - g_ps2RecompiledFunctionTable[48057] = bhPutModel_0x12ebb0; // 0x12eeec - g_ps2RecompiledFunctionTable[48058] = bhPutModel_0x12ebb0; // 0x12eef0 - g_ps2RecompiledFunctionTable[48059] = bhPutModel_0x12ebb0; // 0x12eef4 - g_ps2RecompiledFunctionTable[48062] = DrawTreeBsc_0x12ef00; // 0x12ef00 - g_ps2RecompiledFunctionTable[48071] = DrawTreeBsc_0x12ef00; // 0x12ef24 - g_ps2RecompiledFunctionTable[48074] = DrawTreeBsc_0x12ef00; // 0x12ef30 - g_ps2RecompiledFunctionTable[48077] = DrawTreeBsc_0x12ef00; // 0x12ef3c - g_ps2RecompiledFunctionTable[48086] = DrawTreeBsc_0x12ef00; // 0x12ef60 - g_ps2RecompiledFunctionTable[48088] = DrawTreeBsc_0x12ef00; // 0x12ef68 - g_ps2RecompiledFunctionTable[48098] = EasyMultiDrawTreeCnk_0x12ef90; // 0x12ef90 - g_ps2RecompiledFunctionTable[48109] = EasyMultiDrawTreeCnk_0x12ef90; // 0x12efbc - g_ps2RecompiledFunctionTable[48112] = EasyMultiDrawTreeCnk_0x12ef90; // 0x12efc8 - g_ps2RecompiledFunctionTable[48120] = EasyMultiDrawTreeCnk_0x12ef90; // 0x12efe8 - g_ps2RecompiledFunctionTable[48127] = EasyMultiDrawTreeCnk_0x12ef90; // 0x12f004 - g_ps2RecompiledFunctionTable[48137] = EasyMultiDrawTreeCnk_0x12ef90; // 0x12f02c - g_ps2RecompiledFunctionTable[48140] = EasyMultiDrawTreeCnk_0x12ef90; // 0x12f038 - g_ps2RecompiledFunctionTable[48154] = SimpleMultiDrawTreeCnk_0x12f070; // 0x12f070 - g_ps2RecompiledFunctionTable[48165] = SimpleMultiDrawTreeCnk_0x12f070; // 0x12f09c - g_ps2RecompiledFunctionTable[48168] = SimpleMultiDrawTreeCnk_0x12f070; // 0x12f0a8 - g_ps2RecompiledFunctionTable[48176] = SimpleMultiDrawTreeCnk_0x12f070; // 0x12f0c8 - g_ps2RecompiledFunctionTable[48183] = SimpleMultiDrawTreeCnk_0x12f070; // 0x12f0e4 - g_ps2RecompiledFunctionTable[48193] = SimpleMultiDrawTreeCnk_0x12f070; // 0x12f10c - g_ps2RecompiledFunctionTable[48196] = SimpleMultiDrawTreeCnk_0x12f070; // 0x12f118 - g_ps2RecompiledFunctionTable[48210] = EasyDrawTreeCnk_0x12f150; // 0x12f150 - g_ps2RecompiledFunctionTable[48221] = EasyDrawTreeCnk_0x12f150; // 0x12f17c - g_ps2RecompiledFunctionTable[48224] = EasyDrawTreeCnk_0x12f150; // 0x12f188 - g_ps2RecompiledFunctionTable[48232] = EasyDrawTreeCnk_0x12f150; // 0x12f1a8 - g_ps2RecompiledFunctionTable[48239] = EasyDrawTreeCnk_0x12f150; // 0x12f1c4 - g_ps2RecompiledFunctionTable[48249] = EasyDrawTreeCnk_0x12f150; // 0x12f1ec - g_ps2RecompiledFunctionTable[48252] = EasyDrawTreeCnk_0x12f150; // 0x12f1f8 - g_ps2RecompiledFunctionTable[48266] = SimpleDrawTreeCnk_0x12f230; // 0x12f230 - g_ps2RecompiledFunctionTable[48277] = SimpleDrawTreeCnk_0x12f230; // 0x12f25c - g_ps2RecompiledFunctionTable[48280] = SimpleDrawTreeCnk_0x12f230; // 0x12f268 - g_ps2RecompiledFunctionTable[48288] = SimpleDrawTreeCnk_0x12f230; // 0x12f288 - g_ps2RecompiledFunctionTable[48295] = SimpleDrawTreeCnk_0x12f230; // 0x12f2a4 - g_ps2RecompiledFunctionTable[48305] = SimpleDrawTreeCnk_0x12f230; // 0x12f2cc - g_ps2RecompiledFunctionTable[48308] = SimpleDrawTreeCnk_0x12f230; // 0x12f2d8 - g_ps2RecompiledFunctionTable[48322] = bhCalcModel_0x12f310; // 0x12f310 - g_ps2RecompiledFunctionTable[48340] = bhCalcModel_0x12f310; // 0x12f358 - g_ps2RecompiledFunctionTable[48345] = bhCalcModel_0x12f310; // 0x12f36c - g_ps2RecompiledFunctionTable[48351] = bhCalcModel_0x12f310; // 0x12f384 - g_ps2RecompiledFunctionTable[48356] = bhCalcModel_0x12f310; // 0x12f398 - g_ps2RecompiledFunctionTable[48363] = bhCalcModel_0x12f310; // 0x12f3b4 - g_ps2RecompiledFunctionTable[48368] = bhCalcModel_0x12f310; // 0x12f3c8 - g_ps2RecompiledFunctionTable[48373] = bhCalcModel_0x12f310; // 0x12f3dc - g_ps2RecompiledFunctionTable[48376] = bhCalcModel_0x12f310; // 0x12f3e8 - g_ps2RecompiledFunctionTable[48382] = bhCalcTree_0x12f400; // 0x12f400 - g_ps2RecompiledFunctionTable[48393] = bhCalcTree_0x12f400; // 0x12f42c - g_ps2RecompiledFunctionTable[48397] = bhCalcTree_0x12f400; // 0x12f43c - g_ps2RecompiledFunctionTable[48400] = bhCalcTree_0x12f400; // 0x12f448 - g_ps2RecompiledFunctionTable[48405] = bhCalcTree_0x12f400; // 0x12f45c - g_ps2RecompiledFunctionTable[48411] = bhCalcTree_0x12f400; // 0x12f474 - g_ps2RecompiledFunctionTable[48416] = bhCalcTree_0x12f400; // 0x12f488 - g_ps2RecompiledFunctionTable[48422] = bhCalcTree_0x12f400; // 0x12f4a0 - g_ps2RecompiledFunctionTable[48427] = bhCalcTree_0x12f400; // 0x12f4b4 - g_ps2RecompiledFunctionTable[48433] = bhCalcTree_0x12f400; // 0x12f4cc - g_ps2RecompiledFunctionTable[48440] = bhCalcTree_0x12f400; // 0x12f4e8 - g_ps2RecompiledFunctionTable[48450] = bhSetMotion_0x12f510; // 0x12f510 - g_ps2RecompiledFunctionTable[48516] = bhSetMotion_0x12f510; // 0x12f618 - g_ps2RecompiledFunctionTable[48522] = bhSetMotion_0x12f510; // 0x12f630 - g_ps2RecompiledFunctionTable[48534] = bhSetMotion_0x12f510; // 0x12f660 - g_ps2RecompiledFunctionTable[48540] = bhSetMotion_0x12f510; // 0x12f678 - g_ps2RecompiledFunctionTable[48549] = bhSetMotion_0x12f510; // 0x12f69c - g_ps2RecompiledFunctionTable[48555] = bhSetMotion_0x12f510; // 0x12f6b4 - g_ps2RecompiledFunctionTable[48626] = SetMtnNormal_0x12f7d0; // 0x12f7d0 - g_ps2RecompiledFunctionTable[48649] = SetMtnNormal_0x12f7d0; // 0x12f82c - g_ps2RecompiledFunctionTable[48726] = SetMtnNormalHokan_0x12f960; // 0x12f960 - g_ps2RecompiledFunctionTable[48763] = SetMtnNormalHokan_0x12f960; // 0x12f9f4 - g_ps2RecompiledFunctionTable[48945] = SetMtnNormalHokan_0x12f960; // 0x12fccc - g_ps2RecompiledFunctionTable[48959] = SetMtnNormalHokan_0x12f960; // 0x12fd04 - g_ps2RecompiledFunctionTable[48973] = SetMtnNormalHokan_0x12f960; // 0x12fd3c - g_ps2RecompiledFunctionTable[48998] = SetMtnFast_0x12fda0; // 0x12fda0 - g_ps2RecompiledFunctionTable[49053] = SetMtnFast_0x12fda0; // 0x12fe7c - g_ps2RecompiledFunctionTable[49106] = SetMtnFastHokan_0x12ff50; // 0x12ff50 - g_ps2RecompiledFunctionTable[49195] = SetMtnFastHokan_0x12ff50; // 0x1300b4 - g_ps2RecompiledFunctionTable[49331] = SetMtnFastHokan_0x12ff50; // 0x1302d4 - g_ps2RecompiledFunctionTable[49345] = SetMtnFastHokan_0x12ff50; // 0x13030c - g_ps2RecompiledFunctionTable[49359] = SetMtnFastHokan_0x12ff50; // 0x130344 - g_ps2RecompiledFunctionTable[49367] = SetMtnFastHokan_0x12ff50; // 0x130364 - g_ps2RecompiledFunctionTable[49372] = SetMtnFastHokan_0x12ff50; // 0x130378 - g_ps2RecompiledFunctionTable[49384] = SetMtnFastHokan_0x12ff50; // 0x1303a8 - g_ps2RecompiledFunctionTable[49401] = SetMtnFastHokan_0x12ff50; // 0x1303ec - g_ps2RecompiledFunctionTable[49418] = SetMtnFastHokan_0x12ff50; // 0x130430 - g_ps2RecompiledFunctionTable[49427] = SetMtnFastHokan_0x12ff50; // 0x130454 - g_ps2RecompiledFunctionTable[49450] = SetMtnSlow_0x1304b0; // 0x1304b0 - g_ps2RecompiledFunctionTable[49512] = SetMtnSlow_0x1304b0; // 0x1305a8 - g_ps2RecompiledFunctionTable[49588] = SetMtnSlow_0x1304b0; // 0x1306d8 - g_ps2RecompiledFunctionTable[49605] = SetMtnSlow_0x1304b0; // 0x13071c - g_ps2RecompiledFunctionTable[49622] = SetMtnSlow_0x1304b0; // 0x130760 - g_ps2RecompiledFunctionTable[49650] = SetMtnSlowHokan_0x1307d0; // 0x1307d0 - g_ps2RecompiledFunctionTable[49717] = SetMtnSlowHokan_0x1307d0; // 0x1308dc - g_ps2RecompiledFunctionTable[49833] = SetMtnSlowHokan_0x1307d0; // 0x130aac - g_ps2RecompiledFunctionTable[49850] = SetMtnSlowHokan_0x1307d0; // 0x130af0 - g_ps2RecompiledFunctionTable[49867] = SetMtnSlowHokan_0x1307d0; // 0x130b34 - g_ps2RecompiledFunctionTable[49961] = SetMtnSlowHokan_0x1307d0; // 0x130cac - g_ps2RecompiledFunctionTable[49975] = SetMtnSlowHokan_0x1307d0; // 0x130ce4 - g_ps2RecompiledFunctionTable[49989] = SetMtnSlowHokan_0x1307d0; // 0x130d1c - g_ps2RecompiledFunctionTable[50018] = bhFixPosition_0x130d90; // 0x130d90 - g_ps2RecompiledFunctionTable[50025] = bhFixPosition_0x130d90; // 0x130dac - g_ps2RecompiledFunctionTable[50038] = bhCalcFixOffset_0x130de0; // 0x130de0 - g_ps2RecompiledFunctionTable[50055] = bhCalcFixOffset_0x130de0; // 0x130e24 - g_ps2RecompiledFunctionTable[50070] = bhCalcFixOffset_0x130de0; // 0x130e60 - g_ps2RecompiledFunctionTable[50075] = bhCalcFixOffset_0x130de0; // 0x130e74 - g_ps2RecompiledFunctionTable[50080] = bhCalcFixOffset_0x130de0; // 0x130e88 - g_ps2RecompiledFunctionTable[50085] = bhCalcFixOffset_0x130de0; // 0x130e9c - g_ps2RecompiledFunctionTable[50090] = bhCalcFixOffset_0x130de0; // 0x130eb0 - g_ps2RecompiledFunctionTable[50095] = bhCalcFixOffset_0x130de0; // 0x130ec4 - g_ps2RecompiledFunctionTable[50098] = bhCalcFixOffset_0x130de0; // 0x130ed0 - g_ps2RecompiledFunctionTable[50110] = bhCalcFixOffset_0x130de0; // 0x130f00 - g_ps2RecompiledFunctionTable[50115] = bhCalcFixOffset_0x130de0; // 0x130f14 - g_ps2RecompiledFunctionTable[50124] = bhCalcFixOffset_0x130de0; // 0x130f38 - g_ps2RecompiledFunctionTable[50134] = bhCalcFixOffset_0x130de0; // 0x130f60 - g_ps2RecompiledFunctionTable[50137] = bhCalcFixOffset_0x130de0; // 0x130f6c - g_ps2RecompiledFunctionTable[50145] = bhCalcFixOffset_0x130de0; // 0x130f8c - g_ps2RecompiledFunctionTable[50154] = bhGetObjMotion_0x130fb0; // 0x130fb0 - g_ps2RecompiledFunctionTable[50218] = AngZyxToYzx_0x1310b0; // 0x1310b0 - g_ps2RecompiledFunctionTable[50228] = AngZyxToYzx_0x1310b0; // 0x1310d8 - g_ps2RecompiledFunctionTable[50232] = AngZyxToYzx_0x1310b0; // 0x1310e8 - g_ps2RecompiledFunctionTable[50236] = AngZyxToYzx_0x1310b0; // 0x1310f8 - g_ps2RecompiledFunctionTable[50247] = AngZyxToYzx_0x1310b0; // 0x131124 - g_ps2RecompiledFunctionTable[50252] = AngZyxToYzx_0x1310b0; // 0x131138 - g_ps2RecompiledFunctionTable[50258] = AngZyxToYzx_0x1310b0; // 0x131150 - g_ps2RecompiledFunctionTable[50263] = AngZyxToYzx_0x1310b0; // 0x131164 - g_ps2RecompiledFunctionTable[50268] = AngZyxToYzx_0x1310b0; // 0x131178 - g_ps2RecompiledFunctionTable[50273] = AngZyxToYzx_0x1310b0; // 0x13118c - g_ps2RecompiledFunctionTable[50282] = AngYzxToZyx_0x1311b0; // 0x1311b0 - g_ps2RecompiledFunctionTable[50292] = AngYzxToZyx_0x1311b0; // 0x1311d8 - g_ps2RecompiledFunctionTable[50296] = AngYzxToZyx_0x1311b0; // 0x1311e8 - g_ps2RecompiledFunctionTable[50300] = AngYzxToZyx_0x1311b0; // 0x1311f8 - g_ps2RecompiledFunctionTable[50311] = AngYzxToZyx_0x1311b0; // 0x131224 - g_ps2RecompiledFunctionTable[50316] = AngYzxToZyx_0x1311b0; // 0x131238 - g_ps2RecompiledFunctionTable[50321] = AngYzxToZyx_0x1311b0; // 0x13124c - g_ps2RecompiledFunctionTable[50326] = AngYzxToZyx_0x1311b0; // 0x131260 - g_ps2RecompiledFunctionTable[50332] = AngYzxToZyx_0x1311b0; // 0x131278 - g_ps2RecompiledFunctionTable[50337] = AngYzxToZyx_0x1311b0; // 0x13128c - g_ps2RecompiledFunctionTable[50346] = bhSetPad_0x1312b0; // 0x1312b0 - g_ps2RecompiledFunctionTable[50365] = bhSetPad_0x1312b0; // 0x1312fc - g_ps2RecompiledFunctionTable[50369] = bhSetPad_0x1312b0; // 0x13130c - g_ps2RecompiledFunctionTable[50371] = bhSetPad_0x1312b0; // 0x131314 - g_ps2RecompiledFunctionTable[50405] = bhSetPad_0x1312b0; // 0x13139c - g_ps2RecompiledFunctionTable[50435] = bhSetPad_0x1312b0; // 0x131414 - g_ps2RecompiledFunctionTable[50494] = bhSetPad_0x1312b0; // 0x131500 - g_ps2RecompiledFunctionTable[50498] = bhSetPad_0x1312b0; // 0x131510 - g_ps2RecompiledFunctionTable[50517] = bhSetPad_0x1312b0; // 0x13155c - g_ps2RecompiledFunctionTable[50525] = bhSetPad_0x1312b0; // 0x13157c - g_ps2RecompiledFunctionTable[50532] = bhSetPad_0x1312b0; // 0x131598 - g_ps2RecompiledFunctionTable[50548] = bhSetPad_0x1312b0; // 0x1315d8 - g_ps2RecompiledFunctionTable[50551] = bhSetPad_0x1312b0; // 0x1315e4 - g_ps2RecompiledFunctionTable[50568] = bhSetPad_0x1312b0; // 0x131628 - g_ps2RecompiledFunctionTable[50578] = bhSetPad_0x1312b0; // 0x131650 - g_ps2RecompiledFunctionTable[50594] = bhSetPad_0x1312b0; // 0x131690 - g_ps2RecompiledFunctionTable[50605] = bhSetPad_0x1312b0; // 0x1316bc - g_ps2RecompiledFunctionTable[50709] = bhSetPad_0x1312b0; // 0x13185c - g_ps2RecompiledFunctionTable[50914] = bhCalcVtxBuffer_0x131b90; // 0x131b90 - g_ps2RecompiledFunctionTable[50918] = bhChangeHWSetting_0x131ba0; // 0x131ba0 - g_ps2RecompiledFunctionTable[50980] = bhChangeHWSetting_0x131ba0; // 0x131c98 - g_ps2RecompiledFunctionTable[50994] = bhChangeHWSetting_0x131ba0; // 0x131cd0 - g_ps2RecompiledFunctionTable[51018] = bhChangeHWSetting_0x131ba0; // 0x131d30 - g_ps2RecompiledFunctionTable[51020] = bhChangeHWSetting_0x131ba0; // 0x131d38 - g_ps2RecompiledFunctionTable[51022] = bhChangeHWSetting_0x131ba0; // 0x131d40 - g_ps2RecompiledFunctionTable[51028] = bhChangeHWSetting_0x131ba0; // 0x131d58 - g_ps2RecompiledFunctionTable[51034] = bhChangeHWSetting_0x131ba0; // 0x131d70 - g_ps2RecompiledFunctionTable[51042] = bhChangeHWSetting_0x131ba0; // 0x131d90 - g_ps2RecompiledFunctionTable[51078] = bhChangeHWSetting_0x131ba0; // 0x131e20 - g_ps2RecompiledFunctionTable[51090] = bhInitSystem_0x131e50; // 0x131e50 - g_ps2RecompiledFunctionTable[51094] = bhInitSystem_0x131e50; // 0x131e60 - g_ps2RecompiledFunctionTable[51108] = bhInitSystem_0x131e50; // 0x131e98 - g_ps2RecompiledFunctionTable[51135] = bhInitSystem_0x131e50; // 0x131f04 - g_ps2RecompiledFunctionTable[51193] = bhInitSystem_0x131e50; // 0x131fec - g_ps2RecompiledFunctionTable[51205] = bhInitSystem_0x131e50; // 0x13201c - g_ps2RecompiledFunctionTable[51222] = bhInitSystem_0x131e50; // 0x132060 - g_ps2RecompiledFunctionTable[51229] = bhInitSystem_0x131e50; // 0x13207c - g_ps2RecompiledFunctionTable[51238] = bhInitRoomChangeSystem_0x1320a0; // 0x1320a0 - g_ps2RecompiledFunctionTable[51281] = bhInitRoomChangeSystem_0x1320a0; // 0x13214c - g_ps2RecompiledFunctionTable[51284] = bhInitRoomChangeSystem_0x1320a0; // 0x132158 - g_ps2RecompiledFunctionTable[51286] = bhInitRoomChangeSystem_0x1320a0; // 0x132160 - g_ps2RecompiledFunctionTable[51305] = bhInitRoomChangeSystem_0x1320a0; // 0x1321ac - g_ps2RecompiledFunctionTable[51317] = bhInitRoomChangeSystem_0x1320a0; // 0x1321dc - g_ps2RecompiledFunctionTable[51339] = bhInitRoomChangeSystem_0x1320a0; // 0x132234 - g_ps2RecompiledFunctionTable[51482] = bhInitRoomChangeSystem_0x1320a0; // 0x132470 - g_ps2RecompiledFunctionTable[51502] = bhSysCallInit_0x1324c0; // 0x1324c0 - g_ps2RecompiledFunctionTable[51506] = bhSysCallInit_0x1324c0; // 0x1324d0 - g_ps2RecompiledFunctionTable[51514] = bhSysCallDiscChange_0x1324f0; // 0x1324f0 - g_ps2RecompiledFunctionTable[51518] = bhSysCallDiscChange_0x1324f0; // 0x132500 - g_ps2RecompiledFunctionTable[51522] = bhSysCallDiscChange_0x1324f0; // 0x132510 - g_ps2RecompiledFunctionTable[51524] = bhSysCallDiscChange_0x1324f0; // 0x132518 - g_ps2RecompiledFunctionTable[51528] = bhSysCallDiscChange_0x1324f0; // 0x132528 - g_ps2RecompiledFunctionTable[51530] = bhSysCallDiscChange_0x1324f0; // 0x132530 - g_ps2RecompiledFunctionTable[51546] = bhSysCallSoundMuseum_0x132570; // 0x132570 - g_ps2RecompiledFunctionTable[51550] = bhSysCallSoundMuseum_0x132570; // 0x132580 - g_ps2RecompiledFunctionTable[51554] = bhSysCallSoundMuseum_0x132570; // 0x132590 - g_ps2RecompiledFunctionTable[51556] = bhSysCallSoundMuseum_0x132570; // 0x132598 - g_ps2RecompiledFunctionTable[51566] = bhSysCallWarning_0x1325c0; // 0x1325c0 - g_ps2RecompiledFunctionTable[51570] = bhSysCallWarning_0x1325c0; // 0x1325d0 - g_ps2RecompiledFunctionTable[51574] = bhSysCallWarning_0x1325c0; // 0x1325e0 - g_ps2RecompiledFunctionTable[51576] = bhSysCallWarning_0x1325c0; // 0x1325e8 - g_ps2RecompiledFunctionTable[51586] = bhSysCallIpl_0x132610; // 0x132610 - g_ps2RecompiledFunctionTable[51590] = bhSysCallIpl_0x132610; // 0x132620 - g_ps2RecompiledFunctionTable[51594] = bhSysCallIpl_0x132610; // 0x132630 - g_ps2RecompiledFunctionTable[51596] = bhSysCallIpl_0x132610; // 0x132638 - g_ps2RecompiledFunctionTable[51606] = bhSysCallFirstmovie_0x132660; // 0x132660 - g_ps2RecompiledFunctionTable[51607] = bhSysCallFirstmovie_0x132660; // 0x132664 - g_ps2RecompiledFunctionTable[51608] = bhSysCallFirstmovie_0x132660; // 0x132668 - g_ps2RecompiledFunctionTable[51609] = bhSysCallFirstmovie_0x132660; // 0x13266c - g_ps2RecompiledFunctionTable[51610] = bhSysCallFirstmovie_0x132660; // 0x132670 - g_ps2RecompiledFunctionTable[51611] = bhSysCallFirstmovie_0x132660; // 0x132674 - g_ps2RecompiledFunctionTable[51612] = bhSysCallFirstmovie_0x132660; // 0x132678 - g_ps2RecompiledFunctionTable[51613] = bhSysCallFirstmovie_0x132660; // 0x13267c - g_ps2RecompiledFunctionTable[51614] = bhSysCallFirstmovie_0x132660; // 0x132680 - g_ps2RecompiledFunctionTable[51615] = bhSysCallFirstmovie_0x132660; // 0x132684 - g_ps2RecompiledFunctionTable[51616] = bhSysCallFirstmovie_0x132660; // 0x132688 - g_ps2RecompiledFunctionTable[51617] = bhSysCallFirstmovie_0x132660; // 0x13268c - g_ps2RecompiledFunctionTable[51618] = bhSysCallFirstmovie_0x132660; // 0x132690 - g_ps2RecompiledFunctionTable[51619] = bhSysCallFirstmovie_0x132660; // 0x132694 - g_ps2RecompiledFunctionTable[51620] = bhSysCallFirstmovie_0x132660; // 0x132698 - g_ps2RecompiledFunctionTable[51621] = bhSysCallFirstmovie_0x132660; // 0x13269c - g_ps2RecompiledFunctionTable[51622] = bhSysCallFirstmovie_0x132660; // 0x1326a0 - g_ps2RecompiledFunctionTable[51623] = bhSysCallFirstmovie_0x132660; // 0x1326a4 - g_ps2RecompiledFunctionTable[51624] = bhSysCallFirstmovie_0x132660; // 0x1326a8 - g_ps2RecompiledFunctionTable[51625] = bhSysCallFirstmovie_0x132660; // 0x1326ac - g_ps2RecompiledFunctionTable[51626] = bhSysCallFirstmovie_0x132660; // 0x1326b0 - g_ps2RecompiledFunctionTable[51627] = bhSysCallFirstmovie_0x132660; // 0x1326b4 - g_ps2RecompiledFunctionTable[51628] = bhSysCallFirstmovie_0x132660; // 0x1326b8 - g_ps2RecompiledFunctionTable[51629] = bhSysCallFirstmovie_0x132660; // 0x1326bc - g_ps2RecompiledFunctionTable[51630] = bhSysCallFirstmovie_0x132660; // 0x1326c0 - g_ps2RecompiledFunctionTable[51631] = bhSysCallFirstmovie_0x132660; // 0x1326c4 - g_ps2RecompiledFunctionTable[51632] = bhSysCallFirstmovie_0x132660; // 0x1326c8 - g_ps2RecompiledFunctionTable[51633] = bhSysCallFirstmovie_0x132660; // 0x1326cc - g_ps2RecompiledFunctionTable[51634] = bhSysCallFirstmovie_0x132660; // 0x1326d0 - g_ps2RecompiledFunctionTable[51635] = bhSysCallFirstmovie_0x132660; // 0x1326d4 - g_ps2RecompiledFunctionTable[51636] = bhSysCallFirstmovie_0x132660; // 0x1326d8 - g_ps2RecompiledFunctionTable[51637] = bhSysCallFirstmovie_0x132660; // 0x1326dc - g_ps2RecompiledFunctionTable[51638] = bhSysCallFirstmovie_0x132660; // 0x1326e0 - g_ps2RecompiledFunctionTable[51639] = bhSysCallFirstmovie_0x132660; // 0x1326e4 - g_ps2RecompiledFunctionTable[51640] = bhSysCallFirstmovie_0x132660; // 0x1326e8 - g_ps2RecompiledFunctionTable[51641] = bhSysCallFirstmovie_0x132660; // 0x1326ec - g_ps2RecompiledFunctionTable[51642] = bhSysCallFirstmovie_0x132660; // 0x1326f0 - g_ps2RecompiledFunctionTable[51643] = bhSysCallFirstmovie_0x132660; // 0x1326f4 - g_ps2RecompiledFunctionTable[51644] = bhSysCallFirstmovie_0x132660; // 0x1326f8 - g_ps2RecompiledFunctionTable[51645] = bhSysCallFirstmovie_0x132660; // 0x1326fc - g_ps2RecompiledFunctionTable[51646] = bhSysCallFirstmovie_0x132660; // 0x132700 - g_ps2RecompiledFunctionTable[51647] = bhSysCallFirstmovie_0x132660; // 0x132704 - g_ps2RecompiledFunctionTable[51648] = bhSysCallFirstmovie_0x132660; // 0x132708 - g_ps2RecompiledFunctionTable[51649] = bhSysCallFirstmovie_0x132660; // 0x13270c - g_ps2RecompiledFunctionTable[51650] = bhSysCallFirstmovie_0x132660; // 0x132710 - g_ps2RecompiledFunctionTable[51651] = bhSysCallFirstmovie_0x132660; // 0x132714 - g_ps2RecompiledFunctionTable[51652] = bhSysCallFirstmovie_0x132660; // 0x132718 - g_ps2RecompiledFunctionTable[51653] = bhSysCallFirstmovie_0x132660; // 0x13271c - g_ps2RecompiledFunctionTable[51654] = bhSysCallFirstmovie_0x132660; // 0x132720 - g_ps2RecompiledFunctionTable[51655] = bhSysCallFirstmovie_0x132660; // 0x132724 - g_ps2RecompiledFunctionTable[51656] = bhSysCallFirstmovie_0x132660; // 0x132728 - g_ps2RecompiledFunctionTable[51657] = bhSysCallFirstmovie_0x132660; // 0x13272c - g_ps2RecompiledFunctionTable[51658] = bhSysCallFirstmovie_0x132660; // 0x132730 - g_ps2RecompiledFunctionTable[51659] = bhSysCallFirstmovie_0x132660; // 0x132734 - g_ps2RecompiledFunctionTable[51660] = bhSysCallFirstmovie_0x132660; // 0x132738 - g_ps2RecompiledFunctionTable[51661] = bhSysCallFirstmovie_0x132660; // 0x13273c - g_ps2RecompiledFunctionTable[51662] = bhSysCallFirstmovie_0x132660; // 0x132740 - g_ps2RecompiledFunctionTable[51663] = bhSysCallFirstmovie_0x132660; // 0x132744 - g_ps2RecompiledFunctionTable[51664] = bhSysCallFirstmovie_0x132660; // 0x132748 - g_ps2RecompiledFunctionTable[51665] = bhSysCallFirstmovie_0x132660; // 0x13274c - g_ps2RecompiledFunctionTable[51666] = bhSysCallFirstmovie_0x132660; // 0x132750 - g_ps2RecompiledFunctionTable[51667] = bhSysCallFirstmovie_0x132660; // 0x132754 - g_ps2RecompiledFunctionTable[51668] = bhSysCallFirstmovie_0x132660; // 0x132758 - g_ps2RecompiledFunctionTable[51669] = bhSysCallFirstmovie_0x132660; // 0x13275c - g_ps2RecompiledFunctionTable[51670] = bhSysCallFirstmovie_0x132660; // 0x132760 - g_ps2RecompiledFunctionTable[51671] = bhSysCallFirstmovie_0x132660; // 0x132764 - g_ps2RecompiledFunctionTable[51672] = bhSysCallFirstmovie_0x132660; // 0x132768 - g_ps2RecompiledFunctionTable[51673] = bhSysCallFirstmovie_0x132660; // 0x13276c - g_ps2RecompiledFunctionTable[51674] = bhSysCallFirstmovie_0x132660; // 0x132770 - g_ps2RecompiledFunctionTable[51675] = bhSysCallFirstmovie_0x132660; // 0x132774 - g_ps2RecompiledFunctionTable[51676] = bhSysCallFirstmovie_0x132660; // 0x132778 - g_ps2RecompiledFunctionTable[51677] = bhSysCallFirstmovie_0x132660; // 0x13277c - g_ps2RecompiledFunctionTable[51678] = bhSysCallFirstmovie_0x132660; // 0x132780 - g_ps2RecompiledFunctionTable[51679] = bhSysCallFirstmovie_0x132660; // 0x132784 - g_ps2RecompiledFunctionTable[51680] = bhSysCallFirstmovie_0x132660; // 0x132788 - g_ps2RecompiledFunctionTable[51681] = bhSysCallFirstmovie_0x132660; // 0x13278c - g_ps2RecompiledFunctionTable[51682] = bhSysCallFirstmovie_0x132660; // 0x132790 - g_ps2RecompiledFunctionTable[51683] = bhSysCallFirstmovie_0x132660; // 0x132794 - g_ps2RecompiledFunctionTable[51684] = bhSysCallFirstmovie_0x132660; // 0x132798 - g_ps2RecompiledFunctionTable[51685] = bhSysCallFirstmovie_0x132660; // 0x13279c - g_ps2RecompiledFunctionTable[51686] = bhSysCallFirstmovie_0x132660; // 0x1327a0 - g_ps2RecompiledFunctionTable[51687] = bhSysCallFirstmovie_0x132660; // 0x1327a4 - g_ps2RecompiledFunctionTable[51688] = bhSysCallFirstmovie_0x132660; // 0x1327a8 - g_ps2RecompiledFunctionTable[51689] = bhSysCallFirstmovie_0x132660; // 0x1327ac - g_ps2RecompiledFunctionTable[51690] = bhSysCallFirstmovie_0x132660; // 0x1327b0 - g_ps2RecompiledFunctionTable[51691] = bhSysCallFirstmovie_0x132660; // 0x1327b4 - g_ps2RecompiledFunctionTable[51692] = bhSysCallFirstmovie_0x132660; // 0x1327b8 - g_ps2RecompiledFunctionTable[51693] = bhSysCallFirstmovie_0x132660; // 0x1327bc - g_ps2RecompiledFunctionTable[51694] = bhSysCallFirstmovie_0x132660; // 0x1327c0 - g_ps2RecompiledFunctionTable[51695] = bhSysCallFirstmovie_0x132660; // 0x1327c4 - g_ps2RecompiledFunctionTable[51696] = bhSysCallFirstmovie_0x132660; // 0x1327c8 - g_ps2RecompiledFunctionTable[51697] = bhSysCallFirstmovie_0x132660; // 0x1327cc - g_ps2RecompiledFunctionTable[51698] = bhSysCallFirstmovie_0x132660; // 0x1327d0 - g_ps2RecompiledFunctionTable[51699] = bhSysCallFirstmovie_0x132660; // 0x1327d4 - g_ps2RecompiledFunctionTable[51700] = bhSysCallFirstmovie_0x132660; // 0x1327d8 - g_ps2RecompiledFunctionTable[51702] = bhSysCallTitle_0x1327e0; // 0x1327e0 - g_ps2RecompiledFunctionTable[51706] = bhSysCallTitle_0x1327e0; // 0x1327f0 - g_ps2RecompiledFunctionTable[51710] = bhSysCallTitle_0x1327e0; // 0x132800 - g_ps2RecompiledFunctionTable[51718] = bhSysCallOpening_0x132820; // 0x132820 - g_ps2RecompiledFunctionTable[51722] = bhSysCallOpening_0x132820; // 0x132830 - g_ps2RecompiledFunctionTable[51726] = bhSysCallOpening_0x132820; // 0x132840 - g_ps2RecompiledFunctionTable[51728] = bhSysCallOpening_0x132820; // 0x132848 - g_ps2RecompiledFunctionTable[51734] = bhFirstGameStart_0x132860; // 0x132860 - g_ps2RecompiledFunctionTable[51749] = bhFirstGameStart_0x132860; // 0x13289c - g_ps2RecompiledFunctionTable[51751] = bhFirstGameStart_0x132860; // 0x1328a4 - g_ps2RecompiledFunctionTable[51763] = bhFirstGameStart_0x132860; // 0x1328d4 - g_ps2RecompiledFunctionTable[51773] = bhFirstGameStart_0x132860; // 0x1328fc - g_ps2RecompiledFunctionTable[51783] = bhFirstGameStart_0x132860; // 0x132924 - g_ps2RecompiledFunctionTable[51791] = bhFirstGameStart_0x132860; // 0x132944 - g_ps2RecompiledFunctionTable[51840] = bhFirstGameStart_0x132860; // 0x132a08 - g_ps2RecompiledFunctionTable[51880] = bhFirstGameStart_0x132860; // 0x132aa8 - g_ps2RecompiledFunctionTable[51930] = bhSysCallPad_0x132b70; // 0x132b70 - g_ps2RecompiledFunctionTable[51956] = bhSysCallPad_0x132b70; // 0x132bd8 - g_ps2RecompiledFunctionTable[51998] = bhSysCallGame_0x132c80; // 0x132c80 - g_ps2RecompiledFunctionTable[52002] = bhSysCallGame_0x132c80; // 0x132c90 - g_ps2RecompiledFunctionTable[52046] = bhSysCallGame_0x132c80; // 0x132d40 - g_ps2RecompiledFunctionTable[52048] = bhSysCallGame_0x132c80; // 0x132d48 - g_ps2RecompiledFunctionTable[52066] = bhCheckSubTask_0x132d90; // 0x132d90 - g_ps2RecompiledFunctionTable[52127] = bhCheckSubTask_0x132d90; // 0x132e84 - g_ps2RecompiledFunctionTable[52138] = bhCheckSubTask_0x132d90; // 0x132eb0 - g_ps2RecompiledFunctionTable[52163] = bhCheckSubTask_0x132d90; // 0x132f14 - g_ps2RecompiledFunctionTable[52195] = bhCheckSubTask_0x132d90; // 0x132f94 - g_ps2RecompiledFunctionTable[52219] = bhCheckSubTask_0x132d90; // 0x132ff4 - g_ps2RecompiledFunctionTable[52241] = bhCheckSubTask_0x132d90; // 0x13304c - g_ps2RecompiledFunctionTable[52270] = bhCheckSubTask_0x132d90; // 0x1330c0 - g_ps2RecompiledFunctionTable[52285] = bhCheckSubTask_0x132d90; // 0x1330fc - g_ps2RecompiledFunctionTable[52314] = bhCheckSubTask_0x132d90; // 0x133170 - g_ps2RecompiledFunctionTable[52321] = bhCheckSubTask_0x132d90; // 0x13318c - g_ps2RecompiledFunctionTable[52326] = bhSysCallEvent_0x1331a0; // 0x1331a0 - g_ps2RecompiledFunctionTable[52453] = bhSysCallEvent_0x1331a0; // 0x13339c - g_ps2RecompiledFunctionTable[52529] = bhSysCallEvent_0x1331a0; // 0x1334cc - g_ps2RecompiledFunctionTable[52533] = bhSysCallEvent_0x1331a0; // 0x1334dc - g_ps2RecompiledFunctionTable[52537] = bhSysCallEvent_0x1331a0; // 0x1334ec - g_ps2RecompiledFunctionTable[52642] = bhSysCallMap_0x133690; // 0x133690 - g_ps2RecompiledFunctionTable[52673] = bhSysCallMap_0x133690; // 0x13370c - g_ps2RecompiledFunctionTable[52682] = bhSysCallMap_0x133690; // 0x133730 - g_ps2RecompiledFunctionTable[52687] = bhSysCallMap_0x133690; // 0x133744 - g_ps2RecompiledFunctionTable[52689] = bhSysCallMap_0x133690; // 0x13374c - g_ps2RecompiledFunctionTable[52701] = bhSysCallMap_0x133690; // 0x13377c - g_ps2RecompiledFunctionTable[52710] = bhSysCallMap_0x133690; // 0x1337a0 - g_ps2RecompiledFunctionTable[52722] = bhSysCallMap_0x133690; // 0x1337d0 - g_ps2RecompiledFunctionTable[52726] = bhSysCallMap_0x133690; // 0x1337e0 - g_ps2RecompiledFunctionTable[52786] = bhSysCallMap_0x133690; // 0x1338d0 - g_ps2RecompiledFunctionTable[52794] = bhSysCallMap_0x133690; // 0x1338f0 - g_ps2RecompiledFunctionTable[52796] = bhSysCallMap_0x133690; // 0x1338f8 - g_ps2RecompiledFunctionTable[52800] = bhSysCallMap_0x133690; // 0x133908 - g_ps2RecompiledFunctionTable[52807] = bhSysCallMap_0x133690; // 0x133924 - g_ps2RecompiledFunctionTable[52809] = bhSysCallMap_0x133690; // 0x13392c - g_ps2RecompiledFunctionTable[52820] = bhSysCallMap_0x133690; // 0x133958 - g_ps2RecompiledFunctionTable[52829] = bhSysCallMap_0x133690; // 0x13397c - g_ps2RecompiledFunctionTable[52841] = bhSysCallMap_0x133690; // 0x1339ac - g_ps2RecompiledFunctionTable[52845] = bhSysCallMap_0x133690; // 0x1339bc - g_ps2RecompiledFunctionTable[52862] = bhSysCallMap_0x133690; // 0x133a00 - g_ps2RecompiledFunctionTable[52892] = bhSysCallMap_0x133690; // 0x133a78 - g_ps2RecompiledFunctionTable[52898] = bhSysCallItemselect_0x133a90; // 0x133a90 - g_ps2RecompiledFunctionTable[52902] = bhSysCallItemselect_0x133a90; // 0x133aa0 - g_ps2RecompiledFunctionTable[52904] = bhSysCallItemselect_0x133a90; // 0x133aa8 - g_ps2RecompiledFunctionTable[52906] = bhSysCallItemselect_0x133a90; // 0x133ab0 - g_ps2RecompiledFunctionTable[52914] = bhSysCallItemselect_0x133a90; // 0x133ad0 - g_ps2RecompiledFunctionTable[52918] = bhSysCallItemselect_0x133a90; // 0x133ae0 - g_ps2RecompiledFunctionTable[52926] = bhSysCallItemselect_0x133a90; // 0x133b00 - g_ps2RecompiledFunctionTable[52928] = bhSysCallItemselect_0x133a90; // 0x133b08 - g_ps2RecompiledFunctionTable[52942] = bhSysCallItemselect_0x133a90; // 0x133b40 - g_ps2RecompiledFunctionTable[52950] = bhSysCallItemselect_0x133a90; // 0x133b60 - g_ps2RecompiledFunctionTable[52954] = bhSysCallDoordemo_0x133b70; // 0x133b70 - g_ps2RecompiledFunctionTable[52991] = bhSysCallDoordemo_0x133b70; // 0x133c04 - g_ps2RecompiledFunctionTable[52996] = bhSysCallDoordemo_0x133b70; // 0x133c18 - g_ps2RecompiledFunctionTable[53010] = bhSysCallDoordemo_0x133b70; // 0x133c50 - g_ps2RecompiledFunctionTable[53019] = bhSysCallDoordemo_0x133b70; // 0x133c74 - g_ps2RecompiledFunctionTable[53023] = bhSysCallDoordemo_0x133b70; // 0x133c84 - g_ps2RecompiledFunctionTable[53050] = bhSysCallDoordemo_0x133b70; // 0x133cf0 - g_ps2RecompiledFunctionTable[53052] = bhSysCallDoordemo_0x133b70; // 0x133cf8 - g_ps2RecompiledFunctionTable[53064] = bhSysCallDoordemo_0x133b70; // 0x133d28 - g_ps2RecompiledFunctionTable[53070] = bhSysCallDoordemo_0x133b70; // 0x133d40 - g_ps2RecompiledFunctionTable[53075] = bhSysCallDoordemo_0x133b70; // 0x133d54 - g_ps2RecompiledFunctionTable[53079] = bhSysCallDoordemo_0x133b70; // 0x133d64 - g_ps2RecompiledFunctionTable[53099] = bhSysCallDoordemo_0x133b70; // 0x133db4 - g_ps2RecompiledFunctionTable[53104] = bhSysCallDoordemo_0x133b70; // 0x133dc8 - g_ps2RecompiledFunctionTable[53110] = bhSysCallDoordemo_0x133b70; // 0x133de0 - g_ps2RecompiledFunctionTable[53116] = bhSysCallDoordemo_0x133b70; // 0x133df8 - g_ps2RecompiledFunctionTable[53120] = bhSysCallDoordemo_0x133b70; // 0x133e08 - g_ps2RecompiledFunctionTable[53122] = bhSysCallDoordemo_0x133b70; // 0x133e10 - g_ps2RecompiledFunctionTable[53124] = bhSysCallDoordemo_0x133b70; // 0x133e18 - g_ps2RecompiledFunctionTable[53136] = bhSysCallDoordemo_0x133b70; // 0x133e48 - g_ps2RecompiledFunctionTable[53142] = bhSysCallDoordemo_0x133b70; // 0x133e60 - g_ps2RecompiledFunctionTable[53174] = bhSysCallMovie_0x133ee0; // 0x133ee0 - g_ps2RecompiledFunctionTable[53193] = bhSysCallMovie_0x133ee0; // 0x133f2c - g_ps2RecompiledFunctionTable[53249] = bhSysCallMovie_0x133ee0; // 0x13400c - g_ps2RecompiledFunctionTable[53253] = bhSysCallMovie_0x133ee0; // 0x13401c - g_ps2RecompiledFunctionTable[53264] = bhSysCallMovie_0x133ee0; // 0x134048 - g_ps2RecompiledFunctionTable[53273] = bhSysCallMovie_0x133ee0; // 0x13406c - g_ps2RecompiledFunctionTable[53277] = bhSysCallMovie_0x133ee0; // 0x13407c - g_ps2RecompiledFunctionTable[53279] = bhSysCallMovie_0x133ee0; // 0x134084 - g_ps2RecompiledFunctionTable[53291] = bhSysCallMovie_0x133ee0; // 0x1340b4 - g_ps2RecompiledFunctionTable[53308] = bhSysCallMovie_0x133ee0; // 0x1340f8 - g_ps2RecompiledFunctionTable[53312] = bhSysCallMovie_0x133ee0; // 0x134108 - g_ps2RecompiledFunctionTable[53322] = bhSysCallMovie_0x133ee0; // 0x134130 - g_ps2RecompiledFunctionTable[53339] = bhSysCallMovie_0x133ee0; // 0x134174 - g_ps2RecompiledFunctionTable[53343] = bhSysCallMovie_0x133ee0; // 0x134184 - g_ps2RecompiledFunctionTable[53346] = bhSysCallMovie_0x133ee0; // 0x134190 - g_ps2RecompiledFunctionTable[53379] = bhSysCallMovie_0x133ee0; // 0x134214 - g_ps2RecompiledFunctionTable[53405] = bhSysCallMovie_0x133ee0; // 0x13427c - g_ps2RecompiledFunctionTable[53409] = bhSysCallMovie_0x133ee0; // 0x13428c - g_ps2RecompiledFunctionTable[53411] = bhSysCallMovie_0x133ee0; // 0x134294 - g_ps2RecompiledFunctionTable[53419] = bhSysCallMovie_0x133ee0; // 0x1342b4 - g_ps2RecompiledFunctionTable[53429] = bhSysCallMovie_0x133ee0; // 0x1342dc - g_ps2RecompiledFunctionTable[53433] = bhSysCallMovie_0x133ee0; // 0x1342ec - g_ps2RecompiledFunctionTable[53435] = bhSysCallMovie_0x133ee0; // 0x1342f4 - g_ps2RecompiledFunctionTable[53455] = bhSysCallMovie_0x133ee0; // 0x134344 - g_ps2RecompiledFunctionTable[53459] = bhSysCallMovie_0x133ee0; // 0x134354 - g_ps2RecompiledFunctionTable[53473] = bhSysCallMovie_0x133ee0; // 0x13438c - g_ps2RecompiledFunctionTable[53508] = bhSysCallMovie_0x133ee0; // 0x134418 - g_ps2RecompiledFunctionTable[53526] = bhSysCallEnding_0x134460; // 0x134460 - g_ps2RecompiledFunctionTable[53530] = bhSysCallGameover_0x134470; // 0x134470 - g_ps2RecompiledFunctionTable[53534] = bhSysCallTypewriter_0x134480; // 0x134480 - g_ps2RecompiledFunctionTable[53544] = bhSysCallTypewriter_0x134480; // 0x1344a8 - g_ps2RecompiledFunctionTable[53546] = bhSysCallTypewriter_0x134480; // 0x1344b0 - g_ps2RecompiledFunctionTable[53550] = bhSysCallOption_0x1344c0; // 0x1344c0 - g_ps2RecompiledFunctionTable[53572] = bhSysCallOption_0x1344c0; // 0x134518 - g_ps2RecompiledFunctionTable[53580] = bhSysCallOption_0x1344c0; // 0x134538 - g_ps2RecompiledFunctionTable[53632] = bhSysCallOption_0x1344c0; // 0x134608 - g_ps2RecompiledFunctionTable[53640] = bhSysCallOption_0x1344c0; // 0x134628 - g_ps2RecompiledFunctionTable[53642] = bhSysCallOption_0x1344c0; // 0x134630 - g_ps2RecompiledFunctionTable[53647] = bhSysCallOption_0x1344c0; // 0x134644 - g_ps2RecompiledFunctionTable[53659] = bhSysCallOption_0x1344c0; // 0x134674 - g_ps2RecompiledFunctionTable[53670] = bhSysCallCompEvent_0x1346a0; // 0x1346a0 - g_ps2RecompiledFunctionTable[53674] = bhSysCallMonitor_0x1346b0; // 0x1346b0 - g_ps2RecompiledFunctionTable[53806] = bhSysCallMonitor_0x1346b0; // 0x1348c0 - g_ps2RecompiledFunctionTable[53817] = bhSysCallMonitor_0x1346b0; // 0x1348ec - g_ps2RecompiledFunctionTable[53838] = bhSysCallMonitor_0x1346b0; // 0x134940 - g_ps2RecompiledFunctionTable[53852] = bhSysCallMonitor_0x1346b0; // 0x134978 - g_ps2RecompiledFunctionTable[53879] = bhSysCallMonitor_0x1346b0; // 0x1349e4 - g_ps2RecompiledFunctionTable[53886] = bhSysCallMonitor_0x1346b0; // 0x134a00 - g_ps2RecompiledFunctionTable[53906] = bhSysCallMonitor_0x1346b0; // 0x134a50 - g_ps2RecompiledFunctionTable[53915] = bhSysCallMonitor_0x1346b0; // 0x134a74 - g_ps2RecompiledFunctionTable[53919] = bhSysCallMonitor_0x1346b0; // 0x134a84 - g_ps2RecompiledFunctionTable[53921] = bhSysCallMonitor_0x1346b0; // 0x134a8c - g_ps2RecompiledFunctionTable[53923] = bhSysCallMonitor_0x1346b0; // 0x134a94 - g_ps2RecompiledFunctionTable[53925] = bhSysCallMonitor_0x1346b0; // 0x134a9c - g_ps2RecompiledFunctionTable[53927] = bhSysCallMonitor_0x1346b0; // 0x134aa4 - g_ps2RecompiledFunctionTable[53949] = bhSysCallMonitor_0x1346b0; // 0x134afc - g_ps2RecompiledFunctionTable[53958] = bhSysCallMonitor_0x1346b0; // 0x134b20 - g_ps2RecompiledFunctionTable[53971] = bhSysCallMonitor_0x1346b0; // 0x134b54 - g_ps2RecompiledFunctionTable[53997] = bhSysCallMonitor_0x1346b0; // 0x134bbc - g_ps2RecompiledFunctionTable[54006] = bhSysCallMonitor_0x1346b0; // 0x134be0 - g_ps2RecompiledFunctionTable[54010] = bhSysCallMonitor_0x1346b0; // 0x134bf0 - g_ps2RecompiledFunctionTable[54028] = bhSysCallMonitor_0x1346b0; // 0x134c38 - g_ps2RecompiledFunctionTable[54056] = bhSysCallMonitor_0x1346b0; // 0x134ca8 - g_ps2RecompiledFunctionTable[54065] = bhSysCallMonitor_0x1346b0; // 0x134ccc - g_ps2RecompiledFunctionTable[54069] = bhSysCallMonitor_0x1346b0; // 0x134cdc - g_ps2RecompiledFunctionTable[54126] = bhSysCallMonitor_0x1346b0; // 0x134dc0 - g_ps2RecompiledFunctionTable[54145] = bhSysCallMonitor_0x1346b0; // 0x134e0c - g_ps2RecompiledFunctionTable[54156] = bhSysCallMonitor_0x1346b0; // 0x134e38 - g_ps2RecompiledFunctionTable[54182] = bhSysCallMonitor_0x1346b0; // 0x134ea0 - g_ps2RecompiledFunctionTable[54194] = bhSysCallMonitor_0x1346b0; // 0x134ed0 - g_ps2RecompiledFunctionTable[54310] = bhSysCallMonitor_0x1346b0; // 0x1350a0 - g_ps2RecompiledFunctionTable[54335] = bhSysCallMonitor_0x1346b0; // 0x135104 - g_ps2RecompiledFunctionTable[54351] = bhSysCallMonitor_0x1346b0; // 0x135144 - g_ps2RecompiledFunctionTable[54379] = bhSysCallMonitor_0x1346b0; // 0x1351b4 - g_ps2RecompiledFunctionTable[54388] = bhSysCallMonitor_0x1346b0; // 0x1351d8 - g_ps2RecompiledFunctionTable[54392] = bhSysCallMonitor_0x1346b0; // 0x1351e8 - g_ps2RecompiledFunctionTable[54405] = bhSysCallMonitor_0x1346b0; // 0x13521c - g_ps2RecompiledFunctionTable[54414] = bhSysCallMonitor_0x1346b0; // 0x135240 - g_ps2RecompiledFunctionTable[54493] = bhSysCallMonitor_0x1346b0; // 0x13537c - g_ps2RecompiledFunctionTable[54511] = bhSysCallMonitor_0x1346b0; // 0x1353c4 - g_ps2RecompiledFunctionTable[54517] = bhSysCallMonitor_0x1346b0; // 0x1353dc - g_ps2RecompiledFunctionTable[54522] = bhSysCallMonitor_0x1346b0; // 0x1353f0 - g_ps2RecompiledFunctionTable[54551] = bhSysCallMonitor_0x1346b0; // 0x135464 - g_ps2RecompiledFunctionTable[54626] = bhSysCallMonitor_0x1346b0; // 0x135590 - g_ps2RecompiledFunctionTable[54652] = bhSysCallMonitor_0x1346b0; // 0x1355f8 - g_ps2RecompiledFunctionTable[54656] = bhSysCallMonitor_0x1346b0; // 0x135608 - g_ps2RecompiledFunctionTable[54665] = bhSysCallMonitor_0x1346b0; // 0x13562c - g_ps2RecompiledFunctionTable[54696] = bhSysCallMonitor_0x1346b0; // 0x1356a8 - g_ps2RecompiledFunctionTable[54735] = bhSysCallMonitor_0x1346b0; // 0x135744 - g_ps2RecompiledFunctionTable[54747] = bhSysCallMonitor_0x1346b0; // 0x135774 - g_ps2RecompiledFunctionTable[54772] = bhSysCallMonitor_0x1346b0; // 0x1357d8 - g_ps2RecompiledFunctionTable[54777] = bhSysCallMonitor_0x1346b0; // 0x1357ec - g_ps2RecompiledFunctionTable[54789] = bhSysCallMonitor_0x1346b0; // 0x13581c - g_ps2RecompiledFunctionTable[54850] = bhSysCallMonitor_0x1346b0; // 0x135910 - g_ps2RecompiledFunctionTable[54864] = bhSysCallMonitor_0x1346b0; // 0x135948 - g_ps2RecompiledFunctionTable[54890] = bhSysCallMonitor_0x1346b0; // 0x1359b0 - g_ps2RecompiledFunctionTable[54899] = bhSysCallMonitor_0x1346b0; // 0x1359d4 - g_ps2RecompiledFunctionTable[54903] = bhSysCallMonitor_0x1346b0; // 0x1359e4 - g_ps2RecompiledFunctionTable[54905] = bhSysCallMonitor_0x1346b0; // 0x1359ec - g_ps2RecompiledFunctionTable[54907] = bhSysCallMonitor_0x1346b0; // 0x1359f4 - g_ps2RecompiledFunctionTable[54942] = bhSysCallMonitor_0x1346b0; // 0x135a80 - g_ps2RecompiledFunctionTable[54970] = bhSysCallMonitor_0x1346b0; // 0x135af0 - g_ps2RecompiledFunctionTable[54979] = bhSysCallMonitor_0x1346b0; // 0x135b14 - g_ps2RecompiledFunctionTable[54983] = bhSysCallMonitor_0x1346b0; // 0x135b24 - g_ps2RecompiledFunctionTable[55012] = bhSysCallMonitor_0x1346b0; // 0x135b98 - g_ps2RecompiledFunctionTable[55014] = bhSysCallMonitor_0x1346b0; // 0x135ba0 - g_ps2RecompiledFunctionTable[55033] = bhSysCallMonitor_0x1346b0; // 0x135bec - g_ps2RecompiledFunctionTable[55089] = bhSysCallMonitor_0x1346b0; // 0x135ccc - g_ps2RecompiledFunctionTable[55134] = bhSysCallMonitor_0x1346b0; // 0x135d80 - g_ps2RecompiledFunctionTable[55136] = bhSysCallMonitor_0x1346b0; // 0x135d88 - g_ps2RecompiledFunctionTable[55159] = bhSysCallMonitor_0x1346b0; // 0x135de4 - g_ps2RecompiledFunctionTable[55213] = bhSysCallMonitor_0x1346b0; // 0x135ebc - g_ps2RecompiledFunctionTable[55248] = bhSysCallMonitor_0x1346b0; // 0x135f48 - g_ps2RecompiledFunctionTable[55256] = bhSysCallMonitor_0x1346b0; // 0x135f68 - g_ps2RecompiledFunctionTable[55258] = bhSysCallMonitor_0x1346b0; // 0x135f70 - g_ps2RecompiledFunctionTable[55267] = bhSysCallMonitor_0x1346b0; // 0x135f94 - g_ps2RecompiledFunctionTable[55275] = bhSysCallMonitor_0x1346b0; // 0x135fb4 - g_ps2RecompiledFunctionTable[55284] = bhSysCallMonitor_0x1346b0; // 0x135fd8 - g_ps2RecompiledFunctionTable[55292] = bhSysCallMonitor_0x1346b0; // 0x135ff8 - g_ps2RecompiledFunctionTable[55295] = bhSysCallMonitor_0x1346b0; // 0x136004 - g_ps2RecompiledFunctionTable[55309] = bhSysCallMonitor_0x1346b0; // 0x13603c - g_ps2RecompiledFunctionTable[55317] = bhSysCallMonitor_0x1346b0; // 0x13605c - g_ps2RecompiledFunctionTable[55320] = bhSysCallMonitor_0x1346b0; // 0x136068 - g_ps2RecompiledFunctionTable[55325] = bhSysCallMonitor_0x1346b0; // 0x13607c - g_ps2RecompiledFunctionTable[55375] = bhSysCallMonitor_0x1346b0; // 0x136144 - g_ps2RecompiledFunctionTable[55407] = bhSysCallMonitor_0x1346b0; // 0x1361c4 - g_ps2RecompiledFunctionTable[55415] = bhSysCallMonitor_0x1346b0; // 0x1361e4 - g_ps2RecompiledFunctionTable[55425] = bhSysCallMonitor_0x1346b0; // 0x13620c - g_ps2RecompiledFunctionTable[55445] = bhSysCallMonitor_0x1346b0; // 0x13625c - g_ps2RecompiledFunctionTable[55475] = bhSysCallMonitor_0x1346b0; // 0x1362d4 - g_ps2RecompiledFunctionTable[55477] = bhSysCallMonitor_0x1346b0; // 0x1362dc - g_ps2RecompiledFunctionTable[55492] = bhSysCallMonitor_0x1346b0; // 0x136318 - g_ps2RecompiledFunctionTable[55496] = bhSysCallMonitor_0x1346b0; // 0x136328 - g_ps2RecompiledFunctionTable[55498] = bhSysCallMonitor_0x1346b0; // 0x136330 - g_ps2RecompiledFunctionTable[55510] = bhSysCallMonitor_0x1346b0; // 0x136360 - g_ps2RecompiledFunctionTable[55519] = bhSysCallMonitor_0x1346b0; // 0x136384 - g_ps2RecompiledFunctionTable[55528] = bhSysCallMonitor_0x1346b0; // 0x1363a8 - g_ps2RecompiledFunctionTable[55547] = bhSysCallMonitor_0x1346b0; // 0x1363f4 - g_ps2RecompiledFunctionTable[55558] = bhSysCallMonitor_0x1346b0; // 0x136420 - g_ps2RecompiledFunctionTable[55576] = bhSysCallMonitor_0x1346b0; // 0x136468 - g_ps2RecompiledFunctionTable[55595] = bhSysCallMonitor_0x1346b0; // 0x1364b4 - g_ps2RecompiledFunctionTable[55653] = bhSysCallMonitor_0x1346b0; // 0x13659c - g_ps2RecompiledFunctionTable[55685] = bhSysCallMonitor_0x1346b0; // 0x13661c - g_ps2RecompiledFunctionTable[55693] = bhSysCallMonitor_0x1346b0; // 0x13663c - g_ps2RecompiledFunctionTable[55704] = bhSysCallMonitor_0x1346b0; // 0x136668 - g_ps2RecompiledFunctionTable[55724] = bhSysCallMonitor_0x1346b0; // 0x1366b8 - g_ps2RecompiledFunctionTable[55754] = bhSysCallMonitor_0x1346b0; // 0x136730 - g_ps2RecompiledFunctionTable[55756] = bhSysCallMonitor_0x1346b0; // 0x136738 - g_ps2RecompiledFunctionTable[55776] = bhSysCallMonitor_0x1346b0; // 0x136788 - g_ps2RecompiledFunctionTable[55780] = bhSysCallMonitor_0x1346b0; // 0x136798 - g_ps2RecompiledFunctionTable[55782] = bhSysCallMonitor_0x1346b0; // 0x1367a0 - g_ps2RecompiledFunctionTable[55794] = bhSysCallMonitor_0x1346b0; // 0x1367d0 - g_ps2RecompiledFunctionTable[55835] = bhSysCallMonitor_0x1346b0; // 0x136874 - g_ps2RecompiledFunctionTable[55860] = bhSysCallMonitor_0x1346b0; // 0x1368d8 - g_ps2RecompiledFunctionTable[55882] = bhSysCallMonitor_0x1346b0; // 0x136930 - g_ps2RecompiledFunctionTable[55890] = bhSysCallSndMonitor_0x136950; // 0x136950 - g_ps2RecompiledFunctionTable[55915] = bhSysCallSndMonitor_0x136950; // 0x1369b4 - g_ps2RecompiledFunctionTable[55919] = bhSysCallSndMonitor_0x136950; // 0x1369c4 - g_ps2RecompiledFunctionTable[55921] = bhSysCallSndMonitor_0x136950; // 0x1369cc - g_ps2RecompiledFunctionTable[55929] = bhSysCallSndMonitor_0x136950; // 0x1369ec - g_ps2RecompiledFunctionTable[55984] = bhSysCallSndMonitor_0x136950; // 0x136ac8 - g_ps2RecompiledFunctionTable[55989] = bhSysCallSndMonitor_0x136950; // 0x136adc - g_ps2RecompiledFunctionTable[55993] = bhSysCallSndMonitor_0x136950; // 0x136aec - g_ps2RecompiledFunctionTable[56002] = bhSysCallSndMonitor_0x136950; // 0x136b10 - g_ps2RecompiledFunctionTable[56018] = bhSysCallSndMonitor_0x136950; // 0x136b50 - g_ps2RecompiledFunctionTable[56024] = bhSysCallSndMonitor_0x136950; // 0x136b68 - g_ps2RecompiledFunctionTable[56033] = bhSysCallSndMonitor_0x136950; // 0x136b8c - g_ps2RecompiledFunctionTable[56049] = bhSysCallSndMonitor_0x136950; // 0x136bcc - g_ps2RecompiledFunctionTable[56064] = bhSysCallSndMonitor_0x136950; // 0x136c08 - g_ps2RecompiledFunctionTable[56073] = bhSysCallSndMonitor_0x136950; // 0x136c2c - g_ps2RecompiledFunctionTable[56091] = bhSysCallSndMonitor_0x136950; // 0x136c74 - g_ps2RecompiledFunctionTable[56098] = bhSysCallScreenSaver_0x136c90; // 0x136c90 - g_ps2RecompiledFunctionTable[56186] = bhSysCallScreenSaver_0x136c90; // 0x136df0 - g_ps2RecompiledFunctionTable[56190] = bhSysCallScreenSaver_0x136c90; // 0x136e00 - g_ps2RecompiledFunctionTable[56216] = bhSysCallScreenSaver_0x136c90; // 0x136e68 - g_ps2RecompiledFunctionTable[56241] = bhSysCallScreenSaver_0x136c90; // 0x136ecc - g_ps2RecompiledFunctionTable[56250] = bhSysCallScreenSaver_0x136c90; // 0x136ef0 - g_ps2RecompiledFunctionTable[56259] = bhSysCallScreenSaver_0x136c90; // 0x136f14 - g_ps2RecompiledFunctionTable[56263] = bhSysCallScreenSaver_0x136c90; // 0x136f24 - g_ps2RecompiledFunctionTable[56269] = bhSysCallScreenSaver_0x136c90; // 0x136f3c - g_ps2RecompiledFunctionTable[56281] = bhSysCallScreenSaver_0x136c90; // 0x136f6c - g_ps2RecompiledFunctionTable[56333] = bhSysCallScreenSaver_0x136c90; // 0x13703c - g_ps2RecompiledFunctionTable[56361] = bhSysCallScreenSaver_0x136c90; // 0x1370ac - g_ps2RecompiledFunctionTable[56375] = bhSysCallScreenSaver_0x136c90; // 0x1370e4 - g_ps2RecompiledFunctionTable[56405] = bhSysCallScreenSaver_0x136c90; // 0x13715c - g_ps2RecompiledFunctionTable[56410] = bhReturnTitle_0x137170; // 0x137170 - g_ps2RecompiledFunctionTable[56419] = bhReturnTitle_0x137170; // 0x137194 - g_ps2RecompiledFunctionTable[56458] = bhExitGame_0x137230; // 0x137230 - g_ps2RecompiledFunctionTable[56468] = bhExitGame_0x137230; // 0x137258 - g_ps2RecompiledFunctionTable[56470] = bhExitGame_0x137230; // 0x137260 - g_ps2RecompiledFunctionTable[56472] = bhExitGame_0x137230; // 0x137268 - g_ps2RecompiledFunctionTable[56474] = bhExitGame_0x137230; // 0x137270 - g_ps2RecompiledFunctionTable[56478] = bhExitGame_0x137230; // 0x137280 - g_ps2RecompiledFunctionTable[56480] = bhExitGame_0x137230; // 0x137288 - g_ps2RecompiledFunctionTable[56484] = bhExitGame_0x137230; // 0x137298 - g_ps2RecompiledFunctionTable[56488] = bhExitGame_0x137230; // 0x1372a8 - g_ps2RecompiledFunctionTable[56490] = bhExitGame_0x137230; // 0x1372b0 - g_ps2RecompiledFunctionTable[56494] = bhSetEventTimer_0x1372c0; // 0x1372c0 - g_ps2RecompiledFunctionTable[56516] = bhSetEventTimer_0x1372c0; // 0x137318 - g_ps2RecompiledFunctionTable[56534] = bhSetEventTimer_0x1372c0; // 0x137360 - g_ps2RecompiledFunctionTable[56552] = bhSetEventTimer_0x1372c0; // 0x1373a8 - g_ps2RecompiledFunctionTable[56578] = EasyDispMessage_0x137410; // 0x137410 - g_ps2RecompiledFunctionTable[56598] = EasyDispMessage_0x137410; // 0x137460 - g_ps2RecompiledFunctionTable[56603] = EasyDispMessage_0x137410; // 0x137474 - g_ps2RecompiledFunctionTable[56605] = EasyDispMessage_0x137410; // 0x13747c - g_ps2RecompiledFunctionTable[56617] = EasyDispMessage_0x137410; // 0x1374ac - g_ps2RecompiledFunctionTable[56680] = EasyDispMessage_0x137410; // 0x1375a8 - g_ps2RecompiledFunctionTable[56691] = EasyDispMessage_0x137410; // 0x1375d4 - g_ps2RecompiledFunctionTable[56702] = bhMainSequence_0x137600; // 0x137600 - g_ps2RecompiledFunctionTable[56713] = bhMainSequence_0x137600; // 0x13762c - g_ps2RecompiledFunctionTable[56722] = bhMainSequence_0x137600; // 0x137650 - g_ps2RecompiledFunctionTable[56726] = bhMainSequence_0x137600; // 0x137660 - g_ps2RecompiledFunctionTable[56736] = bhMainSequence_0x137600; // 0x137688 - g_ps2RecompiledFunctionTable[56752] = bhMainSequence_0x137600; // 0x1376c8 - g_ps2RecompiledFunctionTable[56754] = bhMainSequence_0x137600; // 0x1376d0 - g_ps2RecompiledFunctionTable[56756] = bhMainSequence_0x137600; // 0x1376d8 - g_ps2RecompiledFunctionTable[56758] = bhMainSequence_0x137600; // 0x1376e0 - g_ps2RecompiledFunctionTable[56760] = bhMainSequence_0x137600; // 0x1376e8 - g_ps2RecompiledFunctionTable[56776] = bhMainSequence_0x137600; // 0x137728 - g_ps2RecompiledFunctionTable[56778] = bhMainSequence_0x137600; // 0x137730 - g_ps2RecompiledFunctionTable[56780] = bhMainSequence_0x137600; // 0x137738 - g_ps2RecompiledFunctionTable[56794] = bhMainSequence_0x137600; // 0x137770 - g_ps2RecompiledFunctionTable[56802] = bhMainSequence_0x137600; // 0x137790 - g_ps2RecompiledFunctionTable[56806] = bhMainSequence_0x137600; // 0x1377a0 - g_ps2RecompiledFunctionTable[56820] = bhMainSequence_0x137600; // 0x1377d8 - g_ps2RecompiledFunctionTable[56828] = bhMainSequence_0x137600; // 0x1377f8 - g_ps2RecompiledFunctionTable[56830] = bhMainSequence_0x137600; // 0x137800 - g_ps2RecompiledFunctionTable[56832] = bhMainSequence_0x137600; // 0x137808 - g_ps2RecompiledFunctionTable[56837] = bhMainSequence_0x137600; // 0x13781c - g_ps2RecompiledFunctionTable[56856] = bhMainSequence_0x137600; // 0x137868 - g_ps2RecompiledFunctionTable[56865] = bhMainSequence_0x137600; // 0x13788c - g_ps2RecompiledFunctionTable[56875] = bhMainSequence_0x137600; // 0x1378b4 - g_ps2RecompiledFunctionTable[56888] = bhMainSequence_0x137600; // 0x1378e8 - g_ps2RecompiledFunctionTable[57324] = bhMainSequence_0x137600; // 0x137fb8 - g_ps2RecompiledFunctionTable[57333] = bhMainSequence_0x137600; // 0x137fdc - g_ps2RecompiledFunctionTable[57340] = bhMainSequence_0x137600; // 0x137ff8 - g_ps2RecompiledFunctionTable[57348] = bhMainSequence_0x137600; // 0x138018 - g_ps2RecompiledFunctionTable[57353] = bhMainSequence_0x137600; // 0x13802c - g_ps2RecompiledFunctionTable[57372] = bhMainSequence_0x137600; // 0x138078 - g_ps2RecompiledFunctionTable[57377] = bhMainSequence_0x137600; // 0x13808c - g_ps2RecompiledFunctionTable[57380] = bhMainSequence_0x137600; // 0x138098 - g_ps2RecompiledFunctionTable[57394] = bhAllDrawModel_0x1380d0; // 0x1380d0 - g_ps2RecompiledFunctionTable[57398] = bhAllDrawModel_0x1380d0; // 0x1380e0 - g_ps2RecompiledFunctionTable[57400] = bhAllDrawModel_0x1380d0; // 0x1380e8 - g_ps2RecompiledFunctionTable[57409] = bhAllDrawModel_0x1380d0; // 0x13810c - g_ps2RecompiledFunctionTable[57418] = bhAllDrawModel_0x1380d0; // 0x138130 - g_ps2RecompiledFunctionTable[57431] = bhAllDrawModel_0x1380d0; // 0x138164 - g_ps2RecompiledFunctionTable[57435] = bhAllDrawModel_0x1380d0; // 0x138174 - g_ps2RecompiledFunctionTable[57452] = bhAllDrawModel_0x1380d0; // 0x1381b8 - g_ps2RecompiledFunctionTable[57456] = bhAllDrawModel_0x1380d0; // 0x1381c8 - g_ps2RecompiledFunctionTable[57459] = bhAllDrawModel_0x1380d0; // 0x1381d4 - g_ps2RecompiledFunctionTable[57472] = bhAllDrawModel_0x1380d0; // 0x138208 - g_ps2RecompiledFunctionTable[57484] = bhAllDrawModel_0x1380d0; // 0x138238 - g_ps2RecompiledFunctionTable[57486] = bhAllDrawModel_0x1380d0; // 0x138240 - g_ps2RecompiledFunctionTable[57488] = bhAllDrawModel_0x1380d0; // 0x138248 - g_ps2RecompiledFunctionTable[57497] = bhAllDrawModel_0x1380d0; // 0x13826c - g_ps2RecompiledFunctionTable[57506] = bhAllDrawModel_0x1380d0; // 0x138290 - g_ps2RecompiledFunctionTable[57518] = bhAllDrawModel_0x1380d0; // 0x1382c0 - g_ps2RecompiledFunctionTable[57521] = bhAllDrawModel_0x1380d0; // 0x1382cc - g_ps2RecompiledFunctionTable[57523] = bhAllDrawModel_0x1380d0; // 0x1382d4 - g_ps2RecompiledFunctionTable[57531] = bhAllDrawModel_0x1380d0; // 0x1382f4 - g_ps2RecompiledFunctionTable[57534] = bhAllDrawModel_0x1380d0; // 0x138300 - g_ps2RecompiledFunctionTable[57576] = bhAllDrawModel_0x1380d0; // 0x1383a8 - g_ps2RecompiledFunctionTable[57581] = bhAllDrawModel_0x1380d0; // 0x1383bc - g_ps2RecompiledFunctionTable[57585] = bhAllDrawModel_0x1380d0; // 0x1383cc - g_ps2RecompiledFunctionTable[57598] = bhAllDrawModel_0x1380d0; // 0x138400 - g_ps2RecompiledFunctionTable[57602] = bhAllDrawModel_0x1380d0; // 0x138410 - g_ps2RecompiledFunctionTable[57604] = bhAllDrawModel_0x1380d0; // 0x138418 - g_ps2RecompiledFunctionTable[57606] = bhAllDrawModel_0x1380d0; // 0x138420 - g_ps2RecompiledFunctionTable[57608] = bhAllDrawModel_0x1380d0; // 0x138428 - g_ps2RecompiledFunctionTable[57614] = bhAllEasyDrawModel_0x138440; // 0x138440 - g_ps2RecompiledFunctionTable[57619] = bhAllEasyDrawModel_0x138440; // 0x138454 - g_ps2RecompiledFunctionTable[57621] = bhAllEasyDrawModel_0x138440; // 0x13845c - g_ps2RecompiledFunctionTable[57630] = bhAllEasyDrawModel_0x138440; // 0x138480 - g_ps2RecompiledFunctionTable[57639] = bhAllEasyDrawModel_0x138440; // 0x1384a4 - g_ps2RecompiledFunctionTable[57652] = bhAllEasyDrawModel_0x138440; // 0x1384d8 - g_ps2RecompiledFunctionTable[57656] = bhAllEasyDrawModel_0x138440; // 0x1384e8 - g_ps2RecompiledFunctionTable[57673] = bhAllEasyDrawModel_0x138440; // 0x13852c - g_ps2RecompiledFunctionTable[57677] = bhAllEasyDrawModel_0x138440; // 0x13853c - g_ps2RecompiledFunctionTable[57679] = bhAllEasyDrawModel_0x138440; // 0x138544 - g_ps2RecompiledFunctionTable[57681] = bhAllEasyDrawModel_0x138440; // 0x13854c - g_ps2RecompiledFunctionTable[57689] = bhAllEasyDrawModel_0x138440; // 0x13856c - g_ps2RecompiledFunctionTable[57694] = bhEtcMirrorDrawModel_0x138580; // 0x138580 - g_ps2RecompiledFunctionTable[57698] = bhEtcMirrorDrawModel_0x138580; // 0x138590 - g_ps2RecompiledFunctionTable[57701] = bhEtcMirrorDrawModel_0x138580; // 0x13859c - g_ps2RecompiledFunctionTable[57703] = bhEtcMirrorDrawModel_0x138580; // 0x1385a4 - g_ps2RecompiledFunctionTable[57712] = bhEtcMirrorDrawModel_0x138580; // 0x1385c8 - g_ps2RecompiledFunctionTable[57721] = bhEtcMirrorDrawModel_0x138580; // 0x1385ec - g_ps2RecompiledFunctionTable[57734] = bhEtcMirrorDrawModel_0x138580; // 0x138620 - g_ps2RecompiledFunctionTable[57738] = bhEtcMirrorDrawModel_0x138580; // 0x138630 - g_ps2RecompiledFunctionTable[57755] = bhEtcMirrorDrawModel_0x138580; // 0x138674 - g_ps2RecompiledFunctionTable[57759] = bhEtcMirrorDrawModel_0x138580; // 0x138684 - g_ps2RecompiledFunctionTable[57762] = bhEtcMirrorDrawModel_0x138580; // 0x138690 - g_ps2RecompiledFunctionTable[57764] = bhEtcMirrorDrawModel_0x138580; // 0x138698 - g_ps2RecompiledFunctionTable[57772] = bhEtcMirrorDrawModel_0x138580; // 0x1386b8 - g_ps2RecompiledFunctionTable[57778] = bhInitPlayer_0x1386d0; // 0x1386d0 - g_ps2RecompiledFunctionTable[57785] = bhInitPlayer_0x1386d0; // 0x1386ec - g_ps2RecompiledFunctionTable[57788] = bhInitPlayer_0x1386d0; // 0x1386f8 - g_ps2RecompiledFunctionTable[57796] = bhInitPlayer_0x1386d0; // 0x138718 - g_ps2RecompiledFunctionTable[57804] = bhInitPlayer_0x1386d0; // 0x138738 - g_ps2RecompiledFunctionTable[57812] = bhInitPlayer_0x1386d0; // 0x138758 - g_ps2RecompiledFunctionTable[57820] = bhInitPlayer_0x1386d0; // 0x138778 - g_ps2RecompiledFunctionTable[57828] = bhInitPlayer_0x1386d0; // 0x138798 - g_ps2RecompiledFunctionTable[57836] = bhInitPlayer_0x1386d0; // 0x1387b8 - g_ps2RecompiledFunctionTable[57844] = bhInitPlayer_0x1386d0; // 0x1387d8 - g_ps2RecompiledFunctionTable[57852] = bhInitPlayer_0x1386d0; // 0x1387f8 - g_ps2RecompiledFunctionTable[57860] = bhInitPlayer_0x1386d0; // 0x138818 - g_ps2RecompiledFunctionTable[57868] = bhInitPlayer_0x1386d0; // 0x138838 - g_ps2RecompiledFunctionTable[57974] = bhSetPlayer_0x1389e0; // 0x1389e0 - g_ps2RecompiledFunctionTable[58209] = bhSetPlayer_0x1389e0; // 0x138d8c - g_ps2RecompiledFunctionTable[58288] = bhSetPlayer_0x1389e0; // 0x138ec8 - g_ps2RecompiledFunctionTable[58368] = bhSetPlayer_0x1389e0; // 0x139008 - g_ps2RecompiledFunctionTable[58376] = bhSetPlayer_0x1389e0; // 0x139028 - g_ps2RecompiledFunctionTable[58471] = bhSetPlayer_0x1389e0; // 0x1391a4 - g_ps2RecompiledFunctionTable[58477] = bhSetPlayer_0x1389e0; // 0x1391bc - g_ps2RecompiledFunctionTable[58479] = bhSetPlayer_0x1389e0; // 0x1391c4 - g_ps2RecompiledFunctionTable[58481] = bhSetPlayer_0x1389e0; // 0x1391cc - g_ps2RecompiledFunctionTable[58483] = bhSetPlayer_0x1389e0; // 0x1391d4 - g_ps2RecompiledFunctionTable[58486] = bhSetPlayer_0x1389e0; // 0x1391e0 - g_ps2RecompiledFunctionTable[58488] = bhSetPlayer_0x1389e0; // 0x1391e8 - g_ps2RecompiledFunctionTable[58506] = bhInitRoomChangePlayer_0x139230; // 0x139230 - g_ps2RecompiledFunctionTable[58692] = bhInitRoomChangePlayer_0x139230; // 0x139518 - g_ps2RecompiledFunctionTable[58700] = bhInitRoomChangePlayer_0x139230; // 0x139538 - g_ps2RecompiledFunctionTable[58767] = bhInitRoomChangePlayer_0x139230; // 0x139644 - g_ps2RecompiledFunctionTable[58773] = bhInitRoomChangePlayer_0x139230; // 0x13965c - g_ps2RecompiledFunctionTable[58775] = bhInitRoomChangePlayer_0x139230; // 0x139664 - g_ps2RecompiledFunctionTable[58777] = bhInitRoomChangePlayer_0x139230; // 0x13966c - g_ps2RecompiledFunctionTable[58791] = bhInitRoomChangePlayer_0x139230; // 0x1396a4 - g_ps2RecompiledFunctionTable[58810] = bhResetPlayer_0x1396f0; // 0x1396f0 - g_ps2RecompiledFunctionTable[58880] = bhResetPlayer_0x1396f0; // 0x139808 - g_ps2RecompiledFunctionTable[58959] = bhResetPlayer_0x1396f0; // 0x139944 - g_ps2RecompiledFunctionTable[59087] = bhResetPlayer_0x1396f0; // 0x139b44 - g_ps2RecompiledFunctionTable[59102] = bhResetPlayer_0x1396f0; // 0x139b80 - g_ps2RecompiledFunctionTable[59104] = bhResetPlayer_0x1396f0; // 0x139b88 - g_ps2RecompiledFunctionTable[59122] = bhCheckMothEgg_0x139bd0; // 0x139bd0 - g_ps2RecompiledFunctionTable[59143] = bhCheckMothEgg_0x139bd0; // 0x139c24 - g_ps2RecompiledFunctionTable[59155] = bhCheckMothEgg_0x139bd0; // 0x139c54 - g_ps2RecompiledFunctionTable[59167] = bhCheckMothEgg_0x139bd0; // 0x139c84 - g_ps2RecompiledFunctionTable[59170] = bhCheckSubPack_0x139c90; // 0x139c90 - g_ps2RecompiledFunctionTable[59188] = bhCheckSubPack_0x139c90; // 0x139cd8 - g_ps2RecompiledFunctionTable[59208] = bhCheckSubPack_0x139c90; // 0x139d28 - g_ps2RecompiledFunctionTable[59228] = bhCheckSubPack_0x139c90; // 0x139d78 - g_ps2RecompiledFunctionTable[59250] = bhStandPlayerMotion_0x139dd0; // 0x139dd0 - g_ps2RecompiledFunctionTable[59363] = bhStandPlayerMotion_0x139dd0; // 0x139f94 - g_ps2RecompiledFunctionTable[59366] = bhStandPlayerMotion_0x139dd0; // 0x139fa0 - g_ps2RecompiledFunctionTable[59370] = bhKaidanPlayerMotion_0x139fb0; // 0x139fb0 - g_ps2RecompiledFunctionTable[59387] = bhKaidanPlayerMotion_0x139fb0; // 0x139ff4 - g_ps2RecompiledFunctionTable[59486] = bhKaidanPlayerMotion_0x139fb0; // 0x13a180 - g_ps2RecompiledFunctionTable[59494] = bhFixPositionXYZ_0x13a1a0; // 0x13a1a0 - g_ps2RecompiledFunctionTable[59501] = bhFixPositionXYZ_0x13a1a0; // 0x13a1bc - g_ps2RecompiledFunctionTable[59518] = bhCheckPlayerKegaMotion_0x13a200; // 0x13a200 - g_ps2RecompiledFunctionTable[59612] = bhCheckPlayerKegaMotion_0x13a200; // 0x13a378 - g_ps2RecompiledFunctionTable[59626] = bhCheckEvtTimer_0x13a3b0; // 0x13a3b0 - g_ps2RecompiledFunctionTable[59674] = bhCheckEvtTimer_0x13a3b0; // 0x13a470 - g_ps2RecompiledFunctionTable[59703] = bhCheckEvtTimer_0x13a3b0; // 0x13a4e4 - g_ps2RecompiledFunctionTable[59712] = bhCheckEvtTimer_0x13a3b0; // 0x13a508 - g_ps2RecompiledFunctionTable[59717] = bhCheckEvtTimer_0x13a3b0; // 0x13a51c - g_ps2RecompiledFunctionTable[59767] = bhCheckEvtTimer_0x13a3b0; // 0x13a5e4 - g_ps2RecompiledFunctionTable[59772] = bhCheckEvtTimer_0x13a3b0; // 0x13a5f8 - g_ps2RecompiledFunctionTable[59776] = bhCheckEvtTimer_0x13a3b0; // 0x13a608 - g_ps2RecompiledFunctionTable[59824] = bhCheckEvtTimer_0x13a3b0; // 0x13a6c8 - g_ps2RecompiledFunctionTable[59830] = bhControlPlayer_0x13a6e0; // 0x13a6e0 - g_ps2RecompiledFunctionTable[59831] = bhControlPlayer_0x13a6e0; // 0x13a6e4 - g_ps2RecompiledFunctionTable[59832] = bhControlPlayer_0x13a6e0; // 0x13a6e8 - g_ps2RecompiledFunctionTable[59833] = bhControlPlayer_0x13a6e0; // 0x13a6ec - g_ps2RecompiledFunctionTable[59834] = bhControlPlayer_0x13a6e0; // 0x13a6f0 - g_ps2RecompiledFunctionTable[59835] = bhControlPlayer_0x13a6e0; // 0x13a6f4 - g_ps2RecompiledFunctionTable[59836] = bhControlPlayer_0x13a6e0; // 0x13a6f8 - g_ps2RecompiledFunctionTable[59837] = bhControlPlayer_0x13a6e0; // 0x13a6fc - g_ps2RecompiledFunctionTable[59838] = bhControlPlayer_0x13a6e0; // 0x13a700 - g_ps2RecompiledFunctionTable[59839] = bhControlPlayer_0x13a6e0; // 0x13a704 - g_ps2RecompiledFunctionTable[59840] = bhControlPlayer_0x13a6e0; // 0x13a708 - g_ps2RecompiledFunctionTable[59841] = bhControlPlayer_0x13a6e0; // 0x13a70c - g_ps2RecompiledFunctionTable[59842] = bhControlPlayer_0x13a6e0; // 0x13a710 - g_ps2RecompiledFunctionTable[59843] = bhControlPlayer_0x13a6e0; // 0x13a714 - g_ps2RecompiledFunctionTable[59844] = bhControlPlayer_0x13a6e0; // 0x13a718 - g_ps2RecompiledFunctionTable[59845] = bhControlPlayer_0x13a6e0; // 0x13a71c - g_ps2RecompiledFunctionTable[59846] = bhControlPlayer_0x13a6e0; // 0x13a720 - g_ps2RecompiledFunctionTable[59847] = bhControlPlayer_0x13a6e0; // 0x13a724 - g_ps2RecompiledFunctionTable[59848] = bhControlPlayer_0x13a6e0; // 0x13a728 - g_ps2RecompiledFunctionTable[59849] = bhControlPlayer_0x13a6e0; // 0x13a72c - g_ps2RecompiledFunctionTable[59850] = bhControlPlayer_0x13a6e0; // 0x13a730 - g_ps2RecompiledFunctionTable[59851] = bhControlPlayer_0x13a6e0; // 0x13a734 - g_ps2RecompiledFunctionTable[59852] = bhControlPlayer_0x13a6e0; // 0x13a738 - g_ps2RecompiledFunctionTable[59853] = bhControlPlayer_0x13a6e0; // 0x13a73c - g_ps2RecompiledFunctionTable[59854] = bhControlPlayer_0x13a6e0; // 0x13a740 - g_ps2RecompiledFunctionTable[59855] = bhControlPlayer_0x13a6e0; // 0x13a744 - g_ps2RecompiledFunctionTable[59856] = bhControlPlayer_0x13a6e0; // 0x13a748 - g_ps2RecompiledFunctionTable[59857] = bhControlPlayer_0x13a6e0; // 0x13a74c - g_ps2RecompiledFunctionTable[59858] = bhControlPlayer_0x13a6e0; // 0x13a750 - g_ps2RecompiledFunctionTable[59859] = bhControlPlayer_0x13a6e0; // 0x13a754 - g_ps2RecompiledFunctionTable[59860] = bhControlPlayer_0x13a6e0; // 0x13a758 - g_ps2RecompiledFunctionTable[59861] = bhControlPlayer_0x13a6e0; // 0x13a75c - g_ps2RecompiledFunctionTable[59862] = bhControlPlayer_0x13a6e0; // 0x13a760 - g_ps2RecompiledFunctionTable[59863] = bhControlPlayer_0x13a6e0; // 0x13a764 - g_ps2RecompiledFunctionTable[59864] = bhControlPlayer_0x13a6e0; // 0x13a768 - g_ps2RecompiledFunctionTable[59865] = bhControlPlayer_0x13a6e0; // 0x13a76c - g_ps2RecompiledFunctionTable[59866] = bhControlPlayer_0x13a6e0; // 0x13a770 - g_ps2RecompiledFunctionTable[59867] = bhControlPlayer_0x13a6e0; // 0x13a774 - g_ps2RecompiledFunctionTable[59868] = bhControlPlayer_0x13a6e0; // 0x13a778 - g_ps2RecompiledFunctionTable[59869] = bhControlPlayer_0x13a6e0; // 0x13a77c - g_ps2RecompiledFunctionTable[59870] = bhControlPlayer_0x13a6e0; // 0x13a780 - g_ps2RecompiledFunctionTable[59871] = bhControlPlayer_0x13a6e0; // 0x13a784 - g_ps2RecompiledFunctionTable[59872] = bhControlPlayer_0x13a6e0; // 0x13a788 - g_ps2RecompiledFunctionTable[59873] = bhControlPlayer_0x13a6e0; // 0x13a78c - g_ps2RecompiledFunctionTable[59874] = bhControlPlayer_0x13a6e0; // 0x13a790 - g_ps2RecompiledFunctionTable[59875] = bhControlPlayer_0x13a6e0; // 0x13a794 - g_ps2RecompiledFunctionTable[59876] = bhControlPlayer_0x13a6e0; // 0x13a798 - g_ps2RecompiledFunctionTable[59877] = bhControlPlayer_0x13a6e0; // 0x13a79c - g_ps2RecompiledFunctionTable[59878] = bhControlPlayer_0x13a6e0; // 0x13a7a0 - g_ps2RecompiledFunctionTable[59879] = bhControlPlayer_0x13a6e0; // 0x13a7a4 - g_ps2RecompiledFunctionTable[59880] = bhControlPlayer_0x13a6e0; // 0x13a7a8 - g_ps2RecompiledFunctionTable[59881] = bhControlPlayer_0x13a6e0; // 0x13a7ac - g_ps2RecompiledFunctionTable[59882] = bhControlPlayer_0x13a6e0; // 0x13a7b0 - g_ps2RecompiledFunctionTable[59883] = bhControlPlayer_0x13a6e0; // 0x13a7b4 - g_ps2RecompiledFunctionTable[59884] = bhControlPlayer_0x13a6e0; // 0x13a7b8 - g_ps2RecompiledFunctionTable[59885] = bhControlPlayer_0x13a6e0; // 0x13a7bc - g_ps2RecompiledFunctionTable[59886] = bhControlPlayer_0x13a6e0; // 0x13a7c0 - g_ps2RecompiledFunctionTable[59887] = bhControlPlayer_0x13a6e0; // 0x13a7c4 - g_ps2RecompiledFunctionTable[59888] = bhControlPlayer_0x13a6e0; // 0x13a7c8 - g_ps2RecompiledFunctionTable[59889] = bhControlPlayer_0x13a6e0; // 0x13a7cc - g_ps2RecompiledFunctionTable[59890] = bhControlPlayer_0x13a6e0; // 0x13a7d0 - g_ps2RecompiledFunctionTable[59891] = bhControlPlayer_0x13a6e0; // 0x13a7d4 - g_ps2RecompiledFunctionTable[59892] = bhControlPlayer_0x13a6e0; // 0x13a7d8 - g_ps2RecompiledFunctionTable[59893] = bhControlPlayer_0x13a6e0; // 0x13a7dc - g_ps2RecompiledFunctionTable[59894] = bhControlPlayer_0x13a6e0; // 0x13a7e0 - g_ps2RecompiledFunctionTable[59895] = bhControlPlayer_0x13a6e0; // 0x13a7e4 - g_ps2RecompiledFunctionTable[59896] = bhControlPlayer_0x13a6e0; // 0x13a7e8 - g_ps2RecompiledFunctionTable[59897] = bhControlPlayer_0x13a6e0; // 0x13a7ec - g_ps2RecompiledFunctionTable[59898] = bhControlPlayer_0x13a6e0; // 0x13a7f0 - g_ps2RecompiledFunctionTable[59899] = bhControlPlayer_0x13a6e0; // 0x13a7f4 - g_ps2RecompiledFunctionTable[59900] = bhControlPlayer_0x13a6e0; // 0x13a7f8 - g_ps2RecompiledFunctionTable[59901] = bhControlPlayer_0x13a6e0; // 0x13a7fc - g_ps2RecompiledFunctionTable[59902] = bhControlPlayer_0x13a6e0; // 0x13a800 - g_ps2RecompiledFunctionTable[59903] = bhControlPlayer_0x13a6e0; // 0x13a804 - g_ps2RecompiledFunctionTable[59904] = bhControlPlayer_0x13a6e0; // 0x13a808 - g_ps2RecompiledFunctionTable[59905] = bhControlPlayer_0x13a6e0; // 0x13a80c - g_ps2RecompiledFunctionTable[59906] = bhControlPlayer_0x13a6e0; // 0x13a810 - g_ps2RecompiledFunctionTable[59907] = bhControlPlayer_0x13a6e0; // 0x13a814 - g_ps2RecompiledFunctionTable[59908] = bhControlPlayer_0x13a6e0; // 0x13a818 - g_ps2RecompiledFunctionTable[59909] = bhControlPlayer_0x13a6e0; // 0x13a81c - g_ps2RecompiledFunctionTable[59910] = bhControlPlayer_0x13a6e0; // 0x13a820 - g_ps2RecompiledFunctionTable[59911] = bhControlPlayer_0x13a6e0; // 0x13a824 - g_ps2RecompiledFunctionTable[59912] = bhControlPlayer_0x13a6e0; // 0x13a828 - g_ps2RecompiledFunctionTable[59913] = bhControlPlayer_0x13a6e0; // 0x13a82c - g_ps2RecompiledFunctionTable[59914] = bhControlPlayer_0x13a6e0; // 0x13a830 - g_ps2RecompiledFunctionTable[59915] = bhControlPlayer_0x13a6e0; // 0x13a834 - g_ps2RecompiledFunctionTable[59916] = bhControlPlayer_0x13a6e0; // 0x13a838 - g_ps2RecompiledFunctionTable[59917] = bhControlPlayer_0x13a6e0; // 0x13a83c - g_ps2RecompiledFunctionTable[59918] = bhControlPlayer_0x13a6e0; // 0x13a840 - g_ps2RecompiledFunctionTable[59919] = bhControlPlayer_0x13a6e0; // 0x13a844 - g_ps2RecompiledFunctionTable[59920] = bhControlPlayer_0x13a6e0; // 0x13a848 - g_ps2RecompiledFunctionTable[59921] = bhControlPlayer_0x13a6e0; // 0x13a84c - g_ps2RecompiledFunctionTable[59922] = bhControlPlayer_0x13a6e0; // 0x13a850 - g_ps2RecompiledFunctionTable[59923] = bhControlPlayer_0x13a6e0; // 0x13a854 - g_ps2RecompiledFunctionTable[59924] = bhControlPlayer_0x13a6e0; // 0x13a858 - g_ps2RecompiledFunctionTable[59925] = bhControlPlayer_0x13a6e0; // 0x13a85c - g_ps2RecompiledFunctionTable[59926] = bhControlPlayer_0x13a6e0; // 0x13a860 - g_ps2RecompiledFunctionTable[59927] = bhControlPlayer_0x13a6e0; // 0x13a864 - g_ps2RecompiledFunctionTable[59928] = bhControlPlayer_0x13a6e0; // 0x13a868 - g_ps2RecompiledFunctionTable[59929] = bhControlPlayer_0x13a6e0; // 0x13a86c - g_ps2RecompiledFunctionTable[59930] = bhControlPlayer_0x13a6e0; // 0x13a870 - g_ps2RecompiledFunctionTable[59931] = bhControlPlayer_0x13a6e0; // 0x13a874 - g_ps2RecompiledFunctionTable[59932] = bhControlPlayer_0x13a6e0; // 0x13a878 - g_ps2RecompiledFunctionTable[59933] = bhControlPlayer_0x13a6e0; // 0x13a87c - g_ps2RecompiledFunctionTable[59934] = bhControlPlayer_0x13a6e0; // 0x13a880 - g_ps2RecompiledFunctionTable[59935] = bhControlPlayer_0x13a6e0; // 0x13a884 - g_ps2RecompiledFunctionTable[59936] = bhControlPlayer_0x13a6e0; // 0x13a888 - g_ps2RecompiledFunctionTable[59937] = bhControlPlayer_0x13a6e0; // 0x13a88c - g_ps2RecompiledFunctionTable[59938] = bhControlPlayer_0x13a6e0; // 0x13a890 - g_ps2RecompiledFunctionTable[59939] = bhControlPlayer_0x13a6e0; // 0x13a894 - g_ps2RecompiledFunctionTable[59940] = bhControlPlayer_0x13a6e0; // 0x13a898 - g_ps2RecompiledFunctionTable[59941] = bhControlPlayer_0x13a6e0; // 0x13a89c - g_ps2RecompiledFunctionTable[59942] = bhControlPlayer_0x13a6e0; // 0x13a8a0 - g_ps2RecompiledFunctionTable[59943] = bhControlPlayer_0x13a6e0; // 0x13a8a4 - g_ps2RecompiledFunctionTable[59944] = bhControlPlayer_0x13a6e0; // 0x13a8a8 - g_ps2RecompiledFunctionTable[59945] = bhControlPlayer_0x13a6e0; // 0x13a8ac - g_ps2RecompiledFunctionTable[59946] = bhControlPlayer_0x13a6e0; // 0x13a8b0 - g_ps2RecompiledFunctionTable[59947] = bhControlPlayer_0x13a6e0; // 0x13a8b4 - g_ps2RecompiledFunctionTable[59948] = bhControlPlayer_0x13a6e0; // 0x13a8b8 - g_ps2RecompiledFunctionTable[59949] = bhControlPlayer_0x13a6e0; // 0x13a8bc - g_ps2RecompiledFunctionTable[59950] = bhControlPlayer_0x13a6e0; // 0x13a8c0 - g_ps2RecompiledFunctionTable[59951] = bhControlPlayer_0x13a6e0; // 0x13a8c4 - g_ps2RecompiledFunctionTable[59952] = bhControlPlayer_0x13a6e0; // 0x13a8c8 - g_ps2RecompiledFunctionTable[59953] = bhControlPlayer_0x13a6e0; // 0x13a8cc - g_ps2RecompiledFunctionTable[59954] = bhControlPlayer_0x13a6e0; // 0x13a8d0 - g_ps2RecompiledFunctionTable[59955] = bhControlPlayer_0x13a6e0; // 0x13a8d4 - g_ps2RecompiledFunctionTable[59956] = bhControlPlayer_0x13a6e0; // 0x13a8d8 - g_ps2RecompiledFunctionTable[59957] = bhControlPlayer_0x13a6e0; // 0x13a8dc - g_ps2RecompiledFunctionTable[59958] = bhControlPlayer_0x13a6e0; // 0x13a8e0 - g_ps2RecompiledFunctionTable[59959] = bhControlPlayer_0x13a6e0; // 0x13a8e4 - g_ps2RecompiledFunctionTable[59960] = bhControlPlayer_0x13a6e0; // 0x13a8e8 - g_ps2RecompiledFunctionTable[59961] = bhControlPlayer_0x13a6e0; // 0x13a8ec - g_ps2RecompiledFunctionTable[59962] = bhControlPlayer_0x13a6e0; // 0x13a8f0 - g_ps2RecompiledFunctionTable[59963] = bhControlPlayer_0x13a6e0; // 0x13a8f4 - g_ps2RecompiledFunctionTable[59964] = bhControlPlayer_0x13a6e0; // 0x13a8f8 - g_ps2RecompiledFunctionTable[59965] = bhControlPlayer_0x13a6e0; // 0x13a8fc - g_ps2RecompiledFunctionTable[59966] = bhControlPlayer_0x13a6e0; // 0x13a900 - g_ps2RecompiledFunctionTable[59967] = bhControlPlayer_0x13a6e0; // 0x13a904 - g_ps2RecompiledFunctionTable[59968] = bhControlPlayer_0x13a6e0; // 0x13a908 - g_ps2RecompiledFunctionTable[59969] = bhControlPlayer_0x13a6e0; // 0x13a90c - g_ps2RecompiledFunctionTable[59970] = bhControlPlayer_0x13a6e0; // 0x13a910 - g_ps2RecompiledFunctionTable[59971] = bhControlPlayer_0x13a6e0; // 0x13a914 - g_ps2RecompiledFunctionTable[59972] = bhControlPlayer_0x13a6e0; // 0x13a918 - g_ps2RecompiledFunctionTable[59973] = bhControlPlayer_0x13a6e0; // 0x13a91c - g_ps2RecompiledFunctionTable[59974] = bhControlPlayer_0x13a6e0; // 0x13a920 - g_ps2RecompiledFunctionTable[59975] = bhControlPlayer_0x13a6e0; // 0x13a924 - g_ps2RecompiledFunctionTable[59976] = bhControlPlayer_0x13a6e0; // 0x13a928 - g_ps2RecompiledFunctionTable[59977] = bhControlPlayer_0x13a6e0; // 0x13a92c - g_ps2RecompiledFunctionTable[59978] = bhControlPlayer_0x13a6e0; // 0x13a930 - g_ps2RecompiledFunctionTable[59979] = bhControlPlayer_0x13a6e0; // 0x13a934 - g_ps2RecompiledFunctionTable[59980] = bhControlPlayer_0x13a6e0; // 0x13a938 - g_ps2RecompiledFunctionTable[59981] = bhControlPlayer_0x13a6e0; // 0x13a93c - g_ps2RecompiledFunctionTable[59982] = bhControlPlayer_0x13a6e0; // 0x13a940 - g_ps2RecompiledFunctionTable[59983] = bhControlPlayer_0x13a6e0; // 0x13a944 - g_ps2RecompiledFunctionTable[59984] = bhControlPlayer_0x13a6e0; // 0x13a948 - g_ps2RecompiledFunctionTable[59985] = bhControlPlayer_0x13a6e0; // 0x13a94c - g_ps2RecompiledFunctionTable[59986] = bhControlPlayer_0x13a6e0; // 0x13a950 - g_ps2RecompiledFunctionTable[59987] = bhControlPlayer_0x13a6e0; // 0x13a954 - g_ps2RecompiledFunctionTable[59988] = bhControlPlayer_0x13a6e0; // 0x13a958 - g_ps2RecompiledFunctionTable[59989] = bhControlPlayer_0x13a6e0; // 0x13a95c - g_ps2RecompiledFunctionTable[59990] = bhControlPlayer_0x13a6e0; // 0x13a960 - g_ps2RecompiledFunctionTable[59991] = bhControlPlayer_0x13a6e0; // 0x13a964 - g_ps2RecompiledFunctionTable[59992] = bhControlPlayer_0x13a6e0; // 0x13a968 - g_ps2RecompiledFunctionTable[59993] = bhControlPlayer_0x13a6e0; // 0x13a96c - g_ps2RecompiledFunctionTable[59994] = bhControlPlayer_0x13a6e0; // 0x13a970 - g_ps2RecompiledFunctionTable[59995] = bhControlPlayer_0x13a6e0; // 0x13a974 - g_ps2RecompiledFunctionTable[59996] = bhControlPlayer_0x13a6e0; // 0x13a978 - g_ps2RecompiledFunctionTable[59997] = bhControlPlayer_0x13a6e0; // 0x13a97c - g_ps2RecompiledFunctionTable[59998] = bhControlPlayer_0x13a6e0; // 0x13a980 - g_ps2RecompiledFunctionTable[59999] = bhControlPlayer_0x13a6e0; // 0x13a984 - g_ps2RecompiledFunctionTable[60000] = bhControlPlayer_0x13a6e0; // 0x13a988 - g_ps2RecompiledFunctionTable[60001] = bhControlPlayer_0x13a6e0; // 0x13a98c - g_ps2RecompiledFunctionTable[60002] = bhControlPlayer_0x13a6e0; // 0x13a990 - g_ps2RecompiledFunctionTable[60003] = bhControlPlayer_0x13a6e0; // 0x13a994 - g_ps2RecompiledFunctionTable[60004] = bhControlPlayer_0x13a6e0; // 0x13a998 - g_ps2RecompiledFunctionTable[60005] = bhControlPlayer_0x13a6e0; // 0x13a99c - g_ps2RecompiledFunctionTable[60006] = bhControlPlayer_0x13a6e0; // 0x13a9a0 - g_ps2RecompiledFunctionTable[60007] = bhControlPlayer_0x13a6e0; // 0x13a9a4 - g_ps2RecompiledFunctionTable[60008] = bhControlPlayer_0x13a6e0; // 0x13a9a8 - g_ps2RecompiledFunctionTable[60009] = bhControlPlayer_0x13a6e0; // 0x13a9ac - g_ps2RecompiledFunctionTable[60010] = bhControlPlayer_0x13a6e0; // 0x13a9b0 - g_ps2RecompiledFunctionTable[60011] = bhControlPlayer_0x13a6e0; // 0x13a9b4 - g_ps2RecompiledFunctionTable[60012] = bhControlPlayer_0x13a6e0; // 0x13a9b8 - g_ps2RecompiledFunctionTable[60013] = bhControlPlayer_0x13a6e0; // 0x13a9bc - g_ps2RecompiledFunctionTable[60014] = bhControlPlayer_0x13a6e0; // 0x13a9c0 - g_ps2RecompiledFunctionTable[60015] = bhControlPlayer_0x13a6e0; // 0x13a9c4 - g_ps2RecompiledFunctionTable[60016] = bhControlPlayer_0x13a6e0; // 0x13a9c8 - g_ps2RecompiledFunctionTable[60017] = bhControlPlayer_0x13a6e0; // 0x13a9cc - g_ps2RecompiledFunctionTable[60018] = bhControlPlayer_0x13a6e0; // 0x13a9d0 - g_ps2RecompiledFunctionTable[60019] = bhControlPlayer_0x13a6e0; // 0x13a9d4 - g_ps2RecompiledFunctionTable[60020] = bhControlPlayer_0x13a6e0; // 0x13a9d8 - g_ps2RecompiledFunctionTable[60021] = bhControlPlayer_0x13a6e0; // 0x13a9dc - g_ps2RecompiledFunctionTable[60022] = bhControlPlayer_0x13a6e0; // 0x13a9e0 - g_ps2RecompiledFunctionTable[60023] = bhControlPlayer_0x13a6e0; // 0x13a9e4 - g_ps2RecompiledFunctionTable[60024] = bhControlPlayer_0x13a6e0; // 0x13a9e8 - g_ps2RecompiledFunctionTable[60025] = bhControlPlayer_0x13a6e0; // 0x13a9ec - g_ps2RecompiledFunctionTable[60026] = bhControlPlayer_0x13a6e0; // 0x13a9f0 - g_ps2RecompiledFunctionTable[60027] = bhControlPlayer_0x13a6e0; // 0x13a9f4 - g_ps2RecompiledFunctionTable[60028] = bhControlPlayer_0x13a6e0; // 0x13a9f8 - g_ps2RecompiledFunctionTable[60029] = bhControlPlayer_0x13a6e0; // 0x13a9fc - g_ps2RecompiledFunctionTable[60030] = bhControlPlayer_0x13a6e0; // 0x13aa00 - g_ps2RecompiledFunctionTable[60031] = bhControlPlayer_0x13a6e0; // 0x13aa04 - g_ps2RecompiledFunctionTable[60032] = bhControlPlayer_0x13a6e0; // 0x13aa08 - g_ps2RecompiledFunctionTable[60033] = bhControlPlayer_0x13a6e0; // 0x13aa0c - g_ps2RecompiledFunctionTable[60034] = bhControlPlayer_0x13a6e0; // 0x13aa10 - g_ps2RecompiledFunctionTable[60035] = bhControlPlayer_0x13a6e0; // 0x13aa14 - g_ps2RecompiledFunctionTable[60036] = bhControlPlayer_0x13a6e0; // 0x13aa18 - g_ps2RecompiledFunctionTable[60037] = bhControlPlayer_0x13a6e0; // 0x13aa1c - g_ps2RecompiledFunctionTable[60038] = bhControlPlayer_0x13a6e0; // 0x13aa20 - g_ps2RecompiledFunctionTable[60039] = bhControlPlayer_0x13a6e0; // 0x13aa24 - g_ps2RecompiledFunctionTable[60040] = bhControlPlayer_0x13a6e0; // 0x13aa28 - g_ps2RecompiledFunctionTable[60041] = bhControlPlayer_0x13a6e0; // 0x13aa2c - g_ps2RecompiledFunctionTable[60042] = bhControlPlayer_0x13a6e0; // 0x13aa30 - g_ps2RecompiledFunctionTable[60043] = bhControlPlayer_0x13a6e0; // 0x13aa34 - g_ps2RecompiledFunctionTable[60044] = bhControlPlayer_0x13a6e0; // 0x13aa38 - g_ps2RecompiledFunctionTable[60045] = bhControlPlayer_0x13a6e0; // 0x13aa3c - g_ps2RecompiledFunctionTable[60046] = bhControlPlayer_0x13a6e0; // 0x13aa40 - g_ps2RecompiledFunctionTable[60047] = bhControlPlayer_0x13a6e0; // 0x13aa44 - g_ps2RecompiledFunctionTable[60048] = bhControlPlayer_0x13a6e0; // 0x13aa48 - g_ps2RecompiledFunctionTable[60049] = bhControlPlayer_0x13a6e0; // 0x13aa4c - g_ps2RecompiledFunctionTable[60050] = bhControlPlayer_0x13a6e0; // 0x13aa50 - g_ps2RecompiledFunctionTable[60051] = bhControlPlayer_0x13a6e0; // 0x13aa54 - g_ps2RecompiledFunctionTable[60052] = bhControlPlayer_0x13a6e0; // 0x13aa58 - g_ps2RecompiledFunctionTable[60053] = bhControlPlayer_0x13a6e0; // 0x13aa5c - g_ps2RecompiledFunctionTable[60054] = bhControlPlayer_0x13a6e0; // 0x13aa60 - g_ps2RecompiledFunctionTable[60055] = bhControlPlayer_0x13a6e0; // 0x13aa64 - g_ps2RecompiledFunctionTable[60056] = bhControlPlayer_0x13a6e0; // 0x13aa68 - g_ps2RecompiledFunctionTable[60057] = bhControlPlayer_0x13a6e0; // 0x13aa6c - g_ps2RecompiledFunctionTable[60058] = bhControlPlayer_0x13a6e0; // 0x13aa70 - g_ps2RecompiledFunctionTable[60059] = bhControlPlayer_0x13a6e0; // 0x13aa74 - g_ps2RecompiledFunctionTable[60060] = bhControlPlayer_0x13a6e0; // 0x13aa78 - g_ps2RecompiledFunctionTable[60061] = bhControlPlayer_0x13a6e0; // 0x13aa7c - g_ps2RecompiledFunctionTable[60062] = bhControlPlayer_0x13a6e0; // 0x13aa80 - g_ps2RecompiledFunctionTable[60063] = bhControlPlayer_0x13a6e0; // 0x13aa84 - g_ps2RecompiledFunctionTable[60064] = bhControlPlayer_0x13a6e0; // 0x13aa88 - g_ps2RecompiledFunctionTable[60065] = bhControlPlayer_0x13a6e0; // 0x13aa8c - g_ps2RecompiledFunctionTable[60066] = bhControlPlayer_0x13a6e0; // 0x13aa90 - g_ps2RecompiledFunctionTable[60067] = bhControlPlayer_0x13a6e0; // 0x13aa94 - g_ps2RecompiledFunctionTable[60068] = bhControlPlayer_0x13a6e0; // 0x13aa98 - g_ps2RecompiledFunctionTable[60069] = bhControlPlayer_0x13a6e0; // 0x13aa9c - g_ps2RecompiledFunctionTable[60070] = bhControlPlayer_0x13a6e0; // 0x13aaa0 - g_ps2RecompiledFunctionTable[60071] = bhControlPlayer_0x13a6e0; // 0x13aaa4 - g_ps2RecompiledFunctionTable[60072] = bhControlPlayer_0x13a6e0; // 0x13aaa8 - g_ps2RecompiledFunctionTable[60073] = bhControlPlayer_0x13a6e0; // 0x13aaac - g_ps2RecompiledFunctionTable[60074] = bhControlPlayer_0x13a6e0; // 0x13aab0 - g_ps2RecompiledFunctionTable[60075] = bhControlPlayer_0x13a6e0; // 0x13aab4 - g_ps2RecompiledFunctionTable[60076] = bhControlPlayer_0x13a6e0; // 0x13aab8 - g_ps2RecompiledFunctionTable[60077] = bhControlPlayer_0x13a6e0; // 0x13aabc - g_ps2RecompiledFunctionTable[60078] = bhControlPlayer_0x13a6e0; // 0x13aac0 - g_ps2RecompiledFunctionTable[60079] = bhControlPlayer_0x13a6e0; // 0x13aac4 - g_ps2RecompiledFunctionTable[60080] = bhControlPlayer_0x13a6e0; // 0x13aac8 - g_ps2RecompiledFunctionTable[60081] = bhControlPlayer_0x13a6e0; // 0x13aacc - g_ps2RecompiledFunctionTable[60082] = bhControlPlayer_0x13a6e0; // 0x13aad0 - g_ps2RecompiledFunctionTable[60083] = bhControlPlayer_0x13a6e0; // 0x13aad4 - g_ps2RecompiledFunctionTable[60084] = bhControlPlayer_0x13a6e0; // 0x13aad8 - g_ps2RecompiledFunctionTable[60085] = bhControlPlayer_0x13a6e0; // 0x13aadc - g_ps2RecompiledFunctionTable[60086] = bhControlPlayer_0x13a6e0; // 0x13aae0 - g_ps2RecompiledFunctionTable[60087] = bhControlPlayer_0x13a6e0; // 0x13aae4 - g_ps2RecompiledFunctionTable[60088] = bhControlPlayer_0x13a6e0; // 0x13aae8 - g_ps2RecompiledFunctionTable[60089] = bhControlPlayer_0x13a6e0; // 0x13aaec - g_ps2RecompiledFunctionTable[60090] = bhControlPlayer_0x13a6e0; // 0x13aaf0 - g_ps2RecompiledFunctionTable[60091] = bhControlPlayer_0x13a6e0; // 0x13aaf4 - g_ps2RecompiledFunctionTable[60092] = bhControlPlayer_0x13a6e0; // 0x13aaf8 - g_ps2RecompiledFunctionTable[60093] = bhControlPlayer_0x13a6e0; // 0x13aafc - g_ps2RecompiledFunctionTable[60094] = bhControlPlayer_0x13a6e0; // 0x13ab00 - g_ps2RecompiledFunctionTable[60095] = bhControlPlayer_0x13a6e0; // 0x13ab04 - g_ps2RecompiledFunctionTable[60096] = bhControlPlayer_0x13a6e0; // 0x13ab08 - g_ps2RecompiledFunctionTable[60097] = bhControlPlayer_0x13a6e0; // 0x13ab0c - g_ps2RecompiledFunctionTable[60098] = bhControlPlayer_0x13a6e0; // 0x13ab10 - g_ps2RecompiledFunctionTable[60099] = bhControlPlayer_0x13a6e0; // 0x13ab14 - g_ps2RecompiledFunctionTable[60100] = bhControlPlayer_0x13a6e0; // 0x13ab18 - g_ps2RecompiledFunctionTable[60101] = bhControlPlayer_0x13a6e0; // 0x13ab1c - g_ps2RecompiledFunctionTable[60102] = bhControlPlayer_0x13a6e0; // 0x13ab20 - g_ps2RecompiledFunctionTable[60103] = bhControlPlayer_0x13a6e0; // 0x13ab24 - g_ps2RecompiledFunctionTable[60104] = bhControlPlayer_0x13a6e0; // 0x13ab28 - g_ps2RecompiledFunctionTable[60105] = bhControlPlayer_0x13a6e0; // 0x13ab2c - g_ps2RecompiledFunctionTable[60106] = bhControlPlayer_0x13a6e0; // 0x13ab30 - g_ps2RecompiledFunctionTable[60107] = bhControlPlayer_0x13a6e0; // 0x13ab34 - g_ps2RecompiledFunctionTable[60108] = bhControlPlayer_0x13a6e0; // 0x13ab38 - g_ps2RecompiledFunctionTable[60109] = bhControlPlayer_0x13a6e0; // 0x13ab3c - g_ps2RecompiledFunctionTable[60110] = bhControlPlayer_0x13a6e0; // 0x13ab40 - g_ps2RecompiledFunctionTable[60111] = bhControlPlayer_0x13a6e0; // 0x13ab44 - g_ps2RecompiledFunctionTable[60112] = bhControlPlayer_0x13a6e0; // 0x13ab48 - g_ps2RecompiledFunctionTable[60113] = bhControlPlayer_0x13a6e0; // 0x13ab4c - g_ps2RecompiledFunctionTable[60114] = bhControlPlayer_0x13a6e0; // 0x13ab50 - g_ps2RecompiledFunctionTable[60115] = bhControlPlayer_0x13a6e0; // 0x13ab54 - g_ps2RecompiledFunctionTable[60116] = bhControlPlayer_0x13a6e0; // 0x13ab58 - g_ps2RecompiledFunctionTable[60117] = bhControlPlayer_0x13a6e0; // 0x13ab5c - g_ps2RecompiledFunctionTable[60118] = bhControlPlayer_0x13a6e0; // 0x13ab60 - g_ps2RecompiledFunctionTable[60119] = bhControlPlayer_0x13a6e0; // 0x13ab64 - g_ps2RecompiledFunctionTable[60120] = bhControlPlayer_0x13a6e0; // 0x13ab68 - g_ps2RecompiledFunctionTable[60121] = bhControlPlayer_0x13a6e0; // 0x13ab6c - g_ps2RecompiledFunctionTable[60122] = bhControlPlayer_0x13a6e0; // 0x13ab70 - g_ps2RecompiledFunctionTable[60123] = bhControlPlayer_0x13a6e0; // 0x13ab74 - g_ps2RecompiledFunctionTable[60124] = bhControlPlayer_0x13a6e0; // 0x13ab78 - g_ps2RecompiledFunctionTable[60125] = bhControlPlayer_0x13a6e0; // 0x13ab7c - g_ps2RecompiledFunctionTable[60126] = bhControlPlayer_0x13a6e0; // 0x13ab80 - g_ps2RecompiledFunctionTable[60127] = bhControlPlayer_0x13a6e0; // 0x13ab84 - g_ps2RecompiledFunctionTable[60128] = bhControlPlayer_0x13a6e0; // 0x13ab88 - g_ps2RecompiledFunctionTable[60129] = bhControlPlayer_0x13a6e0; // 0x13ab8c - g_ps2RecompiledFunctionTable[60130] = bhControlPlayer_0x13a6e0; // 0x13ab90 - g_ps2RecompiledFunctionTable[60131] = bhControlPlayer_0x13a6e0; // 0x13ab94 - g_ps2RecompiledFunctionTable[60132] = bhControlPlayer_0x13a6e0; // 0x13ab98 - g_ps2RecompiledFunctionTable[60133] = bhControlPlayer_0x13a6e0; // 0x13ab9c - g_ps2RecompiledFunctionTable[60134] = bhControlPlayer_0x13a6e0; // 0x13aba0 - g_ps2RecompiledFunctionTable[60135] = bhControlPlayer_0x13a6e0; // 0x13aba4 - g_ps2RecompiledFunctionTable[60136] = bhControlPlayer_0x13a6e0; // 0x13aba8 - g_ps2RecompiledFunctionTable[60137] = bhControlPlayer_0x13a6e0; // 0x13abac - g_ps2RecompiledFunctionTable[60138] = bhControlPlayer_0x13a6e0; // 0x13abb0 - g_ps2RecompiledFunctionTable[60139] = bhControlPlayer_0x13a6e0; // 0x13abb4 - g_ps2RecompiledFunctionTable[60140] = bhControlPlayer_0x13a6e0; // 0x13abb8 - g_ps2RecompiledFunctionTable[60141] = bhControlPlayer_0x13a6e0; // 0x13abbc - g_ps2RecompiledFunctionTable[60142] = bhControlPlayer_0x13a6e0; // 0x13abc0 - g_ps2RecompiledFunctionTable[60143] = bhControlPlayer_0x13a6e0; // 0x13abc4 - g_ps2RecompiledFunctionTable[60144] = bhControlPlayer_0x13a6e0; // 0x13abc8 - g_ps2RecompiledFunctionTable[60145] = bhControlPlayer_0x13a6e0; // 0x13abcc - g_ps2RecompiledFunctionTable[60146] = bhControlPlayer_0x13a6e0; // 0x13abd0 - g_ps2RecompiledFunctionTable[60147] = bhControlPlayer_0x13a6e0; // 0x13abd4 - g_ps2RecompiledFunctionTable[60148] = bhControlPlayer_0x13a6e0; // 0x13abd8 - g_ps2RecompiledFunctionTable[60149] = bhControlPlayer_0x13a6e0; // 0x13abdc - g_ps2RecompiledFunctionTable[60150] = bhControlPlayer_0x13a6e0; // 0x13abe0 - g_ps2RecompiledFunctionTable[60151] = bhControlPlayer_0x13a6e0; // 0x13abe4 - g_ps2RecompiledFunctionTable[60152] = bhControlPlayer_0x13a6e0; // 0x13abe8 - g_ps2RecompiledFunctionTable[60153] = bhControlPlayer_0x13a6e0; // 0x13abec - g_ps2RecompiledFunctionTable[60154] = bhControlPlayer_0x13a6e0; // 0x13abf0 - g_ps2RecompiledFunctionTable[60155] = bhControlPlayer_0x13a6e0; // 0x13abf4 - g_ps2RecompiledFunctionTable[60156] = bhControlPlayer_0x13a6e0; // 0x13abf8 - g_ps2RecompiledFunctionTable[60157] = bhControlPlayer_0x13a6e0; // 0x13abfc - g_ps2RecompiledFunctionTable[60158] = bhControlPlayer_0x13a6e0; // 0x13ac00 - g_ps2RecompiledFunctionTable[60159] = bhControlPlayer_0x13a6e0; // 0x13ac04 - g_ps2RecompiledFunctionTable[60160] = bhControlPlayer_0x13a6e0; // 0x13ac08 - g_ps2RecompiledFunctionTable[60161] = bhControlPlayer_0x13a6e0; // 0x13ac0c - g_ps2RecompiledFunctionTable[60162] = bhControlPlayer_0x13a6e0; // 0x13ac10 - g_ps2RecompiledFunctionTable[60163] = bhControlPlayer_0x13a6e0; // 0x13ac14 - g_ps2RecompiledFunctionTable[60164] = bhControlPlayer_0x13a6e0; // 0x13ac18 - g_ps2RecompiledFunctionTable[60165] = bhControlPlayer_0x13a6e0; // 0x13ac1c - g_ps2RecompiledFunctionTable[60166] = bhControlPlayer_0x13a6e0; // 0x13ac20 - g_ps2RecompiledFunctionTable[60167] = bhControlPlayer_0x13a6e0; // 0x13ac24 - g_ps2RecompiledFunctionTable[60168] = bhControlPlayer_0x13a6e0; // 0x13ac28 - g_ps2RecompiledFunctionTable[60169] = bhControlPlayer_0x13a6e0; // 0x13ac2c - g_ps2RecompiledFunctionTable[60170] = bhControlPlayer_0x13a6e0; // 0x13ac30 - g_ps2RecompiledFunctionTable[60171] = bhControlPlayer_0x13a6e0; // 0x13ac34 - g_ps2RecompiledFunctionTable[60172] = bhControlPlayer_0x13a6e0; // 0x13ac38 - g_ps2RecompiledFunctionTable[60173] = bhControlPlayer_0x13a6e0; // 0x13ac3c - g_ps2RecompiledFunctionTable[60174] = bhControlPlayer_0x13a6e0; // 0x13ac40 - g_ps2RecompiledFunctionTable[60175] = bhControlPlayer_0x13a6e0; // 0x13ac44 - g_ps2RecompiledFunctionTable[60176] = bhControlPlayer_0x13a6e0; // 0x13ac48 - g_ps2RecompiledFunctionTable[60177] = bhControlPlayer_0x13a6e0; // 0x13ac4c - g_ps2RecompiledFunctionTable[60178] = bhControlPlayer_0x13a6e0; // 0x13ac50 - g_ps2RecompiledFunctionTable[60179] = bhControlPlayer_0x13a6e0; // 0x13ac54 - g_ps2RecompiledFunctionTable[60180] = bhControlPlayer_0x13a6e0; // 0x13ac58 - g_ps2RecompiledFunctionTable[60181] = bhControlPlayer_0x13a6e0; // 0x13ac5c - g_ps2RecompiledFunctionTable[60182] = bhControlPlayer_0x13a6e0; // 0x13ac60 - g_ps2RecompiledFunctionTable[60183] = bhControlPlayer_0x13a6e0; // 0x13ac64 - g_ps2RecompiledFunctionTable[60184] = bhControlPlayer_0x13a6e0; // 0x13ac68 - g_ps2RecompiledFunctionTable[60185] = bhControlPlayer_0x13a6e0; // 0x13ac6c - g_ps2RecompiledFunctionTable[60186] = bhControlPlayer_0x13a6e0; // 0x13ac70 - g_ps2RecompiledFunctionTable[60187] = bhControlPlayer_0x13a6e0; // 0x13ac74 - g_ps2RecompiledFunctionTable[60188] = bhControlPlayer_0x13a6e0; // 0x13ac78 - g_ps2RecompiledFunctionTable[60189] = bhControlPlayer_0x13a6e0; // 0x13ac7c - g_ps2RecompiledFunctionTable[60190] = bhControlPlayer_0x13a6e0; // 0x13ac80 - g_ps2RecompiledFunctionTable[60191] = bhControlPlayer_0x13a6e0; // 0x13ac84 - g_ps2RecompiledFunctionTable[60192] = bhControlPlayer_0x13a6e0; // 0x13ac88 - g_ps2RecompiledFunctionTable[60193] = bhControlPlayer_0x13a6e0; // 0x13ac8c - g_ps2RecompiledFunctionTable[60194] = bhControlPlayer_0x13a6e0; // 0x13ac90 - g_ps2RecompiledFunctionTable[60195] = bhControlPlayer_0x13a6e0; // 0x13ac94 - g_ps2RecompiledFunctionTable[60196] = bhControlPlayer_0x13a6e0; // 0x13ac98 - g_ps2RecompiledFunctionTable[60197] = bhControlPlayer_0x13a6e0; // 0x13ac9c - g_ps2RecompiledFunctionTable[60198] = bhControlPlayer_0x13a6e0; // 0x13aca0 - g_ps2RecompiledFunctionTable[60199] = bhControlPlayer_0x13a6e0; // 0x13aca4 - g_ps2RecompiledFunctionTable[60200] = bhControlPlayer_0x13a6e0; // 0x13aca8 - g_ps2RecompiledFunctionTable[60201] = bhControlPlayer_0x13a6e0; // 0x13acac - g_ps2RecompiledFunctionTable[60202] = bhControlPlayer_0x13a6e0; // 0x13acb0 - g_ps2RecompiledFunctionTable[60203] = bhControlPlayer_0x13a6e0; // 0x13acb4 - g_ps2RecompiledFunctionTable[60204] = bhControlPlayer_0x13a6e0; // 0x13acb8 - g_ps2RecompiledFunctionTable[60205] = bhControlPlayer_0x13a6e0; // 0x13acbc - g_ps2RecompiledFunctionTable[60206] = bhControlPlayer_0x13a6e0; // 0x13acc0 - g_ps2RecompiledFunctionTable[60207] = bhControlPlayer_0x13a6e0; // 0x13acc4 - g_ps2RecompiledFunctionTable[60208] = bhControlPlayer_0x13a6e0; // 0x13acc8 - g_ps2RecompiledFunctionTable[60209] = bhControlPlayer_0x13a6e0; // 0x13accc - g_ps2RecompiledFunctionTable[60210] = bhControlPlayer_0x13a6e0; // 0x13acd0 - g_ps2RecompiledFunctionTable[60211] = bhControlPlayer_0x13a6e0; // 0x13acd4 - g_ps2RecompiledFunctionTable[60212] = bhControlPlayer_0x13a6e0; // 0x13acd8 - g_ps2RecompiledFunctionTable[60213] = bhControlPlayer_0x13a6e0; // 0x13acdc - g_ps2RecompiledFunctionTable[60214] = bhControlPlayer_0x13a6e0; // 0x13ace0 - g_ps2RecompiledFunctionTable[60215] = bhControlPlayer_0x13a6e0; // 0x13ace4 - g_ps2RecompiledFunctionTable[60216] = bhControlPlayer_0x13a6e0; // 0x13ace8 - g_ps2RecompiledFunctionTable[60217] = bhControlPlayer_0x13a6e0; // 0x13acec - g_ps2RecompiledFunctionTable[60218] = bhControlPlayer_0x13a6e0; // 0x13acf0 - g_ps2RecompiledFunctionTable[60219] = bhControlPlayer_0x13a6e0; // 0x13acf4 - g_ps2RecompiledFunctionTable[60220] = bhControlPlayer_0x13a6e0; // 0x13acf8 - g_ps2RecompiledFunctionTable[60221] = bhControlPlayer_0x13a6e0; // 0x13acfc - g_ps2RecompiledFunctionTable[60222] = bhControlPlayer_0x13a6e0; // 0x13ad00 - g_ps2RecompiledFunctionTable[60223] = bhControlPlayer_0x13a6e0; // 0x13ad04 - g_ps2RecompiledFunctionTable[60224] = bhControlPlayer_0x13a6e0; // 0x13ad08 - g_ps2RecompiledFunctionTable[60225] = bhControlPlayer_0x13a6e0; // 0x13ad0c - g_ps2RecompiledFunctionTable[60226] = bhControlPlayer_0x13a6e0; // 0x13ad10 - g_ps2RecompiledFunctionTable[60227] = bhControlPlayer_0x13a6e0; // 0x13ad14 - g_ps2RecompiledFunctionTable[60228] = bhControlPlayer_0x13a6e0; // 0x13ad18 - g_ps2RecompiledFunctionTable[60229] = bhControlPlayer_0x13a6e0; // 0x13ad1c - g_ps2RecompiledFunctionTable[60230] = bhControlPlayer_0x13a6e0; // 0x13ad20 - g_ps2RecompiledFunctionTable[60231] = bhControlPlayer_0x13a6e0; // 0x13ad24 - g_ps2RecompiledFunctionTable[60232] = bhControlPlayer_0x13a6e0; // 0x13ad28 - g_ps2RecompiledFunctionTable[60233] = bhControlPlayer_0x13a6e0; // 0x13ad2c - g_ps2RecompiledFunctionTable[60234] = bhControlPlayer_0x13a6e0; // 0x13ad30 - g_ps2RecompiledFunctionTable[60235] = bhControlPlayer_0x13a6e0; // 0x13ad34 - g_ps2RecompiledFunctionTable[60236] = bhControlPlayer_0x13a6e0; // 0x13ad38 - g_ps2RecompiledFunctionTable[60237] = bhControlPlayer_0x13a6e0; // 0x13ad3c - g_ps2RecompiledFunctionTable[60238] = bhControlPlayer_0x13a6e0; // 0x13ad40 - g_ps2RecompiledFunctionTable[60239] = bhControlPlayer_0x13a6e0; // 0x13ad44 - g_ps2RecompiledFunctionTable[60240] = bhControlPlayer_0x13a6e0; // 0x13ad48 - g_ps2RecompiledFunctionTable[60241] = bhControlPlayer_0x13a6e0; // 0x13ad4c - g_ps2RecompiledFunctionTable[60242] = bhControlPlayer_0x13a6e0; // 0x13ad50 - g_ps2RecompiledFunctionTable[60243] = bhControlPlayer_0x13a6e0; // 0x13ad54 - g_ps2RecompiledFunctionTable[60244] = bhControlPlayer_0x13a6e0; // 0x13ad58 - g_ps2RecompiledFunctionTable[60245] = bhControlPlayer_0x13a6e0; // 0x13ad5c - g_ps2RecompiledFunctionTable[60246] = bhControlPlayer_0x13a6e0; // 0x13ad60 - g_ps2RecompiledFunctionTable[60247] = bhControlPlayer_0x13a6e0; // 0x13ad64 - g_ps2RecompiledFunctionTable[60248] = bhControlPlayer_0x13a6e0; // 0x13ad68 - g_ps2RecompiledFunctionTable[60249] = bhControlPlayer_0x13a6e0; // 0x13ad6c - g_ps2RecompiledFunctionTable[60250] = bhControlPlayer_0x13a6e0; // 0x13ad70 - g_ps2RecompiledFunctionTable[60251] = bhControlPlayer_0x13a6e0; // 0x13ad74 - g_ps2RecompiledFunctionTable[60252] = bhControlPlayer_0x13a6e0; // 0x13ad78 - g_ps2RecompiledFunctionTable[60253] = bhControlPlayer_0x13a6e0; // 0x13ad7c - g_ps2RecompiledFunctionTable[60254] = bhControlPlayer_0x13a6e0; // 0x13ad80 - g_ps2RecompiledFunctionTable[60255] = bhControlPlayer_0x13a6e0; // 0x13ad84 - g_ps2RecompiledFunctionTable[60256] = bhControlPlayer_0x13a6e0; // 0x13ad88 - g_ps2RecompiledFunctionTable[60257] = bhControlPlayer_0x13a6e0; // 0x13ad8c - g_ps2RecompiledFunctionTable[60258] = bhControlPlayer_0x13a6e0; // 0x13ad90 - g_ps2RecompiledFunctionTable[60259] = bhControlPlayer_0x13a6e0; // 0x13ad94 - g_ps2RecompiledFunctionTable[60260] = bhControlPlayer_0x13a6e0; // 0x13ad98 - g_ps2RecompiledFunctionTable[60261] = bhControlPlayer_0x13a6e0; // 0x13ad9c - g_ps2RecompiledFunctionTable[60262] = bhControlPlayer_0x13a6e0; // 0x13ada0 - g_ps2RecompiledFunctionTable[60263] = bhControlPlayer_0x13a6e0; // 0x13ada4 - g_ps2RecompiledFunctionTable[60264] = bhControlPlayer_0x13a6e0; // 0x13ada8 - g_ps2RecompiledFunctionTable[60265] = bhControlPlayer_0x13a6e0; // 0x13adac - g_ps2RecompiledFunctionTable[60266] = bhControlPlayer_0x13a6e0; // 0x13adb0 - g_ps2RecompiledFunctionTable[60267] = bhControlPlayer_0x13a6e0; // 0x13adb4 - g_ps2RecompiledFunctionTable[60268] = bhControlPlayer_0x13a6e0; // 0x13adb8 - g_ps2RecompiledFunctionTable[60269] = bhControlPlayer_0x13a6e0; // 0x13adbc - g_ps2RecompiledFunctionTable[60270] = bhControlPlayer_0x13a6e0; // 0x13adc0 - g_ps2RecompiledFunctionTable[60271] = bhControlPlayer_0x13a6e0; // 0x13adc4 - g_ps2RecompiledFunctionTable[60272] = bhControlPlayer_0x13a6e0; // 0x13adc8 - g_ps2RecompiledFunctionTable[60273] = bhControlPlayer_0x13a6e0; // 0x13adcc - g_ps2RecompiledFunctionTable[60274] = bhControlPlayer_0x13a6e0; // 0x13add0 - g_ps2RecompiledFunctionTable[60275] = bhControlPlayer_0x13a6e0; // 0x13add4 - g_ps2RecompiledFunctionTable[60276] = bhControlPlayer_0x13a6e0; // 0x13add8 - g_ps2RecompiledFunctionTable[60277] = bhControlPlayer_0x13a6e0; // 0x13addc - g_ps2RecompiledFunctionTable[60278] = bhControlPlayer_0x13a6e0; // 0x13ade0 - g_ps2RecompiledFunctionTable[60279] = bhControlPlayer_0x13a6e0; // 0x13ade4 - g_ps2RecompiledFunctionTable[60280] = bhControlPlayer_0x13a6e0; // 0x13ade8 - g_ps2RecompiledFunctionTable[60281] = bhControlPlayer_0x13a6e0; // 0x13adec - g_ps2RecompiledFunctionTable[60282] = bhControlPlayer_0x13a6e0; // 0x13adf0 - g_ps2RecompiledFunctionTable[60283] = bhControlPlayer_0x13a6e0; // 0x13adf4 - g_ps2RecompiledFunctionTable[60284] = bhControlPlayer_0x13a6e0; // 0x13adf8 - g_ps2RecompiledFunctionTable[60285] = bhControlPlayer_0x13a6e0; // 0x13adfc - g_ps2RecompiledFunctionTable[60286] = bhControlPlayer_0x13a6e0; // 0x13ae00 - g_ps2RecompiledFunctionTable[60287] = bhControlPlayer_0x13a6e0; // 0x13ae04 - g_ps2RecompiledFunctionTable[60288] = bhControlPlayer_0x13a6e0; // 0x13ae08 - g_ps2RecompiledFunctionTable[60289] = bhControlPlayer_0x13a6e0; // 0x13ae0c - g_ps2RecompiledFunctionTable[60290] = bhControlPlayer_0x13a6e0; // 0x13ae10 - g_ps2RecompiledFunctionTable[60291] = bhControlPlayer_0x13a6e0; // 0x13ae14 - g_ps2RecompiledFunctionTable[60292] = bhControlPlayer_0x13a6e0; // 0x13ae18 - g_ps2RecompiledFunctionTable[60293] = bhControlPlayer_0x13a6e0; // 0x13ae1c - g_ps2RecompiledFunctionTable[60294] = bhControlPlayer_0x13a6e0; // 0x13ae20 - g_ps2RecompiledFunctionTable[60295] = bhControlPlayer_0x13a6e0; // 0x13ae24 - g_ps2RecompiledFunctionTable[60296] = bhControlPlayer_0x13a6e0; // 0x13ae28 - g_ps2RecompiledFunctionTable[60297] = bhControlPlayer_0x13a6e0; // 0x13ae2c - g_ps2RecompiledFunctionTable[60298] = bhControlPlayer_0x13a6e0; // 0x13ae30 - g_ps2RecompiledFunctionTable[60299] = bhControlPlayer_0x13a6e0; // 0x13ae34 - g_ps2RecompiledFunctionTable[60300] = bhControlPlayer_0x13a6e0; // 0x13ae38 - g_ps2RecompiledFunctionTable[60301] = bhControlPlayer_0x13a6e0; // 0x13ae3c - g_ps2RecompiledFunctionTable[60302] = bhControlPlayer_0x13a6e0; // 0x13ae40 - g_ps2RecompiledFunctionTable[60303] = bhControlPlayer_0x13a6e0; // 0x13ae44 - g_ps2RecompiledFunctionTable[60304] = bhControlPlayer_0x13a6e0; // 0x13ae48 - g_ps2RecompiledFunctionTable[60305] = bhControlPlayer_0x13a6e0; // 0x13ae4c - g_ps2RecompiledFunctionTable[60306] = bhControlPlayer_0x13a6e0; // 0x13ae50 - g_ps2RecompiledFunctionTable[60307] = bhControlPlayer_0x13a6e0; // 0x13ae54 - g_ps2RecompiledFunctionTable[60308] = bhControlPlayer_0x13a6e0; // 0x13ae58 - g_ps2RecompiledFunctionTable[60309] = bhControlPlayer_0x13a6e0; // 0x13ae5c - g_ps2RecompiledFunctionTable[60310] = bhControlPlayer_0x13a6e0; // 0x13ae60 - g_ps2RecompiledFunctionTable[60311] = bhControlPlayer_0x13a6e0; // 0x13ae64 - g_ps2RecompiledFunctionTable[60312] = bhControlPlayer_0x13a6e0; // 0x13ae68 - g_ps2RecompiledFunctionTable[60313] = bhControlPlayer_0x13a6e0; // 0x13ae6c - g_ps2RecompiledFunctionTable[60314] = bhControlPlayer_0x13a6e0; // 0x13ae70 - g_ps2RecompiledFunctionTable[60315] = bhControlPlayer_0x13a6e0; // 0x13ae74 - g_ps2RecompiledFunctionTable[60316] = bhControlPlayer_0x13a6e0; // 0x13ae78 - g_ps2RecompiledFunctionTable[60317] = bhControlPlayer_0x13a6e0; // 0x13ae7c - g_ps2RecompiledFunctionTable[60318] = bhControlPlayer_0x13a6e0; // 0x13ae80 - g_ps2RecompiledFunctionTable[60319] = bhControlPlayer_0x13a6e0; // 0x13ae84 - g_ps2RecompiledFunctionTable[60320] = bhControlPlayer_0x13a6e0; // 0x13ae88 - g_ps2RecompiledFunctionTable[60321] = bhControlPlayer_0x13a6e0; // 0x13ae8c - g_ps2RecompiledFunctionTable[60322] = bhControlPlayer_0x13a6e0; // 0x13ae90 - g_ps2RecompiledFunctionTable[60323] = bhControlPlayer_0x13a6e0; // 0x13ae94 - g_ps2RecompiledFunctionTable[60324] = bhControlPlayer_0x13a6e0; // 0x13ae98 - g_ps2RecompiledFunctionTable[60325] = bhControlPlayer_0x13a6e0; // 0x13ae9c - g_ps2RecompiledFunctionTable[60326] = bhControlPlayer_0x13a6e0; // 0x13aea0 - g_ps2RecompiledFunctionTable[60327] = bhControlPlayer_0x13a6e0; // 0x13aea4 - g_ps2RecompiledFunctionTable[60328] = bhControlPlayer_0x13a6e0; // 0x13aea8 - g_ps2RecompiledFunctionTable[60329] = bhControlPlayer_0x13a6e0; // 0x13aeac - g_ps2RecompiledFunctionTable[60330] = bhControlPlayer_0x13a6e0; // 0x13aeb0 - g_ps2RecompiledFunctionTable[60331] = bhControlPlayer_0x13a6e0; // 0x13aeb4 - g_ps2RecompiledFunctionTable[60332] = bhControlPlayer_0x13a6e0; // 0x13aeb8 - g_ps2RecompiledFunctionTable[60333] = bhControlPlayer_0x13a6e0; // 0x13aebc - g_ps2RecompiledFunctionTable[60334] = bhControlPlayer_0x13a6e0; // 0x13aec0 - g_ps2RecompiledFunctionTable[60335] = bhControlPlayer_0x13a6e0; // 0x13aec4 - g_ps2RecompiledFunctionTable[60336] = bhControlPlayer_0x13a6e0; // 0x13aec8 - g_ps2RecompiledFunctionTable[60337] = bhControlPlayer_0x13a6e0; // 0x13aecc - g_ps2RecompiledFunctionTable[60338] = bhControlPlayer_0x13a6e0; // 0x13aed0 - g_ps2RecompiledFunctionTable[60339] = bhControlPlayer_0x13a6e0; // 0x13aed4 - g_ps2RecompiledFunctionTable[60340] = bhControlPlayer_0x13a6e0; // 0x13aed8 - g_ps2RecompiledFunctionTable[60341] = bhControlPlayer_0x13a6e0; // 0x13aedc - g_ps2RecompiledFunctionTable[60342] = bhControlPlayer_0x13a6e0; // 0x13aee0 - g_ps2RecompiledFunctionTable[60343] = bhControlPlayer_0x13a6e0; // 0x13aee4 - g_ps2RecompiledFunctionTable[60344] = bhControlPlayer_0x13a6e0; // 0x13aee8 - g_ps2RecompiledFunctionTable[60345] = bhControlPlayer_0x13a6e0; // 0x13aeec - g_ps2RecompiledFunctionTable[60346] = bhControlPlayer_0x13a6e0; // 0x13aef0 - g_ps2RecompiledFunctionTable[60347] = bhControlPlayer_0x13a6e0; // 0x13aef4 - g_ps2RecompiledFunctionTable[60348] = bhControlPlayer_0x13a6e0; // 0x13aef8 - g_ps2RecompiledFunctionTable[60349] = bhControlPlayer_0x13a6e0; // 0x13aefc - g_ps2RecompiledFunctionTable[60350] = bhControlPlayer_0x13a6e0; // 0x13af00 - g_ps2RecompiledFunctionTable[60351] = bhControlPlayer_0x13a6e0; // 0x13af04 - g_ps2RecompiledFunctionTable[60352] = bhControlPlayer_0x13a6e0; // 0x13af08 - g_ps2RecompiledFunctionTable[60353] = bhControlPlayer_0x13a6e0; // 0x13af0c - g_ps2RecompiledFunctionTable[60354] = bhControlPlayer_0x13a6e0; // 0x13af10 - g_ps2RecompiledFunctionTable[60355] = bhControlPlayer_0x13a6e0; // 0x13af14 - g_ps2RecompiledFunctionTable[60356] = bhControlPlayer_0x13a6e0; // 0x13af18 - g_ps2RecompiledFunctionTable[60357] = bhControlPlayer_0x13a6e0; // 0x13af1c - g_ps2RecompiledFunctionTable[60358] = bhControlPlayer_0x13a6e0; // 0x13af20 - g_ps2RecompiledFunctionTable[60359] = bhControlPlayer_0x13a6e0; // 0x13af24 - g_ps2RecompiledFunctionTable[60360] = bhControlPlayer_0x13a6e0; // 0x13af28 - g_ps2RecompiledFunctionTable[60361] = bhControlPlayer_0x13a6e0; // 0x13af2c - g_ps2RecompiledFunctionTable[60362] = bhControlPlayer_0x13a6e0; // 0x13af30 - g_ps2RecompiledFunctionTable[60363] = bhControlPlayer_0x13a6e0; // 0x13af34 - g_ps2RecompiledFunctionTable[60364] = bhControlPlayer_0x13a6e0; // 0x13af38 - g_ps2RecompiledFunctionTable[60365] = bhControlPlayer_0x13a6e0; // 0x13af3c - g_ps2RecompiledFunctionTable[60366] = bhControlPlayer_0x13a6e0; // 0x13af40 - g_ps2RecompiledFunctionTable[60367] = bhControlPlayer_0x13a6e0; // 0x13af44 - g_ps2RecompiledFunctionTable[60368] = bhControlPlayer_0x13a6e0; // 0x13af48 - g_ps2RecompiledFunctionTable[60369] = bhControlPlayer_0x13a6e0; // 0x13af4c - g_ps2RecompiledFunctionTable[60370] = bhControlPlayer_0x13a6e0; // 0x13af50 - g_ps2RecompiledFunctionTable[60371] = bhControlPlayer_0x13a6e0; // 0x13af54 - g_ps2RecompiledFunctionTable[60372] = bhControlPlayer_0x13a6e0; // 0x13af58 - g_ps2RecompiledFunctionTable[60373] = bhControlPlayer_0x13a6e0; // 0x13af5c - g_ps2RecompiledFunctionTable[60374] = bhControlPlayer_0x13a6e0; // 0x13af60 - g_ps2RecompiledFunctionTable[60375] = bhControlPlayer_0x13a6e0; // 0x13af64 - g_ps2RecompiledFunctionTable[60376] = bhControlPlayer_0x13a6e0; // 0x13af68 - g_ps2RecompiledFunctionTable[60377] = bhControlPlayer_0x13a6e0; // 0x13af6c - g_ps2RecompiledFunctionTable[60378] = bhControlPlayer_0x13a6e0; // 0x13af70 - g_ps2RecompiledFunctionTable[60379] = bhControlPlayer_0x13a6e0; // 0x13af74 - g_ps2RecompiledFunctionTable[60380] = bhControlPlayer_0x13a6e0; // 0x13af78 - g_ps2RecompiledFunctionTable[60381] = bhControlPlayer_0x13a6e0; // 0x13af7c - g_ps2RecompiledFunctionTable[60382] = bhControlPlayer_0x13a6e0; // 0x13af80 - g_ps2RecompiledFunctionTable[60383] = bhControlPlayer_0x13a6e0; // 0x13af84 - g_ps2RecompiledFunctionTable[60384] = bhControlPlayer_0x13a6e0; // 0x13af88 - g_ps2RecompiledFunctionTable[60385] = bhControlPlayer_0x13a6e0; // 0x13af8c - g_ps2RecompiledFunctionTable[60386] = bhControlPlayer_0x13a6e0; // 0x13af90 - g_ps2RecompiledFunctionTable[60387] = bhControlPlayer_0x13a6e0; // 0x13af94 - g_ps2RecompiledFunctionTable[60388] = bhControlPlayer_0x13a6e0; // 0x13af98 - g_ps2RecompiledFunctionTable[60389] = bhControlPlayer_0x13a6e0; // 0x13af9c - g_ps2RecompiledFunctionTable[60390] = bhControlPlayer_0x13a6e0; // 0x13afa0 - g_ps2RecompiledFunctionTable[60391] = bhControlPlayer_0x13a6e0; // 0x13afa4 - g_ps2RecompiledFunctionTable[60392] = bhControlPlayer_0x13a6e0; // 0x13afa8 - g_ps2RecompiledFunctionTable[60393] = bhControlPlayer_0x13a6e0; // 0x13afac - g_ps2RecompiledFunctionTable[60394] = bhControlPlayer_0x13a6e0; // 0x13afb0 - g_ps2RecompiledFunctionTable[60395] = bhControlPlayer_0x13a6e0; // 0x13afb4 - g_ps2RecompiledFunctionTable[60396] = bhControlPlayer_0x13a6e0; // 0x13afb8 - g_ps2RecompiledFunctionTable[60397] = bhControlPlayer_0x13a6e0; // 0x13afbc - g_ps2RecompiledFunctionTable[60398] = bhControlPlayer_0x13a6e0; // 0x13afc0 - g_ps2RecompiledFunctionTable[60399] = bhControlPlayer_0x13a6e0; // 0x13afc4 - g_ps2RecompiledFunctionTable[60400] = bhControlPlayer_0x13a6e0; // 0x13afc8 - g_ps2RecompiledFunctionTable[60401] = bhControlPlayer_0x13a6e0; // 0x13afcc - g_ps2RecompiledFunctionTable[60402] = bhControlPlayer_0x13a6e0; // 0x13afd0 - g_ps2RecompiledFunctionTable[60403] = bhControlPlayer_0x13a6e0; // 0x13afd4 - g_ps2RecompiledFunctionTable[60404] = bhControlPlayer_0x13a6e0; // 0x13afd8 - g_ps2RecompiledFunctionTable[60405] = bhControlPlayer_0x13a6e0; // 0x13afdc - g_ps2RecompiledFunctionTable[60406] = bhControlPlayer_0x13a6e0; // 0x13afe0 - g_ps2RecompiledFunctionTable[60407] = bhControlPlayer_0x13a6e0; // 0x13afe4 - g_ps2RecompiledFunctionTable[60408] = bhControlPlayer_0x13a6e0; // 0x13afe8 - g_ps2RecompiledFunctionTable[60409] = bhControlPlayer_0x13a6e0; // 0x13afec - g_ps2RecompiledFunctionTable[60410] = bhControlPlayer_0x13a6e0; // 0x13aff0 - g_ps2RecompiledFunctionTable[60411] = bhControlPlayer_0x13a6e0; // 0x13aff4 - g_ps2RecompiledFunctionTable[60412] = bhControlPlayer_0x13a6e0; // 0x13aff8 - g_ps2RecompiledFunctionTable[60413] = bhControlPlayer_0x13a6e0; // 0x13affc - g_ps2RecompiledFunctionTable[60414] = bhControlPlayer_0x13a6e0; // 0x13b000 - g_ps2RecompiledFunctionTable[60415] = bhControlPlayer_0x13a6e0; // 0x13b004 - g_ps2RecompiledFunctionTable[60416] = bhControlPlayer_0x13a6e0; // 0x13b008 - g_ps2RecompiledFunctionTable[60417] = bhControlPlayer_0x13a6e0; // 0x13b00c - g_ps2RecompiledFunctionTable[60418] = bhControlPlayer_0x13a6e0; // 0x13b010 - g_ps2RecompiledFunctionTable[60419] = bhControlPlayer_0x13a6e0; // 0x13b014 - g_ps2RecompiledFunctionTable[60420] = bhControlPlayer_0x13a6e0; // 0x13b018 - g_ps2RecompiledFunctionTable[60421] = bhControlPlayer_0x13a6e0; // 0x13b01c - g_ps2RecompiledFunctionTable[60422] = bhControlPlayer_0x13a6e0; // 0x13b020 - g_ps2RecompiledFunctionTable[60423] = bhControlPlayer_0x13a6e0; // 0x13b024 - g_ps2RecompiledFunctionTable[60424] = bhControlPlayer_0x13a6e0; // 0x13b028 - g_ps2RecompiledFunctionTable[60425] = bhControlPlayer_0x13a6e0; // 0x13b02c - g_ps2RecompiledFunctionTable[60426] = bhControlPlayer_0x13a6e0; // 0x13b030 - g_ps2RecompiledFunctionTable[60427] = bhControlPlayer_0x13a6e0; // 0x13b034 - g_ps2RecompiledFunctionTable[60428] = bhControlPlayer_0x13a6e0; // 0x13b038 - g_ps2RecompiledFunctionTable[60429] = bhControlPlayer_0x13a6e0; // 0x13b03c - g_ps2RecompiledFunctionTable[60430] = bhControlPlayer_0x13a6e0; // 0x13b040 - g_ps2RecompiledFunctionTable[60431] = bhControlPlayer_0x13a6e0; // 0x13b044 - g_ps2RecompiledFunctionTable[60432] = bhControlPlayer_0x13a6e0; // 0x13b048 - g_ps2RecompiledFunctionTable[60433] = bhControlPlayer_0x13a6e0; // 0x13b04c - g_ps2RecompiledFunctionTable[60434] = bhControlPlayer_0x13a6e0; // 0x13b050 - g_ps2RecompiledFunctionTable[60435] = bhControlPlayer_0x13a6e0; // 0x13b054 - g_ps2RecompiledFunctionTable[60436] = bhControlPlayer_0x13a6e0; // 0x13b058 - g_ps2RecompiledFunctionTable[60437] = bhControlPlayer_0x13a6e0; // 0x13b05c - g_ps2RecompiledFunctionTable[60438] = bhControlPlayer_0x13a6e0; // 0x13b060 - g_ps2RecompiledFunctionTable[60439] = bhControlPlayer_0x13a6e0; // 0x13b064 - g_ps2RecompiledFunctionTable[60440] = bhControlPlayer_0x13a6e0; // 0x13b068 - g_ps2RecompiledFunctionTable[60441] = bhControlPlayer_0x13a6e0; // 0x13b06c - g_ps2RecompiledFunctionTable[60442] = bhControlPlayer_0x13a6e0; // 0x13b070 - g_ps2RecompiledFunctionTable[60443] = bhControlPlayer_0x13a6e0; // 0x13b074 - g_ps2RecompiledFunctionTable[60444] = bhControlPlayer_0x13a6e0; // 0x13b078 - g_ps2RecompiledFunctionTable[60445] = bhControlPlayer_0x13a6e0; // 0x13b07c - g_ps2RecompiledFunctionTable[60446] = bhControlPlayer_0x13a6e0; // 0x13b080 - g_ps2RecompiledFunctionTable[60447] = bhControlPlayer_0x13a6e0; // 0x13b084 - g_ps2RecompiledFunctionTable[60448] = bhControlPlayer_0x13a6e0; // 0x13b088 - g_ps2RecompiledFunctionTable[60449] = bhControlPlayer_0x13a6e0; // 0x13b08c - g_ps2RecompiledFunctionTable[60450] = bhControlPlayer_0x13a6e0; // 0x13b090 - g_ps2RecompiledFunctionTable[60451] = bhControlPlayer_0x13a6e0; // 0x13b094 - g_ps2RecompiledFunctionTable[60452] = bhControlPlayer_0x13a6e0; // 0x13b098 - g_ps2RecompiledFunctionTable[60453] = bhControlPlayer_0x13a6e0; // 0x13b09c - g_ps2RecompiledFunctionTable[60454] = bhControlPlayer_0x13a6e0; // 0x13b0a0 - g_ps2RecompiledFunctionTable[60455] = bhControlPlayer_0x13a6e0; // 0x13b0a4 - g_ps2RecompiledFunctionTable[60456] = bhControlPlayer_0x13a6e0; // 0x13b0a8 - g_ps2RecompiledFunctionTable[60457] = bhControlPlayer_0x13a6e0; // 0x13b0ac - g_ps2RecompiledFunctionTable[60458] = bhControlPlayer_0x13a6e0; // 0x13b0b0 - g_ps2RecompiledFunctionTable[60459] = bhControlPlayer_0x13a6e0; // 0x13b0b4 - g_ps2RecompiledFunctionTable[60460] = bhControlPlayer_0x13a6e0; // 0x13b0b8 - g_ps2RecompiledFunctionTable[60461] = bhControlPlayer_0x13a6e0; // 0x13b0bc - g_ps2RecompiledFunctionTable[60462] = bhControlPlayer_0x13a6e0; // 0x13b0c0 - g_ps2RecompiledFunctionTable[60463] = bhControlPlayer_0x13a6e0; // 0x13b0c4 - g_ps2RecompiledFunctionTable[60464] = bhControlPlayer_0x13a6e0; // 0x13b0c8 - g_ps2RecompiledFunctionTable[60465] = bhControlPlayer_0x13a6e0; // 0x13b0cc - g_ps2RecompiledFunctionTable[60466] = bhControlPlayer_0x13a6e0; // 0x13b0d0 - g_ps2RecompiledFunctionTable[60467] = bhControlPlayer_0x13a6e0; // 0x13b0d4 - g_ps2RecompiledFunctionTable[60468] = bhControlPlayer_0x13a6e0; // 0x13b0d8 - g_ps2RecompiledFunctionTable[60469] = bhControlPlayer_0x13a6e0; // 0x13b0dc - g_ps2RecompiledFunctionTable[60470] = bhControlPlayer_0x13a6e0; // 0x13b0e0 - g_ps2RecompiledFunctionTable[60471] = bhControlPlayer_0x13a6e0; // 0x13b0e4 - g_ps2RecompiledFunctionTable[60472] = bhControlPlayer_0x13a6e0; // 0x13b0e8 - g_ps2RecompiledFunctionTable[60473] = bhControlPlayer_0x13a6e0; // 0x13b0ec - g_ps2RecompiledFunctionTable[60474] = bhControlPlayer_0x13a6e0; // 0x13b0f0 - g_ps2RecompiledFunctionTable[60475] = bhControlPlayer_0x13a6e0; // 0x13b0f4 - g_ps2RecompiledFunctionTable[60476] = bhControlPlayer_0x13a6e0; // 0x13b0f8 - g_ps2RecompiledFunctionTable[60477] = bhControlPlayer_0x13a6e0; // 0x13b0fc - g_ps2RecompiledFunctionTable[60478] = bhControlPlayer_0x13a6e0; // 0x13b100 - g_ps2RecompiledFunctionTable[60479] = bhControlPlayer_0x13a6e0; // 0x13b104 - g_ps2RecompiledFunctionTable[60480] = bhControlPlayer_0x13a6e0; // 0x13b108 - g_ps2RecompiledFunctionTable[60481] = bhControlPlayer_0x13a6e0; // 0x13b10c - g_ps2RecompiledFunctionTable[60482] = bhControlPlayer_0x13a6e0; // 0x13b110 - g_ps2RecompiledFunctionTable[60483] = bhControlPlayer_0x13a6e0; // 0x13b114 - g_ps2RecompiledFunctionTable[60484] = bhControlPlayer_0x13a6e0; // 0x13b118 - g_ps2RecompiledFunctionTable[60485] = bhControlPlayer_0x13a6e0; // 0x13b11c - g_ps2RecompiledFunctionTable[60486] = bhControlPlayer_0x13a6e0; // 0x13b120 - g_ps2RecompiledFunctionTable[60487] = bhControlPlayer_0x13a6e0; // 0x13b124 - g_ps2RecompiledFunctionTable[60488] = bhControlPlayer_0x13a6e0; // 0x13b128 - g_ps2RecompiledFunctionTable[60489] = bhControlPlayer_0x13a6e0; // 0x13b12c - g_ps2RecompiledFunctionTable[60490] = bhControlPlayer_0x13a6e0; // 0x13b130 - g_ps2RecompiledFunctionTable[60491] = bhControlPlayer_0x13a6e0; // 0x13b134 - g_ps2RecompiledFunctionTable[60492] = bhControlPlayer_0x13a6e0; // 0x13b138 - g_ps2RecompiledFunctionTable[60493] = bhControlPlayer_0x13a6e0; // 0x13b13c - g_ps2RecompiledFunctionTable[60494] = bhControlPlayer_0x13a6e0; // 0x13b140 - g_ps2RecompiledFunctionTable[60495] = bhControlPlayer_0x13a6e0; // 0x13b144 - g_ps2RecompiledFunctionTable[60496] = bhControlPlayer_0x13a6e0; // 0x13b148 - g_ps2RecompiledFunctionTable[60497] = bhControlPlayer_0x13a6e0; // 0x13b14c - g_ps2RecompiledFunctionTable[60498] = bhControlPlayer_0x13a6e0; // 0x13b150 - g_ps2RecompiledFunctionTable[60499] = bhControlPlayer_0x13a6e0; // 0x13b154 - g_ps2RecompiledFunctionTable[60500] = bhControlPlayer_0x13a6e0; // 0x13b158 - g_ps2RecompiledFunctionTable[60501] = bhControlPlayer_0x13a6e0; // 0x13b15c - g_ps2RecompiledFunctionTable[60502] = bhControlPlayer_0x13a6e0; // 0x13b160 - g_ps2RecompiledFunctionTable[60503] = bhControlPlayer_0x13a6e0; // 0x13b164 - g_ps2RecompiledFunctionTable[60504] = bhControlPlayer_0x13a6e0; // 0x13b168 - g_ps2RecompiledFunctionTable[60505] = bhControlPlayer_0x13a6e0; // 0x13b16c - g_ps2RecompiledFunctionTable[60506] = bhControlPlayer_0x13a6e0; // 0x13b170 - g_ps2RecompiledFunctionTable[60507] = bhControlPlayer_0x13a6e0; // 0x13b174 - g_ps2RecompiledFunctionTable[60508] = bhControlPlayer_0x13a6e0; // 0x13b178 - g_ps2RecompiledFunctionTable[60509] = bhControlPlayer_0x13a6e0; // 0x13b17c - g_ps2RecompiledFunctionTable[60510] = bhControlPlayer_0x13a6e0; // 0x13b180 - g_ps2RecompiledFunctionTable[60511] = bhControlPlayer_0x13a6e0; // 0x13b184 - g_ps2RecompiledFunctionTable[60512] = bhControlPlayer_0x13a6e0; // 0x13b188 - g_ps2RecompiledFunctionTable[60513] = bhControlPlayer_0x13a6e0; // 0x13b18c - g_ps2RecompiledFunctionTable[60514] = bhControlPlayer_0x13a6e0; // 0x13b190 - g_ps2RecompiledFunctionTable[60515] = bhControlPlayer_0x13a6e0; // 0x13b194 - g_ps2RecompiledFunctionTable[60516] = bhControlPlayer_0x13a6e0; // 0x13b198 - g_ps2RecompiledFunctionTable[60517] = bhControlPlayer_0x13a6e0; // 0x13b19c - g_ps2RecompiledFunctionTable[60518] = bhControlPlayer_0x13a6e0; // 0x13b1a0 - g_ps2RecompiledFunctionTable[60519] = bhControlPlayer_0x13a6e0; // 0x13b1a4 - g_ps2RecompiledFunctionTable[60520] = bhControlPlayer_0x13a6e0; // 0x13b1a8 - g_ps2RecompiledFunctionTable[60521] = bhControlPlayer_0x13a6e0; // 0x13b1ac - g_ps2RecompiledFunctionTable[60522] = bhControlPlayer_0x13a6e0; // 0x13b1b0 - g_ps2RecompiledFunctionTable[60523] = bhControlPlayer_0x13a6e0; // 0x13b1b4 - g_ps2RecompiledFunctionTable[60524] = bhControlPlayer_0x13a6e0; // 0x13b1b8 - g_ps2RecompiledFunctionTable[60525] = bhControlPlayer_0x13a6e0; // 0x13b1bc - g_ps2RecompiledFunctionTable[60526] = bhControlPlayer_0x13a6e0; // 0x13b1c0 - g_ps2RecompiledFunctionTable[60527] = bhControlPlayer_0x13a6e0; // 0x13b1c4 - g_ps2RecompiledFunctionTable[60528] = bhControlPlayer_0x13a6e0; // 0x13b1c8 - g_ps2RecompiledFunctionTable[60529] = bhControlPlayer_0x13a6e0; // 0x13b1cc - g_ps2RecompiledFunctionTable[60530] = bhControlPlayer_0x13a6e0; // 0x13b1d0 - g_ps2RecompiledFunctionTable[60531] = bhControlPlayer_0x13a6e0; // 0x13b1d4 - g_ps2RecompiledFunctionTable[60532] = bhControlPlayer_0x13a6e0; // 0x13b1d8 - g_ps2RecompiledFunctionTable[60533] = bhControlPlayer_0x13a6e0; // 0x13b1dc - g_ps2RecompiledFunctionTable[60534] = bhControlPlayer_0x13a6e0; // 0x13b1e0 - g_ps2RecompiledFunctionTable[60535] = bhControlPlayer_0x13a6e0; // 0x13b1e4 - g_ps2RecompiledFunctionTable[60536] = bhControlPlayer_0x13a6e0; // 0x13b1e8 - g_ps2RecompiledFunctionTable[60537] = bhControlPlayer_0x13a6e0; // 0x13b1ec - g_ps2RecompiledFunctionTable[60538] = bhControlPlayer_0x13a6e0; // 0x13b1f0 - g_ps2RecompiledFunctionTable[60539] = bhControlPlayer_0x13a6e0; // 0x13b1f4 - g_ps2RecompiledFunctionTable[60540] = bhControlPlayer_0x13a6e0; // 0x13b1f8 - g_ps2RecompiledFunctionTable[60541] = bhControlPlayer_0x13a6e0; // 0x13b1fc - g_ps2RecompiledFunctionTable[60542] = bhControlPlayer_0x13a6e0; // 0x13b200 - g_ps2RecompiledFunctionTable[60543] = bhControlPlayer_0x13a6e0; // 0x13b204 - g_ps2RecompiledFunctionTable[60544] = bhControlPlayer_0x13a6e0; // 0x13b208 - g_ps2RecompiledFunctionTable[60545] = bhControlPlayer_0x13a6e0; // 0x13b20c - g_ps2RecompiledFunctionTable[60546] = bhControlPlayer_0x13a6e0; // 0x13b210 - g_ps2RecompiledFunctionTable[60547] = bhControlPlayer_0x13a6e0; // 0x13b214 - g_ps2RecompiledFunctionTable[60548] = bhControlPlayer_0x13a6e0; // 0x13b218 - g_ps2RecompiledFunctionTable[60549] = bhControlPlayer_0x13a6e0; // 0x13b21c - g_ps2RecompiledFunctionTable[60550] = bhControlPlayer_0x13a6e0; // 0x13b220 - g_ps2RecompiledFunctionTable[60551] = bhControlPlayer_0x13a6e0; // 0x13b224 - g_ps2RecompiledFunctionTable[60552] = bhControlPlayer_0x13a6e0; // 0x13b228 - g_ps2RecompiledFunctionTable[60553] = bhControlPlayer_0x13a6e0; // 0x13b22c - g_ps2RecompiledFunctionTable[60554] = bhControlPlayer_0x13a6e0; // 0x13b230 - g_ps2RecompiledFunctionTable[60555] = bhControlPlayer_0x13a6e0; // 0x13b234 - g_ps2RecompiledFunctionTable[60556] = bhControlPlayer_0x13a6e0; // 0x13b238 - g_ps2RecompiledFunctionTable[60557] = bhControlPlayer_0x13a6e0; // 0x13b23c - g_ps2RecompiledFunctionTable[60558] = bhControlPlayer_0x13a6e0; // 0x13b240 - g_ps2RecompiledFunctionTable[60559] = bhControlPlayer_0x13a6e0; // 0x13b244 - g_ps2RecompiledFunctionTable[60560] = bhControlPlayer_0x13a6e0; // 0x13b248 - g_ps2RecompiledFunctionTable[60561] = bhControlPlayer_0x13a6e0; // 0x13b24c - g_ps2RecompiledFunctionTable[60562] = bhControlPlayer_0x13a6e0; // 0x13b250 - g_ps2RecompiledFunctionTable[60563] = bhControlPlayer_0x13a6e0; // 0x13b254 - g_ps2RecompiledFunctionTable[60564] = bhControlPlayer_0x13a6e0; // 0x13b258 - g_ps2RecompiledFunctionTable[60565] = bhControlPlayer_0x13a6e0; // 0x13b25c - g_ps2RecompiledFunctionTable[60566] = bhControlPlayer_0x13a6e0; // 0x13b260 - g_ps2RecompiledFunctionTable[60567] = bhControlPlayer_0x13a6e0; // 0x13b264 - g_ps2RecompiledFunctionTable[60568] = bhControlPlayer_0x13a6e0; // 0x13b268 - g_ps2RecompiledFunctionTable[60569] = bhControlPlayer_0x13a6e0; // 0x13b26c - g_ps2RecompiledFunctionTable[60570] = bhControlPlayer_0x13a6e0; // 0x13b270 - g_ps2RecompiledFunctionTable[60571] = bhControlPlayer_0x13a6e0; // 0x13b274 - g_ps2RecompiledFunctionTable[60572] = bhControlPlayer_0x13a6e0; // 0x13b278 - g_ps2RecompiledFunctionTable[60573] = bhControlPlayer_0x13a6e0; // 0x13b27c - g_ps2RecompiledFunctionTable[60574] = bhControlPlayer_0x13a6e0; // 0x13b280 - g_ps2RecompiledFunctionTable[60575] = bhControlPlayer_0x13a6e0; // 0x13b284 - g_ps2RecompiledFunctionTable[60576] = bhControlPlayer_0x13a6e0; // 0x13b288 - g_ps2RecompiledFunctionTable[60577] = bhControlPlayer_0x13a6e0; // 0x13b28c - g_ps2RecompiledFunctionTable[60578] = bhControlPlayer_0x13a6e0; // 0x13b290 - g_ps2RecompiledFunctionTable[60579] = bhControlPlayer_0x13a6e0; // 0x13b294 - g_ps2RecompiledFunctionTable[60580] = bhControlPlayer_0x13a6e0; // 0x13b298 - g_ps2RecompiledFunctionTable[60581] = bhControlPlayer_0x13a6e0; // 0x13b29c - g_ps2RecompiledFunctionTable[60582] = bhControlPlayer_0x13a6e0; // 0x13b2a0 - g_ps2RecompiledFunctionTable[60583] = bhControlPlayer_0x13a6e0; // 0x13b2a4 - g_ps2RecompiledFunctionTable[60584] = bhControlPlayer_0x13a6e0; // 0x13b2a8 - g_ps2RecompiledFunctionTable[60585] = bhControlPlayer_0x13a6e0; // 0x13b2ac - g_ps2RecompiledFunctionTable[60586] = bhControlPlayer_0x13a6e0; // 0x13b2b0 - g_ps2RecompiledFunctionTable[60587] = bhControlPlayer_0x13a6e0; // 0x13b2b4 - g_ps2RecompiledFunctionTable[60588] = bhControlPlayer_0x13a6e0; // 0x13b2b8 - g_ps2RecompiledFunctionTable[60589] = bhControlPlayer_0x13a6e0; // 0x13b2bc - g_ps2RecompiledFunctionTable[60590] = bhControlPlayer_0x13a6e0; // 0x13b2c0 - g_ps2RecompiledFunctionTable[60591] = bhControlPlayer_0x13a6e0; // 0x13b2c4 - g_ps2RecompiledFunctionTable[60592] = bhControlPlayer_0x13a6e0; // 0x13b2c8 - g_ps2RecompiledFunctionTable[60593] = bhControlPlayer_0x13a6e0; // 0x13b2cc - g_ps2RecompiledFunctionTable[60594] = bhControlPlayer_0x13a6e0; // 0x13b2d0 - g_ps2RecompiledFunctionTable[60595] = bhControlPlayer_0x13a6e0; // 0x13b2d4 - g_ps2RecompiledFunctionTable[60596] = bhControlPlayer_0x13a6e0; // 0x13b2d8 - g_ps2RecompiledFunctionTable[60597] = bhControlPlayer_0x13a6e0; // 0x13b2dc - g_ps2RecompiledFunctionTable[60598] = bhControlPlayer_0x13a6e0; // 0x13b2e0 - g_ps2RecompiledFunctionTable[60599] = bhControlPlayer_0x13a6e0; // 0x13b2e4 - g_ps2RecompiledFunctionTable[60600] = bhControlPlayer_0x13a6e0; // 0x13b2e8 - g_ps2RecompiledFunctionTable[60601] = bhControlPlayer_0x13a6e0; // 0x13b2ec - g_ps2RecompiledFunctionTable[60602] = bhControlPlayer_0x13a6e0; // 0x13b2f0 - g_ps2RecompiledFunctionTable[60603] = bhControlPlayer_0x13a6e0; // 0x13b2f4 - g_ps2RecompiledFunctionTable[60604] = bhControlPlayer_0x13a6e0; // 0x13b2f8 - g_ps2RecompiledFunctionTable[60605] = bhControlPlayer_0x13a6e0; // 0x13b2fc - g_ps2RecompiledFunctionTable[60606] = bhControlPlayer_0x13a6e0; // 0x13b300 - g_ps2RecompiledFunctionTable[60607] = bhControlPlayer_0x13a6e0; // 0x13b304 - g_ps2RecompiledFunctionTable[60608] = bhControlPlayer_0x13a6e0; // 0x13b308 - g_ps2RecompiledFunctionTable[60609] = bhControlPlayer_0x13a6e0; // 0x13b30c - g_ps2RecompiledFunctionTable[60610] = bhControlPlayer_0x13a6e0; // 0x13b310 - g_ps2RecompiledFunctionTable[60611] = bhControlPlayer_0x13a6e0; // 0x13b314 - g_ps2RecompiledFunctionTable[60612] = bhControlPlayer_0x13a6e0; // 0x13b318 - g_ps2RecompiledFunctionTable[60613] = bhControlPlayer_0x13a6e0; // 0x13b31c - g_ps2RecompiledFunctionTable[60614] = bhControlPlayer_0x13a6e0; // 0x13b320 - g_ps2RecompiledFunctionTable[60615] = bhControlPlayer_0x13a6e0; // 0x13b324 - g_ps2RecompiledFunctionTable[60616] = bhControlPlayer_0x13a6e0; // 0x13b328 - g_ps2RecompiledFunctionTable[60617] = bhControlPlayer_0x13a6e0; // 0x13b32c - g_ps2RecompiledFunctionTable[60618] = bhControlPlayer_0x13a6e0; // 0x13b330 - g_ps2RecompiledFunctionTable[60619] = bhControlPlayer_0x13a6e0; // 0x13b334 - g_ps2RecompiledFunctionTable[60620] = bhControlPlayer_0x13a6e0; // 0x13b338 - g_ps2RecompiledFunctionTable[60621] = bhControlPlayer_0x13a6e0; // 0x13b33c - g_ps2RecompiledFunctionTable[60622] = bhControlPlayer_0x13a6e0; // 0x13b340 - g_ps2RecompiledFunctionTable[60623] = bhControlPlayer_0x13a6e0; // 0x13b344 - g_ps2RecompiledFunctionTable[60624] = bhControlPlayer_0x13a6e0; // 0x13b348 - g_ps2RecompiledFunctionTable[60625] = bhControlPlayer_0x13a6e0; // 0x13b34c - g_ps2RecompiledFunctionTable[60626] = bhControlPlayer_0x13a6e0; // 0x13b350 - g_ps2RecompiledFunctionTable[60627] = bhControlPlayer_0x13a6e0; // 0x13b354 - g_ps2RecompiledFunctionTable[60628] = bhControlPlayer_0x13a6e0; // 0x13b358 - g_ps2RecompiledFunctionTable[60629] = bhControlPlayer_0x13a6e0; // 0x13b35c - g_ps2RecompiledFunctionTable[60630] = bhControlPlayer_0x13a6e0; // 0x13b360 - g_ps2RecompiledFunctionTable[60631] = bhControlPlayer_0x13a6e0; // 0x13b364 - g_ps2RecompiledFunctionTable[60632] = bhControlPlayer_0x13a6e0; // 0x13b368 - g_ps2RecompiledFunctionTable[60633] = bhControlPlayer_0x13a6e0; // 0x13b36c - g_ps2RecompiledFunctionTable[60634] = bhControlPlayer_0x13a6e0; // 0x13b370 - g_ps2RecompiledFunctionTable[60635] = bhControlPlayer_0x13a6e0; // 0x13b374 - g_ps2RecompiledFunctionTable[60636] = bhControlPlayer_0x13a6e0; // 0x13b378 - g_ps2RecompiledFunctionTable[60637] = bhControlPlayer_0x13a6e0; // 0x13b37c - g_ps2RecompiledFunctionTable[60638] = bhControlPlayer_0x13a6e0; // 0x13b380 - g_ps2RecompiledFunctionTable[60639] = bhControlPlayer_0x13a6e0; // 0x13b384 - g_ps2RecompiledFunctionTable[60640] = bhControlPlayer_0x13a6e0; // 0x13b388 - g_ps2RecompiledFunctionTable[60641] = bhControlPlayer_0x13a6e0; // 0x13b38c - g_ps2RecompiledFunctionTable[60642] = bhControlPlayer_0x13a6e0; // 0x13b390 - g_ps2RecompiledFunctionTable[60643] = bhControlPlayer_0x13a6e0; // 0x13b394 - g_ps2RecompiledFunctionTable[60644] = bhControlPlayer_0x13a6e0; // 0x13b398 - g_ps2RecompiledFunctionTable[60645] = bhControlPlayer_0x13a6e0; // 0x13b39c - g_ps2RecompiledFunctionTable[60646] = bhControlPlayer_0x13a6e0; // 0x13b3a0 - g_ps2RecompiledFunctionTable[60647] = bhControlPlayer_0x13a6e0; // 0x13b3a4 - g_ps2RecompiledFunctionTable[60648] = bhControlPlayer_0x13a6e0; // 0x13b3a8 - g_ps2RecompiledFunctionTable[60649] = bhControlPlayer_0x13a6e0; // 0x13b3ac - g_ps2RecompiledFunctionTable[60650] = bhControlPlayer_0x13a6e0; // 0x13b3b0 - g_ps2RecompiledFunctionTable[60651] = bhControlPlayer_0x13a6e0; // 0x13b3b4 - g_ps2RecompiledFunctionTable[60652] = bhControlPlayer_0x13a6e0; // 0x13b3b8 - g_ps2RecompiledFunctionTable[60653] = bhControlPlayer_0x13a6e0; // 0x13b3bc - g_ps2RecompiledFunctionTable[60654] = bhControlPlayer_0x13a6e0; // 0x13b3c0 - g_ps2RecompiledFunctionTable[60655] = bhControlPlayer_0x13a6e0; // 0x13b3c4 - g_ps2RecompiledFunctionTable[60656] = bhControlPlayer_0x13a6e0; // 0x13b3c8 - g_ps2RecompiledFunctionTable[60657] = bhControlPlayer_0x13a6e0; // 0x13b3cc - g_ps2RecompiledFunctionTable[60658] = bhControlPlayer_0x13a6e0; // 0x13b3d0 - g_ps2RecompiledFunctionTable[60659] = bhControlPlayer_0x13a6e0; // 0x13b3d4 - g_ps2RecompiledFunctionTable[60660] = bhControlPlayer_0x13a6e0; // 0x13b3d8 - g_ps2RecompiledFunctionTable[60661] = bhControlPlayer_0x13a6e0; // 0x13b3dc - g_ps2RecompiledFunctionTable[60662] = bhControlPlayer_0x13a6e0; // 0x13b3e0 - g_ps2RecompiledFunctionTable[60663] = bhControlPlayer_0x13a6e0; // 0x13b3e4 - g_ps2RecompiledFunctionTable[60664] = bhControlPlayer_0x13a6e0; // 0x13b3e8 - g_ps2RecompiledFunctionTable[60665] = bhControlPlayer_0x13a6e0; // 0x13b3ec - g_ps2RecompiledFunctionTable[60666] = bhControlPlayer_0x13a6e0; // 0x13b3f0 - g_ps2RecompiledFunctionTable[60667] = bhControlPlayer_0x13a6e0; // 0x13b3f4 - g_ps2RecompiledFunctionTable[60668] = bhControlPlayer_0x13a6e0; // 0x13b3f8 - g_ps2RecompiledFunctionTable[60669] = bhControlPlayer_0x13a6e0; // 0x13b3fc - g_ps2RecompiledFunctionTable[60670] = bhControlPlayer_0x13a6e0; // 0x13b400 - g_ps2RecompiledFunctionTable[60671] = bhControlPlayer_0x13a6e0; // 0x13b404 - g_ps2RecompiledFunctionTable[60672] = bhControlPlayer_0x13a6e0; // 0x13b408 - g_ps2RecompiledFunctionTable[60673] = bhControlPlayer_0x13a6e0; // 0x13b40c - g_ps2RecompiledFunctionTable[60674] = bhControlPlayer_0x13a6e0; // 0x13b410 - g_ps2RecompiledFunctionTable[60675] = bhControlPlayer_0x13a6e0; // 0x13b414 - g_ps2RecompiledFunctionTable[60676] = bhControlPlayer_0x13a6e0; // 0x13b418 - g_ps2RecompiledFunctionTable[60677] = bhControlPlayer_0x13a6e0; // 0x13b41c - g_ps2RecompiledFunctionTable[60678] = bhControlPlayer_0x13a6e0; // 0x13b420 - g_ps2RecompiledFunctionTable[60679] = bhControlPlayer_0x13a6e0; // 0x13b424 - g_ps2RecompiledFunctionTable[60680] = bhControlPlayer_0x13a6e0; // 0x13b428 - g_ps2RecompiledFunctionTable[60681] = bhControlPlayer_0x13a6e0; // 0x13b42c - g_ps2RecompiledFunctionTable[60682] = bhControlPlayer_0x13a6e0; // 0x13b430 - g_ps2RecompiledFunctionTable[60683] = bhControlPlayer_0x13a6e0; // 0x13b434 - g_ps2RecompiledFunctionTable[60684] = bhControlPlayer_0x13a6e0; // 0x13b438 - g_ps2RecompiledFunctionTable[60685] = bhControlPlayer_0x13a6e0; // 0x13b43c - g_ps2RecompiledFunctionTable[60686] = bhControlPlayer_0x13a6e0; // 0x13b440 - g_ps2RecompiledFunctionTable[60687] = bhControlPlayer_0x13a6e0; // 0x13b444 - g_ps2RecompiledFunctionTable[60688] = bhControlPlayer_0x13a6e0; // 0x13b448 - g_ps2RecompiledFunctionTable[60689] = bhControlPlayer_0x13a6e0; // 0x13b44c - g_ps2RecompiledFunctionTable[60690] = bhControlPlayer_0x13a6e0; // 0x13b450 - g_ps2RecompiledFunctionTable[60691] = bhControlPlayer_0x13a6e0; // 0x13b454 - g_ps2RecompiledFunctionTable[60692] = bhControlPlayer_0x13a6e0; // 0x13b458 - g_ps2RecompiledFunctionTable[60693] = bhControlPlayer_0x13a6e0; // 0x13b45c - g_ps2RecompiledFunctionTable[60694] = bhControlPlayer_0x13a6e0; // 0x13b460 - g_ps2RecompiledFunctionTable[60695] = bhControlPlayer_0x13a6e0; // 0x13b464 - g_ps2RecompiledFunctionTable[60696] = bhControlPlayer_0x13a6e0; // 0x13b468 - g_ps2RecompiledFunctionTable[60697] = bhControlPlayer_0x13a6e0; // 0x13b46c - g_ps2RecompiledFunctionTable[60698] = bhControlPlayer_0x13a6e0; // 0x13b470 - g_ps2RecompiledFunctionTable[60699] = bhControlPlayer_0x13a6e0; // 0x13b474 - g_ps2RecompiledFunctionTable[60700] = bhControlPlayer_0x13a6e0; // 0x13b478 - g_ps2RecompiledFunctionTable[60701] = bhControlPlayer_0x13a6e0; // 0x13b47c - g_ps2RecompiledFunctionTable[60702] = bhControlPlayer_0x13a6e0; // 0x13b480 - g_ps2RecompiledFunctionTable[60703] = bhControlPlayer_0x13a6e0; // 0x13b484 - g_ps2RecompiledFunctionTable[60704] = bhControlPlayer_0x13a6e0; // 0x13b488 - g_ps2RecompiledFunctionTable[60705] = bhControlPlayer_0x13a6e0; // 0x13b48c - g_ps2RecompiledFunctionTable[60706] = bhControlPlayer_0x13a6e0; // 0x13b490 - g_ps2RecompiledFunctionTable[60707] = bhControlPlayer_0x13a6e0; // 0x13b494 - g_ps2RecompiledFunctionTable[60708] = bhControlPlayer_0x13a6e0; // 0x13b498 - g_ps2RecompiledFunctionTable[60709] = bhControlPlayer_0x13a6e0; // 0x13b49c - g_ps2RecompiledFunctionTable[60710] = bhControlPlayer_0x13a6e0; // 0x13b4a0 - g_ps2RecompiledFunctionTable[60711] = bhControlPlayer_0x13a6e0; // 0x13b4a4 - g_ps2RecompiledFunctionTable[60712] = bhControlPlayer_0x13a6e0; // 0x13b4a8 - g_ps2RecompiledFunctionTable[60713] = bhControlPlayer_0x13a6e0; // 0x13b4ac - g_ps2RecompiledFunctionTable[60714] = bhControlPlayer_0x13a6e0; // 0x13b4b0 - g_ps2RecompiledFunctionTable[60715] = bhControlPlayer_0x13a6e0; // 0x13b4b4 - g_ps2RecompiledFunctionTable[60716] = bhControlPlayer_0x13a6e0; // 0x13b4b8 - g_ps2RecompiledFunctionTable[60717] = bhControlPlayer_0x13a6e0; // 0x13b4bc - g_ps2RecompiledFunctionTable[60718] = bhControlPlayer_0x13a6e0; // 0x13b4c0 - g_ps2RecompiledFunctionTable[60719] = bhControlPlayer_0x13a6e0; // 0x13b4c4 - g_ps2RecompiledFunctionTable[60720] = bhControlPlayer_0x13a6e0; // 0x13b4c8 - g_ps2RecompiledFunctionTable[60721] = bhControlPlayer_0x13a6e0; // 0x13b4cc - g_ps2RecompiledFunctionTable[60722] = bhControlPlayer_0x13a6e0; // 0x13b4d0 - g_ps2RecompiledFunctionTable[60723] = bhControlPlayer_0x13a6e0; // 0x13b4d4 - g_ps2RecompiledFunctionTable[60724] = bhControlPlayer_0x13a6e0; // 0x13b4d8 - g_ps2RecompiledFunctionTable[60725] = bhControlPlayer_0x13a6e0; // 0x13b4dc - g_ps2RecompiledFunctionTable[60726] = bhControlPlayer_0x13a6e0; // 0x13b4e0 - g_ps2RecompiledFunctionTable[60727] = bhControlPlayer_0x13a6e0; // 0x13b4e4 - g_ps2RecompiledFunctionTable[60728] = bhControlPlayer_0x13a6e0; // 0x13b4e8 - g_ps2RecompiledFunctionTable[60729] = bhControlPlayer_0x13a6e0; // 0x13b4ec - g_ps2RecompiledFunctionTable[60730] = bhControlPlayer_0x13a6e0; // 0x13b4f0 - g_ps2RecompiledFunctionTable[60731] = bhControlPlayer_0x13a6e0; // 0x13b4f4 - g_ps2RecompiledFunctionTable[60732] = bhControlPlayer_0x13a6e0; // 0x13b4f8 - g_ps2RecompiledFunctionTable[60733] = bhControlPlayer_0x13a6e0; // 0x13b4fc - g_ps2RecompiledFunctionTable[60734] = bhControlPlayer_0x13a6e0; // 0x13b500 - g_ps2RecompiledFunctionTable[60735] = bhControlPlayer_0x13a6e0; // 0x13b504 - g_ps2RecompiledFunctionTable[60736] = bhControlPlayer_0x13a6e0; // 0x13b508 - g_ps2RecompiledFunctionTable[60737] = bhControlPlayer_0x13a6e0; // 0x13b50c - g_ps2RecompiledFunctionTable[60738] = bhControlPlayer_0x13a6e0; // 0x13b510 - g_ps2RecompiledFunctionTable[60739] = bhControlPlayer_0x13a6e0; // 0x13b514 - g_ps2RecompiledFunctionTable[60740] = bhControlPlayer_0x13a6e0; // 0x13b518 - g_ps2RecompiledFunctionTable[60741] = bhControlPlayer_0x13a6e0; // 0x13b51c - g_ps2RecompiledFunctionTable[60742] = bhControlPlayer_0x13a6e0; // 0x13b520 - g_ps2RecompiledFunctionTable[60743] = bhControlPlayer_0x13a6e0; // 0x13b524 - g_ps2RecompiledFunctionTable[60744] = bhControlPlayer_0x13a6e0; // 0x13b528 - g_ps2RecompiledFunctionTable[60745] = bhControlPlayer_0x13a6e0; // 0x13b52c - g_ps2RecompiledFunctionTable[60746] = bhControlPlayer_0x13a6e0; // 0x13b530 - g_ps2RecompiledFunctionTable[60747] = bhControlPlayer_0x13a6e0; // 0x13b534 - g_ps2RecompiledFunctionTable[60748] = bhControlPlayer_0x13a6e0; // 0x13b538 - g_ps2RecompiledFunctionTable[60749] = bhControlPlayer_0x13a6e0; // 0x13b53c - g_ps2RecompiledFunctionTable[60750] = bhControlPlayer_0x13a6e0; // 0x13b540 - g_ps2RecompiledFunctionTable[60751] = bhControlPlayer_0x13a6e0; // 0x13b544 - g_ps2RecompiledFunctionTable[60752] = bhControlPlayer_0x13a6e0; // 0x13b548 - g_ps2RecompiledFunctionTable[60753] = bhControlPlayer_0x13a6e0; // 0x13b54c - g_ps2RecompiledFunctionTable[60754] = bhControlPlayer_0x13a6e0; // 0x13b550 - g_ps2RecompiledFunctionTable[60755] = bhControlPlayer_0x13a6e0; // 0x13b554 - g_ps2RecompiledFunctionTable[60756] = bhControlPlayer_0x13a6e0; // 0x13b558 - g_ps2RecompiledFunctionTable[60757] = bhControlPlayer_0x13a6e0; // 0x13b55c - g_ps2RecompiledFunctionTable[60758] = bhControlPlayer_0x13a6e0; // 0x13b560 - g_ps2RecompiledFunctionTable[60759] = bhControlPlayer_0x13a6e0; // 0x13b564 - g_ps2RecompiledFunctionTable[60760] = bhControlPlayer_0x13a6e0; // 0x13b568 - g_ps2RecompiledFunctionTable[60761] = bhControlPlayer_0x13a6e0; // 0x13b56c - g_ps2RecompiledFunctionTable[60762] = bhControlPlayer_0x13a6e0; // 0x13b570 - g_ps2RecompiledFunctionTable[60763] = bhControlPlayer_0x13a6e0; // 0x13b574 - g_ps2RecompiledFunctionTable[60764] = bhControlPlayer_0x13a6e0; // 0x13b578 - g_ps2RecompiledFunctionTable[60765] = bhControlPlayer_0x13a6e0; // 0x13b57c - g_ps2RecompiledFunctionTable[60766] = bhControlPlayer_0x13a6e0; // 0x13b580 - g_ps2RecompiledFunctionTable[60767] = bhControlPlayer_0x13a6e0; // 0x13b584 - g_ps2RecompiledFunctionTable[60768] = bhControlPlayer_0x13a6e0; // 0x13b588 - g_ps2RecompiledFunctionTable[60769] = bhControlPlayer_0x13a6e0; // 0x13b58c - g_ps2RecompiledFunctionTable[60770] = bhControlPlayer_0x13a6e0; // 0x13b590 - g_ps2RecompiledFunctionTable[60771] = bhControlPlayer_0x13a6e0; // 0x13b594 - g_ps2RecompiledFunctionTable[60772] = bhControlPlayer_0x13a6e0; // 0x13b598 - g_ps2RecompiledFunctionTable[60773] = bhControlPlayer_0x13a6e0; // 0x13b59c - g_ps2RecompiledFunctionTable[60774] = bhControlPlayer_0x13a6e0; // 0x13b5a0 - g_ps2RecompiledFunctionTable[60775] = bhControlPlayer_0x13a6e0; // 0x13b5a4 - g_ps2RecompiledFunctionTable[60776] = bhControlPlayer_0x13a6e0; // 0x13b5a8 - g_ps2RecompiledFunctionTable[60777] = bhControlPlayer_0x13a6e0; // 0x13b5ac - g_ps2RecompiledFunctionTable[60778] = bhControlPlayer_0x13a6e0; // 0x13b5b0 - g_ps2RecompiledFunctionTable[60779] = bhControlPlayer_0x13a6e0; // 0x13b5b4 - g_ps2RecompiledFunctionTable[60780] = bhControlPlayer_0x13a6e0; // 0x13b5b8 - g_ps2RecompiledFunctionTable[60781] = bhControlPlayer_0x13a6e0; // 0x13b5bc - g_ps2RecompiledFunctionTable[60782] = bhControlPlayer_0x13a6e0; // 0x13b5c0 - g_ps2RecompiledFunctionTable[60783] = bhControlPlayer_0x13a6e0; // 0x13b5c4 - g_ps2RecompiledFunctionTable[60784] = bhControlPlayer_0x13a6e0; // 0x13b5c8 - g_ps2RecompiledFunctionTable[60785] = bhControlPlayer_0x13a6e0; // 0x13b5cc - g_ps2RecompiledFunctionTable[60786] = bhControlPlayer_0x13a6e0; // 0x13b5d0 - g_ps2RecompiledFunctionTable[60787] = bhControlPlayer_0x13a6e0; // 0x13b5d4 - g_ps2RecompiledFunctionTable[60788] = bhControlPlayer_0x13a6e0; // 0x13b5d8 - g_ps2RecompiledFunctionTable[60789] = bhControlPlayer_0x13a6e0; // 0x13b5dc - g_ps2RecompiledFunctionTable[60790] = bhControlPlayer_0x13a6e0; // 0x13b5e0 - g_ps2RecompiledFunctionTable[60791] = bhControlPlayer_0x13a6e0; // 0x13b5e4 - g_ps2RecompiledFunctionTable[60792] = bhControlPlayer_0x13a6e0; // 0x13b5e8 - g_ps2RecompiledFunctionTable[60793] = bhControlPlayer_0x13a6e0; // 0x13b5ec - g_ps2RecompiledFunctionTable[60794] = bhControlPlayer_0x13a6e0; // 0x13b5f0 - g_ps2RecompiledFunctionTable[60795] = bhControlPlayer_0x13a6e0; // 0x13b5f4 - g_ps2RecompiledFunctionTable[60796] = bhControlPlayer_0x13a6e0; // 0x13b5f8 - g_ps2RecompiledFunctionTable[60797] = bhControlPlayer_0x13a6e0; // 0x13b5fc - g_ps2RecompiledFunctionTable[60798] = bhControlPlayer_0x13a6e0; // 0x13b600 - g_ps2RecompiledFunctionTable[60799] = bhControlPlayer_0x13a6e0; // 0x13b604 - g_ps2RecompiledFunctionTable[60800] = bhControlPlayer_0x13a6e0; // 0x13b608 - g_ps2RecompiledFunctionTable[60801] = bhControlPlayer_0x13a6e0; // 0x13b60c - g_ps2RecompiledFunctionTable[60802] = bhControlPlayer_0x13a6e0; // 0x13b610 - g_ps2RecompiledFunctionTable[60803] = bhControlPlayer_0x13a6e0; // 0x13b614 - g_ps2RecompiledFunctionTable[60804] = bhControlPlayer_0x13a6e0; // 0x13b618 - g_ps2RecompiledFunctionTable[60805] = bhControlPlayer_0x13a6e0; // 0x13b61c - g_ps2RecompiledFunctionTable[60806] = bhControlPlayer_0x13a6e0; // 0x13b620 - g_ps2RecompiledFunctionTable[60807] = bhControlPlayer_0x13a6e0; // 0x13b624 - g_ps2RecompiledFunctionTable[60808] = bhControlPlayer_0x13a6e0; // 0x13b628 - g_ps2RecompiledFunctionTable[60809] = bhControlPlayer_0x13a6e0; // 0x13b62c - g_ps2RecompiledFunctionTable[60810] = bhControlPlayer_0x13a6e0; // 0x13b630 - g_ps2RecompiledFunctionTable[60811] = bhControlPlayer_0x13a6e0; // 0x13b634 - g_ps2RecompiledFunctionTable[60812] = bhControlPlayer_0x13a6e0; // 0x13b638 - g_ps2RecompiledFunctionTable[60813] = bhControlPlayer_0x13a6e0; // 0x13b63c - g_ps2RecompiledFunctionTable[60814] = bhControlPlayer_0x13a6e0; // 0x13b640 - g_ps2RecompiledFunctionTable[60815] = bhControlPlayer_0x13a6e0; // 0x13b644 - g_ps2RecompiledFunctionTable[60816] = bhControlPlayer_0x13a6e0; // 0x13b648 - g_ps2RecompiledFunctionTable[60817] = bhControlPlayer_0x13a6e0; // 0x13b64c - g_ps2RecompiledFunctionTable[60818] = bhControlPlayer_0x13a6e0; // 0x13b650 - g_ps2RecompiledFunctionTable[60819] = bhControlPlayer_0x13a6e0; // 0x13b654 - g_ps2RecompiledFunctionTable[60820] = bhControlPlayer_0x13a6e0; // 0x13b658 - g_ps2RecompiledFunctionTable[60821] = bhControlPlayer_0x13a6e0; // 0x13b65c - g_ps2RecompiledFunctionTable[60822] = bhControlPlayer_0x13a6e0; // 0x13b660 - g_ps2RecompiledFunctionTable[60823] = bhControlPlayer_0x13a6e0; // 0x13b664 - g_ps2RecompiledFunctionTable[60824] = bhControlPlayer_0x13a6e0; // 0x13b668 - g_ps2RecompiledFunctionTable[60825] = bhControlPlayer_0x13a6e0; // 0x13b66c - g_ps2RecompiledFunctionTable[60826] = bhControlPlayer_0x13a6e0; // 0x13b670 - g_ps2RecompiledFunctionTable[60827] = bhControlPlayer_0x13a6e0; // 0x13b674 - g_ps2RecompiledFunctionTable[60828] = bhControlPlayer_0x13a6e0; // 0x13b678 - g_ps2RecompiledFunctionTable[60829] = bhControlPlayer_0x13a6e0; // 0x13b67c - g_ps2RecompiledFunctionTable[60830] = bhControlPlayer_0x13a6e0; // 0x13b680 - g_ps2RecompiledFunctionTable[60831] = bhControlPlayer_0x13a6e0; // 0x13b684 - g_ps2RecompiledFunctionTable[60832] = bhControlPlayer_0x13a6e0; // 0x13b688 - g_ps2RecompiledFunctionTable[60833] = bhControlPlayer_0x13a6e0; // 0x13b68c - g_ps2RecompiledFunctionTable[60834] = bhControlPlayer_0x13a6e0; // 0x13b690 - g_ps2RecompiledFunctionTable[60835] = bhControlPlayer_0x13a6e0; // 0x13b694 - g_ps2RecompiledFunctionTable[60836] = bhControlPlayer_0x13a6e0; // 0x13b698 - g_ps2RecompiledFunctionTable[60837] = bhControlPlayer_0x13a6e0; // 0x13b69c - g_ps2RecompiledFunctionTable[60838] = bhControlPlayer_0x13a6e0; // 0x13b6a0 - g_ps2RecompiledFunctionTable[60839] = bhControlPlayer_0x13a6e0; // 0x13b6a4 - g_ps2RecompiledFunctionTable[60840] = bhControlPlayer_0x13a6e0; // 0x13b6a8 - g_ps2RecompiledFunctionTable[60841] = bhControlPlayer_0x13a6e0; // 0x13b6ac - g_ps2RecompiledFunctionTable[60842] = bhControlPlayer_0x13a6e0; // 0x13b6b0 - g_ps2RecompiledFunctionTable[60843] = bhControlPlayer_0x13a6e0; // 0x13b6b4 - g_ps2RecompiledFunctionTable[60844] = bhControlPlayer_0x13a6e0; // 0x13b6b8 - g_ps2RecompiledFunctionTable[60845] = bhControlPlayer_0x13a6e0; // 0x13b6bc - g_ps2RecompiledFunctionTable[60846] = bhControlPlayer_0x13a6e0; // 0x13b6c0 - g_ps2RecompiledFunctionTable[60847] = bhControlPlayer_0x13a6e0; // 0x13b6c4 - g_ps2RecompiledFunctionTable[60848] = bhControlPlayer_0x13a6e0; // 0x13b6c8 - g_ps2RecompiledFunctionTable[60849] = bhControlPlayer_0x13a6e0; // 0x13b6cc - g_ps2RecompiledFunctionTable[60850] = bhControlPlayer_0x13a6e0; // 0x13b6d0 - g_ps2RecompiledFunctionTable[60851] = bhControlPlayer_0x13a6e0; // 0x13b6d4 - g_ps2RecompiledFunctionTable[60852] = bhControlPlayer_0x13a6e0; // 0x13b6d8 - g_ps2RecompiledFunctionTable[60853] = bhControlPlayer_0x13a6e0; // 0x13b6dc - g_ps2RecompiledFunctionTable[60854] = bhControlPlayer_0x13a6e0; // 0x13b6e0 - g_ps2RecompiledFunctionTable[60855] = bhControlPlayer_0x13a6e0; // 0x13b6e4 - g_ps2RecompiledFunctionTable[60856] = bhControlPlayer_0x13a6e0; // 0x13b6e8 - g_ps2RecompiledFunctionTable[60857] = bhControlPlayer_0x13a6e0; // 0x13b6ec - g_ps2RecompiledFunctionTable[60858] = bhControlPlayer_0x13a6e0; // 0x13b6f0 - g_ps2RecompiledFunctionTable[60859] = bhControlPlayer_0x13a6e0; // 0x13b6f4 - g_ps2RecompiledFunctionTable[60860] = bhControlPlayer_0x13a6e0; // 0x13b6f8 - g_ps2RecompiledFunctionTable[60861] = bhControlPlayer_0x13a6e0; // 0x13b6fc - g_ps2RecompiledFunctionTable[60862] = bhControlPlayer_0x13a6e0; // 0x13b700 - g_ps2RecompiledFunctionTable[60863] = bhControlPlayer_0x13a6e0; // 0x13b704 - g_ps2RecompiledFunctionTable[60864] = bhControlPlayer_0x13a6e0; // 0x13b708 - g_ps2RecompiledFunctionTable[60865] = bhControlPlayer_0x13a6e0; // 0x13b70c - g_ps2RecompiledFunctionTable[60866] = bhControlPlayer_0x13a6e0; // 0x13b710 - g_ps2RecompiledFunctionTable[60867] = bhControlPlayer_0x13a6e0; // 0x13b714 - g_ps2RecompiledFunctionTable[60868] = bhControlPlayer_0x13a6e0; // 0x13b718 - g_ps2RecompiledFunctionTable[60869] = bhControlPlayer_0x13a6e0; // 0x13b71c - g_ps2RecompiledFunctionTable[60870] = bhControlPlayer_0x13a6e0; // 0x13b720 - g_ps2RecompiledFunctionTable[60871] = bhControlPlayer_0x13a6e0; // 0x13b724 - g_ps2RecompiledFunctionTable[60872] = bhControlPlayer_0x13a6e0; // 0x13b728 - g_ps2RecompiledFunctionTable[60873] = bhControlPlayer_0x13a6e0; // 0x13b72c - g_ps2RecompiledFunctionTable[60874] = bhControlPlayer_0x13a6e0; // 0x13b730 - g_ps2RecompiledFunctionTable[60875] = bhControlPlayer_0x13a6e0; // 0x13b734 - g_ps2RecompiledFunctionTable[60876] = bhControlPlayer_0x13a6e0; // 0x13b738 - g_ps2RecompiledFunctionTable[60877] = bhControlPlayer_0x13a6e0; // 0x13b73c - g_ps2RecompiledFunctionTable[60878] = bhControlPlayer_0x13a6e0; // 0x13b740 - g_ps2RecompiledFunctionTable[60879] = bhControlPlayer_0x13a6e0; // 0x13b744 - g_ps2RecompiledFunctionTable[60880] = bhControlPlayer_0x13a6e0; // 0x13b748 - g_ps2RecompiledFunctionTable[60881] = bhControlPlayer_0x13a6e0; // 0x13b74c - g_ps2RecompiledFunctionTable[60882] = bhControlPlayer_0x13a6e0; // 0x13b750 - g_ps2RecompiledFunctionTable[60883] = bhControlPlayer_0x13a6e0; // 0x13b754 - g_ps2RecompiledFunctionTable[60884] = bhControlPlayer_0x13a6e0; // 0x13b758 - g_ps2RecompiledFunctionTable[60885] = bhControlPlayer_0x13a6e0; // 0x13b75c - g_ps2RecompiledFunctionTable[60886] = bhControlPlayer_0x13a6e0; // 0x13b760 - g_ps2RecompiledFunctionTable[60887] = bhControlPlayer_0x13a6e0; // 0x13b764 - g_ps2RecompiledFunctionTable[60888] = bhControlPlayer_0x13a6e0; // 0x13b768 - g_ps2RecompiledFunctionTable[60889] = bhControlPlayer_0x13a6e0; // 0x13b76c - g_ps2RecompiledFunctionTable[60890] = bhControlPlayer_0x13a6e0; // 0x13b770 - g_ps2RecompiledFunctionTable[60891] = bhControlPlayer_0x13a6e0; // 0x13b774 - g_ps2RecompiledFunctionTable[60892] = bhControlPlayer_0x13a6e0; // 0x13b778 - g_ps2RecompiledFunctionTable[60893] = bhControlPlayer_0x13a6e0; // 0x13b77c - g_ps2RecompiledFunctionTable[60894] = bhControlPlayer_0x13a6e0; // 0x13b780 - g_ps2RecompiledFunctionTable[60895] = bhControlPlayer_0x13a6e0; // 0x13b784 - g_ps2RecompiledFunctionTable[60896] = bhControlPlayer_0x13a6e0; // 0x13b788 - g_ps2RecompiledFunctionTable[60897] = bhControlPlayer_0x13a6e0; // 0x13b78c - g_ps2RecompiledFunctionTable[60898] = bhControlPlayer_0x13a6e0; // 0x13b790 - g_ps2RecompiledFunctionTable[60899] = bhControlPlayer_0x13a6e0; // 0x13b794 - g_ps2RecompiledFunctionTable[60900] = bhControlPlayer_0x13a6e0; // 0x13b798 - g_ps2RecompiledFunctionTable[60901] = bhControlPlayer_0x13a6e0; // 0x13b79c - g_ps2RecompiledFunctionTable[60902] = bhControlPlayer_0x13a6e0; // 0x13b7a0 - g_ps2RecompiledFunctionTable[60903] = bhControlPlayer_0x13a6e0; // 0x13b7a4 - g_ps2RecompiledFunctionTable[60904] = bhControlPlayer_0x13a6e0; // 0x13b7a8 - g_ps2RecompiledFunctionTable[60905] = bhControlPlayer_0x13a6e0; // 0x13b7ac - g_ps2RecompiledFunctionTable[60906] = bhControlPlayer_0x13a6e0; // 0x13b7b0 - g_ps2RecompiledFunctionTable[60907] = bhControlPlayer_0x13a6e0; // 0x13b7b4 - g_ps2RecompiledFunctionTable[60908] = bhControlPlayer_0x13a6e0; // 0x13b7b8 - g_ps2RecompiledFunctionTable[60909] = bhControlPlayer_0x13a6e0; // 0x13b7bc - g_ps2RecompiledFunctionTable[60910] = bhControlPlayer_0x13a6e0; // 0x13b7c0 - g_ps2RecompiledFunctionTable[60911] = bhControlPlayer_0x13a6e0; // 0x13b7c4 - g_ps2RecompiledFunctionTable[60912] = bhControlPlayer_0x13a6e0; // 0x13b7c8 - g_ps2RecompiledFunctionTable[60913] = bhControlPlayer_0x13a6e0; // 0x13b7cc - g_ps2RecompiledFunctionTable[60914] = bhControlPlayer_0x13a6e0; // 0x13b7d0 - g_ps2RecompiledFunctionTable[60915] = bhControlPlayer_0x13a6e0; // 0x13b7d4 - g_ps2RecompiledFunctionTable[60916] = bhControlPlayer_0x13a6e0; // 0x13b7d8 - g_ps2RecompiledFunctionTable[60917] = bhControlPlayer_0x13a6e0; // 0x13b7dc - g_ps2RecompiledFunctionTable[60918] = bhControlPlayer_0x13a6e0; // 0x13b7e0 - g_ps2RecompiledFunctionTable[60919] = bhControlPlayer_0x13a6e0; // 0x13b7e4 - g_ps2RecompiledFunctionTable[60920] = bhControlPlayer_0x13a6e0; // 0x13b7e8 - g_ps2RecompiledFunctionTable[60921] = bhControlPlayer_0x13a6e0; // 0x13b7ec - g_ps2RecompiledFunctionTable[60922] = bhControlPlayer_0x13a6e0; // 0x13b7f0 - g_ps2RecompiledFunctionTable[60923] = bhControlPlayer_0x13a6e0; // 0x13b7f4 - g_ps2RecompiledFunctionTable[60924] = bhControlPlayer_0x13a6e0; // 0x13b7f8 - g_ps2RecompiledFunctionTable[60925] = bhControlPlayer_0x13a6e0; // 0x13b7fc - g_ps2RecompiledFunctionTable[60926] = bhControlPlayer_0x13a6e0; // 0x13b800 - g_ps2RecompiledFunctionTable[60927] = bhControlPlayer_0x13a6e0; // 0x13b804 - g_ps2RecompiledFunctionTable[60928] = bhControlPlayer_0x13a6e0; // 0x13b808 - g_ps2RecompiledFunctionTable[60929] = bhControlPlayer_0x13a6e0; // 0x13b80c - g_ps2RecompiledFunctionTable[60930] = bhControlPlayer_0x13a6e0; // 0x13b810 - g_ps2RecompiledFunctionTable[60931] = bhControlPlayer_0x13a6e0; // 0x13b814 - g_ps2RecompiledFunctionTable[60932] = bhControlPlayer_0x13a6e0; // 0x13b818 - g_ps2RecompiledFunctionTable[60933] = bhControlPlayer_0x13a6e0; // 0x13b81c - g_ps2RecompiledFunctionTable[60934] = bhControlPlayer_0x13a6e0; // 0x13b820 - g_ps2RecompiledFunctionTable[60935] = bhControlPlayer_0x13a6e0; // 0x13b824 - g_ps2RecompiledFunctionTable[60936] = bhControlPlayer_0x13a6e0; // 0x13b828 - g_ps2RecompiledFunctionTable[60937] = bhControlPlayer_0x13a6e0; // 0x13b82c - g_ps2RecompiledFunctionTable[60938] = bhControlPlayer_0x13a6e0; // 0x13b830 - g_ps2RecompiledFunctionTable[60939] = bhControlPlayer_0x13a6e0; // 0x13b834 - g_ps2RecompiledFunctionTable[60940] = bhControlPlayer_0x13a6e0; // 0x13b838 - g_ps2RecompiledFunctionTable[60941] = bhControlPlayer_0x13a6e0; // 0x13b83c - g_ps2RecompiledFunctionTable[60942] = bhControlPlayer_0x13a6e0; // 0x13b840 - g_ps2RecompiledFunctionTable[60943] = bhControlPlayer_0x13a6e0; // 0x13b844 - g_ps2RecompiledFunctionTable[60944] = bhControlPlayer_0x13a6e0; // 0x13b848 - g_ps2RecompiledFunctionTable[60945] = bhControlPlayer_0x13a6e0; // 0x13b84c - g_ps2RecompiledFunctionTable[60946] = bhControlPlayer_0x13a6e0; // 0x13b850 - g_ps2RecompiledFunctionTable[60947] = bhControlPlayer_0x13a6e0; // 0x13b854 - g_ps2RecompiledFunctionTable[60948] = bhControlPlayer_0x13a6e0; // 0x13b858 - g_ps2RecompiledFunctionTable[60950] = bhCPM0_action_0x13b860; // 0x13b860 - g_ps2RecompiledFunctionTable[61044] = bhCPM0_action_0x13b860; // 0x13b9d8 - g_ps2RecompiledFunctionTable[61051] = bhCPM0_action_0x13b860; // 0x13b9f4 - g_ps2RecompiledFunctionTable[61055] = bhCPM0_action_0x13b860; // 0x13ba04 - g_ps2RecompiledFunctionTable[61058] = bhControlPlayerPad_0x13ba10; // 0x13ba10 - g_ps2RecompiledFunctionTable[61306] = bhCPM1_act_bas_0x13bdf0; // 0x13bdf0 - g_ps2RecompiledFunctionTable[61355] = bhCPM1_act_bas_0x13bdf0; // 0x13beb4 - g_ps2RecompiledFunctionTable[61369] = bhCPM1_act_bas_0x13bdf0; // 0x13beec - g_ps2RecompiledFunctionTable[61405] = bhCPM1_act_bas_0x13bdf0; // 0x13bf7c - g_ps2RecompiledFunctionTable[61419] = bhCPM1_act_bas_0x13bdf0; // 0x13bfb4 - g_ps2RecompiledFunctionTable[61427] = bhCPM1_act_bas_0x13bdf0; // 0x13bfd4 - g_ps2RecompiledFunctionTable[61441] = bhCPM1_act_bas_0x13bdf0; // 0x13c00c - g_ps2RecompiledFunctionTable[61449] = bhCPM1_act_bas_0x13bdf0; // 0x13c02c - g_ps2RecompiledFunctionTable[61453] = bhCPM1_act_bas_0x13bdf0; // 0x13c03c - g_ps2RecompiledFunctionTable[61466] = bhCPM1_act_bas_0x13bdf0; // 0x13c070 - g_ps2RecompiledFunctionTable[61470] = bhCPM1_act_bas_0x13bdf0; // 0x13c080 - g_ps2RecompiledFunctionTable[61483] = bhCPM1_act_bas_0x13bdf0; // 0x13c0b4 - g_ps2RecompiledFunctionTable[61487] = bhCPM1_act_bas_0x13bdf0; // 0x13c0c4 - g_ps2RecompiledFunctionTable[61491] = bhCPM1_act_bas_0x13bdf0; // 0x13c0d4 - g_ps2RecompiledFunctionTable[61495] = bhCPM1_act_bas_0x13bdf0; // 0x13c0e4 - g_ps2RecompiledFunctionTable[61508] = bhCPM1_act_bas_0x13bdf0; // 0x13c118 - g_ps2RecompiledFunctionTable[61512] = bhCPM1_act_bas_0x13bdf0; // 0x13c128 - g_ps2RecompiledFunctionTable[61525] = bhCPM1_act_bas_0x13bdf0; // 0x13c15c - g_ps2RecompiledFunctionTable[61529] = bhCPM1_act_bas_0x13bdf0; // 0x13c16c - g_ps2RecompiledFunctionTable[61533] = bhCPM1_act_bas_0x13bdf0; // 0x13c17c - g_ps2RecompiledFunctionTable[61537] = bhCPM1_act_bas_0x13bdf0; // 0x13c18c - g_ps2RecompiledFunctionTable[61541] = bhCPM1_act_bas_0x13bdf0; // 0x13c19c - g_ps2RecompiledFunctionTable[61545] = bhCPM1_act_bas_0x13bdf0; // 0x13c1ac - g_ps2RecompiledFunctionTable[61549] = bhCPM1_act_bas_0x13bdf0; // 0x13c1bc - g_ps2RecompiledFunctionTable[61553] = bhCPM1_act_bas_0x13bdf0; // 0x13c1cc - g_ps2RecompiledFunctionTable[61557] = bhCPM1_act_bas_0x13bdf0; // 0x13c1dc - g_ps2RecompiledFunctionTable[61561] = bhCPM1_act_bas_0x13bdf0; // 0x13c1ec - g_ps2RecompiledFunctionTable[61565] = bhCPM1_act_bas_0x13bdf0; // 0x13c1fc - g_ps2RecompiledFunctionTable[61569] = bhCPM1_act_bas_0x13bdf0; // 0x13c20c - g_ps2RecompiledFunctionTable[61573] = bhCPM1_act_bas_0x13bdf0; // 0x13c21c - g_ps2RecompiledFunctionTable[61586] = bhCPM2_act_std_0x13c250; // 0x13c250 - g_ps2RecompiledFunctionTable[61770] = bhCPM2_act_srt_0x13c530; // 0x13c530 - g_ps2RecompiledFunctionTable[61877] = bhCPM2_act_srt_0x13c530; // 0x13c6dc - g_ps2RecompiledFunctionTable[61886] = bhCPM2_act_srt_0x13c530; // 0x13c700 - g_ps2RecompiledFunctionTable[61903] = bhCPM2_act_srt_0x13c530; // 0x13c744 - g_ps2RecompiledFunctionTable[61927] = bhCPM2_act_srt_0x13c530; // 0x13c7a4 - g_ps2RecompiledFunctionTable[61937] = bhCPM2_act_srt_0x13c530; // 0x13c7cc - g_ps2RecompiledFunctionTable[61968] = bhCPM2_act_srt_0x13c530; // 0x13c848 - g_ps2RecompiledFunctionTable[61981] = bhCPM2_act_srt_0x13c530; // 0x13c87c - g_ps2RecompiledFunctionTable[61988] = bhCPM2_act_srt_0x13c530; // 0x13c898 - g_ps2RecompiledFunctionTable[61994] = bhCPM2_act_sta_0x13c8b0; // 0x13c8b0 - g_ps2RecompiledFunctionTable[62136] = bhCPM2_act_sta_0x13c8b0; // 0x13cae8 - g_ps2RecompiledFunctionTable[62158] = bhCPM2_act_wlk_0x13cb40; // 0x13cb40 - g_ps2RecompiledFunctionTable[62236] = bhCPM2_act_wlk_0x13cb40; // 0x13cc78 - g_ps2RecompiledFunctionTable[62299] = bhCPM2_act_wlk_0x13cb40; // 0x13cd74 - g_ps2RecompiledFunctionTable[62333] = bhCPM2_act_wlk_0x13cb40; // 0x13cdfc - g_ps2RecompiledFunctionTable[62411] = bhCPM2_act_wlk_0x13cb40; // 0x13cf34 - g_ps2RecompiledFunctionTable[62415] = bhCPM2_act_wlk_0x13cb40; // 0x13cf44 - g_ps2RecompiledFunctionTable[62432] = bhCPM2_act_wlk_0x13cb40; // 0x13cf88 - g_ps2RecompiledFunctionTable[62442] = bhCPM2_act_wlk_0x13cb40; // 0x13cfb0 - g_ps2RecompiledFunctionTable[62459] = bhCPM2_act_wlk_0x13cb40; // 0x13cff4 - g_ps2RecompiledFunctionTable[62481] = bhCPM2_act_wlk_0x13cb40; // 0x13d04c - g_ps2RecompiledFunctionTable[62485] = bhCPM2_act_wlk_0x13cb40; // 0x13d05c - g_ps2RecompiledFunctionTable[62502] = bhCPM2_act_wlk_0x13cb40; // 0x13d0a0 - g_ps2RecompiledFunctionTable[62512] = bhCPM2_act_wlk_0x13cb40; // 0x13d0c8 - g_ps2RecompiledFunctionTable[62529] = bhCPM2_act_wlk_0x13cb40; // 0x13d10c - g_ps2RecompiledFunctionTable[62533] = bhCPM2_act_wlk_0x13cb40; // 0x13d11c - g_ps2RecompiledFunctionTable[62589] = bhCPM2_act_wlk_0x13cb40; // 0x13d1fc - g_ps2RecompiledFunctionTable[62594] = bhCPM2_act_run_0x13d210; // 0x13d210 - g_ps2RecompiledFunctionTable[62671] = bhCPM2_act_run_0x13d210; // 0x13d344 - g_ps2RecompiledFunctionTable[62729] = bhCPM2_act_run_0x13d210; // 0x13d42c - g_ps2RecompiledFunctionTable[62846] = bhCPM2_act_run_0x13d210; // 0x13d600 - g_ps2RecompiledFunctionTable[62869] = bhCPM2_act_run_0x13d210; // 0x13d65c - g_ps2RecompiledFunctionTable[62876] = bhCPM2_act_run_0x13d210; // 0x13d678 - g_ps2RecompiledFunctionTable[62886] = bhCPM2_act_run_0x13d210; // 0x13d6a0 - g_ps2RecompiledFunctionTable[62935] = bhCPM2_act_run_0x13d210; // 0x13d764 - g_ps2RecompiledFunctionTable[62939] = bhCPM2_act_run_0x13d210; // 0x13d774 - g_ps2RecompiledFunctionTable[62956] = bhCPM2_act_run_0x13d210; // 0x13d7b8 - g_ps2RecompiledFunctionTable[62966] = bhCPM2_act_run_0x13d210; // 0x13d7e0 - g_ps2RecompiledFunctionTable[62983] = bhCPM2_act_run_0x13d210; // 0x13d824 - g_ps2RecompiledFunctionTable[63005] = bhCPM2_act_run_0x13d210; // 0x13d87c - g_ps2RecompiledFunctionTable[63009] = bhCPM2_act_run_0x13d210; // 0x13d88c - g_ps2RecompiledFunctionTable[63026] = bhCPM2_act_run_0x13d210; // 0x13d8d0 - g_ps2RecompiledFunctionTable[63036] = bhCPM2_act_run_0x13d210; // 0x13d8f8 - g_ps2RecompiledFunctionTable[63053] = bhCPM2_act_run_0x13d210; // 0x13d93c - g_ps2RecompiledFunctionTable[63060] = bhCPM2_act_run_0x13d210; // 0x13d958 - g_ps2RecompiledFunctionTable[63066] = bhCPM2_act_bak_0x13d970; // 0x13d970 - g_ps2RecompiledFunctionTable[63133] = bhCPM2_act_bak_0x13d970; // 0x13da7c - g_ps2RecompiledFunctionTable[63196] = bhCPM2_act_bak_0x13d970; // 0x13db78 - g_ps2RecompiledFunctionTable[63287] = bhCPM2_act_bak_0x13d970; // 0x13dce4 - g_ps2RecompiledFunctionTable[63339] = bhCPM2_act_bak_0x13d970; // 0x13ddb4 - g_ps2RecompiledFunctionTable[63343] = bhCPM2_act_bak_0x13d970; // 0x13ddc4 - g_ps2RecompiledFunctionTable[63360] = bhCPM2_act_bak_0x13d970; // 0x13de08 - g_ps2RecompiledFunctionTable[63370] = bhCPM2_act_bak_0x13d970; // 0x13de30 - g_ps2RecompiledFunctionTable[63387] = bhCPM2_act_bak_0x13d970; // 0x13de74 - g_ps2RecompiledFunctionTable[63401] = bhCPM2_act_bak_0x13d970; // 0x13deac - g_ps2RecompiledFunctionTable[63420] = bhCPM2_act_bak_0x13d970; // 0x13def8 - g_ps2RecompiledFunctionTable[63465] = bhCPM2_act_bak_0x13d970; // 0x13dfac - g_ps2RecompiledFunctionTable[63469] = bhCPM2_act_bak_0x13d970; // 0x13dfbc - g_ps2RecompiledFunctionTable[63486] = bhCPM2_act_bak_0x13d970; // 0x13e000 - g_ps2RecompiledFunctionTable[63496] = bhCPM2_act_bak_0x13d970; // 0x13e028 - g_ps2RecompiledFunctionTable[63513] = bhCPM2_act_bak_0x13d970; // 0x13e06c - g_ps2RecompiledFunctionTable[63535] = bhCPM2_act_bak_0x13d970; // 0x13e0c4 - g_ps2RecompiledFunctionTable[63539] = bhCPM2_act_bak_0x13d970; // 0x13e0d4 - g_ps2RecompiledFunctionTable[63556] = bhCPM2_act_bak_0x13d970; // 0x13e118 - g_ps2RecompiledFunctionTable[63566] = bhCPM2_act_bak_0x13d970; // 0x13e140 - g_ps2RecompiledFunctionTable[63583] = bhCPM2_act_bak_0x13d970; // 0x13e184 - g_ps2RecompiledFunctionTable[63587] = bhCPM2_act_bak_0x13d970; // 0x13e194 - g_ps2RecompiledFunctionTable[63594] = bhCPM2_act_bak_0x13d970; // 0x13e1b0 - g_ps2RecompiledFunctionTable[63598] = bhCPM2_act_bk2_0x13e1c0; // 0x13e1c0 - g_ps2RecompiledFunctionTable[63661] = bhCPM2_act_bk2_0x13e1c0; // 0x13e2bc - g_ps2RecompiledFunctionTable[63775] = bhCPM2_act_bk2_0x13e1c0; // 0x13e484 - g_ps2RecompiledFunctionTable[63827] = bhCPM2_act_bk2_0x13e1c0; // 0x13e554 - g_ps2RecompiledFunctionTable[63831] = bhCPM2_act_bk2_0x13e1c0; // 0x13e564 - g_ps2RecompiledFunctionTable[63848] = bhCPM2_act_bk2_0x13e1c0; // 0x13e5a8 - g_ps2RecompiledFunctionTable[63858] = bhCPM2_act_bk2_0x13e1c0; // 0x13e5d0 - g_ps2RecompiledFunctionTable[63875] = bhCPM2_act_bk2_0x13e1c0; // 0x13e614 - g_ps2RecompiledFunctionTable[63897] = bhCPM2_act_bk2_0x13e1c0; // 0x13e66c - g_ps2RecompiledFunctionTable[63921] = bhCPM2_act_bk2_0x13e1c0; // 0x13e6cc - g_ps2RecompiledFunctionTable[63964] = bhCPM2_act_bk2_0x13e1c0; // 0x13e778 - g_ps2RecompiledFunctionTable[63987] = bhCPM2_act_bk2_0x13e1c0; // 0x13e7d4 - g_ps2RecompiledFunctionTable[64012] = bhCPM2_act_bk2_0x13e1c0; // 0x13e838 - g_ps2RecompiledFunctionTable[64016] = bhCPM2_act_bk2_0x13e1c0; // 0x13e848 - g_ps2RecompiledFunctionTable[64033] = bhCPM2_act_bk2_0x13e1c0; // 0x13e88c - g_ps2RecompiledFunctionTable[64043] = bhCPM2_act_bk2_0x13e1c0; // 0x13e8b4 - g_ps2RecompiledFunctionTable[64060] = bhCPM2_act_bk2_0x13e1c0; // 0x13e8f8 - g_ps2RecompiledFunctionTable[64082] = bhCPM2_act_bk2_0x13e1c0; // 0x13e950 - g_ps2RecompiledFunctionTable[64086] = bhCPM2_act_bk2_0x13e1c0; // 0x13e960 - g_ps2RecompiledFunctionTable[64103] = bhCPM2_act_bk2_0x13e1c0; // 0x13e9a4 - g_ps2RecompiledFunctionTable[64113] = bhCPM2_act_bk2_0x13e1c0; // 0x13e9cc - g_ps2RecompiledFunctionTable[64130] = bhCPM2_act_bk2_0x13e1c0; // 0x13ea10 - g_ps2RecompiledFunctionTable[64134] = bhCPM2_act_bk2_0x13e1c0; // 0x13ea20 - g_ps2RecompiledFunctionTable[64141] = bhCPM2_act_bk2_0x13e1c0; // 0x13ea3c - g_ps2RecompiledFunctionTable[64146] = bhCPM2_act_kdu_0x13ea50; // 0x13ea50 - g_ps2RecompiledFunctionTable[64245] = bhCPM2_act_kdu_0x13ea50; // 0x13ebdc - g_ps2RecompiledFunctionTable[64289] = bhCPM2_act_kdu_0x13ea50; // 0x13ec8c - g_ps2RecompiledFunctionTable[64321] = bhCPM2_act_kdu_0x13ea50; // 0x13ed0c - g_ps2RecompiledFunctionTable[64391] = bhCPM2_act_kdu_0x13ea50; // 0x13ee24 - g_ps2RecompiledFunctionTable[64432] = bhCPM2_act_kdu_0x13ea50; // 0x13eec8 - g_ps2RecompiledFunctionTable[64445] = bhCPM2_act_kdu_0x13ea50; // 0x13eefc - g_ps2RecompiledFunctionTable[64451] = bhCPM2_act_kdu_0x13ea50; // 0x13ef14 - g_ps2RecompiledFunctionTable[64470] = bhCPM2_act_kdu_0x13ea50; // 0x13ef60 - g_ps2RecompiledFunctionTable[64491] = bhCPM2_act_kdu_0x13ea50; // 0x13efb4 - g_ps2RecompiledFunctionTable[64496] = bhCPM2_act_kdu_0x13ea50; // 0x13efc8 - g_ps2RecompiledFunctionTable[64500] = bhCPM2_act_kdu_0x13ea50; // 0x13efd8 - g_ps2RecompiledFunctionTable[64677] = bhCPM2_act_kdu_0x13ea50; // 0x13f29c - g_ps2RecompiledFunctionTable[64681] = bhCPM2_act_kdu_0x13ea50; // 0x13f2ac - g_ps2RecompiledFunctionTable[64709] = bhCPM2_act_kdu_0x13ea50; // 0x13f31c - g_ps2RecompiledFunctionTable[64717] = bhCPM2_act_kdu_0x13ea50; // 0x13f33c - g_ps2RecompiledFunctionTable[64721] = bhCPM2_act_kdu_0x13ea50; // 0x13f34c - g_ps2RecompiledFunctionTable[64746] = bhCPM2_act_kdu_0x13ea50; // 0x13f3b0 - g_ps2RecompiledFunctionTable[64754] = bhCPM2_act_kdu_0x13ea50; // 0x13f3d0 - g_ps2RecompiledFunctionTable[64758] = bhCPM2_act_kdu_0x13ea50; // 0x13f3e0 - g_ps2RecompiledFunctionTable[64774] = bhCPM2_act_kdu_0x13ea50; // 0x13f420 - g_ps2RecompiledFunctionTable[64862] = bhCPM2_act_kdu_0x13ea50; // 0x13f580 - g_ps2RecompiledFunctionTable[64918] = bhCPM2_act_kdd_0x13f660; // 0x13f660 - g_ps2RecompiledFunctionTable[65018] = bhCPM2_act_kdd_0x13f660; // 0x13f7f0 - g_ps2RecompiledFunctionTable[65062] = bhCPM2_act_kdd_0x13f660; // 0x13f8a0 - g_ps2RecompiledFunctionTable[65094] = bhCPM2_act_kdd_0x13f660; // 0x13f920 - g_ps2RecompiledFunctionTable[65163] = bhCPM2_act_kdd_0x13f660; // 0x13fa34 - g_ps2RecompiledFunctionTable[65176] = bhCPM2_act_kdd_0x13f660; // 0x13fa68 - g_ps2RecompiledFunctionTable[65182] = bhCPM2_act_kdd_0x13f660; // 0x13fa80 - g_ps2RecompiledFunctionTable[65210] = bhCPM2_act_kdd_0x13f660; // 0x13faf0 - g_ps2RecompiledFunctionTable[65223] = bhCPM2_act_kdd_0x13f660; // 0x13fb24 - g_ps2RecompiledFunctionTable[65240] = bhCPM2_act_kdd_0x13f660; // 0x13fb68 - g_ps2RecompiledFunctionTable[65245] = bhCPM2_act_kdd_0x13f660; // 0x13fb7c - g_ps2RecompiledFunctionTable[65249] = bhCPM2_act_kdd_0x13f660; // 0x13fb8c - g_ps2RecompiledFunctionTable[65310] = bhCPM2_act_kdd_0x13f660; // 0x13fc80 - g_ps2RecompiledFunctionTable[65314] = bhCPM2_act_kdd_0x13f660; // 0x13fc90 - g_ps2RecompiledFunctionTable[65322] = bhCPM2_act_kdd_0x13f660; // 0x13fcb0 - g_ps2RecompiledFunctionTable[65369] = bhCPM2_act_kdd_0x13f660; // 0x13fd6c - g_ps2RecompiledFunctionTable[65426] = bhCPM2_act_kdd_0x13f660; // 0x13fe50 - g_ps2RecompiledFunctionTable[65499] = bhCPM2_act_kdd_0x13f660; // 0x13ff74 - g_ps2RecompiledFunctionTable[65507] = bhCPM2_act_kdd_0x13f660; // 0x13ff94 - g_ps2RecompiledFunctionTable[65511] = bhCPM2_act_kdd_0x13f660; // 0x13ffa4 - g_ps2RecompiledFunctionTable[65536] = bhCPM2_act_kdd_0x13f660; // 0x140008 - g_ps2RecompiledFunctionTable[65544] = bhCPM2_act_kdd_0x13f660; // 0x140028 - g_ps2RecompiledFunctionTable[65548] = bhCPM2_act_kdd_0x13f660; // 0x140038 - g_ps2RecompiledFunctionTable[65558] = bhCPM2_act_dnu_0x140060; // 0x140060 - g_ps2RecompiledFunctionTable[65685] = bhCPM2_act_dnu_0x140060; // 0x14025c - g_ps2RecompiledFunctionTable[65717] = bhCPM2_act_dnu_0x140060; // 0x1402dc - g_ps2RecompiledFunctionTable[65772] = bhCPM2_act_dnu_0x140060; // 0x1403b8 - g_ps2RecompiledFunctionTable[65785] = bhCPM2_act_dnu_0x140060; // 0x1403ec - g_ps2RecompiledFunctionTable[65814] = bhCPM2_act_dnu_0x140060; // 0x140460 - g_ps2RecompiledFunctionTable[65827] = bhCPM2_act_dnu_0x140060; // 0x140494 - g_ps2RecompiledFunctionTable[65836] = bhCPM2_act_dnu_0x140060; // 0x1404b8 - g_ps2RecompiledFunctionTable[65935] = bhCPM2_act_dnu_0x140060; // 0x140644 - g_ps2RecompiledFunctionTable[65994] = bhCPM2_act_dnd_0x140730; // 0x140730 - g_ps2RecompiledFunctionTable[66123] = bhCPM2_act_dnd_0x140730; // 0x140934 - g_ps2RecompiledFunctionTable[66155] = bhCPM2_act_dnd_0x140730; // 0x1409b4 - g_ps2RecompiledFunctionTable[66206] = bhCPM2_act_dnd_0x140730; // 0x140a80 - g_ps2RecompiledFunctionTable[66216] = bhCPM2_act_dnd_0x140730; // 0x140aa8 - g_ps2RecompiledFunctionTable[66239] = bhCPM2_act_dnd_0x140730; // 0x140b04 - g_ps2RecompiledFunctionTable[66250] = bhCPM2_act_dnd_0x140730; // 0x140b30 - g_ps2RecompiledFunctionTable[66345] = bhCPM2_act_dnd_0x140730; // 0x140cac - g_ps2RecompiledFunctionTable[66363] = bhCPM2_act_dnd_0x140730; // 0x140cf4 - g_ps2RecompiledFunctionTable[66382] = bhCPM2_act_dnd_0x140730; // 0x140d40 - g_ps2RecompiledFunctionTable[66433] = bhCPM2_act_dnd_0x140730; // 0x140e0c - g_ps2RecompiledFunctionTable[66451] = bhCPM2_act_dnd_0x140730; // 0x140e54 - g_ps2RecompiledFunctionTable[66470] = bhCPM2_act_dnd_0x140730; // 0x140ea0 - g_ps2RecompiledFunctionTable[66473] = bhCPM2_act_dnd_0x140730; // 0x140eac - g_ps2RecompiledFunctionTable[66497] = bhCPM2_act_dnd_0x140730; // 0x140f0c - g_ps2RecompiledFunctionTable[66506] = bhCPM2_act_dnd_0x140730; // 0x140f30 - g_ps2RecompiledFunctionTable[66609] = bhCPM2_act_dnd_0x140730; // 0x1410cc - g_ps2RecompiledFunctionTable[66670] = bhCPM2_act_psh_0x1411c0; // 0x1411c0 - g_ps2RecompiledFunctionTable[66802] = bhCPM2_act_psh_0x1411c0; // 0x1413d0 - g_ps2RecompiledFunctionTable[66833] = bhCPM2_act_psh_0x1411c0; // 0x14144c - g_ps2RecompiledFunctionTable[66908] = bhCPM2_act_psh_0x1411c0; // 0x141578 - g_ps2RecompiledFunctionTable[66911] = bhCPM2_act_psh_0x1411c0; // 0x141584 - g_ps2RecompiledFunctionTable[66931] = bhCPM2_act_psh_0x1411c0; // 0x1415d4 - g_ps2RecompiledFunctionTable[66934] = bhCPM2_act_psh_0x1411c0; // 0x1415e0 - g_ps2RecompiledFunctionTable[66943] = bhCPM2_act_psh_0x1411c0; // 0x141604 - g_ps2RecompiledFunctionTable[66955] = bhCPM2_act_psh_0x1411c0; // 0x141634 - g_ps2RecompiledFunctionTable[67034] = bhCPM2_act_cro_0x141770; // 0x141770 - g_ps2RecompiledFunctionTable[67158] = bhCPM2_act_hsu_0x141960; // 0x141960 - g_ps2RecompiledFunctionTable[67257] = bhCPM2_act_hsu_0x141960; // 0x141aec - g_ps2RecompiledFunctionTable[67301] = bhCPM2_act_hsu_0x141960; // 0x141b9c - g_ps2RecompiledFunctionTable[67333] = bhCPM2_act_hsu_0x141960; // 0x141c1c - g_ps2RecompiledFunctionTable[67379] = bhCPM2_act_hsu_0x141960; // 0x141cd4 - g_ps2RecompiledFunctionTable[67544] = bhCPM2_act_hsu_0x141960; // 0x141f68 - g_ps2RecompiledFunctionTable[67640] = bhCPM2_act_hsu_0x141960; // 0x1420e8 - g_ps2RecompiledFunctionTable[67698] = bhCPM2_act_hsd_0x1421d0; // 0x1421d0 - g_ps2RecompiledFunctionTable[67797] = bhCPM2_act_hsd_0x1421d0; // 0x14235c - g_ps2RecompiledFunctionTable[67842] = bhCPM2_act_hsd_0x1421d0; // 0x142410 - g_ps2RecompiledFunctionTable[67874] = bhCPM2_act_hsd_0x1421d0; // 0x142490 - g_ps2RecompiledFunctionTable[67920] = bhCPM2_act_hsd_0x1421d0; // 0x142548 - g_ps2RecompiledFunctionTable[68078] = bhCPM2_act_hsd_0x1421d0; // 0x1427c0 - g_ps2RecompiledFunctionTable[68174] = bhCPM2_act_hsd_0x1421d0; // 0x142940 - g_ps2RecompiledFunctionTable[68230] = bhCPM2_act_rpsh_0x142a20; // 0x142a20 - g_ps2RecompiledFunctionTable[68359] = bhCPM2_act_rpsh_0x142a20; // 0x142c24 - g_ps2RecompiledFunctionTable[68390] = bhCPM2_act_rpsh_0x142a20; // 0x142ca0 - g_ps2RecompiledFunctionTable[68463] = bhCPM2_act_rpsh_0x142a20; // 0x142dc4 - g_ps2RecompiledFunctionTable[68466] = bhCPM2_act_rpsh_0x142a20; // 0x142dd0 - g_ps2RecompiledFunctionTable[68482] = bhCPM2_act_rpsh_0x142a20; // 0x142e10 - g_ps2RecompiledFunctionTable[68485] = bhCPM2_act_rpsh_0x142a20; // 0x142e1c - g_ps2RecompiledFunctionTable[68558] = bhCPM1_act_atk_0x142f40; // 0x142f40 - g_ps2RecompiledFunctionTable[68624] = bhCPM1_act_atk_0x142f40; // 0x143048 - g_ps2RecompiledFunctionTable[68638] = bhCPM1_act_atk_0x142f40; // 0x143080 - g_ps2RecompiledFunctionTable[68718] = bhCPM1_act_atk_0x142f40; // 0x1431c0 - g_ps2RecompiledFunctionTable[68722] = bhCPM1_act_atk_0x142f40; // 0x1431d0 - g_ps2RecompiledFunctionTable[68726] = bhCPM1_act_atk_0x142f40; // 0x1431e0 - g_ps2RecompiledFunctionTable[68730] = bhCPM1_act_atk_0x142f40; // 0x1431f0 - g_ps2RecompiledFunctionTable[68734] = bhCPM1_act_atk_0x142f40; // 0x143200 - g_ps2RecompiledFunctionTable[68738] = bhCPM1_act_atk_0x142f40; // 0x143210 - g_ps2RecompiledFunctionTable[68742] = bhCPM1_act_atk_0x142f40; // 0x143220 - g_ps2RecompiledFunctionTable[68746] = bhCPM1_act_atk_0x142f40; // 0x143230 - g_ps2RecompiledFunctionTable[68750] = bhCPM1_act_atk_0x142f40; // 0x143240 - g_ps2RecompiledFunctionTable[68754] = bhCPM1_act_atk_0x142f40; // 0x143250 - g_ps2RecompiledFunctionTable[68758] = bhCPM1_act_atk_0x142f40; // 0x143260 - g_ps2RecompiledFunctionTable[68762] = bhCPM1_act_atk_0x142f40; // 0x143270 - g_ps2RecompiledFunctionTable[68766] = bhCPM2_act_suw_0x143280; // 0x143280 - g_ps2RecompiledFunctionTable[68791] = bhCPM2_act_suw_0x143280; // 0x1432e4 - g_ps2RecompiledFunctionTable[68850] = bhCPM2_act_suw_0x143280; // 0x1433d0 - g_ps2RecompiledFunctionTable[68882] = bhCPM2_act_suw_0x143280; // 0x143450 - g_ps2RecompiledFunctionTable[68912] = bhCPM2_act_suw_0x143280; // 0x1434c8 - g_ps2RecompiledFunctionTable[68922] = bhCPM2_act_suw_0x143280; // 0x1434f0 - g_ps2RecompiledFunctionTable[68932] = bhCPM2_act_suw_0x143280; // 0x143518 - g_ps2RecompiledFunctionTable[68934] = bhCPM2_act_suw_0x143280; // 0x143520 - g_ps2RecompiledFunctionTable[69209] = bhCPM2_act_suw_0x143280; // 0x14396c - g_ps2RecompiledFunctionTable[69233] = bhCPM2_act_suw_0x143280; // 0x1439cc - g_ps2RecompiledFunctionTable[69242] = bhCPM2_act_wpn_0x1439f0; // 0x1439f0 - g_ps2RecompiledFunctionTable[69608] = bhCPM2_act_wpn_0x1439f0; // 0x143fa8 - g_ps2RecompiledFunctionTable[69656] = bhCPM2_act_wpn_0x1439f0; // 0x144068 - g_ps2RecompiledFunctionTable[69696] = bhCPM2_act_wpn_0x1439f0; // 0x144108 - g_ps2RecompiledFunctionTable[69700] = bhCPM2_act_wpn_0x1439f0; // 0x144118 - g_ps2RecompiledFunctionTable[69735] = bhCPM2_act_wpn_0x1439f0; // 0x1441a4 - g_ps2RecompiledFunctionTable[69748] = bhCPM2_act_wpn_0x1439f0; // 0x1441d8 - g_ps2RecompiledFunctionTable[69787] = bhCPM2_act_wpn_0x1439f0; // 0x144274 - g_ps2RecompiledFunctionTable[69801] = bhCPM2_act_wpn_0x1439f0; // 0x1442ac - g_ps2RecompiledFunctionTable[69820] = bhCPM2_act_wpn_0x1439f0; // 0x1442f8 - g_ps2RecompiledFunctionTable[69877] = bhCPM2_act_wpn_0x1439f0; // 0x1443dc - g_ps2RecompiledFunctionTable[69892] = bhCPM2_act_wpn_0x1439f0; // 0x144418 - g_ps2RecompiledFunctionTable[69894] = bhCPM2_act_wpn_0x1439f0; // 0x144420 - g_ps2RecompiledFunctionTable[69901] = bhCPM2_act_wpn_0x1439f0; // 0x14443c - g_ps2RecompiledFunctionTable[69929] = bhCPM2_act_wpn_0x1439f0; // 0x1444ac - g_ps2RecompiledFunctionTable[69934] = bhCPM2_act_wpn_0x1439f0; // 0x1444c0 - g_ps2RecompiledFunctionTable[69943] = bhCPM2_act_wpn_0x1439f0; // 0x1444e4 - g_ps2RecompiledFunctionTable[69960] = bhCPM2_act_wpn_0x1439f0; // 0x144528 - g_ps2RecompiledFunctionTable[69965] = bhCPM2_act_wpn_0x1439f0; // 0x14453c - g_ps2RecompiledFunctionTable[69968] = bhCPM2_act_wpn_0x1439f0; // 0x144548 - g_ps2RecompiledFunctionTable[69970] = bhCPM2_act_wpn_0x1439f0; // 0x144550 - g_ps2RecompiledFunctionTable[69973] = bhCPM2_act_wpn_0x1439f0; // 0x14455c - g_ps2RecompiledFunctionTable[69980] = bhCPM2_act_wpn_0x1439f0; // 0x144578 - g_ps2RecompiledFunctionTable[69985] = bhCPM2_act_wpn_0x1439f0; // 0x14458c - g_ps2RecompiledFunctionTable[69987] = bhCPM2_act_wpn_0x1439f0; // 0x144594 - g_ps2RecompiledFunctionTable[69990] = bhCPM2_act_wpn_0x1439f0; // 0x1445a0 - g_ps2RecompiledFunctionTable[69992] = bhCPM2_act_wpn_0x1439f0; // 0x1445a8 - g_ps2RecompiledFunctionTable[69995] = bhCPM2_act_wpn_0x1439f0; // 0x1445b4 - g_ps2RecompiledFunctionTable[70002] = bhCPM2_act_wpn_0x1439f0; // 0x1445d0 - g_ps2RecompiledFunctionTable[70007] = bhCPM2_act_wpn_0x1439f0; // 0x1445e4 - g_ps2RecompiledFunctionTable[70009] = bhCPM2_act_wpn_0x1439f0; // 0x1445ec - g_ps2RecompiledFunctionTable[70012] = bhCPM2_act_wpn_0x1439f0; // 0x1445f8 - g_ps2RecompiledFunctionTable[70014] = bhCPM2_act_wpn_0x1439f0; // 0x144600 - g_ps2RecompiledFunctionTable[70017] = bhCPM2_act_wpn_0x1439f0; // 0x14460c - g_ps2RecompiledFunctionTable[70024] = bhCPM2_act_wpn_0x1439f0; // 0x144628 - g_ps2RecompiledFunctionTable[70029] = bhCPM2_act_wpn_0x1439f0; // 0x14463c - g_ps2RecompiledFunctionTable[70031] = bhCPM2_act_wpn_0x1439f0; // 0x144644 - g_ps2RecompiledFunctionTable[70034] = bhCPM2_act_wpn_0x1439f0; // 0x144650 - g_ps2RecompiledFunctionTable[70036] = bhCPM2_act_wpn_0x1439f0; // 0x144658 - g_ps2RecompiledFunctionTable[70039] = bhCPM2_act_wpn_0x1439f0; // 0x144664 - g_ps2RecompiledFunctionTable[70046] = bhCPM2_act_wpn_0x1439f0; // 0x144680 - g_ps2RecompiledFunctionTable[70051] = bhCPM2_act_wpn_0x1439f0; // 0x144694 - g_ps2RecompiledFunctionTable[70053] = bhCPM2_act_wpn_0x1439f0; // 0x14469c - g_ps2RecompiledFunctionTable[70069] = bhCPM2_act_wpn_0x1439f0; // 0x1446dc - g_ps2RecompiledFunctionTable[70074] = bhCPM2_act_wpn_0x1439f0; // 0x1446f0 - g_ps2RecompiledFunctionTable[70090] = bhCPM2_act_wpn_0x1439f0; // 0x144730 - g_ps2RecompiledFunctionTable[70095] = bhCPM2_act_wpn_0x1439f0; // 0x144744 - g_ps2RecompiledFunctionTable[70104] = bhCPM2_act_wpn_0x1439f0; // 0x144768 - g_ps2RecompiledFunctionTable[70120] = bhCPM2_act_wpn_0x1439f0; // 0x1447a8 - g_ps2RecompiledFunctionTable[70125] = bhCPM2_act_wpn_0x1439f0; // 0x1447bc - g_ps2RecompiledFunctionTable[70130] = bhCPM2_act_wpn_0x1439f0; // 0x1447d0 - g_ps2RecompiledFunctionTable[70132] = bhCPM2_act_wpn_0x1439f0; // 0x1447d8 - g_ps2RecompiledFunctionTable[70153] = bhCPM2_act_wpn_0x1439f0; // 0x14482c - g_ps2RecompiledFunctionTable[70176] = bhCPM2_act_wpn_0x1439f0; // 0x144888 - g_ps2RecompiledFunctionTable[70194] = bhCPM2_act_wpn_0x1439f0; // 0x1448d0 - g_ps2RecompiledFunctionTable[70206] = bhCPM2_act_wpn_0x1439f0; // 0x144900 - g_ps2RecompiledFunctionTable[70227] = bhCPM2_act_wpn_0x1439f0; // 0x144954 - g_ps2RecompiledFunctionTable[70250] = bhCPM2_act_wpn_0x1439f0; // 0x1449b0 - g_ps2RecompiledFunctionTable[70268] = bhCPM2_act_wpn_0x1439f0; // 0x1449f8 - g_ps2RecompiledFunctionTable[70280] = bhCPM2_act_wpn_0x1439f0; // 0x144a28 - g_ps2RecompiledFunctionTable[70305] = bhCPM2_act_wpn_0x1439f0; // 0x144a8c - g_ps2RecompiledFunctionTable[70314] = bhCPM2_act_wpn_0x1439f0; // 0x144ab0 - g_ps2RecompiledFunctionTable[70325] = bhCPM2_act_wpn_0x1439f0; // 0x144adc - g_ps2RecompiledFunctionTable[70350] = bhCPM2_act_wre_0x144b40; // 0x144b40 - g_ps2RecompiledFunctionTable[70456] = bhCPM2_act_wre_0x144b40; // 0x144ce8 - g_ps2RecompiledFunctionTable[70466] = bhCPM2_act_wre_0x144b40; // 0x144d10 - g_ps2RecompiledFunctionTable[70476] = bhCPM2_act_wre_0x144b40; // 0x144d38 - g_ps2RecompiledFunctionTable[70534] = bhCPM2_act_wre_0x144b40; // 0x144e20 - g_ps2RecompiledFunctionTable[70558] = bhCPM2_act_wre_0x144b40; // 0x144e80 - g_ps2RecompiledFunctionTable[70566] = bhCPM2_act_atk_0x144ea0; // 0x144ea0 - g_ps2RecompiledFunctionTable[70596] = bhCPM2_act_atk_0x144ea0; // 0x144f18 - g_ps2RecompiledFunctionTable[70677] = bhCPM2_act_atk_0x144ea0; // 0x14505c - g_ps2RecompiledFunctionTable[70854] = bhCPM2_act_atk_0x144ea0; // 0x145320 - g_ps2RecompiledFunctionTable[70875] = bhCPM2_act_atk_0x144ea0; // 0x145374 - g_ps2RecompiledFunctionTable[70882] = bhCPM2_act_atk_0x144ea0; // 0x145390 - g_ps2RecompiledFunctionTable[70908] = bhCPM2_act_atk_0x144ea0; // 0x1453f8 - g_ps2RecompiledFunctionTable[70910] = bhCPM2_act_atk_0x144ea0; // 0x145400 - g_ps2RecompiledFunctionTable[70917] = bhCPM2_act_atk_0x144ea0; // 0x14541c - g_ps2RecompiledFunctionTable[70926] = bhCPM2_act_atk_0x144ea0; // 0x145440 - g_ps2RecompiledFunctionTable[70928] = bhCPM2_act_atk_0x144ea0; // 0x145448 - g_ps2RecompiledFunctionTable[70930] = bhCPM2_act_atk_0x144ea0; // 0x145450 - g_ps2RecompiledFunctionTable[70932] = bhCPM2_act_atk_0x144ea0; // 0x145458 - g_ps2RecompiledFunctionTable[70962] = bhCPM2_act_atk_0x144ea0; // 0x1454d0 - g_ps2RecompiledFunctionTable[70972] = bhCPM2_act_atk_0x144ea0; // 0x1454f8 - g_ps2RecompiledFunctionTable[70982] = bhCPM2_act_atk_0x144ea0; // 0x145520 - g_ps2RecompiledFunctionTable[70989] = bhCPM2_act_atk_0x144ea0; // 0x14553c - g_ps2RecompiledFunctionTable[70999] = bhCPM2_act_atk_0x144ea0; // 0x145564 - g_ps2RecompiledFunctionTable[71009] = bhCPM2_act_atk_0x144ea0; // 0x14558c - g_ps2RecompiledFunctionTable[71038] = bhCPM2_act_atk_0x144ea0; // 0x145600 - g_ps2RecompiledFunctionTable[71099] = bhCPM2_act_atk_0x144ea0; // 0x1456f4 - g_ps2RecompiledFunctionTable[71119] = bhCPM2_act_atk_0x144ea0; // 0x145744 - g_ps2RecompiledFunctionTable[71146] = bhCPM2_act_atk_0x144ea0; // 0x1457b0 - g_ps2RecompiledFunctionTable[71166] = bhCPM2_act_atk_0x144ea0; // 0x145800 - g_ps2RecompiledFunctionTable[71185] = bhCPM2_act_atk_0x144ea0; // 0x14584c - g_ps2RecompiledFunctionTable[71234] = bhCPM2_act_atk_0x144ea0; // 0x145910 - g_ps2RecompiledFunctionTable[71258] = bhCPM2_act_atk_0x144ea0; // 0x145970 - g_ps2RecompiledFunctionTable[71262] = bhCPM2_act_atk_0x144ea0; // 0x145980 - g_ps2RecompiledFunctionTable[71382] = bhCPM2_act_atk_0x144ea0; // 0x145b60 - g_ps2RecompiledFunctionTable[71463] = bhCPM2_act_atk_0x144ea0; // 0x145ca4 - g_ps2RecompiledFunctionTable[71486] = bhCPM2_act_atk_0x144ea0; // 0x145d00 - g_ps2RecompiledFunctionTable[71504] = bhCPM2_act_atk_0x144ea0; // 0x145d48 - g_ps2RecompiledFunctionTable[71516] = bhCPM2_act_atk_0x144ea0; // 0x145d78 - g_ps2RecompiledFunctionTable[71537] = bhCPM2_act_atk_0x144ea0; // 0x145dcc - g_ps2RecompiledFunctionTable[71560] = bhCPM2_act_atk_0x144ea0; // 0x145e28 - g_ps2RecompiledFunctionTable[71578] = bhCPM2_act_atk_0x144ea0; // 0x145e70 - g_ps2RecompiledFunctionTable[71590] = bhCPM2_act_atk_0x144ea0; // 0x145ea0 - g_ps2RecompiledFunctionTable[71715] = bhCPM2_act_atk_0x144ea0; // 0x146094 - g_ps2RecompiledFunctionTable[71740] = bhCPM2_act_atk_0x144ea0; // 0x1460f8 - g_ps2RecompiledFunctionTable[71852] = bhCPM2_act_atk_0x144ea0; // 0x1462b8 - g_ps2RecompiledFunctionTable[71873] = bhCPM2_act_atk_0x144ea0; // 0x14630c - g_ps2RecompiledFunctionTable[71880] = bhCPM2_act_atk_0x144ea0; // 0x146328 - g_ps2RecompiledFunctionTable[71906] = bhCPM2_act_atk_0x144ea0; // 0x146390 - g_ps2RecompiledFunctionTable[71913] = bhCPM2_act_atk_0x144ea0; // 0x1463ac - g_ps2RecompiledFunctionTable[71922] = bhCPM2_act_atk_0x144ea0; // 0x1463d0 - g_ps2RecompiledFunctionTable[71924] = bhCPM2_act_atk_0x144ea0; // 0x1463d8 - g_ps2RecompiledFunctionTable[71926] = bhCPM2_act_atk_0x144ea0; // 0x1463e0 - g_ps2RecompiledFunctionTable[71995] = bhCPM2_act_atk_0x144ea0; // 0x1464f4 - g_ps2RecompiledFunctionTable[72047] = bhCPM2_act_atk_0x144ea0; // 0x1465c4 - g_ps2RecompiledFunctionTable[72157] = bhCPM2_act_atk_0x144ea0; // 0x14677c - g_ps2RecompiledFunctionTable[72395] = bhCPM2_act_atk_0x144ea0; // 0x146b34 - g_ps2RecompiledFunctionTable[72458] = bhCPM2_act_atk_0x144ea0; // 0x146c30 - g_ps2RecompiledFunctionTable[72522] = bhCPM2_act_atk_0x144ea0; // 0x146d30 - g_ps2RecompiledFunctionTable[72568] = bhCPM2_act_atk_0x144ea0; // 0x146de8 - g_ps2RecompiledFunctionTable[72591] = bhCPM2_act_atk_0x144ea0; // 0x146e44 - g_ps2RecompiledFunctionTable[72609] = bhCPM2_act_atk_0x144ea0; // 0x146e8c - g_ps2RecompiledFunctionTable[72621] = bhCPM2_act_atk_0x144ea0; // 0x146ebc - g_ps2RecompiledFunctionTable[72642] = bhCPM2_act_atk_0x144ea0; // 0x146f10 - g_ps2RecompiledFunctionTable[72665] = bhCPM2_act_atk_0x144ea0; // 0x146f6c - g_ps2RecompiledFunctionTable[72683] = bhCPM2_act_atk_0x144ea0; // 0x146fb4 - g_ps2RecompiledFunctionTable[72695] = bhCPM2_act_atk_0x144ea0; // 0x146fe4 - g_ps2RecompiledFunctionTable[72712] = bhCPM2_act_atk_0x144ea0; // 0x147028 - g_ps2RecompiledFunctionTable[72723] = bhCPM2_act_atk_0x144ea0; // 0x147054 - g_ps2RecompiledFunctionTable[72750] = bhCPM2_act_rld_0x1470c0; // 0x1470c0 - g_ps2RecompiledFunctionTable[72886] = bhCPM2_act_rld_0x1470c0; // 0x1472e0 - g_ps2RecompiledFunctionTable[72938] = bhCPM2_act_rld_0x1470c0; // 0x1473b0 - g_ps2RecompiledFunctionTable[72966] = bhCPM2_act_rld_0x1470c0; // 0x147420 - g_ps2RecompiledFunctionTable[72974] = bhCPM2_act_rld_0x1470c0; // 0x147440 - g_ps2RecompiledFunctionTable[73049] = bhCPM2_act_rld_0x1470c0; // 0x14756c - g_ps2RecompiledFunctionTable[73076] = bhCPM2_act_rld_0x1470c0; // 0x1475d8 - g_ps2RecompiledFunctionTable[73094] = bhCPM2_act_rld_0x1470c0; // 0x147620 - g_ps2RecompiledFunctionTable[73124] = bhCPM2_act_rld_0x1470c0; // 0x147698 - g_ps2RecompiledFunctionTable[73151] = bhCPM2_act_rld_0x1470c0; // 0x147704 - g_ps2RecompiledFunctionTable[73199] = bhCPM2_act_rld_0x1470c0; // 0x1477c4 - g_ps2RecompiledFunctionTable[73209] = bhCPM2_act_rld_0x1470c0; // 0x1477ec - g_ps2RecompiledFunctionTable[73241] = bhCPM2_act_rld_0x1470c0; // 0x14786c - g_ps2RecompiledFunctionTable[73268] = bhCPM2_act_rld_0x1470c0; // 0x1478d8 - g_ps2RecompiledFunctionTable[73366] = bhCPM2_act_knf_0x147a60; // 0x147a60 - g_ps2RecompiledFunctionTable[73478] = bhCPM0_damage_0x147c20; // 0x147c20 - g_ps2RecompiledFunctionTable[73595] = bhCPM0_damage_0x147c20; // 0x147df4 - g_ps2RecompiledFunctionTable[73600] = bhCPM0_damage_0x147c20; // 0x147e08 - g_ps2RecompiledFunctionTable[73625] = bhCPM0_damage_0x147c20; // 0x147e6c - g_ps2RecompiledFunctionTable[73637] = bhCPM0_damage_0x147c20; // 0x147e9c - g_ps2RecompiledFunctionTable[73727] = bhCPM0_damage_0x147c20; // 0x148004 - g_ps2RecompiledFunctionTable[73752] = bhCPM0_damage_0x147c20; // 0x148068 - g_ps2RecompiledFunctionTable[73764] = bhCPM0_damage_0x147c20; // 0x148098 - g_ps2RecompiledFunctionTable[73822] = bhCPM0_die_0x148180; // 0x148180 - g_ps2RecompiledFunctionTable[73942] = bhCPM0_die_0x148180; // 0x148360 - g_ps2RecompiledFunctionTable[73961] = bhCPM0_die_0x148180; // 0x1483ac - g_ps2RecompiledFunctionTable[74050] = bhCPM0_die_0x148180; // 0x148510 - g_ps2RecompiledFunctionTable[74062] = bhCPM0_die_0x148180; // 0x148540 - g_ps2RecompiledFunctionTable[74081] = bhCPM0_die_0x148180; // 0x14858c - g_ps2RecompiledFunctionTable[74199] = bhCPM0_die_0x148180; // 0x148764 - g_ps2RecompiledFunctionTable[74218] = bhCPM0_die_0x148180; // 0x1487b0 - g_ps2RecompiledFunctionTable[74307] = bhCPM0_die_0x148180; // 0x148914 - g_ps2RecompiledFunctionTable[74319] = bhCPM0_die_0x148180; // 0x148944 - g_ps2RecompiledFunctionTable[74338] = bhCPM0_die_0x148180; // 0x148990 - g_ps2RecompiledFunctionTable[74414] = bhCPM0_nage_0x148ac0; // 0x148ac0 - g_ps2RecompiledFunctionTable[74514] = bhCPM0_enedam_0x148c50; // 0x148c50 - g_ps2RecompiledFunctionTable[74614] = bhCPM0_enedie_0x148de0; // 0x148de0 - g_ps2RecompiledFunctionTable[74734] = bhCPM0_nothing_0x148fc0; // 0x148fc0 - g_ps2RecompiledFunctionTable[74794] = bhControlPlayerHead_0x1490b0; // 0x1490b0 - g_ps2RecompiledFunctionTable[74984] = bhControlPlayerHead_0x1490b0; // 0x1493a8 - g_ps2RecompiledFunctionTable[74997] = bhControlPlayerHead_0x1490b0; // 0x1493dc - g_ps2RecompiledFunctionTable[75312] = bhControlPlayerHead_0x1490b0; // 0x1498c8 - g_ps2RecompiledFunctionTable[75422] = bhLookNearEnemy_0x149a80; // 0x149a80 - g_ps2RecompiledFunctionTable[75437] = bhLookNearEnemy_0x149a80; // 0x149abc - g_ps2RecompiledFunctionTable[75522] = bhSetHeadRotation_0x149c10; // 0x149c10 - g_ps2RecompiledFunctionTable[75716] = bhSetHeadRotation_0x149c10; // 0x149f18 - g_ps2RecompiledFunctionTable[75757] = bhSetHeadRotation_0x149c10; // 0x149fbc - g_ps2RecompiledFunctionTable[75764] = bhSetHeadRotation_0x149c10; // 0x149fd8 - g_ps2RecompiledFunctionTable[75769] = bhSetHeadRotation_0x149c10; // 0x149fec - g_ps2RecompiledFunctionTable[75797] = bhSetHeadRotation_0x149c10; // 0x14a05c - g_ps2RecompiledFunctionTable[75802] = bhSetHeadRotation_0x149c10; // 0x14a070 - g_ps2RecompiledFunctionTable[75906] = bhCalcHair_0x14a210; // 0x14a210 - g_ps2RecompiledFunctionTable[76028] = bhCalcHair_0x14a210; // 0x14a3f8 - g_ps2RecompiledFunctionTable[76033] = bhCalcHair_0x14a210; // 0x14a40c - g_ps2RecompiledFunctionTable[76038] = bhCalcHair_0x14a210; // 0x14a420 - g_ps2RecompiledFunctionTable[76043] = bhCalcHair_0x14a210; // 0x14a434 - g_ps2RecompiledFunctionTable[76047] = bhCalcHair_0x14a210; // 0x14a444 - g_ps2RecompiledFunctionTable[76114] = bhGetTransZ_0x14a550; // 0x14a550 - g_ps2RecompiledFunctionTable[76124] = bhGetTransZ_0x14a550; // 0x14a578 - g_ps2RecompiledFunctionTable[76138] = PlyPchInit_0x14a5b0; // 0x14a5b0 - g_ps2RecompiledFunctionTable[76145] = PlyPchInit_0x14a5b0; // 0x14a5cc - g_ps2RecompiledFunctionTable[76150] = PlyPchMain_0x14a5e0; // 0x14a5e0 - g_ps2RecompiledFunctionTable[76266] = PlyPchMain_0x14a5e0; // 0x14a7b0 - g_ps2RecompiledFunctionTable[76270] = PlyPchMain_0x14a5e0; // 0x14a7c0 - g_ps2RecompiledFunctionTable[76274] = PlyPchMain_0x14a5e0; // 0x14a7d0 - g_ps2RecompiledFunctionTable[76278] = PlyPchMain_0x14a5e0; // 0x14a7e0 - g_ps2RecompiledFunctionTable[76315] = PlyPchMain_0x14a5e0; // 0x14a874 - g_ps2RecompiledFunctionTable[76321] = PlyPchMain_0x14a5e0; // 0x14a88c - g_ps2RecompiledFunctionTable[76372] = PlyPchMain_0x14a5e0; // 0x14a958 - g_ps2RecompiledFunctionTable[76397] = PlyPchMain_0x14a5e0; // 0x14a9bc - g_ps2RecompiledFunctionTable[76454] = MixSetToJointRot_0x14aaa0; // 0x14aaa0 - g_ps2RecompiledFunctionTable[76473] = MixSetToJointRot_0x14aaa0; // 0x14aaec - g_ps2RecompiledFunctionTable[76475] = MixSetToJointRot_0x14aaa0; // 0x14aaf4 - g_ps2RecompiledFunctionTable[76488] = MixSetToJointRot_0x14aaa0; // 0x14ab28 - g_ps2RecompiledFunctionTable[76495] = MixSetToJointRot_0x14aaa0; // 0x14ab44 - g_ps2RecompiledFunctionTable[76500] = MixSetToJointRot_0x14aaa0; // 0x14ab58 - g_ps2RecompiledFunctionTable[76502] = MixSetToJointRot_0x14aaa0; // 0x14ab60 - g_ps2RecompiledFunctionTable[76505] = MixSetToJointRot_0x14aaa0; // 0x14ab6c - g_ps2RecompiledFunctionTable[76508] = MixSetToJointRot_0x14aaa0; // 0x14ab78 - g_ps2RecompiledFunctionTable[76518] = MixSetToJointRot_0x14aaa0; // 0x14aba0 - g_ps2RecompiledFunctionTable[76523] = MixSetToJointRot_0x14aaa0; // 0x14abb4 - g_ps2RecompiledFunctionTable[76527] = MixSetToJointRot_0x14aaa0; // 0x14abc4 - g_ps2RecompiledFunctionTable[76532] = MixSetToJointRot_0x14aaa0; // 0x14abd8 - g_ps2RecompiledFunctionTable[76536] = MixSetToJointRot_0x14aaa0; // 0x14abe8 - g_ps2RecompiledFunctionTable[76541] = MixSetToJointRot_0x14aaa0; // 0x14abfc - g_ps2RecompiledFunctionTable[76554] = GetOneObjectMotion_0x14ac30; // 0x14ac30 - g_ps2RecompiledFunctionTable[76598] = SetOneObjectMotion_0x14ace0; // 0x14ace0 - g_ps2RecompiledFunctionTable[76689] = SetOneObjectMotion_0x14ace0; // 0x14ae4c - g_ps2RecompiledFunctionTable[76693] = SetOneObjectMotion_0x14ace0; // 0x14ae5c - g_ps2RecompiledFunctionTable[76713] = SetOneObjectMotion_0x14ace0; // 0x14aeac - g_ps2RecompiledFunctionTable[76730] = SetOneObjectMotion_0x14ace0; // 0x14aef0 - g_ps2RecompiledFunctionTable[76747] = SetOneObjectMotion_0x14ace0; // 0x14af34 - g_ps2RecompiledFunctionTable[76756] = SetOneObjectMotion_0x14ace0; // 0x14af58 - g_ps2RecompiledFunctionTable[76774] = bhSearchEnemy_0x14afa0; // 0x14afa0 - g_ps2RecompiledFunctionTable[76796] = bhSearchEnemy_0x14afa0; // 0x14aff8 - g_ps2RecompiledFunctionTable[76803] = bhSearchEnemy_0x14afa0; // 0x14b014 - g_ps2RecompiledFunctionTable[76809] = bhSearchEnemy_0x14afa0; // 0x14b02c - g_ps2RecompiledFunctionTable[76859] = bhSearchEnemy_0x14afa0; // 0x14b0f4 - g_ps2RecompiledFunctionTable[76861] = bhSearchEnemy_0x14afa0; // 0x14b0fc - g_ps2RecompiledFunctionTable[76865] = bhSearchEnemy_0x14afa0; // 0x14b10c - g_ps2RecompiledFunctionTable[76886] = bhSearchEnemy_0x14afa0; // 0x14b160 - g_ps2RecompiledFunctionTable[76893] = bhSearchEnemy_0x14afa0; // 0x14b17c - g_ps2RecompiledFunctionTable[76898] = bhSearchEnemy_0x14afa0; // 0x14b190 - g_ps2RecompiledFunctionTable[76903] = bhSearchEnemy_0x14afa0; // 0x14b1a4 - g_ps2RecompiledFunctionTable[76912] = bhSearchEnemy_0x14afa0; // 0x14b1c8 - g_ps2RecompiledFunctionTable[76950] = SetLockOnDirection_0x14b260; // 0x14b260 - g_ps2RecompiledFunctionTable[76976] = SetLockOnDirection_0x14b260; // 0x14b2c8 - g_ps2RecompiledFunctionTable[76999] = SetLockOnDirection_0x14b260; // 0x14b324 - g_ps2RecompiledFunctionTable[77086] = bhCPM2_act_suw_pch_0x14b480; // 0x14b480 - g_ps2RecompiledFunctionTable[77104] = bhCPM2_act_suw_pch_0x14b480; // 0x14b4c8 - g_ps2RecompiledFunctionTable[77156] = bhCPM2_act_suw_pch_0x14b480; // 0x14b598 - g_ps2RecompiledFunctionTable[77357] = bhCPM2_act_suw_pch_0x14b480; // 0x14b8bc - g_ps2RecompiledFunctionTable[77381] = bhCPM2_act_suw_pch_0x14b480; // 0x14b91c - g_ps2RecompiledFunctionTable[77390] = bhCPM2_act_wsc_pch_0x14b940; // 0x14b940 - g_ps2RecompiledFunctionTable[77394] = bhCPM2_act_atk_pch_0x14b950; // 0x14b950 - g_ps2RecompiledFunctionTable[77430] = bhCPM2_act_atk_pch_0x14b950; // 0x14b9e0 - g_ps2RecompiledFunctionTable[77491] = bhCPM2_act_atk_pch_0x14b950; // 0x14bad4 - g_ps2RecompiledFunctionTable[77536] = bhCPM2_act_atk_pch_0x14b950; // 0x14bb88 - g_ps2RecompiledFunctionTable[77538] = bhCPM2_act_atk_pch_0x14b950; // 0x14bb90 - g_ps2RecompiledFunctionTable[77545] = bhCPM2_act_atk_pch_0x14b950; // 0x14bbac - g_ps2RecompiledFunctionTable[77572] = bhCPM2_act_atk_pch_0x14b950; // 0x14bc18 - g_ps2RecompiledFunctionTable[77589] = bhCPM2_act_atk_pch_0x14b950; // 0x14bc5c - g_ps2RecompiledFunctionTable[77767] = bhCPM2_act_atk_pch_0x14b950; // 0x14bf24 - g_ps2RecompiledFunctionTable[77791] = bhCPM2_act_atk_pch_0x14b950; // 0x14bf84 - g_ps2RecompiledFunctionTable[77884] = bhCPM2_act_atk_pch_0x14b950; // 0x14c0f8 - g_ps2RecompiledFunctionTable[77913] = bhCPM2_act_atk_pch_0x14b950; // 0x14c16c - g_ps2RecompiledFunctionTable[77943] = bhCPM2_act_atk_pch_0x14b950; // 0x14c1e4 - g_ps2RecompiledFunctionTable[77945] = bhCPM2_act_atk_pch_0x14b950; // 0x14c1ec - g_ps2RecompiledFunctionTable[77998] = bhCPM2_act_atk_pch_0x14b950; // 0x14c2c0 - g_ps2RecompiledFunctionTable[78027] = bhCPM2_act_atk_pch_0x14b950; // 0x14c334 - g_ps2RecompiledFunctionTable[78119] = bhCPM2_act_atk_pch_0x14b950; // 0x14c4a4 - g_ps2RecompiledFunctionTable[78509] = bhCPM2_act_atk_pch_0x14b950; // 0x14cabc - g_ps2RecompiledFunctionTable[78533] = bhCPM2_act_atk_pch_0x14b950; // 0x14cb1c - g_ps2RecompiledFunctionTable[78549] = bhCPM2_act_atk_pch_0x14b950; // 0x14cb5c - g_ps2RecompiledFunctionTable[78573] = bhCPM2_act_atk_pch_0x14b950; // 0x14cbbc - g_ps2RecompiledFunctionTable[78582] = bhCPM2_act_atk_pch_0x14b950; // 0x14cbe0 - g_ps2RecompiledFunctionTable[78591] = bhCPM2_act_atk_pch_0x14b950; // 0x14cc04 - g_ps2RecompiledFunctionTable[78618] = CheckGunHit_0x14cc70; // 0x14cc70 - g_ps2RecompiledFunctionTable[78681] = CheckGunHit_0x14cc70; // 0x14cd6c - g_ps2RecompiledFunctionTable[78701] = CheckGunHit_0x14cc70; // 0x14cdbc - g_ps2RecompiledFunctionTable[78708] = CheckGunHit_0x14cc70; // 0x14cdd8 - g_ps2RecompiledFunctionTable[78719] = CheckGunHit_0x14cc70; // 0x14ce04 - g_ps2RecompiledFunctionTable[78722] = CheckGunHit_0x14cc70; // 0x14ce10 - g_ps2RecompiledFunctionTable[78730] = bhCPM2_SearchPch_0x14ce30; // 0x14ce30 - g_ps2RecompiledFunctionTable[78756] = bhCPM2_SearchPch_0x14ce30; // 0x14ce98 - g_ps2RecompiledFunctionTable[78806] = bhArmIkMdk_0x14cf60; // 0x14cf60 - g_ps2RecompiledFunctionTable[78852] = bhArmIkMdk_0x14cf60; // 0x14d018 - g_ps2RecompiledFunctionTable[78854] = bhArmIkMdk_0x14cf60; // 0x14d020 - g_ps2RecompiledFunctionTable[78857] = bhArmIkMdk_0x14cf60; // 0x14d02c - g_ps2RecompiledFunctionTable[78861] = bhArmIkMdk_0x14cf60; // 0x14d03c - g_ps2RecompiledFunctionTable[78864] = bhArmIkMdk_0x14cf60; // 0x14d048 - g_ps2RecompiledFunctionTable[78866] = bhArmIkMdk_0x14cf60; // 0x14d050 - g_ps2RecompiledFunctionTable[78869] = bhArmIkMdk_0x14cf60; // 0x14d05c - g_ps2RecompiledFunctionTable[78876] = bhArmIkMdk_0x14cf60; // 0x14d078 - g_ps2RecompiledFunctionTable[78878] = bhArmIkMdk_0x14cf60; // 0x14d080 - g_ps2RecompiledFunctionTable[78882] = bhArmIkMdk_0x14cf60; // 0x14d090 - g_ps2RecompiledFunctionTable[78884] = bhArmIkMdk_0x14cf60; // 0x14d098 - g_ps2RecompiledFunctionTable[78888] = bhArmIkMdk_0x14cf60; // 0x14d0a8 - g_ps2RecompiledFunctionTable[78902] = bhArmIkMdk_0x14cf60; // 0x14d0e0 - g_ps2RecompiledFunctionTable[78907] = bhArmIkMdk_0x14cf60; // 0x14d0f4 - g_ps2RecompiledFunctionTable[78911] = bhArmIkMdk_0x14cf60; // 0x14d104 - g_ps2RecompiledFunctionTable[78923] = bhArmIkMdk_0x14cf60; // 0x14d134 - g_ps2RecompiledFunctionTable[78925] = bhArmIkMdk_0x14cf60; // 0x14d13c - g_ps2RecompiledFunctionTable[78929] = bhArmIkMdk_0x14cf60; // 0x14d14c - g_ps2RecompiledFunctionTable[78931] = bhArmIkMdk_0x14cf60; // 0x14d154 - g_ps2RecompiledFunctionTable[78934] = bhArmIkMdk_0x14cf60; // 0x14d160 - g_ps2RecompiledFunctionTable[78939] = bhArmIkMdk_0x14cf60; // 0x14d174 - g_ps2RecompiledFunctionTable[78943] = bhArmIkMdk_0x14cf60; // 0x14d184 - g_ps2RecompiledFunctionTable[78948] = bhArmIkMdk_0x14cf60; // 0x14d198 - g_ps2RecompiledFunctionTable[78952] = bhArmIkMdk_0x14cf60; // 0x14d1a8 - g_ps2RecompiledFunctionTable[78957] = bhArmIkMdk_0x14cf60; // 0x14d1bc - g_ps2RecompiledFunctionTable[78970] = bhArmIkMdk_0x14cf60; // 0x14d1f0 - g_ps2RecompiledFunctionTable[78975] = bhArmIkMdk_0x14cf60; // 0x14d204 - g_ps2RecompiledFunctionTable[78977] = bhArmIkMdk_0x14cf60; // 0x14d20c - g_ps2RecompiledFunctionTable[78994] = bhCPM2_act_scp_0x14d250; // 0x14d250 - g_ps2RecompiledFunctionTable[79150] = bhCPM2_act_scp_0x14d250; // 0x14d4c0 - g_ps2RecompiledFunctionTable[79197] = bhCPM2_act_scp_0x14d250; // 0x14d57c - g_ps2RecompiledFunctionTable[79237] = bhCPM2_act_scp_0x14d250; // 0x14d61c - g_ps2RecompiledFunctionTable[79241] = bhCPM2_act_scp_0x14d250; // 0x14d62c - g_ps2RecompiledFunctionTable[79350] = bhCPM2_act_scp_0x14d250; // 0x14d7e0 - g_ps2RecompiledFunctionTable[79357] = bhCPM2_act_scp_0x14d250; // 0x14d7fc - g_ps2RecompiledFunctionTable[79373] = bhCPM2_act_scp_0x14d250; // 0x14d83c - g_ps2RecompiledFunctionTable[79390] = bhCPM2_act_scp_0x14d250; // 0x14d880 - g_ps2RecompiledFunctionTable[79399] = bhCPM2_act_scp_0x14d250; // 0x14d8a4 - g_ps2RecompiledFunctionTable[79480] = bhCPM2_act_scp_0x14d250; // 0x14d9e8 - g_ps2RecompiledFunctionTable[79495] = bhCPM2_act_scp_0x14d250; // 0x14da24 - g_ps2RecompiledFunctionTable[79503] = bhCPM2_act_scp_0x14d250; // 0x14da44 - g_ps2RecompiledFunctionTable[79510] = bhCPM2_act_scp_0x14d250; // 0x14da60 - g_ps2RecompiledFunctionTable[79519] = bhCPM2_act_scp_0x14d250; // 0x14da84 - g_ps2RecompiledFunctionTable[79521] = bhCPM2_act_scp_0x14d250; // 0x14da8c - g_ps2RecompiledFunctionTable[79523] = bhCPM2_act_scp_0x14d250; // 0x14da94 - g_ps2RecompiledFunctionTable[79539] = bhCPM2_act_scp_0x14d250; // 0x14dad4 - g_ps2RecompiledFunctionTable[79559] = bhCPM2_act_scp_0x14d250; // 0x14db24 - g_ps2RecompiledFunctionTable[79595] = bhCPM2_act_scp_0x14d250; // 0x14dbb4 - g_ps2RecompiledFunctionTable[79655] = bhCPM2_act_scp_0x14d250; // 0x14dca4 - g_ps2RecompiledFunctionTable[79670] = bhCPM2_act_scp_0x14d250; // 0x14dce0 - g_ps2RecompiledFunctionTable[79718] = bhCPM2_act_scp_0x14d250; // 0x14dda0 - g_ps2RecompiledFunctionTable[79739] = bhCPM2_act_scp_0x14d250; // 0x14ddf4 - g_ps2RecompiledFunctionTable[79757] = bhCPM2_act_scp_0x14d250; // 0x14de3c - g_ps2RecompiledFunctionTable[79780] = bhCPM2_act_scp_0x14d250; // 0x14de98 - g_ps2RecompiledFunctionTable[79801] = bhCPM2_act_scp_0x14d250; // 0x14deec - g_ps2RecompiledFunctionTable[79819] = bhCPM2_act_scp_0x14d250; // 0x14df34 - g_ps2RecompiledFunctionTable[79850] = bhGetFreeMemory_0x14dfb0; // 0x14dfb0 - g_ps2RecompiledFunctionTable[79884] = bhGetFreeMemory_0x14dfb0; // 0x14e038 - g_ps2RecompiledFunctionTable[79901] = bhGetFreeMemory_0x14dfb0; // 0x14e07c - g_ps2RecompiledFunctionTable[79910] = bhCalcLinkModel_0x14e0a0; // 0x14e0a0 - g_ps2RecompiledFunctionTable[79922] = bhCalcLinkModel_0x14e0a0; // 0x14e0d0 - g_ps2RecompiledFunctionTable[79942] = bhCalcLinkModel_0x14e0a0; // 0x14e120 - g_ps2RecompiledFunctionTable[79958] = bhCalcLinkModel_0x14e0a0; // 0x14e160 - g_ps2RecompiledFunctionTable[79978] = bhCalcLinkModel_0x14e0a0; // 0x14e1b0 - g_ps2RecompiledFunctionTable[79994] = bhCalcLinkModel_0x14e0a0; // 0x14e1f0 - g_ps2RecompiledFunctionTable[80014] = bhCalcLinkModel_0x14e0a0; // 0x14e240 - g_ps2RecompiledFunctionTable[80025] = bhCalcLinkModel_0x14e0a0; // 0x14e26c - g_ps2RecompiledFunctionTable[80047] = bhCalcLinkModel_0x14e0a0; // 0x14e2c4 - g_ps2RecompiledFunctionTable[80052] = bhCalcLinkModel_0x14e0a0; // 0x14e2d8 - g_ps2RecompiledFunctionTable[80057] = bhCalcLinkModel_0x14e0a0; // 0x14e2ec - g_ps2RecompiledFunctionTable[80070] = bhSetFloorNum_0x14e320; // 0x14e320 - g_ps2RecompiledFunctionTable[80077] = bhSetFloorNum_0x14e320; // 0x14e33c - g_ps2RecompiledFunctionTable[80110] = bhCheckFloorNum_0x14e3c0; // 0x14e3c0 - g_ps2RecompiledFunctionTable[80116] = bhCheckFloorNum_0x14e3c0; // 0x14e3d8 - g_ps2RecompiledFunctionTable[80142] = bhAddSpeed_0x14e440; // 0x14e440 - g_ps2RecompiledFunctionTable[80152] = bhAddSpeed_0x14e440; // 0x14e468 - g_ps2RecompiledFunctionTable[80159] = bhAddSpeed_0x14e440; // 0x14e484 - g_ps2RecompiledFunctionTable[80170] = bhGetFrameNum_0x14e4b0; // 0x14e4b0 - g_ps2RecompiledFunctionTable[80210] = bhGetFrameNum_0x14e4b0; // 0x14e550 - g_ps2RecompiledFunctionTable[80222] = bhCalcLockEneYR_0x14e580; // 0x14e580 - g_ps2RecompiledFunctionTable[80273] = bhCalcLockEneYR_0x14e580; // 0x14e64c - g_ps2RecompiledFunctionTable[80278] = bhCalcLockEneYR_0x14e580; // 0x14e660 - g_ps2RecompiledFunctionTable[80283] = bhCalcLockEneYR_0x14e580; // 0x14e674 - g_ps2RecompiledFunctionTable[80290] = bhCalcLockEneYR_0x14e580; // 0x14e690 - g_ps2RecompiledFunctionTable[80296] = bhCalcLockEneYR_0x14e580; // 0x14e6a8 - g_ps2RecompiledFunctionTable[80308] = bhCalcLockEneYR_0x14e580; // 0x14e6d8 - g_ps2RecompiledFunctionTable[80313] = bhCalcLockEneYR_0x14e580; // 0x14e6ec - g_ps2RecompiledFunctionTable[80318] = bhCalcLockEneYR_0x14e580; // 0x14e700 - g_ps2RecompiledFunctionTable[80330] = bhSearchNearEnemy_0x14e730; // 0x14e730 - g_ps2RecompiledFunctionTable[80362] = bhSearchNearEnemy_0x14e730; // 0x14e7b0 - g_ps2RecompiledFunctionTable[80365] = bhSearchNearEnemy_0x14e730; // 0x14e7bc - g_ps2RecompiledFunctionTable[80369] = bhSearchNearEnemy_0x14e730; // 0x14e7cc - g_ps2RecompiledFunctionTable[80372] = bhSearchNearEnemy_0x14e730; // 0x14e7d8 - g_ps2RecompiledFunctionTable[80376] = bhSearchNearEnemy_0x14e730; // 0x14e7e8 - g_ps2RecompiledFunctionTable[80379] = bhSearchNearEnemy_0x14e730; // 0x14e7f4 - g_ps2RecompiledFunctionTable[80397] = bhSearchNearEnemy_0x14e730; // 0x14e83c - g_ps2RecompiledFunctionTable[80460] = bhSearchNearEnemy_0x14e730; // 0x14e938 - g_ps2RecompiledFunctionTable[80464] = bhSearchNearEnemy_0x14e730; // 0x14e948 - g_ps2RecompiledFunctionTable[80467] = bhSearchNearEnemy_0x14e730; // 0x14e954 - g_ps2RecompiledFunctionTable[80475] = bhSearchNearEnemy_0x14e730; // 0x14e974 - g_ps2RecompiledFunctionTable[80531] = bhSearchNearEnemy_0x14e730; // 0x14ea54 - g_ps2RecompiledFunctionTable[80536] = bhSearchNearEnemy_0x14e730; // 0x14ea68 - g_ps2RecompiledFunctionTable[80541] = bhSearchNearEnemy_0x14e730; // 0x14ea7c - g_ps2RecompiledFunctionTable[80566] = bhSearchNearEnemyB_0x14eae0; // 0x14eae0 - g_ps2RecompiledFunctionTable[80589] = bhSearchNearEnemyB_0x14eae0; // 0x14eb3c - g_ps2RecompiledFunctionTable[80592] = bhSearchNearEnemyB_0x14eae0; // 0x14eb48 - g_ps2RecompiledFunctionTable[80596] = bhSearchNearEnemyB_0x14eae0; // 0x14eb58 - g_ps2RecompiledFunctionTable[80599] = bhSearchNearEnemyB_0x14eae0; // 0x14eb64 - g_ps2RecompiledFunctionTable[80603] = bhSearchNearEnemyB_0x14eae0; // 0x14eb74 - g_ps2RecompiledFunctionTable[80606] = bhSearchNearEnemyB_0x14eae0; // 0x14eb80 - g_ps2RecompiledFunctionTable[80620] = bhSearchNearEnemyB_0x14eae0; // 0x14ebb8 - g_ps2RecompiledFunctionTable[80678] = bhSearchNearEnemyB_0x14eae0; // 0x14eca0 - g_ps2RecompiledFunctionTable[80684] = bhSearchNearEnemyB_0x14eae0; // 0x14ecb8 - g_ps2RecompiledFunctionTable[80687] = bhSearchNearEnemyB_0x14eae0; // 0x14ecc4 - g_ps2RecompiledFunctionTable[80694] = bhSearchNearEnemyB_0x14eae0; // 0x14ece0 - g_ps2RecompiledFunctionTable[80722] = bhSearchNearEnemy2_0x14ed50; // 0x14ed50 - g_ps2RecompiledFunctionTable[80765] = bhSearchNearEnemy2_0x14ed50; // 0x14edfc - g_ps2RecompiledFunctionTable[80768] = bhSearchNearEnemy2_0x14ed50; // 0x14ee08 - g_ps2RecompiledFunctionTable[80772] = bhSearchNearEnemy2_0x14ed50; // 0x14ee18 - g_ps2RecompiledFunctionTable[80775] = bhSearchNearEnemy2_0x14ed50; // 0x14ee24 - g_ps2RecompiledFunctionTable[80779] = bhSearchNearEnemy2_0x14ed50; // 0x14ee34 - g_ps2RecompiledFunctionTable[80782] = bhSearchNearEnemy2_0x14ed50; // 0x14ee40 - g_ps2RecompiledFunctionTable[80789] = bhSearchNearEnemy2_0x14ed50; // 0x14ee5c - g_ps2RecompiledFunctionTable[80844] = bhSearchNearEnemy2_0x14ed50; // 0x14ef38 - g_ps2RecompiledFunctionTable[80848] = bhSearchNearEnemy2_0x14ed50; // 0x14ef48 - g_ps2RecompiledFunctionTable[80885] = bhSearchNearEnemy2_0x14ed50; // 0x14efdc - g_ps2RecompiledFunctionTable[80905] = bhSearchNearEnemy2_0x14ed50; // 0x14f02c - g_ps2RecompiledFunctionTable[80910] = bhSearchNearEnemy2_0x14ed50; // 0x14f040 - g_ps2RecompiledFunctionTable[80915] = bhSearchNearEnemy2_0x14ed50; // 0x14f054 - g_ps2RecompiledFunctionTable[80938] = bhSearchNextEnemy_0x14f0b0; // 0x14f0b0 - g_ps2RecompiledFunctionTable[80964] = bhSearchNextEnemy_0x14f0b0; // 0x14f118 - g_ps2RecompiledFunctionTable[80967] = bhSearchNextEnemy_0x14f0b0; // 0x14f124 - g_ps2RecompiledFunctionTable[80971] = bhSearchNextEnemy_0x14f0b0; // 0x14f134 - g_ps2RecompiledFunctionTable[80974] = bhSearchNextEnemy_0x14f0b0; // 0x14f140 - g_ps2RecompiledFunctionTable[80978] = bhSearchNextEnemy_0x14f0b0; // 0x14f150 - g_ps2RecompiledFunctionTable[80981] = bhSearchNextEnemy_0x14f0b0; // 0x14f15c - g_ps2RecompiledFunctionTable[81001] = bhSearchNextEnemy_0x14f0b0; // 0x14f1ac - g_ps2RecompiledFunctionTable[81065] = bhSearchNextEnemy_0x14f0b0; // 0x14f2ac - g_ps2RecompiledFunctionTable[81069] = bhSearchNextEnemy_0x14f0b0; // 0x14f2bc - g_ps2RecompiledFunctionTable[81072] = bhSearchNextEnemy_0x14f0b0; // 0x14f2c8 - g_ps2RecompiledFunctionTable[81080] = bhSearchNextEnemy_0x14f0b0; // 0x14f2e8 - g_ps2RecompiledFunctionTable[81088] = bhSearchNextEnemy_0x14f0b0; // 0x14f308 - g_ps2RecompiledFunctionTable[81100] = bhSearchNextEnemy_0x14f0b0; // 0x14f338 - g_ps2RecompiledFunctionTable[81152] = bhSearchNextEnemy_0x14f0b0; // 0x14f408 - g_ps2RecompiledFunctionTable[81181] = bhSearchNextEnemy_0x14f0b0; // 0x14f47c - g_ps2RecompiledFunctionTable[81239] = bhSearchNextEnemy_0x14f0b0; // 0x14f564 - g_ps2RecompiledFunctionTable[81244] = bhSearchNextEnemy_0x14f0b0; // 0x14f578 - g_ps2RecompiledFunctionTable[81249] = bhSearchNextEnemy_0x14f0b0; // 0x14f58c - g_ps2RecompiledFunctionTable[81270] = bhSearchPlayer_0x14f5e0; // 0x14f5e0 - g_ps2RecompiledFunctionTable[81289] = bhSearchPlayer_0x14f5e0; // 0x14f62c - g_ps2RecompiledFunctionTable[81292] = bhSearchPlayer_0x14f5e0; // 0x14f638 - g_ps2RecompiledFunctionTable[81296] = bhSearchPlayer_0x14f5e0; // 0x14f648 - g_ps2RecompiledFunctionTable[81299] = bhSearchPlayer_0x14f5e0; // 0x14f654 - g_ps2RecompiledFunctionTable[81303] = bhSearchPlayer_0x14f5e0; // 0x14f664 - g_ps2RecompiledFunctionTable[81306] = bhSearchPlayer_0x14f5e0; // 0x14f670 - g_ps2RecompiledFunctionTable[81323] = bhSearchPlayer_0x14f5e0; // 0x14f6b4 - g_ps2RecompiledFunctionTable[81326] = bhSearchPlayer_0x14f5e0; // 0x14f6c0 - g_ps2RecompiledFunctionTable[81346] = bhSearchPlayer_0x14f5e0; // 0x14f710 - g_ps2RecompiledFunctionTable[81351] = bhSearchPlayer_0x14f5e0; // 0x14f724 - g_ps2RecompiledFunctionTable[81366] = bhCheckL2Wall_0x14f760; // 0x14f760 - g_ps2RecompiledFunctionTable[81367] = bhCheckL2Wall_0x14f760; // 0x14f764 - g_ps2RecompiledFunctionTable[81368] = bhCheckL2Wall_0x14f760; // 0x14f768 - g_ps2RecompiledFunctionTable[81369] = bhCheckL2Wall_0x14f760; // 0x14f76c - g_ps2RecompiledFunctionTable[81370] = bhCheckL2Wall_0x14f760; // 0x14f770 - g_ps2RecompiledFunctionTable[81371] = bhCheckL2Wall_0x14f760; // 0x14f774 - g_ps2RecompiledFunctionTable[81372] = bhCheckL2Wall_0x14f760; // 0x14f778 - g_ps2RecompiledFunctionTable[81373] = bhCheckL2Wall_0x14f760; // 0x14f77c - g_ps2RecompiledFunctionTable[81374] = bhCheckL2Wall_0x14f760; // 0x14f780 - g_ps2RecompiledFunctionTable[81375] = bhCheckL2Wall_0x14f760; // 0x14f784 - g_ps2RecompiledFunctionTable[81376] = bhCheckL2Wall_0x14f760; // 0x14f788 - g_ps2RecompiledFunctionTable[81377] = bhCheckL2Wall_0x14f760; // 0x14f78c - g_ps2RecompiledFunctionTable[81378] = bhCheckL2Wall_0x14f760; // 0x14f790 - g_ps2RecompiledFunctionTable[81379] = bhCheckL2Wall_0x14f760; // 0x14f794 - g_ps2RecompiledFunctionTable[81380] = bhCheckL2Wall_0x14f760; // 0x14f798 - g_ps2RecompiledFunctionTable[81381] = bhCheckL2Wall_0x14f760; // 0x14f79c - g_ps2RecompiledFunctionTable[81382] = bhCheckL2Wall_0x14f760; // 0x14f7a0 - g_ps2RecompiledFunctionTable[81383] = bhCheckL2Wall_0x14f760; // 0x14f7a4 - g_ps2RecompiledFunctionTable[81384] = bhCheckL2Wall_0x14f760; // 0x14f7a8 - g_ps2RecompiledFunctionTable[81385] = bhCheckL2Wall_0x14f760; // 0x14f7ac - g_ps2RecompiledFunctionTable[81386] = bhCheckL2Wall_0x14f760; // 0x14f7b0 - g_ps2RecompiledFunctionTable[81387] = bhCheckL2Wall_0x14f760; // 0x14f7b4 - g_ps2RecompiledFunctionTable[81388] = bhCheckL2Wall_0x14f760; // 0x14f7b8 - g_ps2RecompiledFunctionTable[81389] = bhCheckL2Wall_0x14f760; // 0x14f7bc - g_ps2RecompiledFunctionTable[81390] = bhCheckL2Wall_0x14f760; // 0x14f7c0 - g_ps2RecompiledFunctionTable[81391] = bhCheckL2Wall_0x14f760; // 0x14f7c4 - g_ps2RecompiledFunctionTable[81392] = bhCheckL2Wall_0x14f760; // 0x14f7c8 - g_ps2RecompiledFunctionTable[81393] = bhCheckL2Wall_0x14f760; // 0x14f7cc - g_ps2RecompiledFunctionTable[81394] = bhCheckL2Wall_0x14f760; // 0x14f7d0 - g_ps2RecompiledFunctionTable[81395] = bhCheckL2Wall_0x14f760; // 0x14f7d4 - g_ps2RecompiledFunctionTable[81396] = bhCheckL2Wall_0x14f760; // 0x14f7d8 - g_ps2RecompiledFunctionTable[81397] = bhCheckL2Wall_0x14f760; // 0x14f7dc - g_ps2RecompiledFunctionTable[81398] = bhCheckL2Wall_0x14f760; // 0x14f7e0 - g_ps2RecompiledFunctionTable[81399] = bhCheckL2Wall_0x14f760; // 0x14f7e4 - g_ps2RecompiledFunctionTable[81400] = bhCheckL2Wall_0x14f760; // 0x14f7e8 - g_ps2RecompiledFunctionTable[81401] = bhCheckL2Wall_0x14f760; // 0x14f7ec - g_ps2RecompiledFunctionTable[81402] = bhCheckL2Wall_0x14f760; // 0x14f7f0 - g_ps2RecompiledFunctionTable[81403] = bhCheckL2Wall_0x14f760; // 0x14f7f4 - g_ps2RecompiledFunctionTable[81404] = bhCheckL2Wall_0x14f760; // 0x14f7f8 - g_ps2RecompiledFunctionTable[81405] = bhCheckL2Wall_0x14f760; // 0x14f7fc - g_ps2RecompiledFunctionTable[81406] = bhCheckL2Wall_0x14f760; // 0x14f800 - g_ps2RecompiledFunctionTable[81407] = bhCheckL2Wall_0x14f760; // 0x14f804 - g_ps2RecompiledFunctionTable[81408] = bhCheckL2Wall_0x14f760; // 0x14f808 - g_ps2RecompiledFunctionTable[81409] = bhCheckL2Wall_0x14f760; // 0x14f80c - g_ps2RecompiledFunctionTable[81410] = bhCheckL2Wall_0x14f760; // 0x14f810 - g_ps2RecompiledFunctionTable[81411] = bhCheckL2Wall_0x14f760; // 0x14f814 - g_ps2RecompiledFunctionTable[81412] = bhCheckL2Wall_0x14f760; // 0x14f818 - g_ps2RecompiledFunctionTable[81413] = bhCheckL2Wall_0x14f760; // 0x14f81c - g_ps2RecompiledFunctionTable[81414] = bhCheckL2Wall_0x14f760; // 0x14f820 - g_ps2RecompiledFunctionTable[81415] = bhCheckL2Wall_0x14f760; // 0x14f824 - g_ps2RecompiledFunctionTable[81416] = bhCheckL2Wall_0x14f760; // 0x14f828 - g_ps2RecompiledFunctionTable[81417] = bhCheckL2Wall_0x14f760; // 0x14f82c - g_ps2RecompiledFunctionTable[81418] = bhCheckL2Wall_0x14f760; // 0x14f830 - g_ps2RecompiledFunctionTable[81419] = bhCheckL2Wall_0x14f760; // 0x14f834 - g_ps2RecompiledFunctionTable[81420] = bhCheckL2Wall_0x14f760; // 0x14f838 - g_ps2RecompiledFunctionTable[81421] = bhCheckL2Wall_0x14f760; // 0x14f83c - g_ps2RecompiledFunctionTable[81422] = bhCheckL2Wall_0x14f760; // 0x14f840 - g_ps2RecompiledFunctionTable[81423] = bhCheckL2Wall_0x14f760; // 0x14f844 - g_ps2RecompiledFunctionTable[81424] = bhCheckL2Wall_0x14f760; // 0x14f848 - g_ps2RecompiledFunctionTable[81425] = bhCheckL2Wall_0x14f760; // 0x14f84c - g_ps2RecompiledFunctionTable[81426] = bhCheckL2Wall_0x14f760; // 0x14f850 - g_ps2RecompiledFunctionTable[81427] = bhCheckL2Wall_0x14f760; // 0x14f854 - g_ps2RecompiledFunctionTable[81428] = bhCheckL2Wall_0x14f760; // 0x14f858 - g_ps2RecompiledFunctionTable[81429] = bhCheckL2Wall_0x14f760; // 0x14f85c - g_ps2RecompiledFunctionTable[81430] = bhCheckL2Wall_0x14f760; // 0x14f860 - g_ps2RecompiledFunctionTable[81431] = bhCheckL2Wall_0x14f760; // 0x14f864 - g_ps2RecompiledFunctionTable[81432] = bhCheckL2Wall_0x14f760; // 0x14f868 - g_ps2RecompiledFunctionTable[81433] = bhCheckL2Wall_0x14f760; // 0x14f86c - g_ps2RecompiledFunctionTable[81434] = bhCheckL2Wall_0x14f760; // 0x14f870 - g_ps2RecompiledFunctionTable[81435] = bhCheckL2Wall_0x14f760; // 0x14f874 - g_ps2RecompiledFunctionTable[81436] = bhCheckL2Wall_0x14f760; // 0x14f878 - g_ps2RecompiledFunctionTable[81437] = bhCheckL2Wall_0x14f760; // 0x14f87c - g_ps2RecompiledFunctionTable[81438] = bhCheckL2Wall_0x14f760; // 0x14f880 - g_ps2RecompiledFunctionTable[81439] = bhCheckL2Wall_0x14f760; // 0x14f884 - g_ps2RecompiledFunctionTable[81440] = bhCheckL2Wall_0x14f760; // 0x14f888 - g_ps2RecompiledFunctionTable[81441] = bhCheckL2Wall_0x14f760; // 0x14f88c - g_ps2RecompiledFunctionTable[81442] = bhCheckL2Wall_0x14f760; // 0x14f890 - g_ps2RecompiledFunctionTable[81443] = bhCheckL2Wall_0x14f760; // 0x14f894 - g_ps2RecompiledFunctionTable[81444] = bhCheckL2Wall_0x14f760; // 0x14f898 - g_ps2RecompiledFunctionTable[81445] = bhCheckL2Wall_0x14f760; // 0x14f89c - g_ps2RecompiledFunctionTable[81446] = bhCheckL2Wall_0x14f760; // 0x14f8a0 - g_ps2RecompiledFunctionTable[81447] = bhCheckL2Wall_0x14f760; // 0x14f8a4 - g_ps2RecompiledFunctionTable[81448] = bhCheckL2Wall_0x14f760; // 0x14f8a8 - g_ps2RecompiledFunctionTable[81449] = bhCheckL2Wall_0x14f760; // 0x14f8ac - g_ps2RecompiledFunctionTable[81450] = bhCheckL2Wall_0x14f760; // 0x14f8b0 - g_ps2RecompiledFunctionTable[81451] = bhCheckL2Wall_0x14f760; // 0x14f8b4 - g_ps2RecompiledFunctionTable[81452] = bhCheckL2Wall_0x14f760; // 0x14f8b8 - g_ps2RecompiledFunctionTable[81453] = bhCheckL2Wall_0x14f760; // 0x14f8bc - g_ps2RecompiledFunctionTable[81454] = bhCheckL2Wall_0x14f760; // 0x14f8c0 - g_ps2RecompiledFunctionTable[81455] = bhCheckL2Wall_0x14f760; // 0x14f8c4 - g_ps2RecompiledFunctionTable[81456] = bhCheckL2Wall_0x14f760; // 0x14f8c8 - g_ps2RecompiledFunctionTable[81457] = bhCheckL2Wall_0x14f760; // 0x14f8cc - g_ps2RecompiledFunctionTable[81458] = bhCheckL2Wall_0x14f760; // 0x14f8d0 - g_ps2RecompiledFunctionTable[81459] = bhCheckL2Wall_0x14f760; // 0x14f8d4 - g_ps2RecompiledFunctionTable[81460] = bhCheckL2Wall_0x14f760; // 0x14f8d8 - g_ps2RecompiledFunctionTable[81461] = bhCheckL2Wall_0x14f760; // 0x14f8dc - g_ps2RecompiledFunctionTable[81462] = bhCheckL2Wall_0x14f760; // 0x14f8e0 - g_ps2RecompiledFunctionTable[81463] = bhCheckL2Wall_0x14f760; // 0x14f8e4 - g_ps2RecompiledFunctionTable[81464] = bhCheckL2Wall_0x14f760; // 0x14f8e8 - g_ps2RecompiledFunctionTable[81465] = bhCheckL2Wall_0x14f760; // 0x14f8ec - g_ps2RecompiledFunctionTable[81466] = bhCheckL2Wall_0x14f760; // 0x14f8f0 - g_ps2RecompiledFunctionTable[81467] = bhCheckL2Wall_0x14f760; // 0x14f8f4 - g_ps2RecompiledFunctionTable[81468] = bhCheckL2Wall_0x14f760; // 0x14f8f8 - g_ps2RecompiledFunctionTable[81469] = bhCheckL2Wall_0x14f760; // 0x14f8fc - g_ps2RecompiledFunctionTable[81470] = bhCheckL2Wall_0x14f760; // 0x14f900 - g_ps2RecompiledFunctionTable[81471] = bhCheckL2Wall_0x14f760; // 0x14f904 - g_ps2RecompiledFunctionTable[81472] = bhCheckL2Wall_0x14f760; // 0x14f908 - g_ps2RecompiledFunctionTable[81473] = bhCheckL2Wall_0x14f760; // 0x14f90c - g_ps2RecompiledFunctionTable[81474] = bhCheckL2Wall_0x14f760; // 0x14f910 - g_ps2RecompiledFunctionTable[81475] = bhCheckL2Wall_0x14f760; // 0x14f914 - g_ps2RecompiledFunctionTable[81476] = bhCheckL2Wall_0x14f760; // 0x14f918 - g_ps2RecompiledFunctionTable[81477] = bhCheckL2Wall_0x14f760; // 0x14f91c - g_ps2RecompiledFunctionTable[81478] = bhCheckL2Wall_0x14f760; // 0x14f920 - g_ps2RecompiledFunctionTable[81479] = bhCheckL2Wall_0x14f760; // 0x14f924 - g_ps2RecompiledFunctionTable[81480] = bhCheckL2Wall_0x14f760; // 0x14f928 - g_ps2RecompiledFunctionTable[81481] = bhCheckL2Wall_0x14f760; // 0x14f92c - g_ps2RecompiledFunctionTable[81482] = bhCheckL2Wall_0x14f760; // 0x14f930 - g_ps2RecompiledFunctionTable[81483] = bhCheckL2Wall_0x14f760; // 0x14f934 - g_ps2RecompiledFunctionTable[81484] = bhCheckL2Wall_0x14f760; // 0x14f938 - g_ps2RecompiledFunctionTable[81485] = bhCheckL2Wall_0x14f760; // 0x14f93c - g_ps2RecompiledFunctionTable[81486] = bhCheckL2Wall_0x14f760; // 0x14f940 - g_ps2RecompiledFunctionTable[81487] = bhCheckL2Wall_0x14f760; // 0x14f944 - g_ps2RecompiledFunctionTable[81488] = bhCheckL2Wall_0x14f760; // 0x14f948 - g_ps2RecompiledFunctionTable[81489] = bhCheckL2Wall_0x14f760; // 0x14f94c - g_ps2RecompiledFunctionTable[81490] = bhCheckL2Wall_0x14f760; // 0x14f950 - g_ps2RecompiledFunctionTable[81491] = bhCheckL2Wall_0x14f760; // 0x14f954 - g_ps2RecompiledFunctionTable[81492] = bhCheckL2Wall_0x14f760; // 0x14f958 - g_ps2RecompiledFunctionTable[81493] = bhCheckL2Wall_0x14f760; // 0x14f95c - g_ps2RecompiledFunctionTable[81494] = bhCheckL2Wall_0x14f760; // 0x14f960 - g_ps2RecompiledFunctionTable[81495] = bhCheckL2Wall_0x14f760; // 0x14f964 - g_ps2RecompiledFunctionTable[81496] = bhCheckL2Wall_0x14f760; // 0x14f968 - g_ps2RecompiledFunctionTable[81497] = bhCheckL2Wall_0x14f760; // 0x14f96c - g_ps2RecompiledFunctionTable[81498] = bhCheckL2Wall_0x14f760; // 0x14f970 - g_ps2RecompiledFunctionTable[81499] = bhCheckL2Wall_0x14f760; // 0x14f974 - g_ps2RecompiledFunctionTable[81500] = bhCheckL2Wall_0x14f760; // 0x14f978 - g_ps2RecompiledFunctionTable[81501] = bhCheckL2Wall_0x14f760; // 0x14f97c - g_ps2RecompiledFunctionTable[81502] = bhCheckL2Wall_0x14f760; // 0x14f980 - g_ps2RecompiledFunctionTable[81503] = bhCheckL2Wall_0x14f760; // 0x14f984 - g_ps2RecompiledFunctionTable[81504] = bhCheckL2Wall_0x14f760; // 0x14f988 - g_ps2RecompiledFunctionTable[81505] = bhCheckL2Wall_0x14f760; // 0x14f98c - g_ps2RecompiledFunctionTable[81506] = bhCheckL2Wall_0x14f760; // 0x14f990 - g_ps2RecompiledFunctionTable[81507] = bhCheckL2Wall_0x14f760; // 0x14f994 - g_ps2RecompiledFunctionTable[81508] = bhCheckL2Wall_0x14f760; // 0x14f998 - g_ps2RecompiledFunctionTable[81509] = bhCheckL2Wall_0x14f760; // 0x14f99c - g_ps2RecompiledFunctionTable[81510] = bhCheckL2Wall_0x14f760; // 0x14f9a0 - g_ps2RecompiledFunctionTable[81511] = bhCheckL2Wall_0x14f760; // 0x14f9a4 - g_ps2RecompiledFunctionTable[81512] = bhCheckL2Wall_0x14f760; // 0x14f9a8 - g_ps2RecompiledFunctionTable[81513] = bhCheckL2Wall_0x14f760; // 0x14f9ac - g_ps2RecompiledFunctionTable[81514] = bhCheckL2Wall_0x14f760; // 0x14f9b0 - g_ps2RecompiledFunctionTable[81515] = bhCheckL2Wall_0x14f760; // 0x14f9b4 - g_ps2RecompiledFunctionTable[81516] = bhCheckL2Wall_0x14f760; // 0x14f9b8 - g_ps2RecompiledFunctionTable[81517] = bhCheckL2Wall_0x14f760; // 0x14f9bc - g_ps2RecompiledFunctionTable[81518] = bhCheckL2Wall_0x14f760; // 0x14f9c0 - g_ps2RecompiledFunctionTable[81519] = bhCheckL2Wall_0x14f760; // 0x14f9c4 - g_ps2RecompiledFunctionTable[81520] = bhCheckL2Wall_0x14f760; // 0x14f9c8 - g_ps2RecompiledFunctionTable[81521] = bhCheckL2Wall_0x14f760; // 0x14f9cc - g_ps2RecompiledFunctionTable[81522] = bhCheckL2Wall_0x14f760; // 0x14f9d0 - g_ps2RecompiledFunctionTable[81523] = bhCheckL2Wall_0x14f760; // 0x14f9d4 - g_ps2RecompiledFunctionTable[81524] = bhCheckL2Wall_0x14f760; // 0x14f9d8 - g_ps2RecompiledFunctionTable[81525] = bhCheckL2Wall_0x14f760; // 0x14f9dc - g_ps2RecompiledFunctionTable[81526] = bhCheckL2Wall_0x14f760; // 0x14f9e0 - g_ps2RecompiledFunctionTable[81527] = bhCheckL2Wall_0x14f760; // 0x14f9e4 - g_ps2RecompiledFunctionTable[81528] = bhCheckL2Wall_0x14f760; // 0x14f9e8 - g_ps2RecompiledFunctionTable[81529] = bhCheckL2Wall_0x14f760; // 0x14f9ec - g_ps2RecompiledFunctionTable[81530] = bhCheckL2Wall_0x14f760; // 0x14f9f0 - g_ps2RecompiledFunctionTable[81531] = bhCheckL2Wall_0x14f760; // 0x14f9f4 - g_ps2RecompiledFunctionTable[81532] = bhCheckL2Wall_0x14f760; // 0x14f9f8 - g_ps2RecompiledFunctionTable[81533] = bhCheckL2Wall_0x14f760; // 0x14f9fc - g_ps2RecompiledFunctionTable[81534] = bhCheckL2Wall_0x14f760; // 0x14fa00 - g_ps2RecompiledFunctionTable[81535] = bhCheckL2Wall_0x14f760; // 0x14fa04 - g_ps2RecompiledFunctionTable[81536] = bhCheckL2Wall_0x14f760; // 0x14fa08 - g_ps2RecompiledFunctionTable[81537] = bhCheckL2Wall_0x14f760; // 0x14fa0c - g_ps2RecompiledFunctionTable[81538] = bhCheckL2Wall_0x14f760; // 0x14fa10 - g_ps2RecompiledFunctionTable[81539] = bhCheckL2Wall_0x14f760; // 0x14fa14 - g_ps2RecompiledFunctionTable[81540] = bhCheckL2Wall_0x14f760; // 0x14fa18 - g_ps2RecompiledFunctionTable[81541] = bhCheckL2Wall_0x14f760; // 0x14fa1c - g_ps2RecompiledFunctionTable[81542] = bhCheckL2Wall_0x14f760; // 0x14fa20 - g_ps2RecompiledFunctionTable[81543] = bhCheckL2Wall_0x14f760; // 0x14fa24 - g_ps2RecompiledFunctionTable[81544] = bhCheckL2Wall_0x14f760; // 0x14fa28 - g_ps2RecompiledFunctionTable[81545] = bhCheckL2Wall_0x14f760; // 0x14fa2c - g_ps2RecompiledFunctionTable[81546] = bhCheckL2Wall_0x14f760; // 0x14fa30 - g_ps2RecompiledFunctionTable[81547] = bhCheckL2Wall_0x14f760; // 0x14fa34 - g_ps2RecompiledFunctionTable[81548] = bhCheckL2Wall_0x14f760; // 0x14fa38 - g_ps2RecompiledFunctionTable[81549] = bhCheckL2Wall_0x14f760; // 0x14fa3c - g_ps2RecompiledFunctionTable[81550] = bhCheckL2Wall_0x14f760; // 0x14fa40 - g_ps2RecompiledFunctionTable[81551] = bhCheckL2Wall_0x14f760; // 0x14fa44 - g_ps2RecompiledFunctionTable[81552] = bhCheckL2Wall_0x14f760; // 0x14fa48 - g_ps2RecompiledFunctionTable[81553] = bhCheckL2Wall_0x14f760; // 0x14fa4c - g_ps2RecompiledFunctionTable[81554] = bhCheckL2Wall_0x14f760; // 0x14fa50 - g_ps2RecompiledFunctionTable[81555] = bhCheckL2Wall_0x14f760; // 0x14fa54 - g_ps2RecompiledFunctionTable[81556] = bhCheckL2Wall_0x14f760; // 0x14fa58 - g_ps2RecompiledFunctionTable[81557] = bhCheckL2Wall_0x14f760; // 0x14fa5c - g_ps2RecompiledFunctionTable[81558] = bhCheckL2Wall_0x14f760; // 0x14fa60 - g_ps2RecompiledFunctionTable[81559] = bhCheckL2Wall_0x14f760; // 0x14fa64 - g_ps2RecompiledFunctionTable[81560] = bhCheckL2Wall_0x14f760; // 0x14fa68 - g_ps2RecompiledFunctionTable[81561] = bhCheckL2Wall_0x14f760; // 0x14fa6c - g_ps2RecompiledFunctionTable[81562] = bhCheckL2Wall_0x14f760; // 0x14fa70 - g_ps2RecompiledFunctionTable[81563] = bhCheckL2Wall_0x14f760; // 0x14fa74 - g_ps2RecompiledFunctionTable[81564] = bhCheckL2Wall_0x14f760; // 0x14fa78 - g_ps2RecompiledFunctionTable[81565] = bhCheckL2Wall_0x14f760; // 0x14fa7c - g_ps2RecompiledFunctionTable[81566] = bhCheckL2Wall_0x14f760; // 0x14fa80 - g_ps2RecompiledFunctionTable[81567] = bhCheckL2Wall_0x14f760; // 0x14fa84 - g_ps2RecompiledFunctionTable[81568] = bhCheckL2Wall_0x14f760; // 0x14fa88 - g_ps2RecompiledFunctionTable[81569] = bhCheckL2Wall_0x14f760; // 0x14fa8c - g_ps2RecompiledFunctionTable[81570] = bhCheckL2Wall_0x14f760; // 0x14fa90 - g_ps2RecompiledFunctionTable[81571] = bhCheckL2Wall_0x14f760; // 0x14fa94 - g_ps2RecompiledFunctionTable[81572] = bhCheckL2Wall_0x14f760; // 0x14fa98 - g_ps2RecompiledFunctionTable[81573] = bhCheckL2Wall_0x14f760; // 0x14fa9c - g_ps2RecompiledFunctionTable[81574] = bhCheckL2Wall_0x14f760; // 0x14faa0 - g_ps2RecompiledFunctionTable[81575] = bhCheckL2Wall_0x14f760; // 0x14faa4 - g_ps2RecompiledFunctionTable[81576] = bhCheckL2Wall_0x14f760; // 0x14faa8 - g_ps2RecompiledFunctionTable[81577] = bhCheckL2Wall_0x14f760; // 0x14faac - g_ps2RecompiledFunctionTable[81578] = bhCheckL2Wall_0x14f760; // 0x14fab0 - g_ps2RecompiledFunctionTable[81579] = bhCheckL2Wall_0x14f760; // 0x14fab4 - g_ps2RecompiledFunctionTable[81580] = bhCheckL2Wall_0x14f760; // 0x14fab8 - g_ps2RecompiledFunctionTable[81581] = bhCheckL2Wall_0x14f760; // 0x14fabc - g_ps2RecompiledFunctionTable[81582] = bhCheckL2Wall_0x14f760; // 0x14fac0 - g_ps2RecompiledFunctionTable[81583] = bhCheckL2Wall_0x14f760; // 0x14fac4 - g_ps2RecompiledFunctionTable[81584] = bhCheckL2Wall_0x14f760; // 0x14fac8 - g_ps2RecompiledFunctionTable[81585] = bhCheckL2Wall_0x14f760; // 0x14facc - g_ps2RecompiledFunctionTable[81586] = bhCheckL2Wall_0x14f760; // 0x14fad0 - g_ps2RecompiledFunctionTable[81587] = bhCheckL2Wall_0x14f760; // 0x14fad4 - g_ps2RecompiledFunctionTable[81588] = bhCheckL2Wall_0x14f760; // 0x14fad8 - g_ps2RecompiledFunctionTable[81589] = bhCheckL2Wall_0x14f760; // 0x14fadc - g_ps2RecompiledFunctionTable[81590] = bhCheckL2Wall_0x14f760; // 0x14fae0 - g_ps2RecompiledFunctionTable[81591] = bhCheckL2Wall_0x14f760; // 0x14fae4 - g_ps2RecompiledFunctionTable[81592] = bhCheckL2Wall_0x14f760; // 0x14fae8 - g_ps2RecompiledFunctionTable[81593] = bhCheckL2Wall_0x14f760; // 0x14faec - g_ps2RecompiledFunctionTable[81594] = bhCheckL2Wall_0x14f760; // 0x14faf0 - g_ps2RecompiledFunctionTable[81595] = bhCheckL2Wall_0x14f760; // 0x14faf4 - g_ps2RecompiledFunctionTable[81596] = bhCheckL2Wall_0x14f760; // 0x14faf8 - g_ps2RecompiledFunctionTable[81597] = bhCheckL2Wall_0x14f760; // 0x14fafc - g_ps2RecompiledFunctionTable[81598] = bhCheckL2Wall_0x14f760; // 0x14fb00 - g_ps2RecompiledFunctionTable[81599] = bhCheckL2Wall_0x14f760; // 0x14fb04 - g_ps2RecompiledFunctionTable[81600] = bhCheckL2Wall_0x14f760; // 0x14fb08 - g_ps2RecompiledFunctionTable[81601] = bhCheckL2Wall_0x14f760; // 0x14fb0c - g_ps2RecompiledFunctionTable[81602] = bhCheckL2Wall_0x14f760; // 0x14fb10 - g_ps2RecompiledFunctionTable[81603] = bhCheckL2Wall_0x14f760; // 0x14fb14 - g_ps2RecompiledFunctionTable[81604] = bhCheckL2Wall_0x14f760; // 0x14fb18 - g_ps2RecompiledFunctionTable[81605] = bhCheckL2Wall_0x14f760; // 0x14fb1c - g_ps2RecompiledFunctionTable[81606] = bhCheckL2Wall_0x14f760; // 0x14fb20 - g_ps2RecompiledFunctionTable[81607] = bhCheckL2Wall_0x14f760; // 0x14fb24 - g_ps2RecompiledFunctionTable[81608] = bhCheckL2Wall_0x14f760; // 0x14fb28 - g_ps2RecompiledFunctionTable[81609] = bhCheckL2Wall_0x14f760; // 0x14fb2c - g_ps2RecompiledFunctionTable[81610] = bhCheckL2Wall_0x14f760; // 0x14fb30 - g_ps2RecompiledFunctionTable[81611] = bhCheckL2Wall_0x14f760; // 0x14fb34 - g_ps2RecompiledFunctionTable[81612] = bhCheckL2Wall_0x14f760; // 0x14fb38 - g_ps2RecompiledFunctionTable[81613] = bhCheckL2Wall_0x14f760; // 0x14fb3c - g_ps2RecompiledFunctionTable[81614] = bhCheckL2Wall_0x14f760; // 0x14fb40 - g_ps2RecompiledFunctionTable[81615] = bhCheckL2Wall_0x14f760; // 0x14fb44 - g_ps2RecompiledFunctionTable[81616] = bhCheckL2Wall_0x14f760; // 0x14fb48 - g_ps2RecompiledFunctionTable[81617] = bhCheckL2Wall_0x14f760; // 0x14fb4c - g_ps2RecompiledFunctionTable[81618] = bhCheckL2Wall_0x14f760; // 0x14fb50 - g_ps2RecompiledFunctionTable[81619] = bhCheckL2Wall_0x14f760; // 0x14fb54 - g_ps2RecompiledFunctionTable[81620] = bhCheckL2Wall_0x14f760; // 0x14fb58 - g_ps2RecompiledFunctionTable[81621] = bhCheckL2Wall_0x14f760; // 0x14fb5c - g_ps2RecompiledFunctionTable[81622] = bhCheckL2Wall_0x14f760; // 0x14fb60 - g_ps2RecompiledFunctionTable[81623] = bhCheckL2Wall_0x14f760; // 0x14fb64 - g_ps2RecompiledFunctionTable[81624] = bhCheckL2Wall_0x14f760; // 0x14fb68 - g_ps2RecompiledFunctionTable[81625] = bhCheckL2Wall_0x14f760; // 0x14fb6c - g_ps2RecompiledFunctionTable[81626] = bhCheckL2Wall_0x14f760; // 0x14fb70 - g_ps2RecompiledFunctionTable[81627] = bhCheckL2Wall_0x14f760; // 0x14fb74 - g_ps2RecompiledFunctionTable[81628] = bhCheckL2Wall_0x14f760; // 0x14fb78 - g_ps2RecompiledFunctionTable[81629] = bhCheckL2Wall_0x14f760; // 0x14fb7c - g_ps2RecompiledFunctionTable[81630] = bhCheckL2Wall_0x14f760; // 0x14fb80 - g_ps2RecompiledFunctionTable[81631] = bhCheckL2Wall_0x14f760; // 0x14fb84 - g_ps2RecompiledFunctionTable[81632] = bhCheckL2Wall_0x14f760; // 0x14fb88 - g_ps2RecompiledFunctionTable[81633] = bhCheckL2Wall_0x14f760; // 0x14fb8c - g_ps2RecompiledFunctionTable[81634] = bhCheckL2Wall_0x14f760; // 0x14fb90 - g_ps2RecompiledFunctionTable[81635] = bhCheckL2Wall_0x14f760; // 0x14fb94 - g_ps2RecompiledFunctionTable[81636] = bhCheckL2Wall_0x14f760; // 0x14fb98 - g_ps2RecompiledFunctionTable[81637] = bhCheckL2Wall_0x14f760; // 0x14fb9c - g_ps2RecompiledFunctionTable[81638] = bhCheckL2Wall_0x14f760; // 0x14fba0 - g_ps2RecompiledFunctionTable[81639] = bhCheckL2Wall_0x14f760; // 0x14fba4 - g_ps2RecompiledFunctionTable[81640] = bhCheckL2Wall_0x14f760; // 0x14fba8 - g_ps2RecompiledFunctionTable[81641] = bhCheckL2Wall_0x14f760; // 0x14fbac - g_ps2RecompiledFunctionTable[81642] = bhCheckL2Wall_0x14f760; // 0x14fbb0 - g_ps2RecompiledFunctionTable[81643] = bhCheckL2Wall_0x14f760; // 0x14fbb4 - g_ps2RecompiledFunctionTable[81644] = bhCheckL2Wall_0x14f760; // 0x14fbb8 - g_ps2RecompiledFunctionTable[81645] = bhCheckL2Wall_0x14f760; // 0x14fbbc - g_ps2RecompiledFunctionTable[81646] = bhCheckL2Wall_0x14f760; // 0x14fbc0 - g_ps2RecompiledFunctionTable[81647] = bhCheckL2Wall_0x14f760; // 0x14fbc4 - g_ps2RecompiledFunctionTable[81648] = bhCheckL2Wall_0x14f760; // 0x14fbc8 - g_ps2RecompiledFunctionTable[81649] = bhCheckL2Wall_0x14f760; // 0x14fbcc - g_ps2RecompiledFunctionTable[81650] = bhCheckL2Wall_0x14f760; // 0x14fbd0 - g_ps2RecompiledFunctionTable[81651] = bhCheckL2Wall_0x14f760; // 0x14fbd4 - g_ps2RecompiledFunctionTable[81652] = bhCheckL2Wall_0x14f760; // 0x14fbd8 - g_ps2RecompiledFunctionTable[81653] = bhCheckL2Wall_0x14f760; // 0x14fbdc - g_ps2RecompiledFunctionTable[81654] = bhCheckL2Wall_0x14f760; // 0x14fbe0 - g_ps2RecompiledFunctionTable[81655] = bhCheckL2Wall_0x14f760; // 0x14fbe4 - g_ps2RecompiledFunctionTable[81656] = bhCheckL2Wall_0x14f760; // 0x14fbe8 - g_ps2RecompiledFunctionTable[81657] = bhCheckL2Wall_0x14f760; // 0x14fbec - g_ps2RecompiledFunctionTable[81658] = bhCheckL2Wall_0x14f760; // 0x14fbf0 - g_ps2RecompiledFunctionTable[81659] = bhCheckL2Wall_0x14f760; // 0x14fbf4 - g_ps2RecompiledFunctionTable[81660] = bhCheckL2Wall_0x14f760; // 0x14fbf8 - g_ps2RecompiledFunctionTable[81661] = bhCheckL2Wall_0x14f760; // 0x14fbfc - g_ps2RecompiledFunctionTable[81662] = bhCheckL2Wall_0x14f760; // 0x14fc00 - g_ps2RecompiledFunctionTable[81663] = bhCheckL2Wall_0x14f760; // 0x14fc04 - g_ps2RecompiledFunctionTable[81664] = bhCheckL2Wall_0x14f760; // 0x14fc08 - g_ps2RecompiledFunctionTable[81665] = bhCheckL2Wall_0x14f760; // 0x14fc0c - g_ps2RecompiledFunctionTable[81666] = bhCheckL2Wall_0x14f760; // 0x14fc10 - g_ps2RecompiledFunctionTable[81667] = bhCheckL2Wall_0x14f760; // 0x14fc14 - g_ps2RecompiledFunctionTable[81668] = bhCheckL2Wall_0x14f760; // 0x14fc18 - g_ps2RecompiledFunctionTable[81669] = bhCheckL2Wall_0x14f760; // 0x14fc1c - g_ps2RecompiledFunctionTable[81670] = bhCheckL2Wall_0x14f760; // 0x14fc20 - g_ps2RecompiledFunctionTable[81671] = bhCheckL2Wall_0x14f760; // 0x14fc24 - g_ps2RecompiledFunctionTable[81672] = bhCheckL2Wall_0x14f760; // 0x14fc28 - g_ps2RecompiledFunctionTable[81673] = bhCheckL2Wall_0x14f760; // 0x14fc2c - g_ps2RecompiledFunctionTable[81674] = bhCheckL2Wall_0x14f760; // 0x14fc30 - g_ps2RecompiledFunctionTable[81675] = bhCheckL2Wall_0x14f760; // 0x14fc34 - g_ps2RecompiledFunctionTable[81676] = bhCheckL2Wall_0x14f760; // 0x14fc38 - g_ps2RecompiledFunctionTable[81677] = bhCheckL2Wall_0x14f760; // 0x14fc3c - g_ps2RecompiledFunctionTable[81678] = bhCheckL2Wall_0x14f760; // 0x14fc40 - g_ps2RecompiledFunctionTable[81679] = bhCheckL2Wall_0x14f760; // 0x14fc44 - g_ps2RecompiledFunctionTable[81680] = bhCheckL2Wall_0x14f760; // 0x14fc48 - g_ps2RecompiledFunctionTable[81681] = bhCheckL2Wall_0x14f760; // 0x14fc4c - g_ps2RecompiledFunctionTable[81682] = bhCheckL2Wall_0x14f760; // 0x14fc50 - g_ps2RecompiledFunctionTable[81683] = bhCheckL2Wall_0x14f760; // 0x14fc54 - g_ps2RecompiledFunctionTable[81684] = bhCheckL2Wall_0x14f760; // 0x14fc58 - g_ps2RecompiledFunctionTable[81685] = bhCheckL2Wall_0x14f760; // 0x14fc5c - g_ps2RecompiledFunctionTable[81686] = bhCheckL2Wall_0x14f760; // 0x14fc60 - g_ps2RecompiledFunctionTable[81687] = bhCheckL2Wall_0x14f760; // 0x14fc64 - g_ps2RecompiledFunctionTable[81688] = bhCheckL2Wall_0x14f760; // 0x14fc68 - g_ps2RecompiledFunctionTable[81689] = bhCheckL2Wall_0x14f760; // 0x14fc6c - g_ps2RecompiledFunctionTable[81690] = bhCheckL2Wall_0x14f760; // 0x14fc70 - g_ps2RecompiledFunctionTable[81691] = bhCheckL2Wall_0x14f760; // 0x14fc74 - g_ps2RecompiledFunctionTable[81692] = bhCheckL2Wall_0x14f760; // 0x14fc78 - g_ps2RecompiledFunctionTable[81693] = bhCheckL2Wall_0x14f760; // 0x14fc7c - g_ps2RecompiledFunctionTable[81694] = bhCheckL2Wall_0x14f760; // 0x14fc80 - g_ps2RecompiledFunctionTable[81695] = bhCheckL2Wall_0x14f760; // 0x14fc84 - g_ps2RecompiledFunctionTable[81696] = bhCheckL2Wall_0x14f760; // 0x14fc88 - g_ps2RecompiledFunctionTable[81697] = bhCheckL2Wall_0x14f760; // 0x14fc8c - g_ps2RecompiledFunctionTable[81698] = bhCheckL2Wall_0x14f760; // 0x14fc90 - g_ps2RecompiledFunctionTable[81699] = bhCheckL2Wall_0x14f760; // 0x14fc94 - g_ps2RecompiledFunctionTable[81700] = bhCheckL2Wall_0x14f760; // 0x14fc98 - g_ps2RecompiledFunctionTable[81701] = bhCheckL2Wall_0x14f760; // 0x14fc9c - g_ps2RecompiledFunctionTable[81702] = bhCheckL2Wall_0x14f760; // 0x14fca0 - g_ps2RecompiledFunctionTable[81703] = bhCheckL2Wall_0x14f760; // 0x14fca4 - g_ps2RecompiledFunctionTable[81704] = bhCheckL2Wall_0x14f760; // 0x14fca8 - g_ps2RecompiledFunctionTable[81705] = bhCheckL2Wall_0x14f760; // 0x14fcac - g_ps2RecompiledFunctionTable[81706] = bhCheckL2Wall_0x14f760; // 0x14fcb0 - g_ps2RecompiledFunctionTable[81707] = bhCheckL2Wall_0x14f760; // 0x14fcb4 - g_ps2RecompiledFunctionTable[81708] = bhCheckL2Wall_0x14f760; // 0x14fcb8 - g_ps2RecompiledFunctionTable[81709] = bhCheckL2Wall_0x14f760; // 0x14fcbc - g_ps2RecompiledFunctionTable[81710] = bhCheckL2Wall_0x14f760; // 0x14fcc0 - g_ps2RecompiledFunctionTable[81711] = bhCheckL2Wall_0x14f760; // 0x14fcc4 - g_ps2RecompiledFunctionTable[81712] = bhCheckL2Wall_0x14f760; // 0x14fcc8 - g_ps2RecompiledFunctionTable[81713] = bhCheckL2Wall_0x14f760; // 0x14fccc - g_ps2RecompiledFunctionTable[81714] = bhCheckL2Wall_0x14f760; // 0x14fcd0 - g_ps2RecompiledFunctionTable[81715] = bhCheckL2Wall_0x14f760; // 0x14fcd4 - g_ps2RecompiledFunctionTable[81716] = bhCheckL2Wall_0x14f760; // 0x14fcd8 - g_ps2RecompiledFunctionTable[81717] = bhCheckL2Wall_0x14f760; // 0x14fcdc - g_ps2RecompiledFunctionTable[81718] = bhCheckL2Wall_0x14f760; // 0x14fce0 - g_ps2RecompiledFunctionTable[81719] = bhCheckL2Wall_0x14f760; // 0x14fce4 - g_ps2RecompiledFunctionTable[81720] = bhCheckL2Wall_0x14f760; // 0x14fce8 - g_ps2RecompiledFunctionTable[81721] = bhCheckL2Wall_0x14f760; // 0x14fcec - g_ps2RecompiledFunctionTable[81722] = bhCheckL2Wall_0x14f760; // 0x14fcf0 - g_ps2RecompiledFunctionTable[81723] = bhCheckL2Wall_0x14f760; // 0x14fcf4 - g_ps2RecompiledFunctionTable[81724] = bhCheckL2Wall_0x14f760; // 0x14fcf8 - g_ps2RecompiledFunctionTable[81725] = bhCheckL2Wall_0x14f760; // 0x14fcfc - g_ps2RecompiledFunctionTable[81726] = bhCheckL2Wall_0x14f760; // 0x14fd00 - g_ps2RecompiledFunctionTable[81727] = bhCheckL2Wall_0x14f760; // 0x14fd04 - g_ps2RecompiledFunctionTable[81728] = bhCheckL2Wall_0x14f760; // 0x14fd08 - g_ps2RecompiledFunctionTable[81729] = bhCheckL2Wall_0x14f760; // 0x14fd0c - g_ps2RecompiledFunctionTable[81730] = bhCheckL2Wall_0x14f760; // 0x14fd10 - g_ps2RecompiledFunctionTable[81731] = bhCheckL2Wall_0x14f760; // 0x14fd14 - g_ps2RecompiledFunctionTable[81732] = bhCheckL2Wall_0x14f760; // 0x14fd18 - g_ps2RecompiledFunctionTable[81733] = bhCheckL2Wall_0x14f760; // 0x14fd1c - g_ps2RecompiledFunctionTable[81734] = bhCheckL2Wall_0x14f760; // 0x14fd20 - g_ps2RecompiledFunctionTable[81735] = bhCheckL2Wall_0x14f760; // 0x14fd24 - g_ps2RecompiledFunctionTable[81736] = bhCheckL2Wall_0x14f760; // 0x14fd28 - g_ps2RecompiledFunctionTable[81737] = bhCheckL2Wall_0x14f760; // 0x14fd2c - g_ps2RecompiledFunctionTable[81738] = bhCheckL2Wall_0x14f760; // 0x14fd30 - g_ps2RecompiledFunctionTable[81739] = bhCheckL2Wall_0x14f760; // 0x14fd34 - g_ps2RecompiledFunctionTable[81740] = bhCheckL2Wall_0x14f760; // 0x14fd38 - g_ps2RecompiledFunctionTable[81741] = bhCheckL2Wall_0x14f760; // 0x14fd3c - g_ps2RecompiledFunctionTable[81742] = bhCheckL2Wall_0x14f760; // 0x14fd40 - g_ps2RecompiledFunctionTable[81743] = bhCheckL2Wall_0x14f760; // 0x14fd44 - g_ps2RecompiledFunctionTable[81744] = bhCheckL2Wall_0x14f760; // 0x14fd48 - g_ps2RecompiledFunctionTable[81745] = bhCheckL2Wall_0x14f760; // 0x14fd4c - g_ps2RecompiledFunctionTable[81746] = bhCheckL2Wall_0x14f760; // 0x14fd50 - g_ps2RecompiledFunctionTable[81747] = bhCheckL2Wall_0x14f760; // 0x14fd54 - g_ps2RecompiledFunctionTable[81748] = bhCheckL2Wall_0x14f760; // 0x14fd58 - g_ps2RecompiledFunctionTable[81749] = bhCheckL2Wall_0x14f760; // 0x14fd5c - g_ps2RecompiledFunctionTable[81750] = bhCheckL2Wall_0x14f760; // 0x14fd60 - g_ps2RecompiledFunctionTable[81751] = bhCheckL2Wall_0x14f760; // 0x14fd64 - g_ps2RecompiledFunctionTable[81752] = bhCheckL2Wall_0x14f760; // 0x14fd68 - g_ps2RecompiledFunctionTable[81753] = bhCheckL2Wall_0x14f760; // 0x14fd6c - g_ps2RecompiledFunctionTable[81754] = bhCheckL2Wall_0x14f760; // 0x14fd70 - g_ps2RecompiledFunctionTable[81755] = bhCheckL2Wall_0x14f760; // 0x14fd74 - g_ps2RecompiledFunctionTable[81756] = bhCheckL2Wall_0x14f760; // 0x14fd78 - g_ps2RecompiledFunctionTable[81757] = bhCheckL2Wall_0x14f760; // 0x14fd7c - g_ps2RecompiledFunctionTable[81758] = bhCheckL2Wall_0x14f760; // 0x14fd80 - g_ps2RecompiledFunctionTable[81759] = bhCheckL2Wall_0x14f760; // 0x14fd84 - g_ps2RecompiledFunctionTable[81760] = bhCheckL2Wall_0x14f760; // 0x14fd88 - g_ps2RecompiledFunctionTable[81761] = bhCheckL2Wall_0x14f760; // 0x14fd8c - g_ps2RecompiledFunctionTable[81762] = bhCheckL2Wall_0x14f760; // 0x14fd90 - g_ps2RecompiledFunctionTable[81763] = bhCheckL2Wall_0x14f760; // 0x14fd94 - g_ps2RecompiledFunctionTable[81764] = bhCheckL2Wall_0x14f760; // 0x14fd98 - g_ps2RecompiledFunctionTable[81765] = bhCheckL2Wall_0x14f760; // 0x14fd9c - g_ps2RecompiledFunctionTable[81766] = bhCheckL2Wall_0x14f760; // 0x14fda0 - g_ps2RecompiledFunctionTable[81767] = bhCheckL2Wall_0x14f760; // 0x14fda4 - g_ps2RecompiledFunctionTable[81768] = bhCheckL2Wall_0x14f760; // 0x14fda8 - g_ps2RecompiledFunctionTable[81769] = bhCheckL2Wall_0x14f760; // 0x14fdac - g_ps2RecompiledFunctionTable[81770] = bhCheckL2Wall_0x14f760; // 0x14fdb0 - g_ps2RecompiledFunctionTable[81771] = bhCheckL2Wall_0x14f760; // 0x14fdb4 - g_ps2RecompiledFunctionTable[81772] = bhCheckL2Wall_0x14f760; // 0x14fdb8 - g_ps2RecompiledFunctionTable[81773] = bhCheckL2Wall_0x14f760; // 0x14fdbc - g_ps2RecompiledFunctionTable[81774] = bhCheckL2Wall_0x14f760; // 0x14fdc0 - g_ps2RecompiledFunctionTable[81775] = bhCheckL2Wall_0x14f760; // 0x14fdc4 - g_ps2RecompiledFunctionTable[81776] = bhCheckL2Wall_0x14f760; // 0x14fdc8 - g_ps2RecompiledFunctionTable[81777] = bhCheckL2Wall_0x14f760; // 0x14fdcc - g_ps2RecompiledFunctionTable[81778] = bhCheckL2Wall_0x14f760; // 0x14fdd0 - g_ps2RecompiledFunctionTable[81779] = bhCheckL2Wall_0x14f760; // 0x14fdd4 - g_ps2RecompiledFunctionTable[81780] = bhCheckL2Wall_0x14f760; // 0x14fdd8 - g_ps2RecompiledFunctionTable[81781] = bhCheckL2Wall_0x14f760; // 0x14fddc - g_ps2RecompiledFunctionTable[81782] = bhCheckL2Wall_0x14f760; // 0x14fde0 - g_ps2RecompiledFunctionTable[81783] = bhCheckL2Wall_0x14f760; // 0x14fde4 - g_ps2RecompiledFunctionTable[81784] = bhCheckL2Wall_0x14f760; // 0x14fde8 - g_ps2RecompiledFunctionTable[81785] = bhCheckL2Wall_0x14f760; // 0x14fdec - g_ps2RecompiledFunctionTable[81786] = bhCheckL2Wall_0x14f760; // 0x14fdf0 - g_ps2RecompiledFunctionTable[81787] = bhCheckL2Wall_0x14f760; // 0x14fdf4 - g_ps2RecompiledFunctionTable[81788] = bhCheckL2Wall_0x14f760; // 0x14fdf8 - g_ps2RecompiledFunctionTable[81789] = bhCheckL2Wall_0x14f760; // 0x14fdfc - g_ps2RecompiledFunctionTable[81790] = bhCheckL2Wall_0x14f760; // 0x14fe00 - g_ps2RecompiledFunctionTable[81791] = bhCheckL2Wall_0x14f760; // 0x14fe04 - g_ps2RecompiledFunctionTable[81792] = bhCheckL2Wall_0x14f760; // 0x14fe08 - g_ps2RecompiledFunctionTable[81793] = bhCheckL2Wall_0x14f760; // 0x14fe0c - g_ps2RecompiledFunctionTable[81794] = bhCheckL2Wall_0x14f760; // 0x14fe10 - g_ps2RecompiledFunctionTable[81795] = bhCheckL2Wall_0x14f760; // 0x14fe14 - g_ps2RecompiledFunctionTable[81796] = bhCheckL2Wall_0x14f760; // 0x14fe18 - g_ps2RecompiledFunctionTable[81797] = bhCheckL2Wall_0x14f760; // 0x14fe1c - g_ps2RecompiledFunctionTable[81798] = bhCheckL2Wall_0x14f760; // 0x14fe20 - g_ps2RecompiledFunctionTable[81799] = bhCheckL2Wall_0x14f760; // 0x14fe24 - g_ps2RecompiledFunctionTable[81800] = bhCheckL2Wall_0x14f760; // 0x14fe28 - g_ps2RecompiledFunctionTable[81801] = bhCheckL2Wall_0x14f760; // 0x14fe2c - g_ps2RecompiledFunctionTable[81802] = bhCheckL2Wall_0x14f760; // 0x14fe30 - g_ps2RecompiledFunctionTable[81803] = bhCheckL2Wall_0x14f760; // 0x14fe34 - g_ps2RecompiledFunctionTable[81804] = bhCheckL2Wall_0x14f760; // 0x14fe38 - g_ps2RecompiledFunctionTable[81805] = bhCheckL2Wall_0x14f760; // 0x14fe3c - g_ps2RecompiledFunctionTable[81806] = bhCheckL2Wall_0x14f760; // 0x14fe40 - g_ps2RecompiledFunctionTable[81807] = bhCheckL2Wall_0x14f760; // 0x14fe44 - g_ps2RecompiledFunctionTable[81808] = bhCheckL2Wall_0x14f760; // 0x14fe48 - g_ps2RecompiledFunctionTable[81809] = bhCheckL2Wall_0x14f760; // 0x14fe4c - g_ps2RecompiledFunctionTable[81810] = bhCheckL2Wall_0x14f760; // 0x14fe50 - g_ps2RecompiledFunctionTable[81811] = bhCheckL2Wall_0x14f760; // 0x14fe54 - g_ps2RecompiledFunctionTable[81812] = bhCheckL2Wall_0x14f760; // 0x14fe58 - g_ps2RecompiledFunctionTable[81813] = bhCheckL2Wall_0x14f760; // 0x14fe5c - g_ps2RecompiledFunctionTable[81814] = bhCheckL2Wall_0x14f760; // 0x14fe60 - g_ps2RecompiledFunctionTable[81815] = bhCheckL2Wall_0x14f760; // 0x14fe64 - g_ps2RecompiledFunctionTable[81816] = bhCheckL2Wall_0x14f760; // 0x14fe68 - g_ps2RecompiledFunctionTable[81817] = bhCheckL2Wall_0x14f760; // 0x14fe6c - g_ps2RecompiledFunctionTable[81818] = bhCheckL2Wall_0x14f760; // 0x14fe70 - g_ps2RecompiledFunctionTable[81819] = bhCheckL2Wall_0x14f760; // 0x14fe74 - g_ps2RecompiledFunctionTable[81820] = bhCheckL2Wall_0x14f760; // 0x14fe78 - g_ps2RecompiledFunctionTable[81821] = bhCheckL2Wall_0x14f760; // 0x14fe7c - g_ps2RecompiledFunctionTable[81822] = bhCheckL2Wall_0x14f760; // 0x14fe80 - g_ps2RecompiledFunctionTable[81823] = bhCheckL2Wall_0x14f760; // 0x14fe84 - g_ps2RecompiledFunctionTable[81824] = bhCheckL2Wall_0x14f760; // 0x14fe88 - g_ps2RecompiledFunctionTable[81825] = bhCheckL2Wall_0x14f760; // 0x14fe8c - g_ps2RecompiledFunctionTable[81826] = bhCheckL2Wall_0x14f760; // 0x14fe90 - g_ps2RecompiledFunctionTable[81827] = bhCheckL2Wall_0x14f760; // 0x14fe94 - g_ps2RecompiledFunctionTable[81828] = bhCheckL2Wall_0x14f760; // 0x14fe98 - g_ps2RecompiledFunctionTable[81829] = bhCheckL2Wall_0x14f760; // 0x14fe9c - g_ps2RecompiledFunctionTable[81830] = bhCheckL2Wall_0x14f760; // 0x14fea0 - g_ps2RecompiledFunctionTable[81831] = bhCheckL2Wall_0x14f760; // 0x14fea4 - g_ps2RecompiledFunctionTable[81832] = bhCheckL2Wall_0x14f760; // 0x14fea8 - g_ps2RecompiledFunctionTable[81833] = bhCheckL2Wall_0x14f760; // 0x14feac - g_ps2RecompiledFunctionTable[81834] = bhCheckL2Wall_0x14f760; // 0x14feb0 - g_ps2RecompiledFunctionTable[81835] = bhCheckL2Wall_0x14f760; // 0x14feb4 - g_ps2RecompiledFunctionTable[81836] = bhCheckL2Wall_0x14f760; // 0x14feb8 - g_ps2RecompiledFunctionTable[81837] = bhCheckL2Wall_0x14f760; // 0x14febc - g_ps2RecompiledFunctionTable[81838] = bhCheckL2Wall_0x14f760; // 0x14fec0 - g_ps2RecompiledFunctionTable[81839] = bhCheckL2Wall_0x14f760; // 0x14fec4 - g_ps2RecompiledFunctionTable[81840] = bhCheckL2Wall_0x14f760; // 0x14fec8 - g_ps2RecompiledFunctionTable[81841] = bhCheckL2Wall_0x14f760; // 0x14fecc - g_ps2RecompiledFunctionTable[81842] = bhCheckL2Wall_0x14f760; // 0x14fed0 - g_ps2RecompiledFunctionTable[81843] = bhCheckL2Wall_0x14f760; // 0x14fed4 - g_ps2RecompiledFunctionTable[81844] = bhCheckL2Wall_0x14f760; // 0x14fed8 - g_ps2RecompiledFunctionTable[81845] = bhCheckL2Wall_0x14f760; // 0x14fedc - g_ps2RecompiledFunctionTable[81846] = bhCheckL2Wall_0x14f760; // 0x14fee0 - g_ps2RecompiledFunctionTable[81847] = bhCheckL2Wall_0x14f760; // 0x14fee4 - g_ps2RecompiledFunctionTable[81848] = bhCheckL2Wall_0x14f760; // 0x14fee8 - g_ps2RecompiledFunctionTable[81849] = bhCheckL2Wall_0x14f760; // 0x14feec - g_ps2RecompiledFunctionTable[81850] = bhCheckL2Wall_0x14f760; // 0x14fef0 - g_ps2RecompiledFunctionTable[81851] = bhCheckL2Wall_0x14f760; // 0x14fef4 - g_ps2RecompiledFunctionTable[81852] = bhCheckL2Wall_0x14f760; // 0x14fef8 - g_ps2RecompiledFunctionTable[81853] = bhCheckL2Wall_0x14f760; // 0x14fefc - g_ps2RecompiledFunctionTable[81854] = bhCheckL2Wall_0x14f760; // 0x14ff00 - g_ps2RecompiledFunctionTable[81855] = bhCheckL2Wall_0x14f760; // 0x14ff04 - g_ps2RecompiledFunctionTable[81856] = bhCheckL2Wall_0x14f760; // 0x14ff08 - g_ps2RecompiledFunctionTable[81857] = bhCheckL2Wall_0x14f760; // 0x14ff0c - g_ps2RecompiledFunctionTable[81858] = bhCheckL2Wall_0x14f760; // 0x14ff10 - g_ps2RecompiledFunctionTable[81859] = bhCheckL2Wall_0x14f760; // 0x14ff14 - g_ps2RecompiledFunctionTable[81860] = bhCheckL2Wall_0x14f760; // 0x14ff18 - g_ps2RecompiledFunctionTable[81861] = bhCheckL2Wall_0x14f760; // 0x14ff1c - g_ps2RecompiledFunctionTable[81862] = bhCheckL2Wall_0x14f760; // 0x14ff20 - g_ps2RecompiledFunctionTable[81863] = bhCheckL2Wall_0x14f760; // 0x14ff24 - g_ps2RecompiledFunctionTable[81864] = bhCheckL2Wall_0x14f760; // 0x14ff28 - g_ps2RecompiledFunctionTable[81865] = bhCheckL2Wall_0x14f760; // 0x14ff2c - g_ps2RecompiledFunctionTable[81866] = bhCheckL2Wall_0x14f760; // 0x14ff30 - g_ps2RecompiledFunctionTable[81867] = bhCheckL2Wall_0x14f760; // 0x14ff34 - g_ps2RecompiledFunctionTable[81868] = bhCheckL2Wall_0x14f760; // 0x14ff38 - g_ps2RecompiledFunctionTable[81869] = bhCheckL2Wall_0x14f760; // 0x14ff3c - g_ps2RecompiledFunctionTable[81870] = bhCheckL2Wall_0x14f760; // 0x14ff40 - g_ps2RecompiledFunctionTable[81871] = bhCheckL2Wall_0x14f760; // 0x14ff44 - g_ps2RecompiledFunctionTable[81872] = bhCheckL2Wall_0x14f760; // 0x14ff48 - g_ps2RecompiledFunctionTable[81873] = bhCheckL2Wall_0x14f760; // 0x14ff4c - g_ps2RecompiledFunctionTable[81874] = bhCheckL2Wall_0x14f760; // 0x14ff50 - g_ps2RecompiledFunctionTable[81875] = bhCheckL2Wall_0x14f760; // 0x14ff54 - g_ps2RecompiledFunctionTable[81876] = bhCheckL2Wall_0x14f760; // 0x14ff58 - g_ps2RecompiledFunctionTable[81877] = bhCheckL2Wall_0x14f760; // 0x14ff5c - g_ps2RecompiledFunctionTable[81878] = bhCheckL2Wall_0x14f760; // 0x14ff60 - g_ps2RecompiledFunctionTable[81879] = bhCheckL2Wall_0x14f760; // 0x14ff64 - g_ps2RecompiledFunctionTable[81880] = bhCheckL2Wall_0x14f760; // 0x14ff68 - g_ps2RecompiledFunctionTable[81881] = bhCheckL2Wall_0x14f760; // 0x14ff6c - g_ps2RecompiledFunctionTable[81882] = bhCheckL2Wall_0x14f760; // 0x14ff70 - g_ps2RecompiledFunctionTable[81883] = bhCheckL2Wall_0x14f760; // 0x14ff74 - g_ps2RecompiledFunctionTable[81884] = bhCheckL2Wall_0x14f760; // 0x14ff78 - g_ps2RecompiledFunctionTable[81885] = bhCheckL2Wall_0x14f760; // 0x14ff7c - g_ps2RecompiledFunctionTable[81886] = bhCheckL2Wall_0x14f760; // 0x14ff80 - g_ps2RecompiledFunctionTable[81887] = bhCheckL2Wall_0x14f760; // 0x14ff84 - g_ps2RecompiledFunctionTable[81888] = bhCheckL2Wall_0x14f760; // 0x14ff88 - g_ps2RecompiledFunctionTable[81889] = bhCheckL2Wall_0x14f760; // 0x14ff8c - g_ps2RecompiledFunctionTable[81890] = bhCheckL2Wall_0x14f760; // 0x14ff90 - g_ps2RecompiledFunctionTable[81891] = bhCheckL2Wall_0x14f760; // 0x14ff94 - g_ps2RecompiledFunctionTable[81892] = bhCheckL2Wall_0x14f760; // 0x14ff98 - g_ps2RecompiledFunctionTable[81893] = bhCheckL2Wall_0x14f760; // 0x14ff9c - g_ps2RecompiledFunctionTable[81894] = bhCheckL2Wall_0x14f760; // 0x14ffa0 - g_ps2RecompiledFunctionTable[81895] = bhCheckL2Wall_0x14f760; // 0x14ffa4 - g_ps2RecompiledFunctionTable[81896] = bhCheckL2Wall_0x14f760; // 0x14ffa8 - g_ps2RecompiledFunctionTable[81897] = bhCheckL2Wall_0x14f760; // 0x14ffac - g_ps2RecompiledFunctionTable[81898] = bhCheckL2Wall_0x14f760; // 0x14ffb0 - g_ps2RecompiledFunctionTable[81899] = bhCheckL2Wall_0x14f760; // 0x14ffb4 - g_ps2RecompiledFunctionTable[81900] = bhCheckL2Wall_0x14f760; // 0x14ffb8 - g_ps2RecompiledFunctionTable[81901] = bhCheckL2Wall_0x14f760; // 0x14ffbc - g_ps2RecompiledFunctionTable[81902] = bhCheckL2Wall_0x14f760; // 0x14ffc0 - g_ps2RecompiledFunctionTable[81903] = bhCheckL2Wall_0x14f760; // 0x14ffc4 - g_ps2RecompiledFunctionTable[81904] = bhCheckL2Wall_0x14f760; // 0x14ffc8 - g_ps2RecompiledFunctionTable[81905] = bhCheckL2Wall_0x14f760; // 0x14ffcc - g_ps2RecompiledFunctionTable[81906] = bhCheckL2Wall_0x14f760; // 0x14ffd0 - g_ps2RecompiledFunctionTable[81907] = bhCheckL2Wall_0x14f760; // 0x14ffd4 - g_ps2RecompiledFunctionTable[81908] = bhCheckL2Wall_0x14f760; // 0x14ffd8 - g_ps2RecompiledFunctionTable[81909] = bhCheckL2Wall_0x14f760; // 0x14ffdc - g_ps2RecompiledFunctionTable[81910] = bhCheckL2Wall_0x14f760; // 0x14ffe0 - g_ps2RecompiledFunctionTable[81911] = bhCheckL2Wall_0x14f760; // 0x14ffe4 - g_ps2RecompiledFunctionTable[81912] = bhCheckL2Wall_0x14f760; // 0x14ffe8 - g_ps2RecompiledFunctionTable[81913] = bhCheckL2Wall_0x14f760; // 0x14ffec - g_ps2RecompiledFunctionTable[81914] = bhCheckL2Wall_0x14f760; // 0x14fff0 - g_ps2RecompiledFunctionTable[81915] = bhCheckL2Wall_0x14f760; // 0x14fff4 - g_ps2RecompiledFunctionTable[81916] = bhCheckL2Wall_0x14f760; // 0x14fff8 - g_ps2RecompiledFunctionTable[81917] = bhCheckL2Wall_0x14f760; // 0x14fffc - g_ps2RecompiledFunctionTable[81918] = bhCheckL2Wall_0x14f760; // 0x150000 - g_ps2RecompiledFunctionTable[81919] = bhCheckL2Wall_0x14f760; // 0x150004 - g_ps2RecompiledFunctionTable[81920] = bhCheckL2Wall_0x14f760; // 0x150008 - g_ps2RecompiledFunctionTable[81921] = bhCheckL2Wall_0x14f760; // 0x15000c - g_ps2RecompiledFunctionTable[81922] = bhCheckL2Wall_0x14f760; // 0x150010 - g_ps2RecompiledFunctionTable[81923] = bhCheckL2Wall_0x14f760; // 0x150014 - g_ps2RecompiledFunctionTable[81924] = bhCheckL2Wall_0x14f760; // 0x150018 - g_ps2RecompiledFunctionTable[81925] = bhCheckL2Wall_0x14f760; // 0x15001c - g_ps2RecompiledFunctionTable[81926] = bhCheckL2Wall_0x14f760; // 0x150020 - g_ps2RecompiledFunctionTable[81927] = bhCheckL2Wall_0x14f760; // 0x150024 - g_ps2RecompiledFunctionTable[81928] = bhCheckL2Wall_0x14f760; // 0x150028 - g_ps2RecompiledFunctionTable[81929] = bhCheckL2Wall_0x14f760; // 0x15002c - g_ps2RecompiledFunctionTable[81930] = bhCheckL2Wall_0x14f760; // 0x150030 - g_ps2RecompiledFunctionTable[81931] = bhCheckL2Wall_0x14f760; // 0x150034 - g_ps2RecompiledFunctionTable[81932] = bhCheckL2Wall_0x14f760; // 0x150038 - g_ps2RecompiledFunctionTable[81933] = bhCheckL2Wall_0x14f760; // 0x15003c - g_ps2RecompiledFunctionTable[81934] = bhCheckL2Wall_0x14f760; // 0x150040 - g_ps2RecompiledFunctionTable[81935] = bhCheckL2Wall_0x14f760; // 0x150044 - g_ps2RecompiledFunctionTable[81936] = bhCheckL2Wall_0x14f760; // 0x150048 - g_ps2RecompiledFunctionTable[81937] = bhCheckL2Wall_0x14f760; // 0x15004c - g_ps2RecompiledFunctionTable[81938] = bhCheckL2Wall_0x14f760; // 0x150050 - g_ps2RecompiledFunctionTable[81939] = bhCheckL2Wall_0x14f760; // 0x150054 - g_ps2RecompiledFunctionTable[81940] = bhCheckL2Wall_0x14f760; // 0x150058 - g_ps2RecompiledFunctionTable[81941] = bhCheckL2Wall_0x14f760; // 0x15005c - g_ps2RecompiledFunctionTable[81942] = bhCheckL2Wall_0x14f760; // 0x150060 - g_ps2RecompiledFunctionTable[81943] = bhCheckL2Wall_0x14f760; // 0x150064 - g_ps2RecompiledFunctionTable[81944] = bhCheckL2Wall_0x14f760; // 0x150068 - g_ps2RecompiledFunctionTable[81945] = bhCheckL2Wall_0x14f760; // 0x15006c - g_ps2RecompiledFunctionTable[81946] = bhCheckL2Wall_0x14f760; // 0x150070 - g_ps2RecompiledFunctionTable[81947] = bhCheckL2Wall_0x14f760; // 0x150074 - g_ps2RecompiledFunctionTable[81948] = bhCheckL2Wall_0x14f760; // 0x150078 - g_ps2RecompiledFunctionTable[81949] = bhCheckL2Wall_0x14f760; // 0x15007c - g_ps2RecompiledFunctionTable[81950] = bhCheckL2Wall_0x14f760; // 0x150080 - g_ps2RecompiledFunctionTable[81951] = bhCheckL2Wall_0x14f760; // 0x150084 - g_ps2RecompiledFunctionTable[81952] = bhCheckL2Wall_0x14f760; // 0x150088 - g_ps2RecompiledFunctionTable[81953] = bhCheckL2Wall_0x14f760; // 0x15008c - g_ps2RecompiledFunctionTable[81954] = bhCheckL2Wall_0x14f760; // 0x150090 - g_ps2RecompiledFunctionTable[81955] = bhCheckL2Wall_0x14f760; // 0x150094 - g_ps2RecompiledFunctionTable[81956] = bhCheckL2Wall_0x14f760; // 0x150098 - g_ps2RecompiledFunctionTable[81957] = bhCheckL2Wall_0x14f760; // 0x15009c - g_ps2RecompiledFunctionTable[81958] = bhCheckL2Wall_0x14f760; // 0x1500a0 - g_ps2RecompiledFunctionTable[81959] = bhCheckL2Wall_0x14f760; // 0x1500a4 - g_ps2RecompiledFunctionTable[81960] = bhCheckL2Wall_0x14f760; // 0x1500a8 - g_ps2RecompiledFunctionTable[81961] = bhCheckL2Wall_0x14f760; // 0x1500ac - g_ps2RecompiledFunctionTable[81962] = bhCheckL2Wall_0x14f760; // 0x1500b0 - g_ps2RecompiledFunctionTable[81963] = bhCheckL2Wall_0x14f760; // 0x1500b4 - g_ps2RecompiledFunctionTable[81964] = bhCheckL2Wall_0x14f760; // 0x1500b8 - g_ps2RecompiledFunctionTable[81965] = bhCheckL2Wall_0x14f760; // 0x1500bc - g_ps2RecompiledFunctionTable[81966] = bhCheckL2Wall_0x14f760; // 0x1500c0 - g_ps2RecompiledFunctionTable[81967] = bhCheckL2Wall_0x14f760; // 0x1500c4 - g_ps2RecompiledFunctionTable[81968] = bhCheckL2Wall_0x14f760; // 0x1500c8 - g_ps2RecompiledFunctionTable[81969] = bhCheckL2Wall_0x14f760; // 0x1500cc - g_ps2RecompiledFunctionTable[81970] = bhCheckL2Wall_0x14f760; // 0x1500d0 - g_ps2RecompiledFunctionTable[81971] = bhCheckL2Wall_0x14f760; // 0x1500d4 - g_ps2RecompiledFunctionTable[81972] = bhCheckL2Wall_0x14f760; // 0x1500d8 - g_ps2RecompiledFunctionTable[81973] = bhCheckL2Wall_0x14f760; // 0x1500dc - g_ps2RecompiledFunctionTable[81974] = bhCheckL2Wall_0x14f760; // 0x1500e0 - g_ps2RecompiledFunctionTable[81975] = bhCheckL2Wall_0x14f760; // 0x1500e4 - g_ps2RecompiledFunctionTable[81976] = bhCheckL2Wall_0x14f760; // 0x1500e8 - g_ps2RecompiledFunctionTable[81977] = bhCheckL2Wall_0x14f760; // 0x1500ec - g_ps2RecompiledFunctionTable[81978] = bhCheckL2Wall_0x14f760; // 0x1500f0 - g_ps2RecompiledFunctionTable[81979] = bhCheckL2Wall_0x14f760; // 0x1500f4 - g_ps2RecompiledFunctionTable[81980] = bhCheckL2Wall_0x14f760; // 0x1500f8 - g_ps2RecompiledFunctionTable[81981] = bhCheckL2Wall_0x14f760; // 0x1500fc - g_ps2RecompiledFunctionTable[81982] = bhCheckL2Wall_0x14f760; // 0x150100 - g_ps2RecompiledFunctionTable[81983] = bhCheckL2Wall_0x14f760; // 0x150104 - g_ps2RecompiledFunctionTable[81984] = bhCheckL2Wall_0x14f760; // 0x150108 - g_ps2RecompiledFunctionTable[81985] = bhCheckL2Wall_0x14f760; // 0x15010c - g_ps2RecompiledFunctionTable[81986] = bhCheckL2Wall_0x14f760; // 0x150110 - g_ps2RecompiledFunctionTable[81987] = bhCheckL2Wall_0x14f760; // 0x150114 - g_ps2RecompiledFunctionTable[81988] = bhCheckL2Wall_0x14f760; // 0x150118 - g_ps2RecompiledFunctionTable[81989] = bhCheckL2Wall_0x14f760; // 0x15011c - g_ps2RecompiledFunctionTable[81990] = bhCheckL2Wall_0x14f760; // 0x150120 - g_ps2RecompiledFunctionTable[81991] = bhCheckL2Wall_0x14f760; // 0x150124 - g_ps2RecompiledFunctionTable[81992] = bhCheckL2Wall_0x14f760; // 0x150128 - g_ps2RecompiledFunctionTable[81993] = bhCheckL2Wall_0x14f760; // 0x15012c - g_ps2RecompiledFunctionTable[81994] = bhCheckL2Wall_0x14f760; // 0x150130 - g_ps2RecompiledFunctionTable[81995] = bhCheckL2Wall_0x14f760; // 0x150134 - g_ps2RecompiledFunctionTable[81996] = bhCheckL2Wall_0x14f760; // 0x150138 - g_ps2RecompiledFunctionTable[81997] = bhCheckL2Wall_0x14f760; // 0x15013c - g_ps2RecompiledFunctionTable[81998] = bhCheckL2Wall_0x14f760; // 0x150140 - g_ps2RecompiledFunctionTable[81999] = bhCheckL2Wall_0x14f760; // 0x150144 - g_ps2RecompiledFunctionTable[82000] = bhCheckL2Wall_0x14f760; // 0x150148 - g_ps2RecompiledFunctionTable[82001] = bhCheckL2Wall_0x14f760; // 0x15014c - g_ps2RecompiledFunctionTable[82002] = bhCheckL2Wall_0x14f760; // 0x150150 - g_ps2RecompiledFunctionTable[82003] = bhCheckL2Wall_0x14f760; // 0x150154 - g_ps2RecompiledFunctionTable[82004] = bhCheckL2Wall_0x14f760; // 0x150158 - g_ps2RecompiledFunctionTable[82005] = bhCheckL2Wall_0x14f760; // 0x15015c - g_ps2RecompiledFunctionTable[82006] = bhCheckL2Wall_0x14f760; // 0x150160 - g_ps2RecompiledFunctionTable[82007] = bhCheckL2Wall_0x14f760; // 0x150164 - g_ps2RecompiledFunctionTable[82008] = bhCheckL2Wall_0x14f760; // 0x150168 - g_ps2RecompiledFunctionTable[82009] = bhCheckL2Wall_0x14f760; // 0x15016c - g_ps2RecompiledFunctionTable[82010] = bhCheckL2Wall_0x14f760; // 0x150170 - g_ps2RecompiledFunctionTable[82011] = bhCheckL2Wall_0x14f760; // 0x150174 - g_ps2RecompiledFunctionTable[82012] = bhCheckL2Wall_0x14f760; // 0x150178 - g_ps2RecompiledFunctionTable[82013] = bhCheckL2Wall_0x14f760; // 0x15017c - g_ps2RecompiledFunctionTable[82014] = bhCheckL2Wall_0x14f760; // 0x150180 - g_ps2RecompiledFunctionTable[82015] = bhCheckL2Wall_0x14f760; // 0x150184 - g_ps2RecompiledFunctionTable[82016] = bhCheckL2Wall_0x14f760; // 0x150188 - g_ps2RecompiledFunctionTable[82017] = bhCheckL2Wall_0x14f760; // 0x15018c - g_ps2RecompiledFunctionTable[82018] = bhCheckL2Wall_0x14f760; // 0x150190 - g_ps2RecompiledFunctionTable[82019] = bhCheckL2Wall_0x14f760; // 0x150194 - g_ps2RecompiledFunctionTable[82020] = bhCheckL2Wall_0x14f760; // 0x150198 - g_ps2RecompiledFunctionTable[82021] = bhCheckL2Wall_0x14f760; // 0x15019c - g_ps2RecompiledFunctionTable[82022] = bhCheckL2Wall_0x14f760; // 0x1501a0 - g_ps2RecompiledFunctionTable[82023] = bhCheckL2Wall_0x14f760; // 0x1501a4 - g_ps2RecompiledFunctionTable[82024] = bhCheckL2Wall_0x14f760; // 0x1501a8 - g_ps2RecompiledFunctionTable[82025] = bhCheckL2Wall_0x14f760; // 0x1501ac - g_ps2RecompiledFunctionTable[82026] = bhCheckL2Wall_0x14f760; // 0x1501b0 - g_ps2RecompiledFunctionTable[82027] = bhCheckL2Wall_0x14f760; // 0x1501b4 - g_ps2RecompiledFunctionTable[82028] = bhCheckL2Wall_0x14f760; // 0x1501b8 - g_ps2RecompiledFunctionTable[82029] = bhCheckL2Wall_0x14f760; // 0x1501bc - g_ps2RecompiledFunctionTable[82030] = bhCheckL2Wall_0x14f760; // 0x1501c0 - g_ps2RecompiledFunctionTable[82031] = bhCheckL2Wall_0x14f760; // 0x1501c4 - g_ps2RecompiledFunctionTable[82032] = bhCheckL2Wall_0x14f760; // 0x1501c8 - g_ps2RecompiledFunctionTable[82033] = bhCheckL2Wall_0x14f760; // 0x1501cc - g_ps2RecompiledFunctionTable[82034] = bhCheckL2Wall_0x14f760; // 0x1501d0 - g_ps2RecompiledFunctionTable[82035] = bhCheckL2Wall_0x14f760; // 0x1501d4 - g_ps2RecompiledFunctionTable[82036] = bhCheckL2Wall_0x14f760; // 0x1501d8 - g_ps2RecompiledFunctionTable[82037] = bhCheckL2Wall_0x14f760; // 0x1501dc - g_ps2RecompiledFunctionTable[82038] = bhCheckL2Wall_0x14f760; // 0x1501e0 - g_ps2RecompiledFunctionTable[82039] = bhCheckL2Wall_0x14f760; // 0x1501e4 - g_ps2RecompiledFunctionTable[82040] = bhCheckL2Wall_0x14f760; // 0x1501e8 - g_ps2RecompiledFunctionTable[82041] = bhCheckL2Wall_0x14f760; // 0x1501ec - g_ps2RecompiledFunctionTable[82042] = bhCheckL2Wall_0x14f760; // 0x1501f0 - g_ps2RecompiledFunctionTable[82043] = bhCheckL2Wall_0x14f760; // 0x1501f4 - g_ps2RecompiledFunctionTable[82044] = bhCheckL2Wall_0x14f760; // 0x1501f8 - g_ps2RecompiledFunctionTable[82045] = bhCheckL2Wall_0x14f760; // 0x1501fc - g_ps2RecompiledFunctionTable[82046] = bhCheckL2Wall_0x14f760; // 0x150200 - g_ps2RecompiledFunctionTable[82047] = bhCheckL2Wall_0x14f760; // 0x150204 - g_ps2RecompiledFunctionTable[82048] = bhCheckL2Wall_0x14f760; // 0x150208 - g_ps2RecompiledFunctionTable[82049] = bhCheckL2Wall_0x14f760; // 0x15020c - g_ps2RecompiledFunctionTable[82050] = bhCheckL2Wall_0x14f760; // 0x150210 - g_ps2RecompiledFunctionTable[82051] = bhCheckL2Wall_0x14f760; // 0x150214 - g_ps2RecompiledFunctionTable[82052] = bhCheckL2Wall_0x14f760; // 0x150218 - g_ps2RecompiledFunctionTable[82053] = bhCheckL2Wall_0x14f760; // 0x15021c - g_ps2RecompiledFunctionTable[82054] = bhCheckL2Wall_0x14f760; // 0x150220 - g_ps2RecompiledFunctionTable[82055] = bhCheckL2Wall_0x14f760; // 0x150224 - g_ps2RecompiledFunctionTable[82056] = bhCheckL2Wall_0x14f760; // 0x150228 - g_ps2RecompiledFunctionTable[82057] = bhCheckL2Wall_0x14f760; // 0x15022c - g_ps2RecompiledFunctionTable[82058] = bhCheckL2Wall_0x14f760; // 0x150230 - g_ps2RecompiledFunctionTable[82059] = bhCheckL2Wall_0x14f760; // 0x150234 - g_ps2RecompiledFunctionTable[82060] = bhCheckL2Wall_0x14f760; // 0x150238 - g_ps2RecompiledFunctionTable[82061] = bhCheckL2Wall_0x14f760; // 0x15023c - g_ps2RecompiledFunctionTable[82062] = bhCheckL2Wall_0x14f760; // 0x150240 - g_ps2RecompiledFunctionTable[82063] = bhCheckL2Wall_0x14f760; // 0x150244 - g_ps2RecompiledFunctionTable[82064] = bhCheckL2Wall_0x14f760; // 0x150248 - g_ps2RecompiledFunctionTable[82065] = bhCheckL2Wall_0x14f760; // 0x15024c - g_ps2RecompiledFunctionTable[82066] = bhCheckL2Wall_0x14f760; // 0x150250 - g_ps2RecompiledFunctionTable[82067] = bhCheckL2Wall_0x14f760; // 0x150254 - g_ps2RecompiledFunctionTable[82068] = bhCheckL2Wall_0x14f760; // 0x150258 - g_ps2RecompiledFunctionTable[82069] = bhCheckL2Wall_0x14f760; // 0x15025c - g_ps2RecompiledFunctionTable[82070] = bhCheckL2Wall_0x14f760; // 0x150260 - g_ps2RecompiledFunctionTable[82071] = bhCheckL2Wall_0x14f760; // 0x150264 - g_ps2RecompiledFunctionTable[82072] = bhCheckL2Wall_0x14f760; // 0x150268 - g_ps2RecompiledFunctionTable[82073] = bhCheckL2Wall_0x14f760; // 0x15026c - g_ps2RecompiledFunctionTable[82074] = bhCheckL2Wall_0x14f760; // 0x150270 - g_ps2RecompiledFunctionTable[82075] = bhCheckL2Wall_0x14f760; // 0x150274 - g_ps2RecompiledFunctionTable[82076] = bhCheckL2Wall_0x14f760; // 0x150278 - g_ps2RecompiledFunctionTable[82077] = bhCheckL2Wall_0x14f760; // 0x15027c - g_ps2RecompiledFunctionTable[82078] = bhCheckL2Wall_0x14f760; // 0x150280 - g_ps2RecompiledFunctionTable[82079] = bhCheckL2Wall_0x14f760; // 0x150284 - g_ps2RecompiledFunctionTable[82080] = bhCheckL2Wall_0x14f760; // 0x150288 - g_ps2RecompiledFunctionTable[82081] = bhCheckL2Wall_0x14f760; // 0x15028c - g_ps2RecompiledFunctionTable[82082] = bhCheckL2Wall_0x14f760; // 0x150290 - g_ps2RecompiledFunctionTable[82083] = bhCheckL2Wall_0x14f760; // 0x150294 - g_ps2RecompiledFunctionTable[82084] = bhCheckL2Wall_0x14f760; // 0x150298 - g_ps2RecompiledFunctionTable[82085] = bhCheckL2Wall_0x14f760; // 0x15029c - g_ps2RecompiledFunctionTable[82086] = bhCheckL2Wall_0x14f760; // 0x1502a0 - g_ps2RecompiledFunctionTable[82087] = bhCheckL2Wall_0x14f760; // 0x1502a4 - g_ps2RecompiledFunctionTable[82088] = bhCheckL2Wall_0x14f760; // 0x1502a8 - g_ps2RecompiledFunctionTable[82089] = bhCheckL2Wall_0x14f760; // 0x1502ac - g_ps2RecompiledFunctionTable[82090] = bhCheckL2Wall_0x14f760; // 0x1502b0 - g_ps2RecompiledFunctionTable[82091] = bhCheckL2Wall_0x14f760; // 0x1502b4 - g_ps2RecompiledFunctionTable[82092] = bhCheckL2Wall_0x14f760; // 0x1502b8 - g_ps2RecompiledFunctionTable[82093] = bhCheckL2Wall_0x14f760; // 0x1502bc - g_ps2RecompiledFunctionTable[82094] = bhCheckL2Wall_0x14f760; // 0x1502c0 - g_ps2RecompiledFunctionTable[82095] = bhCheckL2Wall_0x14f760; // 0x1502c4 - g_ps2RecompiledFunctionTable[82096] = bhCheckL2Wall_0x14f760; // 0x1502c8 - g_ps2RecompiledFunctionTable[82097] = bhCheckL2Wall_0x14f760; // 0x1502cc - g_ps2RecompiledFunctionTable[82098] = bhCheckL2Wall_0x14f760; // 0x1502d0 - g_ps2RecompiledFunctionTable[82099] = bhCheckL2Wall_0x14f760; // 0x1502d4 - g_ps2RecompiledFunctionTable[82100] = bhCheckL2Wall_0x14f760; // 0x1502d8 - g_ps2RecompiledFunctionTable[82101] = bhCheckL2Wall_0x14f760; // 0x1502dc - g_ps2RecompiledFunctionTable[82102] = bhCheckL2Wall_0x14f760; // 0x1502e0 - g_ps2RecompiledFunctionTable[82103] = bhCheckL2Wall_0x14f760; // 0x1502e4 - g_ps2RecompiledFunctionTable[82104] = bhCheckL2Wall_0x14f760; // 0x1502e8 - g_ps2RecompiledFunctionTable[82105] = bhCheckL2Wall_0x14f760; // 0x1502ec - g_ps2RecompiledFunctionTable[82106] = bhCheckL2Wall_0x14f760; // 0x1502f0 - g_ps2RecompiledFunctionTable[82107] = bhCheckL2Wall_0x14f760; // 0x1502f4 - g_ps2RecompiledFunctionTable[82108] = bhCheckL2Wall_0x14f760; // 0x1502f8 - g_ps2RecompiledFunctionTable[82109] = bhCheckL2Wall_0x14f760; // 0x1502fc - g_ps2RecompiledFunctionTable[82110] = bhCheckL2Wall_0x14f760; // 0x150300 - g_ps2RecompiledFunctionTable[82111] = bhCheckL2Wall_0x14f760; // 0x150304 - g_ps2RecompiledFunctionTable[82112] = bhCheckL2Wall_0x14f760; // 0x150308 - g_ps2RecompiledFunctionTable[82113] = bhCheckL2Wall_0x14f760; // 0x15030c - g_ps2RecompiledFunctionTable[82114] = bhCheckL2Wall_0x14f760; // 0x150310 - g_ps2RecompiledFunctionTable[82115] = bhCheckL2Wall_0x14f760; // 0x150314 - g_ps2RecompiledFunctionTable[82116] = bhCheckL2Wall_0x14f760; // 0x150318 - g_ps2RecompiledFunctionTable[82117] = bhCheckL2Wall_0x14f760; // 0x15031c - g_ps2RecompiledFunctionTable[82118] = bhCheckL2Wall_0x14f760; // 0x150320 - g_ps2RecompiledFunctionTable[82119] = bhCheckL2Wall_0x14f760; // 0x150324 - g_ps2RecompiledFunctionTable[82120] = bhCheckL2Wall_0x14f760; // 0x150328 - g_ps2RecompiledFunctionTable[82121] = bhCheckL2Wall_0x14f760; // 0x15032c - g_ps2RecompiledFunctionTable[82122] = bhCheckL2Wall_0x14f760; // 0x150330 - g_ps2RecompiledFunctionTable[82123] = bhCheckL2Wall_0x14f760; // 0x150334 - g_ps2RecompiledFunctionTable[82124] = bhCheckL2Wall_0x14f760; // 0x150338 - g_ps2RecompiledFunctionTable[82125] = bhCheckL2Wall_0x14f760; // 0x15033c - g_ps2RecompiledFunctionTable[82126] = bhCheckL2Wall_0x14f760; // 0x150340 - g_ps2RecompiledFunctionTable[82127] = bhCheckL2Wall_0x14f760; // 0x150344 - g_ps2RecompiledFunctionTable[82128] = bhCheckL2Wall_0x14f760; // 0x150348 - g_ps2RecompiledFunctionTable[82129] = bhCheckL2Wall_0x14f760; // 0x15034c - g_ps2RecompiledFunctionTable[82130] = bhCheckL2Wall_0x14f760; // 0x150350 - g_ps2RecompiledFunctionTable[82131] = bhCheckL2Wall_0x14f760; // 0x150354 - g_ps2RecompiledFunctionTable[82132] = bhCheckL2Wall_0x14f760; // 0x150358 - g_ps2RecompiledFunctionTable[82133] = bhCheckL2Wall_0x14f760; // 0x15035c - g_ps2RecompiledFunctionTable[82134] = bhCheckL2Wall_0x14f760; // 0x150360 - g_ps2RecompiledFunctionTable[82135] = bhCheckL2Wall_0x14f760; // 0x150364 - g_ps2RecompiledFunctionTable[82136] = bhCheckL2Wall_0x14f760; // 0x150368 - g_ps2RecompiledFunctionTable[82137] = bhCheckL2Wall_0x14f760; // 0x15036c - g_ps2RecompiledFunctionTable[82138] = bhCheckL2Wall_0x14f760; // 0x150370 - g_ps2RecompiledFunctionTable[82139] = bhCheckL2Wall_0x14f760; // 0x150374 - g_ps2RecompiledFunctionTable[82140] = bhCheckL2Wall_0x14f760; // 0x150378 - g_ps2RecompiledFunctionTable[82141] = bhCheckL2Wall_0x14f760; // 0x15037c - g_ps2RecompiledFunctionTable[82142] = bhCheckL2Wall_0x14f760; // 0x150380 - g_ps2RecompiledFunctionTable[82143] = bhCheckL2Wall_0x14f760; // 0x150384 - g_ps2RecompiledFunctionTable[82144] = bhCheckL2Wall_0x14f760; // 0x150388 - g_ps2RecompiledFunctionTable[82145] = bhCheckL2Wall_0x14f760; // 0x15038c - g_ps2RecompiledFunctionTable[82146] = bhCheckL2Wall_0x14f760; // 0x150390 - g_ps2RecompiledFunctionTable[82147] = bhCheckL2Wall_0x14f760; // 0x150394 - g_ps2RecompiledFunctionTable[82148] = bhCheckL2Wall_0x14f760; // 0x150398 - g_ps2RecompiledFunctionTable[82149] = bhCheckL2Wall_0x14f760; // 0x15039c - g_ps2RecompiledFunctionTable[82150] = bhCheckL2Wall_0x14f760; // 0x1503a0 - g_ps2RecompiledFunctionTable[82151] = bhCheckL2Wall_0x14f760; // 0x1503a4 - g_ps2RecompiledFunctionTable[82152] = bhCheckL2Wall_0x14f760; // 0x1503a8 - g_ps2RecompiledFunctionTable[82153] = bhCheckL2Wall_0x14f760; // 0x1503ac - g_ps2RecompiledFunctionTable[82154] = bhCheckL2Wall_0x14f760; // 0x1503b0 - g_ps2RecompiledFunctionTable[82155] = bhCheckL2Wall_0x14f760; // 0x1503b4 - g_ps2RecompiledFunctionTable[82156] = bhCheckL2Wall_0x14f760; // 0x1503b8 - g_ps2RecompiledFunctionTable[82157] = bhCheckL2Wall_0x14f760; // 0x1503bc - g_ps2RecompiledFunctionTable[82158] = bhCheckL2Wall_0x14f760; // 0x1503c0 - g_ps2RecompiledFunctionTable[82159] = bhCheckL2Wall_0x14f760; // 0x1503c4 - g_ps2RecompiledFunctionTable[82160] = bhCheckL2Wall_0x14f760; // 0x1503c8 - g_ps2RecompiledFunctionTable[82161] = bhCheckL2Wall_0x14f760; // 0x1503cc - g_ps2RecompiledFunctionTable[82162] = bhCheckL2Wall_0x14f760; // 0x1503d0 - g_ps2RecompiledFunctionTable[82163] = bhCheckL2Wall_0x14f760; // 0x1503d4 - g_ps2RecompiledFunctionTable[82164] = bhCheckL2Wall_0x14f760; // 0x1503d8 - g_ps2RecompiledFunctionTable[82165] = bhCheckL2Wall_0x14f760; // 0x1503dc - g_ps2RecompiledFunctionTable[82166] = bhCheckL2Wall_0x14f760; // 0x1503e0 - g_ps2RecompiledFunctionTable[82167] = bhCheckL2Wall_0x14f760; // 0x1503e4 - g_ps2RecompiledFunctionTable[82168] = bhCheckL2Wall_0x14f760; // 0x1503e8 - g_ps2RecompiledFunctionTable[82169] = bhCheckL2Wall_0x14f760; // 0x1503ec - g_ps2RecompiledFunctionTable[82170] = bhCheckL2Wall_0x14f760; // 0x1503f0 - g_ps2RecompiledFunctionTable[82171] = bhCheckL2Wall_0x14f760; // 0x1503f4 - g_ps2RecompiledFunctionTable[82172] = bhCheckL2Wall_0x14f760; // 0x1503f8 - g_ps2RecompiledFunctionTable[82173] = bhCheckL2Wall_0x14f760; // 0x1503fc - g_ps2RecompiledFunctionTable[82174] = bhCheckL2Wall_0x14f760; // 0x150400 - g_ps2RecompiledFunctionTable[82175] = bhCheckL2Wall_0x14f760; // 0x150404 - g_ps2RecompiledFunctionTable[82176] = bhCheckL2Wall_0x14f760; // 0x150408 - g_ps2RecompiledFunctionTable[82177] = bhCheckL2Wall_0x14f760; // 0x15040c - g_ps2RecompiledFunctionTable[82178] = bhCheckL2Wall_0x14f760; // 0x150410 - g_ps2RecompiledFunctionTable[82179] = bhCheckL2Wall_0x14f760; // 0x150414 - g_ps2RecompiledFunctionTable[82180] = bhCheckL2Wall_0x14f760; // 0x150418 - g_ps2RecompiledFunctionTable[82181] = bhCheckL2Wall_0x14f760; // 0x15041c - g_ps2RecompiledFunctionTable[82182] = bhCheckL2Wall_0x14f760; // 0x150420 - g_ps2RecompiledFunctionTable[82183] = bhCheckL2Wall_0x14f760; // 0x150424 - g_ps2RecompiledFunctionTable[82184] = bhCheckL2Wall_0x14f760; // 0x150428 - g_ps2RecompiledFunctionTable[82185] = bhCheckL2Wall_0x14f760; // 0x15042c - g_ps2RecompiledFunctionTable[82186] = bhCheckL2Wall_0x14f760; // 0x150430 - g_ps2RecompiledFunctionTable[82187] = bhCheckL2Wall_0x14f760; // 0x150434 - g_ps2RecompiledFunctionTable[82188] = bhCheckL2Wall_0x14f760; // 0x150438 - g_ps2RecompiledFunctionTable[82189] = bhCheckL2Wall_0x14f760; // 0x15043c - g_ps2RecompiledFunctionTable[82190] = bhCheckL2Wall_0x14f760; // 0x150440 - g_ps2RecompiledFunctionTable[82191] = bhCheckL2Wall_0x14f760; // 0x150444 - g_ps2RecompiledFunctionTable[82192] = bhCheckL2Wall_0x14f760; // 0x150448 - g_ps2RecompiledFunctionTable[82193] = bhCheckL2Wall_0x14f760; // 0x15044c - g_ps2RecompiledFunctionTable[82194] = bhCheckL2Wall_0x14f760; // 0x150450 - g_ps2RecompiledFunctionTable[82195] = bhCheckL2Wall_0x14f760; // 0x150454 - g_ps2RecompiledFunctionTable[82196] = bhCheckL2Wall_0x14f760; // 0x150458 - g_ps2RecompiledFunctionTable[82197] = bhCheckL2Wall_0x14f760; // 0x15045c - g_ps2RecompiledFunctionTable[82198] = bhCheckL2Wall_0x14f760; // 0x150460 - g_ps2RecompiledFunctionTable[82199] = bhCheckL2Wall_0x14f760; // 0x150464 - g_ps2RecompiledFunctionTable[82200] = bhCheckL2Wall_0x14f760; // 0x150468 - g_ps2RecompiledFunctionTable[82201] = bhCheckL2Wall_0x14f760; // 0x15046c - g_ps2RecompiledFunctionTable[82202] = bhCheckL2Wall_0x14f760; // 0x150470 - g_ps2RecompiledFunctionTable[82203] = bhCheckL2Wall_0x14f760; // 0x150474 - g_ps2RecompiledFunctionTable[82204] = bhCheckL2Wall_0x14f760; // 0x150478 - g_ps2RecompiledFunctionTable[82205] = bhCheckL2Wall_0x14f760; // 0x15047c - g_ps2RecompiledFunctionTable[82206] = bhCheckL2Wall_0x14f760; // 0x150480 - g_ps2RecompiledFunctionTable[82207] = bhCheckL2Wall_0x14f760; // 0x150484 - g_ps2RecompiledFunctionTable[82208] = bhCheckL2Wall_0x14f760; // 0x150488 - g_ps2RecompiledFunctionTable[82209] = bhCheckL2Wall_0x14f760; // 0x15048c - g_ps2RecompiledFunctionTable[82210] = bhCheckL2Wall_0x14f760; // 0x150490 - g_ps2RecompiledFunctionTable[82211] = bhCheckL2Wall_0x14f760; // 0x150494 - g_ps2RecompiledFunctionTable[82212] = bhCheckL2Wall_0x14f760; // 0x150498 - g_ps2RecompiledFunctionTable[82213] = bhCheckL2Wall_0x14f760; // 0x15049c - g_ps2RecompiledFunctionTable[82214] = bhCheckL2Wall_0x14f760; // 0x1504a0 - g_ps2RecompiledFunctionTable[82215] = bhCheckL2Wall_0x14f760; // 0x1504a4 - g_ps2RecompiledFunctionTable[82216] = bhCheckL2Wall_0x14f760; // 0x1504a8 - g_ps2RecompiledFunctionTable[82217] = bhCheckL2Wall_0x14f760; // 0x1504ac - g_ps2RecompiledFunctionTable[82218] = bhCheckL2Wall_0x14f760; // 0x1504b0 - g_ps2RecompiledFunctionTable[82219] = bhCheckL2Wall_0x14f760; // 0x1504b4 - g_ps2RecompiledFunctionTable[82220] = bhCheckL2Wall_0x14f760; // 0x1504b8 - g_ps2RecompiledFunctionTable[82221] = bhCheckL2Wall_0x14f760; // 0x1504bc - g_ps2RecompiledFunctionTable[82222] = bhCheckL2Wall_0x14f760; // 0x1504c0 - g_ps2RecompiledFunctionTable[82223] = bhCheckL2Wall_0x14f760; // 0x1504c4 - g_ps2RecompiledFunctionTable[82224] = bhCheckL2Wall_0x14f760; // 0x1504c8 - g_ps2RecompiledFunctionTable[82225] = bhCheckL2Wall_0x14f760; // 0x1504cc - g_ps2RecompiledFunctionTable[82226] = bhCheckL2Wall_0x14f760; // 0x1504d0 - g_ps2RecompiledFunctionTable[82227] = bhCheckL2Wall_0x14f760; // 0x1504d4 - g_ps2RecompiledFunctionTable[82228] = bhCheckL2Wall_0x14f760; // 0x1504d8 - g_ps2RecompiledFunctionTable[82229] = bhCheckL2Wall_0x14f760; // 0x1504dc - g_ps2RecompiledFunctionTable[82230] = bhCheckL2Wall_0x14f760; // 0x1504e0 - g_ps2RecompiledFunctionTable[82231] = bhCheckL2Wall_0x14f760; // 0x1504e4 - g_ps2RecompiledFunctionTable[82232] = bhCheckL2Wall_0x14f760; // 0x1504e8 - g_ps2RecompiledFunctionTable[82233] = bhCheckL2Wall_0x14f760; // 0x1504ec - g_ps2RecompiledFunctionTable[82234] = bhCheckL2Wall_0x14f760; // 0x1504f0 - g_ps2RecompiledFunctionTable[82235] = bhCheckL2Wall_0x14f760; // 0x1504f4 - g_ps2RecompiledFunctionTable[82236] = bhCheckL2Wall_0x14f760; // 0x1504f8 - g_ps2RecompiledFunctionTable[82237] = bhCheckL2Wall_0x14f760; // 0x1504fc - g_ps2RecompiledFunctionTable[82238] = bhCheckL2Wall_0x14f760; // 0x150500 - g_ps2RecompiledFunctionTable[82239] = bhCheckL2Wall_0x14f760; // 0x150504 - g_ps2RecompiledFunctionTable[82240] = bhCheckL2Wall_0x14f760; // 0x150508 - g_ps2RecompiledFunctionTable[82241] = bhCheckL2Wall_0x14f760; // 0x15050c - g_ps2RecompiledFunctionTable[82242] = bhCheckL2Wall_0x14f760; // 0x150510 - g_ps2RecompiledFunctionTable[82243] = bhCheckL2Wall_0x14f760; // 0x150514 - g_ps2RecompiledFunctionTable[82244] = bhCheckL2Wall_0x14f760; // 0x150518 - g_ps2RecompiledFunctionTable[82245] = bhCheckL2Wall_0x14f760; // 0x15051c - g_ps2RecompiledFunctionTable[82246] = bhCheckL2Wall_0x14f760; // 0x150520 - g_ps2RecompiledFunctionTable[82247] = bhCheckL2Wall_0x14f760; // 0x150524 - g_ps2RecompiledFunctionTable[82248] = bhCheckL2Wall_0x14f760; // 0x150528 - g_ps2RecompiledFunctionTable[82249] = bhCheckL2Wall_0x14f760; // 0x15052c - g_ps2RecompiledFunctionTable[82250] = bhCheckL2Wall_0x14f760; // 0x150530 - g_ps2RecompiledFunctionTable[82251] = bhCheckL2Wall_0x14f760; // 0x150534 - g_ps2RecompiledFunctionTable[82252] = bhCheckL2Wall_0x14f760; // 0x150538 - g_ps2RecompiledFunctionTable[82253] = bhCheckL2Wall_0x14f760; // 0x15053c - g_ps2RecompiledFunctionTable[82254] = bhCheckL2Wall_0x14f760; // 0x150540 - g_ps2RecompiledFunctionTable[82255] = bhCheckL2Wall_0x14f760; // 0x150544 - g_ps2RecompiledFunctionTable[82256] = bhCheckL2Wall_0x14f760; // 0x150548 - g_ps2RecompiledFunctionTable[82257] = bhCheckL2Wall_0x14f760; // 0x15054c - g_ps2RecompiledFunctionTable[82258] = bhCheckL2Wall_0x14f760; // 0x150550 - g_ps2RecompiledFunctionTable[82259] = bhCheckL2Wall_0x14f760; // 0x150554 - g_ps2RecompiledFunctionTable[82260] = bhCheckL2Wall_0x14f760; // 0x150558 - g_ps2RecompiledFunctionTable[82261] = bhCheckL2Wall_0x14f760; // 0x15055c - g_ps2RecompiledFunctionTable[82262] = bhCheckL2Wall_0x14f760; // 0x150560 - g_ps2RecompiledFunctionTable[82263] = bhCheckL2Wall_0x14f760; // 0x150564 - g_ps2RecompiledFunctionTable[82264] = bhCheckL2Wall_0x14f760; // 0x150568 - g_ps2RecompiledFunctionTable[82265] = bhCheckL2Wall_0x14f760; // 0x15056c - g_ps2RecompiledFunctionTable[82266] = bhCheckL2Wall_0x14f760; // 0x150570 - g_ps2RecompiledFunctionTable[82267] = bhCheckL2Wall_0x14f760; // 0x150574 - g_ps2RecompiledFunctionTable[82268] = bhCheckL2Wall_0x14f760; // 0x150578 - g_ps2RecompiledFunctionTable[82269] = bhCheckL2Wall_0x14f760; // 0x15057c - g_ps2RecompiledFunctionTable[82270] = bhCheckL2Wall_0x14f760; // 0x150580 - g_ps2RecompiledFunctionTable[82271] = bhCheckL2Wall_0x14f760; // 0x150584 - g_ps2RecompiledFunctionTable[82272] = bhCheckL2Wall_0x14f760; // 0x150588 - g_ps2RecompiledFunctionTable[82273] = bhCheckL2Wall_0x14f760; // 0x15058c - g_ps2RecompiledFunctionTable[82274] = bhCheckL2Wall_0x14f760; // 0x150590 - g_ps2RecompiledFunctionTable[82275] = bhCheckL2Wall_0x14f760; // 0x150594 - g_ps2RecompiledFunctionTable[82276] = bhCheckL2Wall_0x14f760; // 0x150598 - g_ps2RecompiledFunctionTable[82277] = bhCheckL2Wall_0x14f760; // 0x15059c - g_ps2RecompiledFunctionTable[82278] = bhCheckL2Wall_0x14f760; // 0x1505a0 - g_ps2RecompiledFunctionTable[82279] = bhCheckL2Wall_0x14f760; // 0x1505a4 - g_ps2RecompiledFunctionTable[82280] = bhCheckL2Wall_0x14f760; // 0x1505a8 - g_ps2RecompiledFunctionTable[82281] = bhCheckL2Wall_0x14f760; // 0x1505ac - g_ps2RecompiledFunctionTable[82282] = bhCheckL2Wall_0x14f760; // 0x1505b0 - g_ps2RecompiledFunctionTable[82283] = bhCheckL2Wall_0x14f760; // 0x1505b4 - g_ps2RecompiledFunctionTable[82284] = bhCheckL2Wall_0x14f760; // 0x1505b8 - g_ps2RecompiledFunctionTable[82285] = bhCheckL2Wall_0x14f760; // 0x1505bc - g_ps2RecompiledFunctionTable[82286] = bhCheckL2Wall_0x14f760; // 0x1505c0 - g_ps2RecompiledFunctionTable[82287] = bhCheckL2Wall_0x14f760; // 0x1505c4 - g_ps2RecompiledFunctionTable[82288] = bhCheckL2Wall_0x14f760; // 0x1505c8 - g_ps2RecompiledFunctionTable[82289] = bhCheckL2Wall_0x14f760; // 0x1505cc - g_ps2RecompiledFunctionTable[82290] = bhCheckL2Wall_0x14f760; // 0x1505d0 - g_ps2RecompiledFunctionTable[82291] = bhCheckL2Wall_0x14f760; // 0x1505d4 - g_ps2RecompiledFunctionTable[82292] = bhCheckL2Wall_0x14f760; // 0x1505d8 - g_ps2RecompiledFunctionTable[82293] = bhCheckL2Wall_0x14f760; // 0x1505dc - g_ps2RecompiledFunctionTable[82294] = bhCheckL2Wall_0x14f760; // 0x1505e0 - g_ps2RecompiledFunctionTable[82295] = bhCheckL2Wall_0x14f760; // 0x1505e4 - g_ps2RecompiledFunctionTable[82296] = bhCheckL2Wall_0x14f760; // 0x1505e8 - g_ps2RecompiledFunctionTable[82297] = bhCheckL2Wall_0x14f760; // 0x1505ec - g_ps2RecompiledFunctionTable[82298] = bhCheckL2Wall_0x14f760; // 0x1505f0 - g_ps2RecompiledFunctionTable[82299] = bhCheckL2Wall_0x14f760; // 0x1505f4 - g_ps2RecompiledFunctionTable[82300] = bhCheckL2Wall_0x14f760; // 0x1505f8 - g_ps2RecompiledFunctionTable[82301] = bhCheckL2Wall_0x14f760; // 0x1505fc - g_ps2RecompiledFunctionTable[82302] = bhCheckL2Wall_0x14f760; // 0x150600 - g_ps2RecompiledFunctionTable[82303] = bhCheckL2Wall_0x14f760; // 0x150604 - g_ps2RecompiledFunctionTable[82304] = bhCheckL2Wall_0x14f760; // 0x150608 - g_ps2RecompiledFunctionTable[82305] = bhCheckL2Wall_0x14f760; // 0x15060c - g_ps2RecompiledFunctionTable[82306] = bhCheckL2Wall_0x14f760; // 0x150610 - g_ps2RecompiledFunctionTable[82307] = bhCheckL2Wall_0x14f760; // 0x150614 - g_ps2RecompiledFunctionTable[82308] = bhCheckL2Wall_0x14f760; // 0x150618 - g_ps2RecompiledFunctionTable[82309] = bhCheckL2Wall_0x14f760; // 0x15061c - g_ps2RecompiledFunctionTable[82310] = bhCheckL2Wall_0x14f760; // 0x150620 - g_ps2RecompiledFunctionTable[82311] = bhCheckL2Wall_0x14f760; // 0x150624 - g_ps2RecompiledFunctionTable[82312] = bhCheckL2Wall_0x14f760; // 0x150628 - g_ps2RecompiledFunctionTable[82313] = bhCheckL2Wall_0x14f760; // 0x15062c - g_ps2RecompiledFunctionTable[82314] = bhCheckL2Wall_0x14f760; // 0x150630 - g_ps2RecompiledFunctionTable[82315] = bhCheckL2Wall_0x14f760; // 0x150634 - g_ps2RecompiledFunctionTable[82316] = bhCheckL2Wall_0x14f760; // 0x150638 - g_ps2RecompiledFunctionTable[82317] = bhCheckL2Wall_0x14f760; // 0x15063c - g_ps2RecompiledFunctionTable[82318] = bhCheckL2Wall_0x14f760; // 0x150640 - g_ps2RecompiledFunctionTable[82319] = bhCheckL2Wall_0x14f760; // 0x150644 - g_ps2RecompiledFunctionTable[82320] = bhCheckL2Wall_0x14f760; // 0x150648 - g_ps2RecompiledFunctionTable[82321] = bhCheckL2Wall_0x14f760; // 0x15064c - g_ps2RecompiledFunctionTable[82322] = bhCheckL2Wall_0x14f760; // 0x150650 - g_ps2RecompiledFunctionTable[82323] = bhCheckL2Wall_0x14f760; // 0x150654 - g_ps2RecompiledFunctionTable[82324] = bhCheckL2Wall_0x14f760; // 0x150658 - g_ps2RecompiledFunctionTable[82325] = bhCheckL2Wall_0x14f760; // 0x15065c - g_ps2RecompiledFunctionTable[82326] = bhCheckL2Wall_0x14f760; // 0x150660 - g_ps2RecompiledFunctionTable[82327] = bhCheckL2Wall_0x14f760; // 0x150664 - g_ps2RecompiledFunctionTable[82328] = bhCheckL2Wall_0x14f760; // 0x150668 - g_ps2RecompiledFunctionTable[82329] = bhCheckL2Wall_0x14f760; // 0x15066c - g_ps2RecompiledFunctionTable[82330] = bhCheckL2Wall_0x14f760; // 0x150670 - g_ps2RecompiledFunctionTable[82331] = bhCheckL2Wall_0x14f760; // 0x150674 - g_ps2RecompiledFunctionTable[82332] = bhCheckL2Wall_0x14f760; // 0x150678 - g_ps2RecompiledFunctionTable[82333] = bhCheckL2Wall_0x14f760; // 0x15067c - g_ps2RecompiledFunctionTable[82334] = bhCheckL2Wall_0x14f760; // 0x150680 - g_ps2RecompiledFunctionTable[82335] = bhCheckL2Wall_0x14f760; // 0x150684 - g_ps2RecompiledFunctionTable[82336] = bhCheckL2Wall_0x14f760; // 0x150688 - g_ps2RecompiledFunctionTable[82337] = bhCheckL2Wall_0x14f760; // 0x15068c - g_ps2RecompiledFunctionTable[82338] = bhCheckL2Wall_0x14f760; // 0x150690 - g_ps2RecompiledFunctionTable[82339] = bhCheckL2Wall_0x14f760; // 0x150694 - g_ps2RecompiledFunctionTable[82340] = bhCheckL2Wall_0x14f760; // 0x150698 - g_ps2RecompiledFunctionTable[82341] = bhCheckL2Wall_0x14f760; // 0x15069c - g_ps2RecompiledFunctionTable[82342] = bhCheckL2Wall_0x14f760; // 0x1506a0 - g_ps2RecompiledFunctionTable[82343] = bhCheckL2Wall_0x14f760; // 0x1506a4 - g_ps2RecompiledFunctionTable[82344] = bhCheckL2Wall_0x14f760; // 0x1506a8 - g_ps2RecompiledFunctionTable[82345] = bhCheckL2Wall_0x14f760; // 0x1506ac - g_ps2RecompiledFunctionTable[82346] = bhCheckL2Wall_0x14f760; // 0x1506b0 - g_ps2RecompiledFunctionTable[82347] = bhCheckL2Wall_0x14f760; // 0x1506b4 - g_ps2RecompiledFunctionTable[82348] = bhCheckL2Wall_0x14f760; // 0x1506b8 - g_ps2RecompiledFunctionTable[82349] = bhCheckL2Wall_0x14f760; // 0x1506bc - g_ps2RecompiledFunctionTable[82350] = bhCheckL2Wall_0x14f760; // 0x1506c0 - g_ps2RecompiledFunctionTable[82351] = bhCheckL2Wall_0x14f760; // 0x1506c4 - g_ps2RecompiledFunctionTable[82352] = bhCheckL2Wall_0x14f760; // 0x1506c8 - g_ps2RecompiledFunctionTable[82353] = bhCheckL2Wall_0x14f760; // 0x1506cc - g_ps2RecompiledFunctionTable[82354] = bhCheckL2Wall_0x14f760; // 0x1506d0 - g_ps2RecompiledFunctionTable[82355] = bhCheckL2Wall_0x14f760; // 0x1506d4 - g_ps2RecompiledFunctionTable[82356] = bhCheckL2Wall_0x14f760; // 0x1506d8 - g_ps2RecompiledFunctionTable[82357] = bhCheckL2Wall_0x14f760; // 0x1506dc - g_ps2RecompiledFunctionTable[82358] = bhCheckL2Wall_0x14f760; // 0x1506e0 - g_ps2RecompiledFunctionTable[82359] = bhCheckL2Wall_0x14f760; // 0x1506e4 - g_ps2RecompiledFunctionTable[82360] = bhCheckL2Wall_0x14f760; // 0x1506e8 - g_ps2RecompiledFunctionTable[82361] = bhCheckL2Wall_0x14f760; // 0x1506ec - g_ps2RecompiledFunctionTable[82362] = bhCheckL2Wall_0x14f760; // 0x1506f0 - g_ps2RecompiledFunctionTable[82363] = bhCheckL2Wall_0x14f760; // 0x1506f4 - g_ps2RecompiledFunctionTable[82364] = bhCheckL2Wall_0x14f760; // 0x1506f8 - g_ps2RecompiledFunctionTable[82365] = bhCheckL2Wall_0x14f760; // 0x1506fc - g_ps2RecompiledFunctionTable[82366] = bhCheckL2Wall_0x14f760; // 0x150700 - g_ps2RecompiledFunctionTable[82367] = bhCheckL2Wall_0x14f760; // 0x150704 - g_ps2RecompiledFunctionTable[82368] = bhCheckL2Wall_0x14f760; // 0x150708 - g_ps2RecompiledFunctionTable[82369] = bhCheckL2Wall_0x14f760; // 0x15070c - g_ps2RecompiledFunctionTable[82370] = bhCheckL2Wall_0x14f760; // 0x150710 - g_ps2RecompiledFunctionTable[82371] = bhCheckL2Wall_0x14f760; // 0x150714 - g_ps2RecompiledFunctionTable[82372] = bhCheckL2Wall_0x14f760; // 0x150718 - g_ps2RecompiledFunctionTable[82373] = bhCheckL2Wall_0x14f760; // 0x15071c - g_ps2RecompiledFunctionTable[82374] = bhCheckL2Wall_0x14f760; // 0x150720 - g_ps2RecompiledFunctionTable[82375] = bhCheckL2Wall_0x14f760; // 0x150724 - g_ps2RecompiledFunctionTable[82376] = bhCheckL2Wall_0x14f760; // 0x150728 - g_ps2RecompiledFunctionTable[82377] = bhCheckL2Wall_0x14f760; // 0x15072c - g_ps2RecompiledFunctionTable[82378] = bhCheckL2Wall_0x14f760; // 0x150730 - g_ps2RecompiledFunctionTable[82379] = bhCheckL2Wall_0x14f760; // 0x150734 - g_ps2RecompiledFunctionTable[82380] = bhCheckL2Wall_0x14f760; // 0x150738 - g_ps2RecompiledFunctionTable[82381] = bhCheckL2Wall_0x14f760; // 0x15073c - g_ps2RecompiledFunctionTable[82382] = bhCheckL2Wall_0x14f760; // 0x150740 - g_ps2RecompiledFunctionTable[82383] = bhCheckL2Wall_0x14f760; // 0x150744 - g_ps2RecompiledFunctionTable[82384] = bhCheckL2Wall_0x14f760; // 0x150748 - g_ps2RecompiledFunctionTable[82385] = bhCheckL2Wall_0x14f760; // 0x15074c - g_ps2RecompiledFunctionTable[82386] = bhCheckL2Wall_0x14f760; // 0x150750 - g_ps2RecompiledFunctionTable[82387] = bhCheckL2Wall_0x14f760; // 0x150754 - g_ps2RecompiledFunctionTable[82388] = bhCheckL2Wall_0x14f760; // 0x150758 - g_ps2RecompiledFunctionTable[82389] = bhCheckL2Wall_0x14f760; // 0x15075c - g_ps2RecompiledFunctionTable[82390] = bhCheckL2Wall_0x14f760; // 0x150760 - g_ps2RecompiledFunctionTable[82391] = bhCheckL2Wall_0x14f760; // 0x150764 - g_ps2RecompiledFunctionTable[82392] = bhCheckL2Wall_0x14f760; // 0x150768 - g_ps2RecompiledFunctionTable[82393] = bhCheckL2Wall_0x14f760; // 0x15076c - g_ps2RecompiledFunctionTable[82394] = bhCheckL2Wall_0x14f760; // 0x150770 - g_ps2RecompiledFunctionTable[82395] = bhCheckL2Wall_0x14f760; // 0x150774 - g_ps2RecompiledFunctionTable[82396] = bhCheckL2Wall_0x14f760; // 0x150778 - g_ps2RecompiledFunctionTable[82397] = bhCheckL2Wall_0x14f760; // 0x15077c - g_ps2RecompiledFunctionTable[82398] = bhCheckL2Wall_0x14f760; // 0x150780 - g_ps2RecompiledFunctionTable[82399] = bhCheckL2Wall_0x14f760; // 0x150784 - g_ps2RecompiledFunctionTable[82400] = bhCheckL2Wall_0x14f760; // 0x150788 - g_ps2RecompiledFunctionTable[82401] = bhCheckL2Wall_0x14f760; // 0x15078c - g_ps2RecompiledFunctionTable[82402] = bhCheckL2Wall_0x14f760; // 0x150790 - g_ps2RecompiledFunctionTable[82403] = bhCheckL2Wall_0x14f760; // 0x150794 - g_ps2RecompiledFunctionTable[82404] = bhCheckL2Wall_0x14f760; // 0x150798 - g_ps2RecompiledFunctionTable[82405] = bhCheckL2Wall_0x14f760; // 0x15079c - g_ps2RecompiledFunctionTable[82406] = bhCheckL2Wall_0x14f760; // 0x1507a0 - g_ps2RecompiledFunctionTable[82407] = bhCheckL2Wall_0x14f760; // 0x1507a4 - g_ps2RecompiledFunctionTable[82408] = bhCheckL2Wall_0x14f760; // 0x1507a8 - g_ps2RecompiledFunctionTable[82409] = bhCheckL2Wall_0x14f760; // 0x1507ac - g_ps2RecompiledFunctionTable[82410] = bhCheckL2Wall_0x14f760; // 0x1507b0 - g_ps2RecompiledFunctionTable[82411] = bhCheckL2Wall_0x14f760; // 0x1507b4 - g_ps2RecompiledFunctionTable[82412] = bhCheckL2Wall_0x14f760; // 0x1507b8 - g_ps2RecompiledFunctionTable[82413] = bhCheckL2Wall_0x14f760; // 0x1507bc - g_ps2RecompiledFunctionTable[82414] = bhCheckL2Wall_0x14f760; // 0x1507c0 - g_ps2RecompiledFunctionTable[82415] = bhCheckL2Wall_0x14f760; // 0x1507c4 - g_ps2RecompiledFunctionTable[82416] = bhCheckL2Wall_0x14f760; // 0x1507c8 - g_ps2RecompiledFunctionTable[82417] = bhCheckL2Wall_0x14f760; // 0x1507cc - g_ps2RecompiledFunctionTable[82418] = bhCheckL2Wall_0x14f760; // 0x1507d0 - g_ps2RecompiledFunctionTable[82419] = bhCheckL2Wall_0x14f760; // 0x1507d4 - g_ps2RecompiledFunctionTable[82420] = bhCheckL2Wall_0x14f760; // 0x1507d8 - g_ps2RecompiledFunctionTable[82421] = bhCheckL2Wall_0x14f760; // 0x1507dc - g_ps2RecompiledFunctionTable[82422] = bhCheckL2Wall_0x14f760; // 0x1507e0 - g_ps2RecompiledFunctionTable[82423] = bhCheckL2Wall_0x14f760; // 0x1507e4 - g_ps2RecompiledFunctionTable[82424] = bhCheckL2Wall_0x14f760; // 0x1507e8 - g_ps2RecompiledFunctionTable[82425] = bhCheckL2Wall_0x14f760; // 0x1507ec - g_ps2RecompiledFunctionTable[82426] = bhCheckL2Wall_0x14f760; // 0x1507f0 - g_ps2RecompiledFunctionTable[82427] = bhCheckL2Wall_0x14f760; // 0x1507f4 - g_ps2RecompiledFunctionTable[82428] = bhCheckL2Wall_0x14f760; // 0x1507f8 - g_ps2RecompiledFunctionTable[82429] = bhCheckL2Wall_0x14f760; // 0x1507fc - g_ps2RecompiledFunctionTable[82430] = bhCheckL2Wall_0x14f760; // 0x150800 - g_ps2RecompiledFunctionTable[82431] = bhCheckL2Wall_0x14f760; // 0x150804 - g_ps2RecompiledFunctionTable[82432] = bhCheckL2Wall_0x14f760; // 0x150808 - g_ps2RecompiledFunctionTable[82433] = bhCheckL2Wall_0x14f760; // 0x15080c - g_ps2RecompiledFunctionTable[82434] = bhCheckL2Wall_0x14f760; // 0x150810 - g_ps2RecompiledFunctionTable[82435] = bhCheckL2Wall_0x14f760; // 0x150814 - g_ps2RecompiledFunctionTable[82436] = bhCheckL2Wall_0x14f760; // 0x150818 - g_ps2RecompiledFunctionTable[82437] = bhCheckL2Wall_0x14f760; // 0x15081c - g_ps2RecompiledFunctionTable[82438] = bhCheckL2Wall_0x14f760; // 0x150820 - g_ps2RecompiledFunctionTable[82439] = bhCheckL2Wall_0x14f760; // 0x150824 - g_ps2RecompiledFunctionTable[82440] = bhCheckL2Wall_0x14f760; // 0x150828 - g_ps2RecompiledFunctionTable[82441] = bhCheckL2Wall_0x14f760; // 0x15082c - g_ps2RecompiledFunctionTable[82442] = bhCheckL2Wall_0x14f760; // 0x150830 - g_ps2RecompiledFunctionTable[82443] = bhCheckL2Wall_0x14f760; // 0x150834 - g_ps2RecompiledFunctionTable[82444] = bhCheckL2Wall_0x14f760; // 0x150838 - g_ps2RecompiledFunctionTable[82445] = bhCheckL2Wall_0x14f760; // 0x15083c - g_ps2RecompiledFunctionTable[82446] = bhCheckL2Wall_0x14f760; // 0x150840 - g_ps2RecompiledFunctionTable[82447] = bhCheckL2Wall_0x14f760; // 0x150844 - g_ps2RecompiledFunctionTable[82448] = bhCheckL2Wall_0x14f760; // 0x150848 - g_ps2RecompiledFunctionTable[82449] = bhCheckL2Wall_0x14f760; // 0x15084c - g_ps2RecompiledFunctionTable[82450] = bhCheckL2Wall_0x14f760; // 0x150850 - g_ps2RecompiledFunctionTable[82451] = bhCheckL2Wall_0x14f760; // 0x150854 - g_ps2RecompiledFunctionTable[82452] = bhCheckL2Wall_0x14f760; // 0x150858 - g_ps2RecompiledFunctionTable[82453] = bhCheckL2Wall_0x14f760; // 0x15085c - g_ps2RecompiledFunctionTable[82454] = bhCheckL2Wall_0x14f760; // 0x150860 - g_ps2RecompiledFunctionTable[82455] = bhCheckL2Wall_0x14f760; // 0x150864 - g_ps2RecompiledFunctionTable[82456] = bhCheckL2Wall_0x14f760; // 0x150868 - g_ps2RecompiledFunctionTable[82457] = bhCheckL2Wall_0x14f760; // 0x15086c - g_ps2RecompiledFunctionTable[82458] = bhCheckL2Wall_0x14f760; // 0x150870 - g_ps2RecompiledFunctionTable[82459] = bhCheckL2Wall_0x14f760; // 0x150874 - g_ps2RecompiledFunctionTable[82460] = bhCheckL2Wall_0x14f760; // 0x150878 - g_ps2RecompiledFunctionTable[82461] = bhCheckL2Wall_0x14f760; // 0x15087c - g_ps2RecompiledFunctionTable[82462] = bhCheckL2Wall_0x14f760; // 0x150880 - g_ps2RecompiledFunctionTable[82463] = bhCheckL2Wall_0x14f760; // 0x150884 - g_ps2RecompiledFunctionTable[82464] = bhCheckL2Wall_0x14f760; // 0x150888 - g_ps2RecompiledFunctionTable[82465] = bhCheckL2Wall_0x14f760; // 0x15088c - g_ps2RecompiledFunctionTable[82466] = bhCheckL2Wall_0x14f760; // 0x150890 - g_ps2RecompiledFunctionTable[82467] = bhCheckL2Wall_0x14f760; // 0x150894 - g_ps2RecompiledFunctionTable[82468] = bhCheckL2Wall_0x14f760; // 0x150898 - g_ps2RecompiledFunctionTable[82469] = bhCheckL2Wall_0x14f760; // 0x15089c - g_ps2RecompiledFunctionTable[82470] = bhCheckL2Wall_0x14f760; // 0x1508a0 - g_ps2RecompiledFunctionTable[82471] = bhCheckL2Wall_0x14f760; // 0x1508a4 - g_ps2RecompiledFunctionTable[82472] = bhCheckL2Wall_0x14f760; // 0x1508a8 - g_ps2RecompiledFunctionTable[82473] = bhCheckL2Wall_0x14f760; // 0x1508ac - g_ps2RecompiledFunctionTable[82474] = bhCheckL2Wall_0x14f760; // 0x1508b0 - g_ps2RecompiledFunctionTable[82475] = bhCheckL2Wall_0x14f760; // 0x1508b4 - g_ps2RecompiledFunctionTable[82476] = bhCheckL2Wall_0x14f760; // 0x1508b8 - g_ps2RecompiledFunctionTable[82477] = bhCheckL2Wall_0x14f760; // 0x1508bc - g_ps2RecompiledFunctionTable[82478] = bhCheckL2Wall_0x14f760; // 0x1508c0 - g_ps2RecompiledFunctionTable[82479] = bhCheckL2Wall_0x14f760; // 0x1508c4 - g_ps2RecompiledFunctionTable[82480] = bhCheckL2Wall_0x14f760; // 0x1508c8 - g_ps2RecompiledFunctionTable[82481] = bhCheckL2Wall_0x14f760; // 0x1508cc - g_ps2RecompiledFunctionTable[82482] = bhCheckL2Wall_0x14f760; // 0x1508d0 - g_ps2RecompiledFunctionTable[82483] = bhCheckL2Wall_0x14f760; // 0x1508d4 - g_ps2RecompiledFunctionTable[82484] = bhCheckL2Wall_0x14f760; // 0x1508d8 - g_ps2RecompiledFunctionTable[82485] = bhCheckL2Wall_0x14f760; // 0x1508dc - g_ps2RecompiledFunctionTable[82486] = bhCheckL2Wall_0x14f760; // 0x1508e0 - g_ps2RecompiledFunctionTable[82487] = bhCheckL2Wall_0x14f760; // 0x1508e4 - g_ps2RecompiledFunctionTable[82488] = bhCheckL2Wall_0x14f760; // 0x1508e8 - g_ps2RecompiledFunctionTable[82489] = bhCheckL2Wall_0x14f760; // 0x1508ec - g_ps2RecompiledFunctionTable[82490] = bhCheckL2Wall_0x14f760; // 0x1508f0 - g_ps2RecompiledFunctionTable[82491] = bhCheckL2Wall_0x14f760; // 0x1508f4 - g_ps2RecompiledFunctionTable[82492] = bhCheckL2Wall_0x14f760; // 0x1508f8 - g_ps2RecompiledFunctionTable[82493] = bhCheckL2Wall_0x14f760; // 0x1508fc - g_ps2RecompiledFunctionTable[82494] = bhCheckL2Wall_0x14f760; // 0x150900 - g_ps2RecompiledFunctionTable[82495] = bhCheckL2Wall_0x14f760; // 0x150904 - g_ps2RecompiledFunctionTable[82496] = bhCheckL2Wall_0x14f760; // 0x150908 - g_ps2RecompiledFunctionTable[82497] = bhCheckL2Wall_0x14f760; // 0x15090c - g_ps2RecompiledFunctionTable[82498] = bhCheckL2Wall_0x14f760; // 0x150910 - g_ps2RecompiledFunctionTable[82499] = bhCheckL2Wall_0x14f760; // 0x150914 - g_ps2RecompiledFunctionTable[82500] = bhCheckL2Wall_0x14f760; // 0x150918 - g_ps2RecompiledFunctionTable[82501] = bhCheckL2Wall_0x14f760; // 0x15091c - g_ps2RecompiledFunctionTable[82502] = bhCheckL2Wall_0x14f760; // 0x150920 - g_ps2RecompiledFunctionTable[82503] = bhCheckL2Wall_0x14f760; // 0x150924 - g_ps2RecompiledFunctionTable[82504] = bhCheckL2Wall_0x14f760; // 0x150928 - g_ps2RecompiledFunctionTable[82505] = bhCheckL2Wall_0x14f760; // 0x15092c - g_ps2RecompiledFunctionTable[82506] = bhCheckL2Wall_0x14f760; // 0x150930 - g_ps2RecompiledFunctionTable[82507] = bhCheckL2Wall_0x14f760; // 0x150934 - g_ps2RecompiledFunctionTable[82508] = bhCheckL2Wall_0x14f760; // 0x150938 - g_ps2RecompiledFunctionTable[82509] = bhCheckL2Wall_0x14f760; // 0x15093c - g_ps2RecompiledFunctionTable[82510] = bhCheckL2Wall_0x14f760; // 0x150940 - g_ps2RecompiledFunctionTable[82511] = bhCheckL2Wall_0x14f760; // 0x150944 - g_ps2RecompiledFunctionTable[82512] = bhCheckL2Wall_0x14f760; // 0x150948 - g_ps2RecompiledFunctionTable[82513] = bhCheckL2Wall_0x14f760; // 0x15094c - g_ps2RecompiledFunctionTable[82514] = bhCheckL2Wall_0x14f760; // 0x150950 - g_ps2RecompiledFunctionTable[82515] = bhCheckL2Wall_0x14f760; // 0x150954 - g_ps2RecompiledFunctionTable[82516] = bhCheckL2Wall_0x14f760; // 0x150958 - g_ps2RecompiledFunctionTable[82517] = bhCheckL2Wall_0x14f760; // 0x15095c - g_ps2RecompiledFunctionTable[82518] = bhCheckL2Wall_0x14f760; // 0x150960 - g_ps2RecompiledFunctionTable[82519] = bhCheckL2Wall_0x14f760; // 0x150964 - g_ps2RecompiledFunctionTable[82520] = bhCheckL2Wall_0x14f760; // 0x150968 - g_ps2RecompiledFunctionTable[82521] = bhCheckL2Wall_0x14f760; // 0x15096c - g_ps2RecompiledFunctionTable[82522] = bhCheckL2Wall_0x14f760; // 0x150970 - g_ps2RecompiledFunctionTable[82523] = bhCheckL2Wall_0x14f760; // 0x150974 - g_ps2RecompiledFunctionTable[82524] = bhCheckL2Wall_0x14f760; // 0x150978 - g_ps2RecompiledFunctionTable[82525] = bhCheckL2Wall_0x14f760; // 0x15097c - g_ps2RecompiledFunctionTable[82526] = bhCheckL2Wall_0x14f760; // 0x150980 - g_ps2RecompiledFunctionTable[82527] = bhCheckL2Wall_0x14f760; // 0x150984 - g_ps2RecompiledFunctionTable[82528] = bhCheckL2Wall_0x14f760; // 0x150988 - g_ps2RecompiledFunctionTable[82529] = bhCheckL2Wall_0x14f760; // 0x15098c - g_ps2RecompiledFunctionTable[82530] = bhCheckL2Wall_0x14f760; // 0x150990 - g_ps2RecompiledFunctionTable[82531] = bhCheckL2Wall_0x14f760; // 0x150994 - g_ps2RecompiledFunctionTable[82532] = bhCheckL2Wall_0x14f760; // 0x150998 - g_ps2RecompiledFunctionTable[82533] = bhCheckL2Wall_0x14f760; // 0x15099c - g_ps2RecompiledFunctionTable[82534] = bhCheckL2Wall_0x14f760; // 0x1509a0 - g_ps2RecompiledFunctionTable[82535] = bhCheckL2Wall_0x14f760; // 0x1509a4 - g_ps2RecompiledFunctionTable[82536] = bhCheckL2Wall_0x14f760; // 0x1509a8 - g_ps2RecompiledFunctionTable[82537] = bhCheckL2Wall_0x14f760; // 0x1509ac - g_ps2RecompiledFunctionTable[82538] = bhCheckL2Wall_0x14f760; // 0x1509b0 - g_ps2RecompiledFunctionTable[82539] = bhCheckL2Wall_0x14f760; // 0x1509b4 - g_ps2RecompiledFunctionTable[82540] = bhCheckL2Wall_0x14f760; // 0x1509b8 - g_ps2RecompiledFunctionTable[82541] = bhCheckL2Wall_0x14f760; // 0x1509bc - g_ps2RecompiledFunctionTable[82542] = bhCheckL2Wall_0x14f760; // 0x1509c0 - g_ps2RecompiledFunctionTable[82543] = bhCheckL2Wall_0x14f760; // 0x1509c4 - g_ps2RecompiledFunctionTable[82544] = bhCheckL2Wall_0x14f760; // 0x1509c8 - g_ps2RecompiledFunctionTable[82545] = bhCheckL2Wall_0x14f760; // 0x1509cc - g_ps2RecompiledFunctionTable[82546] = bhCheckL2Wall_0x14f760; // 0x1509d0 - g_ps2RecompiledFunctionTable[82547] = bhCheckL2Wall_0x14f760; // 0x1509d4 - g_ps2RecompiledFunctionTable[82548] = bhCheckL2Wall_0x14f760; // 0x1509d8 - g_ps2RecompiledFunctionTable[82549] = bhCheckL2Wall_0x14f760; // 0x1509dc - g_ps2RecompiledFunctionTable[82550] = bhCheckL2Wall_0x14f760; // 0x1509e0 - g_ps2RecompiledFunctionTable[82551] = bhCheckL2Wall_0x14f760; // 0x1509e4 - g_ps2RecompiledFunctionTable[82552] = bhCheckL2Wall_0x14f760; // 0x1509e8 - g_ps2RecompiledFunctionTable[82553] = bhCheckL2Wall_0x14f760; // 0x1509ec - g_ps2RecompiledFunctionTable[82554] = bhCheckL2Wall_0x14f760; // 0x1509f0 - g_ps2RecompiledFunctionTable[82555] = bhCheckL2Wall_0x14f760; // 0x1509f4 - g_ps2RecompiledFunctionTable[82556] = bhCheckL2Wall_0x14f760; // 0x1509f8 - g_ps2RecompiledFunctionTable[82557] = bhCheckL2Wall_0x14f760; // 0x1509fc - g_ps2RecompiledFunctionTable[82558] = bhCheckL2Wall_0x14f760; // 0x150a00 - g_ps2RecompiledFunctionTable[82559] = bhCheckL2Wall_0x14f760; // 0x150a04 - g_ps2RecompiledFunctionTable[82560] = bhCheckL2Wall_0x14f760; // 0x150a08 - g_ps2RecompiledFunctionTable[82561] = bhCheckL2Wall_0x14f760; // 0x150a0c - g_ps2RecompiledFunctionTable[82562] = bhCheckL2Wall_0x14f760; // 0x150a10 - g_ps2RecompiledFunctionTable[82563] = bhCheckL2Wall_0x14f760; // 0x150a14 - g_ps2RecompiledFunctionTable[82564] = bhCheckL2Wall_0x14f760; // 0x150a18 - g_ps2RecompiledFunctionTable[82565] = bhCheckL2Wall_0x14f760; // 0x150a1c - g_ps2RecompiledFunctionTable[82566] = bhCheckL2Wall_0x14f760; // 0x150a20 - g_ps2RecompiledFunctionTable[82567] = bhCheckL2Wall_0x14f760; // 0x150a24 - g_ps2RecompiledFunctionTable[82568] = bhCheckL2Wall_0x14f760; // 0x150a28 - g_ps2RecompiledFunctionTable[82569] = bhCheckL2Wall_0x14f760; // 0x150a2c - g_ps2RecompiledFunctionTable[82570] = bhCheckL2Wall_0x14f760; // 0x150a30 - g_ps2RecompiledFunctionTable[82571] = bhCheckL2Wall_0x14f760; // 0x150a34 - g_ps2RecompiledFunctionTable[82572] = bhCheckL2Wall_0x14f760; // 0x150a38 - g_ps2RecompiledFunctionTable[82573] = bhCheckL2Wall_0x14f760; // 0x150a3c - g_ps2RecompiledFunctionTable[82574] = bhCheckL2Wall_0x14f760; // 0x150a40 - g_ps2RecompiledFunctionTable[82575] = bhCheckL2Wall_0x14f760; // 0x150a44 - g_ps2RecompiledFunctionTable[82576] = bhCheckL2Wall_0x14f760; // 0x150a48 - g_ps2RecompiledFunctionTable[82577] = bhCheckL2Wall_0x14f760; // 0x150a4c - g_ps2RecompiledFunctionTable[82578] = bhCheckL2Wall_0x14f760; // 0x150a50 - g_ps2RecompiledFunctionTable[82579] = bhCheckL2Wall_0x14f760; // 0x150a54 - g_ps2RecompiledFunctionTable[82580] = bhCheckL2Wall_0x14f760; // 0x150a58 - g_ps2RecompiledFunctionTable[82581] = bhCheckL2Wall_0x14f760; // 0x150a5c - g_ps2RecompiledFunctionTable[82582] = bhCheckL2Wall_0x14f760; // 0x150a60 - g_ps2RecompiledFunctionTable[82583] = bhCheckL2Wall_0x14f760; // 0x150a64 - g_ps2RecompiledFunctionTable[82584] = bhCheckL2Wall_0x14f760; // 0x150a68 - g_ps2RecompiledFunctionTable[82585] = bhCheckL2Wall_0x14f760; // 0x150a6c - g_ps2RecompiledFunctionTable[82586] = bhCheckL2Wall_0x14f760; // 0x150a70 - g_ps2RecompiledFunctionTable[82587] = bhCheckL2Wall_0x14f760; // 0x150a74 - g_ps2RecompiledFunctionTable[82588] = bhCheckL2Wall_0x14f760; // 0x150a78 - g_ps2RecompiledFunctionTable[82589] = bhCheckL2Wall_0x14f760; // 0x150a7c - g_ps2RecompiledFunctionTable[82590] = bhCheckL2Wall_0x14f760; // 0x150a80 - g_ps2RecompiledFunctionTable[82591] = bhCheckL2Wall_0x14f760; // 0x150a84 - g_ps2RecompiledFunctionTable[82592] = bhCheckL2Wall_0x14f760; // 0x150a88 - g_ps2RecompiledFunctionTable[82593] = bhCheckL2Wall_0x14f760; // 0x150a8c - g_ps2RecompiledFunctionTable[82594] = bhCheckL2Wall_0x14f760; // 0x150a90 - g_ps2RecompiledFunctionTable[82595] = bhCheckL2Wall_0x14f760; // 0x150a94 - g_ps2RecompiledFunctionTable[82596] = bhCheckL2Wall_0x14f760; // 0x150a98 - g_ps2RecompiledFunctionTable[82597] = bhCheckL2Wall_0x14f760; // 0x150a9c - g_ps2RecompiledFunctionTable[82598] = bhCheckL2Wall_0x14f760; // 0x150aa0 - g_ps2RecompiledFunctionTable[82599] = bhCheckL2Wall_0x14f760; // 0x150aa4 - g_ps2RecompiledFunctionTable[82600] = bhCheckL2Wall_0x14f760; // 0x150aa8 - g_ps2RecompiledFunctionTable[82601] = bhCheckL2Wall_0x14f760; // 0x150aac - g_ps2RecompiledFunctionTable[82602] = bhCheckL2Wall_0x14f760; // 0x150ab0 - g_ps2RecompiledFunctionTable[82603] = bhCheckL2Wall_0x14f760; // 0x150ab4 - g_ps2RecompiledFunctionTable[82604] = bhCheckL2Wall_0x14f760; // 0x150ab8 - g_ps2RecompiledFunctionTable[82605] = bhCheckL2Wall_0x14f760; // 0x150abc - g_ps2RecompiledFunctionTable[82606] = bhCheckL2Wall_0x14f760; // 0x150ac0 - g_ps2RecompiledFunctionTable[82607] = bhCheckL2Wall_0x14f760; // 0x150ac4 - g_ps2RecompiledFunctionTable[82608] = bhCheckL2Wall_0x14f760; // 0x150ac8 - g_ps2RecompiledFunctionTable[82609] = bhCheckL2Wall_0x14f760; // 0x150acc - g_ps2RecompiledFunctionTable[82610] = bhCheckL2Wall_0x14f760; // 0x150ad0 - g_ps2RecompiledFunctionTable[82611] = bhCheckL2Wall_0x14f760; // 0x150ad4 - g_ps2RecompiledFunctionTable[82612] = bhCheckL2Wall_0x14f760; // 0x150ad8 - g_ps2RecompiledFunctionTable[82613] = bhCheckL2Wall_0x14f760; // 0x150adc - g_ps2RecompiledFunctionTable[82614] = bhCheckL2Wall_0x14f760; // 0x150ae0 - g_ps2RecompiledFunctionTable[82615] = bhCheckL2Wall_0x14f760; // 0x150ae4 - g_ps2RecompiledFunctionTable[82616] = bhCheckL2Wall_0x14f760; // 0x150ae8 - g_ps2RecompiledFunctionTable[82617] = bhCheckL2Wall_0x14f760; // 0x150aec - g_ps2RecompiledFunctionTable[82618] = bhCheckL2Wall_0x14f760; // 0x150af0 - g_ps2RecompiledFunctionTable[82619] = bhCheckL2Wall_0x14f760; // 0x150af4 - g_ps2RecompiledFunctionTable[82620] = bhCheckL2Wall_0x14f760; // 0x150af8 - g_ps2RecompiledFunctionTable[82621] = bhCheckL2Wall_0x14f760; // 0x150afc - g_ps2RecompiledFunctionTable[82622] = bhCheckL2Wall_0x14f760; // 0x150b00 - g_ps2RecompiledFunctionTable[82623] = bhCheckL2Wall_0x14f760; // 0x150b04 - g_ps2RecompiledFunctionTable[82624] = bhCheckL2Wall_0x14f760; // 0x150b08 - g_ps2RecompiledFunctionTable[82625] = bhCheckL2Wall_0x14f760; // 0x150b0c - g_ps2RecompiledFunctionTable[82626] = bhCheckL2Wall_0x14f760; // 0x150b10 - g_ps2RecompiledFunctionTable[82627] = bhCheckL2Wall_0x14f760; // 0x150b14 - g_ps2RecompiledFunctionTable[82628] = bhCheckL2Wall_0x14f760; // 0x150b18 - g_ps2RecompiledFunctionTable[82629] = bhCheckL2Wall_0x14f760; // 0x150b1c - g_ps2RecompiledFunctionTable[82630] = bhCheckL2Wall_0x14f760; // 0x150b20 - g_ps2RecompiledFunctionTable[82631] = bhCheckL2Wall_0x14f760; // 0x150b24 - g_ps2RecompiledFunctionTable[82632] = bhCheckL2Wall_0x14f760; // 0x150b28 - g_ps2RecompiledFunctionTable[82633] = bhCheckL2Wall_0x14f760; // 0x150b2c - g_ps2RecompiledFunctionTable[82634] = bhCheckL2Wall_0x14f760; // 0x150b30 - g_ps2RecompiledFunctionTable[82635] = bhCheckL2Wall_0x14f760; // 0x150b34 - g_ps2RecompiledFunctionTable[82636] = bhCheckL2Wall_0x14f760; // 0x150b38 - g_ps2RecompiledFunctionTable[82637] = bhCheckL2Wall_0x14f760; // 0x150b3c - g_ps2RecompiledFunctionTable[82638] = bhCheckL2Wall_0x14f760; // 0x150b40 - g_ps2RecompiledFunctionTable[82639] = bhCheckL2Wall_0x14f760; // 0x150b44 - g_ps2RecompiledFunctionTable[82640] = bhCheckL2Wall_0x14f760; // 0x150b48 - g_ps2RecompiledFunctionTable[82641] = bhCheckL2Wall_0x14f760; // 0x150b4c - g_ps2RecompiledFunctionTable[82642] = bhCheckL2Wall_0x14f760; // 0x150b50 - g_ps2RecompiledFunctionTable[82643] = bhCheckL2Wall_0x14f760; // 0x150b54 - g_ps2RecompiledFunctionTable[82644] = bhCheckL2Wall_0x14f760; // 0x150b58 - g_ps2RecompiledFunctionTable[82645] = bhCheckL2Wall_0x14f760; // 0x150b5c - g_ps2RecompiledFunctionTable[82646] = bhCheckL2Wall_0x14f760; // 0x150b60 - g_ps2RecompiledFunctionTable[82647] = bhCheckL2Wall_0x14f760; // 0x150b64 - g_ps2RecompiledFunctionTable[82648] = bhCheckL2Wall_0x14f760; // 0x150b68 - g_ps2RecompiledFunctionTable[82649] = bhCheckL2Wall_0x14f760; // 0x150b6c - g_ps2RecompiledFunctionTable[82650] = bhCheckL2Wall_0x14f760; // 0x150b70 - g_ps2RecompiledFunctionTable[82651] = bhCheckL2Wall_0x14f760; // 0x150b74 - g_ps2RecompiledFunctionTable[82652] = bhCheckL2Wall_0x14f760; // 0x150b78 - g_ps2RecompiledFunctionTable[82653] = bhCheckL2Wall_0x14f760; // 0x150b7c - g_ps2RecompiledFunctionTable[82654] = bhCheckL2Wall_0x14f760; // 0x150b80 - g_ps2RecompiledFunctionTable[82655] = bhCheckL2Wall_0x14f760; // 0x150b84 - g_ps2RecompiledFunctionTable[82656] = bhCheckL2Wall_0x14f760; // 0x150b88 - g_ps2RecompiledFunctionTable[82657] = bhCheckL2Wall_0x14f760; // 0x150b8c - g_ps2RecompiledFunctionTable[82658] = bhCheckL2Wall_0x14f760; // 0x150b90 - g_ps2RecompiledFunctionTable[82659] = bhCheckL2Wall_0x14f760; // 0x150b94 - g_ps2RecompiledFunctionTable[82660] = bhCheckL2Wall_0x14f760; // 0x150b98 - g_ps2RecompiledFunctionTable[82661] = bhCheckL2Wall_0x14f760; // 0x150b9c - g_ps2RecompiledFunctionTable[82662] = bhCheckL2Wall_0x14f760; // 0x150ba0 - g_ps2RecompiledFunctionTable[82663] = bhCheckL2Wall_0x14f760; // 0x150ba4 - g_ps2RecompiledFunctionTable[82664] = bhCheckL2Wall_0x14f760; // 0x150ba8 - g_ps2RecompiledFunctionTable[82665] = bhCheckL2Wall_0x14f760; // 0x150bac - g_ps2RecompiledFunctionTable[82666] = bhCheckL2Wall_0x14f760; // 0x150bb0 - g_ps2RecompiledFunctionTable[82667] = bhCheckL2Wall_0x14f760; // 0x150bb4 - g_ps2RecompiledFunctionTable[82668] = bhCheckL2Wall_0x14f760; // 0x150bb8 - g_ps2RecompiledFunctionTable[82669] = bhCheckL2Wall_0x14f760; // 0x150bbc - g_ps2RecompiledFunctionTable[82670] = bhCheckL2Wall_0x14f760; // 0x150bc0 - g_ps2RecompiledFunctionTable[82671] = bhCheckL2Wall_0x14f760; // 0x150bc4 - g_ps2RecompiledFunctionTable[82672] = bhCheckL2Wall_0x14f760; // 0x150bc8 - g_ps2RecompiledFunctionTable[82673] = bhCheckL2Wall_0x14f760; // 0x150bcc - g_ps2RecompiledFunctionTable[82674] = bhCheckL2Wall_0x14f760; // 0x150bd0 - g_ps2RecompiledFunctionTable[82675] = bhCheckL2Wall_0x14f760; // 0x150bd4 - g_ps2RecompiledFunctionTable[82676] = bhCheckL2Wall_0x14f760; // 0x150bd8 - g_ps2RecompiledFunctionTable[82677] = bhCheckL2Wall_0x14f760; // 0x150bdc - g_ps2RecompiledFunctionTable[82678] = bhCheckL2Wall_0x14f760; // 0x150be0 - g_ps2RecompiledFunctionTable[82679] = bhCheckL2Wall_0x14f760; // 0x150be4 - g_ps2RecompiledFunctionTable[82680] = bhCheckL2Wall_0x14f760; // 0x150be8 - g_ps2RecompiledFunctionTable[82681] = bhCheckL2Wall_0x14f760; // 0x150bec - g_ps2RecompiledFunctionTable[82682] = bhCheckL2Wall_0x14f760; // 0x150bf0 - g_ps2RecompiledFunctionTable[82683] = bhCheckL2Wall_0x14f760; // 0x150bf4 - g_ps2RecompiledFunctionTable[82684] = bhCheckL2Wall_0x14f760; // 0x150bf8 - g_ps2RecompiledFunctionTable[82685] = bhCheckL2Wall_0x14f760; // 0x150bfc - g_ps2RecompiledFunctionTable[82686] = bhCheckL2Wall_0x14f760; // 0x150c00 - g_ps2RecompiledFunctionTable[82687] = bhCheckL2Wall_0x14f760; // 0x150c04 - g_ps2RecompiledFunctionTable[82688] = bhCheckL2Wall_0x14f760; // 0x150c08 - g_ps2RecompiledFunctionTable[82689] = bhCheckL2Wall_0x14f760; // 0x150c0c - g_ps2RecompiledFunctionTable[82690] = bhCheckL2Wall_0x14f760; // 0x150c10 - g_ps2RecompiledFunctionTable[82691] = bhCheckL2Wall_0x14f760; // 0x150c14 - g_ps2RecompiledFunctionTable[82692] = bhCheckL2Wall_0x14f760; // 0x150c18 - g_ps2RecompiledFunctionTable[82693] = bhCheckL2Wall_0x14f760; // 0x150c1c - g_ps2RecompiledFunctionTable[82694] = bhCheckL2Wall_0x14f760; // 0x150c20 - g_ps2RecompiledFunctionTable[82695] = bhCheckL2Wall_0x14f760; // 0x150c24 - g_ps2RecompiledFunctionTable[82696] = bhCheckL2Wall_0x14f760; // 0x150c28 - g_ps2RecompiledFunctionTable[82697] = bhCheckL2Wall_0x14f760; // 0x150c2c - g_ps2RecompiledFunctionTable[82698] = bhCheckL2Wall_0x14f760; // 0x150c30 - g_ps2RecompiledFunctionTable[82699] = bhCheckL2Wall_0x14f760; // 0x150c34 - g_ps2RecompiledFunctionTable[82700] = bhCheckL2Wall_0x14f760; // 0x150c38 - g_ps2RecompiledFunctionTable[82701] = bhCheckL2Wall_0x14f760; // 0x150c3c - g_ps2RecompiledFunctionTable[82702] = bhCheckL2Wall_0x14f760; // 0x150c40 - g_ps2RecompiledFunctionTable[82703] = bhCheckL2Wall_0x14f760; // 0x150c44 - g_ps2RecompiledFunctionTable[82704] = bhCheckL2Wall_0x14f760; // 0x150c48 - g_ps2RecompiledFunctionTable[82705] = bhCheckL2Wall_0x14f760; // 0x150c4c - g_ps2RecompiledFunctionTable[82706] = bhCheckL2Wall_0x14f760; // 0x150c50 - g_ps2RecompiledFunctionTable[82707] = bhCheckL2Wall_0x14f760; // 0x150c54 - g_ps2RecompiledFunctionTable[82708] = bhCheckL2Wall_0x14f760; // 0x150c58 - g_ps2RecompiledFunctionTable[82709] = bhCheckL2Wall_0x14f760; // 0x150c5c - g_ps2RecompiledFunctionTable[82710] = bhCheckL2Wall_0x14f760; // 0x150c60 - g_ps2RecompiledFunctionTable[82711] = bhCheckL2Wall_0x14f760; // 0x150c64 - g_ps2RecompiledFunctionTable[82712] = bhCheckL2Wall_0x14f760; // 0x150c68 - g_ps2RecompiledFunctionTable[82713] = bhCheckL2Wall_0x14f760; // 0x150c6c - g_ps2RecompiledFunctionTable[82714] = bhCheckL2Wall_0x14f760; // 0x150c70 - g_ps2RecompiledFunctionTable[82715] = bhCheckL2Wall_0x14f760; // 0x150c74 - g_ps2RecompiledFunctionTable[82716] = bhCheckL2Wall_0x14f760; // 0x150c78 - g_ps2RecompiledFunctionTable[82717] = bhCheckL2Wall_0x14f760; // 0x150c7c - g_ps2RecompiledFunctionTable[82718] = bhCheckL2Wall_0x14f760; // 0x150c80 - g_ps2RecompiledFunctionTable[82719] = bhCheckL2Wall_0x14f760; // 0x150c84 - g_ps2RecompiledFunctionTable[82720] = bhCheckL2Wall_0x14f760; // 0x150c88 - g_ps2RecompiledFunctionTable[82721] = bhCheckL2Wall_0x14f760; // 0x150c8c - g_ps2RecompiledFunctionTable[82722] = bhCheckL2Wall_0x14f760; // 0x150c90 - g_ps2RecompiledFunctionTable[82723] = bhCheckL2Wall_0x14f760; // 0x150c94 - g_ps2RecompiledFunctionTable[82724] = bhCheckL2Wall_0x14f760; // 0x150c98 - g_ps2RecompiledFunctionTable[82725] = bhCheckL2Wall_0x14f760; // 0x150c9c - g_ps2RecompiledFunctionTable[82726] = bhCheckL2Wall_0x14f760; // 0x150ca0 - g_ps2RecompiledFunctionTable[82727] = bhCheckL2Wall_0x14f760; // 0x150ca4 - g_ps2RecompiledFunctionTable[82728] = bhCheckL2Wall_0x14f760; // 0x150ca8 - g_ps2RecompiledFunctionTable[82729] = bhCheckL2Wall_0x14f760; // 0x150cac - g_ps2RecompiledFunctionTable[82730] = bhCheckL2Wall_0x14f760; // 0x150cb0 - g_ps2RecompiledFunctionTable[82731] = bhCheckL2Wall_0x14f760; // 0x150cb4 - g_ps2RecompiledFunctionTable[82732] = bhCheckL2Wall_0x14f760; // 0x150cb8 - g_ps2RecompiledFunctionTable[82733] = bhCheckL2Wall_0x14f760; // 0x150cbc - g_ps2RecompiledFunctionTable[82734] = bhCheckL2Wall_0x14f760; // 0x150cc0 - g_ps2RecompiledFunctionTable[82735] = bhCheckL2Wall_0x14f760; // 0x150cc4 - g_ps2RecompiledFunctionTable[82736] = bhCheckL2Wall_0x14f760; // 0x150cc8 - g_ps2RecompiledFunctionTable[82737] = bhCheckL2Wall_0x14f760; // 0x150ccc - g_ps2RecompiledFunctionTable[82738] = bhCheckL2Wall_0x14f760; // 0x150cd0 - g_ps2RecompiledFunctionTable[82739] = bhCheckL2Wall_0x14f760; // 0x150cd4 - g_ps2RecompiledFunctionTable[82740] = bhCheckL2Wall_0x14f760; // 0x150cd8 - g_ps2RecompiledFunctionTable[82741] = bhCheckL2Wall_0x14f760; // 0x150cdc - g_ps2RecompiledFunctionTable[82742] = bhCheckL2Wall_0x14f760; // 0x150ce0 - g_ps2RecompiledFunctionTable[82743] = bhCheckL2Wall_0x14f760; // 0x150ce4 - g_ps2RecompiledFunctionTable[82744] = bhCheckL2Wall_0x14f760; // 0x150ce8 - g_ps2RecompiledFunctionTable[82745] = bhCheckL2Wall_0x14f760; // 0x150cec - g_ps2RecompiledFunctionTable[82746] = bhCheckL2Wall_0x14f760; // 0x150cf0 - g_ps2RecompiledFunctionTable[82747] = bhCheckL2Wall_0x14f760; // 0x150cf4 - g_ps2RecompiledFunctionTable[82748] = bhCheckL2Wall_0x14f760; // 0x150cf8 - g_ps2RecompiledFunctionTable[82749] = bhCheckL2Wall_0x14f760; // 0x150cfc - g_ps2RecompiledFunctionTable[82750] = bhCheckL2Wall_0x14f760; // 0x150d00 - g_ps2RecompiledFunctionTable[82751] = bhCheckL2Wall_0x14f760; // 0x150d04 - g_ps2RecompiledFunctionTable[82752] = bhCheckL2Wall_0x14f760; // 0x150d08 - g_ps2RecompiledFunctionTable[82753] = bhCheckL2Wall_0x14f760; // 0x150d0c - g_ps2RecompiledFunctionTable[82754] = bhCheckL2Wall_0x14f760; // 0x150d10 - g_ps2RecompiledFunctionTable[82755] = bhCheckL2Wall_0x14f760; // 0x150d14 - g_ps2RecompiledFunctionTable[82756] = bhCheckL2Wall_0x14f760; // 0x150d18 - g_ps2RecompiledFunctionTable[82757] = bhCheckL2Wall_0x14f760; // 0x150d1c - g_ps2RecompiledFunctionTable[82758] = bhCheckL2Wall_0x14f760; // 0x150d20 - g_ps2RecompiledFunctionTable[82759] = bhCheckL2Wall_0x14f760; // 0x150d24 - g_ps2RecompiledFunctionTable[82760] = bhCheckL2Wall_0x14f760; // 0x150d28 - g_ps2RecompiledFunctionTable[82761] = bhCheckL2Wall_0x14f760; // 0x150d2c - g_ps2RecompiledFunctionTable[82762] = bhCheckL2Wall_0x14f760; // 0x150d30 - g_ps2RecompiledFunctionTable[82763] = bhCheckL2Wall_0x14f760; // 0x150d34 - g_ps2RecompiledFunctionTable[82764] = bhCheckL2Wall_0x14f760; // 0x150d38 - g_ps2RecompiledFunctionTable[82765] = bhCheckL2Wall_0x14f760; // 0x150d3c - g_ps2RecompiledFunctionTable[82766] = bhCheckL2Wall_0x14f760; // 0x150d40 - g_ps2RecompiledFunctionTable[82767] = bhCheckL2Wall_0x14f760; // 0x150d44 - g_ps2RecompiledFunctionTable[82768] = bhCheckL2Wall_0x14f760; // 0x150d48 - g_ps2RecompiledFunctionTable[82769] = bhCheckL2Wall_0x14f760; // 0x150d4c - g_ps2RecompiledFunctionTable[82770] = bhCheckL2Wall_0x14f760; // 0x150d50 - g_ps2RecompiledFunctionTable[82771] = bhCheckL2Wall_0x14f760; // 0x150d54 - g_ps2RecompiledFunctionTable[82772] = bhCheckL2Wall_0x14f760; // 0x150d58 - g_ps2RecompiledFunctionTable[82773] = bhCheckL2Wall_0x14f760; // 0x150d5c - g_ps2RecompiledFunctionTable[82774] = bhCheckL2Wall_0x14f760; // 0x150d60 - g_ps2RecompiledFunctionTable[82775] = bhCheckL2Wall_0x14f760; // 0x150d64 - g_ps2RecompiledFunctionTable[82776] = bhCheckL2Wall_0x14f760; // 0x150d68 - g_ps2RecompiledFunctionTable[82777] = bhCheckL2Wall_0x14f760; // 0x150d6c - g_ps2RecompiledFunctionTable[82778] = bhCheckL2Wall_0x14f760; // 0x150d70 - g_ps2RecompiledFunctionTable[82779] = bhCheckL2Wall_0x14f760; // 0x150d74 - g_ps2RecompiledFunctionTable[82780] = bhCheckL2Wall_0x14f760; // 0x150d78 - g_ps2RecompiledFunctionTable[82781] = bhCheckL2Wall_0x14f760; // 0x150d7c - g_ps2RecompiledFunctionTable[82782] = bhCheckL2Wall_0x14f760; // 0x150d80 - g_ps2RecompiledFunctionTable[82783] = bhCheckL2Wall_0x14f760; // 0x150d84 - g_ps2RecompiledFunctionTable[82784] = bhCheckL2Wall_0x14f760; // 0x150d88 - g_ps2RecompiledFunctionTable[82785] = bhCheckL2Wall_0x14f760; // 0x150d8c - g_ps2RecompiledFunctionTable[82786] = bhCheckL2Wall_0x14f760; // 0x150d90 - g_ps2RecompiledFunctionTable[82787] = bhCheckL2Wall_0x14f760; // 0x150d94 - g_ps2RecompiledFunctionTable[82788] = bhCheckL2Wall_0x14f760; // 0x150d98 - g_ps2RecompiledFunctionTable[82789] = bhCheckL2Wall_0x14f760; // 0x150d9c - g_ps2RecompiledFunctionTable[82790] = bhCheckL2Wall_0x14f760; // 0x150da0 - g_ps2RecompiledFunctionTable[82791] = bhCheckL2Wall_0x14f760; // 0x150da4 - g_ps2RecompiledFunctionTable[82792] = bhCheckL2Wall_0x14f760; // 0x150da8 - g_ps2RecompiledFunctionTable[82793] = bhCheckL2Wall_0x14f760; // 0x150dac - g_ps2RecompiledFunctionTable[82794] = bhCheckL2Wall_0x14f760; // 0x150db0 - g_ps2RecompiledFunctionTable[82795] = bhCheckL2Wall_0x14f760; // 0x150db4 - g_ps2RecompiledFunctionTable[82796] = bhCheckL2Wall_0x14f760; // 0x150db8 - g_ps2RecompiledFunctionTable[82797] = bhCheckL2Wall_0x14f760; // 0x150dbc - g_ps2RecompiledFunctionTable[82798] = bhCheckL2Wall_0x14f760; // 0x150dc0 - g_ps2RecompiledFunctionTable[82799] = bhCheckL2Wall_0x14f760; // 0x150dc4 - g_ps2RecompiledFunctionTable[82800] = bhCheckL2Wall_0x14f760; // 0x150dc8 - g_ps2RecompiledFunctionTable[82801] = bhCheckL2Wall_0x14f760; // 0x150dcc - g_ps2RecompiledFunctionTable[82802] = bhCheckL2Wall_0x14f760; // 0x150dd0 - g_ps2RecompiledFunctionTable[82803] = bhCheckL2Wall_0x14f760; // 0x150dd4 - g_ps2RecompiledFunctionTable[82804] = bhCheckL2Wall_0x14f760; // 0x150dd8 - g_ps2RecompiledFunctionTable[82805] = bhCheckL2Wall_0x14f760; // 0x150ddc - g_ps2RecompiledFunctionTable[82806] = bhCheckL2Wall_0x14f760; // 0x150de0 - g_ps2RecompiledFunctionTable[82807] = bhCheckL2Wall_0x14f760; // 0x150de4 - g_ps2RecompiledFunctionTable[82808] = bhCheckL2Wall_0x14f760; // 0x150de8 - g_ps2RecompiledFunctionTable[82809] = bhCheckL2Wall_0x14f760; // 0x150dec - g_ps2RecompiledFunctionTable[82810] = bhCheckL2Wall_0x14f760; // 0x150df0 - g_ps2RecompiledFunctionTable[82811] = bhCheckL2Wall_0x14f760; // 0x150df4 - g_ps2RecompiledFunctionTable[82812] = bhCheckL2Wall_0x14f760; // 0x150df8 - g_ps2RecompiledFunctionTable[82813] = bhCheckL2Wall_0x14f760; // 0x150dfc - g_ps2RecompiledFunctionTable[82814] = bhCheckL2Wall_0x14f760; // 0x150e00 - g_ps2RecompiledFunctionTable[82815] = bhCheckL2Wall_0x14f760; // 0x150e04 - g_ps2RecompiledFunctionTable[82816] = bhCheckL2Wall_0x14f760; // 0x150e08 - g_ps2RecompiledFunctionTable[82817] = bhCheckL2Wall_0x14f760; // 0x150e0c - g_ps2RecompiledFunctionTable[82818] = bhCheckL2Wall_0x14f760; // 0x150e10 - g_ps2RecompiledFunctionTable[82819] = bhCheckL2Wall_0x14f760; // 0x150e14 - g_ps2RecompiledFunctionTable[82820] = bhCheckL2Wall_0x14f760; // 0x150e18 - g_ps2RecompiledFunctionTable[82821] = bhCheckL2Wall_0x14f760; // 0x150e1c - g_ps2RecompiledFunctionTable[82822] = bhCheckL2Wall_0x14f760; // 0x150e20 - g_ps2RecompiledFunctionTable[82823] = bhCheckL2Wall_0x14f760; // 0x150e24 - g_ps2RecompiledFunctionTable[82824] = bhCheckL2Wall_0x14f760; // 0x150e28 - g_ps2RecompiledFunctionTable[82825] = bhCheckL2Wall_0x14f760; // 0x150e2c - g_ps2RecompiledFunctionTable[82826] = bhCheckL2Wall_0x14f760; // 0x150e30 - g_ps2RecompiledFunctionTable[82827] = bhCheckL2Wall_0x14f760; // 0x150e34 - g_ps2RecompiledFunctionTable[82828] = bhCheckL2Wall_0x14f760; // 0x150e38 - g_ps2RecompiledFunctionTable[82829] = bhCheckL2Wall_0x14f760; // 0x150e3c - g_ps2RecompiledFunctionTable[82830] = bhCheckL2Wall_0x14f760; // 0x150e40 - g_ps2RecompiledFunctionTable[82831] = bhCheckL2Wall_0x14f760; // 0x150e44 - g_ps2RecompiledFunctionTable[82832] = bhCheckL2Wall_0x14f760; // 0x150e48 - g_ps2RecompiledFunctionTable[82833] = bhCheckL2Wall_0x14f760; // 0x150e4c - g_ps2RecompiledFunctionTable[82834] = bhCheckL2Wall_0x14f760; // 0x150e50 - g_ps2RecompiledFunctionTable[82835] = bhCheckL2Wall_0x14f760; // 0x150e54 - g_ps2RecompiledFunctionTable[82836] = bhCheckL2Wall_0x14f760; // 0x150e58 - g_ps2RecompiledFunctionTable[82837] = bhCheckL2Wall_0x14f760; // 0x150e5c - g_ps2RecompiledFunctionTable[82838] = bhCheckL2Wall_0x14f760; // 0x150e60 - g_ps2RecompiledFunctionTable[82839] = bhCheckL2Wall_0x14f760; // 0x150e64 - g_ps2RecompiledFunctionTable[82840] = bhCheckL2Wall_0x14f760; // 0x150e68 - g_ps2RecompiledFunctionTable[82841] = bhCheckL2Wall_0x14f760; // 0x150e6c - g_ps2RecompiledFunctionTable[82842] = bhCheckL2Wall_0x14f760; // 0x150e70 - g_ps2RecompiledFunctionTable[82843] = bhCheckL2Wall_0x14f760; // 0x150e74 - g_ps2RecompiledFunctionTable[82844] = bhCheckL2Wall_0x14f760; // 0x150e78 - g_ps2RecompiledFunctionTable[82845] = bhCheckL2Wall_0x14f760; // 0x150e7c - g_ps2RecompiledFunctionTable[82846] = bhCheckL2Wall_0x14f760; // 0x150e80 - g_ps2RecompiledFunctionTable[82847] = bhCheckL2Wall_0x14f760; // 0x150e84 - g_ps2RecompiledFunctionTable[82848] = bhCheckL2Wall_0x14f760; // 0x150e88 - g_ps2RecompiledFunctionTable[82849] = bhCheckL2Wall_0x14f760; // 0x150e8c - g_ps2RecompiledFunctionTable[82850] = bhCheckL2Wall_0x14f760; // 0x150e90 - g_ps2RecompiledFunctionTable[82851] = bhCheckL2Wall_0x14f760; // 0x150e94 - g_ps2RecompiledFunctionTable[82852] = bhCheckL2Wall_0x14f760; // 0x150e98 - g_ps2RecompiledFunctionTable[82853] = bhCheckL2Wall_0x14f760; // 0x150e9c - g_ps2RecompiledFunctionTable[82854] = bhCheckL2Wall_0x14f760; // 0x150ea0 - g_ps2RecompiledFunctionTable[82855] = bhCheckL2Wall_0x14f760; // 0x150ea4 - g_ps2RecompiledFunctionTable[82856] = bhCheckL2Wall_0x14f760; // 0x150ea8 - g_ps2RecompiledFunctionTable[82857] = bhCheckL2Wall_0x14f760; // 0x150eac - g_ps2RecompiledFunctionTable[82858] = bhCheckL2Wall_0x14f760; // 0x150eb0 - g_ps2RecompiledFunctionTable[82859] = bhCheckL2Wall_0x14f760; // 0x150eb4 - g_ps2RecompiledFunctionTable[82860] = bhCheckL2Wall_0x14f760; // 0x150eb8 - g_ps2RecompiledFunctionTable[82861] = bhCheckL2Wall_0x14f760; // 0x150ebc - g_ps2RecompiledFunctionTable[82862] = bhCheckL2Wall_0x14f760; // 0x150ec0 - g_ps2RecompiledFunctionTable[82863] = bhCheckL2Wall_0x14f760; // 0x150ec4 - g_ps2RecompiledFunctionTable[82864] = bhCheckL2Wall_0x14f760; // 0x150ec8 - g_ps2RecompiledFunctionTable[82865] = bhCheckL2Wall_0x14f760; // 0x150ecc - g_ps2RecompiledFunctionTable[82866] = bhCheckL2Wall_0x14f760; // 0x150ed0 - g_ps2RecompiledFunctionTable[82867] = bhCheckL2Wall_0x14f760; // 0x150ed4 - g_ps2RecompiledFunctionTable[82868] = bhCheckL2Wall_0x14f760; // 0x150ed8 - g_ps2RecompiledFunctionTable[82869] = bhCheckL2Wall_0x14f760; // 0x150edc - g_ps2RecompiledFunctionTable[82870] = bhCheckL2Wall_0x14f760; // 0x150ee0 - g_ps2RecompiledFunctionTable[82871] = bhCheckL2Wall_0x14f760; // 0x150ee4 - g_ps2RecompiledFunctionTable[82872] = bhCheckL2Wall_0x14f760; // 0x150ee8 - g_ps2RecompiledFunctionTable[82873] = bhCheckL2Wall_0x14f760; // 0x150eec - g_ps2RecompiledFunctionTable[82874] = bhCheckL2Wall_0x14f760; // 0x150ef0 - g_ps2RecompiledFunctionTable[82875] = bhCheckL2Wall_0x14f760; // 0x150ef4 - g_ps2RecompiledFunctionTable[82876] = bhCheckL2Wall_0x14f760; // 0x150ef8 - g_ps2RecompiledFunctionTable[82877] = bhCheckL2Wall_0x14f760; // 0x150efc - g_ps2RecompiledFunctionTable[82878] = bhCheckL2Wall_0x14f760; // 0x150f00 - g_ps2RecompiledFunctionTable[82879] = bhCheckL2Wall_0x14f760; // 0x150f04 - g_ps2RecompiledFunctionTable[82880] = bhCheckL2Wall_0x14f760; // 0x150f08 - g_ps2RecompiledFunctionTable[82881] = bhCheckL2Wall_0x14f760; // 0x150f0c - g_ps2RecompiledFunctionTable[82882] = bhCheckL2Wall_0x14f760; // 0x150f10 - g_ps2RecompiledFunctionTable[82883] = bhCheckL2Wall_0x14f760; // 0x150f14 - g_ps2RecompiledFunctionTable[82884] = bhCheckL2Wall_0x14f760; // 0x150f18 - g_ps2RecompiledFunctionTable[82885] = bhCheckL2Wall_0x14f760; // 0x150f1c - g_ps2RecompiledFunctionTable[82886] = bhCheckL2Wall_0x14f760; // 0x150f20 - g_ps2RecompiledFunctionTable[82887] = bhCheckL2Wall_0x14f760; // 0x150f24 - g_ps2RecompiledFunctionTable[82888] = bhCheckL2Wall_0x14f760; // 0x150f28 - g_ps2RecompiledFunctionTable[82889] = bhCheckL2Wall_0x14f760; // 0x150f2c - g_ps2RecompiledFunctionTable[82890] = bhCheckL2Wall_0x14f760; // 0x150f30 - g_ps2RecompiledFunctionTable[82891] = bhCheckL2Wall_0x14f760; // 0x150f34 - g_ps2RecompiledFunctionTable[82892] = bhCheckL2Wall_0x14f760; // 0x150f38 - g_ps2RecompiledFunctionTable[82893] = bhCheckL2Wall_0x14f760; // 0x150f3c - g_ps2RecompiledFunctionTable[82894] = bhCheckL2Wall_0x14f760; // 0x150f40 - g_ps2RecompiledFunctionTable[82895] = bhCheckL2Wall_0x14f760; // 0x150f44 - g_ps2RecompiledFunctionTable[82896] = bhCheckL2Wall_0x14f760; // 0x150f48 - g_ps2RecompiledFunctionTable[82897] = bhCheckL2Wall_0x14f760; // 0x150f4c - g_ps2RecompiledFunctionTable[82898] = bhCheckL2Wall_0x14f760; // 0x150f50 - g_ps2RecompiledFunctionTable[82899] = bhCheckL2Wall_0x14f760; // 0x150f54 - g_ps2RecompiledFunctionTable[82900] = bhCheckL2Wall_0x14f760; // 0x150f58 - g_ps2RecompiledFunctionTable[82901] = bhCheckL2Wall_0x14f760; // 0x150f5c - g_ps2RecompiledFunctionTable[82902] = bhCheckL2Wall_0x14f760; // 0x150f60 - g_ps2RecompiledFunctionTable[82903] = bhCheckL2Wall_0x14f760; // 0x150f64 - g_ps2RecompiledFunctionTable[82904] = bhCheckL2Wall_0x14f760; // 0x150f68 - g_ps2RecompiledFunctionTable[82905] = bhCheckL2Wall_0x14f760; // 0x150f6c - g_ps2RecompiledFunctionTable[82906] = bhCheckL2Wall_0x14f760; // 0x150f70 - g_ps2RecompiledFunctionTable[82907] = bhCheckL2Wall_0x14f760; // 0x150f74 - g_ps2RecompiledFunctionTable[82908] = bhCheckL2Wall_0x14f760; // 0x150f78 - g_ps2RecompiledFunctionTable[82909] = bhCheckL2Wall_0x14f760; // 0x150f7c - g_ps2RecompiledFunctionTable[82910] = bhCheckL2Wall_0x14f760; // 0x150f80 - g_ps2RecompiledFunctionTable[82911] = bhCheckL2Wall_0x14f760; // 0x150f84 - g_ps2RecompiledFunctionTable[82912] = bhCheckL2Wall_0x14f760; // 0x150f88 - g_ps2RecompiledFunctionTable[82913] = bhCheckL2Wall_0x14f760; // 0x150f8c - g_ps2RecompiledFunctionTable[82914] = bhCheckL2Wall_0x14f760; // 0x150f90 - g_ps2RecompiledFunctionTable[82915] = bhCheckL2Wall_0x14f760; // 0x150f94 - g_ps2RecompiledFunctionTable[82916] = bhCheckL2Wall_0x14f760; // 0x150f98 - g_ps2RecompiledFunctionTable[82917] = bhCheckL2Wall_0x14f760; // 0x150f9c - g_ps2RecompiledFunctionTable[82918] = bhCheckL2Wall_0x14f760; // 0x150fa0 - g_ps2RecompiledFunctionTable[82919] = bhCheckL2Wall_0x14f760; // 0x150fa4 - g_ps2RecompiledFunctionTable[82920] = bhCheckL2Wall_0x14f760; // 0x150fa8 - g_ps2RecompiledFunctionTable[82921] = bhCheckL2Wall_0x14f760; // 0x150fac - g_ps2RecompiledFunctionTable[82922] = bhCheckL2Wall_0x14f760; // 0x150fb0 - g_ps2RecompiledFunctionTable[82923] = bhCheckL2Wall_0x14f760; // 0x150fb4 - g_ps2RecompiledFunctionTable[82924] = bhCheckL2Wall_0x14f760; // 0x150fb8 - g_ps2RecompiledFunctionTable[82925] = bhCheckL2Wall_0x14f760; // 0x150fbc - g_ps2RecompiledFunctionTable[82926] = bhCheckL2Wall_0x14f760; // 0x150fc0 - g_ps2RecompiledFunctionTable[82927] = bhCheckL2Wall_0x14f760; // 0x150fc4 - g_ps2RecompiledFunctionTable[82928] = bhCheckL2Wall_0x14f760; // 0x150fc8 - g_ps2RecompiledFunctionTable[82929] = bhCheckL2Wall_0x14f760; // 0x150fcc - g_ps2RecompiledFunctionTable[82930] = bhCheckL2Wall_0x14f760; // 0x150fd0 - g_ps2RecompiledFunctionTable[82931] = bhCheckL2Wall_0x14f760; // 0x150fd4 - g_ps2RecompiledFunctionTable[82932] = bhCheckL2Wall_0x14f760; // 0x150fd8 - g_ps2RecompiledFunctionTable[82933] = bhCheckL2Wall_0x14f760; // 0x150fdc - g_ps2RecompiledFunctionTable[82934] = bhCheckL2Wall_0x14f760; // 0x150fe0 - g_ps2RecompiledFunctionTable[82935] = bhCheckL2Wall_0x14f760; // 0x150fe4 - g_ps2RecompiledFunctionTable[82936] = bhCheckL2Wall_0x14f760; // 0x150fe8 - g_ps2RecompiledFunctionTable[82937] = bhCheckL2Wall_0x14f760; // 0x150fec - g_ps2RecompiledFunctionTable[82938] = bhCheckL2Wall_0x14f760; // 0x150ff0 - g_ps2RecompiledFunctionTable[82939] = bhCheckL2Wall_0x14f760; // 0x150ff4 - g_ps2RecompiledFunctionTable[82940] = bhCheckL2Wall_0x14f760; // 0x150ff8 - g_ps2RecompiledFunctionTable[82941] = bhCheckL2Wall_0x14f760; // 0x150ffc - g_ps2RecompiledFunctionTable[82942] = bhCheckL2Wall_0x14f760; // 0x151000 - g_ps2RecompiledFunctionTable[82943] = bhCheckL2Wall_0x14f760; // 0x151004 - g_ps2RecompiledFunctionTable[82944] = bhCheckL2Wall_0x14f760; // 0x151008 - g_ps2RecompiledFunctionTable[82945] = bhCheckL2Wall_0x14f760; // 0x15100c - g_ps2RecompiledFunctionTable[82946] = bhCheckL2Wall_0x14f760; // 0x151010 - g_ps2RecompiledFunctionTable[82947] = bhCheckL2Wall_0x14f760; // 0x151014 - g_ps2RecompiledFunctionTable[82948] = bhCheckL2Wall_0x14f760; // 0x151018 - g_ps2RecompiledFunctionTable[82949] = bhCheckL2Wall_0x14f760; // 0x15101c - g_ps2RecompiledFunctionTable[82950] = bhCheckL2Wall_0x14f760; // 0x151020 - g_ps2RecompiledFunctionTable[82951] = bhCheckL2Wall_0x14f760; // 0x151024 - g_ps2RecompiledFunctionTable[82952] = bhCheckL2Wall_0x14f760; // 0x151028 - g_ps2RecompiledFunctionTable[82953] = bhCheckL2Wall_0x14f760; // 0x15102c - g_ps2RecompiledFunctionTable[82954] = bhCheckL2Wall_0x14f760; // 0x151030 - g_ps2RecompiledFunctionTable[82955] = bhCheckL2Wall_0x14f760; // 0x151034 - g_ps2RecompiledFunctionTable[82956] = bhCheckL2Wall_0x14f760; // 0x151038 - g_ps2RecompiledFunctionTable[82957] = bhCheckL2Wall_0x14f760; // 0x15103c - g_ps2RecompiledFunctionTable[82958] = bhCheckL2Wall_0x14f760; // 0x151040 - g_ps2RecompiledFunctionTable[82959] = bhCheckL2Wall_0x14f760; // 0x151044 - g_ps2RecompiledFunctionTable[82960] = bhCheckL2Wall_0x14f760; // 0x151048 - g_ps2RecompiledFunctionTable[82961] = bhCheckL2Wall_0x14f760; // 0x15104c - g_ps2RecompiledFunctionTable[82962] = bhCheckL2Wall_0x14f760; // 0x151050 - g_ps2RecompiledFunctionTable[82963] = bhCheckL2Wall_0x14f760; // 0x151054 - g_ps2RecompiledFunctionTable[82964] = bhCheckL2Wall_0x14f760; // 0x151058 - g_ps2RecompiledFunctionTable[82965] = bhCheckL2Wall_0x14f760; // 0x15105c - g_ps2RecompiledFunctionTable[82966] = bhCheckL2Wall_0x14f760; // 0x151060 - g_ps2RecompiledFunctionTable[82967] = bhCheckL2Wall_0x14f760; // 0x151064 - g_ps2RecompiledFunctionTable[82968] = bhCheckL2Wall_0x14f760; // 0x151068 - g_ps2RecompiledFunctionTable[82969] = bhCheckL2Wall_0x14f760; // 0x15106c - g_ps2RecompiledFunctionTable[82970] = bhCheckL2Wall_0x14f760; // 0x151070 - g_ps2RecompiledFunctionTable[82971] = bhCheckL2Wall_0x14f760; // 0x151074 - g_ps2RecompiledFunctionTable[82972] = bhCheckL2Wall_0x14f760; // 0x151078 - g_ps2RecompiledFunctionTable[82973] = bhCheckL2Wall_0x14f760; // 0x15107c - g_ps2RecompiledFunctionTable[82974] = bhCheckL2Wall_0x14f760; // 0x151080 - g_ps2RecompiledFunctionTable[82975] = bhCheckL2Wall_0x14f760; // 0x151084 - g_ps2RecompiledFunctionTable[82976] = bhCheckL2Wall_0x14f760; // 0x151088 - g_ps2RecompiledFunctionTable[82977] = bhCheckL2Wall_0x14f760; // 0x15108c - g_ps2RecompiledFunctionTable[82978] = bhCheckL2Wall_0x14f760; // 0x151090 - g_ps2RecompiledFunctionTable[82979] = bhCheckL2Wall_0x14f760; // 0x151094 - g_ps2RecompiledFunctionTable[82980] = bhCheckL2Wall_0x14f760; // 0x151098 - g_ps2RecompiledFunctionTable[82981] = bhCheckL2Wall_0x14f760; // 0x15109c - g_ps2RecompiledFunctionTable[82982] = bhCheckL2Wall_0x14f760; // 0x1510a0 - g_ps2RecompiledFunctionTable[82983] = bhCheckL2Wall_0x14f760; // 0x1510a4 - g_ps2RecompiledFunctionTable[82984] = bhCheckL2Wall_0x14f760; // 0x1510a8 - g_ps2RecompiledFunctionTable[82985] = bhCheckL2Wall_0x14f760; // 0x1510ac - g_ps2RecompiledFunctionTable[82986] = bhCheckL2Wall_0x14f760; // 0x1510b0 - g_ps2RecompiledFunctionTable[82987] = bhCheckL2Wall_0x14f760; // 0x1510b4 - g_ps2RecompiledFunctionTable[82988] = bhCheckL2Wall_0x14f760; // 0x1510b8 - g_ps2RecompiledFunctionTable[82989] = bhCheckL2Wall_0x14f760; // 0x1510bc - g_ps2RecompiledFunctionTable[82990] = bhCheckL2Wall_0x14f760; // 0x1510c0 - g_ps2RecompiledFunctionTable[82991] = bhCheckL2Wall_0x14f760; // 0x1510c4 - g_ps2RecompiledFunctionTable[82992] = bhCheckL2Wall_0x14f760; // 0x1510c8 - g_ps2RecompiledFunctionTable[82993] = bhCheckL2Wall_0x14f760; // 0x1510cc - g_ps2RecompiledFunctionTable[82994] = bhCheckL2Wall_0x14f760; // 0x1510d0 - g_ps2RecompiledFunctionTable[82995] = bhCheckL2Wall_0x14f760; // 0x1510d4 - g_ps2RecompiledFunctionTable[82996] = bhCheckL2Wall_0x14f760; // 0x1510d8 - g_ps2RecompiledFunctionTable[82997] = bhCheckL2Wall_0x14f760; // 0x1510dc - g_ps2RecompiledFunctionTable[82998] = bhCheckL2Wall_0x14f760; // 0x1510e0 - g_ps2RecompiledFunctionTable[82999] = bhCheckL2Wall_0x14f760; // 0x1510e4 - g_ps2RecompiledFunctionTable[83000] = bhCheckL2Wall_0x14f760; // 0x1510e8 - g_ps2RecompiledFunctionTable[83001] = bhCheckL2Wall_0x14f760; // 0x1510ec - g_ps2RecompiledFunctionTable[83002] = bhCheckL2Wall_0x14f760; // 0x1510f0 - g_ps2RecompiledFunctionTable[83003] = bhCheckL2Wall_0x14f760; // 0x1510f4 - g_ps2RecompiledFunctionTable[83004] = bhCheckL2Wall_0x14f760; // 0x1510f8 - g_ps2RecompiledFunctionTable[83005] = bhCheckL2Wall_0x14f760; // 0x1510fc - g_ps2RecompiledFunctionTable[83006] = bhCheckL2Wall_0x14f760; // 0x151100 - g_ps2RecompiledFunctionTable[83007] = bhCheckL2Wall_0x14f760; // 0x151104 - g_ps2RecompiledFunctionTable[83008] = bhCheckL2Wall_0x14f760; // 0x151108 - g_ps2RecompiledFunctionTable[83009] = bhCheckL2Wall_0x14f760; // 0x15110c - g_ps2RecompiledFunctionTable[83010] = bhCheckL2Wall_0x14f760; // 0x151110 - g_ps2RecompiledFunctionTable[83011] = bhCheckL2Wall_0x14f760; // 0x151114 - g_ps2RecompiledFunctionTable[83012] = bhCheckL2Wall_0x14f760; // 0x151118 - g_ps2RecompiledFunctionTable[83013] = bhCheckL2Wall_0x14f760; // 0x15111c - g_ps2RecompiledFunctionTable[83014] = bhCheckL2Wall_0x14f760; // 0x151120 - g_ps2RecompiledFunctionTable[83015] = bhCheckL2Wall_0x14f760; // 0x151124 - g_ps2RecompiledFunctionTable[83016] = bhCheckL2Wall_0x14f760; // 0x151128 - g_ps2RecompiledFunctionTable[83017] = bhCheckL2Wall_0x14f760; // 0x15112c - g_ps2RecompiledFunctionTable[83018] = bhCheckL2Wall_0x14f760; // 0x151130 - g_ps2RecompiledFunctionTable[83019] = bhCheckL2Wall_0x14f760; // 0x151134 - g_ps2RecompiledFunctionTable[83020] = bhCheckL2Wall_0x14f760; // 0x151138 - g_ps2RecompiledFunctionTable[83021] = bhCheckL2Wall_0x14f760; // 0x15113c - g_ps2RecompiledFunctionTable[83022] = bhCheckL2Wall_0x14f760; // 0x151140 - g_ps2RecompiledFunctionTable[83023] = bhCheckL2Wall_0x14f760; // 0x151144 - g_ps2RecompiledFunctionTable[83024] = bhCheckL2Wall_0x14f760; // 0x151148 - g_ps2RecompiledFunctionTable[83025] = bhCheckL2Wall_0x14f760; // 0x15114c - g_ps2RecompiledFunctionTable[83026] = bhCheckL2Wall_0x14f760; // 0x151150 - g_ps2RecompiledFunctionTable[83027] = bhCheckL2Wall_0x14f760; // 0x151154 - g_ps2RecompiledFunctionTable[83028] = bhCheckL2Wall_0x14f760; // 0x151158 - g_ps2RecompiledFunctionTable[83029] = bhCheckL2Wall_0x14f760; // 0x15115c - g_ps2RecompiledFunctionTable[83030] = bhCheckL2Wall_0x14f760; // 0x151160 - g_ps2RecompiledFunctionTable[83031] = bhCheckL2Wall_0x14f760; // 0x151164 - g_ps2RecompiledFunctionTable[83032] = bhCheckL2Wall_0x14f760; // 0x151168 - g_ps2RecompiledFunctionTable[83033] = bhCheckL2Wall_0x14f760; // 0x15116c - g_ps2RecompiledFunctionTable[83034] = bhCheckL2Wall_0x14f760; // 0x151170 - g_ps2RecompiledFunctionTable[83035] = bhCheckL2Wall_0x14f760; // 0x151174 - g_ps2RecompiledFunctionTable[83036] = bhCheckL2Wall_0x14f760; // 0x151178 - g_ps2RecompiledFunctionTable[83037] = bhCheckL2Wall_0x14f760; // 0x15117c - g_ps2RecompiledFunctionTable[83038] = bhCheckL2Wall_0x14f760; // 0x151180 - g_ps2RecompiledFunctionTable[83039] = bhCheckL2Wall_0x14f760; // 0x151184 - g_ps2RecompiledFunctionTable[83040] = bhCheckL2Wall_0x14f760; // 0x151188 - g_ps2RecompiledFunctionTable[83041] = bhCheckL2Wall_0x14f760; // 0x15118c - g_ps2RecompiledFunctionTable[83042] = bhCheckL2Wall_0x14f760; // 0x151190 - g_ps2RecompiledFunctionTable[83043] = bhCheckL2Wall_0x14f760; // 0x151194 - g_ps2RecompiledFunctionTable[83044] = bhCheckL2Wall_0x14f760; // 0x151198 - g_ps2RecompiledFunctionTable[83045] = bhCheckL2Wall_0x14f760; // 0x15119c - g_ps2RecompiledFunctionTable[83046] = bhCheckL2Wall_0x14f760; // 0x1511a0 - g_ps2RecompiledFunctionTable[83047] = bhCheckL2Wall_0x14f760; // 0x1511a4 - g_ps2RecompiledFunctionTable[83048] = bhCheckL2Wall_0x14f760; // 0x1511a8 - g_ps2RecompiledFunctionTable[83049] = bhCheckL2Wall_0x14f760; // 0x1511ac - g_ps2RecompiledFunctionTable[83050] = bhCheckL2Wall_0x14f760; // 0x1511b0 - g_ps2RecompiledFunctionTable[83051] = bhCheckL2Wall_0x14f760; // 0x1511b4 - g_ps2RecompiledFunctionTable[83052] = bhCheckL2Wall_0x14f760; // 0x1511b8 - g_ps2RecompiledFunctionTable[83053] = bhCheckL2Wall_0x14f760; // 0x1511bc - g_ps2RecompiledFunctionTable[83054] = bhCheckL2Wall_0x14f760; // 0x1511c0 - g_ps2RecompiledFunctionTable[83055] = bhCheckL2Wall_0x14f760; // 0x1511c4 - g_ps2RecompiledFunctionTable[83056] = bhCheckL2Wall_0x14f760; // 0x1511c8 - g_ps2RecompiledFunctionTable[83057] = bhCheckL2Wall_0x14f760; // 0x1511cc - g_ps2RecompiledFunctionTable[83058] = bhCheckL2Wall_0x14f760; // 0x1511d0 - g_ps2RecompiledFunctionTable[83059] = bhCheckL2Wall_0x14f760; // 0x1511d4 - g_ps2RecompiledFunctionTable[83060] = bhCheckL2Wall_0x14f760; // 0x1511d8 - g_ps2RecompiledFunctionTable[83061] = bhCheckL2Wall_0x14f760; // 0x1511dc - g_ps2RecompiledFunctionTable[83062] = bhCheckL2Wall_0x14f760; // 0x1511e0 - g_ps2RecompiledFunctionTable[83063] = bhCheckL2Wall_0x14f760; // 0x1511e4 - g_ps2RecompiledFunctionTable[83064] = bhCheckL2Wall_0x14f760; // 0x1511e8 - g_ps2RecompiledFunctionTable[83065] = bhCheckL2Wall_0x14f760; // 0x1511ec - g_ps2RecompiledFunctionTable[83066] = bhCheckL2Wall_0x14f760; // 0x1511f0 - g_ps2RecompiledFunctionTable[83067] = bhCheckL2Wall_0x14f760; // 0x1511f4 - g_ps2RecompiledFunctionTable[83068] = bhCheckL2Wall_0x14f760; // 0x1511f8 - g_ps2RecompiledFunctionTable[83069] = bhCheckL2Wall_0x14f760; // 0x1511fc - g_ps2RecompiledFunctionTable[83070] = bhCheckL2Wall_0x14f760; // 0x151200 - g_ps2RecompiledFunctionTable[83071] = bhCheckL2Wall_0x14f760; // 0x151204 - g_ps2RecompiledFunctionTable[83072] = bhCheckL2Wall_0x14f760; // 0x151208 - g_ps2RecompiledFunctionTable[83073] = bhCheckL2Wall_0x14f760; // 0x15120c - g_ps2RecompiledFunctionTable[83074] = bhCheckL2Wall_0x14f760; // 0x151210 - g_ps2RecompiledFunctionTable[83075] = bhCheckL2Wall_0x14f760; // 0x151214 - g_ps2RecompiledFunctionTable[83076] = bhCheckL2Wall_0x14f760; // 0x151218 - g_ps2RecompiledFunctionTable[83077] = bhCheckL2Wall_0x14f760; // 0x15121c - g_ps2RecompiledFunctionTable[83078] = bhCheckL2Wall_0x14f760; // 0x151220 - g_ps2RecompiledFunctionTable[83079] = bhCheckL2Wall_0x14f760; // 0x151224 - g_ps2RecompiledFunctionTable[83080] = bhCheckL2Wall_0x14f760; // 0x151228 - g_ps2RecompiledFunctionTable[83081] = bhCheckL2Wall_0x14f760; // 0x15122c - g_ps2RecompiledFunctionTable[83082] = bhCheckL2Wall_0x14f760; // 0x151230 - g_ps2RecompiledFunctionTable[83083] = bhCheckL2Wall_0x14f760; // 0x151234 - g_ps2RecompiledFunctionTable[83084] = bhCheckL2Wall_0x14f760; // 0x151238 - g_ps2RecompiledFunctionTable[83085] = bhCheckL2Wall_0x14f760; // 0x15123c - g_ps2RecompiledFunctionTable[83086] = bhCheckL2Wall_0x14f760; // 0x151240 - g_ps2RecompiledFunctionTable[83087] = bhCheckL2Wall_0x14f760; // 0x151244 - g_ps2RecompiledFunctionTable[83088] = bhCheckL2Wall_0x14f760; // 0x151248 - g_ps2RecompiledFunctionTable[83089] = bhCheckL2Wall_0x14f760; // 0x15124c - g_ps2RecompiledFunctionTable[83090] = bhCheckL2Wall_0x14f760; // 0x151250 - g_ps2RecompiledFunctionTable[83091] = bhCheckL2Wall_0x14f760; // 0x151254 - g_ps2RecompiledFunctionTable[83092] = bhCheckL2Wall_0x14f760; // 0x151258 - g_ps2RecompiledFunctionTable[83093] = bhCheckL2Wall_0x14f760; // 0x15125c - g_ps2RecompiledFunctionTable[83094] = bhCheckL2Wall_0x14f760; // 0x151260 - g_ps2RecompiledFunctionTable[83095] = bhCheckL2Wall_0x14f760; // 0x151264 - g_ps2RecompiledFunctionTable[83096] = bhCheckL2Wall_0x14f760; // 0x151268 - g_ps2RecompiledFunctionTable[83097] = bhCheckL2Wall_0x14f760; // 0x15126c - g_ps2RecompiledFunctionTable[83098] = bhCheckL2Wall_0x14f760; // 0x151270 - g_ps2RecompiledFunctionTable[83099] = bhCheckL2Wall_0x14f760; // 0x151274 - g_ps2RecompiledFunctionTable[83100] = bhCheckL2Wall_0x14f760; // 0x151278 - g_ps2RecompiledFunctionTable[83101] = bhCheckL2Wall_0x14f760; // 0x15127c - g_ps2RecompiledFunctionTable[83102] = bhCheckL2Wall_0x14f760; // 0x151280 - g_ps2RecompiledFunctionTable[83103] = bhCheckL2Wall_0x14f760; // 0x151284 - g_ps2RecompiledFunctionTable[83104] = bhCheckL2Wall_0x14f760; // 0x151288 - g_ps2RecompiledFunctionTable[83105] = bhCheckL2Wall_0x14f760; // 0x15128c - g_ps2RecompiledFunctionTable[83106] = bhCheckL2Wall_0x14f760; // 0x151290 - g_ps2RecompiledFunctionTable[83107] = bhCheckL2Wall_0x14f760; // 0x151294 - g_ps2RecompiledFunctionTable[83108] = bhCheckL2Wall_0x14f760; // 0x151298 - g_ps2RecompiledFunctionTable[83109] = bhCheckL2Wall_0x14f760; // 0x15129c - g_ps2RecompiledFunctionTable[83110] = bhCheckL2Wall_0x14f760; // 0x1512a0 - g_ps2RecompiledFunctionTable[83111] = bhCheckL2Wall_0x14f760; // 0x1512a4 - g_ps2RecompiledFunctionTable[83112] = bhCheckL2Wall_0x14f760; // 0x1512a8 - g_ps2RecompiledFunctionTable[83113] = bhCheckL2Wall_0x14f760; // 0x1512ac - g_ps2RecompiledFunctionTable[83114] = bhCheckL2Wall_0x14f760; // 0x1512b0 - g_ps2RecompiledFunctionTable[83115] = bhCheckL2Wall_0x14f760; // 0x1512b4 - g_ps2RecompiledFunctionTable[83116] = bhCheckL2Wall_0x14f760; // 0x1512b8 - g_ps2RecompiledFunctionTable[83117] = bhCheckL2Wall_0x14f760; // 0x1512bc - g_ps2RecompiledFunctionTable[83118] = bhCheckL2Wall_0x14f760; // 0x1512c0 - g_ps2RecompiledFunctionTable[83119] = bhCheckL2Wall_0x14f760; // 0x1512c4 - g_ps2RecompiledFunctionTable[83120] = bhCheckL2Wall_0x14f760; // 0x1512c8 - g_ps2RecompiledFunctionTable[83121] = bhCheckL2Wall_0x14f760; // 0x1512cc - g_ps2RecompiledFunctionTable[83122] = bhCheckL2Wall_0x14f760; // 0x1512d0 - g_ps2RecompiledFunctionTable[83123] = bhCheckL2Wall_0x14f760; // 0x1512d4 - g_ps2RecompiledFunctionTable[83124] = bhCheckL2Wall_0x14f760; // 0x1512d8 - g_ps2RecompiledFunctionTable[83125] = bhCheckL2Wall_0x14f760; // 0x1512dc - g_ps2RecompiledFunctionTable[83126] = bhCheckL2Wall_0x14f760; // 0x1512e0 - g_ps2RecompiledFunctionTable[83127] = bhCheckL2Wall_0x14f760; // 0x1512e4 - g_ps2RecompiledFunctionTable[83128] = bhCheckL2Wall_0x14f760; // 0x1512e8 - g_ps2RecompiledFunctionTable[83129] = bhCheckL2Wall_0x14f760; // 0x1512ec - g_ps2RecompiledFunctionTable[83130] = bhCheckL2Wall_0x14f760; // 0x1512f0 - g_ps2RecompiledFunctionTable[83131] = bhCheckL2Wall_0x14f760; // 0x1512f4 - g_ps2RecompiledFunctionTable[83132] = bhCheckL2Wall_0x14f760; // 0x1512f8 - g_ps2RecompiledFunctionTable[83133] = bhCheckL2Wall_0x14f760; // 0x1512fc - g_ps2RecompiledFunctionTable[83134] = bhCheckL2Wall_0x14f760; // 0x151300 - g_ps2RecompiledFunctionTable[83135] = bhCheckL2Wall_0x14f760; // 0x151304 - g_ps2RecompiledFunctionTable[83136] = bhCheckL2Wall_0x14f760; // 0x151308 - g_ps2RecompiledFunctionTable[83137] = bhCheckL2Wall_0x14f760; // 0x15130c - g_ps2RecompiledFunctionTable[83138] = bhCheckL2Wall_0x14f760; // 0x151310 - g_ps2RecompiledFunctionTable[83139] = bhCheckL2Wall_0x14f760; // 0x151314 - g_ps2RecompiledFunctionTable[83140] = bhCheckL2Wall_0x14f760; // 0x151318 - g_ps2RecompiledFunctionTable[83141] = bhCheckL2Wall_0x14f760; // 0x15131c - g_ps2RecompiledFunctionTable[83142] = bhCheckL2Wall_0x14f760; // 0x151320 - g_ps2RecompiledFunctionTable[83143] = bhCheckL2Wall_0x14f760; // 0x151324 - g_ps2RecompiledFunctionTable[83144] = bhCheckL2Wall_0x14f760; // 0x151328 - g_ps2RecompiledFunctionTable[83145] = bhCheckL2Wall_0x14f760; // 0x15132c - g_ps2RecompiledFunctionTable[83146] = bhCheckL2Wall_0x14f760; // 0x151330 - g_ps2RecompiledFunctionTable[83147] = bhCheckL2Wall_0x14f760; // 0x151334 - g_ps2RecompiledFunctionTable[83148] = bhCheckL2Wall_0x14f760; // 0x151338 - g_ps2RecompiledFunctionTable[83149] = bhCheckL2Wall_0x14f760; // 0x15133c - g_ps2RecompiledFunctionTable[83150] = bhCheckL2Wall_0x14f760; // 0x151340 - g_ps2RecompiledFunctionTable[83151] = bhCheckL2Wall_0x14f760; // 0x151344 - g_ps2RecompiledFunctionTable[83152] = bhCheckL2Wall_0x14f760; // 0x151348 - g_ps2RecompiledFunctionTable[83153] = bhCheckL2Wall_0x14f760; // 0x15134c - g_ps2RecompiledFunctionTable[83154] = bhCheckL2Wall_0x14f760; // 0x151350 - g_ps2RecompiledFunctionTable[83155] = bhCheckL2Wall_0x14f760; // 0x151354 - g_ps2RecompiledFunctionTable[83156] = bhCheckL2Wall_0x14f760; // 0x151358 - g_ps2RecompiledFunctionTable[83157] = bhCheckL2Wall_0x14f760; // 0x15135c - g_ps2RecompiledFunctionTable[83158] = bhCheckL2Wall_0x14f760; // 0x151360 - g_ps2RecompiledFunctionTable[83159] = bhCheckL2Wall_0x14f760; // 0x151364 - g_ps2RecompiledFunctionTable[83160] = bhCheckL2Wall_0x14f760; // 0x151368 - g_ps2RecompiledFunctionTable[83161] = bhCheckL2Wall_0x14f760; // 0x15136c - g_ps2RecompiledFunctionTable[83162] = bhCheckL2Wall_0x14f760; // 0x151370 - g_ps2RecompiledFunctionTable[83163] = bhCheckL2Wall_0x14f760; // 0x151374 - g_ps2RecompiledFunctionTable[83164] = bhCheckL2Wall_0x14f760; // 0x151378 - g_ps2RecompiledFunctionTable[83165] = bhCheckL2Wall_0x14f760; // 0x15137c - g_ps2RecompiledFunctionTable[83166] = bhCheckL2Wall_0x14f760; // 0x151380 - g_ps2RecompiledFunctionTable[83167] = bhCheckL2Wall_0x14f760; // 0x151384 - g_ps2RecompiledFunctionTable[83168] = bhCheckL2Wall_0x14f760; // 0x151388 - g_ps2RecompiledFunctionTable[83169] = bhCheckL2Wall_0x14f760; // 0x15138c - g_ps2RecompiledFunctionTable[83170] = bhCheckL2Wall_0x14f760; // 0x151390 - g_ps2RecompiledFunctionTable[83171] = bhCheckL2Wall_0x14f760; // 0x151394 - g_ps2RecompiledFunctionTable[83172] = bhCheckL2Wall_0x14f760; // 0x151398 - g_ps2RecompiledFunctionTable[83173] = bhCheckL2Wall_0x14f760; // 0x15139c - g_ps2RecompiledFunctionTable[83174] = bhCheckL2Wall_0x14f760; // 0x1513a0 - g_ps2RecompiledFunctionTable[83175] = bhCheckL2Wall_0x14f760; // 0x1513a4 - g_ps2RecompiledFunctionTable[83176] = bhCheckL2Wall_0x14f760; // 0x1513a8 - g_ps2RecompiledFunctionTable[83177] = bhCheckL2Wall_0x14f760; // 0x1513ac - g_ps2RecompiledFunctionTable[83178] = bhCheckL2Wall_0x14f760; // 0x1513b0 - g_ps2RecompiledFunctionTable[83179] = bhCheckL2Wall_0x14f760; // 0x1513b4 - g_ps2RecompiledFunctionTable[83180] = bhCheckL2Wall_0x14f760; // 0x1513b8 - g_ps2RecompiledFunctionTable[83181] = bhCheckL2Wall_0x14f760; // 0x1513bc - g_ps2RecompiledFunctionTable[83182] = bhCheckL2Wall_0x14f760; // 0x1513c0 - g_ps2RecompiledFunctionTable[83183] = bhCheckL2Wall_0x14f760; // 0x1513c4 - g_ps2RecompiledFunctionTable[83184] = bhCheckL2Wall_0x14f760; // 0x1513c8 - g_ps2RecompiledFunctionTable[83185] = bhCheckL2Wall_0x14f760; // 0x1513cc - g_ps2RecompiledFunctionTable[83186] = bhCheckL2Wall_0x14f760; // 0x1513d0 - g_ps2RecompiledFunctionTable[83187] = bhCheckL2Wall_0x14f760; // 0x1513d4 - g_ps2RecompiledFunctionTable[83188] = bhCheckL2Wall_0x14f760; // 0x1513d8 - g_ps2RecompiledFunctionTable[83189] = bhCheckL2Wall_0x14f760; // 0x1513dc - g_ps2RecompiledFunctionTable[83190] = bhCheckL2Wall_0x14f760; // 0x1513e0 - g_ps2RecompiledFunctionTable[83191] = bhCheckL2Wall_0x14f760; // 0x1513e4 - g_ps2RecompiledFunctionTable[83192] = bhCheckL2Wall_0x14f760; // 0x1513e8 - g_ps2RecompiledFunctionTable[83193] = bhCheckL2Wall_0x14f760; // 0x1513ec - g_ps2RecompiledFunctionTable[83194] = bhCheckL2Wall_0x14f760; // 0x1513f0 - g_ps2RecompiledFunctionTable[83195] = bhCheckL2Wall_0x14f760; // 0x1513f4 - g_ps2RecompiledFunctionTable[83196] = bhCheckL2Wall_0x14f760; // 0x1513f8 - g_ps2RecompiledFunctionTable[83197] = bhCheckL2Wall_0x14f760; // 0x1513fc - g_ps2RecompiledFunctionTable[83198] = bhCheckL2Wall_0x14f760; // 0x151400 - g_ps2RecompiledFunctionTable[83199] = bhCheckL2Wall_0x14f760; // 0x151404 - g_ps2RecompiledFunctionTable[83200] = bhCheckL2Wall_0x14f760; // 0x151408 - g_ps2RecompiledFunctionTable[83201] = bhCheckL2Wall_0x14f760; // 0x15140c - g_ps2RecompiledFunctionTable[83202] = bhCheckL2Wall_0x14f760; // 0x151410 - g_ps2RecompiledFunctionTable[83203] = bhCheckL2Wall_0x14f760; // 0x151414 - g_ps2RecompiledFunctionTable[83204] = bhCheckL2Wall_0x14f760; // 0x151418 - g_ps2RecompiledFunctionTable[83205] = bhCheckL2Wall_0x14f760; // 0x15141c - g_ps2RecompiledFunctionTable[83206] = bhCheckL2Wall_0x14f760; // 0x151420 - g_ps2RecompiledFunctionTable[83207] = bhCheckL2Wall_0x14f760; // 0x151424 - g_ps2RecompiledFunctionTable[83208] = bhCheckL2Wall_0x14f760; // 0x151428 - g_ps2RecompiledFunctionTable[83209] = bhCheckL2Wall_0x14f760; // 0x15142c - g_ps2RecompiledFunctionTable[83210] = bhCheckL2Wall_0x14f760; // 0x151430 - g_ps2RecompiledFunctionTable[83211] = bhCheckL2Wall_0x14f760; // 0x151434 - g_ps2RecompiledFunctionTable[83212] = bhCheckL2Wall_0x14f760; // 0x151438 - g_ps2RecompiledFunctionTable[83213] = bhCheckL2Wall_0x14f760; // 0x15143c - g_ps2RecompiledFunctionTable[83214] = bhCheckL2Wall_0x14f760; // 0x151440 - g_ps2RecompiledFunctionTable[83215] = bhCheckL2Wall_0x14f760; // 0x151444 - g_ps2RecompiledFunctionTable[83216] = bhCheckL2Wall_0x14f760; // 0x151448 - g_ps2RecompiledFunctionTable[83217] = bhCheckL2Wall_0x14f760; // 0x15144c - g_ps2RecompiledFunctionTable[83218] = bhCheckL2Wall_0x14f760; // 0x151450 - g_ps2RecompiledFunctionTable[83219] = bhCheckL2Wall_0x14f760; // 0x151454 - g_ps2RecompiledFunctionTable[83220] = bhCheckL2Wall_0x14f760; // 0x151458 - g_ps2RecompiledFunctionTable[83221] = bhCheckL2Wall_0x14f760; // 0x15145c - g_ps2RecompiledFunctionTable[83222] = bhCheckL2Wall_0x14f760; // 0x151460 - g_ps2RecompiledFunctionTable[83223] = bhCheckL2Wall_0x14f760; // 0x151464 - g_ps2RecompiledFunctionTable[83224] = bhCheckL2Wall_0x14f760; // 0x151468 - g_ps2RecompiledFunctionTable[83225] = bhCheckL2Wall_0x14f760; // 0x15146c - g_ps2RecompiledFunctionTable[83226] = bhCheckL2Wall_0x14f760; // 0x151470 - g_ps2RecompiledFunctionTable[83227] = bhCheckL2Wall_0x14f760; // 0x151474 - g_ps2RecompiledFunctionTable[83228] = bhCheckL2Wall_0x14f760; // 0x151478 - g_ps2RecompiledFunctionTable[83229] = bhCheckL2Wall_0x14f760; // 0x15147c - g_ps2RecompiledFunctionTable[83230] = bhCheckL2Wall_0x14f760; // 0x151480 - g_ps2RecompiledFunctionTable[83231] = bhCheckL2Wall_0x14f760; // 0x151484 - g_ps2RecompiledFunctionTable[83232] = bhCheckL2Wall_0x14f760; // 0x151488 - g_ps2RecompiledFunctionTable[83233] = bhCheckL2Wall_0x14f760; // 0x15148c - g_ps2RecompiledFunctionTable[83234] = bhCheckL2Wall_0x14f760; // 0x151490 - g_ps2RecompiledFunctionTable[83235] = bhCheckL2Wall_0x14f760; // 0x151494 - g_ps2RecompiledFunctionTable[83236] = bhCheckL2Wall_0x14f760; // 0x151498 - g_ps2RecompiledFunctionTable[83237] = bhCheckL2Wall_0x14f760; // 0x15149c - g_ps2RecompiledFunctionTable[83238] = bhCheckL2Wall_0x14f760; // 0x1514a0 - g_ps2RecompiledFunctionTable[83239] = bhCheckL2Wall_0x14f760; // 0x1514a4 - g_ps2RecompiledFunctionTable[83240] = bhCheckL2Wall_0x14f760; // 0x1514a8 - g_ps2RecompiledFunctionTable[83241] = bhCheckL2Wall_0x14f760; // 0x1514ac - g_ps2RecompiledFunctionTable[83242] = bhCheckL2Wall_0x14f760; // 0x1514b0 - g_ps2RecompiledFunctionTable[83243] = bhCheckL2Wall_0x14f760; // 0x1514b4 - g_ps2RecompiledFunctionTable[83244] = bhCheckL2Wall_0x14f760; // 0x1514b8 - g_ps2RecompiledFunctionTable[83245] = bhCheckL2Wall_0x14f760; // 0x1514bc - g_ps2RecompiledFunctionTable[83246] = bhCheckL2Wall_0x14f760; // 0x1514c0 - g_ps2RecompiledFunctionTable[83247] = bhCheckL2Wall_0x14f760; // 0x1514c4 - g_ps2RecompiledFunctionTable[83248] = bhCheckL2Wall_0x14f760; // 0x1514c8 - g_ps2RecompiledFunctionTable[83249] = bhCheckL2Wall_0x14f760; // 0x1514cc - g_ps2RecompiledFunctionTable[83250] = bhCheckL2Wall_0x14f760; // 0x1514d0 - g_ps2RecompiledFunctionTable[83251] = bhCheckL2Wall_0x14f760; // 0x1514d4 - g_ps2RecompiledFunctionTable[83252] = bhCheckL2Wall_0x14f760; // 0x1514d8 - g_ps2RecompiledFunctionTable[83253] = bhCheckL2Wall_0x14f760; // 0x1514dc - g_ps2RecompiledFunctionTable[83254] = bhCheckL2Wall_0x14f760; // 0x1514e0 - g_ps2RecompiledFunctionTable[83255] = bhCheckL2Wall_0x14f760; // 0x1514e4 - g_ps2RecompiledFunctionTable[83256] = bhCheckL2Wall_0x14f760; // 0x1514e8 - g_ps2RecompiledFunctionTable[83257] = bhCheckL2Wall_0x14f760; // 0x1514ec - g_ps2RecompiledFunctionTable[83258] = bhCheckL2Wall_0x14f760; // 0x1514f0 - g_ps2RecompiledFunctionTable[83259] = bhCheckL2Wall_0x14f760; // 0x1514f4 - g_ps2RecompiledFunctionTable[83260] = bhCheckL2Wall_0x14f760; // 0x1514f8 - g_ps2RecompiledFunctionTable[83261] = bhCheckL2Wall_0x14f760; // 0x1514fc - g_ps2RecompiledFunctionTable[83262] = bhCheckL2Wall_0x14f760; // 0x151500 - g_ps2RecompiledFunctionTable[83263] = bhCheckL2Wall_0x14f760; // 0x151504 - g_ps2RecompiledFunctionTable[83264] = bhCheckL2Wall_0x14f760; // 0x151508 - g_ps2RecompiledFunctionTable[83265] = bhCheckL2Wall_0x14f760; // 0x15150c - g_ps2RecompiledFunctionTable[83266] = bhCheckL2Wall_0x14f760; // 0x151510 - g_ps2RecompiledFunctionTable[83267] = bhCheckL2Wall_0x14f760; // 0x151514 - g_ps2RecompiledFunctionTable[83268] = bhCheckL2Wall_0x14f760; // 0x151518 - g_ps2RecompiledFunctionTable[83269] = bhCheckL2Wall_0x14f760; // 0x15151c - g_ps2RecompiledFunctionTable[83270] = bhCheckL2Wall_0x14f760; // 0x151520 - g_ps2RecompiledFunctionTable[83271] = bhCheckL2Wall_0x14f760; // 0x151524 - g_ps2RecompiledFunctionTable[83272] = bhCheckL2Wall_0x14f760; // 0x151528 - g_ps2RecompiledFunctionTable[83273] = bhCheckL2Wall_0x14f760; // 0x15152c - g_ps2RecompiledFunctionTable[83274] = bhCheckL2Wall_0x14f760; // 0x151530 - g_ps2RecompiledFunctionTable[83275] = bhCheckL2Wall_0x14f760; // 0x151534 - g_ps2RecompiledFunctionTable[83276] = bhCheckL2Wall_0x14f760; // 0x151538 - g_ps2RecompiledFunctionTable[83277] = bhCheckL2Wall_0x14f760; // 0x15153c - g_ps2RecompiledFunctionTable[83278] = bhCheckL2Wall_0x14f760; // 0x151540 - g_ps2RecompiledFunctionTable[83279] = bhCheckL2Wall_0x14f760; // 0x151544 - g_ps2RecompiledFunctionTable[83280] = bhCheckL2Wall_0x14f760; // 0x151548 - g_ps2RecompiledFunctionTable[83281] = bhCheckL2Wall_0x14f760; // 0x15154c - g_ps2RecompiledFunctionTable[83282] = bhCheckL2Wall_0x14f760; // 0x151550 - g_ps2RecompiledFunctionTable[83283] = bhCheckL2Wall_0x14f760; // 0x151554 - g_ps2RecompiledFunctionTable[83284] = bhCheckL2Wall_0x14f760; // 0x151558 - g_ps2RecompiledFunctionTable[83285] = bhCheckL2Wall_0x14f760; // 0x15155c - g_ps2RecompiledFunctionTable[83286] = bhCheckL2Wall_0x14f760; // 0x151560 - g_ps2RecompiledFunctionTable[83287] = bhCheckL2Wall_0x14f760; // 0x151564 - g_ps2RecompiledFunctionTable[83288] = bhCheckL2Wall_0x14f760; // 0x151568 - g_ps2RecompiledFunctionTable[83289] = bhCheckL2Wall_0x14f760; // 0x15156c - g_ps2RecompiledFunctionTable[83290] = bhCheckL2Wall_0x14f760; // 0x151570 - g_ps2RecompiledFunctionTable[83291] = bhCheckL2Wall_0x14f760; // 0x151574 - g_ps2RecompiledFunctionTable[83292] = bhCheckL2Wall_0x14f760; // 0x151578 - g_ps2RecompiledFunctionTable[83293] = bhCheckL2Wall_0x14f760; // 0x15157c - g_ps2RecompiledFunctionTable[83294] = bhCheckL2Wall_0x14f760; // 0x151580 - g_ps2RecompiledFunctionTable[83295] = bhCheckL2Wall_0x14f760; // 0x151584 - g_ps2RecompiledFunctionTable[83296] = bhCheckL2Wall_0x14f760; // 0x151588 - g_ps2RecompiledFunctionTable[83297] = bhCheckL2Wall_0x14f760; // 0x15158c - g_ps2RecompiledFunctionTable[83298] = bhCheckL2Wall_0x14f760; // 0x151590 - g_ps2RecompiledFunctionTable[83299] = bhCheckL2Wall_0x14f760; // 0x151594 - g_ps2RecompiledFunctionTable[83300] = bhCheckL2Wall_0x14f760; // 0x151598 - g_ps2RecompiledFunctionTable[83301] = bhCheckL2Wall_0x14f760; // 0x15159c - g_ps2RecompiledFunctionTable[83302] = bhCheckL2Wall_0x14f760; // 0x1515a0 - g_ps2RecompiledFunctionTable[83303] = bhCheckL2Wall_0x14f760; // 0x1515a4 - g_ps2RecompiledFunctionTable[83304] = bhCheckL2Wall_0x14f760; // 0x1515a8 - g_ps2RecompiledFunctionTable[83305] = bhCheckL2Wall_0x14f760; // 0x1515ac - g_ps2RecompiledFunctionTable[83306] = bhCheckL2Wall_0x14f760; // 0x1515b0 - g_ps2RecompiledFunctionTable[83307] = bhCheckL2Wall_0x14f760; // 0x1515b4 - g_ps2RecompiledFunctionTable[83308] = bhCheckL2Wall_0x14f760; // 0x1515b8 - g_ps2RecompiledFunctionTable[83309] = bhCheckL2Wall_0x14f760; // 0x1515bc - g_ps2RecompiledFunctionTable[83310] = bhCheckL2Wall_0x14f760; // 0x1515c0 - g_ps2RecompiledFunctionTable[83311] = bhCheckL2Wall_0x14f760; // 0x1515c4 - g_ps2RecompiledFunctionTable[83312] = bhCheckL2Wall_0x14f760; // 0x1515c8 - g_ps2RecompiledFunctionTable[83313] = bhCheckL2Wall_0x14f760; // 0x1515cc - g_ps2RecompiledFunctionTable[83314] = bhCheckL2Wall_0x14f760; // 0x1515d0 - g_ps2RecompiledFunctionTable[83315] = bhCheckL2Wall_0x14f760; // 0x1515d4 - g_ps2RecompiledFunctionTable[83316] = bhCheckL2Wall_0x14f760; // 0x1515d8 - g_ps2RecompiledFunctionTable[83317] = bhCheckL2Wall_0x14f760; // 0x1515dc - g_ps2RecompiledFunctionTable[83318] = bhCheckL2Wall_0x14f760; // 0x1515e0 - g_ps2RecompiledFunctionTable[83319] = bhCheckL2Wall_0x14f760; // 0x1515e4 - g_ps2RecompiledFunctionTable[83320] = bhCheckL2Wall_0x14f760; // 0x1515e8 - g_ps2RecompiledFunctionTable[83321] = bhCheckL2Wall_0x14f760; // 0x1515ec - g_ps2RecompiledFunctionTable[83322] = bhCheckL2Wall_0x14f760; // 0x1515f0 - g_ps2RecompiledFunctionTable[83323] = bhCheckL2Wall_0x14f760; // 0x1515f4 - g_ps2RecompiledFunctionTable[83324] = bhCheckL2Wall_0x14f760; // 0x1515f8 - g_ps2RecompiledFunctionTable[83325] = bhCheckL2Wall_0x14f760; // 0x1515fc - g_ps2RecompiledFunctionTable[83326] = bhCheckL2Wall_0x14f760; // 0x151600 - g_ps2RecompiledFunctionTable[83327] = bhCheckL2Wall_0x14f760; // 0x151604 - g_ps2RecompiledFunctionTable[83328] = bhCheckL2Wall_0x14f760; // 0x151608 - g_ps2RecompiledFunctionTable[83329] = bhCheckL2Wall_0x14f760; // 0x15160c - g_ps2RecompiledFunctionTable[83330] = bhCheckL2Wall_0x14f760; // 0x151610 - g_ps2RecompiledFunctionTable[83331] = bhCheckL2Wall_0x14f760; // 0x151614 - g_ps2RecompiledFunctionTable[83332] = bhCheckL2Wall_0x14f760; // 0x151618 - g_ps2RecompiledFunctionTable[83333] = bhCheckL2Wall_0x14f760; // 0x15161c - g_ps2RecompiledFunctionTable[83334] = bhCheckL2Wall_0x14f760; // 0x151620 - g_ps2RecompiledFunctionTable[83335] = bhCheckL2Wall_0x14f760; // 0x151624 - g_ps2RecompiledFunctionTable[83336] = bhCheckL2Wall_0x14f760; // 0x151628 - g_ps2RecompiledFunctionTable[83337] = bhCheckL2Wall_0x14f760; // 0x15162c - g_ps2RecompiledFunctionTable[83338] = bhCheckL2Wall_0x14f760; // 0x151630 - g_ps2RecompiledFunctionTable[83339] = bhCheckL2Wall_0x14f760; // 0x151634 - g_ps2RecompiledFunctionTable[83340] = bhCheckL2Wall_0x14f760; // 0x151638 - g_ps2RecompiledFunctionTable[83341] = bhCheckL2Wall_0x14f760; // 0x15163c - g_ps2RecompiledFunctionTable[83342] = bhCheckL2Wall_0x14f760; // 0x151640 - g_ps2RecompiledFunctionTable[83343] = bhCheckL2Wall_0x14f760; // 0x151644 - g_ps2RecompiledFunctionTable[83344] = bhCheckL2Wall_0x14f760; // 0x151648 - g_ps2RecompiledFunctionTable[83345] = bhCheckL2Wall_0x14f760; // 0x15164c - g_ps2RecompiledFunctionTable[83346] = bhCheckL2Wall_0x14f760; // 0x151650 - g_ps2RecompiledFunctionTable[83347] = bhCheckL2Wall_0x14f760; // 0x151654 - g_ps2RecompiledFunctionTable[83348] = bhCheckL2Wall_0x14f760; // 0x151658 - g_ps2RecompiledFunctionTable[83349] = bhCheckL2Wall_0x14f760; // 0x15165c - g_ps2RecompiledFunctionTable[83350] = bhCheckL2Wall_0x14f760; // 0x151660 - g_ps2RecompiledFunctionTable[83351] = bhCheckL2Wall_0x14f760; // 0x151664 - g_ps2RecompiledFunctionTable[83352] = bhCheckL2Wall_0x14f760; // 0x151668 - g_ps2RecompiledFunctionTable[83353] = bhCheckL2Wall_0x14f760; // 0x15166c - g_ps2RecompiledFunctionTable[83354] = bhCheckL2Wall_0x14f760; // 0x151670 - g_ps2RecompiledFunctionTable[83355] = bhCheckL2Wall_0x14f760; // 0x151674 - g_ps2RecompiledFunctionTable[83356] = bhCheckL2Wall_0x14f760; // 0x151678 - g_ps2RecompiledFunctionTable[83357] = bhCheckL2Wall_0x14f760; // 0x15167c - g_ps2RecompiledFunctionTable[83358] = bhCheckL2Wall_0x14f760; // 0x151680 - g_ps2RecompiledFunctionTable[83359] = bhCheckL2Wall_0x14f760; // 0x151684 - g_ps2RecompiledFunctionTable[83360] = bhCheckL2Wall_0x14f760; // 0x151688 - g_ps2RecompiledFunctionTable[83361] = bhCheckL2Wall_0x14f760; // 0x15168c - g_ps2RecompiledFunctionTable[83362] = bhCheckL2Wall_0x14f760; // 0x151690 - g_ps2RecompiledFunctionTable[83363] = bhCheckL2Wall_0x14f760; // 0x151694 - g_ps2RecompiledFunctionTable[83364] = bhCheckL2Wall_0x14f760; // 0x151698 - g_ps2RecompiledFunctionTable[83365] = bhCheckL2Wall_0x14f760; // 0x15169c - g_ps2RecompiledFunctionTable[83366] = bhCheckL2Wall_0x14f760; // 0x1516a0 - g_ps2RecompiledFunctionTable[83367] = bhCheckL2Wall_0x14f760; // 0x1516a4 - g_ps2RecompiledFunctionTable[83368] = bhCheckL2Wall_0x14f760; // 0x1516a8 - g_ps2RecompiledFunctionTable[83369] = bhCheckL2Wall_0x14f760; // 0x1516ac - g_ps2RecompiledFunctionTable[83370] = bhCheckL2Wall_0x14f760; // 0x1516b0 - g_ps2RecompiledFunctionTable[83371] = bhCheckL2Wall_0x14f760; // 0x1516b4 - g_ps2RecompiledFunctionTable[83372] = bhCheckL2Wall_0x14f760; // 0x1516b8 - g_ps2RecompiledFunctionTable[83373] = bhCheckL2Wall_0x14f760; // 0x1516bc - g_ps2RecompiledFunctionTable[83374] = bhCheckL2Wall_0x14f760; // 0x1516c0 - g_ps2RecompiledFunctionTable[83375] = bhCheckL2Wall_0x14f760; // 0x1516c4 - g_ps2RecompiledFunctionTable[83376] = bhCheckL2Wall_0x14f760; // 0x1516c8 - g_ps2RecompiledFunctionTable[83377] = bhCheckL2Wall_0x14f760; // 0x1516cc - g_ps2RecompiledFunctionTable[83378] = bhCheckL2Wall_0x14f760; // 0x1516d0 - g_ps2RecompiledFunctionTable[83379] = bhCheckL2Wall_0x14f760; // 0x1516d4 - g_ps2RecompiledFunctionTable[83380] = bhCheckL2Wall_0x14f760; // 0x1516d8 - g_ps2RecompiledFunctionTable[83381] = bhCheckL2Wall_0x14f760; // 0x1516dc - g_ps2RecompiledFunctionTable[83382] = bhCheckL2Wall_0x14f760; // 0x1516e0 - g_ps2RecompiledFunctionTable[83383] = bhCheckL2Wall_0x14f760; // 0x1516e4 - g_ps2RecompiledFunctionTable[83384] = bhCheckL2Wall_0x14f760; // 0x1516e8 - g_ps2RecompiledFunctionTable[83385] = bhCheckL2Wall_0x14f760; // 0x1516ec - g_ps2RecompiledFunctionTable[83386] = bhCheckL2Wall_0x14f760; // 0x1516f0 - g_ps2RecompiledFunctionTable[83387] = bhCheckL2Wall_0x14f760; // 0x1516f4 - g_ps2RecompiledFunctionTable[83388] = bhCheckL2Wall_0x14f760; // 0x1516f8 - g_ps2RecompiledFunctionTable[83389] = bhCheckL2Wall_0x14f760; // 0x1516fc - g_ps2RecompiledFunctionTable[83390] = bhCheckL2Wall_0x14f760; // 0x151700 - g_ps2RecompiledFunctionTable[83391] = bhCheckL2Wall_0x14f760; // 0x151704 - g_ps2RecompiledFunctionTable[83392] = bhCheckL2Wall_0x14f760; // 0x151708 - g_ps2RecompiledFunctionTable[83393] = bhCheckL2Wall_0x14f760; // 0x15170c - g_ps2RecompiledFunctionTable[83394] = bhCheckL2Wall_0x14f760; // 0x151710 - g_ps2RecompiledFunctionTable[83395] = bhCheckL2Wall_0x14f760; // 0x151714 - g_ps2RecompiledFunctionTable[83396] = bhCheckL2Wall_0x14f760; // 0x151718 - g_ps2RecompiledFunctionTable[83397] = bhCheckL2Wall_0x14f760; // 0x15171c - g_ps2RecompiledFunctionTable[83398] = bhCheckL2Wall_0x14f760; // 0x151720 - g_ps2RecompiledFunctionTable[83399] = bhCheckL2Wall_0x14f760; // 0x151724 - g_ps2RecompiledFunctionTable[83400] = bhCheckL2Wall_0x14f760; // 0x151728 - g_ps2RecompiledFunctionTable[83401] = bhCheckL2Wall_0x14f760; // 0x15172c - g_ps2RecompiledFunctionTable[83402] = bhCheckL2Wall_0x14f760; // 0x151730 - g_ps2RecompiledFunctionTable[83403] = bhCheckL2Wall_0x14f760; // 0x151734 - g_ps2RecompiledFunctionTable[83404] = bhCheckL2Wall_0x14f760; // 0x151738 - g_ps2RecompiledFunctionTable[83405] = bhCheckL2Wall_0x14f760; // 0x15173c - g_ps2RecompiledFunctionTable[83406] = bhCheckL2Wall_0x14f760; // 0x151740 - g_ps2RecompiledFunctionTable[83407] = bhCheckL2Wall_0x14f760; // 0x151744 - g_ps2RecompiledFunctionTable[83408] = bhCheckL2Wall_0x14f760; // 0x151748 - g_ps2RecompiledFunctionTable[83409] = bhCheckL2Wall_0x14f760; // 0x15174c - g_ps2RecompiledFunctionTable[83410] = bhCheckL2Wall_0x14f760; // 0x151750 - g_ps2RecompiledFunctionTable[83411] = bhCheckL2Wall_0x14f760; // 0x151754 - g_ps2RecompiledFunctionTable[83412] = bhCheckL2Wall_0x14f760; // 0x151758 - g_ps2RecompiledFunctionTable[83413] = bhCheckL2Wall_0x14f760; // 0x15175c - g_ps2RecompiledFunctionTable[83414] = bhCheckL2Wall_0x14f760; // 0x151760 - g_ps2RecompiledFunctionTable[83415] = bhCheckL2Wall_0x14f760; // 0x151764 - g_ps2RecompiledFunctionTable[83416] = bhCheckL2Wall_0x14f760; // 0x151768 - g_ps2RecompiledFunctionTable[83417] = bhCheckL2Wall_0x14f760; // 0x15176c - g_ps2RecompiledFunctionTable[83418] = bhCheckL2Wall_0x14f760; // 0x151770 - g_ps2RecompiledFunctionTable[83419] = bhCheckL2Wall_0x14f760; // 0x151774 - g_ps2RecompiledFunctionTable[83420] = bhCheckL2Wall_0x14f760; // 0x151778 - g_ps2RecompiledFunctionTable[83421] = bhCheckL2Wall_0x14f760; // 0x15177c - g_ps2RecompiledFunctionTable[83422] = bhCheckL2Wall_0x14f760; // 0x151780 - g_ps2RecompiledFunctionTable[83423] = bhCheckL2Wall_0x14f760; // 0x151784 - g_ps2RecompiledFunctionTable[83424] = bhCheckL2Wall_0x14f760; // 0x151788 - g_ps2RecompiledFunctionTable[83425] = bhCheckL2Wall_0x14f760; // 0x15178c - g_ps2RecompiledFunctionTable[83426] = bhCheckL2Wall_0x14f760; // 0x151790 - g_ps2RecompiledFunctionTable[83427] = bhCheckL2Wall_0x14f760; // 0x151794 - g_ps2RecompiledFunctionTable[83428] = bhCheckL2Wall_0x14f760; // 0x151798 - g_ps2RecompiledFunctionTable[83429] = bhCheckL2Wall_0x14f760; // 0x15179c - g_ps2RecompiledFunctionTable[83430] = bhCheckL2Wall_0x14f760; // 0x1517a0 - g_ps2RecompiledFunctionTable[83431] = bhCheckL2Wall_0x14f760; // 0x1517a4 - g_ps2RecompiledFunctionTable[83432] = bhCheckL2Wall_0x14f760; // 0x1517a8 - g_ps2RecompiledFunctionTable[83433] = bhCheckL2Wall_0x14f760; // 0x1517ac - g_ps2RecompiledFunctionTable[83434] = bhCheckL2Wall_0x14f760; // 0x1517b0 - g_ps2RecompiledFunctionTable[83435] = bhCheckL2Wall_0x14f760; // 0x1517b4 - g_ps2RecompiledFunctionTable[83436] = bhCheckL2Wall_0x14f760; // 0x1517b8 - g_ps2RecompiledFunctionTable[83437] = bhCheckL2Wall_0x14f760; // 0x1517bc - g_ps2RecompiledFunctionTable[83438] = bhCheckL2Wall_0x14f760; // 0x1517c0 - g_ps2RecompiledFunctionTable[83439] = bhCheckL2Wall_0x14f760; // 0x1517c4 - g_ps2RecompiledFunctionTable[83440] = bhCheckL2Wall_0x14f760; // 0x1517c8 - g_ps2RecompiledFunctionTable[83441] = bhCheckL2Wall_0x14f760; // 0x1517cc - g_ps2RecompiledFunctionTable[83442] = bhCheckL2Wall_0x14f760; // 0x1517d0 - g_ps2RecompiledFunctionTable[83443] = bhCheckL2Wall_0x14f760; // 0x1517d4 - g_ps2RecompiledFunctionTable[83444] = bhCheckL2Wall_0x14f760; // 0x1517d8 - g_ps2RecompiledFunctionTable[83445] = bhCheckL2Wall_0x14f760; // 0x1517dc - g_ps2RecompiledFunctionTable[83446] = bhCheckL2Wall_0x14f760; // 0x1517e0 - g_ps2RecompiledFunctionTable[83447] = bhCheckL2Wall_0x14f760; // 0x1517e4 - g_ps2RecompiledFunctionTable[83448] = bhCheckL2Wall_0x14f760; // 0x1517e8 - g_ps2RecompiledFunctionTable[83449] = bhCheckL2Wall_0x14f760; // 0x1517ec - g_ps2RecompiledFunctionTable[83450] = bhCheckL2Wall_0x14f760; // 0x1517f0 - g_ps2RecompiledFunctionTable[83451] = bhCheckL2Wall_0x14f760; // 0x1517f4 - g_ps2RecompiledFunctionTable[83452] = bhCheckL2Wall_0x14f760; // 0x1517f8 - g_ps2RecompiledFunctionTable[83453] = bhCheckL2Wall_0x14f760; // 0x1517fc - g_ps2RecompiledFunctionTable[83454] = bhCheckL2Wall_0x14f760; // 0x151800 - g_ps2RecompiledFunctionTable[83455] = bhCheckL2Wall_0x14f760; // 0x151804 - g_ps2RecompiledFunctionTable[83456] = bhCheckL2Wall_0x14f760; // 0x151808 - g_ps2RecompiledFunctionTable[83457] = bhCheckL2Wall_0x14f760; // 0x15180c - g_ps2RecompiledFunctionTable[83458] = bhCheckL2Wall_0x14f760; // 0x151810 - g_ps2RecompiledFunctionTable[83459] = bhCheckL2Wall_0x14f760; // 0x151814 - g_ps2RecompiledFunctionTable[83460] = bhCheckL2Wall_0x14f760; // 0x151818 - g_ps2RecompiledFunctionTable[83461] = bhCheckL2Wall_0x14f760; // 0x15181c - g_ps2RecompiledFunctionTable[83462] = bhCheckL2Wall_0x14f760; // 0x151820 - g_ps2RecompiledFunctionTable[83463] = bhCheckL2Wall_0x14f760; // 0x151824 - g_ps2RecompiledFunctionTable[83464] = bhCheckL2Wall_0x14f760; // 0x151828 - g_ps2RecompiledFunctionTable[83465] = bhCheckL2Wall_0x14f760; // 0x15182c - g_ps2RecompiledFunctionTable[83466] = bhCheckL2Wall_0x14f760; // 0x151830 - g_ps2RecompiledFunctionTable[83467] = bhCheckL2Wall_0x14f760; // 0x151834 - g_ps2RecompiledFunctionTable[83468] = bhCheckL2Wall_0x14f760; // 0x151838 - g_ps2RecompiledFunctionTable[83469] = bhCheckL2Wall_0x14f760; // 0x15183c - g_ps2RecompiledFunctionTable[83470] = bhCheckL2Wall_0x14f760; // 0x151840 - g_ps2RecompiledFunctionTable[83471] = bhCheckL2Wall_0x14f760; // 0x151844 - g_ps2RecompiledFunctionTable[83472] = bhCheckL2Wall_0x14f760; // 0x151848 - g_ps2RecompiledFunctionTable[83473] = bhCheckL2Wall_0x14f760; // 0x15184c - g_ps2RecompiledFunctionTable[83474] = bhCheckL2Wall_0x14f760; // 0x151850 - g_ps2RecompiledFunctionTable[83475] = bhCheckL2Wall_0x14f760; // 0x151854 - g_ps2RecompiledFunctionTable[83476] = bhCheckL2Wall_0x14f760; // 0x151858 - g_ps2RecompiledFunctionTable[83477] = bhCheckL2Wall_0x14f760; // 0x15185c - g_ps2RecompiledFunctionTable[83478] = bhCheckL2Wall_0x14f760; // 0x151860 - g_ps2RecompiledFunctionTable[83479] = bhCheckL2Wall_0x14f760; // 0x151864 - g_ps2RecompiledFunctionTable[83480] = bhCheckL2Wall_0x14f760; // 0x151868 - g_ps2RecompiledFunctionTable[83481] = bhCheckL2Wall_0x14f760; // 0x15186c - g_ps2RecompiledFunctionTable[83482] = bhCheckL2Wall_0x14f760; // 0x151870 - g_ps2RecompiledFunctionTable[83483] = bhCheckL2Wall_0x14f760; // 0x151874 - g_ps2RecompiledFunctionTable[83484] = bhCheckL2Wall_0x14f760; // 0x151878 - g_ps2RecompiledFunctionTable[83485] = bhCheckL2Wall_0x14f760; // 0x15187c - g_ps2RecompiledFunctionTable[83486] = bhCheckL2Wall_0x14f760; // 0x151880 - g_ps2RecompiledFunctionTable[83487] = bhCheckL2Wall_0x14f760; // 0x151884 - g_ps2RecompiledFunctionTable[83488] = bhCheckL2Wall_0x14f760; // 0x151888 - g_ps2RecompiledFunctionTable[83489] = bhCheckL2Wall_0x14f760; // 0x15188c - g_ps2RecompiledFunctionTable[83490] = bhCheckL2Wall_0x14f760; // 0x151890 - g_ps2RecompiledFunctionTable[83491] = bhCheckL2Wall_0x14f760; // 0x151894 - g_ps2RecompiledFunctionTable[83492] = bhCheckL2Wall_0x14f760; // 0x151898 - g_ps2RecompiledFunctionTable[83493] = bhCheckL2Wall_0x14f760; // 0x15189c - g_ps2RecompiledFunctionTable[83494] = bhCheckL2Wall_0x14f760; // 0x1518a0 - g_ps2RecompiledFunctionTable[83495] = bhCheckL2Wall_0x14f760; // 0x1518a4 - g_ps2RecompiledFunctionTable[83496] = bhCheckL2Wall_0x14f760; // 0x1518a8 - g_ps2RecompiledFunctionTable[83497] = bhCheckL2Wall_0x14f760; // 0x1518ac - g_ps2RecompiledFunctionTable[83498] = bhCheckL2Wall_0x14f760; // 0x1518b0 - g_ps2RecompiledFunctionTable[83499] = bhCheckL2Wall_0x14f760; // 0x1518b4 - g_ps2RecompiledFunctionTable[83500] = bhCheckL2Wall_0x14f760; // 0x1518b8 - g_ps2RecompiledFunctionTable[83501] = bhCheckL2Wall_0x14f760; // 0x1518bc - g_ps2RecompiledFunctionTable[83502] = bhCheckL2Wall_0x14f760; // 0x1518c0 - g_ps2RecompiledFunctionTable[83503] = bhCheckL2Wall_0x14f760; // 0x1518c4 - g_ps2RecompiledFunctionTable[83504] = bhCheckL2Wall_0x14f760; // 0x1518c8 - g_ps2RecompiledFunctionTable[83505] = bhCheckL2Wall_0x14f760; // 0x1518cc - g_ps2RecompiledFunctionTable[83506] = bhCheckL2Wall_0x14f760; // 0x1518d0 - g_ps2RecompiledFunctionTable[83507] = bhCheckL2Wall_0x14f760; // 0x1518d4 - g_ps2RecompiledFunctionTable[83508] = bhCheckL2Wall_0x14f760; // 0x1518d8 - g_ps2RecompiledFunctionTable[83509] = bhCheckL2Wall_0x14f760; // 0x1518dc - g_ps2RecompiledFunctionTable[83510] = bhCheckL2Wall_0x14f760; // 0x1518e0 - g_ps2RecompiledFunctionTable[83511] = bhCheckL2Wall_0x14f760; // 0x1518e4 - g_ps2RecompiledFunctionTable[83512] = bhCheckL2Wall_0x14f760; // 0x1518e8 - g_ps2RecompiledFunctionTable[83513] = bhCheckL2Wall_0x14f760; // 0x1518ec - g_ps2RecompiledFunctionTable[83514] = bhCheckL2Wall_0x14f760; // 0x1518f0 - g_ps2RecompiledFunctionTable[83515] = bhCheckL2Wall_0x14f760; // 0x1518f4 - g_ps2RecompiledFunctionTable[83516] = bhCheckL2Wall_0x14f760; // 0x1518f8 - g_ps2RecompiledFunctionTable[83517] = bhCheckL2Wall_0x14f760; // 0x1518fc - g_ps2RecompiledFunctionTable[83518] = bhCheckL2Wall_0x14f760; // 0x151900 - g_ps2RecompiledFunctionTable[83519] = bhCheckL2Wall_0x14f760; // 0x151904 - g_ps2RecompiledFunctionTable[83520] = bhCheckL2Wall_0x14f760; // 0x151908 - g_ps2RecompiledFunctionTable[83521] = bhCheckL2Wall_0x14f760; // 0x15190c - g_ps2RecompiledFunctionTable[83522] = bhCheckL2Wall_0x14f760; // 0x151910 - g_ps2RecompiledFunctionTable[83523] = bhCheckL2Wall_0x14f760; // 0x151914 - g_ps2RecompiledFunctionTable[83524] = bhCheckL2Wall_0x14f760; // 0x151918 - g_ps2RecompiledFunctionTable[83525] = bhCheckL2Wall_0x14f760; // 0x15191c - g_ps2RecompiledFunctionTable[83526] = bhCheckL2Wall_0x14f760; // 0x151920 - g_ps2RecompiledFunctionTable[83527] = bhCheckL2Wall_0x14f760; // 0x151924 - g_ps2RecompiledFunctionTable[83528] = bhCheckL2Wall_0x14f760; // 0x151928 - g_ps2RecompiledFunctionTable[83529] = bhCheckL2Wall_0x14f760; // 0x15192c - g_ps2RecompiledFunctionTable[83530] = bhCheckL2Wall_0x14f760; // 0x151930 - g_ps2RecompiledFunctionTable[83531] = bhCheckL2Wall_0x14f760; // 0x151934 - g_ps2RecompiledFunctionTable[83532] = bhCheckL2Wall_0x14f760; // 0x151938 - g_ps2RecompiledFunctionTable[83533] = bhCheckL2Wall_0x14f760; // 0x15193c - g_ps2RecompiledFunctionTable[83534] = bhCheckL2Wall_0x14f760; // 0x151940 - g_ps2RecompiledFunctionTable[83535] = bhCheckL2Wall_0x14f760; // 0x151944 - g_ps2RecompiledFunctionTable[83536] = bhCheckL2Wall_0x14f760; // 0x151948 - g_ps2RecompiledFunctionTable[83537] = bhCheckL2Wall_0x14f760; // 0x15194c - g_ps2RecompiledFunctionTable[83538] = bhCheckL2Wall_0x14f760; // 0x151950 - g_ps2RecompiledFunctionTable[83539] = bhCheckL2Wall_0x14f760; // 0x151954 - g_ps2RecompiledFunctionTable[83540] = bhCheckL2Wall_0x14f760; // 0x151958 - g_ps2RecompiledFunctionTable[83541] = bhCheckL2Wall_0x14f760; // 0x15195c - g_ps2RecompiledFunctionTable[83542] = bhCheckL2Wall_0x14f760; // 0x151960 - g_ps2RecompiledFunctionTable[83543] = bhCheckL2Wall_0x14f760; // 0x151964 - g_ps2RecompiledFunctionTable[83544] = bhCheckL2Wall_0x14f760; // 0x151968 - g_ps2RecompiledFunctionTable[83545] = bhCheckL2Wall_0x14f760; // 0x15196c - g_ps2RecompiledFunctionTable[83546] = bhCheckL2Wall_0x14f760; // 0x151970 - g_ps2RecompiledFunctionTable[83547] = bhCheckL2Wall_0x14f760; // 0x151974 - g_ps2RecompiledFunctionTable[83548] = bhCheckL2Wall_0x14f760; // 0x151978 - g_ps2RecompiledFunctionTable[83549] = bhCheckL2Wall_0x14f760; // 0x15197c - g_ps2RecompiledFunctionTable[83550] = bhCheckL2Wall_0x14f760; // 0x151980 - g_ps2RecompiledFunctionTable[83551] = bhCheckL2Wall_0x14f760; // 0x151984 - g_ps2RecompiledFunctionTable[83552] = bhCheckL2Wall_0x14f760; // 0x151988 - g_ps2RecompiledFunctionTable[83553] = bhCheckL2Wall_0x14f760; // 0x15198c - g_ps2RecompiledFunctionTable[83554] = bhCheckL2Wall_0x14f760; // 0x151990 - g_ps2RecompiledFunctionTable[83555] = bhCheckL2Wall_0x14f760; // 0x151994 - g_ps2RecompiledFunctionTable[83556] = bhCheckL2Wall_0x14f760; // 0x151998 - g_ps2RecompiledFunctionTable[83557] = bhCheckL2Wall_0x14f760; // 0x15199c - g_ps2RecompiledFunctionTable[83558] = bhCheckL2Wall_0x14f760; // 0x1519a0 - g_ps2RecompiledFunctionTable[83559] = bhCheckL2Wall_0x14f760; // 0x1519a4 - g_ps2RecompiledFunctionTable[83560] = bhCheckL2Wall_0x14f760; // 0x1519a8 - g_ps2RecompiledFunctionTable[83561] = bhCheckL2Wall_0x14f760; // 0x1519ac - g_ps2RecompiledFunctionTable[83562] = bhCheckL2Wall_0x14f760; // 0x1519b0 - g_ps2RecompiledFunctionTable[83563] = bhCheckL2Wall_0x14f760; // 0x1519b4 - g_ps2RecompiledFunctionTable[83564] = bhCheckL2Wall_0x14f760; // 0x1519b8 - g_ps2RecompiledFunctionTable[83565] = bhCheckL2Wall_0x14f760; // 0x1519bc - g_ps2RecompiledFunctionTable[83566] = bhCheckL2Wall_0x14f760; // 0x1519c0 - g_ps2RecompiledFunctionTable[83567] = bhCheckL2Wall_0x14f760; // 0x1519c4 - g_ps2RecompiledFunctionTable[83568] = bhCheckL2Wall_0x14f760; // 0x1519c8 - g_ps2RecompiledFunctionTable[83569] = bhCheckL2Wall_0x14f760; // 0x1519cc - g_ps2RecompiledFunctionTable[83570] = bhCheckL2Wall_0x14f760; // 0x1519d0 - g_ps2RecompiledFunctionTable[83571] = bhCheckL2Wall_0x14f760; // 0x1519d4 - g_ps2RecompiledFunctionTable[83572] = bhCheckL2Wall_0x14f760; // 0x1519d8 - g_ps2RecompiledFunctionTable[83573] = bhCheckL2Wall_0x14f760; // 0x1519dc - g_ps2RecompiledFunctionTable[83574] = bhCheckL2Wall_0x14f760; // 0x1519e0 - g_ps2RecompiledFunctionTable[83575] = bhCheckL2Wall_0x14f760; // 0x1519e4 - g_ps2RecompiledFunctionTable[83576] = bhCheckL2Wall_0x14f760; // 0x1519e8 - g_ps2RecompiledFunctionTable[83577] = bhCheckL2Wall_0x14f760; // 0x1519ec - g_ps2RecompiledFunctionTable[83578] = bhCheckL2Wall_0x14f760; // 0x1519f0 - g_ps2RecompiledFunctionTable[83579] = bhCheckL2Wall_0x14f760; // 0x1519f4 - g_ps2RecompiledFunctionTable[83580] = bhCheckL2Wall_0x14f760; // 0x1519f8 - g_ps2RecompiledFunctionTable[83581] = bhCheckL2Wall_0x14f760; // 0x1519fc - g_ps2RecompiledFunctionTable[83582] = bhCheckL2Wall_0x14f760; // 0x151a00 - g_ps2RecompiledFunctionTable[83583] = bhCheckL2Wall_0x14f760; // 0x151a04 - g_ps2RecompiledFunctionTable[83584] = bhCheckL2Wall_0x14f760; // 0x151a08 - g_ps2RecompiledFunctionTable[83585] = bhCheckL2Wall_0x14f760; // 0x151a0c - g_ps2RecompiledFunctionTable[83586] = bhCheckL2Wall_0x14f760; // 0x151a10 - g_ps2RecompiledFunctionTable[83587] = bhCheckL2Wall_0x14f760; // 0x151a14 - g_ps2RecompiledFunctionTable[83588] = bhCheckL2Wall_0x14f760; // 0x151a18 - g_ps2RecompiledFunctionTable[83589] = bhCheckL2Wall_0x14f760; // 0x151a1c - g_ps2RecompiledFunctionTable[83590] = bhCheckL2Wall_0x14f760; // 0x151a20 - g_ps2RecompiledFunctionTable[83591] = bhCheckL2Wall_0x14f760; // 0x151a24 - g_ps2RecompiledFunctionTable[83592] = bhCheckL2Wall_0x14f760; // 0x151a28 - g_ps2RecompiledFunctionTable[83593] = bhCheckL2Wall_0x14f760; // 0x151a2c - g_ps2RecompiledFunctionTable[83594] = bhCheckL2Wall_0x14f760; // 0x151a30 - g_ps2RecompiledFunctionTable[83595] = bhCheckL2Wall_0x14f760; // 0x151a34 - g_ps2RecompiledFunctionTable[83596] = bhCheckL2Wall_0x14f760; // 0x151a38 - g_ps2RecompiledFunctionTable[83597] = bhCheckL2Wall_0x14f760; // 0x151a3c - g_ps2RecompiledFunctionTable[83598] = bhCheckL2Wall_0x14f760; // 0x151a40 - g_ps2RecompiledFunctionTable[83599] = bhCheckL2Wall_0x14f760; // 0x151a44 - g_ps2RecompiledFunctionTable[83600] = bhCheckL2Wall_0x14f760; // 0x151a48 - g_ps2RecompiledFunctionTable[83601] = bhCheckL2Wall_0x14f760; // 0x151a4c - g_ps2RecompiledFunctionTable[83602] = bhCheckL2Wall_0x14f760; // 0x151a50 - g_ps2RecompiledFunctionTable[83603] = bhCheckL2Wall_0x14f760; // 0x151a54 - g_ps2RecompiledFunctionTable[83604] = bhCheckL2Wall_0x14f760; // 0x151a58 - g_ps2RecompiledFunctionTable[83605] = bhCheckL2Wall_0x14f760; // 0x151a5c - g_ps2RecompiledFunctionTable[83606] = bhCheckL2Wall_0x14f760; // 0x151a60 - g_ps2RecompiledFunctionTable[83607] = bhCheckL2Wall_0x14f760; // 0x151a64 - g_ps2RecompiledFunctionTable[83608] = bhCheckL2Wall_0x14f760; // 0x151a68 - g_ps2RecompiledFunctionTable[83609] = bhCheckL2Wall_0x14f760; // 0x151a6c - g_ps2RecompiledFunctionTable[83610] = bhCheckL2Wall_0x14f760; // 0x151a70 - g_ps2RecompiledFunctionTable[83611] = bhCheckL2Wall_0x14f760; // 0x151a74 - g_ps2RecompiledFunctionTable[83612] = bhCheckL2Wall_0x14f760; // 0x151a78 - g_ps2RecompiledFunctionTable[83613] = bhCheckL2Wall_0x14f760; // 0x151a7c - g_ps2RecompiledFunctionTable[83614] = bhCheckL2Wall_0x14f760; // 0x151a80 - g_ps2RecompiledFunctionTable[83615] = bhCheckL2Wall_0x14f760; // 0x151a84 - g_ps2RecompiledFunctionTable[83616] = bhCheckL2Wall_0x14f760; // 0x151a88 - g_ps2RecompiledFunctionTable[83617] = bhCheckL2Wall_0x14f760; // 0x151a8c - g_ps2RecompiledFunctionTable[83618] = bhCheckL2Wall_0x14f760; // 0x151a90 - g_ps2RecompiledFunctionTable[83619] = bhCheckL2Wall_0x14f760; // 0x151a94 - g_ps2RecompiledFunctionTable[83620] = bhCheckL2Wall_0x14f760; // 0x151a98 - g_ps2RecompiledFunctionTable[83621] = bhCheckL2Wall_0x14f760; // 0x151a9c - g_ps2RecompiledFunctionTable[83622] = bhCheckL2Wall_0x14f760; // 0x151aa0 - g_ps2RecompiledFunctionTable[83623] = bhCheckL2Wall_0x14f760; // 0x151aa4 - g_ps2RecompiledFunctionTable[83624] = bhCheckL2Wall_0x14f760; // 0x151aa8 - g_ps2RecompiledFunctionTable[83625] = bhCheckL2Wall_0x14f760; // 0x151aac - g_ps2RecompiledFunctionTable[83626] = bhCheckL2Wall_0x14f760; // 0x151ab0 - g_ps2RecompiledFunctionTable[83627] = bhCheckL2Wall_0x14f760; // 0x151ab4 - g_ps2RecompiledFunctionTable[83628] = bhCheckL2Wall_0x14f760; // 0x151ab8 - g_ps2RecompiledFunctionTable[83629] = bhCheckL2Wall_0x14f760; // 0x151abc - g_ps2RecompiledFunctionTable[83630] = bhCheckL2Wall_0x14f760; // 0x151ac0 - g_ps2RecompiledFunctionTable[83631] = bhCheckL2Wall_0x14f760; // 0x151ac4 - g_ps2RecompiledFunctionTable[83632] = bhCheckL2Wall_0x14f760; // 0x151ac8 - g_ps2RecompiledFunctionTable[83633] = bhCheckL2Wall_0x14f760; // 0x151acc - g_ps2RecompiledFunctionTable[83634] = bhCheckL2Wall_0x14f760; // 0x151ad0 - g_ps2RecompiledFunctionTable[83635] = bhCheckL2Wall_0x14f760; // 0x151ad4 - g_ps2RecompiledFunctionTable[83636] = bhCheckL2Wall_0x14f760; // 0x151ad8 - g_ps2RecompiledFunctionTable[83637] = bhCheckL2Wall_0x14f760; // 0x151adc - g_ps2RecompiledFunctionTable[83638] = bhCheckL2Wall_0x14f760; // 0x151ae0 - g_ps2RecompiledFunctionTable[83639] = bhCheckL2Wall_0x14f760; // 0x151ae4 - g_ps2RecompiledFunctionTable[83640] = bhCheckL2Wall_0x14f760; // 0x151ae8 - g_ps2RecompiledFunctionTable[83641] = bhCheckL2Wall_0x14f760; // 0x151aec - g_ps2RecompiledFunctionTable[83642] = bhCheckL2Wall_0x14f760; // 0x151af0 - g_ps2RecompiledFunctionTable[83643] = bhCheckL2Wall_0x14f760; // 0x151af4 - g_ps2RecompiledFunctionTable[83644] = bhCheckL2Wall_0x14f760; // 0x151af8 - g_ps2RecompiledFunctionTable[83645] = bhCheckL2Wall_0x14f760; // 0x151afc - g_ps2RecompiledFunctionTable[83646] = bhCheckL2Wall_0x14f760; // 0x151b00 - g_ps2RecompiledFunctionTable[83647] = bhCheckL2Wall_0x14f760; // 0x151b04 - g_ps2RecompiledFunctionTable[83648] = bhCheckL2Wall_0x14f760; // 0x151b08 - g_ps2RecompiledFunctionTable[83649] = bhCheckL2Wall_0x14f760; // 0x151b0c - g_ps2RecompiledFunctionTable[83650] = bhCheckL2Wall_0x14f760; // 0x151b10 - g_ps2RecompiledFunctionTable[83651] = bhCheckL2Wall_0x14f760; // 0x151b14 - g_ps2RecompiledFunctionTable[83652] = bhCheckL2Wall_0x14f760; // 0x151b18 - g_ps2RecompiledFunctionTable[83653] = bhCheckL2Wall_0x14f760; // 0x151b1c - g_ps2RecompiledFunctionTable[83654] = bhCheckL2Wall_0x14f760; // 0x151b20 - g_ps2RecompiledFunctionTable[83655] = bhCheckL2Wall_0x14f760; // 0x151b24 - g_ps2RecompiledFunctionTable[83656] = bhCheckL2Wall_0x14f760; // 0x151b28 - g_ps2RecompiledFunctionTable[83657] = bhCheckL2Wall_0x14f760; // 0x151b2c - g_ps2RecompiledFunctionTable[83658] = bhCheckL2Wall_0x14f760; // 0x151b30 - g_ps2RecompiledFunctionTable[83659] = bhCheckL2Wall_0x14f760; // 0x151b34 - g_ps2RecompiledFunctionTable[83660] = bhCheckL2Wall_0x14f760; // 0x151b38 - g_ps2RecompiledFunctionTable[83661] = bhCheckL2Wall_0x14f760; // 0x151b3c - g_ps2RecompiledFunctionTable[83662] = bhCheckL2Wall_0x14f760; // 0x151b40 - g_ps2RecompiledFunctionTable[83663] = bhCheckL2Wall_0x14f760; // 0x151b44 - g_ps2RecompiledFunctionTable[83664] = bhCheckL2Wall_0x14f760; // 0x151b48 - g_ps2RecompiledFunctionTable[83665] = bhCheckL2Wall_0x14f760; // 0x151b4c - g_ps2RecompiledFunctionTable[83666] = bhCheckL2Wall_0x14f760; // 0x151b50 - g_ps2RecompiledFunctionTable[83667] = bhCheckL2Wall_0x14f760; // 0x151b54 - g_ps2RecompiledFunctionTable[83668] = bhCheckL2Wall_0x14f760; // 0x151b58 - g_ps2RecompiledFunctionTable[83669] = bhCheckL2Wall_0x14f760; // 0x151b5c - g_ps2RecompiledFunctionTable[83670] = bhCheckL2Wall_0x14f760; // 0x151b60 - g_ps2RecompiledFunctionTable[83671] = bhCheckL2Wall_0x14f760; // 0x151b64 - g_ps2RecompiledFunctionTable[83672] = bhCheckL2Wall_0x14f760; // 0x151b68 - g_ps2RecompiledFunctionTable[83673] = bhCheckL2Wall_0x14f760; // 0x151b6c - g_ps2RecompiledFunctionTable[83674] = bhCheckL2Wall_0x14f760; // 0x151b70 - g_ps2RecompiledFunctionTable[83675] = bhCheckL2Wall_0x14f760; // 0x151b74 - g_ps2RecompiledFunctionTable[83676] = bhCheckL2Wall_0x14f760; // 0x151b78 - g_ps2RecompiledFunctionTable[83677] = bhCheckL2Wall_0x14f760; // 0x151b7c - g_ps2RecompiledFunctionTable[83678] = bhCheckL2Wall_0x14f760; // 0x151b80 - g_ps2RecompiledFunctionTable[83679] = bhCheckL2Wall_0x14f760; // 0x151b84 - g_ps2RecompiledFunctionTable[83680] = bhCheckL2Wall_0x14f760; // 0x151b88 - g_ps2RecompiledFunctionTable[83681] = bhCheckL2Wall_0x14f760; // 0x151b8c - g_ps2RecompiledFunctionTable[83682] = bhCheckL2Wall_0x14f760; // 0x151b90 - g_ps2RecompiledFunctionTable[83683] = bhCheckL2Wall_0x14f760; // 0x151b94 - g_ps2RecompiledFunctionTable[83684] = bhCheckL2Wall_0x14f760; // 0x151b98 - g_ps2RecompiledFunctionTable[83685] = bhCheckL2Wall_0x14f760; // 0x151b9c - g_ps2RecompiledFunctionTable[83686] = bhCheckL2Wall_0x14f760; // 0x151ba0 - g_ps2RecompiledFunctionTable[83687] = bhCheckL2Wall_0x14f760; // 0x151ba4 - g_ps2RecompiledFunctionTable[83688] = bhCheckL2Wall_0x14f760; // 0x151ba8 - g_ps2RecompiledFunctionTable[83689] = bhCheckL2Wall_0x14f760; // 0x151bac - g_ps2RecompiledFunctionTable[83690] = bhCheckL2Wall_0x14f760; // 0x151bb0 - g_ps2RecompiledFunctionTable[83691] = bhCheckL2Wall_0x14f760; // 0x151bb4 - g_ps2RecompiledFunctionTable[83692] = bhCheckL2Wall_0x14f760; // 0x151bb8 - g_ps2RecompiledFunctionTable[83693] = bhCheckL2Wall_0x14f760; // 0x151bbc - g_ps2RecompiledFunctionTable[83694] = bhCheckL2Wall_0x14f760; // 0x151bc0 - g_ps2RecompiledFunctionTable[83695] = bhCheckL2Wall_0x14f760; // 0x151bc4 - g_ps2RecompiledFunctionTable[83696] = bhCheckL2Wall_0x14f760; // 0x151bc8 - g_ps2RecompiledFunctionTable[83697] = bhCheckL2Wall_0x14f760; // 0x151bcc - g_ps2RecompiledFunctionTable[83698] = bhCheckL2Wall_0x14f760; // 0x151bd0 - g_ps2RecompiledFunctionTable[83699] = bhCheckL2Wall_0x14f760; // 0x151bd4 - g_ps2RecompiledFunctionTable[83700] = bhCheckL2Wall_0x14f760; // 0x151bd8 - g_ps2RecompiledFunctionTable[83701] = bhCheckL2Wall_0x14f760; // 0x151bdc - g_ps2RecompiledFunctionTable[83702] = bhCheckL2Wall_0x14f760; // 0x151be0 - g_ps2RecompiledFunctionTable[83703] = bhCheckL2Wall_0x14f760; // 0x151be4 - g_ps2RecompiledFunctionTable[83704] = bhCheckL2Wall_0x14f760; // 0x151be8 - g_ps2RecompiledFunctionTable[83705] = bhCheckL2Wall_0x14f760; // 0x151bec - g_ps2RecompiledFunctionTable[83706] = bhCheckL2Wall_0x14f760; // 0x151bf0 - g_ps2RecompiledFunctionTable[83707] = bhCheckL2Wall_0x14f760; // 0x151bf4 - g_ps2RecompiledFunctionTable[83708] = bhCheckL2Wall_0x14f760; // 0x151bf8 - g_ps2RecompiledFunctionTable[83709] = bhCheckL2Wall_0x14f760; // 0x151bfc - g_ps2RecompiledFunctionTable[83710] = bhCheckL2Wall_0x14f760; // 0x151c00 - g_ps2RecompiledFunctionTable[83711] = bhCheckL2Wall_0x14f760; // 0x151c04 - g_ps2RecompiledFunctionTable[83712] = bhCheckL2Wall_0x14f760; // 0x151c08 - g_ps2RecompiledFunctionTable[83713] = bhCheckL2Wall_0x14f760; // 0x151c0c - g_ps2RecompiledFunctionTable[83714] = bhCheckL2Wall_0x14f760; // 0x151c10 - g_ps2RecompiledFunctionTable[83715] = bhCheckL2Wall_0x14f760; // 0x151c14 - g_ps2RecompiledFunctionTable[83716] = bhCheckL2Wall_0x14f760; // 0x151c18 - g_ps2RecompiledFunctionTable[83717] = bhCheckL2Wall_0x14f760; // 0x151c1c - g_ps2RecompiledFunctionTable[83718] = bhCheckL2Wall_0x14f760; // 0x151c20 - g_ps2RecompiledFunctionTable[83719] = bhCheckL2Wall_0x14f760; // 0x151c24 - g_ps2RecompiledFunctionTable[83720] = bhCheckL2Wall_0x14f760; // 0x151c28 - g_ps2RecompiledFunctionTable[83721] = bhCheckL2Wall_0x14f760; // 0x151c2c - g_ps2RecompiledFunctionTable[83722] = bhCheckL2Wall_0x14f760; // 0x151c30 - g_ps2RecompiledFunctionTable[83723] = bhCheckL2Wall_0x14f760; // 0x151c34 - g_ps2RecompiledFunctionTable[83724] = bhCheckL2Wall_0x14f760; // 0x151c38 - g_ps2RecompiledFunctionTable[83725] = bhCheckL2Wall_0x14f760; // 0x151c3c - g_ps2RecompiledFunctionTable[83726] = bhCheckL2Wall_0x14f760; // 0x151c40 - g_ps2RecompiledFunctionTable[83727] = bhCheckL2Wall_0x14f760; // 0x151c44 - g_ps2RecompiledFunctionTable[83728] = bhCheckL2Wall_0x14f760; // 0x151c48 - g_ps2RecompiledFunctionTable[83729] = bhCheckL2Wall_0x14f760; // 0x151c4c - g_ps2RecompiledFunctionTable[83730] = bhCheckL2Wall_0x14f760; // 0x151c50 - g_ps2RecompiledFunctionTable[83731] = bhCheckL2Wall_0x14f760; // 0x151c54 - g_ps2RecompiledFunctionTable[83732] = bhCheckL2Wall_0x14f760; // 0x151c58 - g_ps2RecompiledFunctionTable[83733] = bhCheckL2Wall_0x14f760; // 0x151c5c - g_ps2RecompiledFunctionTable[83734] = bhCheckL2Wall_0x14f760; // 0x151c60 - g_ps2RecompiledFunctionTable[83735] = bhCheckL2Wall_0x14f760; // 0x151c64 - g_ps2RecompiledFunctionTable[83736] = bhCheckL2Wall_0x14f760; // 0x151c68 - g_ps2RecompiledFunctionTable[83737] = bhCheckL2Wall_0x14f760; // 0x151c6c - g_ps2RecompiledFunctionTable[83738] = bhCheckL2Wall_0x14f760; // 0x151c70 - g_ps2RecompiledFunctionTable[83739] = bhCheckL2Wall_0x14f760; // 0x151c74 - g_ps2RecompiledFunctionTable[83740] = bhCheckL2Wall_0x14f760; // 0x151c78 - g_ps2RecompiledFunctionTable[83741] = bhCheckL2Wall_0x14f760; // 0x151c7c - g_ps2RecompiledFunctionTable[83742] = bhCheckL2Wall_0x14f760; // 0x151c80 - g_ps2RecompiledFunctionTable[83743] = bhCheckL2Wall_0x14f760; // 0x151c84 - g_ps2RecompiledFunctionTable[83744] = bhCheckL2Wall_0x14f760; // 0x151c88 - g_ps2RecompiledFunctionTable[83745] = bhCheckL2Wall_0x14f760; // 0x151c8c - g_ps2RecompiledFunctionTable[83746] = bhCheckL2Wall_0x14f760; // 0x151c90 - g_ps2RecompiledFunctionTable[83747] = bhCheckL2Wall_0x14f760; // 0x151c94 - g_ps2RecompiledFunctionTable[83748] = bhCheckL2Wall_0x14f760; // 0x151c98 - g_ps2RecompiledFunctionTable[83749] = bhCheckL2Wall_0x14f760; // 0x151c9c - g_ps2RecompiledFunctionTable[83750] = bhCheckL2Wall_0x14f760; // 0x151ca0 - g_ps2RecompiledFunctionTable[83751] = bhCheckL2Wall_0x14f760; // 0x151ca4 - g_ps2RecompiledFunctionTable[83752] = bhCheckL2Wall_0x14f760; // 0x151ca8 - g_ps2RecompiledFunctionTable[83753] = bhCheckL2Wall_0x14f760; // 0x151cac - g_ps2RecompiledFunctionTable[83754] = bhCheckL2Wall_0x14f760; // 0x151cb0 - g_ps2RecompiledFunctionTable[83755] = bhCheckL2Wall_0x14f760; // 0x151cb4 - g_ps2RecompiledFunctionTable[83756] = bhCheckL2Wall_0x14f760; // 0x151cb8 - g_ps2RecompiledFunctionTable[83757] = bhCheckL2Wall_0x14f760; // 0x151cbc - g_ps2RecompiledFunctionTable[83758] = bhCheckL2Wall_0x14f760; // 0x151cc0 - g_ps2RecompiledFunctionTable[83759] = bhCheckL2Wall_0x14f760; // 0x151cc4 - g_ps2RecompiledFunctionTable[83760] = bhCheckL2Wall_0x14f760; // 0x151cc8 - g_ps2RecompiledFunctionTable[83761] = bhCheckL2Wall_0x14f760; // 0x151ccc - g_ps2RecompiledFunctionTable[83762] = bhCheckL2Wall_0x14f760; // 0x151cd0 - g_ps2RecompiledFunctionTable[83763] = bhCheckL2Wall_0x14f760; // 0x151cd4 - g_ps2RecompiledFunctionTable[83764] = bhCheckL2Wall_0x14f760; // 0x151cd8 - g_ps2RecompiledFunctionTable[83765] = bhCheckL2Wall_0x14f760; // 0x151cdc - g_ps2RecompiledFunctionTable[83766] = bhCheckL2Wall_0x14f760; // 0x151ce0 - g_ps2RecompiledFunctionTable[83767] = bhCheckL2Wall_0x14f760; // 0x151ce4 - g_ps2RecompiledFunctionTable[83768] = bhCheckL2Wall_0x14f760; // 0x151ce8 - g_ps2RecompiledFunctionTable[83769] = bhCheckL2Wall_0x14f760; // 0x151cec - g_ps2RecompiledFunctionTable[83770] = bhCheckL2Wall_0x14f760; // 0x151cf0 - g_ps2RecompiledFunctionTable[83771] = bhCheckL2Wall_0x14f760; // 0x151cf4 - g_ps2RecompiledFunctionTable[83772] = bhCheckL2Wall_0x14f760; // 0x151cf8 - g_ps2RecompiledFunctionTable[83773] = bhCheckL2Wall_0x14f760; // 0x151cfc - g_ps2RecompiledFunctionTable[83774] = bhCheckL2Wall_0x14f760; // 0x151d00 - g_ps2RecompiledFunctionTable[83775] = bhCheckL2Wall_0x14f760; // 0x151d04 - g_ps2RecompiledFunctionTable[83776] = bhCheckL2Wall_0x14f760; // 0x151d08 - g_ps2RecompiledFunctionTable[83777] = bhCheckL2Wall_0x14f760; // 0x151d0c - g_ps2RecompiledFunctionTable[83778] = bhCheckL2Wall_0x14f760; // 0x151d10 - g_ps2RecompiledFunctionTable[83779] = bhCheckL2Wall_0x14f760; // 0x151d14 - g_ps2RecompiledFunctionTable[83780] = bhCheckL2Wall_0x14f760; // 0x151d18 - g_ps2RecompiledFunctionTable[83781] = bhCheckL2Wall_0x14f760; // 0x151d1c - g_ps2RecompiledFunctionTable[83782] = bhCheckL2Wall_0x14f760; // 0x151d20 - g_ps2RecompiledFunctionTable[83783] = bhCheckL2Wall_0x14f760; // 0x151d24 - g_ps2RecompiledFunctionTable[83784] = bhCheckL2Wall_0x14f760; // 0x151d28 - g_ps2RecompiledFunctionTable[83785] = bhCheckL2Wall_0x14f760; // 0x151d2c - g_ps2RecompiledFunctionTable[83786] = bhCheckL2Wall_0x14f760; // 0x151d30 - g_ps2RecompiledFunctionTable[83787] = bhCheckL2Wall_0x14f760; // 0x151d34 - g_ps2RecompiledFunctionTable[83788] = bhCheckL2Wall_0x14f760; // 0x151d38 - g_ps2RecompiledFunctionTable[83789] = bhCheckL2Wall_0x14f760; // 0x151d3c - g_ps2RecompiledFunctionTable[83790] = bhCheckL2Wall_0x14f760; // 0x151d40 - g_ps2RecompiledFunctionTable[83791] = bhCheckL2Wall_0x14f760; // 0x151d44 - g_ps2RecompiledFunctionTable[83792] = bhCheckL2Wall_0x14f760; // 0x151d48 - g_ps2RecompiledFunctionTable[83793] = bhCheckL2Wall_0x14f760; // 0x151d4c - g_ps2RecompiledFunctionTable[83794] = bhCheckL2Wall_0x14f760; // 0x151d50 - g_ps2RecompiledFunctionTable[83795] = bhCheckL2Wall_0x14f760; // 0x151d54 - g_ps2RecompiledFunctionTable[83796] = bhCheckL2Wall_0x14f760; // 0x151d58 - g_ps2RecompiledFunctionTable[83797] = bhCheckL2Wall_0x14f760; // 0x151d5c - g_ps2RecompiledFunctionTable[83798] = bhCheckL2Wall_0x14f760; // 0x151d60 - g_ps2RecompiledFunctionTable[83799] = bhCheckL2Wall_0x14f760; // 0x151d64 - g_ps2RecompiledFunctionTable[83800] = bhCheckL2Wall_0x14f760; // 0x151d68 - g_ps2RecompiledFunctionTable[83801] = bhCheckL2Wall_0x14f760; // 0x151d6c - g_ps2RecompiledFunctionTable[83802] = bhCheckL2Wall_0x14f760; // 0x151d70 - g_ps2RecompiledFunctionTable[83803] = bhCheckL2Wall_0x14f760; // 0x151d74 - g_ps2RecompiledFunctionTable[83804] = bhCheckL2Wall_0x14f760; // 0x151d78 - g_ps2RecompiledFunctionTable[83805] = bhCheckL2Wall_0x14f760; // 0x151d7c - g_ps2RecompiledFunctionTable[83806] = bhCheckL2Wall_0x14f760; // 0x151d80 - g_ps2RecompiledFunctionTable[83807] = bhCheckL2Wall_0x14f760; // 0x151d84 - g_ps2RecompiledFunctionTable[83808] = bhCheckL2Wall_0x14f760; // 0x151d88 - g_ps2RecompiledFunctionTable[83809] = bhCheckL2Wall_0x14f760; // 0x151d8c - g_ps2RecompiledFunctionTable[83810] = bhCheckL2Wall_0x14f760; // 0x151d90 - g_ps2RecompiledFunctionTable[83811] = bhCheckL2Wall_0x14f760; // 0x151d94 - g_ps2RecompiledFunctionTable[83812] = bhCheckL2Wall_0x14f760; // 0x151d98 - g_ps2RecompiledFunctionTable[83813] = bhCheckL2Wall_0x14f760; // 0x151d9c - g_ps2RecompiledFunctionTable[83814] = bhCheckL2Wall_0x14f760; // 0x151da0 - g_ps2RecompiledFunctionTable[83815] = bhCheckL2Wall_0x14f760; // 0x151da4 - g_ps2RecompiledFunctionTable[83816] = bhCheckL2Wall_0x14f760; // 0x151da8 - g_ps2RecompiledFunctionTable[83817] = bhCheckL2Wall_0x14f760; // 0x151dac - g_ps2RecompiledFunctionTable[83818] = bhCheckL2Wall_0x14f760; // 0x151db0 - g_ps2RecompiledFunctionTable[83819] = bhCheckL2Wall_0x14f760; // 0x151db4 - g_ps2RecompiledFunctionTable[83820] = bhCheckL2Wall_0x14f760; // 0x151db8 - g_ps2RecompiledFunctionTable[83821] = bhCheckL2Wall_0x14f760; // 0x151dbc - g_ps2RecompiledFunctionTable[83822] = bhCheckL2Wall_0x14f760; // 0x151dc0 - g_ps2RecompiledFunctionTable[83823] = bhCheckL2Wall_0x14f760; // 0x151dc4 - g_ps2RecompiledFunctionTable[83824] = bhCheckL2Wall_0x14f760; // 0x151dc8 - g_ps2RecompiledFunctionTable[83825] = bhCheckL2Wall_0x14f760; // 0x151dcc - g_ps2RecompiledFunctionTable[83826] = bhCheckL2Wall_0x14f760; // 0x151dd0 - g_ps2RecompiledFunctionTable[83827] = bhCheckL2Wall_0x14f760; // 0x151dd4 - g_ps2RecompiledFunctionTable[83828] = bhCheckL2Wall_0x14f760; // 0x151dd8 - g_ps2RecompiledFunctionTable[83829] = bhCheckL2Wall_0x14f760; // 0x151ddc - g_ps2RecompiledFunctionTable[83830] = bhCheckL2Wall_0x14f760; // 0x151de0 - g_ps2RecompiledFunctionTable[83831] = bhCheckL2Wall_0x14f760; // 0x151de4 - g_ps2RecompiledFunctionTable[83832] = bhCheckL2Wall_0x14f760; // 0x151de8 - g_ps2RecompiledFunctionTable[83833] = bhCheckL2Wall_0x14f760; // 0x151dec - g_ps2RecompiledFunctionTable[83834] = bhCheckL2Wall_0x14f760; // 0x151df0 - g_ps2RecompiledFunctionTable[83835] = bhCheckL2Wall_0x14f760; // 0x151df4 - g_ps2RecompiledFunctionTable[83836] = bhCheckL2Wall_0x14f760; // 0x151df8 - g_ps2RecompiledFunctionTable[83837] = bhCheckL2Wall_0x14f760; // 0x151dfc - g_ps2RecompiledFunctionTable[83838] = bhCheckL2Wall_0x14f760; // 0x151e00 - g_ps2RecompiledFunctionTable[83839] = bhCheckL2Wall_0x14f760; // 0x151e04 - g_ps2RecompiledFunctionTable[83840] = bhCheckL2Wall_0x14f760; // 0x151e08 - g_ps2RecompiledFunctionTable[83841] = bhCheckL2Wall_0x14f760; // 0x151e0c - g_ps2RecompiledFunctionTable[83842] = bhCheckL2Wall_0x14f760; // 0x151e10 - g_ps2RecompiledFunctionTable[83843] = bhCheckL2Wall_0x14f760; // 0x151e14 - g_ps2RecompiledFunctionTable[83844] = bhCheckL2Wall_0x14f760; // 0x151e18 - g_ps2RecompiledFunctionTable[83845] = bhCheckL2Wall_0x14f760; // 0x151e1c - g_ps2RecompiledFunctionTable[83846] = bhCheckL2Wall_0x14f760; // 0x151e20 - g_ps2RecompiledFunctionTable[83847] = bhCheckL2Wall_0x14f760; // 0x151e24 - g_ps2RecompiledFunctionTable[83848] = bhCheckL2Wall_0x14f760; // 0x151e28 - g_ps2RecompiledFunctionTable[83849] = bhCheckL2Wall_0x14f760; // 0x151e2c - g_ps2RecompiledFunctionTable[83850] = bhCheckL2Wall_0x14f760; // 0x151e30 - g_ps2RecompiledFunctionTable[83851] = bhCheckL2Wall_0x14f760; // 0x151e34 - g_ps2RecompiledFunctionTable[83852] = bhCheckL2Wall_0x14f760; // 0x151e38 - g_ps2RecompiledFunctionTable[83853] = bhCheckL2Wall_0x14f760; // 0x151e3c - g_ps2RecompiledFunctionTable[83854] = bhCheckL2Wall_0x14f760; // 0x151e40 - g_ps2RecompiledFunctionTable[83855] = bhCheckL2Wall_0x14f760; // 0x151e44 - g_ps2RecompiledFunctionTable[83856] = bhCheckL2Wall_0x14f760; // 0x151e48 - g_ps2RecompiledFunctionTable[83857] = bhCheckL2Wall_0x14f760; // 0x151e4c - g_ps2RecompiledFunctionTable[83858] = bhCheckL2Wall_0x14f760; // 0x151e50 - g_ps2RecompiledFunctionTable[83859] = bhCheckL2Wall_0x14f760; // 0x151e54 - g_ps2RecompiledFunctionTable[83860] = bhCheckL2Wall_0x14f760; // 0x151e58 - g_ps2RecompiledFunctionTable[83861] = bhCheckL2Wall_0x14f760; // 0x151e5c - g_ps2RecompiledFunctionTable[83862] = bhCheckL2Wall_0x14f760; // 0x151e60 - g_ps2RecompiledFunctionTable[83863] = bhCheckL2Wall_0x14f760; // 0x151e64 - g_ps2RecompiledFunctionTable[83864] = bhCheckL2Wall_0x14f760; // 0x151e68 - g_ps2RecompiledFunctionTable[83865] = bhCheckL2Wall_0x14f760; // 0x151e6c - g_ps2RecompiledFunctionTable[83866] = bhCheckL2Wall_0x14f760; // 0x151e70 - g_ps2RecompiledFunctionTable[83867] = bhCheckL2Wall_0x14f760; // 0x151e74 - g_ps2RecompiledFunctionTable[83868] = bhCheckL2Wall_0x14f760; // 0x151e78 - g_ps2RecompiledFunctionTable[83869] = bhCheckL2Wall_0x14f760; // 0x151e7c - g_ps2RecompiledFunctionTable[83870] = bhCheckL2Wall_0x14f760; // 0x151e80 - g_ps2RecompiledFunctionTable[83871] = bhCheckL2Wall_0x14f760; // 0x151e84 - g_ps2RecompiledFunctionTable[83872] = bhCheckL2Wall_0x14f760; // 0x151e88 - g_ps2RecompiledFunctionTable[83873] = bhCheckL2Wall_0x14f760; // 0x151e8c - g_ps2RecompiledFunctionTable[83874] = bhCheckL2Wall_0x14f760; // 0x151e90 - g_ps2RecompiledFunctionTable[83875] = bhCheckL2Wall_0x14f760; // 0x151e94 - g_ps2RecompiledFunctionTable[83876] = bhCheckL2Wall_0x14f760; // 0x151e98 - g_ps2RecompiledFunctionTable[83877] = bhCheckL2Wall_0x14f760; // 0x151e9c - g_ps2RecompiledFunctionTable[83878] = bhCheckL2Wall_0x14f760; // 0x151ea0 - g_ps2RecompiledFunctionTable[83879] = bhCheckL2Wall_0x14f760; // 0x151ea4 - g_ps2RecompiledFunctionTable[83880] = bhCheckL2Wall_0x14f760; // 0x151ea8 - g_ps2RecompiledFunctionTable[83881] = bhCheckL2Wall_0x14f760; // 0x151eac - g_ps2RecompiledFunctionTable[83882] = bhCheckL2Wall_0x14f760; // 0x151eb0 - g_ps2RecompiledFunctionTable[83883] = bhCheckL2Wall_0x14f760; // 0x151eb4 - g_ps2RecompiledFunctionTable[83884] = bhCheckL2Wall_0x14f760; // 0x151eb8 - g_ps2RecompiledFunctionTable[83885] = bhCheckL2Wall_0x14f760; // 0x151ebc - g_ps2RecompiledFunctionTable[83886] = bhCheckL2Wall_0x14f760; // 0x151ec0 - g_ps2RecompiledFunctionTable[83887] = bhCheckL2Wall_0x14f760; // 0x151ec4 - g_ps2RecompiledFunctionTable[83888] = bhCheckL2Wall_0x14f760; // 0x151ec8 - g_ps2RecompiledFunctionTable[83889] = bhCheckL2Wall_0x14f760; // 0x151ecc - g_ps2RecompiledFunctionTable[83890] = bhCheckL2Wall_0x14f760; // 0x151ed0 - g_ps2RecompiledFunctionTable[83891] = bhCheckL2Wall_0x14f760; // 0x151ed4 - g_ps2RecompiledFunctionTable[83892] = bhCheckL2Wall_0x14f760; // 0x151ed8 - g_ps2RecompiledFunctionTable[83893] = bhCheckL2Wall_0x14f760; // 0x151edc - g_ps2RecompiledFunctionTable[83894] = bhCheckL2Wall_0x14f760; // 0x151ee0 - g_ps2RecompiledFunctionTable[83895] = bhCheckL2Wall_0x14f760; // 0x151ee4 - g_ps2RecompiledFunctionTable[83896] = bhCheckL2Wall_0x14f760; // 0x151ee8 - g_ps2RecompiledFunctionTable[83897] = bhCheckL2Wall_0x14f760; // 0x151eec - g_ps2RecompiledFunctionTable[83898] = bhCheckL2Wall_0x14f760; // 0x151ef0 - g_ps2RecompiledFunctionTable[83899] = bhCheckL2Wall_0x14f760; // 0x151ef4 - g_ps2RecompiledFunctionTable[83900] = bhCheckL2Wall_0x14f760; // 0x151ef8 - g_ps2RecompiledFunctionTable[83901] = bhCheckL2Wall_0x14f760; // 0x151efc - g_ps2RecompiledFunctionTable[83902] = bhCheckL2Wall_0x14f760; // 0x151f00 - g_ps2RecompiledFunctionTable[83903] = bhCheckL2Wall_0x14f760; // 0x151f04 - g_ps2RecompiledFunctionTable[83904] = bhCheckL2Wall_0x14f760; // 0x151f08 - g_ps2RecompiledFunctionTable[83905] = bhCheckL2Wall_0x14f760; // 0x151f0c - g_ps2RecompiledFunctionTable[83906] = bhCheckL2Wall_0x14f760; // 0x151f10 - g_ps2RecompiledFunctionTable[83907] = bhCheckL2Wall_0x14f760; // 0x151f14 - g_ps2RecompiledFunctionTable[83908] = bhCheckL2Wall_0x14f760; // 0x151f18 - g_ps2RecompiledFunctionTable[83909] = bhCheckL2Wall_0x14f760; // 0x151f1c - g_ps2RecompiledFunctionTable[83910] = bhCheckL2Wall_0x14f760; // 0x151f20 - g_ps2RecompiledFunctionTable[83911] = bhCheckL2Wall_0x14f760; // 0x151f24 - g_ps2RecompiledFunctionTable[83912] = bhCheckL2Wall_0x14f760; // 0x151f28 - g_ps2RecompiledFunctionTable[83913] = bhCheckL2Wall_0x14f760; // 0x151f2c - g_ps2RecompiledFunctionTable[83914] = bhCheckL2Wall_0x14f760; // 0x151f30 - g_ps2RecompiledFunctionTable[83915] = bhCheckL2Wall_0x14f760; // 0x151f34 - g_ps2RecompiledFunctionTable[83916] = bhCheckL2Wall_0x14f760; // 0x151f38 - g_ps2RecompiledFunctionTable[83917] = bhCheckL2Wall_0x14f760; // 0x151f3c - g_ps2RecompiledFunctionTable[83918] = bhCheckL2Wall_0x14f760; // 0x151f40 - g_ps2RecompiledFunctionTable[83919] = bhCheckL2Wall_0x14f760; // 0x151f44 - g_ps2RecompiledFunctionTable[83920] = bhCheckL2Wall_0x14f760; // 0x151f48 - g_ps2RecompiledFunctionTable[83921] = bhCheckL2Wall_0x14f760; // 0x151f4c - g_ps2RecompiledFunctionTable[83922] = bhCheckL2Wall_0x14f760; // 0x151f50 - g_ps2RecompiledFunctionTable[83923] = bhCheckL2Wall_0x14f760; // 0x151f54 - g_ps2RecompiledFunctionTable[83924] = bhCheckL2Wall_0x14f760; // 0x151f58 - g_ps2RecompiledFunctionTable[83925] = bhCheckL2Wall_0x14f760; // 0x151f5c - g_ps2RecompiledFunctionTable[83926] = bhCheckL2Wall_0x14f760; // 0x151f60 - g_ps2RecompiledFunctionTable[83927] = bhCheckL2Wall_0x14f760; // 0x151f64 - g_ps2RecompiledFunctionTable[83928] = bhCheckL2Wall_0x14f760; // 0x151f68 - g_ps2RecompiledFunctionTable[83929] = bhCheckL2Wall_0x14f760; // 0x151f6c - g_ps2RecompiledFunctionTable[83930] = bhCheckL2Wall_0x14f760; // 0x151f70 - g_ps2RecompiledFunctionTable[83931] = bhCheckL2Wall_0x14f760; // 0x151f74 - g_ps2RecompiledFunctionTable[83932] = bhCheckL2Wall_0x14f760; // 0x151f78 - g_ps2RecompiledFunctionTable[83933] = bhCheckL2Wall_0x14f760; // 0x151f7c - g_ps2RecompiledFunctionTable[83934] = bhCheckL2Wall_0x14f760; // 0x151f80 - g_ps2RecompiledFunctionTable[83935] = bhCheckL2Wall_0x14f760; // 0x151f84 - g_ps2RecompiledFunctionTable[83936] = bhCheckL2Wall_0x14f760; // 0x151f88 - g_ps2RecompiledFunctionTable[83937] = bhCheckL2Wall_0x14f760; // 0x151f8c - g_ps2RecompiledFunctionTable[83938] = bhCheckL2Wall_0x14f760; // 0x151f90 - g_ps2RecompiledFunctionTable[83939] = bhCheckL2Wall_0x14f760; // 0x151f94 - g_ps2RecompiledFunctionTable[83940] = bhCheckL2Wall_0x14f760; // 0x151f98 - g_ps2RecompiledFunctionTable[83941] = bhCheckL2Wall_0x14f760; // 0x151f9c - g_ps2RecompiledFunctionTable[83942] = bhCheckL2Wall_0x14f760; // 0x151fa0 - g_ps2RecompiledFunctionTable[83943] = bhCheckL2Wall_0x14f760; // 0x151fa4 - g_ps2RecompiledFunctionTable[83944] = bhCheckL2Wall_0x14f760; // 0x151fa8 - g_ps2RecompiledFunctionTable[83945] = bhCheckL2Wall_0x14f760; // 0x151fac - g_ps2RecompiledFunctionTable[83946] = bhCheckL2Wall_0x14f760; // 0x151fb0 - g_ps2RecompiledFunctionTable[83947] = bhCheckL2Wall_0x14f760; // 0x151fb4 - g_ps2RecompiledFunctionTable[83948] = bhCheckL2Wall_0x14f760; // 0x151fb8 - g_ps2RecompiledFunctionTable[83949] = bhCheckL2Wall_0x14f760; // 0x151fbc - g_ps2RecompiledFunctionTable[83950] = bhCheckL2Wall_0x14f760; // 0x151fc0 - g_ps2RecompiledFunctionTable[83951] = bhCheckL2Wall_0x14f760; // 0x151fc4 - g_ps2RecompiledFunctionTable[83952] = bhCheckL2Wall_0x14f760; // 0x151fc8 - g_ps2RecompiledFunctionTable[83953] = bhCheckL2Wall_0x14f760; // 0x151fcc - g_ps2RecompiledFunctionTable[83954] = bhCheckL2Wall_0x14f760; // 0x151fd0 - g_ps2RecompiledFunctionTable[83955] = bhCheckL2Wall_0x14f760; // 0x151fd4 - g_ps2RecompiledFunctionTable[83956] = bhCheckL2Wall_0x14f760; // 0x151fd8 - g_ps2RecompiledFunctionTable[83957] = bhCheckL2Wall_0x14f760; // 0x151fdc - g_ps2RecompiledFunctionTable[83958] = bhCheckL2Wall_0x14f760; // 0x151fe0 - g_ps2RecompiledFunctionTable[83959] = bhCheckL2Wall_0x14f760; // 0x151fe4 - g_ps2RecompiledFunctionTable[83960] = bhCheckL2Wall_0x14f760; // 0x151fe8 - g_ps2RecompiledFunctionTable[83961] = bhCheckL2Wall_0x14f760; // 0x151fec - g_ps2RecompiledFunctionTable[83962] = bhCheckL2Wall_0x14f760; // 0x151ff0 - g_ps2RecompiledFunctionTable[83963] = bhCheckL2Wall_0x14f760; // 0x151ff4 - g_ps2RecompiledFunctionTable[83964] = bhCheckL2Wall_0x14f760; // 0x151ff8 - g_ps2RecompiledFunctionTable[83965] = bhCheckL2Wall_0x14f760; // 0x151ffc - g_ps2RecompiledFunctionTable[83966] = bhCheckL2Wall_0x14f760; // 0x152000 - g_ps2RecompiledFunctionTable[83967] = bhCheckL2Wall_0x14f760; // 0x152004 - g_ps2RecompiledFunctionTable[83968] = bhCheckL2Wall_0x14f760; // 0x152008 - g_ps2RecompiledFunctionTable[83969] = bhCheckL2Wall_0x14f760; // 0x15200c - g_ps2RecompiledFunctionTable[83970] = bhCheckL2Wall_0x14f760; // 0x152010 - g_ps2RecompiledFunctionTable[83971] = bhCheckL2Wall_0x14f760; // 0x152014 - g_ps2RecompiledFunctionTable[83972] = bhCheckL2Wall_0x14f760; // 0x152018 - g_ps2RecompiledFunctionTable[83973] = bhCheckL2Wall_0x14f760; // 0x15201c - g_ps2RecompiledFunctionTable[83974] = bhCheckL2Wall_0x14f760; // 0x152020 - g_ps2RecompiledFunctionTable[83975] = bhCheckL2Wall_0x14f760; // 0x152024 - g_ps2RecompiledFunctionTable[83976] = bhCheckL2Wall_0x14f760; // 0x152028 - g_ps2RecompiledFunctionTable[83977] = bhCheckL2Wall_0x14f760; // 0x15202c - g_ps2RecompiledFunctionTable[83978] = bhCheckL2Wall_0x14f760; // 0x152030 - g_ps2RecompiledFunctionTable[83979] = bhCheckL2Wall_0x14f760; // 0x152034 - g_ps2RecompiledFunctionTable[83980] = bhCheckL2Wall_0x14f760; // 0x152038 - g_ps2RecompiledFunctionTable[83981] = bhCheckL2Wall_0x14f760; // 0x15203c - g_ps2RecompiledFunctionTable[83982] = bhCheckL2Wall_0x14f760; // 0x152040 - g_ps2RecompiledFunctionTable[83983] = bhCheckL2Wall_0x14f760; // 0x152044 - g_ps2RecompiledFunctionTable[83984] = bhCheckL2Wall_0x14f760; // 0x152048 - g_ps2RecompiledFunctionTable[83985] = bhCheckL2Wall_0x14f760; // 0x15204c - g_ps2RecompiledFunctionTable[83986] = bhCheckL2Wall_0x14f760; // 0x152050 - g_ps2RecompiledFunctionTable[83987] = bhCheckL2Wall_0x14f760; // 0x152054 - g_ps2RecompiledFunctionTable[83988] = bhCheckL2Wall_0x14f760; // 0x152058 - g_ps2RecompiledFunctionTable[83989] = bhCheckL2Wall_0x14f760; // 0x15205c - g_ps2RecompiledFunctionTable[83990] = bhCheckL2Wall_0x14f760; // 0x152060 - g_ps2RecompiledFunctionTable[83991] = bhCheckL2Wall_0x14f760; // 0x152064 - g_ps2RecompiledFunctionTable[83992] = bhCheckL2Wall_0x14f760; // 0x152068 - g_ps2RecompiledFunctionTable[83993] = bhCheckL2Wall_0x14f760; // 0x15206c - g_ps2RecompiledFunctionTable[83994] = bhCheckL2Wall_0x14f760; // 0x152070 - g_ps2RecompiledFunctionTable[83995] = bhCheckL2Wall_0x14f760; // 0x152074 - g_ps2RecompiledFunctionTable[83996] = bhCheckL2Wall_0x14f760; // 0x152078 - g_ps2RecompiledFunctionTable[83997] = bhCheckL2Wall_0x14f760; // 0x15207c - g_ps2RecompiledFunctionTable[83998] = bhCheckL2Wall_0x14f760; // 0x152080 - g_ps2RecompiledFunctionTable[83999] = bhCheckL2Wall_0x14f760; // 0x152084 - g_ps2RecompiledFunctionTable[84000] = bhCheckL2Wall_0x14f760; // 0x152088 - g_ps2RecompiledFunctionTable[84001] = bhCheckL2Wall_0x14f760; // 0x15208c - g_ps2RecompiledFunctionTable[84002] = bhCheckL2Wall_0x14f760; // 0x152090 - g_ps2RecompiledFunctionTable[84003] = bhCheckL2Wall_0x14f760; // 0x152094 - g_ps2RecompiledFunctionTable[84004] = bhCheckL2Wall_0x14f760; // 0x152098 - g_ps2RecompiledFunctionTable[84005] = bhCheckL2Wall_0x14f760; // 0x15209c - g_ps2RecompiledFunctionTable[84006] = bhCheckL2Wall_0x14f760; // 0x1520a0 - g_ps2RecompiledFunctionTable[84007] = bhCheckL2Wall_0x14f760; // 0x1520a4 - g_ps2RecompiledFunctionTable[84008] = bhCheckL2Wall_0x14f760; // 0x1520a8 - g_ps2RecompiledFunctionTable[84009] = bhCheckL2Wall_0x14f760; // 0x1520ac - g_ps2RecompiledFunctionTable[84010] = bhCheckL2Wall_0x14f760; // 0x1520b0 - g_ps2RecompiledFunctionTable[84011] = bhCheckL2Wall_0x14f760; // 0x1520b4 - g_ps2RecompiledFunctionTable[84012] = bhCheckL2Wall_0x14f760; // 0x1520b8 - g_ps2RecompiledFunctionTable[84013] = bhCheckL2Wall_0x14f760; // 0x1520bc - g_ps2RecompiledFunctionTable[84014] = bhCheckL2Wall_0x14f760; // 0x1520c0 - g_ps2RecompiledFunctionTable[84015] = bhCheckL2Wall_0x14f760; // 0x1520c4 - g_ps2RecompiledFunctionTable[84016] = bhCheckL2Wall_0x14f760; // 0x1520c8 - g_ps2RecompiledFunctionTable[84017] = bhCheckL2Wall_0x14f760; // 0x1520cc - g_ps2RecompiledFunctionTable[84018] = bhCheckL2Wall_0x14f760; // 0x1520d0 - g_ps2RecompiledFunctionTable[84019] = bhCheckL2Wall_0x14f760; // 0x1520d4 - g_ps2RecompiledFunctionTable[84020] = bhCheckL2Wall_0x14f760; // 0x1520d8 - g_ps2RecompiledFunctionTable[84021] = bhCheckL2Wall_0x14f760; // 0x1520dc - g_ps2RecompiledFunctionTable[84022] = bhCheckL2Wall_0x14f760; // 0x1520e0 - g_ps2RecompiledFunctionTable[84023] = bhCheckL2Wall_0x14f760; // 0x1520e4 - g_ps2RecompiledFunctionTable[84024] = bhCheckL2Wall_0x14f760; // 0x1520e8 - g_ps2RecompiledFunctionTable[84025] = bhCheckL2Wall_0x14f760; // 0x1520ec - g_ps2RecompiledFunctionTable[84026] = bhCheckL2Wall_0x14f760; // 0x1520f0 - g_ps2RecompiledFunctionTable[84027] = bhCheckL2Wall_0x14f760; // 0x1520f4 - g_ps2RecompiledFunctionTable[84028] = bhCheckL2Wall_0x14f760; // 0x1520f8 - g_ps2RecompiledFunctionTable[84029] = bhCheckL2Wall_0x14f760; // 0x1520fc - g_ps2RecompiledFunctionTable[84030] = bhCheckL2Wall_0x14f760; // 0x152100 - g_ps2RecompiledFunctionTable[84031] = bhCheckL2Wall_0x14f760; // 0x152104 - g_ps2RecompiledFunctionTable[84032] = bhCheckL2Wall_0x14f760; // 0x152108 - g_ps2RecompiledFunctionTable[84033] = bhCheckL2Wall_0x14f760; // 0x15210c - g_ps2RecompiledFunctionTable[84034] = bhCheckL2Wall_0x14f760; // 0x152110 - g_ps2RecompiledFunctionTable[84035] = bhCheckL2Wall_0x14f760; // 0x152114 - g_ps2RecompiledFunctionTable[84036] = bhCheckL2Wall_0x14f760; // 0x152118 - g_ps2RecompiledFunctionTable[84037] = bhCheckL2Wall_0x14f760; // 0x15211c - g_ps2RecompiledFunctionTable[84038] = bhCheckL2Wall_0x14f760; // 0x152120 - g_ps2RecompiledFunctionTable[84039] = bhCheckL2Wall_0x14f760; // 0x152124 - g_ps2RecompiledFunctionTable[84040] = bhCheckL2Wall_0x14f760; // 0x152128 - g_ps2RecompiledFunctionTable[84041] = bhCheckL2Wall_0x14f760; // 0x15212c - g_ps2RecompiledFunctionTable[84042] = bhCheckL2Wall_0x14f760; // 0x152130 - g_ps2RecompiledFunctionTable[84043] = bhCheckL2Wall_0x14f760; // 0x152134 - g_ps2RecompiledFunctionTable[84044] = bhCheckL2Wall_0x14f760; // 0x152138 - g_ps2RecompiledFunctionTable[84045] = bhCheckL2Wall_0x14f760; // 0x15213c - g_ps2RecompiledFunctionTable[84046] = bhCheckL2Wall_0x14f760; // 0x152140 - g_ps2RecompiledFunctionTable[84047] = bhCheckL2Wall_0x14f760; // 0x152144 - g_ps2RecompiledFunctionTable[84048] = bhCheckL2Wall_0x14f760; // 0x152148 - g_ps2RecompiledFunctionTable[84049] = bhCheckL2Wall_0x14f760; // 0x15214c - g_ps2RecompiledFunctionTable[84050] = bhCheckL2Wall_0x14f760; // 0x152150 - g_ps2RecompiledFunctionTable[84051] = bhCheckL2Wall_0x14f760; // 0x152154 - g_ps2RecompiledFunctionTable[84052] = bhCheckL2Wall_0x14f760; // 0x152158 - g_ps2RecompiledFunctionTable[84053] = bhCheckL2Wall_0x14f760; // 0x15215c - g_ps2RecompiledFunctionTable[84054] = bhCheckL2Wall_0x14f760; // 0x152160 - g_ps2RecompiledFunctionTable[84055] = bhCheckL2Wall_0x14f760; // 0x152164 - g_ps2RecompiledFunctionTable[84056] = bhCheckL2Wall_0x14f760; // 0x152168 - g_ps2RecompiledFunctionTable[84057] = bhCheckL2Wall_0x14f760; // 0x15216c - g_ps2RecompiledFunctionTable[84058] = bhCheckL2Wall_0x14f760; // 0x152170 - g_ps2RecompiledFunctionTable[84059] = bhCheckL2Wall_0x14f760; // 0x152174 - g_ps2RecompiledFunctionTable[84060] = bhCheckL2Wall_0x14f760; // 0x152178 - g_ps2RecompiledFunctionTable[84061] = bhCheckL2Wall_0x14f760; // 0x15217c - g_ps2RecompiledFunctionTable[84062] = bhCheckL2Wall_0x14f760; // 0x152180 - g_ps2RecompiledFunctionTable[84063] = bhCheckL2Wall_0x14f760; // 0x152184 - g_ps2RecompiledFunctionTable[84064] = bhCheckL2Wall_0x14f760; // 0x152188 - g_ps2RecompiledFunctionTable[84065] = bhCheckL2Wall_0x14f760; // 0x15218c - g_ps2RecompiledFunctionTable[84066] = bhCheckL2Wall_0x14f760; // 0x152190 - g_ps2RecompiledFunctionTable[84067] = bhCheckL2Wall_0x14f760; // 0x152194 - g_ps2RecompiledFunctionTable[84068] = bhCheckL2Wall_0x14f760; // 0x152198 - g_ps2RecompiledFunctionTable[84069] = bhCheckL2Wall_0x14f760; // 0x15219c - g_ps2RecompiledFunctionTable[84070] = bhCheckL2Wall_0x14f760; // 0x1521a0 - g_ps2RecompiledFunctionTable[84071] = bhCheckL2Wall_0x14f760; // 0x1521a4 - g_ps2RecompiledFunctionTable[84072] = bhCheckL2Wall_0x14f760; // 0x1521a8 - g_ps2RecompiledFunctionTable[84073] = bhCheckL2Wall_0x14f760; // 0x1521ac - g_ps2RecompiledFunctionTable[84074] = bhCheckL2Wall_0x14f760; // 0x1521b0 - g_ps2RecompiledFunctionTable[84075] = bhCheckL2Wall_0x14f760; // 0x1521b4 - g_ps2RecompiledFunctionTable[84076] = bhCheckL2Wall_0x14f760; // 0x1521b8 - g_ps2RecompiledFunctionTable[84078] = bhCheckC2Wall_0x1521c0; // 0x1521c0 - g_ps2RecompiledFunctionTable[84124] = bhCheckC2Wall_0x1521c0; // 0x152278 - g_ps2RecompiledFunctionTable[84141] = bhCheckC2Wall_0x1521c0; // 0x1522bc - g_ps2RecompiledFunctionTable[84224] = bhCheckC2Wall_0x1521c0; // 0x152408 - g_ps2RecompiledFunctionTable[84239] = bhCheckC2Wall_0x1521c0; // 0x152444 - g_ps2RecompiledFunctionTable[84263] = bhCheckC2Wall_0x1521c0; // 0x1524a4 - g_ps2RecompiledFunctionTable[84284] = bhCheckC2Wall_0x1521c0; // 0x1524f8 - g_ps2RecompiledFunctionTable[84292] = bhCheckC2Wall_0x1521c0; // 0x152518 - g_ps2RecompiledFunctionTable[84298] = bhCheckC2Wall_0x1521c0; // 0x152530 - g_ps2RecompiledFunctionTable[84320] = bhCheckC2Wall_0x1521c0; // 0x152588 - g_ps2RecompiledFunctionTable[84341] = bhCheckC2Wall_0x1521c0; // 0x1525dc - g_ps2RecompiledFunctionTable[84349] = bhCheckC2Wall_0x1521c0; // 0x1525fc - g_ps2RecompiledFunctionTable[84355] = bhCheckC2Wall_0x1521c0; // 0x152614 - g_ps2RecompiledFunctionTable[84385] = bhCheckC2Wall_0x1521c0; // 0x15268c - g_ps2RecompiledFunctionTable[84401] = bhCheckC2Wall_0x1521c0; // 0x1526cc - g_ps2RecompiledFunctionTable[84420] = bhCheckC2Wall_0x1521c0; // 0x152718 - g_ps2RecompiledFunctionTable[84428] = bhCheckC2Wall_0x1521c0; // 0x152738 - g_ps2RecompiledFunctionTable[84434] = bhCheckC2Wall_0x1521c0; // 0x152750 - g_ps2RecompiledFunctionTable[84462] = bhCheckC2Wall_0x1521c0; // 0x1527c0 - g_ps2RecompiledFunctionTable[84477] = bhCheckC2Wall_0x1521c0; // 0x1527fc - g_ps2RecompiledFunctionTable[84496] = bhCheckC2Wall_0x1521c0; // 0x152848 - g_ps2RecompiledFunctionTable[84504] = bhCheckC2Wall_0x1521c0; // 0x152868 - g_ps2RecompiledFunctionTable[84510] = bhCheckC2Wall_0x1521c0; // 0x152880 - g_ps2RecompiledFunctionTable[84552] = bhCheckC2Wall_0x1521c0; // 0x152928 - g_ps2RecompiledFunctionTable[84586] = bhCheckC2WallN_0x1529b0; // 0x1529b0 - g_ps2RecompiledFunctionTable[84587] = bhCheckC2WallN_0x1529b0; // 0x1529b4 - g_ps2RecompiledFunctionTable[84588] = bhCheckC2WallN_0x1529b0; // 0x1529b8 - g_ps2RecompiledFunctionTable[84589] = bhCheckC2WallN_0x1529b0; // 0x1529bc - g_ps2RecompiledFunctionTable[84590] = bhCheckC2WallN_0x1529b0; // 0x1529c0 - g_ps2RecompiledFunctionTable[84591] = bhCheckC2WallN_0x1529b0; // 0x1529c4 - g_ps2RecompiledFunctionTable[84592] = bhCheckC2WallN_0x1529b0; // 0x1529c8 - g_ps2RecompiledFunctionTable[84593] = bhCheckC2WallN_0x1529b0; // 0x1529cc - g_ps2RecompiledFunctionTable[84594] = bhCheckC2WallN_0x1529b0; // 0x1529d0 - g_ps2RecompiledFunctionTable[84595] = bhCheckC2WallN_0x1529b0; // 0x1529d4 - g_ps2RecompiledFunctionTable[84596] = bhCheckC2WallN_0x1529b0; // 0x1529d8 - g_ps2RecompiledFunctionTable[84597] = bhCheckC2WallN_0x1529b0; // 0x1529dc - g_ps2RecompiledFunctionTable[84598] = bhCheckC2WallN_0x1529b0; // 0x1529e0 - g_ps2RecompiledFunctionTable[84599] = bhCheckC2WallN_0x1529b0; // 0x1529e4 - g_ps2RecompiledFunctionTable[84600] = bhCheckC2WallN_0x1529b0; // 0x1529e8 - g_ps2RecompiledFunctionTable[84601] = bhCheckC2WallN_0x1529b0; // 0x1529ec - g_ps2RecompiledFunctionTable[84602] = bhCheckC2WallN_0x1529b0; // 0x1529f0 - g_ps2RecompiledFunctionTable[84603] = bhCheckC2WallN_0x1529b0; // 0x1529f4 - g_ps2RecompiledFunctionTable[84604] = bhCheckC2WallN_0x1529b0; // 0x1529f8 - g_ps2RecompiledFunctionTable[84605] = bhCheckC2WallN_0x1529b0; // 0x1529fc - g_ps2RecompiledFunctionTable[84606] = bhCheckC2WallN_0x1529b0; // 0x152a00 - g_ps2RecompiledFunctionTable[84607] = bhCheckC2WallN_0x1529b0; // 0x152a04 - g_ps2RecompiledFunctionTable[84608] = bhCheckC2WallN_0x1529b0; // 0x152a08 - g_ps2RecompiledFunctionTable[84609] = bhCheckC2WallN_0x1529b0; // 0x152a0c - g_ps2RecompiledFunctionTable[84610] = bhCheckC2WallN_0x1529b0; // 0x152a10 - g_ps2RecompiledFunctionTable[84611] = bhCheckC2WallN_0x1529b0; // 0x152a14 - g_ps2RecompiledFunctionTable[84612] = bhCheckC2WallN_0x1529b0; // 0x152a18 - g_ps2RecompiledFunctionTable[84613] = bhCheckC2WallN_0x1529b0; // 0x152a1c - g_ps2RecompiledFunctionTable[84614] = bhCheckC2WallN_0x1529b0; // 0x152a20 - g_ps2RecompiledFunctionTable[84615] = bhCheckC2WallN_0x1529b0; // 0x152a24 - g_ps2RecompiledFunctionTable[84616] = bhCheckC2WallN_0x1529b0; // 0x152a28 - g_ps2RecompiledFunctionTable[84617] = bhCheckC2WallN_0x1529b0; // 0x152a2c - g_ps2RecompiledFunctionTable[84618] = bhCheckC2WallN_0x1529b0; // 0x152a30 - g_ps2RecompiledFunctionTable[84619] = bhCheckC2WallN_0x1529b0; // 0x152a34 - g_ps2RecompiledFunctionTable[84620] = bhCheckC2WallN_0x1529b0; // 0x152a38 - g_ps2RecompiledFunctionTable[84621] = bhCheckC2WallN_0x1529b0; // 0x152a3c - g_ps2RecompiledFunctionTable[84622] = bhCheckC2WallN_0x1529b0; // 0x152a40 - g_ps2RecompiledFunctionTable[84623] = bhCheckC2WallN_0x1529b0; // 0x152a44 - g_ps2RecompiledFunctionTable[84624] = bhCheckC2WallN_0x1529b0; // 0x152a48 - g_ps2RecompiledFunctionTable[84625] = bhCheckC2WallN_0x1529b0; // 0x152a4c - g_ps2RecompiledFunctionTable[84626] = bhCheckC2WallN_0x1529b0; // 0x152a50 - g_ps2RecompiledFunctionTable[84627] = bhCheckC2WallN_0x1529b0; // 0x152a54 - g_ps2RecompiledFunctionTable[84628] = bhCheckC2WallN_0x1529b0; // 0x152a58 - g_ps2RecompiledFunctionTable[84629] = bhCheckC2WallN_0x1529b0; // 0x152a5c - g_ps2RecompiledFunctionTable[84630] = bhCheckC2WallN_0x1529b0; // 0x152a60 - g_ps2RecompiledFunctionTable[84631] = bhCheckC2WallN_0x1529b0; // 0x152a64 - g_ps2RecompiledFunctionTable[84632] = bhCheckC2WallN_0x1529b0; // 0x152a68 - g_ps2RecompiledFunctionTable[84633] = bhCheckC2WallN_0x1529b0; // 0x152a6c - g_ps2RecompiledFunctionTable[84634] = bhCheckC2WallN_0x1529b0; // 0x152a70 - g_ps2RecompiledFunctionTable[84635] = bhCheckC2WallN_0x1529b0; // 0x152a74 - g_ps2RecompiledFunctionTable[84636] = bhCheckC2WallN_0x1529b0; // 0x152a78 - g_ps2RecompiledFunctionTable[84637] = bhCheckC2WallN_0x1529b0; // 0x152a7c - g_ps2RecompiledFunctionTable[84638] = bhCheckC2WallN_0x1529b0; // 0x152a80 - g_ps2RecompiledFunctionTable[84639] = bhCheckC2WallN_0x1529b0; // 0x152a84 - g_ps2RecompiledFunctionTable[84640] = bhCheckC2WallN_0x1529b0; // 0x152a88 - g_ps2RecompiledFunctionTable[84641] = bhCheckC2WallN_0x1529b0; // 0x152a8c - g_ps2RecompiledFunctionTable[84642] = bhCheckC2WallN_0x1529b0; // 0x152a90 - g_ps2RecompiledFunctionTable[84643] = bhCheckC2WallN_0x1529b0; // 0x152a94 - g_ps2RecompiledFunctionTable[84644] = bhCheckC2WallN_0x1529b0; // 0x152a98 - g_ps2RecompiledFunctionTable[84645] = bhCheckC2WallN_0x1529b0; // 0x152a9c - g_ps2RecompiledFunctionTable[84646] = bhCheckC2WallN_0x1529b0; // 0x152aa0 - g_ps2RecompiledFunctionTable[84647] = bhCheckC2WallN_0x1529b0; // 0x152aa4 - g_ps2RecompiledFunctionTable[84648] = bhCheckC2WallN_0x1529b0; // 0x152aa8 - g_ps2RecompiledFunctionTable[84649] = bhCheckC2WallN_0x1529b0; // 0x152aac - g_ps2RecompiledFunctionTable[84650] = bhCheckC2WallN_0x1529b0; // 0x152ab0 - g_ps2RecompiledFunctionTable[84651] = bhCheckC2WallN_0x1529b0; // 0x152ab4 - g_ps2RecompiledFunctionTable[84652] = bhCheckC2WallN_0x1529b0; // 0x152ab8 - g_ps2RecompiledFunctionTable[84653] = bhCheckC2WallN_0x1529b0; // 0x152abc - g_ps2RecompiledFunctionTable[84654] = bhCheckC2WallN_0x1529b0; // 0x152ac0 - g_ps2RecompiledFunctionTable[84655] = bhCheckC2WallN_0x1529b0; // 0x152ac4 - g_ps2RecompiledFunctionTable[84656] = bhCheckC2WallN_0x1529b0; // 0x152ac8 - g_ps2RecompiledFunctionTable[84657] = bhCheckC2WallN_0x1529b0; // 0x152acc - g_ps2RecompiledFunctionTable[84658] = bhCheckC2WallN_0x1529b0; // 0x152ad0 - g_ps2RecompiledFunctionTable[84659] = bhCheckC2WallN_0x1529b0; // 0x152ad4 - g_ps2RecompiledFunctionTable[84660] = bhCheckC2WallN_0x1529b0; // 0x152ad8 - g_ps2RecompiledFunctionTable[84661] = bhCheckC2WallN_0x1529b0; // 0x152adc - g_ps2RecompiledFunctionTable[84662] = bhCheckC2WallN_0x1529b0; // 0x152ae0 - g_ps2RecompiledFunctionTable[84663] = bhCheckC2WallN_0x1529b0; // 0x152ae4 - g_ps2RecompiledFunctionTable[84664] = bhCheckC2WallN_0x1529b0; // 0x152ae8 - g_ps2RecompiledFunctionTable[84665] = bhCheckC2WallN_0x1529b0; // 0x152aec - g_ps2RecompiledFunctionTable[84666] = bhCheckC2WallN_0x1529b0; // 0x152af0 - g_ps2RecompiledFunctionTable[84667] = bhCheckC2WallN_0x1529b0; // 0x152af4 - g_ps2RecompiledFunctionTable[84668] = bhCheckC2WallN_0x1529b0; // 0x152af8 - g_ps2RecompiledFunctionTable[84669] = bhCheckC2WallN_0x1529b0; // 0x152afc - g_ps2RecompiledFunctionTable[84670] = bhCheckC2WallN_0x1529b0; // 0x152b00 - g_ps2RecompiledFunctionTable[84671] = bhCheckC2WallN_0x1529b0; // 0x152b04 - g_ps2RecompiledFunctionTable[84672] = bhCheckC2WallN_0x1529b0; // 0x152b08 - g_ps2RecompiledFunctionTable[84673] = bhCheckC2WallN_0x1529b0; // 0x152b0c - g_ps2RecompiledFunctionTable[84674] = bhCheckC2WallN_0x1529b0; // 0x152b10 - g_ps2RecompiledFunctionTable[84675] = bhCheckC2WallN_0x1529b0; // 0x152b14 - g_ps2RecompiledFunctionTable[84676] = bhCheckC2WallN_0x1529b0; // 0x152b18 - g_ps2RecompiledFunctionTable[84677] = bhCheckC2WallN_0x1529b0; // 0x152b1c - g_ps2RecompiledFunctionTable[84678] = bhCheckC2WallN_0x1529b0; // 0x152b20 - g_ps2RecompiledFunctionTable[84679] = bhCheckC2WallN_0x1529b0; // 0x152b24 - g_ps2RecompiledFunctionTable[84680] = bhCheckC2WallN_0x1529b0; // 0x152b28 - g_ps2RecompiledFunctionTable[84681] = bhCheckC2WallN_0x1529b0; // 0x152b2c - g_ps2RecompiledFunctionTable[84682] = bhCheckC2WallN_0x1529b0; // 0x152b30 - g_ps2RecompiledFunctionTable[84683] = bhCheckC2WallN_0x1529b0; // 0x152b34 - g_ps2RecompiledFunctionTable[84684] = bhCheckC2WallN_0x1529b0; // 0x152b38 - g_ps2RecompiledFunctionTable[84685] = bhCheckC2WallN_0x1529b0; // 0x152b3c - g_ps2RecompiledFunctionTable[84686] = bhCheckC2WallN_0x1529b0; // 0x152b40 - g_ps2RecompiledFunctionTable[84687] = bhCheckC2WallN_0x1529b0; // 0x152b44 - g_ps2RecompiledFunctionTable[84688] = bhCheckC2WallN_0x1529b0; // 0x152b48 - g_ps2RecompiledFunctionTable[84689] = bhCheckC2WallN_0x1529b0; // 0x152b4c - g_ps2RecompiledFunctionTable[84690] = bhCheckC2WallN_0x1529b0; // 0x152b50 - g_ps2RecompiledFunctionTable[84691] = bhCheckC2WallN_0x1529b0; // 0x152b54 - g_ps2RecompiledFunctionTable[84692] = bhCheckC2WallN_0x1529b0; // 0x152b58 - g_ps2RecompiledFunctionTable[84693] = bhCheckC2WallN_0x1529b0; // 0x152b5c - g_ps2RecompiledFunctionTable[84694] = bhCheckC2WallN_0x1529b0; // 0x152b60 - g_ps2RecompiledFunctionTable[84695] = bhCheckC2WallN_0x1529b0; // 0x152b64 - g_ps2RecompiledFunctionTable[84696] = bhCheckC2WallN_0x1529b0; // 0x152b68 - g_ps2RecompiledFunctionTable[84697] = bhCheckC2WallN_0x1529b0; // 0x152b6c - g_ps2RecompiledFunctionTable[84698] = bhCheckC2WallN_0x1529b0; // 0x152b70 - g_ps2RecompiledFunctionTable[84699] = bhCheckC2WallN_0x1529b0; // 0x152b74 - g_ps2RecompiledFunctionTable[84700] = bhCheckC2WallN_0x1529b0; // 0x152b78 - g_ps2RecompiledFunctionTable[84701] = bhCheckC2WallN_0x1529b0; // 0x152b7c - g_ps2RecompiledFunctionTable[84702] = bhCheckC2WallN_0x1529b0; // 0x152b80 - g_ps2RecompiledFunctionTable[84703] = bhCheckC2WallN_0x1529b0; // 0x152b84 - g_ps2RecompiledFunctionTable[84704] = bhCheckC2WallN_0x1529b0; // 0x152b88 - g_ps2RecompiledFunctionTable[84705] = bhCheckC2WallN_0x1529b0; // 0x152b8c - g_ps2RecompiledFunctionTable[84706] = bhCheckC2WallN_0x1529b0; // 0x152b90 - g_ps2RecompiledFunctionTable[84707] = bhCheckC2WallN_0x1529b0; // 0x152b94 - g_ps2RecompiledFunctionTable[84708] = bhCheckC2WallN_0x1529b0; // 0x152b98 - g_ps2RecompiledFunctionTable[84709] = bhCheckC2WallN_0x1529b0; // 0x152b9c - g_ps2RecompiledFunctionTable[84710] = bhCheckC2WallN_0x1529b0; // 0x152ba0 - g_ps2RecompiledFunctionTable[84711] = bhCheckC2WallN_0x1529b0; // 0x152ba4 - g_ps2RecompiledFunctionTable[84712] = bhCheckC2WallN_0x1529b0; // 0x152ba8 - g_ps2RecompiledFunctionTable[84713] = bhCheckC2WallN_0x1529b0; // 0x152bac - g_ps2RecompiledFunctionTable[84714] = bhCheckC2WallN_0x1529b0; // 0x152bb0 - g_ps2RecompiledFunctionTable[84715] = bhCheckC2WallN_0x1529b0; // 0x152bb4 - g_ps2RecompiledFunctionTable[84716] = bhCheckC2WallN_0x1529b0; // 0x152bb8 - g_ps2RecompiledFunctionTable[84717] = bhCheckC2WallN_0x1529b0; // 0x152bbc - g_ps2RecompiledFunctionTable[84718] = bhCheckC2WallN_0x1529b0; // 0x152bc0 - g_ps2RecompiledFunctionTable[84719] = bhCheckC2WallN_0x1529b0; // 0x152bc4 - g_ps2RecompiledFunctionTable[84720] = bhCheckC2WallN_0x1529b0; // 0x152bc8 - g_ps2RecompiledFunctionTable[84721] = bhCheckC2WallN_0x1529b0; // 0x152bcc - g_ps2RecompiledFunctionTable[84722] = bhCheckC2WallN_0x1529b0; // 0x152bd0 - g_ps2RecompiledFunctionTable[84723] = bhCheckC2WallN_0x1529b0; // 0x152bd4 - g_ps2RecompiledFunctionTable[84724] = bhCheckC2WallN_0x1529b0; // 0x152bd8 - g_ps2RecompiledFunctionTable[84725] = bhCheckC2WallN_0x1529b0; // 0x152bdc - g_ps2RecompiledFunctionTable[84726] = bhCheckC2WallN_0x1529b0; // 0x152be0 - g_ps2RecompiledFunctionTable[84727] = bhCheckC2WallN_0x1529b0; // 0x152be4 - g_ps2RecompiledFunctionTable[84728] = bhCheckC2WallN_0x1529b0; // 0x152be8 - g_ps2RecompiledFunctionTable[84729] = bhCheckC2WallN_0x1529b0; // 0x152bec - g_ps2RecompiledFunctionTable[84730] = bhCheckC2WallN_0x1529b0; // 0x152bf0 - g_ps2RecompiledFunctionTable[84731] = bhCheckC2WallN_0x1529b0; // 0x152bf4 - g_ps2RecompiledFunctionTable[84732] = bhCheckC2WallN_0x1529b0; // 0x152bf8 - g_ps2RecompiledFunctionTable[84733] = bhCheckC2WallN_0x1529b0; // 0x152bfc - g_ps2RecompiledFunctionTable[84734] = bhCheckC2WallN_0x1529b0; // 0x152c00 - g_ps2RecompiledFunctionTable[84735] = bhCheckC2WallN_0x1529b0; // 0x152c04 - g_ps2RecompiledFunctionTable[84736] = bhCheckC2WallN_0x1529b0; // 0x152c08 - g_ps2RecompiledFunctionTable[84737] = bhCheckC2WallN_0x1529b0; // 0x152c0c - g_ps2RecompiledFunctionTable[84738] = bhCheckC2WallN_0x1529b0; // 0x152c10 - g_ps2RecompiledFunctionTable[84739] = bhCheckC2WallN_0x1529b0; // 0x152c14 - g_ps2RecompiledFunctionTable[84740] = bhCheckC2WallN_0x1529b0; // 0x152c18 - g_ps2RecompiledFunctionTable[84741] = bhCheckC2WallN_0x1529b0; // 0x152c1c - g_ps2RecompiledFunctionTable[84742] = bhCheckC2WallN_0x1529b0; // 0x152c20 - g_ps2RecompiledFunctionTable[84743] = bhCheckC2WallN_0x1529b0; // 0x152c24 - g_ps2RecompiledFunctionTable[84744] = bhCheckC2WallN_0x1529b0; // 0x152c28 - g_ps2RecompiledFunctionTable[84745] = bhCheckC2WallN_0x1529b0; // 0x152c2c - g_ps2RecompiledFunctionTable[84746] = bhCheckC2WallN_0x1529b0; // 0x152c30 - g_ps2RecompiledFunctionTable[84747] = bhCheckC2WallN_0x1529b0; // 0x152c34 - g_ps2RecompiledFunctionTable[84748] = bhCheckC2WallN_0x1529b0; // 0x152c38 - g_ps2RecompiledFunctionTable[84749] = bhCheckC2WallN_0x1529b0; // 0x152c3c - g_ps2RecompiledFunctionTable[84750] = bhCheckC2WallN_0x1529b0; // 0x152c40 - g_ps2RecompiledFunctionTable[84751] = bhCheckC2WallN_0x1529b0; // 0x152c44 - g_ps2RecompiledFunctionTable[84752] = bhCheckC2WallN_0x1529b0; // 0x152c48 - g_ps2RecompiledFunctionTable[84753] = bhCheckC2WallN_0x1529b0; // 0x152c4c - g_ps2RecompiledFunctionTable[84754] = bhCheckC2WallN_0x1529b0; // 0x152c50 - g_ps2RecompiledFunctionTable[84755] = bhCheckC2WallN_0x1529b0; // 0x152c54 - g_ps2RecompiledFunctionTable[84756] = bhCheckC2WallN_0x1529b0; // 0x152c58 - g_ps2RecompiledFunctionTable[84757] = bhCheckC2WallN_0x1529b0; // 0x152c5c - g_ps2RecompiledFunctionTable[84758] = bhCheckC2WallN_0x1529b0; // 0x152c60 - g_ps2RecompiledFunctionTable[84759] = bhCheckC2WallN_0x1529b0; // 0x152c64 - g_ps2RecompiledFunctionTable[84760] = bhCheckC2WallN_0x1529b0; // 0x152c68 - g_ps2RecompiledFunctionTable[84761] = bhCheckC2WallN_0x1529b0; // 0x152c6c - g_ps2RecompiledFunctionTable[84762] = bhCheckC2WallN_0x1529b0; // 0x152c70 - g_ps2RecompiledFunctionTable[84763] = bhCheckC2WallN_0x1529b0; // 0x152c74 - g_ps2RecompiledFunctionTable[84764] = bhCheckC2WallN_0x1529b0; // 0x152c78 - g_ps2RecompiledFunctionTable[84765] = bhCheckC2WallN_0x1529b0; // 0x152c7c - g_ps2RecompiledFunctionTable[84766] = bhCheckC2WallN_0x1529b0; // 0x152c80 - g_ps2RecompiledFunctionTable[84767] = bhCheckC2WallN_0x1529b0; // 0x152c84 - g_ps2RecompiledFunctionTable[84768] = bhCheckC2WallN_0x1529b0; // 0x152c88 - g_ps2RecompiledFunctionTable[84769] = bhCheckC2WallN_0x1529b0; // 0x152c8c - g_ps2RecompiledFunctionTable[84770] = bhCheckC2WallN_0x1529b0; // 0x152c90 - g_ps2RecompiledFunctionTable[84771] = bhCheckC2WallN_0x1529b0; // 0x152c94 - g_ps2RecompiledFunctionTable[84772] = bhCheckC2WallN_0x1529b0; // 0x152c98 - g_ps2RecompiledFunctionTable[84773] = bhCheckC2WallN_0x1529b0; // 0x152c9c - g_ps2RecompiledFunctionTable[84774] = bhCheckC2WallN_0x1529b0; // 0x152ca0 - g_ps2RecompiledFunctionTable[84775] = bhCheckC2WallN_0x1529b0; // 0x152ca4 - g_ps2RecompiledFunctionTable[84776] = bhCheckC2WallN_0x1529b0; // 0x152ca8 - g_ps2RecompiledFunctionTable[84777] = bhCheckC2WallN_0x1529b0; // 0x152cac - g_ps2RecompiledFunctionTable[84778] = bhCheckC2WallN_0x1529b0; // 0x152cb0 - g_ps2RecompiledFunctionTable[84779] = bhCheckC2WallN_0x1529b0; // 0x152cb4 - g_ps2RecompiledFunctionTable[84780] = bhCheckC2WallN_0x1529b0; // 0x152cb8 - g_ps2RecompiledFunctionTable[84781] = bhCheckC2WallN_0x1529b0; // 0x152cbc - g_ps2RecompiledFunctionTable[84782] = bhCheckC2WallN_0x1529b0; // 0x152cc0 - g_ps2RecompiledFunctionTable[84783] = bhCheckC2WallN_0x1529b0; // 0x152cc4 - g_ps2RecompiledFunctionTable[84784] = bhCheckC2WallN_0x1529b0; // 0x152cc8 - g_ps2RecompiledFunctionTable[84785] = bhCheckC2WallN_0x1529b0; // 0x152ccc - g_ps2RecompiledFunctionTable[84786] = bhCheckC2WallN_0x1529b0; // 0x152cd0 - g_ps2RecompiledFunctionTable[84787] = bhCheckC2WallN_0x1529b0; // 0x152cd4 - g_ps2RecompiledFunctionTable[84788] = bhCheckC2WallN_0x1529b0; // 0x152cd8 - g_ps2RecompiledFunctionTable[84789] = bhCheckC2WallN_0x1529b0; // 0x152cdc - g_ps2RecompiledFunctionTable[84790] = bhCheckC2WallN_0x1529b0; // 0x152ce0 - g_ps2RecompiledFunctionTable[84791] = bhCheckC2WallN_0x1529b0; // 0x152ce4 - g_ps2RecompiledFunctionTable[84792] = bhCheckC2WallN_0x1529b0; // 0x152ce8 - g_ps2RecompiledFunctionTable[84793] = bhCheckC2WallN_0x1529b0; // 0x152cec - g_ps2RecompiledFunctionTable[84794] = bhCheckC2WallN_0x1529b0; // 0x152cf0 - g_ps2RecompiledFunctionTable[84795] = bhCheckC2WallN_0x1529b0; // 0x152cf4 - g_ps2RecompiledFunctionTable[84796] = bhCheckC2WallN_0x1529b0; // 0x152cf8 - g_ps2RecompiledFunctionTable[84797] = bhCheckC2WallN_0x1529b0; // 0x152cfc - g_ps2RecompiledFunctionTable[84798] = bhCheckC2WallN_0x1529b0; // 0x152d00 - g_ps2RecompiledFunctionTable[84799] = bhCheckC2WallN_0x1529b0; // 0x152d04 - g_ps2RecompiledFunctionTable[84800] = bhCheckC2WallN_0x1529b0; // 0x152d08 - g_ps2RecompiledFunctionTable[84801] = bhCheckC2WallN_0x1529b0; // 0x152d0c - g_ps2RecompiledFunctionTable[84802] = bhCheckC2WallN_0x1529b0; // 0x152d10 - g_ps2RecompiledFunctionTable[84803] = bhCheckC2WallN_0x1529b0; // 0x152d14 - g_ps2RecompiledFunctionTable[84804] = bhCheckC2WallN_0x1529b0; // 0x152d18 - g_ps2RecompiledFunctionTable[84805] = bhCheckC2WallN_0x1529b0; // 0x152d1c - g_ps2RecompiledFunctionTable[84806] = bhCheckC2WallN_0x1529b0; // 0x152d20 - g_ps2RecompiledFunctionTable[84807] = bhCheckC2WallN_0x1529b0; // 0x152d24 - g_ps2RecompiledFunctionTable[84808] = bhCheckC2WallN_0x1529b0; // 0x152d28 - g_ps2RecompiledFunctionTable[84809] = bhCheckC2WallN_0x1529b0; // 0x152d2c - g_ps2RecompiledFunctionTable[84810] = bhCheckC2WallN_0x1529b0; // 0x152d30 - g_ps2RecompiledFunctionTable[84811] = bhCheckC2WallN_0x1529b0; // 0x152d34 - g_ps2RecompiledFunctionTable[84812] = bhCheckC2WallN_0x1529b0; // 0x152d38 - g_ps2RecompiledFunctionTable[84813] = bhCheckC2WallN_0x1529b0; // 0x152d3c - g_ps2RecompiledFunctionTable[84814] = bhCheckC2WallN_0x1529b0; // 0x152d40 - g_ps2RecompiledFunctionTable[84815] = bhCheckC2WallN_0x1529b0; // 0x152d44 - g_ps2RecompiledFunctionTable[84816] = bhCheckC2WallN_0x1529b0; // 0x152d48 - g_ps2RecompiledFunctionTable[84817] = bhCheckC2WallN_0x1529b0; // 0x152d4c - g_ps2RecompiledFunctionTable[84818] = bhCheckC2WallN_0x1529b0; // 0x152d50 - g_ps2RecompiledFunctionTable[84819] = bhCheckC2WallN_0x1529b0; // 0x152d54 - g_ps2RecompiledFunctionTable[84820] = bhCheckC2WallN_0x1529b0; // 0x152d58 - g_ps2RecompiledFunctionTable[84821] = bhCheckC2WallN_0x1529b0; // 0x152d5c - g_ps2RecompiledFunctionTable[84822] = bhCheckC2WallN_0x1529b0; // 0x152d60 - g_ps2RecompiledFunctionTable[84823] = bhCheckC2WallN_0x1529b0; // 0x152d64 - g_ps2RecompiledFunctionTable[84824] = bhCheckC2WallN_0x1529b0; // 0x152d68 - g_ps2RecompiledFunctionTable[84825] = bhCheckC2WallN_0x1529b0; // 0x152d6c - g_ps2RecompiledFunctionTable[84826] = bhCheckC2WallN_0x1529b0; // 0x152d70 - g_ps2RecompiledFunctionTable[84827] = bhCheckC2WallN_0x1529b0; // 0x152d74 - g_ps2RecompiledFunctionTable[84828] = bhCheckC2WallN_0x1529b0; // 0x152d78 - g_ps2RecompiledFunctionTable[84829] = bhCheckC2WallN_0x1529b0; // 0x152d7c - g_ps2RecompiledFunctionTable[84830] = bhCheckC2WallN_0x1529b0; // 0x152d80 - g_ps2RecompiledFunctionTable[84831] = bhCheckC2WallN_0x1529b0; // 0x152d84 - g_ps2RecompiledFunctionTable[84832] = bhCheckC2WallN_0x1529b0; // 0x152d88 - g_ps2RecompiledFunctionTable[84833] = bhCheckC2WallN_0x1529b0; // 0x152d8c - g_ps2RecompiledFunctionTable[84834] = bhCheckC2WallN_0x1529b0; // 0x152d90 - g_ps2RecompiledFunctionTable[84835] = bhCheckC2WallN_0x1529b0; // 0x152d94 - g_ps2RecompiledFunctionTable[84836] = bhCheckC2WallN_0x1529b0; // 0x152d98 - g_ps2RecompiledFunctionTable[84837] = bhCheckC2WallN_0x1529b0; // 0x152d9c - g_ps2RecompiledFunctionTable[84838] = bhCheckC2WallN_0x1529b0; // 0x152da0 - g_ps2RecompiledFunctionTable[84839] = bhCheckC2WallN_0x1529b0; // 0x152da4 - g_ps2RecompiledFunctionTable[84840] = bhCheckC2WallN_0x1529b0; // 0x152da8 - g_ps2RecompiledFunctionTable[84841] = bhCheckC2WallN_0x1529b0; // 0x152dac - g_ps2RecompiledFunctionTable[84842] = bhCheckC2WallN_0x1529b0; // 0x152db0 - g_ps2RecompiledFunctionTable[84843] = bhCheckC2WallN_0x1529b0; // 0x152db4 - g_ps2RecompiledFunctionTable[84844] = bhCheckC2WallN_0x1529b0; // 0x152db8 - g_ps2RecompiledFunctionTable[84845] = bhCheckC2WallN_0x1529b0; // 0x152dbc - g_ps2RecompiledFunctionTable[84846] = bhCheckC2WallN_0x1529b0; // 0x152dc0 - g_ps2RecompiledFunctionTable[84847] = bhCheckC2WallN_0x1529b0; // 0x152dc4 - g_ps2RecompiledFunctionTable[84848] = bhCheckC2WallN_0x1529b0; // 0x152dc8 - g_ps2RecompiledFunctionTable[84849] = bhCheckC2WallN_0x1529b0; // 0x152dcc - g_ps2RecompiledFunctionTable[84850] = bhCheckC2WallN_0x1529b0; // 0x152dd0 - g_ps2RecompiledFunctionTable[84851] = bhCheckC2WallN_0x1529b0; // 0x152dd4 - g_ps2RecompiledFunctionTable[84852] = bhCheckC2WallN_0x1529b0; // 0x152dd8 - g_ps2RecompiledFunctionTable[84853] = bhCheckC2WallN_0x1529b0; // 0x152ddc - g_ps2RecompiledFunctionTable[84854] = bhCheckC2WallN_0x1529b0; // 0x152de0 - g_ps2RecompiledFunctionTable[84855] = bhCheckC2WallN_0x1529b0; // 0x152de4 - g_ps2RecompiledFunctionTable[84856] = bhCheckC2WallN_0x1529b0; // 0x152de8 - g_ps2RecompiledFunctionTable[84857] = bhCheckC2WallN_0x1529b0; // 0x152dec - g_ps2RecompiledFunctionTable[84858] = bhCheckC2WallN_0x1529b0; // 0x152df0 - g_ps2RecompiledFunctionTable[84859] = bhCheckC2WallN_0x1529b0; // 0x152df4 - g_ps2RecompiledFunctionTable[84860] = bhCheckC2WallN_0x1529b0; // 0x152df8 - g_ps2RecompiledFunctionTable[84861] = bhCheckC2WallN_0x1529b0; // 0x152dfc - g_ps2RecompiledFunctionTable[84862] = bhCheckC2WallN_0x1529b0; // 0x152e00 - g_ps2RecompiledFunctionTable[84863] = bhCheckC2WallN_0x1529b0; // 0x152e04 - g_ps2RecompiledFunctionTable[84864] = bhCheckC2WallN_0x1529b0; // 0x152e08 - g_ps2RecompiledFunctionTable[84865] = bhCheckC2WallN_0x1529b0; // 0x152e0c - g_ps2RecompiledFunctionTable[84866] = bhCheckC2WallN_0x1529b0; // 0x152e10 - g_ps2RecompiledFunctionTable[84867] = bhCheckC2WallN_0x1529b0; // 0x152e14 - g_ps2RecompiledFunctionTable[84868] = bhCheckC2WallN_0x1529b0; // 0x152e18 - g_ps2RecompiledFunctionTable[84869] = bhCheckC2WallN_0x1529b0; // 0x152e1c - g_ps2RecompiledFunctionTable[84870] = bhCheckC2WallN_0x1529b0; // 0x152e20 - g_ps2RecompiledFunctionTable[84871] = bhCheckC2WallN_0x1529b0; // 0x152e24 - g_ps2RecompiledFunctionTable[84872] = bhCheckC2WallN_0x1529b0; // 0x152e28 - g_ps2RecompiledFunctionTable[84873] = bhCheckC2WallN_0x1529b0; // 0x152e2c - g_ps2RecompiledFunctionTable[84874] = bhCheckC2WallN_0x1529b0; // 0x152e30 - g_ps2RecompiledFunctionTable[84875] = bhCheckC2WallN_0x1529b0; // 0x152e34 - g_ps2RecompiledFunctionTable[84876] = bhCheckC2WallN_0x1529b0; // 0x152e38 - g_ps2RecompiledFunctionTable[84877] = bhCheckC2WallN_0x1529b0; // 0x152e3c - g_ps2RecompiledFunctionTable[84878] = bhCheckC2WallN_0x1529b0; // 0x152e40 - g_ps2RecompiledFunctionTable[84879] = bhCheckC2WallN_0x1529b0; // 0x152e44 - g_ps2RecompiledFunctionTable[84880] = bhCheckC2WallN_0x1529b0; // 0x152e48 - g_ps2RecompiledFunctionTable[84881] = bhCheckC2WallN_0x1529b0; // 0x152e4c - g_ps2RecompiledFunctionTable[84882] = bhCheckC2WallN_0x1529b0; // 0x152e50 - g_ps2RecompiledFunctionTable[84883] = bhCheckC2WallN_0x1529b0; // 0x152e54 - g_ps2RecompiledFunctionTable[84884] = bhCheckC2WallN_0x1529b0; // 0x152e58 - g_ps2RecompiledFunctionTable[84885] = bhCheckC2WallN_0x1529b0; // 0x152e5c - g_ps2RecompiledFunctionTable[84886] = bhCheckC2WallN_0x1529b0; // 0x152e60 - g_ps2RecompiledFunctionTable[84887] = bhCheckC2WallN_0x1529b0; // 0x152e64 - g_ps2RecompiledFunctionTable[84888] = bhCheckC2WallN_0x1529b0; // 0x152e68 - g_ps2RecompiledFunctionTable[84889] = bhCheckC2WallN_0x1529b0; // 0x152e6c - g_ps2RecompiledFunctionTable[84890] = bhCheckC2WallN_0x1529b0; // 0x152e70 - g_ps2RecompiledFunctionTable[84891] = bhCheckC2WallN_0x1529b0; // 0x152e74 - g_ps2RecompiledFunctionTable[84892] = bhCheckC2WallN_0x1529b0; // 0x152e78 - g_ps2RecompiledFunctionTable[84893] = bhCheckC2WallN_0x1529b0; // 0x152e7c - g_ps2RecompiledFunctionTable[84894] = bhCheckC2WallN_0x1529b0; // 0x152e80 - g_ps2RecompiledFunctionTable[84895] = bhCheckC2WallN_0x1529b0; // 0x152e84 - g_ps2RecompiledFunctionTable[84896] = bhCheckC2WallN_0x1529b0; // 0x152e88 - g_ps2RecompiledFunctionTable[84897] = bhCheckC2WallN_0x1529b0; // 0x152e8c - g_ps2RecompiledFunctionTable[84898] = bhCheckC2WallN_0x1529b0; // 0x152e90 - g_ps2RecompiledFunctionTable[84899] = bhCheckC2WallN_0x1529b0; // 0x152e94 - g_ps2RecompiledFunctionTable[84900] = bhCheckC2WallN_0x1529b0; // 0x152e98 - g_ps2RecompiledFunctionTable[84901] = bhCheckC2WallN_0x1529b0; // 0x152e9c - g_ps2RecompiledFunctionTable[84902] = bhCheckC2WallN_0x1529b0; // 0x152ea0 - g_ps2RecompiledFunctionTable[84903] = bhCheckC2WallN_0x1529b0; // 0x152ea4 - g_ps2RecompiledFunctionTable[84904] = bhCheckC2WallN_0x1529b0; // 0x152ea8 - g_ps2RecompiledFunctionTable[84905] = bhCheckC2WallN_0x1529b0; // 0x152eac - g_ps2RecompiledFunctionTable[84906] = bhCheckC2WallN_0x1529b0; // 0x152eb0 - g_ps2RecompiledFunctionTable[84907] = bhCheckC2WallN_0x1529b0; // 0x152eb4 - g_ps2RecompiledFunctionTable[84908] = bhCheckC2WallN_0x1529b0; // 0x152eb8 - g_ps2RecompiledFunctionTable[84909] = bhCheckC2WallN_0x1529b0; // 0x152ebc - g_ps2RecompiledFunctionTable[84910] = bhCheckC2WallN_0x1529b0; // 0x152ec0 - g_ps2RecompiledFunctionTable[84911] = bhCheckC2WallN_0x1529b0; // 0x152ec4 - g_ps2RecompiledFunctionTable[84912] = bhCheckC2WallN_0x1529b0; // 0x152ec8 - g_ps2RecompiledFunctionTable[84913] = bhCheckC2WallN_0x1529b0; // 0x152ecc - g_ps2RecompiledFunctionTable[84914] = bhCheckC2WallN_0x1529b0; // 0x152ed0 - g_ps2RecompiledFunctionTable[84915] = bhCheckC2WallN_0x1529b0; // 0x152ed4 - g_ps2RecompiledFunctionTable[84916] = bhCheckC2WallN_0x1529b0; // 0x152ed8 - g_ps2RecompiledFunctionTable[84917] = bhCheckC2WallN_0x1529b0; // 0x152edc - g_ps2RecompiledFunctionTable[84918] = bhCheckC2WallN_0x1529b0; // 0x152ee0 - g_ps2RecompiledFunctionTable[84919] = bhCheckC2WallN_0x1529b0; // 0x152ee4 - g_ps2RecompiledFunctionTable[84920] = bhCheckC2WallN_0x1529b0; // 0x152ee8 - g_ps2RecompiledFunctionTable[84921] = bhCheckC2WallN_0x1529b0; // 0x152eec - g_ps2RecompiledFunctionTable[84922] = bhCheckC2WallN_0x1529b0; // 0x152ef0 - g_ps2RecompiledFunctionTable[84923] = bhCheckC2WallN_0x1529b0; // 0x152ef4 - g_ps2RecompiledFunctionTable[84924] = bhCheckC2WallN_0x1529b0; // 0x152ef8 - g_ps2RecompiledFunctionTable[84925] = bhCheckC2WallN_0x1529b0; // 0x152efc - g_ps2RecompiledFunctionTable[84926] = bhCheckC2WallN_0x1529b0; // 0x152f00 - g_ps2RecompiledFunctionTable[84927] = bhCheckC2WallN_0x1529b0; // 0x152f04 - g_ps2RecompiledFunctionTable[84928] = bhCheckC2WallN_0x1529b0; // 0x152f08 - g_ps2RecompiledFunctionTable[84929] = bhCheckC2WallN_0x1529b0; // 0x152f0c - g_ps2RecompiledFunctionTable[84930] = bhCheckC2WallN_0x1529b0; // 0x152f10 - g_ps2RecompiledFunctionTable[84931] = bhCheckC2WallN_0x1529b0; // 0x152f14 - g_ps2RecompiledFunctionTable[84932] = bhCheckC2WallN_0x1529b0; // 0x152f18 - g_ps2RecompiledFunctionTable[84933] = bhCheckC2WallN_0x1529b0; // 0x152f1c - g_ps2RecompiledFunctionTable[84934] = bhCheckC2WallN_0x1529b0; // 0x152f20 - g_ps2RecompiledFunctionTable[84935] = bhCheckC2WallN_0x1529b0; // 0x152f24 - g_ps2RecompiledFunctionTable[84936] = bhCheckC2WallN_0x1529b0; // 0x152f28 - g_ps2RecompiledFunctionTable[84937] = bhCheckC2WallN_0x1529b0; // 0x152f2c - g_ps2RecompiledFunctionTable[84938] = bhCheckC2WallN_0x1529b0; // 0x152f30 - g_ps2RecompiledFunctionTable[84939] = bhCheckC2WallN_0x1529b0; // 0x152f34 - g_ps2RecompiledFunctionTable[84940] = bhCheckC2WallN_0x1529b0; // 0x152f38 - g_ps2RecompiledFunctionTable[84941] = bhCheckC2WallN_0x1529b0; // 0x152f3c - g_ps2RecompiledFunctionTable[84942] = bhCheckC2WallN_0x1529b0; // 0x152f40 - g_ps2RecompiledFunctionTable[84943] = bhCheckC2WallN_0x1529b0; // 0x152f44 - g_ps2RecompiledFunctionTable[84944] = bhCheckC2WallN_0x1529b0; // 0x152f48 - g_ps2RecompiledFunctionTable[84945] = bhCheckC2WallN_0x1529b0; // 0x152f4c - g_ps2RecompiledFunctionTable[84946] = bhCheckC2WallN_0x1529b0; // 0x152f50 - g_ps2RecompiledFunctionTable[84947] = bhCheckC2WallN_0x1529b0; // 0x152f54 - g_ps2RecompiledFunctionTable[84948] = bhCheckC2WallN_0x1529b0; // 0x152f58 - g_ps2RecompiledFunctionTable[84949] = bhCheckC2WallN_0x1529b0; // 0x152f5c - g_ps2RecompiledFunctionTable[84950] = bhCheckC2WallN_0x1529b0; // 0x152f60 - g_ps2RecompiledFunctionTable[84951] = bhCheckC2WallN_0x1529b0; // 0x152f64 - g_ps2RecompiledFunctionTable[84952] = bhCheckC2WallN_0x1529b0; // 0x152f68 - g_ps2RecompiledFunctionTable[84953] = bhCheckC2WallN_0x1529b0; // 0x152f6c - g_ps2RecompiledFunctionTable[84954] = bhCheckC2WallN_0x1529b0; // 0x152f70 - g_ps2RecompiledFunctionTable[84955] = bhCheckC2WallN_0x1529b0; // 0x152f74 - g_ps2RecompiledFunctionTable[84956] = bhCheckC2WallN_0x1529b0; // 0x152f78 - g_ps2RecompiledFunctionTable[84957] = bhCheckC2WallN_0x1529b0; // 0x152f7c - g_ps2RecompiledFunctionTable[84958] = bhCheckC2WallN_0x1529b0; // 0x152f80 - g_ps2RecompiledFunctionTable[84959] = bhCheckC2WallN_0x1529b0; // 0x152f84 - g_ps2RecompiledFunctionTable[84960] = bhCheckC2WallN_0x1529b0; // 0x152f88 - g_ps2RecompiledFunctionTable[84961] = bhCheckC2WallN_0x1529b0; // 0x152f8c - g_ps2RecompiledFunctionTable[84962] = bhCheckC2WallN_0x1529b0; // 0x152f90 - g_ps2RecompiledFunctionTable[84963] = bhCheckC2WallN_0x1529b0; // 0x152f94 - g_ps2RecompiledFunctionTable[84964] = bhCheckC2WallN_0x1529b0; // 0x152f98 - g_ps2RecompiledFunctionTable[84965] = bhCheckC2WallN_0x1529b0; // 0x152f9c - g_ps2RecompiledFunctionTable[84966] = bhCheckC2WallN_0x1529b0; // 0x152fa0 - g_ps2RecompiledFunctionTable[84967] = bhCheckC2WallN_0x1529b0; // 0x152fa4 - g_ps2RecompiledFunctionTable[84968] = bhCheckC2WallN_0x1529b0; // 0x152fa8 - g_ps2RecompiledFunctionTable[84969] = bhCheckC2WallN_0x1529b0; // 0x152fac - g_ps2RecompiledFunctionTable[84970] = bhCheckC2WallN_0x1529b0; // 0x152fb0 - g_ps2RecompiledFunctionTable[84971] = bhCheckC2WallN_0x1529b0; // 0x152fb4 - g_ps2RecompiledFunctionTable[84972] = bhCheckC2WallN_0x1529b0; // 0x152fb8 - g_ps2RecompiledFunctionTable[84973] = bhCheckC2WallN_0x1529b0; // 0x152fbc - g_ps2RecompiledFunctionTable[84974] = bhCheckC2WallN_0x1529b0; // 0x152fc0 - g_ps2RecompiledFunctionTable[84975] = bhCheckC2WallN_0x1529b0; // 0x152fc4 - g_ps2RecompiledFunctionTable[84976] = bhCheckC2WallN_0x1529b0; // 0x152fc8 - g_ps2RecompiledFunctionTable[84977] = bhCheckC2WallN_0x1529b0; // 0x152fcc - g_ps2RecompiledFunctionTable[84978] = bhCheckC2WallN_0x1529b0; // 0x152fd0 - g_ps2RecompiledFunctionTable[84979] = bhCheckC2WallN_0x1529b0; // 0x152fd4 - g_ps2RecompiledFunctionTable[84980] = bhCheckC2WallN_0x1529b0; // 0x152fd8 - g_ps2RecompiledFunctionTable[84981] = bhCheckC2WallN_0x1529b0; // 0x152fdc - g_ps2RecompiledFunctionTable[84982] = bhCheckC2WallN_0x1529b0; // 0x152fe0 - g_ps2RecompiledFunctionTable[84983] = bhCheckC2WallN_0x1529b0; // 0x152fe4 - g_ps2RecompiledFunctionTable[84984] = bhCheckC2WallN_0x1529b0; // 0x152fe8 - g_ps2RecompiledFunctionTable[84985] = bhCheckC2WallN_0x1529b0; // 0x152fec - g_ps2RecompiledFunctionTable[84986] = bhCheckC2WallN_0x1529b0; // 0x152ff0 - g_ps2RecompiledFunctionTable[84987] = bhCheckC2WallN_0x1529b0; // 0x152ff4 - g_ps2RecompiledFunctionTable[84988] = bhCheckC2WallN_0x1529b0; // 0x152ff8 - g_ps2RecompiledFunctionTable[84989] = bhCheckC2WallN_0x1529b0; // 0x152ffc - g_ps2RecompiledFunctionTable[84990] = bhCheckC2WallN_0x1529b0; // 0x153000 - g_ps2RecompiledFunctionTable[84991] = bhCheckC2WallN_0x1529b0; // 0x153004 - g_ps2RecompiledFunctionTable[84992] = bhCheckC2WallN_0x1529b0; // 0x153008 - g_ps2RecompiledFunctionTable[84993] = bhCheckC2WallN_0x1529b0; // 0x15300c - g_ps2RecompiledFunctionTable[84994] = bhCheckC2WallN_0x1529b0; // 0x153010 - g_ps2RecompiledFunctionTable[84995] = bhCheckC2WallN_0x1529b0; // 0x153014 - g_ps2RecompiledFunctionTable[84996] = bhCheckC2WallN_0x1529b0; // 0x153018 - g_ps2RecompiledFunctionTable[84997] = bhCheckC2WallN_0x1529b0; // 0x15301c - g_ps2RecompiledFunctionTable[84998] = bhCheckC2WallN_0x1529b0; // 0x153020 - g_ps2RecompiledFunctionTable[84999] = bhCheckC2WallN_0x1529b0; // 0x153024 - g_ps2RecompiledFunctionTable[85000] = bhCheckC2WallN_0x1529b0; // 0x153028 - g_ps2RecompiledFunctionTable[85001] = bhCheckC2WallN_0x1529b0; // 0x15302c - g_ps2RecompiledFunctionTable[85002] = bhCheckC2WallN_0x1529b0; // 0x153030 - g_ps2RecompiledFunctionTable[85003] = bhCheckC2WallN_0x1529b0; // 0x153034 - g_ps2RecompiledFunctionTable[85004] = bhCheckC2WallN_0x1529b0; // 0x153038 - g_ps2RecompiledFunctionTable[85005] = bhCheckC2WallN_0x1529b0; // 0x15303c - g_ps2RecompiledFunctionTable[85006] = bhCheckC2WallN_0x1529b0; // 0x153040 - g_ps2RecompiledFunctionTable[85007] = bhCheckC2WallN_0x1529b0; // 0x153044 - g_ps2RecompiledFunctionTable[85008] = bhCheckC2WallN_0x1529b0; // 0x153048 - g_ps2RecompiledFunctionTable[85009] = bhCheckC2WallN_0x1529b0; // 0x15304c - g_ps2RecompiledFunctionTable[85010] = bhCheckC2WallN_0x1529b0; // 0x153050 - g_ps2RecompiledFunctionTable[85011] = bhCheckC2WallN_0x1529b0; // 0x153054 - g_ps2RecompiledFunctionTable[85012] = bhCheckC2WallN_0x1529b0; // 0x153058 - g_ps2RecompiledFunctionTable[85013] = bhCheckC2WallN_0x1529b0; // 0x15305c - g_ps2RecompiledFunctionTable[85014] = bhCheckC2WallN_0x1529b0; // 0x153060 - g_ps2RecompiledFunctionTable[85015] = bhCheckC2WallN_0x1529b0; // 0x153064 - g_ps2RecompiledFunctionTable[85016] = bhCheckC2WallN_0x1529b0; // 0x153068 - g_ps2RecompiledFunctionTable[85017] = bhCheckC2WallN_0x1529b0; // 0x15306c - g_ps2RecompiledFunctionTable[85018] = bhCheckC2WallN_0x1529b0; // 0x153070 - g_ps2RecompiledFunctionTable[85019] = bhCheckC2WallN_0x1529b0; // 0x153074 - g_ps2RecompiledFunctionTable[85020] = bhCheckC2WallN_0x1529b0; // 0x153078 - g_ps2RecompiledFunctionTable[85021] = bhCheckC2WallN_0x1529b0; // 0x15307c - g_ps2RecompiledFunctionTable[85022] = bhCheckC2WallN_0x1529b0; // 0x153080 - g_ps2RecompiledFunctionTable[85023] = bhCheckC2WallN_0x1529b0; // 0x153084 - g_ps2RecompiledFunctionTable[85024] = bhCheckC2WallN_0x1529b0; // 0x153088 - g_ps2RecompiledFunctionTable[85025] = bhCheckC2WallN_0x1529b0; // 0x15308c - g_ps2RecompiledFunctionTable[85026] = bhCheckC2WallN_0x1529b0; // 0x153090 - g_ps2RecompiledFunctionTable[85027] = bhCheckC2WallN_0x1529b0; // 0x153094 - g_ps2RecompiledFunctionTable[85028] = bhCheckC2WallN_0x1529b0; // 0x153098 - g_ps2RecompiledFunctionTable[85029] = bhCheckC2WallN_0x1529b0; // 0x15309c - g_ps2RecompiledFunctionTable[85030] = bhCheckC2WallN_0x1529b0; // 0x1530a0 - g_ps2RecompiledFunctionTable[85031] = bhCheckC2WallN_0x1529b0; // 0x1530a4 - g_ps2RecompiledFunctionTable[85032] = bhCheckC2WallN_0x1529b0; // 0x1530a8 - g_ps2RecompiledFunctionTable[85033] = bhCheckC2WallN_0x1529b0; // 0x1530ac - g_ps2RecompiledFunctionTable[85034] = bhCheckC2WallN_0x1529b0; // 0x1530b0 - g_ps2RecompiledFunctionTable[85035] = bhCheckC2WallN_0x1529b0; // 0x1530b4 - g_ps2RecompiledFunctionTable[85036] = bhCheckC2WallN_0x1529b0; // 0x1530b8 - g_ps2RecompiledFunctionTable[85037] = bhCheckC2WallN_0x1529b0; // 0x1530bc - g_ps2RecompiledFunctionTable[85038] = bhCheckC2WallN_0x1529b0; // 0x1530c0 - g_ps2RecompiledFunctionTable[85039] = bhCheckC2WallN_0x1529b0; // 0x1530c4 - g_ps2RecompiledFunctionTable[85040] = bhCheckC2WallN_0x1529b0; // 0x1530c8 - g_ps2RecompiledFunctionTable[85041] = bhCheckC2WallN_0x1529b0; // 0x1530cc - g_ps2RecompiledFunctionTable[85042] = bhCheckC2WallN_0x1529b0; // 0x1530d0 - g_ps2RecompiledFunctionTable[85043] = bhCheckC2WallN_0x1529b0; // 0x1530d4 - g_ps2RecompiledFunctionTable[85044] = bhCheckC2WallN_0x1529b0; // 0x1530d8 - g_ps2RecompiledFunctionTable[85045] = bhCheckC2WallN_0x1529b0; // 0x1530dc - g_ps2RecompiledFunctionTable[85046] = bhCheckC2WallN_0x1529b0; // 0x1530e0 - g_ps2RecompiledFunctionTable[85047] = bhCheckC2WallN_0x1529b0; // 0x1530e4 - g_ps2RecompiledFunctionTable[85048] = bhCheckC2WallN_0x1529b0; // 0x1530e8 - g_ps2RecompiledFunctionTable[85049] = bhCheckC2WallN_0x1529b0; // 0x1530ec - g_ps2RecompiledFunctionTable[85050] = bhCheckC2WallN_0x1529b0; // 0x1530f0 - g_ps2RecompiledFunctionTable[85051] = bhCheckC2WallN_0x1529b0; // 0x1530f4 - g_ps2RecompiledFunctionTable[85052] = bhCheckC2WallN_0x1529b0; // 0x1530f8 - g_ps2RecompiledFunctionTable[85053] = bhCheckC2WallN_0x1529b0; // 0x1530fc - g_ps2RecompiledFunctionTable[85054] = bhCheckC2WallN_0x1529b0; // 0x153100 - g_ps2RecompiledFunctionTable[85055] = bhCheckC2WallN_0x1529b0; // 0x153104 - g_ps2RecompiledFunctionTable[85056] = bhCheckC2WallN_0x1529b0; // 0x153108 - g_ps2RecompiledFunctionTable[85057] = bhCheckC2WallN_0x1529b0; // 0x15310c - g_ps2RecompiledFunctionTable[85058] = bhCheckC2WallN_0x1529b0; // 0x153110 - g_ps2RecompiledFunctionTable[85059] = bhCheckC2WallN_0x1529b0; // 0x153114 - g_ps2RecompiledFunctionTable[85060] = bhCheckC2WallN_0x1529b0; // 0x153118 - g_ps2RecompiledFunctionTable[85061] = bhCheckC2WallN_0x1529b0; // 0x15311c - g_ps2RecompiledFunctionTable[85062] = bhCheckC2WallN_0x1529b0; // 0x153120 - g_ps2RecompiledFunctionTable[85063] = bhCheckC2WallN_0x1529b0; // 0x153124 - g_ps2RecompiledFunctionTable[85064] = bhCheckC2WallN_0x1529b0; // 0x153128 - g_ps2RecompiledFunctionTable[85065] = bhCheckC2WallN_0x1529b0; // 0x15312c - g_ps2RecompiledFunctionTable[85066] = bhCheckC2WallN_0x1529b0; // 0x153130 - g_ps2RecompiledFunctionTable[85067] = bhCheckC2WallN_0x1529b0; // 0x153134 - g_ps2RecompiledFunctionTable[85068] = bhCheckC2WallN_0x1529b0; // 0x153138 - g_ps2RecompiledFunctionTable[85069] = bhCheckC2WallN_0x1529b0; // 0x15313c - g_ps2RecompiledFunctionTable[85070] = bhCheckC2WallN_0x1529b0; // 0x153140 - g_ps2RecompiledFunctionTable[85071] = bhCheckC2WallN_0x1529b0; // 0x153144 - g_ps2RecompiledFunctionTable[85072] = bhCheckC2WallN_0x1529b0; // 0x153148 - g_ps2RecompiledFunctionTable[85073] = bhCheckC2WallN_0x1529b0; // 0x15314c - g_ps2RecompiledFunctionTable[85074] = bhCheckC2WallN_0x1529b0; // 0x153150 - g_ps2RecompiledFunctionTable[85075] = bhCheckC2WallN_0x1529b0; // 0x153154 - g_ps2RecompiledFunctionTable[85076] = bhCheckC2WallN_0x1529b0; // 0x153158 - g_ps2RecompiledFunctionTable[85077] = bhCheckC2WallN_0x1529b0; // 0x15315c - g_ps2RecompiledFunctionTable[85078] = bhCheckC2WallN_0x1529b0; // 0x153160 - g_ps2RecompiledFunctionTable[85079] = bhCheckC2WallN_0x1529b0; // 0x153164 - g_ps2RecompiledFunctionTable[85080] = bhCheckC2WallN_0x1529b0; // 0x153168 - g_ps2RecompiledFunctionTable[85081] = bhCheckC2WallN_0x1529b0; // 0x15316c - g_ps2RecompiledFunctionTable[85082] = bhCheckC2WallN_0x1529b0; // 0x153170 - g_ps2RecompiledFunctionTable[85083] = bhCheckC2WallN_0x1529b0; // 0x153174 - g_ps2RecompiledFunctionTable[85084] = bhCheckC2WallN_0x1529b0; // 0x153178 - g_ps2RecompiledFunctionTable[85085] = bhCheckC2WallN_0x1529b0; // 0x15317c - g_ps2RecompiledFunctionTable[85086] = bhCheckC2WallN_0x1529b0; // 0x153180 - g_ps2RecompiledFunctionTable[85087] = bhCheckC2WallN_0x1529b0; // 0x153184 - g_ps2RecompiledFunctionTable[85088] = bhCheckC2WallN_0x1529b0; // 0x153188 - g_ps2RecompiledFunctionTable[85089] = bhCheckC2WallN_0x1529b0; // 0x15318c - g_ps2RecompiledFunctionTable[85090] = bhCheckC2WallN_0x1529b0; // 0x153190 - g_ps2RecompiledFunctionTable[85091] = bhCheckC2WallN_0x1529b0; // 0x153194 - g_ps2RecompiledFunctionTable[85092] = bhCheckC2WallN_0x1529b0; // 0x153198 - g_ps2RecompiledFunctionTable[85093] = bhCheckC2WallN_0x1529b0; // 0x15319c - g_ps2RecompiledFunctionTable[85094] = bhCheckC2WallN_0x1529b0; // 0x1531a0 - g_ps2RecompiledFunctionTable[85095] = bhCheckC2WallN_0x1529b0; // 0x1531a4 - g_ps2RecompiledFunctionTable[85096] = bhCheckC2WallN_0x1529b0; // 0x1531a8 - g_ps2RecompiledFunctionTable[85097] = bhCheckC2WallN_0x1529b0; // 0x1531ac - g_ps2RecompiledFunctionTable[85098] = bhCheckC2WallN_0x1529b0; // 0x1531b0 - g_ps2RecompiledFunctionTable[85099] = bhCheckC2WallN_0x1529b0; // 0x1531b4 - g_ps2RecompiledFunctionTable[85100] = bhCheckC2WallN_0x1529b0; // 0x1531b8 - g_ps2RecompiledFunctionTable[85101] = bhCheckC2WallN_0x1529b0; // 0x1531bc - g_ps2RecompiledFunctionTable[85102] = bhCheckC2WallN_0x1529b0; // 0x1531c0 - g_ps2RecompiledFunctionTable[85103] = bhCheckC2WallN_0x1529b0; // 0x1531c4 - g_ps2RecompiledFunctionTable[85104] = bhCheckC2WallN_0x1529b0; // 0x1531c8 - g_ps2RecompiledFunctionTable[85105] = bhCheckC2WallN_0x1529b0; // 0x1531cc - g_ps2RecompiledFunctionTable[85106] = bhCheckC2WallN_0x1529b0; // 0x1531d0 - g_ps2RecompiledFunctionTable[85107] = bhCheckC2WallN_0x1529b0; // 0x1531d4 - g_ps2RecompiledFunctionTable[85108] = bhCheckC2WallN_0x1529b0; // 0x1531d8 - g_ps2RecompiledFunctionTable[85109] = bhCheckC2WallN_0x1529b0; // 0x1531dc - g_ps2RecompiledFunctionTable[85110] = bhCheckC2WallN_0x1529b0; // 0x1531e0 - g_ps2RecompiledFunctionTable[85111] = bhCheckC2WallN_0x1529b0; // 0x1531e4 - g_ps2RecompiledFunctionTable[85112] = bhCheckC2WallN_0x1529b0; // 0x1531e8 - g_ps2RecompiledFunctionTable[85113] = bhCheckC2WallN_0x1529b0; // 0x1531ec - g_ps2RecompiledFunctionTable[85114] = bhCheckC2WallN_0x1529b0; // 0x1531f0 - g_ps2RecompiledFunctionTable[85115] = bhCheckC2WallN_0x1529b0; // 0x1531f4 - g_ps2RecompiledFunctionTable[85116] = bhCheckC2WallN_0x1529b0; // 0x1531f8 - g_ps2RecompiledFunctionTable[85117] = bhCheckC2WallN_0x1529b0; // 0x1531fc - g_ps2RecompiledFunctionTable[85118] = bhCheckC2WallN_0x1529b0; // 0x153200 - g_ps2RecompiledFunctionTable[85119] = bhCheckC2WallN_0x1529b0; // 0x153204 - g_ps2RecompiledFunctionTable[85120] = bhCheckC2WallN_0x1529b0; // 0x153208 - g_ps2RecompiledFunctionTable[85121] = bhCheckC2WallN_0x1529b0; // 0x15320c - g_ps2RecompiledFunctionTable[85122] = bhCheckClipModel_0x153210; // 0x153210 - g_ps2RecompiledFunctionTable[85135] = bhCheckClipModel_0x153210; // 0x153244 - g_ps2RecompiledFunctionTable[85149] = bhCheckClipModel_0x153210; // 0x15327c - g_ps2RecompiledFunctionTable[85156] = bhCheckClipModel_0x153210; // 0x153298 - g_ps2RecompiledFunctionTable[85206] = bhCheckClipPoint_0x153360; // 0x153360 - g_ps2RecompiledFunctionTable[85215] = bhCheckClipPoint_0x153360; // 0x153384 - g_ps2RecompiledFunctionTable[85220] = bhCheckClipPoint_0x153360; // 0x153398 - g_ps2RecompiledFunctionTable[85262] = bhSetWaterSplash_0x153440; // 0x153440 - g_ps2RecompiledFunctionTable[85294] = bhSetWaterSplash_0x153440; // 0x1534c0 - g_ps2RecompiledFunctionTable[85297] = bhSetWaterSplash_0x153440; // 0x1534cc - g_ps2RecompiledFunctionTable[85377] = bhSetWaterSplash_0x153440; // 0x15360c - g_ps2RecompiledFunctionTable[85393] = bhSetWaterSplash_0x153440; // 0x15364c - g_ps2RecompiledFunctionTable[85410] = bhSetWaterSplash_0x153440; // 0x153690 - g_ps2RecompiledFunctionTable[85422] = bhSetWaterSplash2_0x1536c0; // 0x1536c0 - g_ps2RecompiledFunctionTable[85446] = bhSetWaterSplash2_0x1536c0; // 0x153720 - g_ps2RecompiledFunctionTable[85449] = bhSetWaterSplash2_0x1536c0; // 0x15372c - g_ps2RecompiledFunctionTable[85529] = bhSetWaterSplash2_0x1536c0; // 0x15386c - g_ps2RecompiledFunctionTable[85545] = bhSetWaterSplash2_0x1536c0; // 0x1538ac - g_ps2RecompiledFunctionTable[85562] = bhSetWaterSplash2_0x1536c0; // 0x1538f0 - g_ps2RecompiledFunctionTable[85574] = bhSetWaterSplash3_0x153920; // 0x153920 - g_ps2RecompiledFunctionTable[85653] = bhSetWaterSplash3_0x153920; // 0x153a5c - g_ps2RecompiledFunctionTable[85668] = bhSetWaterSplash3_0x153920; // 0x153a98 - g_ps2RecompiledFunctionTable[85674] = bhSetWaterSplash4_0x153ab0; // 0x153ab0 - g_ps2RecompiledFunctionTable[85754] = bhSetWaterSplash4_0x153ab0; // 0x153bf0 - g_ps2RecompiledFunctionTable[85769] = bhSetWaterSplash4_0x153ab0; // 0x153c2c - g_ps2RecompiledFunctionTable[85774] = bhSetGunFire_0x153c40; // 0x153c40 - g_ps2RecompiledFunctionTable[85966] = bhSetGunFire_0x153c40; // 0x153f40 - g_ps2RecompiledFunctionTable[86027] = bhSetGunFire_0x153c40; // 0x154034 - g_ps2RecompiledFunctionTable[86100] = bhSetGunFire_0x153c40; // 0x154158 - g_ps2RecompiledFunctionTable[86117] = bhSetGunFire_0x153c40; // 0x15419c - g_ps2RecompiledFunctionTable[86122] = bhSetGunFire_0x153c40; // 0x1541b0 - g_ps2RecompiledFunctionTable[86130] = bhSetGunFire_0x153c40; // 0x1541d0 - g_ps2RecompiledFunctionTable[86168] = bhSetGunFire_0x153c40; // 0x154268 - g_ps2RecompiledFunctionTable[86176] = bhSetGunFire_0x153c40; // 0x154288 - g_ps2RecompiledFunctionTable[86181] = bhSetGunFire_0x153c40; // 0x15429c - g_ps2RecompiledFunctionTable[86186] = bhSetGunFire_0x153c40; // 0x1542b0 - g_ps2RecompiledFunctionTable[86195] = bhSetGunFire_0x153c40; // 0x1542d4 - g_ps2RecompiledFunctionTable[86202] = bhSetGunFire_0x153c40; // 0x1542f0 - g_ps2RecompiledFunctionTable[86215] = bhSetGunFire_0x153c40; // 0x154324 - g_ps2RecompiledFunctionTable[86274] = bhSetGunFire_0x153c40; // 0x154410 - g_ps2RecompiledFunctionTable[86308] = bhSetGunFire_0x153c40; // 0x154498 - g_ps2RecompiledFunctionTable[86315] = bhSetGunFire_0x153c40; // 0x1544b4 - g_ps2RecompiledFunctionTable[86323] = bhSetGunFire_0x153c40; // 0x1544d4 - g_ps2RecompiledFunctionTable[86443] = bhSetGunFire_0x153c40; // 0x1546b4 - g_ps2RecompiledFunctionTable[86489] = bhSetGunFire_0x153c40; // 0x15476c - g_ps2RecompiledFunctionTable[86498] = bhSetGunFire_0x153c40; // 0x154790 - g_ps2RecompiledFunctionTable[86522] = bhSetGunFire_0x153c40; // 0x1547f0 - g_ps2RecompiledFunctionTable[86531] = bhSetGunFire_0x153c40; // 0x154814 - g_ps2RecompiledFunctionTable[86556] = bhSetGunFire_0x153c40; // 0x154878 - g_ps2RecompiledFunctionTable[86567] = bhSetGunFire_0x153c40; // 0x1548a4 - g_ps2RecompiledFunctionTable[86597] = bhSetGunFire_0x153c40; // 0x15491c - g_ps2RecompiledFunctionTable[86614] = bhSetGunFire_0x153c40; // 0x154960 - g_ps2RecompiledFunctionTable[86619] = bhSetGunFire_0x153c40; // 0x154974 - g_ps2RecompiledFunctionTable[86656] = bhSetGunFire_0x153c40; // 0x154a08 - g_ps2RecompiledFunctionTable[86684] = bhSetGunFire_0x153c40; // 0x154a78 - g_ps2RecompiledFunctionTable[86686] = bhSetGunFire_0x153c40; // 0x154a80 - g_ps2RecompiledFunctionTable[86689] = bhSetGunFire_0x153c40; // 0x154a8c - g_ps2RecompiledFunctionTable[86694] = bhSetGunFire_0x153c40; // 0x154aa0 - g_ps2RecompiledFunctionTable[86697] = bhSetGunFire_0x153c40; // 0x154aac - g_ps2RecompiledFunctionTable[86718] = bhSetGunFire_0x153c40; // 0x154b00 - g_ps2RecompiledFunctionTable[86781] = bhSetGunFire_0x153c40; // 0x154bfc - g_ps2RecompiledFunctionTable[86785] = bhSetGunFire_0x153c40; // 0x154c0c - g_ps2RecompiledFunctionTable[86794] = bhSetGunFire_0x153c40; // 0x154c30 - g_ps2RecompiledFunctionTable[86815] = bhSetGunFire_0x153c40; // 0x154c84 - g_ps2RecompiledFunctionTable[86825] = bhSetGunFire_0x153c40; // 0x154cac - g_ps2RecompiledFunctionTable[86828] = bhSetGunFire_0x153c40; // 0x154cb8 - g_ps2RecompiledFunctionTable[86831] = bhSetGunFire_0x153c40; // 0x154cc4 - g_ps2RecompiledFunctionTable[86836] = bhSetGunFire_0x153c40; // 0x154cd8 - g_ps2RecompiledFunctionTable[86840] = bhSetGunFire_0x153c40; // 0x154ce8 - g_ps2RecompiledFunctionTable[86865] = bhSetGunFire_0x153c40; // 0x154d4c - g_ps2RecompiledFunctionTable[86888] = bhSetGunFire_0x153c40; // 0x154da8 - g_ps2RecompiledFunctionTable[86978] = bhSetGunFire_0x153c40; // 0x154f10 - g_ps2RecompiledFunctionTable[87010] = bhSetGunFire_0x153c40; // 0x154f90 - g_ps2RecompiledFunctionTable[87043] = bhSetGunFire_0x153c40; // 0x155014 - g_ps2RecompiledFunctionTable[87075] = bhSetGunFire_0x153c40; // 0x155094 - g_ps2RecompiledFunctionTable[87090] = bhSetYakkyou_0x1550d0; // 0x1550d0 - g_ps2RecompiledFunctionTable[87242] = bhSetYakkyou_0x1550d0; // 0x155330 - g_ps2RecompiledFunctionTable[87258] = bhSetYakkyou_0x1550d0; // 0x155370 - g_ps2RecompiledFunctionTable[87263] = bhSetYakkyou_0x1550d0; // 0x155384 - g_ps2RecompiledFunctionTable[87269] = bhSetYakkyou_0x1550d0; // 0x15539c - g_ps2RecompiledFunctionTable[87337] = bhSetYakkyou_0x1550d0; // 0x1554ac - g_ps2RecompiledFunctionTable[87346] = bhSetYakkyou_0x1550d0; // 0x1554d0 - g_ps2RecompiledFunctionTable[87353] = bhSetYakkyou_0x1550d0; // 0x1554ec - g_ps2RecompiledFunctionTable[87441] = bhSetYakkyou_0x1550d0; // 0x15564c - g_ps2RecompiledFunctionTable[87454] = bhSetMagazine_0x155680; // 0x155680 - g_ps2RecompiledFunctionTable[87521] = bhSetMagazine_0x155680; // 0x15578c - g_ps2RecompiledFunctionTable[87538] = bhSetLighterFire_0x1557d0; // 0x1557d0 - g_ps2RecompiledFunctionTable[87616] = bhSetLighterFire_0x1557d0; // 0x155908 - g_ps2RecompiledFunctionTable[87628] = bhSetLighterFire_0x1557d0; // 0x155938 - g_ps2RecompiledFunctionTable[87662] = bhInitEvent_0x1559c0; // 0x1559c0 - g_ps2RecompiledFunctionTable[87667] = bhInitEvent_0x1559c0; // 0x1559d4 - g_ps2RecompiledFunctionTable[87676] = bhInitEvent_0x1559c0; // 0x1559f8 - g_ps2RecompiledFunctionTable[87678] = bhInitEvent_0x1559c0; // 0x155a00 - g_ps2RecompiledFunctionTable[87711] = bhInitEvent_0x1559c0; // 0x155a84 - g_ps2RecompiledFunctionTable[87717] = bhInitEvent_0x1559c0; // 0x155a9c - g_ps2RecompiledFunctionTable[87725] = bhInitEvent_0x1559c0; // 0x155abc - g_ps2RecompiledFunctionTable[87730] = bhControlEvent_0x155ad0; // 0x155ad0 - g_ps2RecompiledFunctionTable[87735] = bhControlEvent_0x155ad0; // 0x155ae4 - g_ps2RecompiledFunctionTable[87737] = bhControlEvent_0x155ad0; // 0x155aec - g_ps2RecompiledFunctionTable[87742] = bhEnd_0x155b00; // 0x155b00 - g_ps2RecompiledFunctionTable[87746] = bhIfelCk_0x155b10; // 0x155b10 - g_ps2RecompiledFunctionTable[87770] = bhElseCk_0x155b70; // 0x155b70 - g_ps2RecompiledFunctionTable[87790] = bhEndif_0x155bc0; // 0x155bc0 - g_ps2RecompiledFunctionTable[87810] = dm0_0x155c10; // 0x155c10 - g_ps2RecompiledFunctionTable[87814] = bhCk_0x155c20; // 0x155c20 - g_ps2RecompiledFunctionTable[87954] = bhSet_0x155e50; // 0x155e50 - g_ps2RecompiledFunctionTable[88094] = bhCmpB_0x156080; // 0x156080 - g_ps2RecompiledFunctionTable[88206] = bhCmpW_0x156240; // 0x156240 - g_ps2RecompiledFunctionTable[88306] = bhSv_0x1563d0; // 0x1563d0 - g_ps2RecompiledFunctionTable[88426] = bhSvW_0x1565b0; // 0x1565b0 - g_ps2RecompiledFunctionTable[88550] = bhEvtOn_0x1567a0; // 0x1567a0 - g_ps2RecompiledFunctionTable[88563] = bhEvtOn_0x1567a0; // 0x1567d4 - g_ps2RecompiledFunctionTable[88574] = bhCamSet_0x156800; // 0x156800 - g_ps2RecompiledFunctionTable[88616] = bhCamSet_0x156800; // 0x1568a8 - g_ps2RecompiledFunctionTable[88624] = bhCamSet_0x156800; // 0x1568c8 - g_ps2RecompiledFunctionTable[88632] = bhCamSet_0x156800; // 0x1568e8 - g_ps2RecompiledFunctionTable[88642] = bhCamSet_0x156800; // 0x156910 - g_ps2RecompiledFunctionTable[88659] = bhCamSet_0x156800; // 0x156954 - g_ps2RecompiledFunctionTable[88666] = bhCamSet_0x156800; // 0x156970 - g_ps2RecompiledFunctionTable[88674] = bhCamSet_0x156800; // 0x156990 - g_ps2RecompiledFunctionTable[88678] = bhCamSet2_0x1569a0; // 0x1569a0 - g_ps2RecompiledFunctionTable[88735] = bhCamSet2_0x1569a0; // 0x156a84 - g_ps2RecompiledFunctionTable[88754] = bhCamPauseSet_0x156ad0; // 0x156ad0 - g_ps2RecompiledFunctionTable[88782] = bhMessageSet_0x156b40; // 0x156b40 - g_ps2RecompiledFunctionTable[88816] = bhMessageSet_0x156b40; // 0x156bc8 - g_ps2RecompiledFunctionTable[88834] = bhBgmOn_0x156c10; // 0x156c10 - g_ps2RecompiledFunctionTable[88862] = bhBgmOn_0x156c10; // 0x156c80 - g_ps2RecompiledFunctionTable[88866] = bhBgmOff_0x156c90; // 0x156c90 - g_ps2RecompiledFunctionTable[88883] = bhBgmOff_0x156c90; // 0x156cd4 - g_ps2RecompiledFunctionTable[88890] = bhSeOn_0x156cf0; // 0x156cf0 - g_ps2RecompiledFunctionTable[89006] = bhSeOn_0x156cf0; // 0x156ec0 - g_ps2RecompiledFunctionTable[89010] = bhSeOff_0x156ed0; // 0x156ed0 - g_ps2RecompiledFunctionTable[89024] = bhSeOff_0x156ed0; // 0x156f08 - g_ps2RecompiledFunctionTable[89030] = bhBGSeOn_0x156f20; // 0x156f20 - g_ps2RecompiledFunctionTable[89061] = bhBGSeOn_0x156f20; // 0x156f9c - g_ps2RecompiledFunctionTable[89066] = bhBGSeOff_0x156fb0; // 0x156fb0 - g_ps2RecompiledFunctionTable[89091] = bhBGSeOff_0x156fb0; // 0x157014 - g_ps2RecompiledFunctionTable[89098] = bhUseItemCheck_0x157030; // 0x157030 - g_ps2RecompiledFunctionTable[89126] = bhArmsItemCheck_0x1570a0; // 0x1570a0 - g_ps2RecompiledFunctionTable[89146] = bhArmsItemChange_0x1570f0; // 0x1570f0 - g_ps2RecompiledFunctionTable[89174] = bhPlItemLost_0x157160; // 0x157160 - g_ps2RecompiledFunctionTable[89194] = bhPlItemLost_0x157160; // 0x1571b0 - g_ps2RecompiledFunctionTable[89226] = bhPlItemLost_0x157160; // 0x157230 - g_ps2RecompiledFunctionTable[89250] = bhUseItemClear_0x157290; // 0x157290 - g_ps2RecompiledFunctionTable[89266] = bhPlItemCheck_0x1572d0; // 0x1572d0 - g_ps2RecompiledFunctionTable[89286] = bhPlItemCheck_0x1572d0; // 0x157320 - g_ps2RecompiledFunctionTable[89318] = bhMovieStart_0x1573a0; // 0x1573a0 - g_ps2RecompiledFunctionTable[89350] = bhMovieStop_0x157420; // 0x157420 - g_ps2RecompiledFunctionTable[89366] = bhVoiceOn_0x157460; // 0x157460 - g_ps2RecompiledFunctionTable[89419] = bhVoiceOn_0x157460; // 0x157534 - g_ps2RecompiledFunctionTable[89505] = bhVoiceOn_0x157460; // 0x15768c - g_ps2RecompiledFunctionTable[89514] = bhVoiceOff_0x1576b0; // 0x1576b0 - g_ps2RecompiledFunctionTable[89534] = bhVoiceOff_0x1576b0; // 0x157700 - g_ps2RecompiledFunctionTable[89538] = bhAdxCk_0x157710; // 0x157710 - g_ps2RecompiledFunctionTable[89562] = bhAdxTimeCk_0x157770; // 0x157770 - g_ps2RecompiledFunctionTable[89590] = bhAdxTimeCk_0x157770; // 0x1577e0 - g_ps2RecompiledFunctionTable[89638] = bhCineSet_0x1578a0; // 0x1578a0 - g_ps2RecompiledFunctionTable[89810] = bhWalAtariSet_0x157b50; // 0x157b50 - g_ps2RecompiledFunctionTable[89846] = bhEtcAtariSet_0x157be0; // 0x157be0 - g_ps2RecompiledFunctionTable[89882] = bhFlrAtariSet_0x157c70; // 0x157c70 - g_ps2RecompiledFunctionTable[89918] = bhSubStatus_0x157d00; // 0x157d00 - g_ps2RecompiledFunctionTable[89930] = bhMotionPauseSet_0x157d30; // 0x157d30 - g_ps2RecompiledFunctionTable[89978] = bhMotionPauseSetPly_0x157df0; // 0x157df0 - g_ps2RecompiledFunctionTable[90010] = bhInitMotionPause_0x157e70; // 0x157e70 - g_ps2RecompiledFunctionTable[90054] = bhInitMotionPauseEx_0x157f20; // 0x157f20 - g_ps2RecompiledFunctionTable[90114] = bhEffectSet_0x158010; // 0x158010 - g_ps2RecompiledFunctionTable[90154] = bhEffectSet_0x158010; // 0x1580b0 - g_ps2RecompiledFunctionTable[90168] = bhEffectSet_0x158010; // 0x1580e8 - g_ps2RecompiledFunctionTable[90178] = bhEffectSensyaSet_0x158110; // 0x158110 - g_ps2RecompiledFunctionTable[90203] = bhEffectSensyaSet_0x158110; // 0x158174 - g_ps2RecompiledFunctionTable[90210] = bhEffectKokuenSet_0x158190; // 0x158190 - g_ps2RecompiledFunctionTable[90499] = bhEffectKokuenSet_0x158190; // 0x158614 - g_ps2RecompiledFunctionTable[90506] = bhDieCk_0x158630; // 0x158630 - g_ps2RecompiledFunctionTable[90582] = bhItmCk_0x158760; // 0x158760 - g_ps2RecompiledFunctionTable[90718] = bhObjLinkSet_0x158980; // 0x158980 - g_ps2RecompiledFunctionTable[91006] = bhSetObjMotion_0x158e00; // 0x158e00 - g_ps2RecompiledFunctionTable[91045] = bhSetObjMotion_0x158e00; // 0x158e9c - g_ps2RecompiledFunctionTable[91047] = bhSetObjMotion_0x158e00; // 0x158ea4 - g_ps2RecompiledFunctionTable[91054] = bhSetDispObj_0x158ec0; // 0x158ec0 - g_ps2RecompiledFunctionTable[91146] = bhSetDoorCall_0x159030; // 0x159030 - g_ps2RecompiledFunctionTable[91184] = bhSetDoorCall_0x159030; // 0x1590c8 - g_ps2RecompiledFunctionTable[91190] = bhDieEventCk_0x1590e0; // 0x1590e0 - g_ps2RecompiledFunctionTable[91210] = bhDieEventCk_0x1590e0; // 0x159130 - g_ps2RecompiledFunctionTable[91274] = bhSetDebugLoopEx_0x159230; // 0x159230 - g_ps2RecompiledFunctionTable[91300] = bhSetDebugLoopEx_0x159230; // 0x159298 - g_ps2RecompiledFunctionTable[91310] = bhSetDebugLoopEx_0x159230; // 0x1592c0 - g_ps2RecompiledFunctionTable[91318] = bhSetDebugLoopEx_0x159230; // 0x1592e0 - g_ps2RecompiledFunctionTable[91323] = bhSetDebugLoopEx_0x159230; // 0x1592f4 - g_ps2RecompiledFunctionTable[91330] = bhInitSetKage_0x159310; // 0x159310 - g_ps2RecompiledFunctionTable[91395] = bhInitSetKage_0x159310; // 0x159414 - g_ps2RecompiledFunctionTable[91405] = bhInitSetKage_0x159310; // 0x15943c - g_ps2RecompiledFunctionTable[91416] = bhInitSetKage_0x159310; // 0x159468 - g_ps2RecompiledFunctionTable[91427] = bhInitSetKage_0x159310; // 0x159494 - g_ps2RecompiledFunctionTable[91438] = bhInitSetKage_0x159310; // 0x1594c0 - g_ps2RecompiledFunctionTable[91442] = bhObjLinkSetPly_0x1594d0; // 0x1594d0 - g_ps2RecompiledFunctionTable[91710] = bhSetNextRoomBgm_0x159900; // 0x159900 - g_ps2RecompiledFunctionTable[91766] = bhSetNextRoomBgSe_0x1599e0; // 0x1599e0 - g_ps2RecompiledFunctionTable[91866] = bhFootSeCall_0x159b70; // 0x159b70 - g_ps2RecompiledFunctionTable[91922] = bhFootSeCall_0x159b70; // 0x159c50 - g_ps2RecompiledFunctionTable[91937] = bhFootSeCall_0x159b70; // 0x159c8c - g_ps2RecompiledFunctionTable[91949] = bhFootSeCall_0x159b70; // 0x159cbc - g_ps2RecompiledFunctionTable[91964] = bhFootSeCall_0x159b70; // 0x159cf8 - g_ps2RecompiledFunctionTable[91974] = bhEneSetCk_0x159d20; // 0x159d20 - g_ps2RecompiledFunctionTable[92030] = bhItmSetCk_0x159e00; // 0x159e00 - g_ps2RecompiledFunctionTable[92114] = bhInitModelSet_0x159f50; // 0x159f50 - g_ps2RecompiledFunctionTable[92270] = bhEtcAtariSet2_0x15a1c0; // 0x15a1c0 - g_ps2RecompiledFunctionTable[92346] = bhLightSet_0x15a2f0; // 0x15a2f0 - g_ps2RecompiledFunctionTable[92398] = bhWeaponSeCall_0x15a3c0; // 0x15a3c0 - g_ps2RecompiledFunctionTable[92470] = bhWeaponSeCall_0x15a3c0; // 0x15a4e0 - g_ps2RecompiledFunctionTable[92505] = bhWeaponSeCall_0x15a3c0; // 0x15a56c - g_ps2RecompiledFunctionTable[92512] = bhWeaponSeCall_0x15a3c0; // 0x15a588 - g_ps2RecompiledFunctionTable[92533] = bhWeaponSeCall_0x15a3c0; // 0x15a5dc - g_ps2RecompiledFunctionTable[92540] = bhWeaponSeCall_0x15a3c0; // 0x15a5f8 - g_ps2RecompiledFunctionTable[92582] = bhWeaponSeCall_0x15a3c0; // 0x15a6a0 - g_ps2RecompiledFunctionTable[92588] = bhWeaponSeCall_0x15a3c0; // 0x15a6b8 - g_ps2RecompiledFunctionTable[92613] = bhWeaponSeCall_0x15a3c0; // 0x15a71c - g_ps2RecompiledFunctionTable[92619] = bhWeaponSeCall_0x15a3c0; // 0x15a734 - g_ps2RecompiledFunctionTable[92630] = bhWeaponSeCall_0x15a3c0; // 0x15a760 - g_ps2RecompiledFunctionTable[92639] = bhWeaponSeCall_0x15a3c0; // 0x15a784 - g_ps2RecompiledFunctionTable[92663] = bhWeaponSeCall_0x15a3c0; // 0x15a7e4 - g_ps2RecompiledFunctionTable[92670] = bhWeaponSeCall_0x15a3c0; // 0x15a800 - g_ps2RecompiledFunctionTable[92682] = bhYakkyouSet_0x15a830; // 0x15a830 - g_ps2RecompiledFunctionTable[92746] = bhYakkyouSet_0x15a830; // 0x15a930 - g_ps2RecompiledFunctionTable[92762] = bhYakkyouSet_0x15a830; // 0x15a970 - g_ps2RecompiledFunctionTable[92771] = bhYakkyouSet_0x15a830; // 0x15a994 - g_ps2RecompiledFunctionTable[92795] = bhYakkyouSet_0x15a830; // 0x15a9f4 - g_ps2RecompiledFunctionTable[92802] = bhYakkyouSet_0x15a830; // 0x15aa10 - g_ps2RecompiledFunctionTable[92814] = bhFadeSet_0x15aa40; // 0x15aa40 - g_ps2RecompiledFunctionTable[92860] = bhFadeSet_0x15aa40; // 0x15aaf8 - g_ps2RecompiledFunctionTable[92866] = bhRoomCaseNo_0x15ab10; // 0x15ab10 - g_ps2RecompiledFunctionTable[92882] = bhFrameCheck_0x15ab50; // 0x15ab50 - g_ps2RecompiledFunctionTable[92970] = bhCamInfoSet_0x15acb0; // 0x15acb0 - g_ps2RecompiledFunctionTable[93006] = bhMaskSet_0x15ad40; // 0x15ad40 - g_ps2RecompiledFunctionTable[93048] = bhMaskSet_0x15ad40; // 0x15ade8 - g_ps2RecompiledFunctionTable[93054] = bhLipSet_0x15ae00; // 0x15ae00 - g_ps2RecompiledFunctionTable[93098] = bhLipSet_0x15ae00; // 0x15aeb0 - g_ps2RecompiledFunctionTable[93102] = bhMaskStart_0x15aec0; // 0x15aec0 - g_ps2RecompiledFunctionTable[93154] = bhLipStart_0x15af90; // 0x15af90 - g_ps2RecompiledFunctionTable[93206] = bhMutekiSetPl_0x15b060; // 0x15b060 - g_ps2RecompiledFunctionTable[93234] = bhLookGsetPlStart_0x15b0d0; // 0x15b0d0 - g_ps2RecompiledFunctionTable[93426] = bhLookGsetPlStop_0x15b3d0; // 0x15b3d0 - g_ps2RecompiledFunctionTable[93442] = bhSoundFadeOut_0x15b410; // 0x15b410 - g_ps2RecompiledFunctionTable[93450] = bhDefModelSet_0x15b430; // 0x15b430 - g_ps2RecompiledFunctionTable[93550] = bhItmAspdSet_0x15b5c0; // 0x15b5c0 - g_ps2RecompiledFunctionTable[93582] = bhEffDispSet_0x15b640; // 0x15b640 - g_ps2RecompiledFunctionTable[93630] = bhEffAmbSet_0x15b700; // 0x15b700 - g_ps2RecompiledFunctionTable[93722] = bhObjLinkSetObjEne_0x15b870; // 0x15b870 - g_ps2RecompiledFunctionTable[93962] = bhObjLinkSetObjItem_0x15bc30; // 0x15bc30 - g_ps2RecompiledFunctionTable[94242] = bhObjLinkSetEneItem_0x15c090; // 0x15c090 - g_ps2RecompiledFunctionTable[94530] = bhObjLinkSetEneEne_0x15c510; // 0x15c510 - g_ps2RecompiledFunctionTable[94774] = bhDelObjSe_0x15c8e0; // 0x15c8e0 - g_ps2RecompiledFunctionTable[94788] = bhDelObjSe_0x15c8e0; // 0x15c918 - g_ps2RecompiledFunctionTable[94794] = bhLightTypeSet_0x15c930; // 0x15c930 - g_ps2RecompiledFunctionTable[94830] = bhFogColorSet_0x15c9c0; // 0x15c9c0 - g_ps2RecompiledFunctionTable[94906] = bhEffectSandSet_0x15caf0; // 0x15caf0 - g_ps2RecompiledFunctionTable[95272] = bhEffectSandSet_0x15caf0; // 0x15d0a8 - g_ps2RecompiledFunctionTable[95278] = bhPlItemBlockCk_0x15d0c0; // 0x15d0c0 - g_ps2RecompiledFunctionTable[95317] = bhPlItemBlockCk_0x15d0c0; // 0x15d15c - g_ps2RecompiledFunctionTable[95362] = bhPlItemBlockCk_0x15d0c0; // 0x15d210 - g_ps2RecompiledFunctionTable[95422] = bhEffBloodSet_0x15d300; // 0x15d300 - g_ps2RecompiledFunctionTable[95653] = bhEffBloodSet_0x15d300; // 0x15d69c - g_ps2RecompiledFunctionTable[95659] = bhEffBloodSet_0x15d300; // 0x15d6b4 - g_ps2RecompiledFunctionTable[95666] = bhEffBloodPoolSet_0x15d6d0; // 0x15d6d0 - g_ps2RecompiledFunctionTable[95733] = bhEffBloodPoolSet_0x15d6d0; // 0x15d7dc - g_ps2RecompiledFunctionTable[95744] = bhEffBloodPoolSet_0x15d6d0; // 0x15d808 - g_ps2RecompiledFunctionTable[95753] = bhEffBloodPoolSet_0x15d6d0; // 0x15d82c - g_ps2RecompiledFunctionTable[95764] = bhEffBloodPoolSet_0x15d6d0; // 0x15d858 - g_ps2RecompiledFunctionTable[95775] = bhEffBloodPoolSet_0x15d6d0; // 0x15d884 - g_ps2RecompiledFunctionTable[95784] = bhEffBloodPoolSet_0x15d6d0; // 0x15d8a8 - g_ps2RecompiledFunctionTable[95795] = bhEffBloodPoolSet_0x15d6d0; // 0x15d8d4 - g_ps2RecompiledFunctionTable[95806] = bhEffBloodPoolSet_0x15d6d0; // 0x15d900 - g_ps2RecompiledFunctionTable[95815] = bhEffBloodPoolSet_0x15d6d0; // 0x15d924 - g_ps2RecompiledFunctionTable[95826] = bhEffBloodPoolSet2_0x15d950; // 0x15d950 - g_ps2RecompiledFunctionTable[96045] = bhEffBloodPoolSet2_0x15d950; // 0x15dcbc - g_ps2RecompiledFunctionTable[96052] = bhEffBloodPoolSet2_0x15d950; // 0x15dcd8 - g_ps2RecompiledFunctionTable[96058] = bhEffBloodPoolSet2_0x15d950; // 0x15dcf0 - g_ps2RecompiledFunctionTable[96068] = bhEffBloodPoolSet2_0x15d950; // 0x15dd18 - g_ps2RecompiledFunctionTable[96080] = bhEffBloodPoolSet2_0x15d950; // 0x15dd48 - g_ps2RecompiledFunctionTable[96084] = bhEffBloodPoolSet2_0x15d950; // 0x15dd58 - g_ps2RecompiledFunctionTable[96090] = bhEffBloodPoolSet2_0x15d950; // 0x15dd70 - g_ps2RecompiledFunctionTable[96100] = bhEffBloodPoolSet2_0x15d950; // 0x15dd98 - g_ps2RecompiledFunctionTable[96112] = bhEffBloodPoolSet2_0x15d950; // 0x15ddc8 - g_ps2RecompiledFunctionTable[96116] = bhEffBloodPoolSet2_0x15d950; // 0x15ddd8 - g_ps2RecompiledFunctionTable[96122] = bhEffBloodPoolSet2_0x15d950; // 0x15ddf0 - g_ps2RecompiledFunctionTable[96132] = bhEffBloodPoolSet2_0x15d950; // 0x15de18 - g_ps2RecompiledFunctionTable[96142] = bhCyoutenHenkeiSet_0x15de40; // 0x15de40 - g_ps2RecompiledFunctionTable[96210] = bhCyoutenHenkeiStart_0x15df50; // 0x15df50 - g_ps2RecompiledFunctionTable[96246] = bhFixEventCamPly_0x15dfe0; // 0x15dfe0 - g_ps2RecompiledFunctionTable[96274] = bhObjLinkSetObjObj_0x15e050; // 0x15e050 - g_ps2RecompiledFunctionTable[96550] = bhCamYureSet_0x15e4a0; // 0x15e4a0 - g_ps2RecompiledFunctionTable[96574] = bhCamYureSet_0x15e4a0; // 0x15e500 - g_ps2RecompiledFunctionTable[96591] = bhCamYureSet_0x15e4a0; // 0x15e544 - g_ps2RecompiledFunctionTable[96602] = bhCamYureSet_0x15e4a0; // 0x15e570 - g_ps2RecompiledFunctionTable[96626] = bhInitCamSet_0x15e5d0; // 0x15e5d0 - g_ps2RecompiledFunctionTable[96653] = bhInitCamSet_0x15e5d0; // 0x15e63c - g_ps2RecompiledFunctionTable[96655] = bhInitCamSet_0x15e5d0; // 0x15e644 - g_ps2RecompiledFunctionTable[96657] = bhInitCamSet_0x15e5d0; // 0x15e64c - g_ps2RecompiledFunctionTable[96662] = bhMesDispEndSet_0x15e660; // 0x15e660 - g_ps2RecompiledFunctionTable[96698] = bhPadCheck_0x15e6f0; // 0x15e6f0 - g_ps2RecompiledFunctionTable[96850] = bhTFrameCheck_0x15e950; // 0x15e950 - g_ps2RecompiledFunctionTable[96870] = bhEventTimerClr_0x15e9a0; // 0x15e9a0 - g_ps2RecompiledFunctionTable[96882] = bhCamCheck_0x15e9d0; // 0x15e9d0 - g_ps2RecompiledFunctionTable[96946] = bhRandamSet_0x15ead0; // 0x15ead0 - g_ps2RecompiledFunctionTable[96961] = bhRandamSet_0x15ead0; // 0x15eb0c - g_ps2RecompiledFunctionTable[96974] = bhRandamSet_0x15ead0; // 0x15eb40 - g_ps2RecompiledFunctionTable[96986] = bhEventSkipSet_0x15eb70; // 0x15eb70 - g_ps2RecompiledFunctionTable[97014] = bhDelYakkyou_0x15ebe0; // 0x15ebe0 - g_ps2RecompiledFunctionTable[97022] = bhDelYakkyou_0x15ebe0; // 0x15ec00 - g_ps2RecompiledFunctionTable[97026] = bhObjAlphaSet_0x15ec10; // 0x15ec10 - g_ps2RecompiledFunctionTable[97101] = bhObjAlphaSet_0x15ec10; // 0x15ed3c - g_ps2RecompiledFunctionTable[97106] = bhCyodanSet_0x15ed50; // 0x15ed50 - g_ps2RecompiledFunctionTable[97488] = bhCyodanSet_0x15ed50; // 0x15f348 - g_ps2RecompiledFunctionTable[97494] = bhHEffectSet_0x15f360; // 0x15f360 - g_ps2RecompiledFunctionTable[97692] = bhHEffectSet_0x15f360; // 0x15f678 - g_ps2RecompiledFunctionTable[97711] = bhHEffectSet_0x15f360; // 0x15f6c4 - g_ps2RecompiledFunctionTable[97890] = bhHEffectSet_0x15f360; // 0x15f990 - g_ps2RecompiledFunctionTable[97898] = bhObjLinkSetObjPly_0x15f9b0; // 0x15f9b0 - g_ps2RecompiledFunctionTable[98130] = bhEffPush_0x15fd50; // 0x15fd50 - g_ps2RecompiledFunctionTable[98138] = bhEffPush_0x15fd50; // 0x15fd70 - g_ps2RecompiledFunctionTable[98142] = bhEffPop_0x15fd80; // 0x15fd80 - g_ps2RecompiledFunctionTable[98150] = bhEffPop_0x15fd80; // 0x15fda0 - g_ps2RecompiledFunctionTable[98154] = bhAreaSearchObj_0x15fdb0; // 0x15fdb0 - g_ps2RecompiledFunctionTable[98474] = bhLightParameterCSet_0x1602b0; // 0x1602b0 - g_ps2RecompiledFunctionTable[98610] = bhLightParameterStart_0x1604d0; // 0x1604d0 - g_ps2RecompiledFunctionTable[98681] = bhLightParameterStart_0x1604d0; // 0x1605ec - g_ps2RecompiledFunctionTable[98703] = bhLightParameterStart_0x1604d0; // 0x160644 - g_ps2RecompiledFunctionTable[98718] = bhInitMidiSlotSet_0x160680; // 0x160680 - g_ps2RecompiledFunctionTable[98738] = bhInitMidiSlotSet_0x160680; // 0x1606d0 - g_ps2RecompiledFunctionTable[98742] = bh3dSoundFlagSet_0x1606e0; // 0x1606e0 - g_ps2RecompiledFunctionTable[98768] = bh3dSoundFlagSet_0x1606e0; // 0x160748 - g_ps2RecompiledFunctionTable[98774] = bhSoundVolumeSet_0x160760; // 0x160760 - g_ps2RecompiledFunctionTable[98814] = bhSoundVolumeSet_0x160760; // 0x160800 - g_ps2RecompiledFunctionTable[98818] = bhLightParameterSet_0x160810; // 0x160810 - g_ps2RecompiledFunctionTable[98910] = bhEneSeOn_0x160980; // 0x160980 - g_ps2RecompiledFunctionTable[98979] = bhEneSeOn_0x160980; // 0x160a94 - g_ps2RecompiledFunctionTable[98986] = bhEneSeOff_0x160ab0; // 0x160ab0 - g_ps2RecompiledFunctionTable[99000] = bhEneSeOff_0x160ab0; // 0x160ae8 - g_ps2RecompiledFunctionTable[99006] = bhWalAtariSet2_0x160b00; // 0x160b00 - g_ps2RecompiledFunctionTable[99082] = bhFlrAtariSet2_0x160c30; // 0x160c30 - g_ps2RecompiledFunctionTable[99158] = bhMotionPosSetEnePly_0x160d60; // 0x160d60 - g_ps2RecompiledFunctionTable[99229] = bhMotionPosSetEnePly_0x160d60; // 0x160e7c - g_ps2RecompiledFunctionTable[99275] = bhMotionPosSetEnePly_0x160d60; // 0x160f34 - g_ps2RecompiledFunctionTable[99282] = bhKageSwSet_0x160f50; // 0x160f50 - g_ps2RecompiledFunctionTable[99402] = bhSoundPanSet_0x161130; // 0x161130 - g_ps2RecompiledFunctionTable[99442] = bhSoundPanSet_0x161130; // 0x1611d0 - g_ps2RecompiledFunctionTable[99446] = bhInitPonySet_0x1611e0; // 0x1611e0 - g_ps2RecompiledFunctionTable[99498] = bhCyoutenHenkeiSetEX_0x1612b0; // 0x1612b0 - g_ps2RecompiledFunctionTable[99578] = bhCyoutenHenkeiStartEX_0x1613f0; // 0x1613f0 - g_ps2RecompiledFunctionTable[99618] = bhEasySESet_0x161490; // 0x161490 - g_ps2RecompiledFunctionTable[99799] = bhEasySESet_0x161490; // 0x161764 - g_ps2RecompiledFunctionTable[99806] = bhSoundFlagReSet_0x161780; // 0x161780 - g_ps2RecompiledFunctionTable[99814] = bhSoundFlagReSet_0x161780; // 0x1617a0 - g_ps2RecompiledFunctionTable[99818] = bhEffUVSet_0x1617b0; // 0x1617b0 - g_ps2RecompiledFunctionTable[99894] = bhPlayerChangeSet_0x1618e0; // 0x1618e0 - g_ps2RecompiledFunctionTable[99918] = bhPlayerPoisonCk_0x161940; // 0x161940 - g_ps2RecompiledFunctionTable[99946] = bhAddObjSe_0x1619b0; // 0x1619b0 - g_ps2RecompiledFunctionTable[100136] = bhAddObjSe_0x1619b0; // 0x161ca8 - g_ps2RecompiledFunctionTable[100142] = bhRandTest_0x161cc0; // 0x161cc0 - g_ps2RecompiledFunctionTable[100172] = bhRandTest_0x161cc0; // 0x161d38 - g_ps2RecompiledFunctionTable[100174] = bhRandTest_0x161cc0; // 0x161d40 - g_ps2RecompiledFunctionTable[100191] = bhRandTest_0x161cc0; // 0x161d84 - g_ps2RecompiledFunctionTable[100210] = bhEvtComSet_0x161dd0; // 0x161dd0 - g_ps2RecompiledFunctionTable[100234] = bhZombieUpDieCk_0x161e30; // 0x161e30 - g_ps2RecompiledFunctionTable[100281] = bhZombieUpDieCk_0x161e30; // 0x161eec - g_ps2RecompiledFunctionTable[100286] = bhFacePauseSet_0x161f00; // 0x161f00 - g_ps2RecompiledFunctionTable[100334] = bhFaceReSet_0x161fc0; // 0x161fc0 - g_ps2RecompiledFunctionTable[100370] = bhEffModeSet_0x162050; // 0x162050 - g_ps2RecompiledFunctionTable[100406] = bhEnemyHpUp_0x1620e0; // 0x1620e0 - g_ps2RecompiledFunctionTable[100454] = bhFaceRep_0x1621a0; // 0x1621a0 - g_ps2RecompiledFunctionTable[100502] = bhBGSeOff2_0x162260; // 0x162260 - g_ps2RecompiledFunctionTable[100516] = bhBGSeOff2_0x162260; // 0x162298 - g_ps2RecompiledFunctionTable[100522] = bhBgmOff2_0x1622b0; // 0x1622b0 - g_ps2RecompiledFunctionTable[100530] = bhBgmOff2_0x1622b0; // 0x1622d0 - g_ps2RecompiledFunctionTable[100534] = bhBGSeOn2_0x1622e0; // 0x1622e0 - g_ps2RecompiledFunctionTable[100554] = bhBGSeOn2_0x1622e0; // 0x162330 - g_ps2RecompiledFunctionTable[100558] = bhBgmOn2_0x162340; // 0x162340 - g_ps2RecompiledFunctionTable[100580] = bhBgmOn2_0x162340; // 0x162398 - g_ps2RecompiledFunctionTable[100586] = bhMovieCk_0x1623b0; // 0x1623b0 - g_ps2RecompiledFunctionTable[100609] = bhMovieCk_0x1623b0; // 0x16240c - g_ps2RecompiledFunctionTable[100618] = bhSetItmMotion_0x162430; // 0x162430 - g_ps2RecompiledFunctionTable[100657] = bhSetItmMotion_0x162430; // 0x1624cc - g_ps2RecompiledFunctionTable[100659] = bhSetItmMotion_0x162430; // 0x1624d4 - g_ps2RecompiledFunctionTable[100666] = bhObjAspdSet_0x1624f0; // 0x1624f0 - g_ps2RecompiledFunctionTable[100698] = bhPuruPuruFlagSet_0x162570; // 0x162570 - g_ps2RecompiledFunctionTable[100714] = bhPuruPuruFlagSet_0x162570; // 0x1625b0 - g_ps2RecompiledFunctionTable[100718] = bhPuruPuruFlagSet_0x162570; // 0x1625c0 - g_ps2RecompiledFunctionTable[100722] = bhPuruPuruStart_0x1625d0; // 0x1625d0 - g_ps2RecompiledFunctionTable[100737] = bhPuruPuruStart_0x1625d0; // 0x16260c - g_ps2RecompiledFunctionTable[100742] = bhSubMapBusyCk_0x162620; // 0x162620 - g_ps2RecompiledFunctionTable[100774] = bhMapSystemOn_0x1626a0; // 0x1626a0 - g_ps2RecompiledFunctionTable[100834] = bhTrapDamageSet_0x162790; // 0x162790 - g_ps2RecompiledFunctionTable[100862] = bhEvtLighterFireSet_0x162800; // 0x162800 - g_ps2RecompiledFunctionTable[100893] = bhEvtLighterFireSet_0x162800; // 0x16287c - g_ps2RecompiledFunctionTable[100898] = bhObjLinkSetPlyItem_0x162890; // 0x162890 - g_ps2RecompiledFunctionTable[101166] = bhPlayerKaidanMotion_0x162cc0; // 0x162cc0 - g_ps2RecompiledFunctionTable[101186] = bhPlayerKaidanMotion_0x162cc0; // 0x162d10 - g_ps2RecompiledFunctionTable[101190] = bhEneRenderSet_0x162d20; // 0x162d20 - g_ps2RecompiledFunctionTable[101234] = bhBgmOnEx_0x162dd0; // 0x162dd0 - g_ps2RecompiledFunctionTable[101264] = bhBgmOnEx_0x162dd0; // 0x162e48 - g_ps2RecompiledFunctionTable[101270] = bhBgmOn2Ex_0x162e60; // 0x162e60 - g_ps2RecompiledFunctionTable[101291] = bhBgmOn2Ex_0x162e60; // 0x162eb4 - g_ps2RecompiledFunctionTable[101298] = bhFogParameterCSet_0x162ed0; // 0x162ed0 - g_ps2RecompiledFunctionTable[101394] = bhFogParameterStart_0x163050; // 0x163050 - g_ps2RecompiledFunctionTable[101434] = bhFogParameterStart_0x163050; // 0x1630f0 - g_ps2RecompiledFunctionTable[101436] = bhFogParameterStart_0x163050; // 0x1630f8 - g_ps2RecompiledFunctionTable[101439] = bhFogParameterStart_0x163050; // 0x163104 - g_ps2RecompiledFunctionTable[101442] = bhFogParameterStart_0x163050; // 0x163110 - g_ps2RecompiledFunctionTable[101454] = bhFogParameterStart_0x163050; // 0x163140 - g_ps2RecompiledFunctionTable[101461] = bhFogParameterStart_0x163050; // 0x16315c - g_ps2RecompiledFunctionTable[101490] = bhEffUVSet2_0x1631d0; // 0x1631d0 - g_ps2RecompiledFunctionTable[101570] = bhBGColorSet_0x163310; // 0x163310 - g_ps2RecompiledFunctionTable[101626] = bhMovieTimeCk_0x1633f0; // 0x1633f0 - g_ps2RecompiledFunctionTable[101653] = bhMovieTimeCk_0x1633f0; // 0x16345c - g_ps2RecompiledFunctionTable[101659] = bhMovieTimeCk_0x1633f0; // 0x163474 - g_ps2RecompiledFunctionTable[101706] = bhEffTypeSet_0x163530; // 0x163530 - g_ps2RecompiledFunctionTable[101742] = bhPlayerPoison2Cr_0x1635c0; // 0x1635c0 - g_ps2RecompiledFunctionTable[101758] = bhPlyHandChange_0x163600; // 0x163600 - g_ps2RecompiledFunctionTable[102010] = bhHEffectSet2_0x1639f0; // 0x1639f0 - g_ps2RecompiledFunctionTable[102222] = bhHEffectSet2_0x1639f0; // 0x163d40 - g_ps2RecompiledFunctionTable[102241] = bhHEffectSet2_0x1639f0; // 0x163d8c - g_ps2RecompiledFunctionTable[102428] = bhHEffectSet2_0x1639f0; // 0x164078 - g_ps2RecompiledFunctionTable[102438] = bhObjDposCk_0x1640a0; // 0x1640a0 - g_ps2RecompiledFunctionTable[102492] = bhObjDposCk_0x1640a0; // 0x164178 - g_ps2RecompiledFunctionTable[102501] = bhObjDposCk_0x1640a0; // 0x16419c - g_ps2RecompiledFunctionTable[102566] = bhObjDposCk_0x1640a0; // 0x1642a0 - g_ps2RecompiledFunctionTable[102576] = bhObjDposCk_0x1640a0; // 0x1642c8 - g_ps2RecompiledFunctionTable[102642] = bhItemGetGet_0x1643d0; // 0x1643d0 - g_ps2RecompiledFunctionTable[102722] = bhEtcAtariEnePosSet_0x164510; // 0x164510 - g_ps2RecompiledFunctionTable[102807] = bhEtcAtariEnePosSet_0x164510; // 0x164664 - g_ps2RecompiledFunctionTable[102811] = bhEtcAtariEnePosSet_0x164510; // 0x164674 - g_ps2RecompiledFunctionTable[102817] = bhEtcAtariEnePosSet_0x164510; // 0x16468c - g_ps2RecompiledFunctionTable[102866] = bhEtcAtariEvtPosSet_0x164750; // 0x164750 - g_ps2RecompiledFunctionTable[102938] = bhRoomSoundCase_0x164870; // 0x164870 - g_ps2RecompiledFunctionTable[102952] = bhRoomSoundCase_0x164870; // 0x1648a8 - g_ps2RecompiledFunctionTable[102958] = bhItemPlToSBox_0x1648c0; // 0x1648c0 - g_ps2RecompiledFunctionTable[102971] = bhItemPlToSBox_0x1648c0; // 0x1648f4 - g_ps2RecompiledFunctionTable[102986] = bhItemPlToSBox_0x1648c0; // 0x164930 - g_ps2RecompiledFunctionTable[103006] = bhItemSBoxToIBox_0x164980; // 0x164980 - g_ps2RecompiledFunctionTable[103016] = bhItemSBoxToIBox_0x164980; // 0x1649a8 - g_ps2RecompiledFunctionTable[103046] = bhGrdPosSet_0x164a20; // 0x164a20 - g_ps2RecompiledFunctionTable[103230] = bhGrdPosMoveCSet_0x164d00; // 0x164d00 - g_ps2RecompiledFunctionTable[103582] = bhGrdPosMoveStart_0x165280; // 0x165280 - g_ps2RecompiledFunctionTable[103642] = bhGrdPosMoveStart_0x165280; // 0x165370 - g_ps2RecompiledFunctionTable[103654] = bhEvtKill_0x1653a0; // 0x1653a0 - g_ps2RecompiledFunctionTable[103674] = bhReTryPointSet_0x1653f0; // 0x1653f0 - g_ps2RecompiledFunctionTable[103682] = bhReTryPointSet_0x1653f0; // 0x165410 - g_ps2RecompiledFunctionTable[103686] = bhPlyDposCk_0x165420; // 0x165420 - g_ps2RecompiledFunctionTable[103734] = bhPlyDposCk_0x165420; // 0x1654e0 - g_ps2RecompiledFunctionTable[103743] = bhPlyDposCk_0x165420; // 0x165504 - g_ps2RecompiledFunctionTable[103794] = bhPlItemLostEx_0x1655d0; // 0x1655d0 - g_ps2RecompiledFunctionTable[103821] = bhPlItemLostEx_0x1655d0; // 0x16563c - g_ps2RecompiledFunctionTable[103861] = bhPlItemLostEx_0x1655d0; // 0x1656dc - g_ps2RecompiledFunctionTable[103886] = bhCyodanSetEx_0x165740; // 0x165740 - g_ps2RecompiledFunctionTable[104399] = bhCyodanSetEx_0x165740; // 0x165f44 - g_ps2RecompiledFunctionTable[104406] = bhArmsItemSet_0x165f60; // 0x165f60 - g_ps2RecompiledFunctionTable[104433] = bhArmsItemSet_0x165f60; // 0x165fcc - g_ps2RecompiledFunctionTable[104458] = bhArmsItemSet_0x165f60; // 0x166030 - g_ps2RecompiledFunctionTable[104482] = bhItemGetGetEx_0x166090; // 0x166090 - g_ps2RecompiledFunctionTable[104526] = bhItemGetGetEx_0x166090; // 0x166140 - g_ps2RecompiledFunctionTable[104547] = bhItemGetGetEx_0x166090; // 0x166194 - g_ps2RecompiledFunctionTable[104594] = bhEffectSandSetMatsumoto_0x166250; // 0x166250 - g_ps2RecompiledFunctionTable[104620] = bhEffectSandSetMatsumoto_0x166250; // 0x1662b8 - g_ps2RecompiledFunctionTable[104626] = bhVoiceWait_0x1662d0; // 0x1662d0 - g_ps2RecompiledFunctionTable[104684] = bhVoiceWait_0x1662d0; // 0x1663b8 - g_ps2RecompiledFunctionTable[104770] = bhVoiceWait_0x1662d0; // 0x166510 - g_ps2RecompiledFunctionTable[104782] = bhVoiceStart_0x166540; // 0x166540 - g_ps2RecompiledFunctionTable[104790] = bhVoiceStart_0x166540; // 0x166560 - g_ps2RecompiledFunctionTable[104794] = bhGameOverSet_0x166570; // 0x166570 - g_ps2RecompiledFunctionTable[104814] = bhPlItemChangeM_0x1665c0; // 0x1665c0 - g_ps2RecompiledFunctionTable[104840] = bhPlItemChangeM_0x1665c0; // 0x166628 - g_ps2RecompiledFunctionTable[104862] = bhEffBakuDrmSet_0x166680; // 0x166680 - g_ps2RecompiledFunctionTable[105034] = bhEffBakuDrmSet_0x166680; // 0x166930 - g_ps2RecompiledFunctionTable[105038] = bhPlItemTamaSet_0x166940; // 0x166940 - g_ps2RecompiledFunctionTable[105064] = bhPlItemTamaSet_0x166940; // 0x1669a8 - g_ps2RecompiledFunctionTable[105086] = bhEffClearEvt_0x166a00; // 0x166a00 - g_ps2RecompiledFunctionTable[105094] = bhEffClearEvt_0x166a00; // 0x166a20 - g_ps2RecompiledFunctionTable[105098] = bhEvtTimerSet_0x166a30; // 0x166a30 - g_ps2RecompiledFunctionTable[105112] = bhEvtTimerSet_0x166a30; // 0x166a68 - g_ps2RecompiledFunctionTable[105118] = bhEneLookFlgSet_0x166a80; // 0x166a80 - g_ps2RecompiledFunctionTable[105166] = bhReturnTitleEvt_0x166b40; // 0x166b40 - g_ps2RecompiledFunctionTable[105177] = bhReturnTitleEvt_0x166b40; // 0x166b6c - g_ps2RecompiledFunctionTable[105179] = bhReturnTitleEvt_0x166b40; // 0x166b74 - g_ps2RecompiledFunctionTable[105190] = bhSyukanModeSet_0x166ba0; // 0x166ba0 - g_ps2RecompiledFunctionTable[105246] = bhExGameItemInit_0x166c80; // 0x166c80 - g_ps2RecompiledFunctionTable[105254] = bhExGameItemInit_0x166c80; // 0x166ca0 - g_ps2RecompiledFunctionTable[105258] = bhEneLifeSetM_0x166cb0; // 0x166cb0 - g_ps2RecompiledFunctionTable[105294] = bhEffSSizeSet_0x166d40; // 0x166d40 - g_ps2RecompiledFunctionTable[105490] = bhEffLinkOffsetSet_0x167050; // 0x167050 - g_ps2RecompiledFunctionTable[105682] = bhRankingCall_0x167350; // 0x167350 - g_ps2RecompiledFunctionTable[105696] = bhRankingCall_0x167350; // 0x167388 - g_ps2RecompiledFunctionTable[105700] = bhRankingCall_0x167350; // 0x167398 - g_ps2RecompiledFunctionTable[105702] = bhRankingCall_0x167350; // 0x1673a0 - g_ps2RecompiledFunctionTable[105704] = bhRankingCall_0x167350; // 0x1673a8 - g_ps2RecompiledFunctionTable[105716] = bhRankingCall_0x167350; // 0x1673d8 - g_ps2RecompiledFunctionTable[105754] = bhCallSysSe_0x167470; // 0x167470 - g_ps2RecompiledFunctionTable[105769] = bhCallSysSe_0x167470; // 0x1674ac - g_ps2RecompiledFunctionTable[105774] = bhSleep_0x1674c0; // 0x1674c0 - g_ps2RecompiledFunctionTable[105814] = bhSleeping_0x167560; // 0x167560 - g_ps2RecompiledFunctionTable[105838] = bhWhile_0x1675c0; // 0x1675c0 - g_ps2RecompiledFunctionTable[105870] = bhEwhile_0x167640; // 0x167640 - g_ps2RecompiledFunctionTable[105871] = bhEwhile_0x167640; // 0x167644 - g_ps2RecompiledFunctionTable[105872] = bhEwhile_0x167640; // 0x167648 - g_ps2RecompiledFunctionTable[105873] = bhEwhile_0x167640; // 0x16764c - g_ps2RecompiledFunctionTable[105874] = bhEwhile_0x167640; // 0x167650 - g_ps2RecompiledFunctionTable[105875] = bhEwhile_0x167640; // 0x167654 - g_ps2RecompiledFunctionTable[105876] = bhEwhile_0x167640; // 0x167658 - g_ps2RecompiledFunctionTable[105877] = bhEwhile_0x167640; // 0x16765c - g_ps2RecompiledFunctionTable[105878] = bhEwhile_0x167640; // 0x167660 - g_ps2RecompiledFunctionTable[105879] = bhEwhile_0x167640; // 0x167664 - g_ps2RecompiledFunctionTable[105880] = bhEwhile_0x167640; // 0x167668 - g_ps2RecompiledFunctionTable[105881] = bhEwhile_0x167640; // 0x16766c - g_ps2RecompiledFunctionTable[105882] = bhEwhile_0x167640; // 0x167670 - g_ps2RecompiledFunctionTable[105883] = bhEwhile_0x167640; // 0x167674 - g_ps2RecompiledFunctionTable[105884] = bhEwhile_0x167640; // 0x167678 - g_ps2RecompiledFunctionTable[105885] = bhEwhile_0x167640; // 0x16767c - g_ps2RecompiledFunctionTable[105886] = bhEwhile_0x167640; // 0x167680 - g_ps2RecompiledFunctionTable[105887] = bhEwhile_0x167640; // 0x167684 - g_ps2RecompiledFunctionTable[105888] = bhEwhile_0x167640; // 0x167688 - g_ps2RecompiledFunctionTable[105889] = bhEwhile_0x167640; // 0x16768c - g_ps2RecompiledFunctionTable[105890] = bhEwhile_0x167640; // 0x167690 - g_ps2RecompiledFunctionTable[105891] = bhEwhile_0x167640; // 0x167694 - g_ps2RecompiledFunctionTable[105892] = bhEwhile_0x167640; // 0x167698 - g_ps2RecompiledFunctionTable[105893] = bhEwhile_0x167640; // 0x16769c - g_ps2RecompiledFunctionTable[105894] = bhEwhile_0x167640; // 0x1676a0 - g_ps2RecompiledFunctionTable[105895] = bhEwhile_0x167640; // 0x1676a4 - g_ps2RecompiledFunctionTable[105896] = bhEwhile_0x167640; // 0x1676a8 - g_ps2RecompiledFunctionTable[105897] = bhEwhile_0x167640; // 0x1676ac - g_ps2RecompiledFunctionTable[105898] = bhEwhile_0x167640; // 0x1676b0 - g_ps2RecompiledFunctionTable[105899] = bhEwhile_0x167640; // 0x1676b4 - g_ps2RecompiledFunctionTable[105900] = bhEwhile_0x167640; // 0x1676b8 - g_ps2RecompiledFunctionTable[105901] = bhEwhile_0x167640; // 0x1676bc - g_ps2RecompiledFunctionTable[105902] = bhEwhile_0x167640; // 0x1676c0 - g_ps2RecompiledFunctionTable[105903] = bhEwhile_0x167640; // 0x1676c4 - g_ps2RecompiledFunctionTable[105904] = bhEwhile_0x167640; // 0x1676c8 - g_ps2RecompiledFunctionTable[105905] = bhEwhile_0x167640; // 0x1676cc - g_ps2RecompiledFunctionTable[105906] = bhEwhile_0x167640; // 0x1676d0 - g_ps2RecompiledFunctionTable[105907] = bhEwhile_0x167640; // 0x1676d4 - g_ps2RecompiledFunctionTable[105908] = bhEwhile_0x167640; // 0x1676d8 - g_ps2RecompiledFunctionTable[105909] = bhEwhile_0x167640; // 0x1676dc - g_ps2RecompiledFunctionTable[105910] = bhEwhile_0x167640; // 0x1676e0 - g_ps2RecompiledFunctionTable[105911] = bhEwhile_0x167640; // 0x1676e4 - g_ps2RecompiledFunctionTable[105912] = bhEwhile_0x167640; // 0x1676e8 - g_ps2RecompiledFunctionTable[105913] = bhEwhile_0x167640; // 0x1676ec - g_ps2RecompiledFunctionTable[105914] = bhEwhile_0x167640; // 0x1676f0 - g_ps2RecompiledFunctionTable[105915] = bhEwhile_0x167640; // 0x1676f4 - g_ps2RecompiledFunctionTable[105916] = bhEwhile_0x167640; // 0x1676f8 - g_ps2RecompiledFunctionTable[105917] = bhEwhile_0x167640; // 0x1676fc - g_ps2RecompiledFunctionTable[105918] = bhEwhile_0x167640; // 0x167700 - g_ps2RecompiledFunctionTable[105919] = bhEwhile_0x167640; // 0x167704 - g_ps2RecompiledFunctionTable[105920] = bhEwhile_0x167640; // 0x167708 - g_ps2RecompiledFunctionTable[105921] = bhEwhile_0x167640; // 0x16770c - g_ps2RecompiledFunctionTable[105922] = bhEwhile_0x167640; // 0x167710 - g_ps2RecompiledFunctionTable[105923] = bhEwhile_0x167640; // 0x167714 - g_ps2RecompiledFunctionTable[105924] = bhEwhile_0x167640; // 0x167718 - g_ps2RecompiledFunctionTable[105926] = bhEwhile2_0x167720; // 0x167720 - g_ps2RecompiledFunctionTable[105927] = bhEwhile2_0x167720; // 0x167724 - g_ps2RecompiledFunctionTable[105928] = bhEwhile2_0x167720; // 0x167728 - g_ps2RecompiledFunctionTable[105929] = bhEwhile2_0x167720; // 0x16772c - g_ps2RecompiledFunctionTable[105930] = bhEwhile2_0x167720; // 0x167730 - g_ps2RecompiledFunctionTable[105931] = bhEwhile2_0x167720; // 0x167734 - g_ps2RecompiledFunctionTable[105932] = bhEwhile2_0x167720; // 0x167738 - g_ps2RecompiledFunctionTable[105933] = bhEwhile2_0x167720; // 0x16773c - g_ps2RecompiledFunctionTable[105934] = bhEwhile2_0x167720; // 0x167740 - g_ps2RecompiledFunctionTable[105935] = bhEwhile2_0x167720; // 0x167744 - g_ps2RecompiledFunctionTable[105936] = bhEwhile2_0x167720; // 0x167748 - g_ps2RecompiledFunctionTable[105937] = bhEwhile2_0x167720; // 0x16774c - g_ps2RecompiledFunctionTable[105938] = bhEwhile2_0x167720; // 0x167750 - g_ps2RecompiledFunctionTable[105939] = bhEwhile2_0x167720; // 0x167754 - g_ps2RecompiledFunctionTable[105940] = bhEwhile2_0x167720; // 0x167758 - g_ps2RecompiledFunctionTable[105941] = bhEwhile2_0x167720; // 0x16775c - g_ps2RecompiledFunctionTable[105942] = bhEwhile2_0x167720; // 0x167760 - g_ps2RecompiledFunctionTable[105943] = bhEwhile2_0x167720; // 0x167764 - g_ps2RecompiledFunctionTable[105944] = bhEwhile2_0x167720; // 0x167768 - g_ps2RecompiledFunctionTable[105945] = bhEwhile2_0x167720; // 0x16776c - g_ps2RecompiledFunctionTable[105946] = bhEwhile2_0x167720; // 0x167770 - g_ps2RecompiledFunctionTable[105947] = bhEwhile2_0x167720; // 0x167774 - g_ps2RecompiledFunctionTable[105948] = bhEwhile2_0x167720; // 0x167778 - g_ps2RecompiledFunctionTable[105949] = bhEwhile2_0x167720; // 0x16777c - g_ps2RecompiledFunctionTable[105950] = bhEwhile2_0x167720; // 0x167780 - g_ps2RecompiledFunctionTable[105951] = bhEwhile2_0x167720; // 0x167784 - g_ps2RecompiledFunctionTable[105952] = bhEwhile2_0x167720; // 0x167788 - g_ps2RecompiledFunctionTable[105953] = bhEwhile2_0x167720; // 0x16778c - g_ps2RecompiledFunctionTable[105954] = bhEwhile2_0x167720; // 0x167790 - g_ps2RecompiledFunctionTable[105955] = bhEwhile2_0x167720; // 0x167794 - g_ps2RecompiledFunctionTable[105956] = bhEwhile2_0x167720; // 0x167798 - g_ps2RecompiledFunctionTable[105957] = bhEwhile2_0x167720; // 0x16779c - g_ps2RecompiledFunctionTable[105958] = bhEwhile2_0x167720; // 0x1677a0 - g_ps2RecompiledFunctionTable[105959] = bhEwhile2_0x167720; // 0x1677a4 - g_ps2RecompiledFunctionTable[105960] = bhEwhile2_0x167720; // 0x1677a8 - g_ps2RecompiledFunctionTable[105961] = bhEwhile2_0x167720; // 0x1677ac - g_ps2RecompiledFunctionTable[105962] = bhEwhile2_0x167720; // 0x1677b0 - g_ps2RecompiledFunctionTable[105963] = bhEwhile2_0x167720; // 0x1677b4 - g_ps2RecompiledFunctionTable[105964] = bhEwhile2_0x167720; // 0x1677b8 - g_ps2RecompiledFunctionTable[105965] = bhEwhile2_0x167720; // 0x1677bc - g_ps2RecompiledFunctionTable[105966] = bhEwhile2_0x167720; // 0x1677c0 - g_ps2RecompiledFunctionTable[105967] = bhEwhile2_0x167720; // 0x1677c4 - g_ps2RecompiledFunctionTable[105968] = bhEwhile2_0x167720; // 0x1677c8 - g_ps2RecompiledFunctionTable[105969] = bhEwhile2_0x167720; // 0x1677cc - g_ps2RecompiledFunctionTable[105970] = bhEwhile2_0x167720; // 0x1677d0 - g_ps2RecompiledFunctionTable[105971] = bhEwhile2_0x167720; // 0x1677d4 - g_ps2RecompiledFunctionTable[105972] = bhEwhile2_0x167720; // 0x1677d8 - g_ps2RecompiledFunctionTable[105973] = bhEwhile2_0x167720; // 0x1677dc - g_ps2RecompiledFunctionTable[105974] = bhEwhile2_0x167720; // 0x1677e0 - g_ps2RecompiledFunctionTable[105975] = bhEwhile2_0x167720; // 0x1677e4 - g_ps2RecompiledFunctionTable[105976] = bhEwhile2_0x167720; // 0x1677e8 - g_ps2RecompiledFunctionTable[105977] = bhEwhile2_0x167720; // 0x1677ec - g_ps2RecompiledFunctionTable[105978] = bhEwhile2_0x167720; // 0x1677f0 - g_ps2RecompiledFunctionTable[105979] = bhEwhile2_0x167720; // 0x1677f4 - g_ps2RecompiledFunctionTable[105980] = bhEwhile2_0x167720; // 0x1677f8 - g_ps2RecompiledFunctionTable[105982] = bhEvtNext_0x167800; // 0x167800 - g_ps2RecompiledFunctionTable[105990] = bhComNext_0x167820; // 0x167820 - g_ps2RecompiledFunctionTable[105998] = bhEvtEnd_0x167840; // 0x167840 - g_ps2RecompiledFunctionTable[106014] = bhFor_0x167880; // 0x167880 - g_ps2RecompiledFunctionTable[106050] = bhNext_0x167910; // 0x167910 - g_ps2RecompiledFunctionTable[106098] = bhPlCtr_0x1679d0; // 0x1679d0 - g_ps2RecompiledFunctionTable[106110] = bhPlCtr_0x1679d0; // 0x167a00 - g_ps2RecompiledFunctionTable[106114] = Player_controll_0x167a10; // 0x167a10 - g_ps2RecompiledFunctionTable[106240] = Player_controll_0x167a10; // 0x167c08 - g_ps2RecompiledFunctionTable[106268] = Player_controll_0x167a10; // 0x167c78 - g_ps2RecompiledFunctionTable[106296] = Player_controll_0x167a10; // 0x167ce8 - g_ps2RecompiledFunctionTable[106351] = Player_controll_0x167a10; // 0x167dc4 - g_ps2RecompiledFunctionTable[106364] = Player_controll_0x167a10; // 0x167df8 - g_ps2RecompiledFunctionTable[106385] = Player_controll_0x167a10; // 0x167e4c - g_ps2RecompiledFunctionTable[106398] = Player_controll_0x167a10; // 0x167e80 - g_ps2RecompiledFunctionTable[106410] = Player_controll_0x167a10; // 0x167eb0 - g_ps2RecompiledFunctionTable[106945] = Player_controll_0x167a10; // 0x16870c - g_ps2RecompiledFunctionTable[107167] = Player_controll_0x167a10; // 0x168a84 - g_ps2RecompiledFunctionTable[107247] = Player_controll_0x167a10; // 0x168bc4 - g_ps2RecompiledFunctionTable[107258] = bhObjCtr_0x168bf0; // 0x168bf0 - g_ps2RecompiledFunctionTable[107266] = bhObjCtr_0x168bf0; // 0x168c10 - g_ps2RecompiledFunctionTable[107270] = Obj_controll_0x168c20; // 0x168c20 - g_ps2RecompiledFunctionTable[107326] = bhSubCtr_0x168d00; // 0x168d00 - g_ps2RecompiledFunctionTable[107334] = bhSubCtr_0x168d00; // 0x168d20 - g_ps2RecompiledFunctionTable[107338] = Sub_controll_0x168d30; // 0x168d30 - g_ps2RecompiledFunctionTable[107418] = Sub_controll_0x168d30; // 0x168e70 - g_ps2RecompiledFunctionTable[107824] = Sub_controll_0x168d30; // 0x1694c8 - g_ps2RecompiledFunctionTable[107862] = bhCommonCtr_0x169560; // 0x169560 - g_ps2RecompiledFunctionTable[107870] = bhCommonCtr_0x169560; // 0x169580 - g_ps2RecompiledFunctionTable[107874] = Common_controll_0x169590; // 0x169590 - g_ps2RecompiledFunctionTable[108320] = Common_controll_0x169590; // 0x169c88 - g_ps2RecompiledFunctionTable[108410] = Common_controll_0x169590; // 0x169df0 - g_ps2RecompiledFunctionTable[108416] = Common_controll_0x169590; // 0x169e08 - g_ps2RecompiledFunctionTable[108474] = Common_controll_0x169590; // 0x169ef0 - g_ps2RecompiledFunctionTable[108481] = Common_controll_0x169590; // 0x169f0c - g_ps2RecompiledFunctionTable[108495] = Common_controll_0x169590; // 0x169f44 - g_ps2RecompiledFunctionTable[108506] = Common_controll_0x169590; // 0x169f70 - g_ps2RecompiledFunctionTable[108519] = Common_controll_0x169590; // 0x169fa4 - g_ps2RecompiledFunctionTable[108541] = Common_controll_0x169590; // 0x169ffc - g_ps2RecompiledFunctionTable[108551] = Common_controll_0x169590; // 0x16a024 - g_ps2RecompiledFunctionTable[108561] = Common_controll_0x169590; // 0x16a04c - g_ps2RecompiledFunctionTable[108624] = Common_controll_0x169590; // 0x16a148 - g_ps2RecompiledFunctionTable[108629] = Common_controll_0x169590; // 0x16a15c - g_ps2RecompiledFunctionTable[108742] = Common_controll_0x169590; // 0x16a320 - g_ps2RecompiledFunctionTable[108747] = Common_controll_0x169590; // 0x16a334 - g_ps2RecompiledFunctionTable[108761] = Common_controll_0x169590; // 0x16a36c - g_ps2RecompiledFunctionTable[108772] = Common_controll_0x169590; // 0x16a398 - g_ps2RecompiledFunctionTable[108785] = Common_controll_0x169590; // 0x16a3cc - g_ps2RecompiledFunctionTable[108807] = Common_controll_0x169590; // 0x16a424 - g_ps2RecompiledFunctionTable[108817] = Common_controll_0x169590; // 0x16a44c - g_ps2RecompiledFunctionTable[108827] = Common_controll_0x169590; // 0x16a474 - g_ps2RecompiledFunctionTable[109022] = Common_controll_0x169590; // 0x16a780 - g_ps2RecompiledFunctionTable[109028] = Common_controll_0x169590; // 0x16a798 - g_ps2RecompiledFunctionTable[109069] = Common_controll_0x169590; // 0x16a83c - g_ps2RecompiledFunctionTable[109076] = Common_controll_0x169590; // 0x16a858 - g_ps2RecompiledFunctionTable[109087] = Common_controll_0x169590; // 0x16a884 - g_ps2RecompiledFunctionTable[109095] = Common_controll_0x169590; // 0x16a8a4 - g_ps2RecompiledFunctionTable[109105] = Common_controll_0x169590; // 0x16a8cc - g_ps2RecompiledFunctionTable[109126] = Common_controll_0x169590; // 0x16a920 - g_ps2RecompiledFunctionTable[109133] = Common_controll_0x169590; // 0x16a93c - g_ps2RecompiledFunctionTable[109140] = Common_controll_0x169590; // 0x16a958 - g_ps2RecompiledFunctionTable[109192] = Common_controll_0x169590; // 0x16aa28 - g_ps2RecompiledFunctionTable[109197] = Common_controll_0x169590; // 0x16aa3c - g_ps2RecompiledFunctionTable[109282] = Common_controll_0x169590; // 0x16ab90 - g_ps2RecompiledFunctionTable[109287] = Common_controll_0x169590; // 0x16aba4 - g_ps2RecompiledFunctionTable[109298] = Common_controll_0x169590; // 0x16abd0 - g_ps2RecompiledFunctionTable[109306] = Common_controll_0x169590; // 0x16abf0 - g_ps2RecompiledFunctionTable[109316] = Common_controll_0x169590; // 0x16ac18 - g_ps2RecompiledFunctionTable[109337] = Common_controll_0x169590; // 0x16ac6c - g_ps2RecompiledFunctionTable[109344] = Common_controll_0x169590; // 0x16ac88 - g_ps2RecompiledFunctionTable[109351] = Common_controll_0x169590; // 0x16aca4 - g_ps2RecompiledFunctionTable[109424] = Common_controll_0x169590; // 0x16adc8 - g_ps2RecompiledFunctionTable[109463] = Common_controll_0x169590; // 0x16ae64 - g_ps2RecompiledFunctionTable[109474] = Common_controll_0x169590; // 0x16ae90 - g_ps2RecompiledFunctionTable[109482] = Common_controll_0x169590; // 0x16aeb0 - g_ps2RecompiledFunctionTable[109492] = Common_controll_0x169590; // 0x16aed8 - g_ps2RecompiledFunctionTable[109513] = Common_controll_0x169590; // 0x16af2c - g_ps2RecompiledFunctionTable[109520] = Common_controll_0x169590; // 0x16af48 - g_ps2RecompiledFunctionTable[109527] = Common_controll_0x169590; // 0x16af64 - g_ps2RecompiledFunctionTable[109576] = Common_controll_0x169590; // 0x16b028 - g_ps2RecompiledFunctionTable[109658] = Common_controll_0x169590; // 0x16b170 - g_ps2RecompiledFunctionTable[109669] = Common_controll_0x169590; // 0x16b19c - g_ps2RecompiledFunctionTable[109677] = Common_controll_0x169590; // 0x16b1bc - g_ps2RecompiledFunctionTable[109687] = Common_controll_0x169590; // 0x16b1e4 - g_ps2RecompiledFunctionTable[109708] = Common_controll_0x169590; // 0x16b238 - g_ps2RecompiledFunctionTable[109715] = Common_controll_0x169590; // 0x16b254 - g_ps2RecompiledFunctionTable[109722] = Common_controll_0x169590; // 0x16b270 - g_ps2RecompiledFunctionTable[110742] = Common_controll_0x169590; // 0x16c260 - g_ps2RecompiledFunctionTable[110746] = Common_controll_0x169590; // 0x16c270 - g_ps2RecompiledFunctionTable[110750] = Common_controll_0x169590; // 0x16c280 - g_ps2RecompiledFunctionTable[110759] = Common_controll_0x169590; // 0x16c2a4 - g_ps2RecompiledFunctionTable[110765] = Common_controll_0x169590; // 0x16c2bc - g_ps2RecompiledFunctionTable[110771] = Common_controll_0x169590; // 0x16c2d4 - g_ps2RecompiledFunctionTable[110780] = Common_controll_0x169590; // 0x16c2f8 - g_ps2RecompiledFunctionTable[110784] = Common_controll_0x169590; // 0x16c308 - g_ps2RecompiledFunctionTable[110793] = Common_controll_0x169590; // 0x16c32c - g_ps2RecompiledFunctionTable[110797] = Common_controll_0x169590; // 0x16c33c - g_ps2RecompiledFunctionTable[110803] = Common_controll_0x169590; // 0x16c354 - g_ps2RecompiledFunctionTable[110807] = Common_controll_0x169590; // 0x16c364 - g_ps2RecompiledFunctionTable[111252] = Common_controll_0x169590; // 0x16ca58 - g_ps2RecompiledFunctionTable[111256] = Common_controll_0x169590; // 0x16ca68 - g_ps2RecompiledFunctionTable[111260] = Common_controll_0x169590; // 0x16ca78 - g_ps2RecompiledFunctionTable[111269] = Common_controll_0x169590; // 0x16ca9c - g_ps2RecompiledFunctionTable[111275] = Common_controll_0x169590; // 0x16cab4 - g_ps2RecompiledFunctionTable[111281] = Common_controll_0x169590; // 0x16cacc - g_ps2RecompiledFunctionTable[111290] = Common_controll_0x169590; // 0x16caf0 - g_ps2RecompiledFunctionTable[111294] = Common_controll_0x169590; // 0x16cb00 - g_ps2RecompiledFunctionTable[111303] = Common_controll_0x169590; // 0x16cb24 - g_ps2RecompiledFunctionTable[111307] = Common_controll_0x169590; // 0x16cb34 - g_ps2RecompiledFunctionTable[111313] = Common_controll_0x169590; // 0x16cb4c - g_ps2RecompiledFunctionTable[111317] = Common_controll_0x169590; // 0x16cb5c - g_ps2RecompiledFunctionTable[112095] = Common_controll_0x169590; // 0x16d784 - g_ps2RecompiledFunctionTable[112099] = Common_controll_0x169590; // 0x16d794 - g_ps2RecompiledFunctionTable[112103] = Common_controll_0x169590; // 0x16d7a4 - g_ps2RecompiledFunctionTable[112112] = Common_controll_0x169590; // 0x16d7c8 - g_ps2RecompiledFunctionTable[112118] = Common_controll_0x169590; // 0x16d7e0 - g_ps2RecompiledFunctionTable[112124] = Common_controll_0x169590; // 0x16d7f8 - g_ps2RecompiledFunctionTable[112133] = Common_controll_0x169590; // 0x16d81c - g_ps2RecompiledFunctionTable[112137] = Common_controll_0x169590; // 0x16d82c - g_ps2RecompiledFunctionTable[112146] = Common_controll_0x169590; // 0x16d850 - g_ps2RecompiledFunctionTable[112150] = Common_controll_0x169590; // 0x16d860 - g_ps2RecompiledFunctionTable[112156] = Common_controll_0x169590; // 0x16d878 - g_ps2RecompiledFunctionTable[112160] = Common_controll_0x169590; // 0x16d888 - g_ps2RecompiledFunctionTable[112975] = Common_controll_0x169590; // 0x16e544 - g_ps2RecompiledFunctionTable[112979] = Common_controll_0x169590; // 0x16e554 - g_ps2RecompiledFunctionTable[112983] = Common_controll_0x169590; // 0x16e564 - g_ps2RecompiledFunctionTable[112992] = Common_controll_0x169590; // 0x16e588 - g_ps2RecompiledFunctionTable[112998] = Common_controll_0x169590; // 0x16e5a0 - g_ps2RecompiledFunctionTable[113004] = Common_controll_0x169590; // 0x16e5b8 - g_ps2RecompiledFunctionTable[113013] = Common_controll_0x169590; // 0x16e5dc - g_ps2RecompiledFunctionTable[113017] = Common_controll_0x169590; // 0x16e5ec - g_ps2RecompiledFunctionTable[113026] = Common_controll_0x169590; // 0x16e610 - g_ps2RecompiledFunctionTable[113030] = Common_controll_0x169590; // 0x16e620 - g_ps2RecompiledFunctionTable[113036] = Common_controll_0x169590; // 0x16e638 - g_ps2RecompiledFunctionTable[113040] = Common_controll_0x169590; // 0x16e648 - g_ps2RecompiledFunctionTable[113204] = Common_controll_0x169590; // 0x16e8d8 - g_ps2RecompiledFunctionTable[113233] = Common_controll_0x169590; // 0x16e94c - g_ps2RecompiledFunctionTable[113262] = Common_controll_0x169590; // 0x16e9c0 - g_ps2RecompiledFunctionTable[113488] = Common_controll_0x169590; // 0x16ed48 - g_ps2RecompiledFunctionTable[113578] = Common_controll_0x169590; // 0x16eeb0 - g_ps2RecompiledFunctionTable[113605] = Common_controll_0x169590; // 0x16ef1c - g_ps2RecompiledFunctionTable[113632] = Common_controll_0x169590; // 0x16ef88 - g_ps2RecompiledFunctionTable[113856] = Common_controll_0x169590; // 0x16f308 - g_ps2RecompiledFunctionTable[113877] = Common_controll_0x169590; // 0x16f35c - g_ps2RecompiledFunctionTable[113898] = Common_controll_0x169590; // 0x16f3b0 - g_ps2RecompiledFunctionTable[115062] = Common_controll_0x169590; // 0x1705e0 - g_ps2RecompiledFunctionTable[115071] = Common_controll_0x169590; // 0x170604 - g_ps2RecompiledFunctionTable[115099] = Common_controll_0x169590; // 0x170674 - g_ps2RecompiledFunctionTable[115108] = Common_controll_0x169590; // 0x170698 - g_ps2RecompiledFunctionTable[115136] = Common_controll_0x169590; // 0x170708 - g_ps2RecompiledFunctionTable[115145] = Common_controll_0x169590; // 0x17072c - g_ps2RecompiledFunctionTable[115175] = Common_controll_0x169590; // 0x1707a4 - g_ps2RecompiledFunctionTable[115200] = Common_controll_0x169590; // 0x170808 - g_ps2RecompiledFunctionTable[115225] = Common_controll_0x169590; // 0x17086c - g_ps2RecompiledFunctionTable[115506] = bhLoadWork_0x170cd0; // 0x170cd0 - g_ps2RecompiledFunctionTable[115726] = bhLoadWorkEx_0x171040; // 0x171040 - g_ps2RecompiledFunctionTable[115930] = bhLoadWork2_0x171370; // 0x171370 - g_ps2RecompiledFunctionTable[116034] = Event_init_0x171510; // 0x171510 - g_ps2RecompiledFunctionTable[116078] = Event_exec_0x1715c0; // 0x1715c0 - g_ps2RecompiledFunctionTable[116087] = Event_exec_0x1715c0; // 0x1715e4 - g_ps2RecompiledFunctionTable[116102] = bhEventScheduler2_0x171620; // 0x171620 - g_ps2RecompiledFunctionTable[116103] = bhEventScheduler2_0x171620; // 0x171624 - g_ps2RecompiledFunctionTable[116104] = bhEventScheduler2_0x171620; // 0x171628 - g_ps2RecompiledFunctionTable[116105] = bhEventScheduler2_0x171620; // 0x17162c - g_ps2RecompiledFunctionTable[116106] = bhEventScheduler2_0x171620; // 0x171630 - g_ps2RecompiledFunctionTable[116107] = bhEventScheduler2_0x171620; // 0x171634 - g_ps2RecompiledFunctionTable[116108] = bhEventScheduler2_0x171620; // 0x171638 - g_ps2RecompiledFunctionTable[116109] = bhEventScheduler2_0x171620; // 0x17163c - g_ps2RecompiledFunctionTable[116110] = bhEventScheduler2_0x171620; // 0x171640 - g_ps2RecompiledFunctionTable[116111] = bhEventScheduler2_0x171620; // 0x171644 - g_ps2RecompiledFunctionTable[116112] = bhEventScheduler2_0x171620; // 0x171648 - g_ps2RecompiledFunctionTable[116113] = bhEventScheduler2_0x171620; // 0x17164c - g_ps2RecompiledFunctionTable[116114] = bhEventScheduler2_0x171620; // 0x171650 - g_ps2RecompiledFunctionTable[116115] = bhEventScheduler2_0x171620; // 0x171654 - g_ps2RecompiledFunctionTable[116116] = bhEventScheduler2_0x171620; // 0x171658 - g_ps2RecompiledFunctionTable[116117] = bhEventScheduler2_0x171620; // 0x17165c - g_ps2RecompiledFunctionTable[116118] = bhEventScheduler2_0x171620; // 0x171660 - g_ps2RecompiledFunctionTable[116119] = bhEventScheduler2_0x171620; // 0x171664 - g_ps2RecompiledFunctionTable[116120] = bhEventScheduler2_0x171620; // 0x171668 - g_ps2RecompiledFunctionTable[116121] = bhEventScheduler2_0x171620; // 0x17166c - g_ps2RecompiledFunctionTable[116122] = bhEventScheduler2_0x171620; // 0x171670 - g_ps2RecompiledFunctionTable[116123] = bhEventScheduler2_0x171620; // 0x171674 - g_ps2RecompiledFunctionTable[116124] = bhEventScheduler2_0x171620; // 0x171678 - g_ps2RecompiledFunctionTable[116125] = bhEventScheduler2_0x171620; // 0x17167c - g_ps2RecompiledFunctionTable[116126] = bhEventScheduler2_0x171620; // 0x171680 - g_ps2RecompiledFunctionTable[116127] = bhEventScheduler2_0x171620; // 0x171684 - g_ps2RecompiledFunctionTable[116128] = bhEventScheduler2_0x171620; // 0x171688 - g_ps2RecompiledFunctionTable[116129] = bhEventScheduler2_0x171620; // 0x17168c - g_ps2RecompiledFunctionTable[116130] = bhEventScheduler2_0x171620; // 0x171690 - g_ps2RecompiledFunctionTable[116131] = bhEventScheduler2_0x171620; // 0x171694 - g_ps2RecompiledFunctionTable[116132] = bhEventScheduler2_0x171620; // 0x171698 - g_ps2RecompiledFunctionTable[116133] = bhEventScheduler2_0x171620; // 0x17169c - g_ps2RecompiledFunctionTable[116134] = bhEventScheduler2_0x171620; // 0x1716a0 - g_ps2RecompiledFunctionTable[116135] = bhEventScheduler2_0x171620; // 0x1716a4 - g_ps2RecompiledFunctionTable[116136] = bhEventScheduler2_0x171620; // 0x1716a8 - g_ps2RecompiledFunctionTable[116137] = bhEventScheduler2_0x171620; // 0x1716ac - g_ps2RecompiledFunctionTable[116138] = bhEventScheduler2_0x171620; // 0x1716b0 - g_ps2RecompiledFunctionTable[116139] = bhEventScheduler2_0x171620; // 0x1716b4 - g_ps2RecompiledFunctionTable[116140] = bhEventScheduler2_0x171620; // 0x1716b8 - g_ps2RecompiledFunctionTable[116141] = bhEventScheduler2_0x171620; // 0x1716bc - g_ps2RecompiledFunctionTable[116142] = bhEventScheduler2_0x171620; // 0x1716c0 - g_ps2RecompiledFunctionTable[116143] = bhEventScheduler2_0x171620; // 0x1716c4 - g_ps2RecompiledFunctionTable[116144] = bhEventScheduler2_0x171620; // 0x1716c8 - g_ps2RecompiledFunctionTable[116145] = bhEventScheduler2_0x171620; // 0x1716cc - g_ps2RecompiledFunctionTable[116146] = bhEventScheduler2_0x171620; // 0x1716d0 - g_ps2RecompiledFunctionTable[116147] = bhEventScheduler2_0x171620; // 0x1716d4 - g_ps2RecompiledFunctionTable[116148] = bhEventScheduler2_0x171620; // 0x1716d8 - g_ps2RecompiledFunctionTable[116149] = bhEventScheduler2_0x171620; // 0x1716dc - g_ps2RecompiledFunctionTable[116150] = bhEventScheduler2_0x171620; // 0x1716e0 - g_ps2RecompiledFunctionTable[116151] = bhEventScheduler2_0x171620; // 0x1716e4 - g_ps2RecompiledFunctionTable[116152] = bhEventScheduler2_0x171620; // 0x1716e8 - g_ps2RecompiledFunctionTable[116153] = bhEventScheduler2_0x171620; // 0x1716ec - g_ps2RecompiledFunctionTable[116154] = bhEventScheduler2_0x171620; // 0x1716f0 - g_ps2RecompiledFunctionTable[116155] = bhEventScheduler2_0x171620; // 0x1716f4 - g_ps2RecompiledFunctionTable[116156] = bhEventScheduler2_0x171620; // 0x1716f8 - g_ps2RecompiledFunctionTable[116157] = bhEventScheduler2_0x171620; // 0x1716fc - g_ps2RecompiledFunctionTable[116158] = bhEventScheduler2_0x171620; // 0x171700 - g_ps2RecompiledFunctionTable[116159] = bhEventScheduler2_0x171620; // 0x171704 - g_ps2RecompiledFunctionTable[116160] = bhEventScheduler2_0x171620; // 0x171708 - g_ps2RecompiledFunctionTable[116161] = bhEventScheduler2_0x171620; // 0x17170c - g_ps2RecompiledFunctionTable[116162] = bhEventScheduler2_0x171620; // 0x171710 - g_ps2RecompiledFunctionTable[116163] = bhEventScheduler2_0x171620; // 0x171714 - g_ps2RecompiledFunctionTable[116164] = bhEventScheduler2_0x171620; // 0x171718 - g_ps2RecompiledFunctionTable[116165] = bhEventScheduler2_0x171620; // 0x17171c - g_ps2RecompiledFunctionTable[116166] = bhEventScheduler2_0x171620; // 0x171720 - g_ps2RecompiledFunctionTable[116167] = bhEventScheduler2_0x171620; // 0x171724 - g_ps2RecompiledFunctionTable[116168] = bhEventScheduler2_0x171620; // 0x171728 - g_ps2RecompiledFunctionTable[116169] = bhEventScheduler2_0x171620; // 0x17172c - g_ps2RecompiledFunctionTable[116170] = bhEventScheduler2_0x171620; // 0x171730 - g_ps2RecompiledFunctionTable[116171] = bhEventScheduler2_0x171620; // 0x171734 - g_ps2RecompiledFunctionTable[116172] = bhEventScheduler2_0x171620; // 0x171738 - g_ps2RecompiledFunctionTable[116173] = bhEventScheduler2_0x171620; // 0x17173c - g_ps2RecompiledFunctionTable[116174] = bhEventScheduler2_0x171620; // 0x171740 - g_ps2RecompiledFunctionTable[116175] = bhEventScheduler2_0x171620; // 0x171744 - g_ps2RecompiledFunctionTable[116178] = bhScenarioCheck_0x171750; // 0x171750 - g_ps2RecompiledFunctionTable[116179] = bhScenarioCheck_0x171750; // 0x171754 - g_ps2RecompiledFunctionTable[116180] = bhScenarioCheck_0x171750; // 0x171758 - g_ps2RecompiledFunctionTable[116181] = bhScenarioCheck_0x171750; // 0x17175c - g_ps2RecompiledFunctionTable[116182] = bhScenarioCheck_0x171750; // 0x171760 - g_ps2RecompiledFunctionTable[116183] = bhScenarioCheck_0x171750; // 0x171764 - g_ps2RecompiledFunctionTable[116184] = bhScenarioCheck_0x171750; // 0x171768 - g_ps2RecompiledFunctionTable[116185] = bhScenarioCheck_0x171750; // 0x17176c - g_ps2RecompiledFunctionTable[116186] = bhScenarioCheck_0x171750; // 0x171770 - g_ps2RecompiledFunctionTable[116187] = bhScenarioCheck_0x171750; // 0x171774 - g_ps2RecompiledFunctionTable[116188] = bhScenarioCheck_0x171750; // 0x171778 - g_ps2RecompiledFunctionTable[116189] = bhScenarioCheck_0x171750; // 0x17177c - g_ps2RecompiledFunctionTable[116190] = bhScenarioCheck_0x171750; // 0x171780 - g_ps2RecompiledFunctionTable[116191] = bhScenarioCheck_0x171750; // 0x171784 - g_ps2RecompiledFunctionTable[116192] = bhScenarioCheck_0x171750; // 0x171788 - g_ps2RecompiledFunctionTable[116193] = bhScenarioCheck_0x171750; // 0x17178c - g_ps2RecompiledFunctionTable[116194] = bhScenarioCheck_0x171750; // 0x171790 - g_ps2RecompiledFunctionTable[116195] = bhScenarioCheck_0x171750; // 0x171794 - g_ps2RecompiledFunctionTable[116196] = bhScenarioCheck_0x171750; // 0x171798 - g_ps2RecompiledFunctionTable[116197] = bhScenarioCheck_0x171750; // 0x17179c - g_ps2RecompiledFunctionTable[116198] = bhScenarioCheck_0x171750; // 0x1717a0 - g_ps2RecompiledFunctionTable[116199] = bhScenarioCheck_0x171750; // 0x1717a4 - g_ps2RecompiledFunctionTable[116200] = bhScenarioCheck_0x171750; // 0x1717a8 - g_ps2RecompiledFunctionTable[116201] = bhScenarioCheck_0x171750; // 0x1717ac - g_ps2RecompiledFunctionTable[116202] = bhScenarioCheck_0x171750; // 0x1717b0 - g_ps2RecompiledFunctionTable[116203] = bhScenarioCheck_0x171750; // 0x1717b4 - g_ps2RecompiledFunctionTable[116204] = bhScenarioCheck_0x171750; // 0x1717b8 - g_ps2RecompiledFunctionTable[116205] = bhScenarioCheck_0x171750; // 0x1717bc - g_ps2RecompiledFunctionTable[116206] = bhScenarioCheck_0x171750; // 0x1717c0 - g_ps2RecompiledFunctionTable[116207] = bhScenarioCheck_0x171750; // 0x1717c4 - g_ps2RecompiledFunctionTable[116208] = bhScenarioCheck_0x171750; // 0x1717c8 - g_ps2RecompiledFunctionTable[116209] = bhScenarioCheck_0x171750; // 0x1717cc - g_ps2RecompiledFunctionTable[116210] = bhScenarioCheck_0x171750; // 0x1717d0 - g_ps2RecompiledFunctionTable[116211] = bhScenarioCheck_0x171750; // 0x1717d4 - g_ps2RecompiledFunctionTable[116212] = bhScenarioCheck_0x171750; // 0x1717d8 - g_ps2RecompiledFunctionTable[116213] = bhScenarioCheck_0x171750; // 0x1717dc - g_ps2RecompiledFunctionTable[116214] = bhScenarioCheck_0x171750; // 0x1717e0 - g_ps2RecompiledFunctionTable[116215] = bhScenarioCheck_0x171750; // 0x1717e4 - g_ps2RecompiledFunctionTable[116216] = bhScenarioCheck_0x171750; // 0x1717e8 - g_ps2RecompiledFunctionTable[116217] = bhScenarioCheck_0x171750; // 0x1717ec - g_ps2RecompiledFunctionTable[116218] = bhScenarioCheck_0x171750; // 0x1717f0 - g_ps2RecompiledFunctionTable[116219] = bhScenarioCheck_0x171750; // 0x1717f4 - g_ps2RecompiledFunctionTable[116220] = bhScenarioCheck_0x171750; // 0x1717f8 - g_ps2RecompiledFunctionTable[116221] = bhScenarioCheck_0x171750; // 0x1717fc - g_ps2RecompiledFunctionTable[116222] = bhFlagCk_0x171800; // 0x171800 - g_ps2RecompiledFunctionTable[116286] = bhFlagSet_0x171900; // 0x171900 - g_ps2RecompiledFunctionTable[116374] = bhChangeViewClip_0x171a60; // 0x171a60 - g_ps2RecompiledFunctionTable[116413] = bhChangeViewClip_0x171a60; // 0x171afc - g_ps2RecompiledFunctionTable[116436] = bhChangeViewClip_0x171a60; // 0x171b58 - g_ps2RecompiledFunctionTable[116458] = bhChangeViewClipRM_0x171bb0; // 0x171bb0 - g_ps2RecompiledFunctionTable[116489] = bhChangeViewClipRM_0x171bb0; // 0x171c2c - g_ps2RecompiledFunctionTable[116519] = bhChangeViewClipRM_0x171bb0; // 0x171ca4 - g_ps2RecompiledFunctionTable[116538] = bhChangeClipVolume_0x171cf0; // 0x171cf0 - g_ps2RecompiledFunctionTable[116559] = bhChangeClipVolume_0x171cf0; // 0x171d44 - g_ps2RecompiledFunctionTable[116582] = bhChangeClipVolumeRM_0x171da0; // 0x171da0 - g_ps2RecompiledFunctionTable[116603] = bhChangeClipVolumeRM_0x171da0; // 0x171df4 - g_ps2RecompiledFunctionTable[116626] = bhCPM0_event_0x171e50; // 0x171e50 - g_ps2RecompiledFunctionTable[116627] = bhCPM0_event_0x171e50; // 0x171e54 - g_ps2RecompiledFunctionTable[116628] = bhCPM0_event_0x171e50; // 0x171e58 - g_ps2RecompiledFunctionTable[116629] = bhCPM0_event_0x171e50; // 0x171e5c - g_ps2RecompiledFunctionTable[116630] = bhCPM0_event_0x171e50; // 0x171e60 - g_ps2RecompiledFunctionTable[116631] = bhCPM0_event_0x171e50; // 0x171e64 - g_ps2RecompiledFunctionTable[116632] = bhCPM0_event_0x171e50; // 0x171e68 - g_ps2RecompiledFunctionTable[116633] = bhCPM0_event_0x171e50; // 0x171e6c - g_ps2RecompiledFunctionTable[116634] = bhCPM0_event_0x171e50; // 0x171e70 - g_ps2RecompiledFunctionTable[116635] = bhCPM0_event_0x171e50; // 0x171e74 - g_ps2RecompiledFunctionTable[116638] = pl_smove00_0x171e80; // 0x171e80 - g_ps2RecompiledFunctionTable[116762] = pl_smove01_0x172070; // 0x172070 - g_ps2RecompiledFunctionTable[116943] = pl_smove01_0x172070; // 0x172344 - g_ps2RecompiledFunctionTable[116971] = pl_smove01_0x172070; // 0x1723b4 - g_ps2RecompiledFunctionTable[117042] = pl_smove01_0x172070; // 0x1724d0 - g_ps2RecompiledFunctionTable[117070] = pl_smove01_0x172070; // 0x172540 - g_ps2RecompiledFunctionTable[117082] = pl_smove02_0x172570; // 0x172570 - g_ps2RecompiledFunctionTable[117141] = pl_smove02_0x172570; // 0x17265c - g_ps2RecompiledFunctionTable[117205] = pl_smove02_0x172570; // 0x17275c - g_ps2RecompiledFunctionTable[117228] = pl_smove02_0x172570; // 0x1727b8 - g_ps2RecompiledFunctionTable[117233] = pl_smove02_0x172570; // 0x1727cc - g_ps2RecompiledFunctionTable[117276] = pl_smove02_0x172570; // 0x172878 - g_ps2RecompiledFunctionTable[117291] = pl_smove02_0x172570; // 0x1728b4 - g_ps2RecompiledFunctionTable[117316] = pl_smove02_0x172570; // 0x172918 - g_ps2RecompiledFunctionTable[117320] = pl_smove02_0x172570; // 0x172928 - g_ps2RecompiledFunctionTable[117337] = pl_smove02_0x172570; // 0x17296c - g_ps2RecompiledFunctionTable[117347] = pl_smove02_0x172570; // 0x172994 - g_ps2RecompiledFunctionTable[117369] = pl_smove02_0x172570; // 0x1729ec - g_ps2RecompiledFunctionTable[117373] = pl_smove02_0x172570; // 0x1729fc - g_ps2RecompiledFunctionTable[117390] = pl_smove02_0x172570; // 0x172a40 - g_ps2RecompiledFunctionTable[117400] = pl_smove02_0x172570; // 0x172a68 - g_ps2RecompiledFunctionTable[117404] = pl_smove02_0x172570; // 0x172a78 - g_ps2RecompiledFunctionTable[117410] = pl_smove03_0x172a90; // 0x172a90 - g_ps2RecompiledFunctionTable[117467] = pl_smove03_0x172a90; // 0x172b74 - g_ps2RecompiledFunctionTable[117529] = pl_smove03_0x172a90; // 0x172c6c - g_ps2RecompiledFunctionTable[117534] = pl_smove03_0x172a90; // 0x172c80 - g_ps2RecompiledFunctionTable[117591] = pl_smove03_0x172a90; // 0x172d64 - g_ps2RecompiledFunctionTable[117606] = pl_smove03_0x172a90; // 0x172da0 - g_ps2RecompiledFunctionTable[117631] = pl_smove03_0x172a90; // 0x172e04 - g_ps2RecompiledFunctionTable[117635] = pl_smove03_0x172a90; // 0x172e14 - g_ps2RecompiledFunctionTable[117652] = pl_smove03_0x172a90; // 0x172e58 - g_ps2RecompiledFunctionTable[117662] = pl_smove03_0x172a90; // 0x172e80 - g_ps2RecompiledFunctionTable[117684] = pl_smove03_0x172a90; // 0x172ed8 - g_ps2RecompiledFunctionTable[117688] = pl_smove03_0x172a90; // 0x172ee8 - g_ps2RecompiledFunctionTable[117705] = pl_smove03_0x172a90; // 0x172f2c - g_ps2RecompiledFunctionTable[117715] = pl_smove03_0x172a90; // 0x172f54 - g_ps2RecompiledFunctionTable[117719] = pl_smove03_0x172a90; // 0x172f64 - g_ps2RecompiledFunctionTable[117726] = pl_smove04_0x172f80; // 0x172f80 - g_ps2RecompiledFunctionTable[117801] = pl_smove04_0x172f80; // 0x1730ac - g_ps2RecompiledFunctionTable[117862] = pl_smove04_0x172f80; // 0x1731a0 - g_ps2RecompiledFunctionTable[117885] = pl_smove04_0x172f80; // 0x1731fc - g_ps2RecompiledFunctionTable[117890] = pl_smove04_0x172f80; // 0x173210 - g_ps2RecompiledFunctionTable[117933] = pl_smove04_0x172f80; // 0x1732bc - g_ps2RecompiledFunctionTable[117948] = pl_smove04_0x172f80; // 0x1732f8 - g_ps2RecompiledFunctionTable[117973] = pl_smove04_0x172f80; // 0x17335c - g_ps2RecompiledFunctionTable[117977] = pl_smove04_0x172f80; // 0x17336c - g_ps2RecompiledFunctionTable[117994] = pl_smove04_0x172f80; // 0x1733b0 - g_ps2RecompiledFunctionTable[118004] = pl_smove04_0x172f80; // 0x1733d8 - g_ps2RecompiledFunctionTable[118026] = pl_smove04_0x172f80; // 0x173430 - g_ps2RecompiledFunctionTable[118030] = pl_smove04_0x172f80; // 0x173440 - g_ps2RecompiledFunctionTable[118047] = pl_smove04_0x172f80; // 0x173484 - g_ps2RecompiledFunctionTable[118057] = pl_smove04_0x172f80; // 0x1734ac - g_ps2RecompiledFunctionTable[118061] = pl_smove04_0x172f80; // 0x1734bc - g_ps2RecompiledFunctionTable[118066] = pl_smove05_0x1734d0; // 0x1734d0 - g_ps2RecompiledFunctionTable[118190] = pl_smove06_0x1736c0; // 0x1736c0 - g_ps2RecompiledFunctionTable[118246] = pl_smove06_0x1736c0; // 0x1737a0 - g_ps2RecompiledFunctionTable[118316] = pl_smove06_0x1736c0; // 0x1738b8 - g_ps2RecompiledFunctionTable[118321] = pl_smove06_0x1736c0; // 0x1738cc - g_ps2RecompiledFunctionTable[118347] = pl_smove06_0x1736c0; // 0x173934 - g_ps2RecompiledFunctionTable[118365] = pl_smove06_0x1736c0; // 0x17397c - g_ps2RecompiledFunctionTable[118369] = pl_smove06_0x1736c0; // 0x17398c - g_ps2RecompiledFunctionTable[118382] = pl_smove06_0x1736c0; // 0x1739c0 - g_ps2RecompiledFunctionTable[118386] = pl_smove06_0x1736c0; // 0x1739d0 - g_ps2RecompiledFunctionTable[118390] = pl_smove06_0x1736c0; // 0x1739e0 - g_ps2RecompiledFunctionTable[118394] = pl_smove07_0x1739f0; // 0x1739f0 - g_ps2RecompiledFunctionTable[118444] = pl_smove07_0x1739f0; // 0x173ab8 - g_ps2RecompiledFunctionTable[118501] = pl_smove07_0x1739f0; // 0x173b9c - g_ps2RecompiledFunctionTable[118506] = pl_smove07_0x1739f0; // 0x173bb0 - g_ps2RecompiledFunctionTable[118532] = pl_smove07_0x1739f0; // 0x173c18 - g_ps2RecompiledFunctionTable[118550] = pl_smove07_0x1739f0; // 0x173c60 - g_ps2RecompiledFunctionTable[118554] = pl_smove07_0x1739f0; // 0x173c70 - g_ps2RecompiledFunctionTable[118566] = pl_smove07_0x1739f0; // 0x173ca0 - g_ps2RecompiledFunctionTable[118570] = pl_smove07_0x1739f0; // 0x173cb0 - g_ps2RecompiledFunctionTable[118574] = pl_smove07_0x1739f0; // 0x173cc0 - g_ps2RecompiledFunctionTable[118578] = pl_smove08_0x173cd0; // 0x173cd0 - g_ps2RecompiledFunctionTable[118702] = bhSubpl_0x173ec0; // 0x173ec0 - g_ps2RecompiledFunctionTable[118703] = bhSubpl_0x173ec0; // 0x173ec4 - g_ps2RecompiledFunctionTable[118704] = bhSubpl_0x173ec0; // 0x173ec8 - g_ps2RecompiledFunctionTable[118705] = bhSubpl_0x173ec0; // 0x173ecc - g_ps2RecompiledFunctionTable[118706] = bhSubpl_0x173ec0; // 0x173ed0 - g_ps2RecompiledFunctionTable[118707] = bhSubpl_0x173ec0; // 0x173ed4 - g_ps2RecompiledFunctionTable[118708] = bhSubpl_0x173ec0; // 0x173ed8 - g_ps2RecompiledFunctionTable[118709] = bhSubpl_0x173ec0; // 0x173edc - g_ps2RecompiledFunctionTable[118710] = bhSubpl_0x173ec0; // 0x173ee0 - g_ps2RecompiledFunctionTable[118711] = bhSubpl_0x173ec0; // 0x173ee4 - g_ps2RecompiledFunctionTable[118712] = bhSubpl_0x173ec0; // 0x173ee8 - g_ps2RecompiledFunctionTable[118713] = bhSubpl_0x173ec0; // 0x173eec - g_ps2RecompiledFunctionTable[118714] = bhSubpl_0x173ec0; // 0x173ef0 - g_ps2RecompiledFunctionTable[118715] = bhSubpl_0x173ec0; // 0x173ef4 - g_ps2RecompiledFunctionTable[118716] = bhSubpl_0x173ec0; // 0x173ef8 - g_ps2RecompiledFunctionTable[118717] = bhSubpl_0x173ec0; // 0x173efc - g_ps2RecompiledFunctionTable[118718] = bhSubpl_0x173ec0; // 0x173f00 - g_ps2RecompiledFunctionTable[118719] = bhSubpl_0x173ec0; // 0x173f04 - g_ps2RecompiledFunctionTable[118720] = bhSubpl_0x173ec0; // 0x173f08 - g_ps2RecompiledFunctionTable[118721] = bhSubpl_0x173ec0; // 0x173f0c - g_ps2RecompiledFunctionTable[118722] = bhSubpl_0x173ec0; // 0x173f10 - g_ps2RecompiledFunctionTable[118723] = bhSubpl_0x173ec0; // 0x173f14 - g_ps2RecompiledFunctionTable[118724] = bhSubpl_0x173ec0; // 0x173f18 - g_ps2RecompiledFunctionTable[118725] = bhSubpl_0x173ec0; // 0x173f1c - g_ps2RecompiledFunctionTable[118726] = bhSubpl_0x173ec0; // 0x173f20 - g_ps2RecompiledFunctionTable[118730] = init_subpl_0x173f30; // 0x173f30 - g_ps2RecompiledFunctionTable[118731] = init_subpl_0x173f30; // 0x173f34 - g_ps2RecompiledFunctionTable[118732] = init_subpl_0x173f30; // 0x173f38 - g_ps2RecompiledFunctionTable[118733] = init_subpl_0x173f30; // 0x173f3c - g_ps2RecompiledFunctionTable[118734] = init_subpl_0x173f30; // 0x173f40 - g_ps2RecompiledFunctionTable[118735] = init_subpl_0x173f30; // 0x173f44 - g_ps2RecompiledFunctionTable[118736] = init_subpl_0x173f30; // 0x173f48 - g_ps2RecompiledFunctionTable[118737] = init_subpl_0x173f30; // 0x173f4c - g_ps2RecompiledFunctionTable[118738] = init_subpl_0x173f30; // 0x173f50 - g_ps2RecompiledFunctionTable[118739] = init_subpl_0x173f30; // 0x173f54 - g_ps2RecompiledFunctionTable[118742] = em60_init_0x173f60; // 0x173f60 - g_ps2RecompiledFunctionTable[118777] = em60_init_0x173f60; // 0x173fec - g_ps2RecompiledFunctionTable[118794] = em60_init_0x173f60; // 0x174030 - g_ps2RecompiledFunctionTable[118798] = move_subpl_0x174040; // 0x174040 - g_ps2RecompiledFunctionTable[118799] = move_subpl_0x174040; // 0x174044 - g_ps2RecompiledFunctionTable[118800] = move_subpl_0x174040; // 0x174048 - g_ps2RecompiledFunctionTable[118801] = move_subpl_0x174040; // 0x17404c - g_ps2RecompiledFunctionTable[118802] = move_subpl_0x174040; // 0x174050 - g_ps2RecompiledFunctionTable[118803] = move_subpl_0x174040; // 0x174054 - g_ps2RecompiledFunctionTable[118804] = move_subpl_0x174040; // 0x174058 - g_ps2RecompiledFunctionTable[118805] = move_subpl_0x174040; // 0x17405c - g_ps2RecompiledFunctionTable[118806] = em_sce_0x174060; // 0x174060 - g_ps2RecompiledFunctionTable[118807] = em_sce_0x174060; // 0x174064 - g_ps2RecompiledFunctionTable[118808] = em_sce_0x174060; // 0x174068 - g_ps2RecompiledFunctionTable[118809] = em_sce_0x174060; // 0x17406c - g_ps2RecompiledFunctionTable[118810] = em_sce_0x174060; // 0x174070 - g_ps2RecompiledFunctionTable[118811] = em_sce_0x174060; // 0x174074 - g_ps2RecompiledFunctionTable[118812] = em_sce_0x174060; // 0x174078 - g_ps2RecompiledFunctionTable[118813] = em_sce_0x174060; // 0x17407c - g_ps2RecompiledFunctionTable[118814] = bhEne_Event_0x174080; // 0x174080 - g_ps2RecompiledFunctionTable[118815] = bhEne_Event_0x174080; // 0x174084 - g_ps2RecompiledFunctionTable[118816] = bhEne_Event_0x174080; // 0x174088 - g_ps2RecompiledFunctionTable[118817] = bhEne_Event_0x174080; // 0x17408c - g_ps2RecompiledFunctionTable[118818] = bhEne_Event_0x174080; // 0x174090 - g_ps2RecompiledFunctionTable[118819] = bhEne_Event_0x174080; // 0x174094 - g_ps2RecompiledFunctionTable[118820] = bhEne_Event_0x174080; // 0x174098 - g_ps2RecompiledFunctionTable[118821] = bhEne_Event_0x174080; // 0x17409c - g_ps2RecompiledFunctionTable[118822] = bhEne_Event2_0x1740a0; // 0x1740a0 - g_ps2RecompiledFunctionTable[118823] = bhEne_Event2_0x1740a0; // 0x1740a4 - g_ps2RecompiledFunctionTable[118824] = bhEne_Event2_0x1740a0; // 0x1740a8 - g_ps2RecompiledFunctionTable[118825] = bhEne_Event2_0x1740a0; // 0x1740ac - g_ps2RecompiledFunctionTable[118826] = bhEne_Event2_0x1740a0; // 0x1740b0 - g_ps2RecompiledFunctionTable[118827] = bhEne_Event2_0x1740a0; // 0x1740b4 - g_ps2RecompiledFunctionTable[118828] = bhEne_Event2_0x1740a0; // 0x1740b8 - g_ps2RecompiledFunctionTable[118829] = bhEne_Event2_0x1740a0; // 0x1740bc - g_ps2RecompiledFunctionTable[118830] = mv00_subpl0_0x1740c0; // 0x1740c0 - g_ps2RecompiledFunctionTable[118855] = mv00_subpl0_0x1740c0; // 0x174124 - g_ps2RecompiledFunctionTable[118858] = mv00_subpl0Ex_0x174130; // 0x174130 - g_ps2RecompiledFunctionTable[118881] = mv00_subpl0Ex_0x174130; // 0x17418c - g_ps2RecompiledFunctionTable[118886] = mv00_subpl1_0x1741a0; // 0x1741a0 - g_ps2RecompiledFunctionTable[118924] = mv00_subpl1_0x1741a0; // 0x174238 - g_ps2RecompiledFunctionTable[118939] = mv00_subpl1_0x1741a0; // 0x174274 - g_ps2RecompiledFunctionTable[118942] = mv00_subpl1_0x1741a0; // 0x174280 - g_ps2RecompiledFunctionTable[118946] = mv00_subpl2_0x174290; // 0x174290 - g_ps2RecompiledFunctionTable[118962] = mv00_subpl2_0_0x1742d0; // 0x1742d0 - g_ps2RecompiledFunctionTable[118978] = mv00_subpl3_0x174310; // 0x174310 - g_ps2RecompiledFunctionTable[119014] = mv00_subpl3_0x174310; // 0x1743a0 - g_ps2RecompiledFunctionTable[119027] = mv00_subpl3_0x174310; // 0x1743d4 - g_ps2RecompiledFunctionTable[119034] = mv00_subpl3_0_0x1743f0; // 0x1743f0 - g_ps2RecompiledFunctionTable[119069] = mv00_subpl3_0_0x1743f0; // 0x17447c - g_ps2RecompiledFunctionTable[119082] = mv00_subpl3_0_0x1743f0; // 0x1744b0 - g_ps2RecompiledFunctionTable[119086] = mv00_subpl5_0x1744c0; // 0x1744c0 - g_ps2RecompiledFunctionTable[119108] = mv00_subpl5_0x1744c0; // 0x174518 - g_ps2RecompiledFunctionTable[119114] = mv00_subpl6_0x174530; // 0x174530 - g_ps2RecompiledFunctionTable[119140] = mv00_subpl6_0x174530; // 0x174598 - g_ps2RecompiledFunctionTable[119146] = mv00_subpl0_1_0x1745b0; // 0x1745b0 - g_ps2RecompiledFunctionTable[119165] = mv00_subpl0_1_0x1745b0; // 0x1745fc - g_ps2RecompiledFunctionTable[119170] = bhSub_DirTarget_0x174610; // 0x174610 - g_ps2RecompiledFunctionTable[119181] = bhSub_DirTarget_0x174610; // 0x17463c - g_ps2RecompiledFunctionTable[119186] = bhSub_DirTarget_0x174610; // 0x174650 - g_ps2RecompiledFunctionTable[119192] = bhSub_DirTarget_0x174610; // 0x174668 - g_ps2RecompiledFunctionTable[119210] = mv00_subpl10_0x1746b0; // 0x1746b0 - g_ps2RecompiledFunctionTable[119226] = bhEne28_0x1746f0; // 0x1746f0 - g_ps2RecompiledFunctionTable[119230] = bhInitEnemy_0x174700; // 0x174700 - g_ps2RecompiledFunctionTable[119238] = bhSetEnemy_0x174720; // 0x174720 - g_ps2RecompiledFunctionTable[119247] = bhSetEnemy_0x174720; // 0x174744 - g_ps2RecompiledFunctionTable[119255] = bhSetEnemy_0x174720; // 0x174764 - g_ps2RecompiledFunctionTable[119417] = bhSetEnemy_0x174720; // 0x1749ec - g_ps2RecompiledFunctionTable[119419] = bhSetEnemy_0x174720; // 0x1749f4 - g_ps2RecompiledFunctionTable[119427] = bhSetEnemy_0x174720; // 0x174a14 - g_ps2RecompiledFunctionTable[119434] = bhCheckEneWorkNum_0x174a30; // 0x174a30 - g_ps2RecompiledFunctionTable[119442] = bhCheckEneWorkNum_0x174a30; // 0x174a50 - g_ps2RecompiledFunctionTable[119458] = bhControlEnemy_0x174a90; // 0x174a90 - g_ps2RecompiledFunctionTable[119459] = bhControlEnemy_0x174a90; // 0x174a94 - g_ps2RecompiledFunctionTable[119460] = bhControlEnemy_0x174a90; // 0x174a98 - g_ps2RecompiledFunctionTable[119461] = bhControlEnemy_0x174a90; // 0x174a9c - g_ps2RecompiledFunctionTable[119462] = bhControlEnemy_0x174a90; // 0x174aa0 - g_ps2RecompiledFunctionTable[119463] = bhControlEnemy_0x174a90; // 0x174aa4 - g_ps2RecompiledFunctionTable[119464] = bhControlEnemy_0x174a90; // 0x174aa8 - g_ps2RecompiledFunctionTable[119465] = bhControlEnemy_0x174a90; // 0x174aac - g_ps2RecompiledFunctionTable[119466] = bhControlEnemy_0x174a90; // 0x174ab0 - g_ps2RecompiledFunctionTable[119467] = bhControlEnemy_0x174a90; // 0x174ab4 - g_ps2RecompiledFunctionTable[119468] = bhControlEnemy_0x174a90; // 0x174ab8 - g_ps2RecompiledFunctionTable[119469] = bhControlEnemy_0x174a90; // 0x174abc - g_ps2RecompiledFunctionTable[119470] = bhControlEnemy_0x174a90; // 0x174ac0 - g_ps2RecompiledFunctionTable[119471] = bhControlEnemy_0x174a90; // 0x174ac4 - g_ps2RecompiledFunctionTable[119472] = bhControlEnemy_0x174a90; // 0x174ac8 - g_ps2RecompiledFunctionTable[119473] = bhControlEnemy_0x174a90; // 0x174acc - g_ps2RecompiledFunctionTable[119474] = bhControlEnemy_0x174a90; // 0x174ad0 - g_ps2RecompiledFunctionTable[119475] = bhControlEnemy_0x174a90; // 0x174ad4 - g_ps2RecompiledFunctionTable[119476] = bhControlEnemy_0x174a90; // 0x174ad8 - g_ps2RecompiledFunctionTable[119477] = bhControlEnemy_0x174a90; // 0x174adc - g_ps2RecompiledFunctionTable[119478] = bhControlEnemy_0x174a90; // 0x174ae0 - g_ps2RecompiledFunctionTable[119479] = bhControlEnemy_0x174a90; // 0x174ae4 - g_ps2RecompiledFunctionTable[119480] = bhControlEnemy_0x174a90; // 0x174ae8 - g_ps2RecompiledFunctionTable[119481] = bhControlEnemy_0x174a90; // 0x174aec - g_ps2RecompiledFunctionTable[119482] = bhControlEnemy_0x174a90; // 0x174af0 - g_ps2RecompiledFunctionTable[119483] = bhControlEnemy_0x174a90; // 0x174af4 - g_ps2RecompiledFunctionTable[119484] = bhControlEnemy_0x174a90; // 0x174af8 - g_ps2RecompiledFunctionTable[119485] = bhControlEnemy_0x174a90; // 0x174afc - g_ps2RecompiledFunctionTable[119486] = bhControlEnemy_0x174a90; // 0x174b00 - g_ps2RecompiledFunctionTable[119487] = bhControlEnemy_0x174a90; // 0x174b04 - g_ps2RecompiledFunctionTable[119488] = bhControlEnemy_0x174a90; // 0x174b08 - g_ps2RecompiledFunctionTable[119489] = bhControlEnemy_0x174a90; // 0x174b0c - g_ps2RecompiledFunctionTable[119490] = bhControlEnemy_0x174a90; // 0x174b10 - g_ps2RecompiledFunctionTable[119491] = bhControlEnemy_0x174a90; // 0x174b14 - g_ps2RecompiledFunctionTable[119492] = bhControlEnemy_0x174a90; // 0x174b18 - g_ps2RecompiledFunctionTable[119493] = bhControlEnemy_0x174a90; // 0x174b1c - g_ps2RecompiledFunctionTable[119494] = bhControlEnemy_0x174a90; // 0x174b20 - g_ps2RecompiledFunctionTable[119495] = bhControlEnemy_0x174a90; // 0x174b24 - g_ps2RecompiledFunctionTable[119496] = bhControlEnemy_0x174a90; // 0x174b28 - g_ps2RecompiledFunctionTable[119497] = bhControlEnemy_0x174a90; // 0x174b2c - g_ps2RecompiledFunctionTable[119498] = bhControlEnemy_0x174a90; // 0x174b30 - g_ps2RecompiledFunctionTable[119499] = bhControlEnemy_0x174a90; // 0x174b34 - g_ps2RecompiledFunctionTable[119500] = bhControlEnemy_0x174a90; // 0x174b38 - g_ps2RecompiledFunctionTable[119501] = bhControlEnemy_0x174a90; // 0x174b3c - g_ps2RecompiledFunctionTable[119502] = bhControlEnemy_0x174a90; // 0x174b40 - g_ps2RecompiledFunctionTable[119503] = bhControlEnemy_0x174a90; // 0x174b44 - g_ps2RecompiledFunctionTable[119504] = bhControlEnemy_0x174a90; // 0x174b48 - g_ps2RecompiledFunctionTable[119505] = bhControlEnemy_0x174a90; // 0x174b4c - g_ps2RecompiledFunctionTable[119506] = bhControlEnemy_0x174a90; // 0x174b50 - g_ps2RecompiledFunctionTable[119507] = bhControlEnemy_0x174a90; // 0x174b54 - g_ps2RecompiledFunctionTable[119508] = bhControlEnemy_0x174a90; // 0x174b58 - g_ps2RecompiledFunctionTable[119509] = bhControlEnemy_0x174a90; // 0x174b5c - g_ps2RecompiledFunctionTable[119510] = bhControlEnemy_0x174a90; // 0x174b60 - g_ps2RecompiledFunctionTable[119511] = bhControlEnemy_0x174a90; // 0x174b64 - g_ps2RecompiledFunctionTable[119512] = bhControlEnemy_0x174a90; // 0x174b68 - g_ps2RecompiledFunctionTable[119513] = bhControlEnemy_0x174a90; // 0x174b6c - g_ps2RecompiledFunctionTable[119514] = bhControlEnemy_0x174a90; // 0x174b70 - g_ps2RecompiledFunctionTable[119515] = bhControlEnemy_0x174a90; // 0x174b74 - g_ps2RecompiledFunctionTable[119516] = bhControlEnemy_0x174a90; // 0x174b78 - g_ps2RecompiledFunctionTable[119517] = bhControlEnemy_0x174a90; // 0x174b7c - g_ps2RecompiledFunctionTable[119518] = bhControlEnemy_0x174a90; // 0x174b80 - g_ps2RecompiledFunctionTable[119519] = bhControlEnemy_0x174a90; // 0x174b84 - g_ps2RecompiledFunctionTable[119520] = bhControlEnemy_0x174a90; // 0x174b88 - g_ps2RecompiledFunctionTable[119521] = bhControlEnemy_0x174a90; // 0x174b8c - g_ps2RecompiledFunctionTable[119522] = bhControlEnemy_0x174a90; // 0x174b90 - g_ps2RecompiledFunctionTable[119523] = bhControlEnemy_0x174a90; // 0x174b94 - g_ps2RecompiledFunctionTable[119524] = bhControlEnemy_0x174a90; // 0x174b98 - g_ps2RecompiledFunctionTable[119525] = bhControlEnemy_0x174a90; // 0x174b9c - g_ps2RecompiledFunctionTable[119526] = bhControlEnemy_0x174a90; // 0x174ba0 - g_ps2RecompiledFunctionTable[119527] = bhControlEnemy_0x174a90; // 0x174ba4 - g_ps2RecompiledFunctionTable[119528] = bhControlEnemy_0x174a90; // 0x174ba8 - g_ps2RecompiledFunctionTable[119529] = bhControlEnemy_0x174a90; // 0x174bac - g_ps2RecompiledFunctionTable[119530] = bhControlEnemy_0x174a90; // 0x174bb0 - g_ps2RecompiledFunctionTable[119531] = bhControlEnemy_0x174a90; // 0x174bb4 - g_ps2RecompiledFunctionTable[119532] = bhControlEnemy_0x174a90; // 0x174bb8 - g_ps2RecompiledFunctionTable[119533] = bhControlEnemy_0x174a90; // 0x174bbc - g_ps2RecompiledFunctionTable[119534] = bhControlEnemy_0x174a90; // 0x174bc0 - g_ps2RecompiledFunctionTable[119535] = bhControlEnemy_0x174a90; // 0x174bc4 - g_ps2RecompiledFunctionTable[119536] = bhControlEnemy_0x174a90; // 0x174bc8 - g_ps2RecompiledFunctionTable[119537] = bhControlEnemy_0x174a90; // 0x174bcc - g_ps2RecompiledFunctionTable[119538] = bhControlEnemy_0x174a90; // 0x174bd0 - g_ps2RecompiledFunctionTable[119539] = bhControlEnemy_0x174a90; // 0x174bd4 - g_ps2RecompiledFunctionTable[119540] = bhControlEnemy_0x174a90; // 0x174bd8 - g_ps2RecompiledFunctionTable[119541] = bhControlEnemy_0x174a90; // 0x174bdc - g_ps2RecompiledFunctionTable[119542] = bhControlEnemy_0x174a90; // 0x174be0 - g_ps2RecompiledFunctionTable[119543] = bhControlEnemy_0x174a90; // 0x174be4 - g_ps2RecompiledFunctionTable[119544] = bhControlEnemy_0x174a90; // 0x174be8 - g_ps2RecompiledFunctionTable[119545] = bhControlEnemy_0x174a90; // 0x174bec - g_ps2RecompiledFunctionTable[119546] = bhControlEnemy_0x174a90; // 0x174bf0 - g_ps2RecompiledFunctionTable[119547] = bhControlEnemy_0x174a90; // 0x174bf4 - g_ps2RecompiledFunctionTable[119548] = bhControlEnemy_0x174a90; // 0x174bf8 - g_ps2RecompiledFunctionTable[119549] = bhControlEnemy_0x174a90; // 0x174bfc - g_ps2RecompiledFunctionTable[119550] = bhControlEnemy_0x174a90; // 0x174c00 - g_ps2RecompiledFunctionTable[119551] = bhControlEnemy_0x174a90; // 0x174c04 - g_ps2RecompiledFunctionTable[119552] = bhControlEnemy_0x174a90; // 0x174c08 - g_ps2RecompiledFunctionTable[119553] = bhControlEnemy_0x174a90; // 0x174c0c - g_ps2RecompiledFunctionTable[119554] = bhControlEnemy_0x174a90; // 0x174c10 - g_ps2RecompiledFunctionTable[119555] = bhControlEnemy_0x174a90; // 0x174c14 - g_ps2RecompiledFunctionTable[119556] = bhControlEnemy_0x174a90; // 0x174c18 - g_ps2RecompiledFunctionTable[119557] = bhControlEnemy_0x174a90; // 0x174c1c - g_ps2RecompiledFunctionTable[119558] = bhControlEnemy_0x174a90; // 0x174c20 - g_ps2RecompiledFunctionTable[119559] = bhControlEnemy_0x174a90; // 0x174c24 - g_ps2RecompiledFunctionTable[119560] = bhControlEnemy_0x174a90; // 0x174c28 - g_ps2RecompiledFunctionTable[119561] = bhControlEnemy_0x174a90; // 0x174c2c - g_ps2RecompiledFunctionTable[119562] = bhControlEnemy_0x174a90; // 0x174c30 - g_ps2RecompiledFunctionTable[119563] = bhControlEnemy_0x174a90; // 0x174c34 - g_ps2RecompiledFunctionTable[119564] = bhControlEnemy_0x174a90; // 0x174c38 - g_ps2RecompiledFunctionTable[119565] = bhControlEnemy_0x174a90; // 0x174c3c - g_ps2RecompiledFunctionTable[119566] = bhControlEnemy_0x174a90; // 0x174c40 - g_ps2RecompiledFunctionTable[119570] = bhEne00_0x174c50; // 0x174c50 - g_ps2RecompiledFunctionTable[119684] = bhEne00_0x174c50; // 0x174e18 - g_ps2RecompiledFunctionTable[119730] = bhEne00_0x174c50; // 0x174ed0 - g_ps2RecompiledFunctionTable[119757] = bhEne00_0x174c50; // 0x174f3c - g_ps2RecompiledFunctionTable[119775] = bhEne00_0x174c50; // 0x174f84 - g_ps2RecompiledFunctionTable[119781] = bhEne00_0x174c50; // 0x174f9c - g_ps2RecompiledFunctionTable[119787] = bhEne00_0x174c50; // 0x174fb4 - g_ps2RecompiledFunctionTable[119790] = bhEne00_0x174c50; // 0x174fc0 - g_ps2RecompiledFunctionTable[119818] = bhEne56_0x175030; // 0x175030 - g_ps2RecompiledFunctionTable[119864] = bhEne56_0x175030; // 0x1750e8 - g_ps2RecompiledFunctionTable[119923] = bhEne56_0x175030; // 0x1751d4 - g_ps2RecompiledFunctionTable[119932] = bhEne56_0x175030; // 0x1751f8 - g_ps2RecompiledFunctionTable[119985] = bhEne56_0x175030; // 0x1752cc - g_ps2RecompiledFunctionTable[119987] = bhEne56_0x175030; // 0x1752d4 - g_ps2RecompiledFunctionTable[120005] = bhEne56_0x175030; // 0x17531c - g_ps2RecompiledFunctionTable[120050] = bhEne56_0x175030; // 0x1753d0 - g_ps2RecompiledFunctionTable[120085] = bhEne56_0x175030; // 0x17545c - g_ps2RecompiledFunctionTable[120120] = bhEne56_0x175030; // 0x1754e8 - g_ps2RecompiledFunctionTable[120155] = bhEne56_0x175030; // 0x175574 - g_ps2RecompiledFunctionTable[120336] = bhEne56_0x175030; // 0x175848 - g_ps2RecompiledFunctionTable[120340] = bhEne56_0x175030; // 0x175858 - g_ps2RecompiledFunctionTable[120373] = bhEne56_0x175030; // 0x1758dc - g_ps2RecompiledFunctionTable[120375] = bhEne56_0x175030; // 0x1758e4 - g_ps2RecompiledFunctionTable[120382] = bhDrawEnemy_0x175900; // 0x175900 - g_ps2RecompiledFunctionTable[120390] = bhDrawEnemy_0x175900; // 0x175920 - g_ps2RecompiledFunctionTable[120428] = bhDrawEnemy_0x175900; // 0x1759b8 - g_ps2RecompiledFunctionTable[120434] = bhDrawEnemy_0x175900; // 0x1759d0 - g_ps2RecompiledFunctionTable[120452] = bhDrawEnemy_0x175900; // 0x175a18 - g_ps2RecompiledFunctionTable[120465] = bhDrawEnemy_0x175900; // 0x175a4c - g_ps2RecompiledFunctionTable[120486] = bhDrawEnemy_0x175900; // 0x175aa0 - g_ps2RecompiledFunctionTable[120493] = bhDrawEnemy_0x175900; // 0x175abc - g_ps2RecompiledFunctionTable[120502] = bhDrawEnemy_0x175900; // 0x175ae0 - g_ps2RecompiledFunctionTable[120508] = bhDrawEnemy_0x175900; // 0x175af8 - g_ps2RecompiledFunctionTable[120513] = bhDrawEnemy_0x175900; // 0x175b0c - g_ps2RecompiledFunctionTable[120517] = bhDrawEnemy_0x175900; // 0x175b1c - g_ps2RecompiledFunctionTable[120522] = bhDrawEnemy_0x175900; // 0x175b30 - g_ps2RecompiledFunctionTable[120538] = bhDrawEneObject_0x175b70; // 0x175b70 - g_ps2RecompiledFunctionTable[120547] = bhDrawEneObject_0x175b70; // 0x175b94 - g_ps2RecompiledFunctionTable[120565] = bhDrawEneObject_0x175b70; // 0x175bdc - g_ps2RecompiledFunctionTable[120572] = bhDrawEneObject_0x175b70; // 0x175bf8 - g_ps2RecompiledFunctionTable[120588] = bhDrawEneObject_0x175b70; // 0x175c38 - g_ps2RecompiledFunctionTable[120594] = bhDrawEneObject_0x175b70; // 0x175c50 - g_ps2RecompiledFunctionTable[120599] = bhDrawEneObject_0x175b70; // 0x175c64 - g_ps2RecompiledFunctionTable[120603] = bhDrawEneObject_0x175b70; // 0x175c74 - g_ps2RecompiledFunctionTable[120608] = bhDrawEneObject_0x175b70; // 0x175c88 - g_ps2RecompiledFunctionTable[120626] = bhEne_CallocWork_0x175cd0; // 0x175cd0 - g_ps2RecompiledFunctionTable[120660] = bhEne_CallocWork_0x175cd0; // 0x175d58 - g_ps2RecompiledFunctionTable[120670] = bhEne_SetCallFunc_0x175d80; // 0x175d80 - g_ps2RecompiledFunctionTable[120678] = bhEne01_DmgCheckTypeDmmy_0x175da0; // 0x175da0 - g_ps2RecompiledFunctionTable[120682] = bhEne01_0x175db0; // 0x175db0 - g_ps2RecompiledFunctionTable[120687] = bhEne01_0x175db0; // 0x175dc4 - g_ps2RecompiledFunctionTable[120689] = bhEne01_0x175db0; // 0x175dcc - g_ps2RecompiledFunctionTable[120723] = bhEne01_0x175db0; // 0x175e54 - g_ps2RecompiledFunctionTable[120733] = bhEne01_0x175db0; // 0x175e7c - g_ps2RecompiledFunctionTable[120736] = bhEne01_0x175db0; // 0x175e88 - g_ps2RecompiledFunctionTable[120742] = bhEne01_MainLoop_0x175ea0; // 0x175ea0 - g_ps2RecompiledFunctionTable[120743] = bhEne01_MainLoop_0x175ea0; // 0x175ea4 - g_ps2RecompiledFunctionTable[120744] = bhEne01_MainLoop_0x175ea0; // 0x175ea8 - g_ps2RecompiledFunctionTable[120745] = bhEne01_MainLoop_0x175ea0; // 0x175eac - g_ps2RecompiledFunctionTable[120746] = bhEne01_MainLoop_0x175ea0; // 0x175eb0 - g_ps2RecompiledFunctionTable[120747] = bhEne01_MainLoop_0x175ea0; // 0x175eb4 - g_ps2RecompiledFunctionTable[120748] = bhEne01_MainLoop_0x175ea0; // 0x175eb8 - g_ps2RecompiledFunctionTable[120749] = bhEne01_MainLoop_0x175ea0; // 0x175ebc - g_ps2RecompiledFunctionTable[120750] = bhEne01_MainLoop_0x175ea0; // 0x175ec0 - g_ps2RecompiledFunctionTable[120751] = bhEne01_MainLoop_0x175ea0; // 0x175ec4 - g_ps2RecompiledFunctionTable[120752] = bhEne01_MainLoop_0x175ea0; // 0x175ec8 - g_ps2RecompiledFunctionTable[120753] = bhEne01_MainLoop_0x175ea0; // 0x175ecc - g_ps2RecompiledFunctionTable[120754] = bhEne01_MainLoop_0x175ea0; // 0x175ed0 - g_ps2RecompiledFunctionTable[120755] = bhEne01_MainLoop_0x175ea0; // 0x175ed4 - g_ps2RecompiledFunctionTable[120756] = bhEne01_MainLoop_0x175ea0; // 0x175ed8 - g_ps2RecompiledFunctionTable[120757] = bhEne01_MainLoop_0x175ea0; // 0x175edc - g_ps2RecompiledFunctionTable[120758] = bhEne01_MainLoop_0x175ea0; // 0x175ee0 - g_ps2RecompiledFunctionTable[120759] = bhEne01_MainLoop_0x175ea0; // 0x175ee4 - g_ps2RecompiledFunctionTable[120760] = bhEne01_MainLoop_0x175ea0; // 0x175ee8 - g_ps2RecompiledFunctionTable[120761] = bhEne01_MainLoop_0x175ea0; // 0x175eec - g_ps2RecompiledFunctionTable[120762] = bhEne01_MainLoop_0x175ea0; // 0x175ef0 - g_ps2RecompiledFunctionTable[120763] = bhEne01_MainLoop_0x175ea0; // 0x175ef4 - g_ps2RecompiledFunctionTable[120764] = bhEne01_MainLoop_0x175ea0; // 0x175ef8 - g_ps2RecompiledFunctionTable[120765] = bhEne01_MainLoop_0x175ea0; // 0x175efc - g_ps2RecompiledFunctionTable[120766] = bhEne01_MainLoop_0x175ea0; // 0x175f00 - g_ps2RecompiledFunctionTable[120767] = bhEne01_MainLoop_0x175ea0; // 0x175f04 - g_ps2RecompiledFunctionTable[120768] = bhEne01_MainLoop_0x175ea0; // 0x175f08 - g_ps2RecompiledFunctionTable[120769] = bhEne01_MainLoop_0x175ea0; // 0x175f0c - g_ps2RecompiledFunctionTable[120770] = bhEne01_MainLoop_0x175ea0; // 0x175f10 - g_ps2RecompiledFunctionTable[120771] = bhEne01_MainLoop_0x175ea0; // 0x175f14 - g_ps2RecompiledFunctionTable[120772] = bhEne01_MainLoop_0x175ea0; // 0x175f18 - g_ps2RecompiledFunctionTable[120773] = bhEne01_MainLoop_0x175ea0; // 0x175f1c - g_ps2RecompiledFunctionTable[120774] = bhEne01_MainLoop_0x175ea0; // 0x175f20 - g_ps2RecompiledFunctionTable[120775] = bhEne01_MainLoop_0x175ea0; // 0x175f24 - g_ps2RecompiledFunctionTable[120776] = bhEne01_MainLoop_0x175ea0; // 0x175f28 - g_ps2RecompiledFunctionTable[120777] = bhEne01_MainLoop_0x175ea0; // 0x175f2c - g_ps2RecompiledFunctionTable[120778] = bhEne01_MainLoop_0x175ea0; // 0x175f30 - g_ps2RecompiledFunctionTable[120779] = bhEne01_MainLoop_0x175ea0; // 0x175f34 - g_ps2RecompiledFunctionTable[120780] = bhEne01_MainLoop_0x175ea0; // 0x175f38 - g_ps2RecompiledFunctionTable[120781] = bhEne01_MainLoop_0x175ea0; // 0x175f3c - g_ps2RecompiledFunctionTable[120782] = bhEne01_MainLoop_0x175ea0; // 0x175f40 - g_ps2RecompiledFunctionTable[120783] = bhEne01_MainLoop_0x175ea0; // 0x175f44 - g_ps2RecompiledFunctionTable[120784] = bhEne01_MainLoop_0x175ea0; // 0x175f48 - g_ps2RecompiledFunctionTable[120785] = bhEne01_MainLoop_0x175ea0; // 0x175f4c - g_ps2RecompiledFunctionTable[120786] = bhEne01_MainLoop_0x175ea0; // 0x175f50 - g_ps2RecompiledFunctionTable[120787] = bhEne01_MainLoop_0x175ea0; // 0x175f54 - g_ps2RecompiledFunctionTable[120788] = bhEne01_MainLoop_0x175ea0; // 0x175f58 - g_ps2RecompiledFunctionTable[120789] = bhEne01_MainLoop_0x175ea0; // 0x175f5c - g_ps2RecompiledFunctionTable[120790] = bhEne01_MainLoop_0x175ea0; // 0x175f60 - g_ps2RecompiledFunctionTable[120791] = bhEne01_MainLoop_0x175ea0; // 0x175f64 - g_ps2RecompiledFunctionTable[120792] = bhEne01_MainLoop_0x175ea0; // 0x175f68 - g_ps2RecompiledFunctionTable[120793] = bhEne01_MainLoop_0x175ea0; // 0x175f6c - g_ps2RecompiledFunctionTable[120794] = bhEne01_MainLoop_0x175ea0; // 0x175f70 - g_ps2RecompiledFunctionTable[120795] = bhEne01_MainLoop_0x175ea0; // 0x175f74 - g_ps2RecompiledFunctionTable[120796] = bhEne01_MainLoop_0x175ea0; // 0x175f78 - g_ps2RecompiledFunctionTable[120797] = bhEne01_MainLoop_0x175ea0; // 0x175f7c - g_ps2RecompiledFunctionTable[120798] = bhEne01_MainLoop_0x175ea0; // 0x175f80 - g_ps2RecompiledFunctionTable[120799] = bhEne01_MainLoop_0x175ea0; // 0x175f84 - g_ps2RecompiledFunctionTable[120800] = bhEne01_MainLoop_0x175ea0; // 0x175f88 - g_ps2RecompiledFunctionTable[120801] = bhEne01_MainLoop_0x175ea0; // 0x175f8c - g_ps2RecompiledFunctionTable[120802] = bhEne01_MainLoop_0x175ea0; // 0x175f90 - g_ps2RecompiledFunctionTable[120803] = bhEne01_MainLoop_0x175ea0; // 0x175f94 - g_ps2RecompiledFunctionTable[120804] = bhEne01_MainLoop_0x175ea0; // 0x175f98 - g_ps2RecompiledFunctionTable[120805] = bhEne01_MainLoop_0x175ea0; // 0x175f9c - g_ps2RecompiledFunctionTable[120806] = bhEne01_MainLoop_0x175ea0; // 0x175fa0 - g_ps2RecompiledFunctionTable[120810] = bhEne01_Init_0x175fb0; // 0x175fb0 - g_ps2RecompiledFunctionTable[120811] = bhEne01_Init_0x175fb0; // 0x175fb4 - g_ps2RecompiledFunctionTable[120812] = bhEne01_Init_0x175fb0; // 0x175fb8 - g_ps2RecompiledFunctionTable[120813] = bhEne01_Init_0x175fb0; // 0x175fbc - g_ps2RecompiledFunctionTable[120814] = bhEne01_Init_0x175fb0; // 0x175fc0 - g_ps2RecompiledFunctionTable[120815] = bhEne01_Init_0x175fb0; // 0x175fc4 - g_ps2RecompiledFunctionTable[120816] = bhEne01_Init_0x175fb0; // 0x175fc8 - g_ps2RecompiledFunctionTable[120817] = bhEne01_Init_0x175fb0; // 0x175fcc - g_ps2RecompiledFunctionTable[120818] = bhEne01_Init_0x175fb0; // 0x175fd0 - g_ps2RecompiledFunctionTable[120819] = bhEne01_Init_0x175fb0; // 0x175fd4 - g_ps2RecompiledFunctionTable[120820] = bhEne01_Init_0x175fb0; // 0x175fd8 - g_ps2RecompiledFunctionTable[120821] = bhEne01_Init_0x175fb0; // 0x175fdc - g_ps2RecompiledFunctionTable[120822] = bhEne01_Init_0x175fb0; // 0x175fe0 - g_ps2RecompiledFunctionTable[120823] = bhEne01_Init_0x175fb0; // 0x175fe4 - g_ps2RecompiledFunctionTable[120824] = bhEne01_Init_0x175fb0; // 0x175fe8 - g_ps2RecompiledFunctionTable[120825] = bhEne01_Init_0x175fb0; // 0x175fec - g_ps2RecompiledFunctionTable[120826] = bhEne01_Init_0x175fb0; // 0x175ff0 - g_ps2RecompiledFunctionTable[120827] = bhEne01_Init_0x175fb0; // 0x175ff4 - g_ps2RecompiledFunctionTable[120828] = bhEne01_Init_0x175fb0; // 0x175ff8 - g_ps2RecompiledFunctionTable[120829] = bhEne01_Init_0x175fb0; // 0x175ffc - g_ps2RecompiledFunctionTable[120830] = bhEne01_Init_0x175fb0; // 0x176000 - g_ps2RecompiledFunctionTable[120831] = bhEne01_Init_0x175fb0; // 0x176004 - g_ps2RecompiledFunctionTable[120832] = bhEne01_Init_0x175fb0; // 0x176008 - g_ps2RecompiledFunctionTable[120833] = bhEne01_Init_0x175fb0; // 0x17600c - g_ps2RecompiledFunctionTable[120834] = bhEne01_Init_0x175fb0; // 0x176010 - g_ps2RecompiledFunctionTable[120835] = bhEne01_Init_0x175fb0; // 0x176014 - g_ps2RecompiledFunctionTable[120836] = bhEne01_Init_0x175fb0; // 0x176018 - g_ps2RecompiledFunctionTable[120837] = bhEne01_Init_0x175fb0; // 0x17601c - g_ps2RecompiledFunctionTable[120838] = bhEne01_Init_0x175fb0; // 0x176020 - g_ps2RecompiledFunctionTable[120839] = bhEne01_Init_0x175fb0; // 0x176024 - g_ps2RecompiledFunctionTable[120840] = bhEne01_Init_0x175fb0; // 0x176028 - g_ps2RecompiledFunctionTable[120841] = bhEne01_Init_0x175fb0; // 0x17602c - g_ps2RecompiledFunctionTable[120842] = bhEne01_Init_0x175fb0; // 0x176030 - g_ps2RecompiledFunctionTable[120843] = bhEne01_Init_0x175fb0; // 0x176034 - g_ps2RecompiledFunctionTable[120844] = bhEne01_Init_0x175fb0; // 0x176038 - g_ps2RecompiledFunctionTable[120845] = bhEne01_Init_0x175fb0; // 0x17603c - g_ps2RecompiledFunctionTable[120846] = bhEne01_Init_0x175fb0; // 0x176040 - g_ps2RecompiledFunctionTable[120847] = bhEne01_Init_0x175fb0; // 0x176044 - g_ps2RecompiledFunctionTable[120848] = bhEne01_Init_0x175fb0; // 0x176048 - g_ps2RecompiledFunctionTable[120849] = bhEne01_Init_0x175fb0; // 0x17604c - g_ps2RecompiledFunctionTable[120850] = bhEne01_Init_0x175fb0; // 0x176050 - g_ps2RecompiledFunctionTable[120851] = bhEne01_Init_0x175fb0; // 0x176054 - g_ps2RecompiledFunctionTable[120852] = bhEne01_Init_0x175fb0; // 0x176058 - g_ps2RecompiledFunctionTable[120853] = bhEne01_Init_0x175fb0; // 0x17605c - g_ps2RecompiledFunctionTable[120854] = bhEne01_Init_0x175fb0; // 0x176060 - g_ps2RecompiledFunctionTable[120855] = bhEne01_Init_0x175fb0; // 0x176064 - g_ps2RecompiledFunctionTable[120856] = bhEne01_Init_0x175fb0; // 0x176068 - g_ps2RecompiledFunctionTable[120857] = bhEne01_Init_0x175fb0; // 0x17606c - g_ps2RecompiledFunctionTable[120858] = bhEne01_Init_0x175fb0; // 0x176070 - g_ps2RecompiledFunctionTable[120859] = bhEne01_Init_0x175fb0; // 0x176074 - g_ps2RecompiledFunctionTable[120860] = bhEne01_Init_0x175fb0; // 0x176078 - g_ps2RecompiledFunctionTable[120861] = bhEne01_Init_0x175fb0; // 0x17607c - g_ps2RecompiledFunctionTable[120862] = bhEne01_Init_0x175fb0; // 0x176080 - g_ps2RecompiledFunctionTable[120863] = bhEne01_Init_0x175fb0; // 0x176084 - g_ps2RecompiledFunctionTable[120864] = bhEne01_Init_0x175fb0; // 0x176088 - g_ps2RecompiledFunctionTable[120865] = bhEne01_Init_0x175fb0; // 0x17608c - g_ps2RecompiledFunctionTable[120866] = bhEne01_Init_0x175fb0; // 0x176090 - g_ps2RecompiledFunctionTable[120867] = bhEne01_Init_0x175fb0; // 0x176094 - g_ps2RecompiledFunctionTable[120868] = bhEne01_Init_0x175fb0; // 0x176098 - g_ps2RecompiledFunctionTable[120869] = bhEne01_Init_0x175fb0; // 0x17609c - g_ps2RecompiledFunctionTable[120870] = bhEne01_Init_0x175fb0; // 0x1760a0 - g_ps2RecompiledFunctionTable[120871] = bhEne01_Init_0x175fb0; // 0x1760a4 - g_ps2RecompiledFunctionTable[120872] = bhEne01_Init_0x175fb0; // 0x1760a8 - g_ps2RecompiledFunctionTable[120873] = bhEne01_Init_0x175fb0; // 0x1760ac - g_ps2RecompiledFunctionTable[120874] = bhEne01_Init_0x175fb0; // 0x1760b0 - g_ps2RecompiledFunctionTable[120875] = bhEne01_Init_0x175fb0; // 0x1760b4 - g_ps2RecompiledFunctionTable[120876] = bhEne01_Init_0x175fb0; // 0x1760b8 - g_ps2RecompiledFunctionTable[120877] = bhEne01_Init_0x175fb0; // 0x1760bc - g_ps2RecompiledFunctionTable[120878] = bhEne01_Init_0x175fb0; // 0x1760c0 - g_ps2RecompiledFunctionTable[120879] = bhEne01_Init_0x175fb0; // 0x1760c4 - g_ps2RecompiledFunctionTable[120880] = bhEne01_Init_0x175fb0; // 0x1760c8 - g_ps2RecompiledFunctionTable[120881] = bhEne01_Init_0x175fb0; // 0x1760cc - g_ps2RecompiledFunctionTable[120882] = bhEne01_Init_0x175fb0; // 0x1760d0 - g_ps2RecompiledFunctionTable[120883] = bhEne01_Init_0x175fb0; // 0x1760d4 - g_ps2RecompiledFunctionTable[120884] = bhEne01_Init_0x175fb0; // 0x1760d8 - g_ps2RecompiledFunctionTable[120885] = bhEne01_Init_0x175fb0; // 0x1760dc - g_ps2RecompiledFunctionTable[120886] = bhEne01_Init_0x175fb0; // 0x1760e0 - g_ps2RecompiledFunctionTable[120887] = bhEne01_Init_0x175fb0; // 0x1760e4 - g_ps2RecompiledFunctionTable[120888] = bhEne01_Init_0x175fb0; // 0x1760e8 - g_ps2RecompiledFunctionTable[120889] = bhEne01_Init_0x175fb0; // 0x1760ec - g_ps2RecompiledFunctionTable[120890] = bhEne01_Init_0x175fb0; // 0x1760f0 - g_ps2RecompiledFunctionTable[120891] = bhEne01_Init_0x175fb0; // 0x1760f4 - g_ps2RecompiledFunctionTable[120892] = bhEne01_Init_0x175fb0; // 0x1760f8 - g_ps2RecompiledFunctionTable[120893] = bhEne01_Init_0x175fb0; // 0x1760fc - g_ps2RecompiledFunctionTable[120894] = bhEne01_Init_0x175fb0; // 0x176100 - g_ps2RecompiledFunctionTable[120895] = bhEne01_Init_0x175fb0; // 0x176104 - g_ps2RecompiledFunctionTable[120896] = bhEne01_Init_0x175fb0; // 0x176108 - g_ps2RecompiledFunctionTable[120897] = bhEne01_Init_0x175fb0; // 0x17610c - g_ps2RecompiledFunctionTable[120898] = bhEne01_Init_0x175fb0; // 0x176110 - g_ps2RecompiledFunctionTable[120899] = bhEne01_Init_0x175fb0; // 0x176114 - g_ps2RecompiledFunctionTable[120900] = bhEne01_Init_0x175fb0; // 0x176118 - g_ps2RecompiledFunctionTable[120901] = bhEne01_Init_0x175fb0; // 0x17611c - g_ps2RecompiledFunctionTable[120902] = bhEne01_Init_0x175fb0; // 0x176120 - g_ps2RecompiledFunctionTable[120903] = bhEne01_Init_0x175fb0; // 0x176124 - g_ps2RecompiledFunctionTable[120904] = bhEne01_Init_0x175fb0; // 0x176128 - g_ps2RecompiledFunctionTable[120905] = bhEne01_Init_0x175fb0; // 0x17612c - g_ps2RecompiledFunctionTable[120906] = bhEne01_Init_0x175fb0; // 0x176130 - g_ps2RecompiledFunctionTable[120907] = bhEne01_Init_0x175fb0; // 0x176134 - g_ps2RecompiledFunctionTable[120908] = bhEne01_Init_0x175fb0; // 0x176138 - g_ps2RecompiledFunctionTable[120909] = bhEne01_Init_0x175fb0; // 0x17613c - g_ps2RecompiledFunctionTable[120910] = bhEne01_Init_0x175fb0; // 0x176140 - g_ps2RecompiledFunctionTable[120911] = bhEne01_Init_0x175fb0; // 0x176144 - g_ps2RecompiledFunctionTable[120912] = bhEne01_Init_0x175fb0; // 0x176148 - g_ps2RecompiledFunctionTable[120913] = bhEne01_Init_0x175fb0; // 0x17614c - g_ps2RecompiledFunctionTable[120914] = bhEne01_Init_0x175fb0; // 0x176150 - g_ps2RecompiledFunctionTable[120915] = bhEne01_Init_0x175fb0; // 0x176154 - g_ps2RecompiledFunctionTable[120916] = bhEne01_Init_0x175fb0; // 0x176158 - g_ps2RecompiledFunctionTable[120917] = bhEne01_Init_0x175fb0; // 0x17615c - g_ps2RecompiledFunctionTable[120918] = bhEne01_Init_0x175fb0; // 0x176160 - g_ps2RecompiledFunctionTable[120919] = bhEne01_Init_0x175fb0; // 0x176164 - g_ps2RecompiledFunctionTable[120920] = bhEne01_Init_0x175fb0; // 0x176168 - g_ps2RecompiledFunctionTable[120921] = bhEne01_Init_0x175fb0; // 0x17616c - g_ps2RecompiledFunctionTable[120922] = bhEne01_Init_0x175fb0; // 0x176170 - g_ps2RecompiledFunctionTable[120923] = bhEne01_Init_0x175fb0; // 0x176174 - g_ps2RecompiledFunctionTable[120924] = bhEne01_Init_0x175fb0; // 0x176178 - g_ps2RecompiledFunctionTable[120925] = bhEne01_Init_0x175fb0; // 0x17617c - g_ps2RecompiledFunctionTable[120926] = bhEne01_Init_0x175fb0; // 0x176180 - g_ps2RecompiledFunctionTable[120927] = bhEne01_Init_0x175fb0; // 0x176184 - g_ps2RecompiledFunctionTable[120928] = bhEne01_Init_0x175fb0; // 0x176188 - g_ps2RecompiledFunctionTable[120929] = bhEne01_Init_0x175fb0; // 0x17618c - g_ps2RecompiledFunctionTable[120930] = bhEne01_Init_0x175fb0; // 0x176190 - g_ps2RecompiledFunctionTable[120931] = bhEne01_Init_0x175fb0; // 0x176194 - g_ps2RecompiledFunctionTable[120932] = bhEne01_Init_0x175fb0; // 0x176198 - g_ps2RecompiledFunctionTable[120933] = bhEne01_Init_0x175fb0; // 0x17619c - g_ps2RecompiledFunctionTable[120934] = bhEne01_Init_0x175fb0; // 0x1761a0 - g_ps2RecompiledFunctionTable[120935] = bhEne01_Init_0x175fb0; // 0x1761a4 - g_ps2RecompiledFunctionTable[120936] = bhEne01_Init_0x175fb0; // 0x1761a8 - g_ps2RecompiledFunctionTable[120937] = bhEne01_Init_0x175fb0; // 0x1761ac - g_ps2RecompiledFunctionTable[120938] = bhEne01_Init_0x175fb0; // 0x1761b0 - g_ps2RecompiledFunctionTable[120939] = bhEne01_Init_0x175fb0; // 0x1761b4 - g_ps2RecompiledFunctionTable[120940] = bhEne01_Init_0x175fb0; // 0x1761b8 - g_ps2RecompiledFunctionTable[120941] = bhEne01_Init_0x175fb0; // 0x1761bc - g_ps2RecompiledFunctionTable[120942] = bhEne01_Init_0x175fb0; // 0x1761c0 - g_ps2RecompiledFunctionTable[120943] = bhEne01_Init_0x175fb0; // 0x1761c4 - g_ps2RecompiledFunctionTable[120944] = bhEne01_Init_0x175fb0; // 0x1761c8 - g_ps2RecompiledFunctionTable[120945] = bhEne01_Init_0x175fb0; // 0x1761cc - g_ps2RecompiledFunctionTable[120946] = bhEne01_Init_0x175fb0; // 0x1761d0 - g_ps2RecompiledFunctionTable[120947] = bhEne01_Init_0x175fb0; // 0x1761d4 - g_ps2RecompiledFunctionTable[120948] = bhEne01_Init_0x175fb0; // 0x1761d8 - g_ps2RecompiledFunctionTable[120949] = bhEne01_Init_0x175fb0; // 0x1761dc - g_ps2RecompiledFunctionTable[120950] = bhEne01_Init_0x175fb0; // 0x1761e0 - g_ps2RecompiledFunctionTable[120951] = bhEne01_Init_0x175fb0; // 0x1761e4 - g_ps2RecompiledFunctionTable[120952] = bhEne01_Init_0x175fb0; // 0x1761e8 - g_ps2RecompiledFunctionTable[120953] = bhEne01_Init_0x175fb0; // 0x1761ec - g_ps2RecompiledFunctionTable[120954] = bhEne01_Init_0x175fb0; // 0x1761f0 - g_ps2RecompiledFunctionTable[120955] = bhEne01_Init_0x175fb0; // 0x1761f4 - g_ps2RecompiledFunctionTable[120956] = bhEne01_Init_0x175fb0; // 0x1761f8 - g_ps2RecompiledFunctionTable[120957] = bhEne01_Init_0x175fb0; // 0x1761fc - g_ps2RecompiledFunctionTable[120958] = bhEne01_Init_0x175fb0; // 0x176200 - g_ps2RecompiledFunctionTable[120959] = bhEne01_Init_0x175fb0; // 0x176204 - g_ps2RecompiledFunctionTable[120960] = bhEne01_Init_0x175fb0; // 0x176208 - g_ps2RecompiledFunctionTable[120961] = bhEne01_Init_0x175fb0; // 0x17620c - g_ps2RecompiledFunctionTable[120962] = bhEne01_Init_0x175fb0; // 0x176210 - g_ps2RecompiledFunctionTable[120963] = bhEne01_Init_0x175fb0; // 0x176214 - g_ps2RecompiledFunctionTable[120964] = bhEne01_Init_0x175fb0; // 0x176218 - g_ps2RecompiledFunctionTable[120965] = bhEne01_Init_0x175fb0; // 0x17621c - g_ps2RecompiledFunctionTable[120966] = bhEne01_Init_0x175fb0; // 0x176220 - g_ps2RecompiledFunctionTable[120967] = bhEne01_Init_0x175fb0; // 0x176224 - g_ps2RecompiledFunctionTable[120968] = bhEne01_Init_0x175fb0; // 0x176228 - g_ps2RecompiledFunctionTable[120969] = bhEne01_Init_0x175fb0; // 0x17622c - g_ps2RecompiledFunctionTable[120970] = bhEne01_Init_0x175fb0; // 0x176230 - g_ps2RecompiledFunctionTable[120971] = bhEne01_Init_0x175fb0; // 0x176234 - g_ps2RecompiledFunctionTable[120972] = bhEne01_Init_0x175fb0; // 0x176238 - g_ps2RecompiledFunctionTable[120973] = bhEne01_Init_0x175fb0; // 0x17623c - g_ps2RecompiledFunctionTable[120974] = bhEne01_Init_0x175fb0; // 0x176240 - g_ps2RecompiledFunctionTable[120975] = bhEne01_Init_0x175fb0; // 0x176244 - g_ps2RecompiledFunctionTable[120976] = bhEne01_Init_0x175fb0; // 0x176248 - g_ps2RecompiledFunctionTable[120977] = bhEne01_Init_0x175fb0; // 0x17624c - g_ps2RecompiledFunctionTable[120978] = bhEne01_Init_0x175fb0; // 0x176250 - g_ps2RecompiledFunctionTable[120979] = bhEne01_Init_0x175fb0; // 0x176254 - g_ps2RecompiledFunctionTable[120980] = bhEne01_Init_0x175fb0; // 0x176258 - g_ps2RecompiledFunctionTable[120981] = bhEne01_Init_0x175fb0; // 0x17625c - g_ps2RecompiledFunctionTable[120982] = bhEne01_Init_0x175fb0; // 0x176260 - g_ps2RecompiledFunctionTable[120983] = bhEne01_Init_0x175fb0; // 0x176264 - g_ps2RecompiledFunctionTable[120984] = bhEne01_Init_0x175fb0; // 0x176268 - g_ps2RecompiledFunctionTable[120985] = bhEne01_Init_0x175fb0; // 0x17626c - g_ps2RecompiledFunctionTable[120986] = bhEne01_Init_0x175fb0; // 0x176270 - g_ps2RecompiledFunctionTable[120987] = bhEne01_Init_0x175fb0; // 0x176274 - g_ps2RecompiledFunctionTable[120988] = bhEne01_Init_0x175fb0; // 0x176278 - g_ps2RecompiledFunctionTable[120989] = bhEne01_Init_0x175fb0; // 0x17627c - g_ps2RecompiledFunctionTable[120990] = bhEne01_Init_0x175fb0; // 0x176280 - g_ps2RecompiledFunctionTable[120991] = bhEne01_Init_0x175fb0; // 0x176284 - g_ps2RecompiledFunctionTable[120992] = bhEne01_Init_0x175fb0; // 0x176288 - g_ps2RecompiledFunctionTable[120993] = bhEne01_Init_0x175fb0; // 0x17628c - g_ps2RecompiledFunctionTable[120994] = bhEne01_Init_0x175fb0; // 0x176290 - g_ps2RecompiledFunctionTable[120995] = bhEne01_Init_0x175fb0; // 0x176294 - g_ps2RecompiledFunctionTable[120996] = bhEne01_Init_0x175fb0; // 0x176298 - g_ps2RecompiledFunctionTable[120997] = bhEne01_Init_0x175fb0; // 0x17629c - g_ps2RecompiledFunctionTable[120998] = bhEne01_Init_0x175fb0; // 0x1762a0 - g_ps2RecompiledFunctionTable[120999] = bhEne01_Init_0x175fb0; // 0x1762a4 - g_ps2RecompiledFunctionTable[121000] = bhEne01_Init_0x175fb0; // 0x1762a8 - g_ps2RecompiledFunctionTable[121001] = bhEne01_Init_0x175fb0; // 0x1762ac - g_ps2RecompiledFunctionTable[121002] = bhEne01_Init_0x175fb0; // 0x1762b0 - g_ps2RecompiledFunctionTable[121003] = bhEne01_Init_0x175fb0; // 0x1762b4 - g_ps2RecompiledFunctionTable[121004] = bhEne01_Init_0x175fb0; // 0x1762b8 - g_ps2RecompiledFunctionTable[121005] = bhEne01_Init_0x175fb0; // 0x1762bc - g_ps2RecompiledFunctionTable[121006] = bhEne01_Init_0x175fb0; // 0x1762c0 - g_ps2RecompiledFunctionTable[121007] = bhEne01_Init_0x175fb0; // 0x1762c4 - g_ps2RecompiledFunctionTable[121008] = bhEne01_Init_0x175fb0; // 0x1762c8 - g_ps2RecompiledFunctionTable[121009] = bhEne01_Init_0x175fb0; // 0x1762cc - g_ps2RecompiledFunctionTable[121010] = bhEne01_Init_0x175fb0; // 0x1762d0 - g_ps2RecompiledFunctionTable[121011] = bhEne01_Init_0x175fb0; // 0x1762d4 - g_ps2RecompiledFunctionTable[121012] = bhEne01_Init_0x175fb0; // 0x1762d8 - g_ps2RecompiledFunctionTable[121013] = bhEne01_Init_0x175fb0; // 0x1762dc - g_ps2RecompiledFunctionTable[121014] = bhEne01_Init_0x175fb0; // 0x1762e0 - g_ps2RecompiledFunctionTable[121015] = bhEne01_Init_0x175fb0; // 0x1762e4 - g_ps2RecompiledFunctionTable[121016] = bhEne01_Init_0x175fb0; // 0x1762e8 - g_ps2RecompiledFunctionTable[121017] = bhEne01_Init_0x175fb0; // 0x1762ec - g_ps2RecompiledFunctionTable[121018] = bhEne01_Init_0x175fb0; // 0x1762f0 - g_ps2RecompiledFunctionTable[121019] = bhEne01_Init_0x175fb0; // 0x1762f4 - g_ps2RecompiledFunctionTable[121020] = bhEne01_Init_0x175fb0; // 0x1762f8 - g_ps2RecompiledFunctionTable[121021] = bhEne01_Init_0x175fb0; // 0x1762fc - g_ps2RecompiledFunctionTable[121022] = bhEne01_Init_0x175fb0; // 0x176300 - g_ps2RecompiledFunctionTable[121023] = bhEne01_Init_0x175fb0; // 0x176304 - g_ps2RecompiledFunctionTable[121024] = bhEne01_Init_0x175fb0; // 0x176308 - g_ps2RecompiledFunctionTable[121025] = bhEne01_Init_0x175fb0; // 0x17630c - g_ps2RecompiledFunctionTable[121026] = bhEne01_Init_0x175fb0; // 0x176310 - g_ps2RecompiledFunctionTable[121027] = bhEne01_Init_0x175fb0; // 0x176314 - g_ps2RecompiledFunctionTable[121028] = bhEne01_Init_0x175fb0; // 0x176318 - g_ps2RecompiledFunctionTable[121029] = bhEne01_Init_0x175fb0; // 0x17631c - g_ps2RecompiledFunctionTable[121030] = bhEne01_Init_0x175fb0; // 0x176320 - g_ps2RecompiledFunctionTable[121031] = bhEne01_Init_0x175fb0; // 0x176324 - g_ps2RecompiledFunctionTable[121032] = bhEne01_Init_0x175fb0; // 0x176328 - g_ps2RecompiledFunctionTable[121033] = bhEne01_Init_0x175fb0; // 0x17632c - g_ps2RecompiledFunctionTable[121034] = bhEne01_Init_0x175fb0; // 0x176330 - g_ps2RecompiledFunctionTable[121035] = bhEne01_Init_0x175fb0; // 0x176334 - g_ps2RecompiledFunctionTable[121036] = bhEne01_Init_0x175fb0; // 0x176338 - g_ps2RecompiledFunctionTable[121037] = bhEne01_Init_0x175fb0; // 0x17633c - g_ps2RecompiledFunctionTable[121038] = bhEne01_Init_0x175fb0; // 0x176340 - g_ps2RecompiledFunctionTable[121039] = bhEne01_Init_0x175fb0; // 0x176344 - g_ps2RecompiledFunctionTable[121040] = bhEne01_Init_0x175fb0; // 0x176348 - g_ps2RecompiledFunctionTable[121041] = bhEne01_Init_0x175fb0; // 0x17634c - g_ps2RecompiledFunctionTable[121042] = bhEne01_Init_0x175fb0; // 0x176350 - g_ps2RecompiledFunctionTable[121043] = bhEne01_Init_0x175fb0; // 0x176354 - g_ps2RecompiledFunctionTable[121044] = bhEne01_Init_0x175fb0; // 0x176358 - g_ps2RecompiledFunctionTable[121045] = bhEne01_Init_0x175fb0; // 0x17635c - g_ps2RecompiledFunctionTable[121046] = bhEne01_Init_0x175fb0; // 0x176360 - g_ps2RecompiledFunctionTable[121047] = bhEne01_Init_0x175fb0; // 0x176364 - g_ps2RecompiledFunctionTable[121048] = bhEne01_Init_0x175fb0; // 0x176368 - g_ps2RecompiledFunctionTable[121049] = bhEne01_Init_0x175fb0; // 0x17636c - g_ps2RecompiledFunctionTable[121050] = bhEne01_Init_0x175fb0; // 0x176370 - g_ps2RecompiledFunctionTable[121051] = bhEne01_Init_0x175fb0; // 0x176374 - g_ps2RecompiledFunctionTable[121052] = bhEne01_Init_0x175fb0; // 0x176378 - g_ps2RecompiledFunctionTable[121053] = bhEne01_Init_0x175fb0; // 0x17637c - g_ps2RecompiledFunctionTable[121054] = bhEne01_Init_0x175fb0; // 0x176380 - g_ps2RecompiledFunctionTable[121055] = bhEne01_Init_0x175fb0; // 0x176384 - g_ps2RecompiledFunctionTable[121056] = bhEne01_Init_0x175fb0; // 0x176388 - g_ps2RecompiledFunctionTable[121057] = bhEne01_Init_0x175fb0; // 0x17638c - g_ps2RecompiledFunctionTable[121058] = bhEne01_Init_0x175fb0; // 0x176390 - g_ps2RecompiledFunctionTable[121059] = bhEne01_Init_0x175fb0; // 0x176394 - g_ps2RecompiledFunctionTable[121060] = bhEne01_Init_0x175fb0; // 0x176398 - g_ps2RecompiledFunctionTable[121061] = bhEne01_Init_0x175fb0; // 0x17639c - g_ps2RecompiledFunctionTable[121062] = bhEne01_Init_0x175fb0; // 0x1763a0 - g_ps2RecompiledFunctionTable[121063] = bhEne01_Init_0x175fb0; // 0x1763a4 - g_ps2RecompiledFunctionTable[121064] = bhEne01_Init_0x175fb0; // 0x1763a8 - g_ps2RecompiledFunctionTable[121065] = bhEne01_Init_0x175fb0; // 0x1763ac - g_ps2RecompiledFunctionTable[121066] = bhEne01_Init_0x175fb0; // 0x1763b0 - g_ps2RecompiledFunctionTable[121067] = bhEne01_Init_0x175fb0; // 0x1763b4 - g_ps2RecompiledFunctionTable[121068] = bhEne01_Init_0x175fb0; // 0x1763b8 - g_ps2RecompiledFunctionTable[121069] = bhEne01_Init_0x175fb0; // 0x1763bc - g_ps2RecompiledFunctionTable[121070] = bhEne01_Init_0x175fb0; // 0x1763c0 - g_ps2RecompiledFunctionTable[121071] = bhEne01_Init_0x175fb0; // 0x1763c4 - g_ps2RecompiledFunctionTable[121072] = bhEne01_Init_0x175fb0; // 0x1763c8 - g_ps2RecompiledFunctionTable[121073] = bhEne01_Init_0x175fb0; // 0x1763cc - g_ps2RecompiledFunctionTable[121074] = bhEne01_Init_0x175fb0; // 0x1763d0 - g_ps2RecompiledFunctionTable[121075] = bhEne01_Init_0x175fb0; // 0x1763d4 - g_ps2RecompiledFunctionTable[121076] = bhEne01_Init_0x175fb0; // 0x1763d8 - g_ps2RecompiledFunctionTable[121077] = bhEne01_Init_0x175fb0; // 0x1763dc - g_ps2RecompiledFunctionTable[121078] = bhEne01_Init_0x175fb0; // 0x1763e0 - g_ps2RecompiledFunctionTable[121079] = bhEne01_Init_0x175fb0; // 0x1763e4 - g_ps2RecompiledFunctionTable[121080] = bhEne01_Init_0x175fb0; // 0x1763e8 - g_ps2RecompiledFunctionTable[121081] = bhEne01_Init_0x175fb0; // 0x1763ec - g_ps2RecompiledFunctionTable[121082] = bhEne01_Init_0x175fb0; // 0x1763f0 - g_ps2RecompiledFunctionTable[121083] = bhEne01_Init_0x175fb0; // 0x1763f4 - g_ps2RecompiledFunctionTable[121084] = bhEne01_Init_0x175fb0; // 0x1763f8 - g_ps2RecompiledFunctionTable[121085] = bhEne01_Init_0x175fb0; // 0x1763fc - g_ps2RecompiledFunctionTable[121086] = bhEne01_Init_0x175fb0; // 0x176400 - g_ps2RecompiledFunctionTable[121087] = bhEne01_Init_0x175fb0; // 0x176404 - g_ps2RecompiledFunctionTable[121088] = bhEne01_Init_0x175fb0; // 0x176408 - g_ps2RecompiledFunctionTable[121089] = bhEne01_Init_0x175fb0; // 0x17640c - g_ps2RecompiledFunctionTable[121090] = bhEne01_Init_0x175fb0; // 0x176410 - g_ps2RecompiledFunctionTable[121091] = bhEne01_Init_0x175fb0; // 0x176414 - g_ps2RecompiledFunctionTable[121092] = bhEne01_Init_0x175fb0; // 0x176418 - g_ps2RecompiledFunctionTable[121093] = bhEne01_Init_0x175fb0; // 0x17641c - g_ps2RecompiledFunctionTable[121094] = bhEne01_Init_0x175fb0; // 0x176420 - g_ps2RecompiledFunctionTable[121095] = bhEne01_Init_0x175fb0; // 0x176424 - g_ps2RecompiledFunctionTable[121096] = bhEne01_Init_0x175fb0; // 0x176428 - g_ps2RecompiledFunctionTable[121097] = bhEne01_Init_0x175fb0; // 0x17642c - g_ps2RecompiledFunctionTable[121098] = bhEne01_Init_0x175fb0; // 0x176430 - g_ps2RecompiledFunctionTable[121099] = bhEne01_Init_0x175fb0; // 0x176434 - g_ps2RecompiledFunctionTable[121100] = bhEne01_Init_0x175fb0; // 0x176438 - g_ps2RecompiledFunctionTable[121101] = bhEne01_Init_0x175fb0; // 0x17643c - g_ps2RecompiledFunctionTable[121102] = bhEne01_Init_0x175fb0; // 0x176440 - g_ps2RecompiledFunctionTable[121103] = bhEne01_Init_0x175fb0; // 0x176444 - g_ps2RecompiledFunctionTable[121104] = bhEne01_Init_0x175fb0; // 0x176448 - g_ps2RecompiledFunctionTable[121105] = bhEne01_Init_0x175fb0; // 0x17644c - g_ps2RecompiledFunctionTable[121106] = bhEne01_Init_0x175fb0; // 0x176450 - g_ps2RecompiledFunctionTable[121107] = bhEne01_Init_0x175fb0; // 0x176454 - g_ps2RecompiledFunctionTable[121108] = bhEne01_Init_0x175fb0; // 0x176458 - g_ps2RecompiledFunctionTable[121109] = bhEne01_Init_0x175fb0; // 0x17645c - g_ps2RecompiledFunctionTable[121110] = bhEne01_Init_0x175fb0; // 0x176460 - g_ps2RecompiledFunctionTable[121111] = bhEne01_Init_0x175fb0; // 0x176464 - g_ps2RecompiledFunctionTable[121112] = bhEne01_Init_0x175fb0; // 0x176468 - g_ps2RecompiledFunctionTable[121113] = bhEne01_Init_0x175fb0; // 0x17646c - g_ps2RecompiledFunctionTable[121114] = bhEne01_Init_0x175fb0; // 0x176470 - g_ps2RecompiledFunctionTable[121115] = bhEne01_Init_0x175fb0; // 0x176474 - g_ps2RecompiledFunctionTable[121116] = bhEne01_Init_0x175fb0; // 0x176478 - g_ps2RecompiledFunctionTable[121117] = bhEne01_Init_0x175fb0; // 0x17647c - g_ps2RecompiledFunctionTable[121118] = bhEne01_Init_0x175fb0; // 0x176480 - g_ps2RecompiledFunctionTable[121119] = bhEne01_Init_0x175fb0; // 0x176484 - g_ps2RecompiledFunctionTable[121120] = bhEne01_Init_0x175fb0; // 0x176488 - g_ps2RecompiledFunctionTable[121121] = bhEne01_Init_0x175fb0; // 0x17648c - g_ps2RecompiledFunctionTable[121122] = bhEne01_Init_0x175fb0; // 0x176490 - g_ps2RecompiledFunctionTable[121123] = bhEne01_Init_0x175fb0; // 0x176494 - g_ps2RecompiledFunctionTable[121124] = bhEne01_Init_0x175fb0; // 0x176498 - g_ps2RecompiledFunctionTable[121125] = bhEne01_Init_0x175fb0; // 0x17649c - g_ps2RecompiledFunctionTable[121126] = bhEne01_Init_0x175fb0; // 0x1764a0 - g_ps2RecompiledFunctionTable[121127] = bhEne01_Init_0x175fb0; // 0x1764a4 - g_ps2RecompiledFunctionTable[121128] = bhEne01_Init_0x175fb0; // 0x1764a8 - g_ps2RecompiledFunctionTable[121129] = bhEne01_Init_0x175fb0; // 0x1764ac - g_ps2RecompiledFunctionTable[121130] = bhEne01_Init_0x175fb0; // 0x1764b0 - g_ps2RecompiledFunctionTable[121131] = bhEne01_Init_0x175fb0; // 0x1764b4 - g_ps2RecompiledFunctionTable[121132] = bhEne01_Init_0x175fb0; // 0x1764b8 - g_ps2RecompiledFunctionTable[121133] = bhEne01_Init_0x175fb0; // 0x1764bc - g_ps2RecompiledFunctionTable[121134] = bhEne01_Init_0x175fb0; // 0x1764c0 - g_ps2RecompiledFunctionTable[121135] = bhEne01_Init_0x175fb0; // 0x1764c4 - g_ps2RecompiledFunctionTable[121136] = bhEne01_Init_0x175fb0; // 0x1764c8 - g_ps2RecompiledFunctionTable[121137] = bhEne01_Init_0x175fb0; // 0x1764cc - g_ps2RecompiledFunctionTable[121138] = bhEne01_Init_0x175fb0; // 0x1764d0 - g_ps2RecompiledFunctionTable[121139] = bhEne01_Init_0x175fb0; // 0x1764d4 - g_ps2RecompiledFunctionTable[121140] = bhEne01_Init_0x175fb0; // 0x1764d8 - g_ps2RecompiledFunctionTable[121141] = bhEne01_Init_0x175fb0; // 0x1764dc - g_ps2RecompiledFunctionTable[121142] = bhEne01_Init_0x175fb0; // 0x1764e0 - g_ps2RecompiledFunctionTable[121143] = bhEne01_Init_0x175fb0; // 0x1764e4 - g_ps2RecompiledFunctionTable[121144] = bhEne01_Init_0x175fb0; // 0x1764e8 - g_ps2RecompiledFunctionTable[121145] = bhEne01_Init_0x175fb0; // 0x1764ec - g_ps2RecompiledFunctionTable[121146] = bhEne01_Init_0x175fb0; // 0x1764f0 - g_ps2RecompiledFunctionTable[121147] = bhEne01_Init_0x175fb0; // 0x1764f4 - g_ps2RecompiledFunctionTable[121148] = bhEne01_Init_0x175fb0; // 0x1764f8 - g_ps2RecompiledFunctionTable[121149] = bhEne01_Init_0x175fb0; // 0x1764fc - g_ps2RecompiledFunctionTable[121150] = bhEne01_Init_0x175fb0; // 0x176500 - g_ps2RecompiledFunctionTable[121151] = bhEne01_Init_0x175fb0; // 0x176504 - g_ps2RecompiledFunctionTable[121152] = bhEne01_Init_0x175fb0; // 0x176508 - g_ps2RecompiledFunctionTable[121153] = bhEne01_Init_0x175fb0; // 0x17650c - g_ps2RecompiledFunctionTable[121154] = bhEne01_Init_0x175fb0; // 0x176510 - g_ps2RecompiledFunctionTable[121155] = bhEne01_Init_0x175fb0; // 0x176514 - g_ps2RecompiledFunctionTable[121156] = bhEne01_Init_0x175fb0; // 0x176518 - g_ps2RecompiledFunctionTable[121157] = bhEne01_Init_0x175fb0; // 0x17651c - g_ps2RecompiledFunctionTable[121158] = bhEne01_Init_0x175fb0; // 0x176520 - g_ps2RecompiledFunctionTable[121159] = bhEne01_Init_0x175fb0; // 0x176524 - g_ps2RecompiledFunctionTable[121160] = bhEne01_Init_0x175fb0; // 0x176528 - g_ps2RecompiledFunctionTable[121161] = bhEne01_Init_0x175fb0; // 0x17652c - g_ps2RecompiledFunctionTable[121162] = bhEne01_Init_0x175fb0; // 0x176530 - g_ps2RecompiledFunctionTable[121163] = bhEne01_Init_0x175fb0; // 0x176534 - g_ps2RecompiledFunctionTable[121164] = bhEne01_Init_0x175fb0; // 0x176538 - g_ps2RecompiledFunctionTable[121165] = bhEne01_Init_0x175fb0; // 0x17653c - g_ps2RecompiledFunctionTable[121166] = bhEne01_Init_0x175fb0; // 0x176540 - g_ps2RecompiledFunctionTable[121167] = bhEne01_Init_0x175fb0; // 0x176544 - g_ps2RecompiledFunctionTable[121168] = bhEne01_Init_0x175fb0; // 0x176548 - g_ps2RecompiledFunctionTable[121169] = bhEne01_Init_0x175fb0; // 0x17654c - g_ps2RecompiledFunctionTable[121170] = bhEne01_Init_0x175fb0; // 0x176550 - g_ps2RecompiledFunctionTable[121171] = bhEne01_Init_0x175fb0; // 0x176554 - g_ps2RecompiledFunctionTable[121172] = bhEne01_Init_0x175fb0; // 0x176558 - g_ps2RecompiledFunctionTable[121173] = bhEne01_Init_0x175fb0; // 0x17655c - g_ps2RecompiledFunctionTable[121174] = bhEne01_Init_0x175fb0; // 0x176560 - g_ps2RecompiledFunctionTable[121175] = bhEne01_Init_0x175fb0; // 0x176564 - g_ps2RecompiledFunctionTable[121176] = bhEne01_Init_0x175fb0; // 0x176568 - g_ps2RecompiledFunctionTable[121177] = bhEne01_Init_0x175fb0; // 0x17656c - g_ps2RecompiledFunctionTable[121178] = bhEne01_Init_0x175fb0; // 0x176570 - g_ps2RecompiledFunctionTable[121179] = bhEne01_Init_0x175fb0; // 0x176574 - g_ps2RecompiledFunctionTable[121180] = bhEne01_Init_0x175fb0; // 0x176578 - g_ps2RecompiledFunctionTable[121181] = bhEne01_Init_0x175fb0; // 0x17657c - g_ps2RecompiledFunctionTable[121182] = bhEne01_Init_0x175fb0; // 0x176580 - g_ps2RecompiledFunctionTable[121183] = bhEne01_Init_0x175fb0; // 0x176584 - g_ps2RecompiledFunctionTable[121184] = bhEne01_Init_0x175fb0; // 0x176588 - g_ps2RecompiledFunctionTable[121185] = bhEne01_Init_0x175fb0; // 0x17658c - g_ps2RecompiledFunctionTable[121186] = bhEne01_Init_0x175fb0; // 0x176590 - g_ps2RecompiledFunctionTable[121187] = bhEne01_Init_0x175fb0; // 0x176594 - g_ps2RecompiledFunctionTable[121188] = bhEne01_Init_0x175fb0; // 0x176598 - g_ps2RecompiledFunctionTable[121189] = bhEne01_Init_0x175fb0; // 0x17659c - g_ps2RecompiledFunctionTable[121190] = bhEne01_Init_0x175fb0; // 0x1765a0 - g_ps2RecompiledFunctionTable[121191] = bhEne01_Init_0x175fb0; // 0x1765a4 - g_ps2RecompiledFunctionTable[121192] = bhEne01_Init_0x175fb0; // 0x1765a8 - g_ps2RecompiledFunctionTable[121193] = bhEne01_Init_0x175fb0; // 0x1765ac - g_ps2RecompiledFunctionTable[121194] = bhEne01_Init_0x175fb0; // 0x1765b0 - g_ps2RecompiledFunctionTable[121195] = bhEne01_Init_0x175fb0; // 0x1765b4 - g_ps2RecompiledFunctionTable[121196] = bhEne01_Init_0x175fb0; // 0x1765b8 - g_ps2RecompiledFunctionTable[121197] = bhEne01_Init_0x175fb0; // 0x1765bc - g_ps2RecompiledFunctionTable[121198] = bhEne01_Init_0x175fb0; // 0x1765c0 - g_ps2RecompiledFunctionTable[121199] = bhEne01_Init_0x175fb0; // 0x1765c4 - g_ps2RecompiledFunctionTable[121200] = bhEne01_Init_0x175fb0; // 0x1765c8 - g_ps2RecompiledFunctionTable[121201] = bhEne01_Init_0x175fb0; // 0x1765cc - g_ps2RecompiledFunctionTable[121202] = bhEne01_Init_0x175fb0; // 0x1765d0 - g_ps2RecompiledFunctionTable[121203] = bhEne01_Init_0x175fb0; // 0x1765d4 - g_ps2RecompiledFunctionTable[121204] = bhEne01_Init_0x175fb0; // 0x1765d8 - g_ps2RecompiledFunctionTable[121205] = bhEne01_Init_0x175fb0; // 0x1765dc - g_ps2RecompiledFunctionTable[121206] = bhEne01_Init_0x175fb0; // 0x1765e0 - g_ps2RecompiledFunctionTable[121207] = bhEne01_Init_0x175fb0; // 0x1765e4 - g_ps2RecompiledFunctionTable[121208] = bhEne01_Init_0x175fb0; // 0x1765e8 - g_ps2RecompiledFunctionTable[121209] = bhEne01_Init_0x175fb0; // 0x1765ec - g_ps2RecompiledFunctionTable[121210] = bhEne01_Init_0x175fb0; // 0x1765f0 - g_ps2RecompiledFunctionTable[121211] = bhEne01_Init_0x175fb0; // 0x1765f4 - g_ps2RecompiledFunctionTable[121212] = bhEne01_Init_0x175fb0; // 0x1765f8 - g_ps2RecompiledFunctionTable[121213] = bhEne01_Init_0x175fb0; // 0x1765fc - g_ps2RecompiledFunctionTable[121214] = bhEne01_Init_0x175fb0; // 0x176600 - g_ps2RecompiledFunctionTable[121215] = bhEne01_Init_0x175fb0; // 0x176604 - g_ps2RecompiledFunctionTable[121216] = bhEne01_Init_0x175fb0; // 0x176608 - g_ps2RecompiledFunctionTable[121217] = bhEne01_Init_0x175fb0; // 0x17660c - g_ps2RecompiledFunctionTable[121218] = bhEne01_Init_0x175fb0; // 0x176610 - g_ps2RecompiledFunctionTable[121219] = bhEne01_Init_0x175fb0; // 0x176614 - g_ps2RecompiledFunctionTable[121220] = bhEne01_Init_0x175fb0; // 0x176618 - g_ps2RecompiledFunctionTable[121221] = bhEne01_Init_0x175fb0; // 0x17661c - g_ps2RecompiledFunctionTable[121222] = bhEne01_Init_0x175fb0; // 0x176620 - g_ps2RecompiledFunctionTable[121223] = bhEne01_Init_0x175fb0; // 0x176624 - g_ps2RecompiledFunctionTable[121224] = bhEne01_Init_0x175fb0; // 0x176628 - g_ps2RecompiledFunctionTable[121225] = bhEne01_Init_0x175fb0; // 0x17662c - g_ps2RecompiledFunctionTable[121226] = bhEne01_Init_0x175fb0; // 0x176630 - g_ps2RecompiledFunctionTable[121227] = bhEne01_Init_0x175fb0; // 0x176634 - g_ps2RecompiledFunctionTable[121228] = bhEne01_Init_0x175fb0; // 0x176638 - g_ps2RecompiledFunctionTable[121229] = bhEne01_Init_0x175fb0; // 0x17663c - g_ps2RecompiledFunctionTable[121230] = bhEne01_Init_0x175fb0; // 0x176640 - g_ps2RecompiledFunctionTable[121231] = bhEne01_Init_0x175fb0; // 0x176644 - g_ps2RecompiledFunctionTable[121232] = bhEne01_Init_0x175fb0; // 0x176648 - g_ps2RecompiledFunctionTable[121233] = bhEne01_Init_0x175fb0; // 0x17664c - g_ps2RecompiledFunctionTable[121234] = bhEne01_Init_0x175fb0; // 0x176650 - g_ps2RecompiledFunctionTable[121235] = bhEne01_Init_0x175fb0; // 0x176654 - g_ps2RecompiledFunctionTable[121236] = bhEne01_Init_0x175fb0; // 0x176658 - g_ps2RecompiledFunctionTable[121237] = bhEne01_Init_0x175fb0; // 0x17665c - g_ps2RecompiledFunctionTable[121238] = bhEne01_Init_0x175fb0; // 0x176660 - g_ps2RecompiledFunctionTable[121239] = bhEne01_Init_0x175fb0; // 0x176664 - g_ps2RecompiledFunctionTable[121240] = bhEne01_Init_0x175fb0; // 0x176668 - g_ps2RecompiledFunctionTable[121241] = bhEne01_Init_0x175fb0; // 0x17666c - g_ps2RecompiledFunctionTable[121242] = bhEne01_Init_0x175fb0; // 0x176670 - g_ps2RecompiledFunctionTable[121243] = bhEne01_Init_0x175fb0; // 0x176674 - g_ps2RecompiledFunctionTable[121244] = bhEne01_Init_0x175fb0; // 0x176678 - g_ps2RecompiledFunctionTable[121245] = bhEne01_Init_0x175fb0; // 0x17667c - g_ps2RecompiledFunctionTable[121246] = bhEne01_Init_0x175fb0; // 0x176680 - g_ps2RecompiledFunctionTable[121247] = bhEne01_Init_0x175fb0; // 0x176684 - g_ps2RecompiledFunctionTable[121248] = bhEne01_Init_0x175fb0; // 0x176688 - g_ps2RecompiledFunctionTable[121249] = bhEne01_Init_0x175fb0; // 0x17668c - g_ps2RecompiledFunctionTable[121250] = bhEne01_Init_0x175fb0; // 0x176690 - g_ps2RecompiledFunctionTable[121251] = bhEne01_Init_0x175fb0; // 0x176694 - g_ps2RecompiledFunctionTable[121252] = bhEne01_Init_0x175fb0; // 0x176698 - g_ps2RecompiledFunctionTable[121253] = bhEne01_Init_0x175fb0; // 0x17669c - g_ps2RecompiledFunctionTable[121254] = bhEne01_Init_0x175fb0; // 0x1766a0 - g_ps2RecompiledFunctionTable[121255] = bhEne01_Init_0x175fb0; // 0x1766a4 - g_ps2RecompiledFunctionTable[121256] = bhEne01_Init_0x175fb0; // 0x1766a8 - g_ps2RecompiledFunctionTable[121257] = bhEne01_Init_0x175fb0; // 0x1766ac - g_ps2RecompiledFunctionTable[121258] = bhEne01_Init_0x175fb0; // 0x1766b0 - g_ps2RecompiledFunctionTable[121259] = bhEne01_Init_0x175fb0; // 0x1766b4 - g_ps2RecompiledFunctionTable[121260] = bhEne01_Init_0x175fb0; // 0x1766b8 - g_ps2RecompiledFunctionTable[121261] = bhEne01_Init_0x175fb0; // 0x1766bc - g_ps2RecompiledFunctionTable[121262] = bhEne01_Init_0x175fb0; // 0x1766c0 - g_ps2RecompiledFunctionTable[121263] = bhEne01_Init_0x175fb0; // 0x1766c4 - g_ps2RecompiledFunctionTable[121264] = bhEne01_Init_0x175fb0; // 0x1766c8 - g_ps2RecompiledFunctionTable[121265] = bhEne01_Init_0x175fb0; // 0x1766cc - g_ps2RecompiledFunctionTable[121266] = bhEne01_Init_0x175fb0; // 0x1766d0 - g_ps2RecompiledFunctionTable[121267] = bhEne01_Init_0x175fb0; // 0x1766d4 - g_ps2RecompiledFunctionTable[121268] = bhEne01_Init_0x175fb0; // 0x1766d8 - g_ps2RecompiledFunctionTable[121269] = bhEne01_Init_0x175fb0; // 0x1766dc - g_ps2RecompiledFunctionTable[121270] = bhEne01_Init_0x175fb0; // 0x1766e0 - g_ps2RecompiledFunctionTable[121271] = bhEne01_Init_0x175fb0; // 0x1766e4 - g_ps2RecompiledFunctionTable[121272] = bhEne01_Init_0x175fb0; // 0x1766e8 - g_ps2RecompiledFunctionTable[121273] = bhEne01_Init_0x175fb0; // 0x1766ec - g_ps2RecompiledFunctionTable[121274] = bhEne01_Init_0x175fb0; // 0x1766f0 - g_ps2RecompiledFunctionTable[121275] = bhEne01_Init_0x175fb0; // 0x1766f4 - g_ps2RecompiledFunctionTable[121276] = bhEne01_Init_0x175fb0; // 0x1766f8 - g_ps2RecompiledFunctionTable[121277] = bhEne01_Init_0x175fb0; // 0x1766fc - g_ps2RecompiledFunctionTable[121278] = bhEne01_Init_0x175fb0; // 0x176700 - g_ps2RecompiledFunctionTable[121279] = bhEne01_Init_0x175fb0; // 0x176704 - g_ps2RecompiledFunctionTable[121280] = bhEne01_Init_0x175fb0; // 0x176708 - g_ps2RecompiledFunctionTable[121281] = bhEne01_Init_0x175fb0; // 0x17670c - g_ps2RecompiledFunctionTable[121282] = bhEne01_Init_0x175fb0; // 0x176710 - g_ps2RecompiledFunctionTable[121283] = bhEne01_Init_0x175fb0; // 0x176714 - g_ps2RecompiledFunctionTable[121284] = bhEne01_Init_0x175fb0; // 0x176718 - g_ps2RecompiledFunctionTable[121285] = bhEne01_Init_0x175fb0; // 0x17671c - g_ps2RecompiledFunctionTable[121286] = bhEne01_Init_0x175fb0; // 0x176720 - g_ps2RecompiledFunctionTable[121287] = bhEne01_Init_0x175fb0; // 0x176724 - g_ps2RecompiledFunctionTable[121288] = bhEne01_Init_0x175fb0; // 0x176728 - g_ps2RecompiledFunctionTable[121289] = bhEne01_Init_0x175fb0; // 0x17672c - g_ps2RecompiledFunctionTable[121290] = bhEne01_Init_0x175fb0; // 0x176730 - g_ps2RecompiledFunctionTable[121291] = bhEne01_Init_0x175fb0; // 0x176734 - g_ps2RecompiledFunctionTable[121292] = bhEne01_Init_0x175fb0; // 0x176738 - g_ps2RecompiledFunctionTable[121293] = bhEne01_Init_0x175fb0; // 0x17673c - g_ps2RecompiledFunctionTable[121294] = bhEne01_Init_0x175fb0; // 0x176740 - g_ps2RecompiledFunctionTable[121295] = bhEne01_Init_0x175fb0; // 0x176744 - g_ps2RecompiledFunctionTable[121296] = bhEne01_Init_0x175fb0; // 0x176748 - g_ps2RecompiledFunctionTable[121297] = bhEne01_Init_0x175fb0; // 0x17674c - g_ps2RecompiledFunctionTable[121298] = bhEne01_Init_0x175fb0; // 0x176750 - g_ps2RecompiledFunctionTable[121299] = bhEne01_Init_0x175fb0; // 0x176754 - g_ps2RecompiledFunctionTable[121300] = bhEne01_Init_0x175fb0; // 0x176758 - g_ps2RecompiledFunctionTable[121301] = bhEne01_Init_0x175fb0; // 0x17675c - g_ps2RecompiledFunctionTable[121302] = bhEne01_Init_0x175fb0; // 0x176760 - g_ps2RecompiledFunctionTable[121303] = bhEne01_Init_0x175fb0; // 0x176764 - g_ps2RecompiledFunctionTable[121304] = bhEne01_Init_0x175fb0; // 0x176768 - g_ps2RecompiledFunctionTable[121305] = bhEne01_Init_0x175fb0; // 0x17676c - g_ps2RecompiledFunctionTable[121306] = bhEne01_Init_0x175fb0; // 0x176770 - g_ps2RecompiledFunctionTable[121307] = bhEne01_Init_0x175fb0; // 0x176774 - g_ps2RecompiledFunctionTable[121308] = bhEne01_Init_0x175fb0; // 0x176778 - g_ps2RecompiledFunctionTable[121309] = bhEne01_Init_0x175fb0; // 0x17677c - g_ps2RecompiledFunctionTable[121310] = bhEne01_Init_0x175fb0; // 0x176780 - g_ps2RecompiledFunctionTable[121311] = bhEne01_Init_0x175fb0; // 0x176784 - g_ps2RecompiledFunctionTable[121312] = bhEne01_Init_0x175fb0; // 0x176788 - g_ps2RecompiledFunctionTable[121313] = bhEne01_Init_0x175fb0; // 0x17678c - g_ps2RecompiledFunctionTable[121314] = bhEne01_Init_0x175fb0; // 0x176790 - g_ps2RecompiledFunctionTable[121315] = bhEne01_Init_0x175fb0; // 0x176794 - g_ps2RecompiledFunctionTable[121316] = bhEne01_Init_0x175fb0; // 0x176798 - g_ps2RecompiledFunctionTable[121317] = bhEne01_Init_0x175fb0; // 0x17679c - g_ps2RecompiledFunctionTable[121318] = bhEne01_Init_0x175fb0; // 0x1767a0 - g_ps2RecompiledFunctionTable[121319] = bhEne01_Init_0x175fb0; // 0x1767a4 - g_ps2RecompiledFunctionTable[121320] = bhEne01_Init_0x175fb0; // 0x1767a8 - g_ps2RecompiledFunctionTable[121321] = bhEne01_Init_0x175fb0; // 0x1767ac - g_ps2RecompiledFunctionTable[121322] = bhEne01_Init_0x175fb0; // 0x1767b0 - g_ps2RecompiledFunctionTable[121323] = bhEne01_Init_0x175fb0; // 0x1767b4 - g_ps2RecompiledFunctionTable[121324] = bhEne01_Init_0x175fb0; // 0x1767b8 - g_ps2RecompiledFunctionTable[121325] = bhEne01_Init_0x175fb0; // 0x1767bc - g_ps2RecompiledFunctionTable[121326] = bhEne01_Init_0x175fb0; // 0x1767c0 - g_ps2RecompiledFunctionTable[121327] = bhEne01_Init_0x175fb0; // 0x1767c4 - g_ps2RecompiledFunctionTable[121328] = bhEne01_Init_0x175fb0; // 0x1767c8 - g_ps2RecompiledFunctionTable[121329] = bhEne01_Init_0x175fb0; // 0x1767cc - g_ps2RecompiledFunctionTable[121330] = bhEne01_Init_0x175fb0; // 0x1767d0 - g_ps2RecompiledFunctionTable[121331] = bhEne01_Init_0x175fb0; // 0x1767d4 - g_ps2RecompiledFunctionTable[121332] = bhEne01_Init_0x175fb0; // 0x1767d8 - g_ps2RecompiledFunctionTable[121333] = bhEne01_Init_0x175fb0; // 0x1767dc - g_ps2RecompiledFunctionTable[121334] = bhEne01_Init_0x175fb0; // 0x1767e0 - g_ps2RecompiledFunctionTable[121335] = bhEne01_Init_0x175fb0; // 0x1767e4 - g_ps2RecompiledFunctionTable[121336] = bhEne01_Init_0x175fb0; // 0x1767e8 - g_ps2RecompiledFunctionTable[121337] = bhEne01_Init_0x175fb0; // 0x1767ec - g_ps2RecompiledFunctionTable[121338] = bhEne01_Init_0x175fb0; // 0x1767f0 - g_ps2RecompiledFunctionTable[121339] = bhEne01_Init_0x175fb0; // 0x1767f4 - g_ps2RecompiledFunctionTable[121340] = bhEne01_Init_0x175fb0; // 0x1767f8 - g_ps2RecompiledFunctionTable[121341] = bhEne01_Init_0x175fb0; // 0x1767fc - g_ps2RecompiledFunctionTable[121342] = bhEne01_Init_0x175fb0; // 0x176800 - g_ps2RecompiledFunctionTable[121343] = bhEne01_Init_0x175fb0; // 0x176804 - g_ps2RecompiledFunctionTable[121344] = bhEne01_Init_0x175fb0; // 0x176808 - g_ps2RecompiledFunctionTable[121345] = bhEne01_Init_0x175fb0; // 0x17680c - g_ps2RecompiledFunctionTable[121346] = bhEne01_Init_0x175fb0; // 0x176810 - g_ps2RecompiledFunctionTable[121347] = bhEne01_Init_0x175fb0; // 0x176814 - g_ps2RecompiledFunctionTable[121348] = bhEne01_Init_0x175fb0; // 0x176818 - g_ps2RecompiledFunctionTable[121349] = bhEne01_Init_0x175fb0; // 0x17681c - g_ps2RecompiledFunctionTable[121350] = bhEne01_Init_0x175fb0; // 0x176820 - g_ps2RecompiledFunctionTable[121351] = bhEne01_Init_0x175fb0; // 0x176824 - g_ps2RecompiledFunctionTable[121352] = bhEne01_Init_0x175fb0; // 0x176828 - g_ps2RecompiledFunctionTable[121353] = bhEne01_Init_0x175fb0; // 0x17682c - g_ps2RecompiledFunctionTable[121354] = bhEne01_Init_0x175fb0; // 0x176830 - g_ps2RecompiledFunctionTable[121355] = bhEne01_Init_0x175fb0; // 0x176834 - g_ps2RecompiledFunctionTable[121356] = bhEne01_Init_0x175fb0; // 0x176838 - g_ps2RecompiledFunctionTable[121357] = bhEne01_Init_0x175fb0; // 0x17683c - g_ps2RecompiledFunctionTable[121358] = bhEne01_Init_0x175fb0; // 0x176840 - g_ps2RecompiledFunctionTable[121359] = bhEne01_Init_0x175fb0; // 0x176844 - g_ps2RecompiledFunctionTable[121360] = bhEne01_Init_0x175fb0; // 0x176848 - g_ps2RecompiledFunctionTable[121361] = bhEne01_Init_0x175fb0; // 0x17684c - g_ps2RecompiledFunctionTable[121362] = bhEne01_Init_0x175fb0; // 0x176850 - g_ps2RecompiledFunctionTable[121363] = bhEne01_Init_0x175fb0; // 0x176854 - g_ps2RecompiledFunctionTable[121364] = bhEne01_Init_0x175fb0; // 0x176858 - g_ps2RecompiledFunctionTable[121365] = bhEne01_Init_0x175fb0; // 0x17685c - g_ps2RecompiledFunctionTable[121366] = bhEne01_Init_0x175fb0; // 0x176860 - g_ps2RecompiledFunctionTable[121367] = bhEne01_Init_0x175fb0; // 0x176864 - g_ps2RecompiledFunctionTable[121368] = bhEne01_Init_0x175fb0; // 0x176868 - g_ps2RecompiledFunctionTable[121369] = bhEne01_Init_0x175fb0; // 0x17686c - g_ps2RecompiledFunctionTable[121370] = bhEne01_Init_0x175fb0; // 0x176870 - g_ps2RecompiledFunctionTable[121371] = bhEne01_Init_0x175fb0; // 0x176874 - g_ps2RecompiledFunctionTable[121372] = bhEne01_Init_0x175fb0; // 0x176878 - g_ps2RecompiledFunctionTable[121373] = bhEne01_Init_0x175fb0; // 0x17687c - g_ps2RecompiledFunctionTable[121374] = bhEne01_Init_0x175fb0; // 0x176880 - g_ps2RecompiledFunctionTable[121375] = bhEne01_Init_0x175fb0; // 0x176884 - g_ps2RecompiledFunctionTable[121376] = bhEne01_Init_0x175fb0; // 0x176888 - g_ps2RecompiledFunctionTable[121377] = bhEne01_Init_0x175fb0; // 0x17688c - g_ps2RecompiledFunctionTable[121378] = bhEne01_Init_0x175fb0; // 0x176890 - g_ps2RecompiledFunctionTable[121379] = bhEne01_Init_0x175fb0; // 0x176894 - g_ps2RecompiledFunctionTable[121380] = bhEne01_Init_0x175fb0; // 0x176898 - g_ps2RecompiledFunctionTable[121381] = bhEne01_Init_0x175fb0; // 0x17689c - g_ps2RecompiledFunctionTable[121382] = bhEne01_Init_0x175fb0; // 0x1768a0 - g_ps2RecompiledFunctionTable[121383] = bhEne01_Init_0x175fb0; // 0x1768a4 - g_ps2RecompiledFunctionTable[121384] = bhEne01_Init_0x175fb0; // 0x1768a8 - g_ps2RecompiledFunctionTable[121385] = bhEne01_Init_0x175fb0; // 0x1768ac - g_ps2RecompiledFunctionTable[121386] = bhEne01_Init_0x175fb0; // 0x1768b0 - g_ps2RecompiledFunctionTable[121387] = bhEne01_Init_0x175fb0; // 0x1768b4 - g_ps2RecompiledFunctionTable[121388] = bhEne01_Init_0x175fb0; // 0x1768b8 - g_ps2RecompiledFunctionTable[121389] = bhEne01_Init_0x175fb0; // 0x1768bc - g_ps2RecompiledFunctionTable[121390] = bhEne01_Init_0x175fb0; // 0x1768c0 - g_ps2RecompiledFunctionTable[121391] = bhEne01_Init_0x175fb0; // 0x1768c4 - g_ps2RecompiledFunctionTable[121392] = bhEne01_Init_0x175fb0; // 0x1768c8 - g_ps2RecompiledFunctionTable[121393] = bhEne01_Init_0x175fb0; // 0x1768cc - g_ps2RecompiledFunctionTable[121394] = bhEne01_Init_0x175fb0; // 0x1768d0 - g_ps2RecompiledFunctionTable[121395] = bhEne01_Init_0x175fb0; // 0x1768d4 - g_ps2RecompiledFunctionTable[121396] = bhEne01_Init_0x175fb0; // 0x1768d8 - g_ps2RecompiledFunctionTable[121397] = bhEne01_Init_0x175fb0; // 0x1768dc - g_ps2RecompiledFunctionTable[121398] = bhEne01_Init_0x175fb0; // 0x1768e0 - g_ps2RecompiledFunctionTable[121399] = bhEne01_Init_0x175fb0; // 0x1768e4 - g_ps2RecompiledFunctionTable[121400] = bhEne01_Init_0x175fb0; // 0x1768e8 - g_ps2RecompiledFunctionTable[121401] = bhEne01_Init_0x175fb0; // 0x1768ec - g_ps2RecompiledFunctionTable[121402] = bhEne01_Init_0x175fb0; // 0x1768f0 - g_ps2RecompiledFunctionTable[121403] = bhEne01_Init_0x175fb0; // 0x1768f4 - g_ps2RecompiledFunctionTable[121404] = bhEne01_Init_0x175fb0; // 0x1768f8 - g_ps2RecompiledFunctionTable[121405] = bhEne01_Init_0x175fb0; // 0x1768fc - g_ps2RecompiledFunctionTable[121406] = bhEne01_Init_0x175fb0; // 0x176900 - g_ps2RecompiledFunctionTable[121407] = bhEne01_Init_0x175fb0; // 0x176904 - g_ps2RecompiledFunctionTable[121408] = bhEne01_Init_0x175fb0; // 0x176908 - g_ps2RecompiledFunctionTable[121409] = bhEne01_Init_0x175fb0; // 0x17690c - g_ps2RecompiledFunctionTable[121410] = bhEne01_Init_0x175fb0; // 0x176910 - g_ps2RecompiledFunctionTable[121411] = bhEne01_Init_0x175fb0; // 0x176914 - g_ps2RecompiledFunctionTable[121412] = bhEne01_Init_0x175fb0; // 0x176918 - g_ps2RecompiledFunctionTable[121413] = bhEne01_Init_0x175fb0; // 0x17691c - g_ps2RecompiledFunctionTable[121414] = bhEne01_Init_0x175fb0; // 0x176920 - g_ps2RecompiledFunctionTable[121415] = bhEne01_Init_0x175fb0; // 0x176924 - g_ps2RecompiledFunctionTable[121416] = bhEne01_Init_0x175fb0; // 0x176928 - g_ps2RecompiledFunctionTable[121417] = bhEne01_Init_0x175fb0; // 0x17692c - g_ps2RecompiledFunctionTable[121418] = bhEne01_Init_0x175fb0; // 0x176930 - g_ps2RecompiledFunctionTable[121419] = bhEne01_Init_0x175fb0; // 0x176934 - g_ps2RecompiledFunctionTable[121420] = bhEne01_Init_0x175fb0; // 0x176938 - g_ps2RecompiledFunctionTable[121421] = bhEne01_Init_0x175fb0; // 0x17693c - g_ps2RecompiledFunctionTable[121422] = bhEne01_Init_0x175fb0; // 0x176940 - g_ps2RecompiledFunctionTable[121423] = bhEne01_Init_0x175fb0; // 0x176944 - g_ps2RecompiledFunctionTable[121424] = bhEne01_Init_0x175fb0; // 0x176948 - g_ps2RecompiledFunctionTable[121425] = bhEne01_Init_0x175fb0; // 0x17694c - g_ps2RecompiledFunctionTable[121426] = bhEne01_Init_0x175fb0; // 0x176950 - g_ps2RecompiledFunctionTable[121427] = bhEne01_Init_0x175fb0; // 0x176954 - g_ps2RecompiledFunctionTable[121428] = bhEne01_Init_0x175fb0; // 0x176958 - g_ps2RecompiledFunctionTable[121429] = bhEne01_Init_0x175fb0; // 0x17695c - g_ps2RecompiledFunctionTable[121430] = bhEne01_Init_0x175fb0; // 0x176960 - g_ps2RecompiledFunctionTable[121431] = bhEne01_Init_0x175fb0; // 0x176964 - g_ps2RecompiledFunctionTable[121432] = bhEne01_Init_0x175fb0; // 0x176968 - g_ps2RecompiledFunctionTable[121433] = bhEne01_Init_0x175fb0; // 0x17696c - g_ps2RecompiledFunctionTable[121434] = bhEne01_Init_0x175fb0; // 0x176970 - g_ps2RecompiledFunctionTable[121435] = bhEne01_Init_0x175fb0; // 0x176974 - g_ps2RecompiledFunctionTable[121436] = bhEne01_Init_0x175fb0; // 0x176978 - g_ps2RecompiledFunctionTable[121437] = bhEne01_Init_0x175fb0; // 0x17697c - g_ps2RecompiledFunctionTable[121438] = bhEne01_Init_0x175fb0; // 0x176980 - g_ps2RecompiledFunctionTable[121439] = bhEne01_Init_0x175fb0; // 0x176984 - g_ps2RecompiledFunctionTable[121440] = bhEne01_Init_0x175fb0; // 0x176988 - g_ps2RecompiledFunctionTable[121441] = bhEne01_Init_0x175fb0; // 0x17698c - g_ps2RecompiledFunctionTable[121442] = bhEne01_Init_0x175fb0; // 0x176990 - g_ps2RecompiledFunctionTable[121443] = bhEne01_Init_0x175fb0; // 0x176994 - g_ps2RecompiledFunctionTable[121444] = bhEne01_Init_0x175fb0; // 0x176998 - g_ps2RecompiledFunctionTable[121445] = bhEne01_Init_0x175fb0; // 0x17699c - g_ps2RecompiledFunctionTable[121446] = bhEne01_Init_0x175fb0; // 0x1769a0 - g_ps2RecompiledFunctionTable[121447] = bhEne01_Init_0x175fb0; // 0x1769a4 - g_ps2RecompiledFunctionTable[121448] = bhEne01_Init_0x175fb0; // 0x1769a8 - g_ps2RecompiledFunctionTable[121449] = bhEne01_Init_0x175fb0; // 0x1769ac - g_ps2RecompiledFunctionTable[121450] = bhEne01_Init_0x175fb0; // 0x1769b0 - g_ps2RecompiledFunctionTable[121451] = bhEne01_Init_0x175fb0; // 0x1769b4 - g_ps2RecompiledFunctionTable[121452] = bhEne01_Init_0x175fb0; // 0x1769b8 - g_ps2RecompiledFunctionTable[121453] = bhEne01_Init_0x175fb0; // 0x1769bc - g_ps2RecompiledFunctionTable[121454] = bhEne01_Init_0x175fb0; // 0x1769c0 - g_ps2RecompiledFunctionTable[121455] = bhEne01_Init_0x175fb0; // 0x1769c4 - g_ps2RecompiledFunctionTable[121456] = bhEne01_Init_0x175fb0; // 0x1769c8 - g_ps2RecompiledFunctionTable[121457] = bhEne01_Init_0x175fb0; // 0x1769cc - g_ps2RecompiledFunctionTable[121458] = bhEne01_Init_0x175fb0; // 0x1769d0 - g_ps2RecompiledFunctionTable[121459] = bhEne01_Init_0x175fb0; // 0x1769d4 - g_ps2RecompiledFunctionTable[121460] = bhEne01_Init_0x175fb0; // 0x1769d8 - g_ps2RecompiledFunctionTable[121461] = bhEne01_Init_0x175fb0; // 0x1769dc - g_ps2RecompiledFunctionTable[121462] = bhEne01_Init_0x175fb0; // 0x1769e0 - g_ps2RecompiledFunctionTable[121463] = bhEne01_Init_0x175fb0; // 0x1769e4 - g_ps2RecompiledFunctionTable[121464] = bhEne01_Init_0x175fb0; // 0x1769e8 - g_ps2RecompiledFunctionTable[121465] = bhEne01_Init_0x175fb0; // 0x1769ec - g_ps2RecompiledFunctionTable[121466] = bhEne01_Init_0x175fb0; // 0x1769f0 - g_ps2RecompiledFunctionTable[121467] = bhEne01_Init_0x175fb0; // 0x1769f4 - g_ps2RecompiledFunctionTable[121468] = bhEne01_Init_0x175fb0; // 0x1769f8 - g_ps2RecompiledFunctionTable[121469] = bhEne01_Init_0x175fb0; // 0x1769fc - g_ps2RecompiledFunctionTable[121470] = bhEne01_Init_0x175fb0; // 0x176a00 - g_ps2RecompiledFunctionTable[121471] = bhEne01_Init_0x175fb0; // 0x176a04 - g_ps2RecompiledFunctionTable[121472] = bhEne01_Init_0x175fb0; // 0x176a08 - g_ps2RecompiledFunctionTable[121473] = bhEne01_Init_0x175fb0; // 0x176a0c - g_ps2RecompiledFunctionTable[121474] = bhEne01_Init_0x175fb0; // 0x176a10 - g_ps2RecompiledFunctionTable[121475] = bhEne01_Init_0x175fb0; // 0x176a14 - g_ps2RecompiledFunctionTable[121476] = bhEne01_Init_0x175fb0; // 0x176a18 - g_ps2RecompiledFunctionTable[121477] = bhEne01_Init_0x175fb0; // 0x176a1c - g_ps2RecompiledFunctionTable[121478] = bhEne01_Init_0x175fb0; // 0x176a20 - g_ps2RecompiledFunctionTable[121479] = bhEne01_Init_0x175fb0; // 0x176a24 - g_ps2RecompiledFunctionTable[121480] = bhEne01_Init_0x175fb0; // 0x176a28 - g_ps2RecompiledFunctionTable[121481] = bhEne01_Init_0x175fb0; // 0x176a2c - g_ps2RecompiledFunctionTable[121482] = bhEne01_Init_0x175fb0; // 0x176a30 - g_ps2RecompiledFunctionTable[121486] = bhEne01_SetLinkEnemy_0x176a40; // 0x176a40 - g_ps2RecompiledFunctionTable[121500] = bhEne01_SetLinkEnemy_0x176a40; // 0x176a78 - g_ps2RecompiledFunctionTable[121522] = bhEne01_Move_0x176ad0; // 0x176ad0 - g_ps2RecompiledFunctionTable[121523] = bhEne01_Move_0x176ad0; // 0x176ad4 - g_ps2RecompiledFunctionTable[121524] = bhEne01_Move_0x176ad0; // 0x176ad8 - g_ps2RecompiledFunctionTable[121525] = bhEne01_Move_0x176ad0; // 0x176adc - g_ps2RecompiledFunctionTable[121526] = bhEne01_Move_0x176ad0; // 0x176ae0 - g_ps2RecompiledFunctionTable[121527] = bhEne01_Move_0x176ad0; // 0x176ae4 - g_ps2RecompiledFunctionTable[121528] = bhEne01_Move_0x176ad0; // 0x176ae8 - g_ps2RecompiledFunctionTable[121529] = bhEne01_Move_0x176ad0; // 0x176aec - g_ps2RecompiledFunctionTable[121530] = bhEne01_Move_0x176ad0; // 0x176af0 - g_ps2RecompiledFunctionTable[121531] = bhEne01_Move_0x176ad0; // 0x176af4 - g_ps2RecompiledFunctionTable[121532] = bhEne01_Move_0x176ad0; // 0x176af8 - g_ps2RecompiledFunctionTable[121533] = bhEne01_Move_0x176ad0; // 0x176afc - g_ps2RecompiledFunctionTable[121534] = bhEne01_Move_0x176ad0; // 0x176b00 - g_ps2RecompiledFunctionTable[121535] = bhEne01_Move_0x176ad0; // 0x176b04 - g_ps2RecompiledFunctionTable[121536] = bhEne01_Move_0x176ad0; // 0x176b08 - g_ps2RecompiledFunctionTable[121537] = bhEne01_Move_0x176ad0; // 0x176b0c - g_ps2RecompiledFunctionTable[121538] = bhEne01_Move_0x176ad0; // 0x176b10 - g_ps2RecompiledFunctionTable[121539] = bhEne01_Move_0x176ad0; // 0x176b14 - g_ps2RecompiledFunctionTable[121540] = bhEne01_Move_0x176ad0; // 0x176b18 - g_ps2RecompiledFunctionTable[121541] = bhEne01_Move_0x176ad0; // 0x176b1c - g_ps2RecompiledFunctionTable[121542] = bhEne01_Move_0x176ad0; // 0x176b20 - g_ps2RecompiledFunctionTable[121543] = bhEne01_Move_0x176ad0; // 0x176b24 - g_ps2RecompiledFunctionTable[121544] = bhEne01_Move_0x176ad0; // 0x176b28 - g_ps2RecompiledFunctionTable[121545] = bhEne01_Move_0x176ad0; // 0x176b2c - g_ps2RecompiledFunctionTable[121546] = bhEne01_Move_0x176ad0; // 0x176b30 - g_ps2RecompiledFunctionTable[121547] = bhEne01_Move_0x176ad0; // 0x176b34 - g_ps2RecompiledFunctionTable[121548] = bhEne01_Move_0x176ad0; // 0x176b38 - g_ps2RecompiledFunctionTable[121549] = bhEne01_Move_0x176ad0; // 0x176b3c - g_ps2RecompiledFunctionTable[121550] = bhEne01_Move_0x176ad0; // 0x176b40 - g_ps2RecompiledFunctionTable[121551] = bhEne01_Move_0x176ad0; // 0x176b44 - g_ps2RecompiledFunctionTable[121552] = bhEne01_Move_0x176ad0; // 0x176b48 - g_ps2RecompiledFunctionTable[121553] = bhEne01_Move_0x176ad0; // 0x176b4c - g_ps2RecompiledFunctionTable[121554] = bhEne01_Move_0x176ad0; // 0x176b50 - g_ps2RecompiledFunctionTable[121555] = bhEne01_Move_0x176ad0; // 0x176b54 - g_ps2RecompiledFunctionTable[121556] = bhEne01_Move_0x176ad0; // 0x176b58 - g_ps2RecompiledFunctionTable[121557] = bhEne01_Move_0x176ad0; // 0x176b5c - g_ps2RecompiledFunctionTable[121558] = bhEne01_Move_0x176ad0; // 0x176b60 - g_ps2RecompiledFunctionTable[121559] = bhEne01_Move_0x176ad0; // 0x176b64 - g_ps2RecompiledFunctionTable[121560] = bhEne01_Move_0x176ad0; // 0x176b68 - g_ps2RecompiledFunctionTable[121561] = bhEne01_Move_0x176ad0; // 0x176b6c - g_ps2RecompiledFunctionTable[121562] = bhEne01_Move_0x176ad0; // 0x176b70 - g_ps2RecompiledFunctionTable[121563] = bhEne01_Move_0x176ad0; // 0x176b74 - g_ps2RecompiledFunctionTable[121564] = bhEne01_Move_0x176ad0; // 0x176b78 - g_ps2RecompiledFunctionTable[121565] = bhEne01_Move_0x176ad0; // 0x176b7c - g_ps2RecompiledFunctionTable[121566] = bhEne01_Move_0x176ad0; // 0x176b80 - g_ps2RecompiledFunctionTable[121567] = bhEne01_Move_0x176ad0; // 0x176b84 - g_ps2RecompiledFunctionTable[121568] = bhEne01_Move_0x176ad0; // 0x176b88 - g_ps2RecompiledFunctionTable[121569] = bhEne01_Move_0x176ad0; // 0x176b8c - g_ps2RecompiledFunctionTable[121570] = bhEne01_Move_0x176ad0; // 0x176b90 - g_ps2RecompiledFunctionTable[121571] = bhEne01_Move_0x176ad0; // 0x176b94 - g_ps2RecompiledFunctionTable[121572] = bhEne01_Move_0x176ad0; // 0x176b98 - g_ps2RecompiledFunctionTable[121573] = bhEne01_Move_0x176ad0; // 0x176b9c - g_ps2RecompiledFunctionTable[121574] = bhEne01_Move_0x176ad0; // 0x176ba0 - g_ps2RecompiledFunctionTable[121575] = bhEne01_Move_0x176ad0; // 0x176ba4 - g_ps2RecompiledFunctionTable[121576] = bhEne01_Move_0x176ad0; // 0x176ba8 - g_ps2RecompiledFunctionTable[121577] = bhEne01_Move_0x176ad0; // 0x176bac - g_ps2RecompiledFunctionTable[121578] = bhEne01_Move_0x176ad0; // 0x176bb0 - g_ps2RecompiledFunctionTable[121579] = bhEne01_Move_0x176ad0; // 0x176bb4 - g_ps2RecompiledFunctionTable[121580] = bhEne01_Move_0x176ad0; // 0x176bb8 - g_ps2RecompiledFunctionTable[121581] = bhEne01_Move_0x176ad0; // 0x176bbc - g_ps2RecompiledFunctionTable[121582] = bhEne01_Move_0x176ad0; // 0x176bc0 - g_ps2RecompiledFunctionTable[121583] = bhEne01_Move_0x176ad0; // 0x176bc4 - g_ps2RecompiledFunctionTable[121584] = bhEne01_Move_0x176ad0; // 0x176bc8 - g_ps2RecompiledFunctionTable[121585] = bhEne01_Move_0x176ad0; // 0x176bcc - g_ps2RecompiledFunctionTable[121586] = bhEne01_Move_0x176ad0; // 0x176bd0 - g_ps2RecompiledFunctionTable[121587] = bhEne01_Move_0x176ad0; // 0x176bd4 - g_ps2RecompiledFunctionTable[121588] = bhEne01_Move_0x176ad0; // 0x176bd8 - g_ps2RecompiledFunctionTable[121589] = bhEne01_Move_0x176ad0; // 0x176bdc - g_ps2RecompiledFunctionTable[121590] = bhEne01_Move_0x176ad0; // 0x176be0 - g_ps2RecompiledFunctionTable[121591] = bhEne01_Move_0x176ad0; // 0x176be4 - g_ps2RecompiledFunctionTable[121592] = bhEne01_Move_0x176ad0; // 0x176be8 - g_ps2RecompiledFunctionTable[121594] = bhEne01_Nage_0x176bf0; // 0x176bf0 - g_ps2RecompiledFunctionTable[121595] = bhEne01_Nage_0x176bf0; // 0x176bf4 - g_ps2RecompiledFunctionTable[121596] = bhEne01_Nage_0x176bf0; // 0x176bf8 - g_ps2RecompiledFunctionTable[121597] = bhEne01_Nage_0x176bf0; // 0x176bfc - g_ps2RecompiledFunctionTable[121598] = bhEne01_Nage_0x176bf0; // 0x176c00 - g_ps2RecompiledFunctionTable[121599] = bhEne01_Nage_0x176bf0; // 0x176c04 - g_ps2RecompiledFunctionTable[121600] = bhEne01_Nage_0x176bf0; // 0x176c08 - g_ps2RecompiledFunctionTable[121601] = bhEne01_Nage_0x176bf0; // 0x176c0c - g_ps2RecompiledFunctionTable[121602] = bhEne01_Nage_0x176bf0; // 0x176c10 - g_ps2RecompiledFunctionTable[121603] = bhEne01_Nage_0x176bf0; // 0x176c14 - g_ps2RecompiledFunctionTable[121604] = bhEne01_Nage_0x176bf0; // 0x176c18 - g_ps2RecompiledFunctionTable[121605] = bhEne01_Nage_0x176bf0; // 0x176c1c - g_ps2RecompiledFunctionTable[121606] = bhEne01_Nage_0x176bf0; // 0x176c20 - g_ps2RecompiledFunctionTable[121607] = bhEne01_Nage_0x176bf0; // 0x176c24 - g_ps2RecompiledFunctionTable[121608] = bhEne01_Nage_0x176bf0; // 0x176c28 - g_ps2RecompiledFunctionTable[121609] = bhEne01_Nage_0x176bf0; // 0x176c2c - g_ps2RecompiledFunctionTable[121610] = bhEne01_Nage_0x176bf0; // 0x176c30 - g_ps2RecompiledFunctionTable[121611] = bhEne01_Nage_0x176bf0; // 0x176c34 - g_ps2RecompiledFunctionTable[121612] = bhEne01_Nage_0x176bf0; // 0x176c38 - g_ps2RecompiledFunctionTable[121613] = bhEne01_Nage_0x176bf0; // 0x176c3c - g_ps2RecompiledFunctionTable[121614] = bhEne01_Nage_0x176bf0; // 0x176c40 - g_ps2RecompiledFunctionTable[121615] = bhEne01_Nage_0x176bf0; // 0x176c44 - g_ps2RecompiledFunctionTable[121616] = bhEne01_Nage_0x176bf0; // 0x176c48 - g_ps2RecompiledFunctionTable[121617] = bhEne01_Nage_0x176bf0; // 0x176c4c - g_ps2RecompiledFunctionTable[121618] = bhEne01_Nage_0x176bf0; // 0x176c50 - g_ps2RecompiledFunctionTable[121619] = bhEne01_Nage_0x176bf0; // 0x176c54 - g_ps2RecompiledFunctionTable[121620] = bhEne01_Nage_0x176bf0; // 0x176c58 - g_ps2RecompiledFunctionTable[121621] = bhEne01_Nage_0x176bf0; // 0x176c5c - g_ps2RecompiledFunctionTable[121622] = bhEne01_Nage_0x176bf0; // 0x176c60 - g_ps2RecompiledFunctionTable[121623] = bhEne01_Nage_0x176bf0; // 0x176c64 - g_ps2RecompiledFunctionTable[121624] = bhEne01_Nage_0x176bf0; // 0x176c68 - g_ps2RecompiledFunctionTable[121625] = bhEne01_Nage_0x176bf0; // 0x176c6c - g_ps2RecompiledFunctionTable[121626] = bhEne01_Nage_0x176bf0; // 0x176c70 - g_ps2RecompiledFunctionTable[121627] = bhEne01_Nage_0x176bf0; // 0x176c74 - g_ps2RecompiledFunctionTable[121628] = bhEne01_Nage_0x176bf0; // 0x176c78 - g_ps2RecompiledFunctionTable[121629] = bhEne01_Nage_0x176bf0; // 0x176c7c - g_ps2RecompiledFunctionTable[121630] = bhEne01_Nage_0x176bf0; // 0x176c80 - g_ps2RecompiledFunctionTable[121631] = bhEne01_Nage_0x176bf0; // 0x176c84 - g_ps2RecompiledFunctionTable[121632] = bhEne01_Nage_0x176bf0; // 0x176c88 - g_ps2RecompiledFunctionTable[121633] = bhEne01_Nage_0x176bf0; // 0x176c8c - g_ps2RecompiledFunctionTable[121634] = bhEne01_Nage_0x176bf0; // 0x176c90 - g_ps2RecompiledFunctionTable[121635] = bhEne01_Nage_0x176bf0; // 0x176c94 - g_ps2RecompiledFunctionTable[121636] = bhEne01_Nage_0x176bf0; // 0x176c98 - g_ps2RecompiledFunctionTable[121637] = bhEne01_Nage_0x176bf0; // 0x176c9c - g_ps2RecompiledFunctionTable[121638] = bhEne01_Damage_0x176ca0; // 0x176ca0 - g_ps2RecompiledFunctionTable[121639] = bhEne01_Damage_0x176ca0; // 0x176ca4 - g_ps2RecompiledFunctionTable[121640] = bhEne01_Damage_0x176ca0; // 0x176ca8 - g_ps2RecompiledFunctionTable[121641] = bhEne01_Damage_0x176ca0; // 0x176cac - g_ps2RecompiledFunctionTable[121642] = bhEne01_Damage_0x176ca0; // 0x176cb0 - g_ps2RecompiledFunctionTable[121643] = bhEne01_Damage_0x176ca0; // 0x176cb4 - g_ps2RecompiledFunctionTable[121644] = bhEne01_Damage_0x176ca0; // 0x176cb8 - g_ps2RecompiledFunctionTable[121645] = bhEne01_Damage_0x176ca0; // 0x176cbc - g_ps2RecompiledFunctionTable[121646] = bhEne01_Damage_0x176ca0; // 0x176cc0 - g_ps2RecompiledFunctionTable[121647] = bhEne01_Damage_0x176ca0; // 0x176cc4 - g_ps2RecompiledFunctionTable[121648] = bhEne01_Damage_0x176ca0; // 0x176cc8 - g_ps2RecompiledFunctionTable[121649] = bhEne01_Damage_0x176ca0; // 0x176ccc - g_ps2RecompiledFunctionTable[121650] = bhEne01_Damage_0x176ca0; // 0x176cd0 - g_ps2RecompiledFunctionTable[121651] = bhEne01_Damage_0x176ca0; // 0x176cd4 - g_ps2RecompiledFunctionTable[121652] = bhEne01_Damage_0x176ca0; // 0x176cd8 - g_ps2RecompiledFunctionTable[121653] = bhEne01_Damage_0x176ca0; // 0x176cdc - g_ps2RecompiledFunctionTable[121654] = bhEne01_Damage_0x176ca0; // 0x176ce0 - g_ps2RecompiledFunctionTable[121655] = bhEne01_Damage_0x176ca0; // 0x176ce4 - g_ps2RecompiledFunctionTable[121656] = bhEne01_Damage_0x176ca0; // 0x176ce8 - g_ps2RecompiledFunctionTable[121657] = bhEne01_Damage_0x176ca0; // 0x176cec - g_ps2RecompiledFunctionTable[121658] = bhEne01_Damage_0x176ca0; // 0x176cf0 - g_ps2RecompiledFunctionTable[121659] = bhEne01_Damage_0x176ca0; // 0x176cf4 - g_ps2RecompiledFunctionTable[121660] = bhEne01_Damage_0x176ca0; // 0x176cf8 - g_ps2RecompiledFunctionTable[121661] = bhEne01_Damage_0x176ca0; // 0x176cfc - g_ps2RecompiledFunctionTable[121662] = bhEne01_Damage_0x176ca0; // 0x176d00 - g_ps2RecompiledFunctionTable[121663] = bhEne01_Damage_0x176ca0; // 0x176d04 - g_ps2RecompiledFunctionTable[121664] = bhEne01_Damage_0x176ca0; // 0x176d08 - g_ps2RecompiledFunctionTable[121665] = bhEne01_Damage_0x176ca0; // 0x176d0c - g_ps2RecompiledFunctionTable[121666] = bhEne01_Damage_0x176ca0; // 0x176d10 - g_ps2RecompiledFunctionTable[121667] = bhEne01_Damage_0x176ca0; // 0x176d14 - g_ps2RecompiledFunctionTable[121668] = bhEne01_Damage_0x176ca0; // 0x176d18 - g_ps2RecompiledFunctionTable[121669] = bhEne01_Damage_0x176ca0; // 0x176d1c - g_ps2RecompiledFunctionTable[121670] = bhEne01_Damage_0x176ca0; // 0x176d20 - g_ps2RecompiledFunctionTable[121671] = bhEne01_Damage_0x176ca0; // 0x176d24 - g_ps2RecompiledFunctionTable[121672] = bhEne01_Damage_0x176ca0; // 0x176d28 - g_ps2RecompiledFunctionTable[121673] = bhEne01_Damage_0x176ca0; // 0x176d2c - g_ps2RecompiledFunctionTable[121674] = bhEne01_Damage_0x176ca0; // 0x176d30 - g_ps2RecompiledFunctionTable[121675] = bhEne01_Damage_0x176ca0; // 0x176d34 - g_ps2RecompiledFunctionTable[121676] = bhEne01_Damage_0x176ca0; // 0x176d38 - g_ps2RecompiledFunctionTable[121677] = bhEne01_Damage_0x176ca0; // 0x176d3c - g_ps2RecompiledFunctionTable[121678] = bhEne01_Damage_0x176ca0; // 0x176d40 - g_ps2RecompiledFunctionTable[121679] = bhEne01_Damage_0x176ca0; // 0x176d44 - g_ps2RecompiledFunctionTable[121680] = bhEne01_Damage_0x176ca0; // 0x176d48 - g_ps2RecompiledFunctionTable[121681] = bhEne01_Damage_0x176ca0; // 0x176d4c - g_ps2RecompiledFunctionTable[121682] = bhEne01_Die_0x176d50; // 0x176d50 - g_ps2RecompiledFunctionTable[121683] = bhEne01_Die_0x176d50; // 0x176d54 - g_ps2RecompiledFunctionTable[121684] = bhEne01_Die_0x176d50; // 0x176d58 - g_ps2RecompiledFunctionTable[121685] = bhEne01_Die_0x176d50; // 0x176d5c - g_ps2RecompiledFunctionTable[121686] = bhEne01_Die_0x176d50; // 0x176d60 - g_ps2RecompiledFunctionTable[121687] = bhEne01_Die_0x176d50; // 0x176d64 - g_ps2RecompiledFunctionTable[121688] = bhEne01_Die_0x176d50; // 0x176d68 - g_ps2RecompiledFunctionTable[121689] = bhEne01_Die_0x176d50; // 0x176d6c - g_ps2RecompiledFunctionTable[121690] = bhEne01_Die_0x176d50; // 0x176d70 - g_ps2RecompiledFunctionTable[121691] = bhEne01_Die_0x176d50; // 0x176d74 - g_ps2RecompiledFunctionTable[121692] = bhEne01_Die_0x176d50; // 0x176d78 - g_ps2RecompiledFunctionTable[121693] = bhEne01_Die_0x176d50; // 0x176d7c - g_ps2RecompiledFunctionTable[121694] = bhEne01_Die_0x176d50; // 0x176d80 - g_ps2RecompiledFunctionTable[121695] = bhEne01_Die_0x176d50; // 0x176d84 - g_ps2RecompiledFunctionTable[121696] = bhEne01_Die_0x176d50; // 0x176d88 - g_ps2RecompiledFunctionTable[121697] = bhEne01_Die_0x176d50; // 0x176d8c - g_ps2RecompiledFunctionTable[121698] = bhEne01_Die_0x176d50; // 0x176d90 - g_ps2RecompiledFunctionTable[121699] = bhEne01_Die_0x176d50; // 0x176d94 - g_ps2RecompiledFunctionTable[121700] = bhEne01_Die_0x176d50; // 0x176d98 - g_ps2RecompiledFunctionTable[121701] = bhEne01_Die_0x176d50; // 0x176d9c - g_ps2RecompiledFunctionTable[121702] = bhEne01_Die_0x176d50; // 0x176da0 - g_ps2RecompiledFunctionTable[121703] = bhEne01_Die_0x176d50; // 0x176da4 - g_ps2RecompiledFunctionTable[121704] = bhEne01_Die_0x176d50; // 0x176da8 - g_ps2RecompiledFunctionTable[121705] = bhEne01_Die_0x176d50; // 0x176dac - g_ps2RecompiledFunctionTable[121706] = bhEne01_Die_0x176d50; // 0x176db0 - g_ps2RecompiledFunctionTable[121707] = bhEne01_Die_0x176d50; // 0x176db4 - g_ps2RecompiledFunctionTable[121708] = bhEne01_Die_0x176d50; // 0x176db8 - g_ps2RecompiledFunctionTable[121709] = bhEne01_Die_0x176d50; // 0x176dbc - g_ps2RecompiledFunctionTable[121710] = bhEne01_Die_0x176d50; // 0x176dc0 - g_ps2RecompiledFunctionTable[121711] = bhEne01_Die_0x176d50; // 0x176dc4 - g_ps2RecompiledFunctionTable[121712] = bhEne01_Die_0x176d50; // 0x176dc8 - g_ps2RecompiledFunctionTable[121713] = bhEne01_Die_0x176d50; // 0x176dcc - g_ps2RecompiledFunctionTable[121714] = bhEne01_Die_0x176d50; // 0x176dd0 - g_ps2RecompiledFunctionTable[121715] = bhEne01_Die_0x176d50; // 0x176dd4 - g_ps2RecompiledFunctionTable[121716] = bhEne01_Die_0x176d50; // 0x176dd8 - g_ps2RecompiledFunctionTable[121717] = bhEne01_Die_0x176d50; // 0x176ddc - g_ps2RecompiledFunctionTable[121718] = bhEne01_Die_0x176d50; // 0x176de0 - g_ps2RecompiledFunctionTable[121719] = bhEne01_Die_0x176d50; // 0x176de4 - g_ps2RecompiledFunctionTable[121720] = bhEne01_Die_0x176d50; // 0x176de8 - g_ps2RecompiledFunctionTable[121721] = bhEne01_Die_0x176d50; // 0x176dec - g_ps2RecompiledFunctionTable[121722] = bhEne01_Die_0x176d50; // 0x176df0 - g_ps2RecompiledFunctionTable[121723] = bhEne01_Die_0x176d50; // 0x176df4 - g_ps2RecompiledFunctionTable[121724] = bhEne01_Die_0x176d50; // 0x176df8 - g_ps2RecompiledFunctionTable[121725] = bhEne01_Die_0x176d50; // 0x176dfc - g_ps2RecompiledFunctionTable[121726] = bhEne01_Die_0x176d50; // 0x176e00 - g_ps2RecompiledFunctionTable[121727] = bhEne01_Die_0x176d50; // 0x176e04 - g_ps2RecompiledFunctionTable[121728] = bhEne01_Die_0x176d50; // 0x176e08 - g_ps2RecompiledFunctionTable[121729] = bhEne01_Die_0x176d50; // 0x176e0c - g_ps2RecompiledFunctionTable[121730] = bhEne01_Die_0x176d50; // 0x176e10 - g_ps2RecompiledFunctionTable[121731] = bhEne01_Die_0x176d50; // 0x176e14 - g_ps2RecompiledFunctionTable[121732] = bhEne01_Die_0x176d50; // 0x176e18 - g_ps2RecompiledFunctionTable[121733] = bhEne01_Die_0x176d50; // 0x176e1c - g_ps2RecompiledFunctionTable[121734] = bhEne01_Die_0x176d50; // 0x176e20 - g_ps2RecompiledFunctionTable[121735] = bhEne01_Die_0x176d50; // 0x176e24 - g_ps2RecompiledFunctionTable[121736] = bhEne01_Die_0x176d50; // 0x176e28 - g_ps2RecompiledFunctionTable[121737] = bhEne01_Die_0x176d50; // 0x176e2c - g_ps2RecompiledFunctionTable[121738] = bhEne01_Die_0x176d50; // 0x176e30 - g_ps2RecompiledFunctionTable[121739] = bhEne01_Die_0x176d50; // 0x176e34 - g_ps2RecompiledFunctionTable[121740] = bhEne01_Die_0x176d50; // 0x176e38 - g_ps2RecompiledFunctionTable[121741] = bhEne01_Die_0x176d50; // 0x176e3c - g_ps2RecompiledFunctionTable[121742] = bhEne01_Die_0x176d50; // 0x176e40 - g_ps2RecompiledFunctionTable[121743] = bhEne01_Die_0x176d50; // 0x176e44 - g_ps2RecompiledFunctionTable[121744] = bhEne01_Die_0x176d50; // 0x176e48 - g_ps2RecompiledFunctionTable[121745] = bhEne01_Die_0x176d50; // 0x176e4c - g_ps2RecompiledFunctionTable[121746] = bhEne01_Die_0x176d50; // 0x176e50 - g_ps2RecompiledFunctionTable[121747] = bhEne01_Die_0x176d50; // 0x176e54 - g_ps2RecompiledFunctionTable[121748] = bhEne01_Die_0x176d50; // 0x176e58 - g_ps2RecompiledFunctionTable[121749] = bhEne01_Die_0x176d50; // 0x176e5c - g_ps2RecompiledFunctionTable[121750] = bhEne01_Die_0x176d50; // 0x176e60 - g_ps2RecompiledFunctionTable[121751] = bhEne01_Die_0x176d50; // 0x176e64 - g_ps2RecompiledFunctionTable[121752] = bhEne01_Die_0x176d50; // 0x176e68 - g_ps2RecompiledFunctionTable[121754] = bhEne01_PlayerControl_0x176e70; // 0x176e70 - g_ps2RecompiledFunctionTable[121755] = bhEne01_PlayerControl_0x176e70; // 0x176e74 - g_ps2RecompiledFunctionTable[121756] = bhEne01_PlayerControl_0x176e70; // 0x176e78 - g_ps2RecompiledFunctionTable[121757] = bhEne01_PlayerControl_0x176e70; // 0x176e7c - g_ps2RecompiledFunctionTable[121758] = bhEne01_PlayerControl_0x176e70; // 0x176e80 - g_ps2RecompiledFunctionTable[121759] = bhEne01_PlayerControl_0x176e70; // 0x176e84 - g_ps2RecompiledFunctionTable[121760] = bhEne01_PlayerControl_0x176e70; // 0x176e88 - g_ps2RecompiledFunctionTable[121761] = bhEne01_PlayerControl_0x176e70; // 0x176e8c - g_ps2RecompiledFunctionTable[121762] = bhEne01_PlayerControl_0x176e70; // 0x176e90 - g_ps2RecompiledFunctionTable[121763] = bhEne01_PlayerControl_0x176e70; // 0x176e94 - g_ps2RecompiledFunctionTable[121764] = bhEne01_PlayerControl_0x176e70; // 0x176e98 - g_ps2RecompiledFunctionTable[121765] = bhEne01_PlayerControl_0x176e70; // 0x176e9c - g_ps2RecompiledFunctionTable[121766] = bhEne01_PlayerControl_0x176e70; // 0x176ea0 - g_ps2RecompiledFunctionTable[121767] = bhEne01_PlayerControl_0x176e70; // 0x176ea4 - g_ps2RecompiledFunctionTable[121768] = bhEne01_PlayerControl_0x176e70; // 0x176ea8 - g_ps2RecompiledFunctionTable[121769] = bhEne01_PlayerControl_0x176e70; // 0x176eac - g_ps2RecompiledFunctionTable[121770] = bhEne01_PlayerControl_0x176e70; // 0x176eb0 - g_ps2RecompiledFunctionTable[121771] = bhEne01_PlayerControl_0x176e70; // 0x176eb4 - g_ps2RecompiledFunctionTable[121772] = bhEne01_PlayerControl_0x176e70; // 0x176eb8 - g_ps2RecompiledFunctionTable[121773] = bhEne01_PlayerControl_0x176e70; // 0x176ebc - g_ps2RecompiledFunctionTable[121774] = bhEne01_PlayerControl_0x176e70; // 0x176ec0 - g_ps2RecompiledFunctionTable[121775] = bhEne01_PlayerControl_0x176e70; // 0x176ec4 - g_ps2RecompiledFunctionTable[121776] = bhEne01_PlayerControl_0x176e70; // 0x176ec8 - g_ps2RecompiledFunctionTable[121777] = bhEne01_PlayerControl_0x176e70; // 0x176ecc - g_ps2RecompiledFunctionTable[121778] = bhEne01_PlayerControl_0x176e70; // 0x176ed0 - g_ps2RecompiledFunctionTable[121779] = bhEne01_PlayerControl_0x176e70; // 0x176ed4 - g_ps2RecompiledFunctionTable[121782] = bhEne01_SearchNeck_0x176ee0; // 0x176ee0 - g_ps2RecompiledFunctionTable[121848] = bhEne01_SearchNeck_0x176ee0; // 0x176fe8 - g_ps2RecompiledFunctionTable[121894] = bhEne01_PlayerLink_0x1770a0; // 0x1770a0 - g_ps2RecompiledFunctionTable[121917] = bhEne01_PlayerLink_0x1770a0; // 0x1770fc - g_ps2RecompiledFunctionTable[121922] = bhEne01_PlayerLink_0x1770a0; // 0x177110 - g_ps2RecompiledFunctionTable[121927] = bhEne01_PlayerLink_0x1770a0; // 0x177124 - g_ps2RecompiledFunctionTable[121932] = bhEne01_PlayerLink_0x1770a0; // 0x177138 - g_ps2RecompiledFunctionTable[121951] = bhEne01_PlayerLink_0x1770a0; // 0x177184 - g_ps2RecompiledFunctionTable[121998] = bhEne01_PlayerLink_0x1770a0; // 0x177240 - g_ps2RecompiledFunctionTable[122003] = bhEne01_PlayerLink_0x1770a0; // 0x177254 - g_ps2RecompiledFunctionTable[122008] = bhEne01_PlayerLink_0x1770a0; // 0x177268 - g_ps2RecompiledFunctionTable[122012] = bhEne01_PlayerLink_0x1770a0; // 0x177278 - g_ps2RecompiledFunctionTable[122014] = bhEne01_PlayerLink_0x1770a0; // 0x177280 - g_ps2RecompiledFunctionTable[122019] = bhEne01_PlayerLink_0x1770a0; // 0x177294 - g_ps2RecompiledFunctionTable[122024] = bhEne01_PlayerLink_0x1770a0; // 0x1772a8 - g_ps2RecompiledFunctionTable[122029] = bhEne01_PlayerLink_0x1770a0; // 0x1772bc - g_ps2RecompiledFunctionTable[122034] = bhEne01_PlayerLink_0x1770a0; // 0x1772d0 - g_ps2RecompiledFunctionTable[122039] = bhEne01_PlayerLink_0x1770a0; // 0x1772e4 - g_ps2RecompiledFunctionTable[122043] = bhEne01_PlayerLink_0x1770a0; // 0x1772f4 - g_ps2RecompiledFunctionTable[122050] = bhEne01_PlayerLink_0x1770a0; // 0x177310 - g_ps2RecompiledFunctionTable[122074] = bhEne01_CalcEnemy_0x177370; // 0x177370 - g_ps2RecompiledFunctionTable[122088] = bhEne01_CalcEnemy_0x177370; // 0x1773a8 - g_ps2RecompiledFunctionTable[122109] = bhEne01_CalcEnemy_0x177370; // 0x1773fc - g_ps2RecompiledFunctionTable[122117] = bhEne01_CalcEnemy_0x177370; // 0x17741c - g_ps2RecompiledFunctionTable[122166] = bhEne01_CalcEnemy_0x177370; // 0x1774e0 - g_ps2RecompiledFunctionTable[122180] = bhEne01_CalcEnemy_0x177370; // 0x177518 - g_ps2RecompiledFunctionTable[122203] = bhEne01_CalcEnemy_0x177370; // 0x177574 - g_ps2RecompiledFunctionTable[122286] = bhEne01_DmgCheck_0x1776c0; // 0x1776c0 - g_ps2RecompiledFunctionTable[122287] = bhEne01_DmgCheck_0x1776c0; // 0x1776c4 - g_ps2RecompiledFunctionTable[122288] = bhEne01_DmgCheck_0x1776c0; // 0x1776c8 - g_ps2RecompiledFunctionTable[122289] = bhEne01_DmgCheck_0x1776c0; // 0x1776cc - g_ps2RecompiledFunctionTable[122290] = bhEne01_DmgCheck_0x1776c0; // 0x1776d0 - g_ps2RecompiledFunctionTable[122291] = bhEne01_DmgCheck_0x1776c0; // 0x1776d4 - g_ps2RecompiledFunctionTable[122292] = bhEne01_DmgCheck_0x1776c0; // 0x1776d8 - g_ps2RecompiledFunctionTable[122293] = bhEne01_DmgCheck_0x1776c0; // 0x1776dc - g_ps2RecompiledFunctionTable[122294] = bhEne01_DmgCheck_0x1776c0; // 0x1776e0 - g_ps2RecompiledFunctionTable[122295] = bhEne01_DmgCheck_0x1776c0; // 0x1776e4 - g_ps2RecompiledFunctionTable[122296] = bhEne01_DmgCheck_0x1776c0; // 0x1776e8 - g_ps2RecompiledFunctionTable[122297] = bhEne01_DmgCheck_0x1776c0; // 0x1776ec - g_ps2RecompiledFunctionTable[122298] = bhEne01_DmgCheck_0x1776c0; // 0x1776f0 - g_ps2RecompiledFunctionTable[122299] = bhEne01_DmgCheck_0x1776c0; // 0x1776f4 - g_ps2RecompiledFunctionTable[122300] = bhEne01_DmgCheck_0x1776c0; // 0x1776f8 - g_ps2RecompiledFunctionTable[122301] = bhEne01_DmgCheck_0x1776c0; // 0x1776fc - g_ps2RecompiledFunctionTable[122302] = bhEne01_DmgCheck_0x1776c0; // 0x177700 - g_ps2RecompiledFunctionTable[122303] = bhEne01_DmgCheck_0x1776c0; // 0x177704 - g_ps2RecompiledFunctionTable[122304] = bhEne01_DmgCheck_0x1776c0; // 0x177708 - g_ps2RecompiledFunctionTable[122305] = bhEne01_DmgCheck_0x1776c0; // 0x17770c - g_ps2RecompiledFunctionTable[122306] = bhEne01_DmgCheck_0x1776c0; // 0x177710 - g_ps2RecompiledFunctionTable[122307] = bhEne01_DmgCheck_0x1776c0; // 0x177714 - g_ps2RecompiledFunctionTable[122308] = bhEne01_DmgCheck_0x1776c0; // 0x177718 - g_ps2RecompiledFunctionTable[122309] = bhEne01_DmgCheck_0x1776c0; // 0x17771c - g_ps2RecompiledFunctionTable[122310] = bhEne01_DmgCheck_0x1776c0; // 0x177720 - g_ps2RecompiledFunctionTable[122311] = bhEne01_DmgCheck_0x1776c0; // 0x177724 - g_ps2RecompiledFunctionTable[122312] = bhEne01_DmgCheck_0x1776c0; // 0x177728 - g_ps2RecompiledFunctionTable[122313] = bhEne01_DmgCheck_0x1776c0; // 0x17772c - g_ps2RecompiledFunctionTable[122314] = bhEne01_DmgCheck_0x1776c0; // 0x177730 - g_ps2RecompiledFunctionTable[122315] = bhEne01_DmgCheck_0x1776c0; // 0x177734 - g_ps2RecompiledFunctionTable[122316] = bhEne01_DmgCheck_0x1776c0; // 0x177738 - g_ps2RecompiledFunctionTable[122317] = bhEne01_DmgCheck_0x1776c0; // 0x17773c - g_ps2RecompiledFunctionTable[122318] = bhEne01_DmgCheck_0x1776c0; // 0x177740 - g_ps2RecompiledFunctionTable[122319] = bhEne01_DmgCheck_0x1776c0; // 0x177744 - g_ps2RecompiledFunctionTable[122320] = bhEne01_DmgCheck_0x1776c0; // 0x177748 - g_ps2RecompiledFunctionTable[122321] = bhEne01_DmgCheck_0x1776c0; // 0x17774c - g_ps2RecompiledFunctionTable[122322] = bhEne01_DmgCheck_0x1776c0; // 0x177750 - g_ps2RecompiledFunctionTable[122323] = bhEne01_DmgCheck_0x1776c0; // 0x177754 - g_ps2RecompiledFunctionTable[122324] = bhEne01_DmgCheck_0x1776c0; // 0x177758 - g_ps2RecompiledFunctionTable[122325] = bhEne01_DmgCheck_0x1776c0; // 0x17775c - g_ps2RecompiledFunctionTable[122326] = bhEne01_DmgCheck_0x1776c0; // 0x177760 - g_ps2RecompiledFunctionTable[122327] = bhEne01_DmgCheck_0x1776c0; // 0x177764 - g_ps2RecompiledFunctionTable[122328] = bhEne01_DmgCheck_0x1776c0; // 0x177768 - g_ps2RecompiledFunctionTable[122329] = bhEne01_DmgCheck_0x1776c0; // 0x17776c - g_ps2RecompiledFunctionTable[122330] = bhEne01_DmgCheck_0x1776c0; // 0x177770 - g_ps2RecompiledFunctionTable[122331] = bhEne01_DmgCheck_0x1776c0; // 0x177774 - g_ps2RecompiledFunctionTable[122332] = bhEne01_DmgCheck_0x1776c0; // 0x177778 - g_ps2RecompiledFunctionTable[122333] = bhEne01_DmgCheck_0x1776c0; // 0x17777c - g_ps2RecompiledFunctionTable[122334] = bhEne01_DmgCheck_0x1776c0; // 0x177780 - g_ps2RecompiledFunctionTable[122335] = bhEne01_DmgCheck_0x1776c0; // 0x177784 - g_ps2RecompiledFunctionTable[122336] = bhEne01_DmgCheck_0x1776c0; // 0x177788 - g_ps2RecompiledFunctionTable[122337] = bhEne01_DmgCheck_0x1776c0; // 0x17778c - g_ps2RecompiledFunctionTable[122338] = bhEne01_DmgCheck_0x1776c0; // 0x177790 - g_ps2RecompiledFunctionTable[122339] = bhEne01_DmgCheck_0x1776c0; // 0x177794 - g_ps2RecompiledFunctionTable[122340] = bhEne01_DmgCheck_0x1776c0; // 0x177798 - g_ps2RecompiledFunctionTable[122341] = bhEne01_DmgCheck_0x1776c0; // 0x17779c - g_ps2RecompiledFunctionTable[122342] = bhEne01_DmgCheck_0x1776c0; // 0x1777a0 - g_ps2RecompiledFunctionTable[122343] = bhEne01_DmgCheck_0x1776c0; // 0x1777a4 - g_ps2RecompiledFunctionTable[122344] = bhEne01_DmgCheck_0x1776c0; // 0x1777a8 - g_ps2RecompiledFunctionTable[122345] = bhEne01_DmgCheck_0x1776c0; // 0x1777ac - g_ps2RecompiledFunctionTable[122346] = bhEne01_DmgCheck_0x1776c0; // 0x1777b0 - g_ps2RecompiledFunctionTable[122347] = bhEne01_DmgCheck_0x1776c0; // 0x1777b4 - g_ps2RecompiledFunctionTable[122348] = bhEne01_DmgCheck_0x1776c0; // 0x1777b8 - g_ps2RecompiledFunctionTable[122349] = bhEne01_DmgCheck_0x1776c0; // 0x1777bc - g_ps2RecompiledFunctionTable[122350] = bhEne01_DmgCheck_0x1776c0; // 0x1777c0 - g_ps2RecompiledFunctionTable[122351] = bhEne01_DmgCheck_0x1776c0; // 0x1777c4 - g_ps2RecompiledFunctionTable[122352] = bhEne01_DmgCheck_0x1776c0; // 0x1777c8 - g_ps2RecompiledFunctionTable[122353] = bhEne01_DmgCheck_0x1776c0; // 0x1777cc - g_ps2RecompiledFunctionTable[122354] = bhEne01_DmgCheck_0x1776c0; // 0x1777d0 - g_ps2RecompiledFunctionTable[122355] = bhEne01_DmgCheck_0x1776c0; // 0x1777d4 - g_ps2RecompiledFunctionTable[122356] = bhEne01_DmgCheck_0x1776c0; // 0x1777d8 - g_ps2RecompiledFunctionTable[122357] = bhEne01_DmgCheck_0x1776c0; // 0x1777dc - g_ps2RecompiledFunctionTable[122358] = bhEne01_DmgCheck_0x1776c0; // 0x1777e0 - g_ps2RecompiledFunctionTable[122359] = bhEne01_DmgCheck_0x1776c0; // 0x1777e4 - g_ps2RecompiledFunctionTable[122360] = bhEne01_DmgCheck_0x1776c0; // 0x1777e8 - g_ps2RecompiledFunctionTable[122361] = bhEne01_DmgCheck_0x1776c0; // 0x1777ec - g_ps2RecompiledFunctionTable[122362] = bhEne01_DmgCheck_0x1776c0; // 0x1777f0 - g_ps2RecompiledFunctionTable[122363] = bhEne01_DmgCheck_0x1776c0; // 0x1777f4 - g_ps2RecompiledFunctionTable[122364] = bhEne01_DmgCheck_0x1776c0; // 0x1777f8 - g_ps2RecompiledFunctionTable[122365] = bhEne01_DmgCheck_0x1776c0; // 0x1777fc - g_ps2RecompiledFunctionTable[122366] = bhEne01_DmgCheck_0x1776c0; // 0x177800 - g_ps2RecompiledFunctionTable[122367] = bhEne01_DmgCheck_0x1776c0; // 0x177804 - g_ps2RecompiledFunctionTable[122368] = bhEne01_DmgCheck_0x1776c0; // 0x177808 - g_ps2RecompiledFunctionTable[122369] = bhEne01_DmgCheck_0x1776c0; // 0x17780c - g_ps2RecompiledFunctionTable[122370] = bhEne01_DmgCheck_0x1776c0; // 0x177810 - g_ps2RecompiledFunctionTable[122371] = bhEne01_DmgCheck_0x1776c0; // 0x177814 - g_ps2RecompiledFunctionTable[122372] = bhEne01_DmgCheck_0x1776c0; // 0x177818 - g_ps2RecompiledFunctionTable[122373] = bhEne01_DmgCheck_0x1776c0; // 0x17781c - g_ps2RecompiledFunctionTable[122374] = bhEne01_DmgCheck_0x1776c0; // 0x177820 - g_ps2RecompiledFunctionTable[122375] = bhEne01_DmgCheck_0x1776c0; // 0x177824 - g_ps2RecompiledFunctionTable[122376] = bhEne01_DmgCheck_0x1776c0; // 0x177828 - g_ps2RecompiledFunctionTable[122377] = bhEne01_DmgCheck_0x1776c0; // 0x17782c - g_ps2RecompiledFunctionTable[122378] = bhEne01_DmgCheck_0x1776c0; // 0x177830 - g_ps2RecompiledFunctionTable[122379] = bhEne01_DmgCheck_0x1776c0; // 0x177834 - g_ps2RecompiledFunctionTable[122380] = bhEne01_DmgCheck_0x1776c0; // 0x177838 - g_ps2RecompiledFunctionTable[122381] = bhEne01_DmgCheck_0x1776c0; // 0x17783c - g_ps2RecompiledFunctionTable[122382] = bhEne01_DmgCheck_0x1776c0; // 0x177840 - g_ps2RecompiledFunctionTable[122383] = bhEne01_DmgCheck_0x1776c0; // 0x177844 - g_ps2RecompiledFunctionTable[122384] = bhEne01_DmgCheck_0x1776c0; // 0x177848 - g_ps2RecompiledFunctionTable[122385] = bhEne01_DmgCheck_0x1776c0; // 0x17784c - g_ps2RecompiledFunctionTable[122386] = bhEne01_DmgCheck_0x1776c0; // 0x177850 - g_ps2RecompiledFunctionTable[122387] = bhEne01_DmgCheck_0x1776c0; // 0x177854 - g_ps2RecompiledFunctionTable[122388] = bhEne01_DmgCheck_0x1776c0; // 0x177858 - g_ps2RecompiledFunctionTable[122389] = bhEne01_DmgCheck_0x1776c0; // 0x17785c - g_ps2RecompiledFunctionTable[122390] = bhEne01_DmgCheck_0x1776c0; // 0x177860 - g_ps2RecompiledFunctionTable[122391] = bhEne01_DmgCheck_0x1776c0; // 0x177864 - g_ps2RecompiledFunctionTable[122392] = bhEne01_DmgCheck_0x1776c0; // 0x177868 - g_ps2RecompiledFunctionTable[122393] = bhEne01_DmgCheck_0x1776c0; // 0x17786c - g_ps2RecompiledFunctionTable[122394] = bhEne01_DmgCheck_0x1776c0; // 0x177870 - g_ps2RecompiledFunctionTable[122395] = bhEne01_DmgCheck_0x1776c0; // 0x177874 - g_ps2RecompiledFunctionTable[122396] = bhEne01_DmgCheck_0x1776c0; // 0x177878 - g_ps2RecompiledFunctionTable[122397] = bhEne01_DmgCheck_0x1776c0; // 0x17787c - g_ps2RecompiledFunctionTable[122398] = bhEne01_DmgCheck_0x1776c0; // 0x177880 - g_ps2RecompiledFunctionTable[122399] = bhEne01_DmgCheck_0x1776c0; // 0x177884 - g_ps2RecompiledFunctionTable[122400] = bhEne01_DmgCheck_0x1776c0; // 0x177888 - g_ps2RecompiledFunctionTable[122401] = bhEne01_DmgCheck_0x1776c0; // 0x17788c - g_ps2RecompiledFunctionTable[122402] = bhEne01_DmgCheck_0x1776c0; // 0x177890 - g_ps2RecompiledFunctionTable[122403] = bhEne01_DmgCheck_0x1776c0; // 0x177894 - g_ps2RecompiledFunctionTable[122404] = bhEne01_DmgCheck_0x1776c0; // 0x177898 - g_ps2RecompiledFunctionTable[122405] = bhEne01_DmgCheck_0x1776c0; // 0x17789c - g_ps2RecompiledFunctionTable[122406] = bhEne01_DmgCheck_0x1776c0; // 0x1778a0 - g_ps2RecompiledFunctionTable[122407] = bhEne01_DmgCheck_0x1776c0; // 0x1778a4 - g_ps2RecompiledFunctionTable[122408] = bhEne01_DmgCheck_0x1776c0; // 0x1778a8 - g_ps2RecompiledFunctionTable[122409] = bhEne01_DmgCheck_0x1776c0; // 0x1778ac - g_ps2RecompiledFunctionTable[122410] = bhEne01_DmgCheck_0x1776c0; // 0x1778b0 - g_ps2RecompiledFunctionTable[122411] = bhEne01_DmgCheck_0x1776c0; // 0x1778b4 - g_ps2RecompiledFunctionTable[122412] = bhEne01_DmgCheck_0x1776c0; // 0x1778b8 - g_ps2RecompiledFunctionTable[122413] = bhEne01_DmgCheck_0x1776c0; // 0x1778bc - g_ps2RecompiledFunctionTable[122414] = bhEne01_DmgCheck_0x1776c0; // 0x1778c0 - g_ps2RecompiledFunctionTable[122415] = bhEne01_DmgCheck_0x1776c0; // 0x1778c4 - g_ps2RecompiledFunctionTable[122416] = bhEne01_DmgCheck_0x1776c0; // 0x1778c8 - g_ps2RecompiledFunctionTable[122417] = bhEne01_DmgCheck_0x1776c0; // 0x1778cc - g_ps2RecompiledFunctionTable[122418] = bhEne01_DmgCheck_0x1776c0; // 0x1778d0 - g_ps2RecompiledFunctionTable[122419] = bhEne01_DmgCheck_0x1776c0; // 0x1778d4 - g_ps2RecompiledFunctionTable[122420] = bhEne01_DmgCheck_0x1776c0; // 0x1778d8 - g_ps2RecompiledFunctionTable[122421] = bhEne01_DmgCheck_0x1776c0; // 0x1778dc - g_ps2RecompiledFunctionTable[122422] = bhEne01_DmgCheck_0x1776c0; // 0x1778e0 - g_ps2RecompiledFunctionTable[122423] = bhEne01_DmgCheck_0x1776c0; // 0x1778e4 - g_ps2RecompiledFunctionTable[122424] = bhEne01_DmgCheck_0x1776c0; // 0x1778e8 - g_ps2RecompiledFunctionTable[122425] = bhEne01_DmgCheck_0x1776c0; // 0x1778ec - g_ps2RecompiledFunctionTable[122426] = bhEne01_DmgCheck_0x1776c0; // 0x1778f0 - g_ps2RecompiledFunctionTable[122427] = bhEne01_DmgCheck_0x1776c0; // 0x1778f4 - g_ps2RecompiledFunctionTable[122428] = bhEne01_DmgCheck_0x1776c0; // 0x1778f8 - g_ps2RecompiledFunctionTable[122429] = bhEne01_DmgCheck_0x1776c0; // 0x1778fc - g_ps2RecompiledFunctionTable[122430] = bhEne01_DmgCheck_0x1776c0; // 0x177900 - g_ps2RecompiledFunctionTable[122431] = bhEne01_DmgCheck_0x1776c0; // 0x177904 - g_ps2RecompiledFunctionTable[122432] = bhEne01_DmgCheck_0x1776c0; // 0x177908 - g_ps2RecompiledFunctionTable[122433] = bhEne01_DmgCheck_0x1776c0; // 0x17790c - g_ps2RecompiledFunctionTable[122434] = bhEne01_DmgCheck_0x1776c0; // 0x177910 - g_ps2RecompiledFunctionTable[122435] = bhEne01_DmgCheck_0x1776c0; // 0x177914 - g_ps2RecompiledFunctionTable[122436] = bhEne01_DmgCheck_0x1776c0; // 0x177918 - g_ps2RecompiledFunctionTable[122437] = bhEne01_DmgCheck_0x1776c0; // 0x17791c - g_ps2RecompiledFunctionTable[122438] = bhEne01_DmgCheck_0x1776c0; // 0x177920 - g_ps2RecompiledFunctionTable[122439] = bhEne01_DmgCheck_0x1776c0; // 0x177924 - g_ps2RecompiledFunctionTable[122440] = bhEne01_DmgCheck_0x1776c0; // 0x177928 - g_ps2RecompiledFunctionTable[122441] = bhEne01_DmgCheck_0x1776c0; // 0x17792c - g_ps2RecompiledFunctionTable[122442] = bhEne01_DmgCheck_0x1776c0; // 0x177930 - g_ps2RecompiledFunctionTable[122443] = bhEne01_DmgCheck_0x1776c0; // 0x177934 - g_ps2RecompiledFunctionTable[122444] = bhEne01_DmgCheck_0x1776c0; // 0x177938 - g_ps2RecompiledFunctionTable[122445] = bhEne01_DmgCheck_0x1776c0; // 0x17793c - g_ps2RecompiledFunctionTable[122446] = bhEne01_DmgCheck_0x1776c0; // 0x177940 - g_ps2RecompiledFunctionTable[122447] = bhEne01_DmgCheck_0x1776c0; // 0x177944 - g_ps2RecompiledFunctionTable[122448] = bhEne01_DmgCheck_0x1776c0; // 0x177948 - g_ps2RecompiledFunctionTable[122449] = bhEne01_DmgCheck_0x1776c0; // 0x17794c - g_ps2RecompiledFunctionTable[122450] = bhEne01_DmgCheck_0x1776c0; // 0x177950 - g_ps2RecompiledFunctionTable[122451] = bhEne01_DmgCheck_0x1776c0; // 0x177954 - g_ps2RecompiledFunctionTable[122452] = bhEne01_DmgCheck_0x1776c0; // 0x177958 - g_ps2RecompiledFunctionTable[122453] = bhEne01_DmgCheck_0x1776c0; // 0x17795c - g_ps2RecompiledFunctionTable[122454] = bhEne01_DmgCheck_0x1776c0; // 0x177960 - g_ps2RecompiledFunctionTable[122455] = bhEne01_DmgCheck_0x1776c0; // 0x177964 - g_ps2RecompiledFunctionTable[122456] = bhEne01_DmgCheck_0x1776c0; // 0x177968 - g_ps2RecompiledFunctionTable[122457] = bhEne01_DmgCheck_0x1776c0; // 0x17796c - g_ps2RecompiledFunctionTable[122458] = bhEne01_DmgCheck_0x1776c0; // 0x177970 - g_ps2RecompiledFunctionTable[122459] = bhEne01_DmgCheck_0x1776c0; // 0x177974 - g_ps2RecompiledFunctionTable[122460] = bhEne01_DmgCheck_0x1776c0; // 0x177978 - g_ps2RecompiledFunctionTable[122461] = bhEne01_DmgCheck_0x1776c0; // 0x17797c - g_ps2RecompiledFunctionTable[122462] = bhEne01_DmgCheck_0x1776c0; // 0x177980 - g_ps2RecompiledFunctionTable[122463] = bhEne01_DmgCheck_0x1776c0; // 0x177984 - g_ps2RecompiledFunctionTable[122464] = bhEne01_DmgCheck_0x1776c0; // 0x177988 - g_ps2RecompiledFunctionTable[122465] = bhEne01_DmgCheck_0x1776c0; // 0x17798c - g_ps2RecompiledFunctionTable[122466] = bhEne01_DmgCheck_0x1776c0; // 0x177990 - g_ps2RecompiledFunctionTable[122467] = bhEne01_DmgCheck_0x1776c0; // 0x177994 - g_ps2RecompiledFunctionTable[122468] = bhEne01_DmgCheck_0x1776c0; // 0x177998 - g_ps2RecompiledFunctionTable[122469] = bhEne01_DmgCheck_0x1776c0; // 0x17799c - g_ps2RecompiledFunctionTable[122470] = bhEne01_DmgCheck_0x1776c0; // 0x1779a0 - g_ps2RecompiledFunctionTable[122471] = bhEne01_DmgCheck_0x1776c0; // 0x1779a4 - g_ps2RecompiledFunctionTable[122472] = bhEne01_DmgCheck_0x1776c0; // 0x1779a8 - g_ps2RecompiledFunctionTable[122473] = bhEne01_DmgCheck_0x1776c0; // 0x1779ac - g_ps2RecompiledFunctionTable[122474] = bhEne01_DmgCheck_0x1776c0; // 0x1779b0 - g_ps2RecompiledFunctionTable[122475] = bhEne01_DmgCheck_0x1776c0; // 0x1779b4 - g_ps2RecompiledFunctionTable[122476] = bhEne01_DmgCheck_0x1776c0; // 0x1779b8 - g_ps2RecompiledFunctionTable[122477] = bhEne01_DmgCheck_0x1776c0; // 0x1779bc - g_ps2RecompiledFunctionTable[122478] = bhEne01_DmgCheck_0x1776c0; // 0x1779c0 - g_ps2RecompiledFunctionTable[122479] = bhEne01_DmgCheck_0x1776c0; // 0x1779c4 - g_ps2RecompiledFunctionTable[122480] = bhEne01_DmgCheck_0x1776c0; // 0x1779c8 - g_ps2RecompiledFunctionTable[122481] = bhEne01_DmgCheck_0x1776c0; // 0x1779cc - g_ps2RecompiledFunctionTable[122482] = bhEne01_DmgCheck_0x1776c0; // 0x1779d0 - g_ps2RecompiledFunctionTable[122483] = bhEne01_DmgCheck_0x1776c0; // 0x1779d4 - g_ps2RecompiledFunctionTable[122484] = bhEne01_DmgCheck_0x1776c0; // 0x1779d8 - g_ps2RecompiledFunctionTable[122485] = bhEne01_DmgCheck_0x1776c0; // 0x1779dc - g_ps2RecompiledFunctionTable[122486] = bhEne01_DmgCheck_0x1776c0; // 0x1779e0 - g_ps2RecompiledFunctionTable[122487] = bhEne01_DmgCheck_0x1776c0; // 0x1779e4 - g_ps2RecompiledFunctionTable[122488] = bhEne01_DmgCheck_0x1776c0; // 0x1779e8 - g_ps2RecompiledFunctionTable[122489] = bhEne01_DmgCheck_0x1776c0; // 0x1779ec - g_ps2RecompiledFunctionTable[122490] = bhEne01_DmgCheck_0x1776c0; // 0x1779f0 - g_ps2RecompiledFunctionTable[122491] = bhEne01_DmgCheck_0x1776c0; // 0x1779f4 - g_ps2RecompiledFunctionTable[122492] = bhEne01_DmgCheck_0x1776c0; // 0x1779f8 - g_ps2RecompiledFunctionTable[122493] = bhEne01_DmgCheck_0x1776c0; // 0x1779fc - g_ps2RecompiledFunctionTable[122494] = bhEne01_DmgCheck_0x1776c0; // 0x177a00 - g_ps2RecompiledFunctionTable[122495] = bhEne01_DmgCheck_0x1776c0; // 0x177a04 - g_ps2RecompiledFunctionTable[122496] = bhEne01_DmgCheck_0x1776c0; // 0x177a08 - g_ps2RecompiledFunctionTable[122497] = bhEne01_DmgCheck_0x1776c0; // 0x177a0c - g_ps2RecompiledFunctionTable[122498] = bhEne01_DmgCheck_0x1776c0; // 0x177a10 - g_ps2RecompiledFunctionTable[122499] = bhEne01_DmgCheck_0x1776c0; // 0x177a14 - g_ps2RecompiledFunctionTable[122500] = bhEne01_DmgCheck_0x1776c0; // 0x177a18 - g_ps2RecompiledFunctionTable[122501] = bhEne01_DmgCheck_0x1776c0; // 0x177a1c - g_ps2RecompiledFunctionTable[122502] = bhEne01_DmgCheck_0x1776c0; // 0x177a20 - g_ps2RecompiledFunctionTable[122503] = bhEne01_DmgCheck_0x1776c0; // 0x177a24 - g_ps2RecompiledFunctionTable[122504] = bhEne01_DmgCheck_0x1776c0; // 0x177a28 - g_ps2RecompiledFunctionTable[122505] = bhEne01_DmgCheck_0x1776c0; // 0x177a2c - g_ps2RecompiledFunctionTable[122506] = bhEne01_DmgCheck_0x1776c0; // 0x177a30 - g_ps2RecompiledFunctionTable[122507] = bhEne01_DmgCheck_0x1776c0; // 0x177a34 - g_ps2RecompiledFunctionTable[122508] = bhEne01_DmgCheck_0x1776c0; // 0x177a38 - g_ps2RecompiledFunctionTable[122509] = bhEne01_DmgCheck_0x1776c0; // 0x177a3c - g_ps2RecompiledFunctionTable[122510] = bhEne01_DmgCheck_0x1776c0; // 0x177a40 - g_ps2RecompiledFunctionTable[122511] = bhEne01_DmgCheck_0x1776c0; // 0x177a44 - g_ps2RecompiledFunctionTable[122512] = bhEne01_DmgCheck_0x1776c0; // 0x177a48 - g_ps2RecompiledFunctionTable[122513] = bhEne01_DmgCheck_0x1776c0; // 0x177a4c - g_ps2RecompiledFunctionTable[122514] = bhEne01_DmgCheck_0x1776c0; // 0x177a50 - g_ps2RecompiledFunctionTable[122515] = bhEne01_DmgCheck_0x1776c0; // 0x177a54 - g_ps2RecompiledFunctionTable[122516] = bhEne01_DmgCheck_0x1776c0; // 0x177a58 - g_ps2RecompiledFunctionTable[122517] = bhEne01_DmgCheck_0x1776c0; // 0x177a5c - g_ps2RecompiledFunctionTable[122518] = bhEne01_DmgCheck_0x1776c0; // 0x177a60 - g_ps2RecompiledFunctionTable[122519] = bhEne01_DmgCheck_0x1776c0; // 0x177a64 - g_ps2RecompiledFunctionTable[122520] = bhEne01_DmgCheck_0x1776c0; // 0x177a68 - g_ps2RecompiledFunctionTable[122521] = bhEne01_DmgCheck_0x1776c0; // 0x177a6c - g_ps2RecompiledFunctionTable[122522] = bhEne01_DmgCheck_0x1776c0; // 0x177a70 - g_ps2RecompiledFunctionTable[122523] = bhEne01_DmgCheck_0x1776c0; // 0x177a74 - g_ps2RecompiledFunctionTable[122524] = bhEne01_DmgCheck_0x1776c0; // 0x177a78 - g_ps2RecompiledFunctionTable[122525] = bhEne01_DmgCheck_0x1776c0; // 0x177a7c - g_ps2RecompiledFunctionTable[122526] = bhEne01_DmgCheck_0x1776c0; // 0x177a80 - g_ps2RecompiledFunctionTable[122527] = bhEne01_DmgCheck_0x1776c0; // 0x177a84 - g_ps2RecompiledFunctionTable[122528] = bhEne01_DmgCheck_0x1776c0; // 0x177a88 - g_ps2RecompiledFunctionTable[122529] = bhEne01_DmgCheck_0x1776c0; // 0x177a8c - g_ps2RecompiledFunctionTable[122530] = bhEne01_DmgCheck_0x1776c0; // 0x177a90 - g_ps2RecompiledFunctionTable[122531] = bhEne01_DmgCheck_0x1776c0; // 0x177a94 - g_ps2RecompiledFunctionTable[122532] = bhEne01_DmgCheck_0x1776c0; // 0x177a98 - g_ps2RecompiledFunctionTable[122533] = bhEne01_DmgCheck_0x1776c0; // 0x177a9c - g_ps2RecompiledFunctionTable[122534] = bhEne01_DmgCheck_0x1776c0; // 0x177aa0 - g_ps2RecompiledFunctionTable[122535] = bhEne01_DmgCheck_0x1776c0; // 0x177aa4 - g_ps2RecompiledFunctionTable[122536] = bhEne01_DmgCheck_0x1776c0; // 0x177aa8 - g_ps2RecompiledFunctionTable[122537] = bhEne01_DmgCheck_0x1776c0; // 0x177aac - g_ps2RecompiledFunctionTable[122538] = bhEne01_DmgCheck_0x1776c0; // 0x177ab0 - g_ps2RecompiledFunctionTable[122539] = bhEne01_DmgCheck_0x1776c0; // 0x177ab4 - g_ps2RecompiledFunctionTable[122540] = bhEne01_DmgCheck_0x1776c0; // 0x177ab8 - g_ps2RecompiledFunctionTable[122541] = bhEne01_DmgCheck_0x1776c0; // 0x177abc - g_ps2RecompiledFunctionTable[122542] = bhEne01_DmgCheck_0x1776c0; // 0x177ac0 - g_ps2RecompiledFunctionTable[122543] = bhEne01_DmgCheck_0x1776c0; // 0x177ac4 - g_ps2RecompiledFunctionTable[122544] = bhEne01_DmgCheck_0x1776c0; // 0x177ac8 - g_ps2RecompiledFunctionTable[122545] = bhEne01_DmgCheck_0x1776c0; // 0x177acc - g_ps2RecompiledFunctionTable[122546] = bhEne01_DmgCheck_0x1776c0; // 0x177ad0 - g_ps2RecompiledFunctionTable[122547] = bhEne01_DmgCheck_0x1776c0; // 0x177ad4 - g_ps2RecompiledFunctionTable[122548] = bhEne01_DmgCheck_0x1776c0; // 0x177ad8 - g_ps2RecompiledFunctionTable[122549] = bhEne01_DmgCheck_0x1776c0; // 0x177adc - g_ps2RecompiledFunctionTable[122550] = bhEne01_DmgCheck_0x1776c0; // 0x177ae0 - g_ps2RecompiledFunctionTable[122551] = bhEne01_DmgCheck_0x1776c0; // 0x177ae4 - g_ps2RecompiledFunctionTable[122552] = bhEne01_DmgCheck_0x1776c0; // 0x177ae8 - g_ps2RecompiledFunctionTable[122553] = bhEne01_DmgCheck_0x1776c0; // 0x177aec - g_ps2RecompiledFunctionTable[122554] = bhEne01_DmgCheck_0x1776c0; // 0x177af0 - g_ps2RecompiledFunctionTable[122555] = bhEne01_DmgCheck_0x1776c0; // 0x177af4 - g_ps2RecompiledFunctionTable[122556] = bhEne01_DmgCheck_0x1776c0; // 0x177af8 - g_ps2RecompiledFunctionTable[122557] = bhEne01_DmgCheck_0x1776c0; // 0x177afc - g_ps2RecompiledFunctionTable[122558] = bhEne01_DmgCheck_0x1776c0; // 0x177b00 - g_ps2RecompiledFunctionTable[122559] = bhEne01_DmgCheck_0x1776c0; // 0x177b04 - g_ps2RecompiledFunctionTable[122560] = bhEne01_DmgCheck_0x1776c0; // 0x177b08 - g_ps2RecompiledFunctionTable[122561] = bhEne01_DmgCheck_0x1776c0; // 0x177b0c - g_ps2RecompiledFunctionTable[122562] = bhEne01_DmgCheck_0x1776c0; // 0x177b10 - g_ps2RecompiledFunctionTable[122563] = bhEne01_DmgCheck_0x1776c0; // 0x177b14 - g_ps2RecompiledFunctionTable[122564] = bhEne01_DmgCheck_0x1776c0; // 0x177b18 - g_ps2RecompiledFunctionTable[122565] = bhEne01_DmgCheck_0x1776c0; // 0x177b1c - g_ps2RecompiledFunctionTable[122566] = bhEne01_DmgCheck_0x1776c0; // 0x177b20 - g_ps2RecompiledFunctionTable[122567] = bhEne01_DmgCheck_0x1776c0; // 0x177b24 - g_ps2RecompiledFunctionTable[122568] = bhEne01_DmgCheck_0x1776c0; // 0x177b28 - g_ps2RecompiledFunctionTable[122569] = bhEne01_DmgCheck_0x1776c0; // 0x177b2c - g_ps2RecompiledFunctionTable[122570] = bhEne01_DmgCheck_0x1776c0; // 0x177b30 - g_ps2RecompiledFunctionTable[122571] = bhEne01_DmgCheck_0x1776c0; // 0x177b34 - g_ps2RecompiledFunctionTable[122572] = bhEne01_DmgCheck_0x1776c0; // 0x177b38 - g_ps2RecompiledFunctionTable[122573] = bhEne01_DmgCheck_0x1776c0; // 0x177b3c - g_ps2RecompiledFunctionTable[122574] = bhEne01_DmgCheck_0x1776c0; // 0x177b40 - g_ps2RecompiledFunctionTable[122575] = bhEne01_DmgCheck_0x1776c0; // 0x177b44 - g_ps2RecompiledFunctionTable[122576] = bhEne01_DmgCheck_0x1776c0; // 0x177b48 - g_ps2RecompiledFunctionTable[122577] = bhEne01_DmgCheck_0x1776c0; // 0x177b4c - g_ps2RecompiledFunctionTable[122578] = bhEne01_DmgCheck_0x1776c0; // 0x177b50 - g_ps2RecompiledFunctionTable[122579] = bhEne01_DmgCheck_0x1776c0; // 0x177b54 - g_ps2RecompiledFunctionTable[122580] = bhEne01_DmgCheck_0x1776c0; // 0x177b58 - g_ps2RecompiledFunctionTable[122581] = bhEne01_DmgCheck_0x1776c0; // 0x177b5c - g_ps2RecompiledFunctionTable[122582] = bhEne01_DmgCheck_0x1776c0; // 0x177b60 - g_ps2RecompiledFunctionTable[122583] = bhEne01_DmgCheck_0x1776c0; // 0x177b64 - g_ps2RecompiledFunctionTable[122584] = bhEne01_DmgCheck_0x1776c0; // 0x177b68 - g_ps2RecompiledFunctionTable[122585] = bhEne01_DmgCheck_0x1776c0; // 0x177b6c - g_ps2RecompiledFunctionTable[122586] = bhEne01_DmgCheck_0x1776c0; // 0x177b70 - g_ps2RecompiledFunctionTable[122587] = bhEne01_DmgCheck_0x1776c0; // 0x177b74 - g_ps2RecompiledFunctionTable[122588] = bhEne01_DmgCheck_0x1776c0; // 0x177b78 - g_ps2RecompiledFunctionTable[122589] = bhEne01_DmgCheck_0x1776c0; // 0x177b7c - g_ps2RecompiledFunctionTable[122590] = bhEne01_DmgCheck_0x1776c0; // 0x177b80 - g_ps2RecompiledFunctionTable[122591] = bhEne01_DmgCheck_0x1776c0; // 0x177b84 - g_ps2RecompiledFunctionTable[122592] = bhEne01_DmgCheck_0x1776c0; // 0x177b88 - g_ps2RecompiledFunctionTable[122593] = bhEne01_DmgCheck_0x1776c0; // 0x177b8c - g_ps2RecompiledFunctionTable[122594] = bhEne01_DmgCheck_0x1776c0; // 0x177b90 - g_ps2RecompiledFunctionTable[122595] = bhEne01_DmgCheck_0x1776c0; // 0x177b94 - g_ps2RecompiledFunctionTable[122596] = bhEne01_DmgCheck_0x1776c0; // 0x177b98 - g_ps2RecompiledFunctionTable[122597] = bhEne01_DmgCheck_0x1776c0; // 0x177b9c - g_ps2RecompiledFunctionTable[122598] = bhEne01_DmgCheck_0x1776c0; // 0x177ba0 - g_ps2RecompiledFunctionTable[122599] = bhEne01_DmgCheck_0x1776c0; // 0x177ba4 - g_ps2RecompiledFunctionTable[122600] = bhEne01_DmgCheck_0x1776c0; // 0x177ba8 - g_ps2RecompiledFunctionTable[122601] = bhEne01_DmgCheck_0x1776c0; // 0x177bac - g_ps2RecompiledFunctionTable[122602] = bhEne01_DmgCheck_0x1776c0; // 0x177bb0 - g_ps2RecompiledFunctionTable[122603] = bhEne01_DmgCheck_0x1776c0; // 0x177bb4 - g_ps2RecompiledFunctionTable[122606] = bhEne01_SetBlood_0x177bc0; // 0x177bc0 - g_ps2RecompiledFunctionTable[122659] = bhEne01_SetBlood_0x177bc0; // 0x177c94 - g_ps2RecompiledFunctionTable[122705] = bhEne01_SetBlood_0x177bc0; // 0x177d4c - g_ps2RecompiledFunctionTable[122711] = bhEne01_SetBlood_0x177bc0; // 0x177d64 - g_ps2RecompiledFunctionTable[122716] = bhEne01_SetBlood_0x177bc0; // 0x177d78 - g_ps2RecompiledFunctionTable[122722] = bhEne01_SetBlood_0x177bc0; // 0x177d90 - g_ps2RecompiledFunctionTable[122733] = bhEne01_SetBlood_0x177bc0; // 0x177dbc - g_ps2RecompiledFunctionTable[122738] = bhEne01_SetBlood_0x177bc0; // 0x177dd0 - g_ps2RecompiledFunctionTable[122744] = bhEne01_SetBlood_0x177bc0; // 0x177de8 - g_ps2RecompiledFunctionTable[122756] = bhEne01_SetBlood_0x177bc0; // 0x177e18 - g_ps2RecompiledFunctionTable[122781] = bhEne01_SetBlood_0x177bc0; // 0x177e7c - g_ps2RecompiledFunctionTable[122787] = bhEne01_SetBlood_0x177bc0; // 0x177e94 - g_ps2RecompiledFunctionTable[122792] = bhEne01_SetBlood_0x177bc0; // 0x177ea8 - g_ps2RecompiledFunctionTable[122798] = bhEne01_SetBlood_0x177bc0; // 0x177ec0 - g_ps2RecompiledFunctionTable[122805] = bhEne01_SetBlood_0x177bc0; // 0x177edc - g_ps2RecompiledFunctionTable[122839] = bhEne01_SetBlood_0x177bc0; // 0x177f64 - g_ps2RecompiledFunctionTable[122845] = bhEne01_SetBlood_0x177bc0; // 0x177f7c - g_ps2RecompiledFunctionTable[122854] = bhEne01_DmgCheckType00_0x177fa0; // 0x177fa0 - g_ps2RecompiledFunctionTable[122893] = bhEne01_DmgCheckType00_0x177fa0; // 0x17803c - g_ps2RecompiledFunctionTable[122898] = bhEne01_DmgCheckType00_0x177fa0; // 0x178050 - g_ps2RecompiledFunctionTable[122921] = bhEne01_DmgCheckType00_0x177fa0; // 0x1780ac - g_ps2RecompiledFunctionTable[122931] = bhEne01_DmgCheckType00_0x177fa0; // 0x1780d4 - g_ps2RecompiledFunctionTable[122938] = bhEne01_DmgCheckType00_0x177fa0; // 0x1780f0 - g_ps2RecompiledFunctionTable[122995] = bhEne01_DmgCheckType00_0x177fa0; // 0x1781d4 - g_ps2RecompiledFunctionTable[123012] = bhEne01_DmgCheckType00_0x177fa0; // 0x178218 - g_ps2RecompiledFunctionTable[123052] = bhEne01_DmgCheckType00_0x177fa0; // 0x1782b8 - g_ps2RecompiledFunctionTable[123061] = bhEne01_DmgCheckType00_0x177fa0; // 0x1782dc - g_ps2RecompiledFunctionTable[123198] = bhEne01_DmgCheckType00_0x177fa0; // 0x178500 - g_ps2RecompiledFunctionTable[123240] = bhEne01_DmgCheckType00_0x177fa0; // 0x1785a8 - g_ps2RecompiledFunctionTable[123321] = bhEne01_DmgCheckType00_0x177fa0; // 0x1786ec - g_ps2RecompiledFunctionTable[123350] = bhEne01_DmgCheckType00_0x177fa0; // 0x178760 - g_ps2RecompiledFunctionTable[123371] = bhEne01_DmgCheckType00_0x177fa0; // 0x1787b4 - g_ps2RecompiledFunctionTable[123394] = bhEne01_CheckExpHead_0x178810; // 0x178810 - g_ps2RecompiledFunctionTable[123478] = bhEne01_DmgCheckType02_0x178960; // 0x178960 - g_ps2RecompiledFunctionTable[123510] = bhEne01_DamageAdd_0x1789e0; // 0x1789e0 - g_ps2RecompiledFunctionTable[123522] = bhEne01_DamageAdd_0x1789e0; // 0x178a10 - g_ps2RecompiledFunctionTable[123547] = bhEne01_DamageAdd_0x1789e0; // 0x178a74 - g_ps2RecompiledFunctionTable[123584] = bhEne01_DamageAdd_0x1789e0; // 0x178b08 - g_ps2RecompiledFunctionTable[123599] = bhEne01_DamageAdd_0x1789e0; // 0x178b44 - g_ps2RecompiledFunctionTable[123607] = bhEne01_DamageAdd_0x1789e0; // 0x178b64 - g_ps2RecompiledFunctionTable[123619] = bhEne01_DamageAdd_0x1789e0; // 0x178b94 - g_ps2RecompiledFunctionTable[123636] = bhEne01_DamageAdd_0x1789e0; // 0x178bd8 - g_ps2RecompiledFunctionTable[123642] = bhEne01_DamageAdd_0x1789e0; // 0x178bf0 - g_ps2RecompiledFunctionTable[123650] = bhEne01_DamageAdd_0x1789e0; // 0x178c10 - g_ps2RecompiledFunctionTable[123654] = bhEne01_DamageAdd_0x1789e0; // 0x178c20 - g_ps2RecompiledFunctionTable[123662] = bhEne01_DamageAdd_0x1789e0; // 0x178c40 - g_ps2RecompiledFunctionTable[123674] = bhEne01_PartsDamageCheck_0x178c70; // 0x178c70 - g_ps2RecompiledFunctionTable[123762] = bhEne01_DmgModeJumpCheck_0x178dd0; // 0x178dd0 - g_ps2RecompiledFunctionTable[123775] = bhEne01_DmgModeJumpCheck_0x178dd0; // 0x178e04 - g_ps2RecompiledFunctionTable[123825] = bhEne01_DmgModeJumpCheck_0x178dd0; // 0x178ecc - g_ps2RecompiledFunctionTable[123847] = bhEne01_DmgModeJumpCheck_0x178dd0; // 0x178f24 - g_ps2RecompiledFunctionTable[123866] = bhEne01_DmgModeJumpCheck_0x178dd0; // 0x178f70 - g_ps2RecompiledFunctionTable[123893] = bhEne01_DmgModeJumpCheck_0x178dd0; // 0x178fdc - g_ps2RecompiledFunctionTable[123920] = bhEne01_DmgModeJumpCheck_0x178dd0; // 0x179048 - g_ps2RecompiledFunctionTable[123950] = bhEne01_CollCheck_0x1790c0; // 0x1790c0 - g_ps2RecompiledFunctionTable[123979] = bhEne01_CollCheck_0x1790c0; // 0x179134 - g_ps2RecompiledFunctionTable[124012] = bhEne01_CollCheck_0x1790c0; // 0x1791b8 - g_ps2RecompiledFunctionTable[124018] = bhEne01_CollCheck_0x1790c0; // 0x1791d0 - g_ps2RecompiledFunctionTable[124020] = bhEne01_CollCheck_0x1790c0; // 0x1791d8 - g_ps2RecompiledFunctionTable[124023] = bhEne01_CollCheck_0x1790c0; // 0x1791e4 - g_ps2RecompiledFunctionTable[124035] = bhEne01_CollCheck_0x1790c0; // 0x179214 - g_ps2RecompiledFunctionTable[124050] = bhEne01_CollCheck_0x1790c0; // 0x179250 - g_ps2RecompiledFunctionTable[124072] = bhEne01_CollCheck_0x1790c0; // 0x1792a8 - g_ps2RecompiledFunctionTable[124086] = bhEne01_CollCheckPush_0x1792e0; // 0x1792e0 - g_ps2RecompiledFunctionTable[124101] = bhEne01_CollCheckPush_0x1792e0; // 0x17931c - g_ps2RecompiledFunctionTable[124124] = bhEne01_CollCheckPush_0x1792e0; // 0x179378 - g_ps2RecompiledFunctionTable[124129] = bhEne01_CollCheckPush_0x1792e0; // 0x17938c - g_ps2RecompiledFunctionTable[124132] = bhEne01_CollCheckPush_0x1792e0; // 0x179398 - g_ps2RecompiledFunctionTable[124204] = bhEne01_CollCheckPush_0x1792e0; // 0x1794b8 - g_ps2RecompiledFunctionTable[124222] = bhEne01_CollCheckPush_0x1792e0; // 0x179500 - g_ps2RecompiledFunctionTable[124226] = bhEne01_CollCheckPush_0x1792e0; // 0x179510 - g_ps2RecompiledFunctionTable[124230] = bhEne01_CollCheckPush_0x1792e0; // 0x179520 - g_ps2RecompiledFunctionTable[124290] = bhEne01_EnemyHitChk_0x179610; // 0x179610 - g_ps2RecompiledFunctionTable[124301] = bhEne01_EnemyHitChk_0x179610; // 0x17963c - g_ps2RecompiledFunctionTable[124322] = bhEne01_CollCheckWall_0x179690; // 0x179690 - g_ps2RecompiledFunctionTable[124346] = bhEne01_CollCheckWall_0x179690; // 0x1796f0 - g_ps2RecompiledFunctionTable[124371] = bhEne01_CollCheckWall_0x179690; // 0x179754 - g_ps2RecompiledFunctionTable[124376] = bhEne01_CollCheckWall_0x179690; // 0x179768 - g_ps2RecompiledFunctionTable[124381] = bhEne01_CollCheckWall_0x179690; // 0x17977c - g_ps2RecompiledFunctionTable[124393] = bhEne01_CollCheckWall_0x179690; // 0x1797ac - g_ps2RecompiledFunctionTable[124397] = bhEne01_CollCheckWall_0x179690; // 0x1797bc - g_ps2RecompiledFunctionTable[124406] = bhEne01_CollCheckWall_0x179690; // 0x1797e0 - g_ps2RecompiledFunctionTable[124410] = bhEne01_CollCheckWall_0x179690; // 0x1797f0 - g_ps2RecompiledFunctionTable[124420] = bhEne01_CollCheckWall_0x179690; // 0x179818 - g_ps2RecompiledFunctionTable[124445] = bhEne01_CollCheckWall_0x179690; // 0x17987c - g_ps2RecompiledFunctionTable[124486] = bhEne01_CollCheckWall_0x179690; // 0x179920 - g_ps2RecompiledFunctionTable[124492] = bhEne01_CollCheckWall_0x179690; // 0x179938 - g_ps2RecompiledFunctionTable[124536] = bhEne01_CollCheckWall_0x179690; // 0x1799e8 - g_ps2RecompiledFunctionTable[124546] = bhEne01_CollCheckWall_0x179690; // 0x179a10 - g_ps2RecompiledFunctionTable[124590] = bhEne01_CollCheckWall_0x179690; // 0x179ac0 - g_ps2RecompiledFunctionTable[124596] = bhEne01_CollCheckWall_0x179690; // 0x179ad8 - g_ps2RecompiledFunctionTable[124656] = bhEne01_CollCheckWall_0x179690; // 0x179bc8 - g_ps2RecompiledFunctionTable[124665] = bhEne01_CollCheckWall_0x179690; // 0x179bec - g_ps2RecompiledFunctionTable[124687] = bhEne01_CollCheckWall_0x179690; // 0x179c44 - g_ps2RecompiledFunctionTable[124719] = bhEne01_CollCheckWall_0x179690; // 0x179cc4 - g_ps2RecompiledFunctionTable[124730] = bhEne01_CollCheckWall_0x179690; // 0x179cf0 - g_ps2RecompiledFunctionTable[124748] = bhEne01_CollCheckWall_0x179690; // 0x179d38 - g_ps2RecompiledFunctionTable[124753] = bhEne01_CollCheckWall_0x179690; // 0x179d4c - g_ps2RecompiledFunctionTable[124758] = bhEne01_CollCheckWall_0x179690; // 0x179d60 - g_ps2RecompiledFunctionTable[124771] = bhEne01_CollCheckWall_0x179690; // 0x179d94 - g_ps2RecompiledFunctionTable[124775] = bhEne01_CollCheckWall_0x179690; // 0x179da4 - g_ps2RecompiledFunctionTable[124782] = bhEne01_CollCheckWall_0x179690; // 0x179dc0 - g_ps2RecompiledFunctionTable[124815] = bhEne01_CollCheckWall_0x179690; // 0x179e44 - g_ps2RecompiledFunctionTable[124824] = bhEne01_CollCheckWall_0x179690; // 0x179e68 - g_ps2RecompiledFunctionTable[124848] = bhEne01_CollCheckWall_0x179690; // 0x179ec8 - g_ps2RecompiledFunctionTable[124862] = bhEne01_CollCheckWall_0x179690; // 0x179f00 - g_ps2RecompiledFunctionTable[124866] = bhEne01_CollCheckWall_0x179690; // 0x179f10 - g_ps2RecompiledFunctionTable[124876] = bhEne01_CollCheckWall_0x179690; // 0x179f38 - g_ps2RecompiledFunctionTable[124880] = bhEne01_CollCheckWall_0x179690; // 0x179f48 - g_ps2RecompiledFunctionTable[124893] = bhEne01_CollCheckWall_0x179690; // 0x179f7c - g_ps2RecompiledFunctionTable[124912] = bhEne01_CollCheckWall_0x179690; // 0x179fc8 - g_ps2RecompiledFunctionTable[124934] = bhEne01_InitType00_0x17a020; // 0x17a020 - g_ps2RecompiledFunctionTable[124951] = bhEne01_InitType00_0x17a020; // 0x17a064 - g_ps2RecompiledFunctionTable[124958] = bhEne01_InitType02_0x17a080; // 0x17a080 - g_ps2RecompiledFunctionTable[124994] = bhEne01_InitType06_0x17a110; // 0x17a110 - g_ps2RecompiledFunctionTable[125032] = bhEne01_InitType06_0x17a110; // 0x17a1a8 - g_ps2RecompiledFunctionTable[125050] = bhEne01_InitType10_0x17a1f0; // 0x17a1f0 - g_ps2RecompiledFunctionTable[125077] = bhEne01_InitType10_0x17a1f0; // 0x17a25c - g_ps2RecompiledFunctionTable[125086] = bhEne01_InitType11_0x17a280; // 0x17a280 - g_ps2RecompiledFunctionTable[125107] = bhEne01_InitType11_0x17a280; // 0x17a2d4 - g_ps2RecompiledFunctionTable[125114] = bhEne01_InitType15_0x17a2f0; // 0x17a2f0 - g_ps2RecompiledFunctionTable[125137] = bhEne01_InitType15_0x17a2f0; // 0x17a34c - g_ps2RecompiledFunctionTable[125158] = bhEne01_EneSearch_0x17a3a0; // 0x17a3a0 - g_ps2RecompiledFunctionTable[125189] = bhEne01_EneSearch_0x17a3a0; // 0x17a41c - g_ps2RecompiledFunctionTable[125262] = bhEne01_Brain00_0x17a540; // 0x17a540 - g_ps2RecompiledFunctionTable[125267] = bhEne01_Brain00_0x17a540; // 0x17a554 - g_ps2RecompiledFunctionTable[125302] = bhEne01_Brain00_0x17a540; // 0x17a5e0 - g_ps2RecompiledFunctionTable[125310] = bhEne01_Brain00_0x17a540; // 0x17a600 - g_ps2RecompiledFunctionTable[125329] = bhEne01_Brain00_0x17a540; // 0x17a64c - g_ps2RecompiledFunctionTable[125346] = bhEne01_Brain00_0x17a540; // 0x17a690 - g_ps2RecompiledFunctionTable[125359] = bhEne01_Brain00_0x17a540; // 0x17a6c4 - g_ps2RecompiledFunctionTable[125383] = bhEne01_Brain00_0x17a540; // 0x17a724 - g_ps2RecompiledFunctionTable[125390] = bhEne01_Brain02_0x17a740; // 0x17a740 - g_ps2RecompiledFunctionTable[125396] = bhEne01_Brain02_0x17a740; // 0x17a758 - g_ps2RecompiledFunctionTable[125416] = bhEne01_Brain02_0x17a740; // 0x17a7a8 - g_ps2RecompiledFunctionTable[125438] = bhEne01_ActionModeCheck_0x17a800; // 0x17a800 - g_ps2RecompiledFunctionTable[125453] = bhEne01_ActionModeCheck_0x17a800; // 0x17a83c - g_ps2RecompiledFunctionTable[125488] = bhEne01_ActionModeCheck_0x17a800; // 0x17a8c8 - g_ps2RecompiledFunctionTable[125522] = bhEne01_ActionModeCheck_0x17a800; // 0x17a950 - g_ps2RecompiledFunctionTable[125563] = bhEne01_ActionModeCheck_0x17a800; // 0x17a9f4 - g_ps2RecompiledFunctionTable[125586] = bhEne01_ActionModeCheck_0x17a800; // 0x17aa50 - g_ps2RecompiledFunctionTable[125593] = bhEne01_ActionModeCheck_0x17a800; // 0x17aa6c - g_ps2RecompiledFunctionTable[125598] = bhEne01_ActionModeCheck_0x17a800; // 0x17aa80 - g_ps2RecompiledFunctionTable[125604] = bhEne01_ActionModeCheck_0x17a800; // 0x17aa98 - g_ps2RecompiledFunctionTable[125610] = bhEne01_ActionModeCheck_0x17a800; // 0x17aab0 - g_ps2RecompiledFunctionTable[125616] = bhEne01_ActionModeCheck_0x17a800; // 0x17aac8 - g_ps2RecompiledFunctionTable[125661] = bhEne01_ActionModeCheck_0x17a800; // 0x17ab7c - g_ps2RecompiledFunctionTable[125701] = bhEne01_ActionModeCheck_0x17a800; // 0x17ac1c - g_ps2RecompiledFunctionTable[125740] = bhEne01_ActionModeCheck_0x17a800; // 0x17acb8 - g_ps2RecompiledFunctionTable[125749] = bhEne01_ActionModeCheck_0x17a800; // 0x17acdc - g_ps2RecompiledFunctionTable[125762] = bhEne01_ActionModeCheck_0x17a800; // 0x17ad10 - g_ps2RecompiledFunctionTable[125789] = bhEne01_ActionModeCheck_0x17a800; // 0x17ad7c - g_ps2RecompiledFunctionTable[125823] = bhEne01_ActionModeCheck_0x17a800; // 0x17ae04 - g_ps2RecompiledFunctionTable[125838] = bhEne01_MVType00_0x17ae40; // 0x17ae40 - g_ps2RecompiledFunctionTable[125839] = bhEne01_MVType00_0x17ae40; // 0x17ae44 - g_ps2RecompiledFunctionTable[125840] = bhEne01_MVType00_0x17ae40; // 0x17ae48 - g_ps2RecompiledFunctionTable[125841] = bhEne01_MVType00_0x17ae40; // 0x17ae4c - g_ps2RecompiledFunctionTable[125842] = bhEne01_MVType00_0x17ae40; // 0x17ae50 - g_ps2RecompiledFunctionTable[125843] = bhEne01_MVType00_0x17ae40; // 0x17ae54 - g_ps2RecompiledFunctionTable[125844] = bhEne01_MVType00_0x17ae40; // 0x17ae58 - g_ps2RecompiledFunctionTable[125845] = bhEne01_MVType00_0x17ae40; // 0x17ae5c - g_ps2RecompiledFunctionTable[125846] = bhEne01_MVType00_0x17ae40; // 0x17ae60 - g_ps2RecompiledFunctionTable[125847] = bhEne01_MVType00_0x17ae40; // 0x17ae64 - g_ps2RecompiledFunctionTable[125848] = bhEne01_MVType00_0x17ae40; // 0x17ae68 - g_ps2RecompiledFunctionTable[125849] = bhEne01_MVType00_0x17ae40; // 0x17ae6c - g_ps2RecompiledFunctionTable[125850] = bhEne01_MVType00_0x17ae40; // 0x17ae70 - g_ps2RecompiledFunctionTable[125851] = bhEne01_MVType00_0x17ae40; // 0x17ae74 - g_ps2RecompiledFunctionTable[125852] = bhEne01_MVType00_0x17ae40; // 0x17ae78 - g_ps2RecompiledFunctionTable[125853] = bhEne01_MVType00_0x17ae40; // 0x17ae7c - g_ps2RecompiledFunctionTable[125854] = bhEne01_MVType00_0x17ae40; // 0x17ae80 - g_ps2RecompiledFunctionTable[125855] = bhEne01_MVType00_0x17ae40; // 0x17ae84 - g_ps2RecompiledFunctionTable[125856] = bhEne01_MVType00_0x17ae40; // 0x17ae88 - g_ps2RecompiledFunctionTable[125857] = bhEne01_MVType00_0x17ae40; // 0x17ae8c - g_ps2RecompiledFunctionTable[125858] = bhEne01_MVType00_0x17ae40; // 0x17ae90 - g_ps2RecompiledFunctionTable[125859] = bhEne01_MVType00_0x17ae40; // 0x17ae94 - g_ps2RecompiledFunctionTable[125860] = bhEne01_MVType00_0x17ae40; // 0x17ae98 - g_ps2RecompiledFunctionTable[125861] = bhEne01_MVType00_0x17ae40; // 0x17ae9c - g_ps2RecompiledFunctionTable[125862] = bhEne01_MVType00_0x17ae40; // 0x17aea0 - g_ps2RecompiledFunctionTable[125863] = bhEne01_MVType00_0x17ae40; // 0x17aea4 - g_ps2RecompiledFunctionTable[125864] = bhEne01_MVType00_0x17ae40; // 0x17aea8 - g_ps2RecompiledFunctionTable[125865] = bhEne01_MVType00_0x17ae40; // 0x17aeac - g_ps2RecompiledFunctionTable[125866] = bhEne01_MVType00_0x17ae40; // 0x17aeb0 - g_ps2RecompiledFunctionTable[125867] = bhEne01_MVType00_0x17ae40; // 0x17aeb4 - g_ps2RecompiledFunctionTable[125868] = bhEne01_MVType00_0x17ae40; // 0x17aeb8 - g_ps2RecompiledFunctionTable[125869] = bhEne01_MVType00_0x17ae40; // 0x17aebc - g_ps2RecompiledFunctionTable[125870] = bhEne01_MVType00_0x17ae40; // 0x17aec0 - g_ps2RecompiledFunctionTable[125871] = bhEne01_MVType00_0x17ae40; // 0x17aec4 - g_ps2RecompiledFunctionTable[125872] = bhEne01_MVType00_0x17ae40; // 0x17aec8 - g_ps2RecompiledFunctionTable[125873] = bhEne01_MVType00_0x17ae40; // 0x17aecc - g_ps2RecompiledFunctionTable[125874] = bhEne01_MVType00_0x17ae40; // 0x17aed0 - g_ps2RecompiledFunctionTable[125875] = bhEne01_MVType00_0x17ae40; // 0x17aed4 - g_ps2RecompiledFunctionTable[125876] = bhEne01_MVType00_0x17ae40; // 0x17aed8 - g_ps2RecompiledFunctionTable[125877] = bhEne01_MVType00_0x17ae40; // 0x17aedc - g_ps2RecompiledFunctionTable[125878] = bhEne01_MVType00_0x17ae40; // 0x17aee0 - g_ps2RecompiledFunctionTable[125879] = bhEne01_MVType00_0x17ae40; // 0x17aee4 - g_ps2RecompiledFunctionTable[125880] = bhEne01_MVType00_0x17ae40; // 0x17aee8 - g_ps2RecompiledFunctionTable[125881] = bhEne01_MVType00_0x17ae40; // 0x17aeec - g_ps2RecompiledFunctionTable[125882] = bhEne01_MVType00_0x17ae40; // 0x17aef0 - g_ps2RecompiledFunctionTable[125883] = bhEne01_MVType00_0x17ae40; // 0x17aef4 - g_ps2RecompiledFunctionTable[125884] = bhEne01_MVType00_0x17ae40; // 0x17aef8 - g_ps2RecompiledFunctionTable[125885] = bhEne01_MVType00_0x17ae40; // 0x17aefc - g_ps2RecompiledFunctionTable[125886] = bhEne01_MVType00_0x17ae40; // 0x17af00 - g_ps2RecompiledFunctionTable[125887] = bhEne01_MVType00_0x17ae40; // 0x17af04 - g_ps2RecompiledFunctionTable[125888] = bhEne01_MVType00_0x17ae40; // 0x17af08 - g_ps2RecompiledFunctionTable[125889] = bhEne01_MVType00_0x17ae40; // 0x17af0c - g_ps2RecompiledFunctionTable[125890] = bhEne01_MVType00_0x17ae40; // 0x17af10 - g_ps2RecompiledFunctionTable[125891] = bhEne01_MVType00_0x17ae40; // 0x17af14 - g_ps2RecompiledFunctionTable[125894] = bhEne01_MVType02_0x17af20; // 0x17af20 - g_ps2RecompiledFunctionTable[125895] = bhEne01_MVType02_0x17af20; // 0x17af24 - g_ps2RecompiledFunctionTable[125896] = bhEne01_MVType02_0x17af20; // 0x17af28 - g_ps2RecompiledFunctionTable[125897] = bhEne01_MVType02_0x17af20; // 0x17af2c - g_ps2RecompiledFunctionTable[125898] = bhEne01_MVType02_0x17af20; // 0x17af30 - g_ps2RecompiledFunctionTable[125899] = bhEne01_MVType02_0x17af20; // 0x17af34 - g_ps2RecompiledFunctionTable[125900] = bhEne01_MVType02_0x17af20; // 0x17af38 - g_ps2RecompiledFunctionTable[125901] = bhEne01_MVType02_0x17af20; // 0x17af3c - g_ps2RecompiledFunctionTable[125902] = bhEne01_MVType02_0x17af20; // 0x17af40 - g_ps2RecompiledFunctionTable[125903] = bhEne01_MVType02_0x17af20; // 0x17af44 - g_ps2RecompiledFunctionTable[125904] = bhEne01_MVType02_0x17af20; // 0x17af48 - g_ps2RecompiledFunctionTable[125905] = bhEne01_MVType02_0x17af20; // 0x17af4c - g_ps2RecompiledFunctionTable[125906] = bhEne01_MVType02_0x17af20; // 0x17af50 - g_ps2RecompiledFunctionTable[125907] = bhEne01_MVType02_0x17af20; // 0x17af54 - g_ps2RecompiledFunctionTable[125908] = bhEne01_MVType02_0x17af20; // 0x17af58 - g_ps2RecompiledFunctionTable[125909] = bhEne01_MVType02_0x17af20; // 0x17af5c - g_ps2RecompiledFunctionTable[125910] = bhEne01_MVType02_0x17af20; // 0x17af60 - g_ps2RecompiledFunctionTable[125911] = bhEne01_MVType02_0x17af20; // 0x17af64 - g_ps2RecompiledFunctionTable[125912] = bhEne01_MVType02_0x17af20; // 0x17af68 - g_ps2RecompiledFunctionTable[125913] = bhEne01_MVType02_0x17af20; // 0x17af6c - g_ps2RecompiledFunctionTable[125914] = bhEne01_MVType02_0x17af20; // 0x17af70 - g_ps2RecompiledFunctionTable[125915] = bhEne01_MVType02_0x17af20; // 0x17af74 - g_ps2RecompiledFunctionTable[125916] = bhEne01_MVType02_0x17af20; // 0x17af78 - g_ps2RecompiledFunctionTable[125917] = bhEne01_MVType02_0x17af20; // 0x17af7c - g_ps2RecompiledFunctionTable[125918] = bhEne01_MVType02_0x17af20; // 0x17af80 - g_ps2RecompiledFunctionTable[125919] = bhEne01_MVType02_0x17af20; // 0x17af84 - g_ps2RecompiledFunctionTable[125920] = bhEne01_MVType02_0x17af20; // 0x17af88 - g_ps2RecompiledFunctionTable[125921] = bhEne01_MVType02_0x17af20; // 0x17af8c - g_ps2RecompiledFunctionTable[125922] = bhEne01_MVType02_0x17af20; // 0x17af90 - g_ps2RecompiledFunctionTable[125923] = bhEne01_MVType02_0x17af20; // 0x17af94 - g_ps2RecompiledFunctionTable[125924] = bhEne01_MVType02_0x17af20; // 0x17af98 - g_ps2RecompiledFunctionTable[125925] = bhEne01_MVType02_0x17af20; // 0x17af9c - g_ps2RecompiledFunctionTable[125926] = bhEne01_MVType02_0x17af20; // 0x17afa0 - g_ps2RecompiledFunctionTable[125927] = bhEne01_MVType02_0x17af20; // 0x17afa4 - g_ps2RecompiledFunctionTable[125928] = bhEne01_MVType02_0x17af20; // 0x17afa8 - g_ps2RecompiledFunctionTable[125929] = bhEne01_MVType02_0x17af20; // 0x17afac - g_ps2RecompiledFunctionTable[125930] = bhEne01_MVType02_0x17af20; // 0x17afb0 - g_ps2RecompiledFunctionTable[125931] = bhEne01_MVType02_0x17af20; // 0x17afb4 - g_ps2RecompiledFunctionTable[125932] = bhEne01_MVType02_0x17af20; // 0x17afb8 - g_ps2RecompiledFunctionTable[125933] = bhEne01_MVType02_0x17af20; // 0x17afbc - g_ps2RecompiledFunctionTable[125934] = bhEne01_MVType02_0x17af20; // 0x17afc0 - g_ps2RecompiledFunctionTable[125935] = bhEne01_MVType02_0x17af20; // 0x17afc4 - g_ps2RecompiledFunctionTable[125936] = bhEne01_MVType02_0x17af20; // 0x17afc8 - g_ps2RecompiledFunctionTable[125937] = bhEne01_MVType02_0x17af20; // 0x17afcc - g_ps2RecompiledFunctionTable[125938] = bhEne01_MVType02_0x17af20; // 0x17afd0 - g_ps2RecompiledFunctionTable[125939] = bhEne01_MVType02_0x17af20; // 0x17afd4 - g_ps2RecompiledFunctionTable[125940] = bhEne01_MVType02_0x17af20; // 0x17afd8 - g_ps2RecompiledFunctionTable[125941] = bhEne01_MVType02_0x17af20; // 0x17afdc - g_ps2RecompiledFunctionTable[125942] = bhEne01_MVType02_0x17af20; // 0x17afe0 - g_ps2RecompiledFunctionTable[125943] = bhEne01_MVType02_0x17af20; // 0x17afe4 - g_ps2RecompiledFunctionTable[125944] = bhEne01_MVType02_0x17af20; // 0x17afe8 - g_ps2RecompiledFunctionTable[125945] = bhEne01_MVType02_0x17af20; // 0x17afec - g_ps2RecompiledFunctionTable[125946] = bhEne01_MVType02_0x17af20; // 0x17aff0 - g_ps2RecompiledFunctionTable[125947] = bhEne01_MVType02_0x17af20; // 0x17aff4 - g_ps2RecompiledFunctionTable[125948] = bhEne01_MVType02_0x17af20; // 0x17aff8 - g_ps2RecompiledFunctionTable[125949] = bhEne01_MVType02_0x17af20; // 0x17affc - g_ps2RecompiledFunctionTable[125950] = bhEne01_MVType02_0x17af20; // 0x17b000 - g_ps2RecompiledFunctionTable[125951] = bhEne01_MVType02_0x17af20; // 0x17b004 - g_ps2RecompiledFunctionTable[125952] = bhEne01_MVType02_0x17af20; // 0x17b008 - g_ps2RecompiledFunctionTable[125953] = bhEne01_MVType02_0x17af20; // 0x17b00c - g_ps2RecompiledFunctionTable[125954] = bhEne01_MVType02_0x17af20; // 0x17b010 - g_ps2RecompiledFunctionTable[125955] = bhEne01_MVType02_0x17af20; // 0x17b014 - g_ps2RecompiledFunctionTable[125956] = bhEne01_MVType02_0x17af20; // 0x17b018 - g_ps2RecompiledFunctionTable[125957] = bhEne01_MVType02_0x17af20; // 0x17b01c - g_ps2RecompiledFunctionTable[125958] = bhEne01_MVType02_0x17af20; // 0x17b020 - g_ps2RecompiledFunctionTable[125959] = bhEne01_MVType02_0x17af20; // 0x17b024 - g_ps2RecompiledFunctionTable[125960] = bhEne01_MVType02_0x17af20; // 0x17b028 - g_ps2RecompiledFunctionTable[125961] = bhEne01_MVType02_0x17af20; // 0x17b02c - g_ps2RecompiledFunctionTable[125962] = bhEne01_MVType02_0x17af20; // 0x17b030 - g_ps2RecompiledFunctionTable[125963] = bhEne01_MVType02_0x17af20; // 0x17b034 - g_ps2RecompiledFunctionTable[125964] = bhEne01_MVType02_0x17af20; // 0x17b038 - g_ps2RecompiledFunctionTable[125965] = bhEne01_MVType02_0x17af20; // 0x17b03c - g_ps2RecompiledFunctionTable[125966] = bhEne01_MVType02_0x17af20; // 0x17b040 - g_ps2RecompiledFunctionTable[125967] = bhEne01_MVType02_0x17af20; // 0x17b044 - g_ps2RecompiledFunctionTable[125968] = bhEne01_MVType02_0x17af20; // 0x17b048 - g_ps2RecompiledFunctionTable[125969] = bhEne01_MVType02_0x17af20; // 0x17b04c - g_ps2RecompiledFunctionTable[125970] = bhEne01_MVType02_0x17af20; // 0x17b050 - g_ps2RecompiledFunctionTable[125971] = bhEne01_MVType02_0x17af20; // 0x17b054 - g_ps2RecompiledFunctionTable[125972] = bhEne01_MVType02_0x17af20; // 0x17b058 - g_ps2RecompiledFunctionTable[125973] = bhEne01_MVType02_0x17af20; // 0x17b05c - g_ps2RecompiledFunctionTable[125974] = bhEne01_MVType02_0x17af20; // 0x17b060 - g_ps2RecompiledFunctionTable[125975] = bhEne01_MVType02_0x17af20; // 0x17b064 - g_ps2RecompiledFunctionTable[125976] = bhEne01_MVType02_0x17af20; // 0x17b068 - g_ps2RecompiledFunctionTable[125977] = bhEne01_MVType02_0x17af20; // 0x17b06c - g_ps2RecompiledFunctionTable[125978] = bhEne01_MVType02_0x17af20; // 0x17b070 - g_ps2RecompiledFunctionTable[125979] = bhEne01_MVType02_0x17af20; // 0x17b074 - g_ps2RecompiledFunctionTable[125980] = bhEne01_MVType02_0x17af20; // 0x17b078 - g_ps2RecompiledFunctionTable[125981] = bhEne01_MVType02_0x17af20; // 0x17b07c - g_ps2RecompiledFunctionTable[125982] = bhEne01_MVType02_0x17af20; // 0x17b080 - g_ps2RecompiledFunctionTable[125983] = bhEne01_MVType02_0x17af20; // 0x17b084 - g_ps2RecompiledFunctionTable[125984] = bhEne01_MVType02_0x17af20; // 0x17b088 - g_ps2RecompiledFunctionTable[125985] = bhEne01_MVType02_0x17af20; // 0x17b08c - g_ps2RecompiledFunctionTable[125986] = bhEne01_MVType02_0x17af20; // 0x17b090 - g_ps2RecompiledFunctionTable[125987] = bhEne01_MVType02_0x17af20; // 0x17b094 - g_ps2RecompiledFunctionTable[125990] = bhEne01_MV00_0x17b0a0; // 0x17b0a0 - g_ps2RecompiledFunctionTable[126019] = bhEne01_MV00_0x17b0a0; // 0x17b114 - g_ps2RecompiledFunctionTable[126029] = bhEne01_MV00_0x17b0a0; // 0x17b13c - g_ps2RecompiledFunctionTable[126042] = bhEne01_MV00_0x17b0a0; // 0x17b170 - g_ps2RecompiledFunctionTable[126055] = bhEne01_MV00_0x17b0a0; // 0x17b1a4 - g_ps2RecompiledFunctionTable[126081] = bhEne01_MV00_0x17b0a0; // 0x17b20c - g_ps2RecompiledFunctionTable[126155] = bhEne01_MV00_0x17b0a0; // 0x17b334 - g_ps2RecompiledFunctionTable[126157] = bhEne01_MV00_0x17b0a0; // 0x17b33c - g_ps2RecompiledFunctionTable[126170] = bhEne01_MV01_0x17b370; // 0x17b370 - g_ps2RecompiledFunctionTable[126197] = bhEne01_MV01_0x17b370; // 0x17b3dc - g_ps2RecompiledFunctionTable[126209] = bhEne01_MV01_0x17b370; // 0x17b40c - g_ps2RecompiledFunctionTable[126228] = bhEne01_MV01_0x17b370; // 0x17b458 - g_ps2RecompiledFunctionTable[126246] = bhEne01_MV01_0x17b370; // 0x17b4a0 - g_ps2RecompiledFunctionTable[126259] = bhEne01_MV01_0x17b370; // 0x17b4d4 - g_ps2RecompiledFunctionTable[126268] = bhEne01_MV01_0x17b370; // 0x17b4f8 - g_ps2RecompiledFunctionTable[126325] = bhEne01_MV01_0x17b370; // 0x17b5dc - g_ps2RecompiledFunctionTable[126338] = bhEne01_MV01_0x17b370; // 0x17b610 - g_ps2RecompiledFunctionTable[126351] = bhEne01_MV01_0x17b370; // 0x17b644 - g_ps2RecompiledFunctionTable[126358] = bhEne01_MV01_0x17b370; // 0x17b660 - g_ps2RecompiledFunctionTable[126367] = bhEne01_MV01_0x17b370; // 0x17b684 - g_ps2RecompiledFunctionTable[126447] = bhEne01_MV01_0x17b370; // 0x17b7c4 - g_ps2RecompiledFunctionTable[126471] = bhEne01_MV01_0x17b370; // 0x17b824 - g_ps2RecompiledFunctionTable[126478] = bhEne01_MV01_0x17b370; // 0x17b840 - g_ps2RecompiledFunctionTable[126494] = bhEne01_MV01_0x17b370; // 0x17b880 - g_ps2RecompiledFunctionTable[126496] = bhEne01_MV01_0x17b370; // 0x17b888 - g_ps2RecompiledFunctionTable[126510] = bhEne01_MV02_0x17b8c0; // 0x17b8c0 - g_ps2RecompiledFunctionTable[126536] = bhEne01_MV02_0x17b8c0; // 0x17b928 - g_ps2RecompiledFunctionTable[126554] = bhEne01_MV02_0x17b8c0; // 0x17b970 - g_ps2RecompiledFunctionTable[126569] = bhEne01_MV02_0x17b8c0; // 0x17b9ac - g_ps2RecompiledFunctionTable[126581] = bhEne01_MV02_0x17b8c0; // 0x17b9dc - g_ps2RecompiledFunctionTable[126613] = bhEne01_MV02_0x17b8c0; // 0x17ba5c - g_ps2RecompiledFunctionTable[126630] = bhEne01_MV02_0x17b8c0; // 0x17baa0 - g_ps2RecompiledFunctionTable[126642] = bhEne01_MV02_0x17b8c0; // 0x17bad0 - g_ps2RecompiledFunctionTable[126661] = bhEne01_MV02_0x17b8c0; // 0x17bb1c - g_ps2RecompiledFunctionTable[126669] = bhEne01_MV02_0x17b8c0; // 0x17bb3c - g_ps2RecompiledFunctionTable[126682] = bhEne01_MV02_0x17b8c0; // 0x17bb70 - g_ps2RecompiledFunctionTable[126724] = bhEne01_MV02_0x17b8c0; // 0x17bc18 - g_ps2RecompiledFunctionTable[126735] = bhEne01_MV02_0x17b8c0; // 0x17bc44 - g_ps2RecompiledFunctionTable[126751] = bhEne01_MV02_0x17b8c0; // 0x17bc84 - g_ps2RecompiledFunctionTable[126759] = bhEne01_MV02_0x17b8c0; // 0x17bca4 - g_ps2RecompiledFunctionTable[126765] = bhEne01_MV02_0x17b8c0; // 0x17bcbc - g_ps2RecompiledFunctionTable[126791] = bhEne01_MV02_0x17b8c0; // 0x17bd24 - g_ps2RecompiledFunctionTable[126810] = bhEne01_MV02_0x17b8c0; // 0x17bd70 - g_ps2RecompiledFunctionTable[126821] = bhEne01_MV02_0x17b8c0; // 0x17bd9c - g_ps2RecompiledFunctionTable[126833] = bhEne01_MV02_0x17b8c0; // 0x17bdcc - g_ps2RecompiledFunctionTable[126882] = bhEne01_MV02_0x17b8c0; // 0x17be90 - g_ps2RecompiledFunctionTable[126944] = bhEne01_MV02_0x17b8c0; // 0x17bf88 - g_ps2RecompiledFunctionTable[126967] = bhEne01_MV02_0x17b8c0; // 0x17bfe4 - g_ps2RecompiledFunctionTable[126976] = bhEne01_MV02_0x17b8c0; // 0x17c008 - g_ps2RecompiledFunctionTable[126978] = bhEne01_MV02_0x17b8c0; // 0x17c010 - g_ps2RecompiledFunctionTable[126990] = bhEne01_MV03_0x17c040; // 0x17c040 - g_ps2RecompiledFunctionTable[127009] = bhEne01_MV03_0x17c040; // 0x17c08c - g_ps2RecompiledFunctionTable[127022] = bhEne01_MV03_0x17c040; // 0x17c0c0 - g_ps2RecompiledFunctionTable[127042] = bhEne01_MV03_0x17c040; // 0x17c110 - g_ps2RecompiledFunctionTable[127052] = bhEne01_MV03_0x17c040; // 0x17c138 - g_ps2RecompiledFunctionTable[127075] = bhEne01_MV03_0x17c040; // 0x17c194 - g_ps2RecompiledFunctionTable[127082] = bhEne01_MV03_0x17c040; // 0x17c1b0 - g_ps2RecompiledFunctionTable[127087] = bhEne01_MV03_0x17c040; // 0x17c1c4 - g_ps2RecompiledFunctionTable[127093] = bhEne01_MV03_0x17c040; // 0x17c1dc - g_ps2RecompiledFunctionTable[127099] = bhEne01_MV03_0x17c040; // 0x17c1f4 - g_ps2RecompiledFunctionTable[127105] = bhEne01_MV03_0x17c040; // 0x17c20c - g_ps2RecompiledFunctionTable[127137] = bhEne01_MV03_0x17c040; // 0x17c28c - g_ps2RecompiledFunctionTable[127178] = bhEne01_MV04_0x17c330; // 0x17c330 - g_ps2RecompiledFunctionTable[127350] = bhEne01_MV04_0x17c330; // 0x17c5e0 - g_ps2RecompiledFunctionTable[127358] = bhEne01_MV04_0x17c330; // 0x17c600 - g_ps2RecompiledFunctionTable[127369] = bhEne01_MV04_0x17c330; // 0x17c62c - g_ps2RecompiledFunctionTable[127386] = bhEne01_MV04_0x17c330; // 0x17c670 - g_ps2RecompiledFunctionTable[127410] = bhEne01_MV04_0x17c330; // 0x17c6d0 - g_ps2RecompiledFunctionTable[127433] = bhEne01_MV04_0x17c330; // 0x17c72c - g_ps2RecompiledFunctionTable[127436] = bhEne01_MV04_0x17c330; // 0x17c738 - g_ps2RecompiledFunctionTable[127440] = bhEne01_MV04_0x17c330; // 0x17c748 - g_ps2RecompiledFunctionTable[127445] = bhEne01_MV04_0x17c330; // 0x17c75c - g_ps2RecompiledFunctionTable[127448] = bhEne01_MV04_0x17c330; // 0x17c768 - g_ps2RecompiledFunctionTable[127453] = bhEne01_MV04_0x17c330; // 0x17c77c - g_ps2RecompiledFunctionTable[127459] = bhEne01_MV04_0x17c330; // 0x17c794 - g_ps2RecompiledFunctionTable[127473] = bhEne01_MV04_0x17c330; // 0x17c7cc - g_ps2RecompiledFunctionTable[127479] = bhEne01_MV04_0x17c330; // 0x17c7e4 - g_ps2RecompiledFunctionTable[127544] = bhEne01_MV04_0x17c330; // 0x17c8e8 - g_ps2RecompiledFunctionTable[127615] = bhEne01_MV04_0x17c330; // 0x17ca04 - g_ps2RecompiledFunctionTable[127810] = bhEne01_MV04_0x17c330; // 0x17cd10 - g_ps2RecompiledFunctionTable[127826] = bhEne01_MV04_0x17c330; // 0x17cd50 - g_ps2RecompiledFunctionTable[127849] = bhEne01_MV04_0x17c330; // 0x17cdac - g_ps2RecompiledFunctionTable[127865] = bhEne01_MV04_0x17c330; // 0x17cdec - g_ps2RecompiledFunctionTable[127881] = bhEne01_MV04_0x17c330; // 0x17ce2c - g_ps2RecompiledFunctionTable[127889] = bhEne01_MV04_0x17c330; // 0x17ce4c - g_ps2RecompiledFunctionTable[127911] = bhEne01_MV04_0x17c330; // 0x17cea4 - g_ps2RecompiledFunctionTable[127931] = bhEne01_MV04_0x17c330; // 0x17cef4 - g_ps2RecompiledFunctionTable[127934] = bhEne01_MV04_0x17c330; // 0x17cf00 - g_ps2RecompiledFunctionTable[127938] = bhEne01_MV04_0x17c330; // 0x17cf10 - g_ps2RecompiledFunctionTable[127943] = bhEne01_MV04_0x17c330; // 0x17cf24 - g_ps2RecompiledFunctionTable[127946] = bhEne01_MV04_0x17c330; // 0x17cf30 - g_ps2RecompiledFunctionTable[127951] = bhEne01_MV04_0x17c330; // 0x17cf44 - g_ps2RecompiledFunctionTable[127957] = bhEne01_MV04_0x17c330; // 0x17cf5c - g_ps2RecompiledFunctionTable[127971] = bhEne01_MV04_0x17c330; // 0x17cf94 - g_ps2RecompiledFunctionTable[127977] = bhEne01_MV04_0x17c330; // 0x17cfac - g_ps2RecompiledFunctionTable[128028] = bhEne01_MV04_0x17c330; // 0x17d078 - g_ps2RecompiledFunctionTable[128040] = bhEne01_MV04_0x17c330; // 0x17d0a8 - g_ps2RecompiledFunctionTable[128083] = bhEne01_MV04_0x17c330; // 0x17d154 - g_ps2RecompiledFunctionTable[128098] = bhEne01_MV04_0x17c330; // 0x17d190 - g_ps2RecompiledFunctionTable[128114] = bhEne01_MV04_0x17c330; // 0x17d1d0 - g_ps2RecompiledFunctionTable[128128] = bhEne01_MV04_0x17c330; // 0x17d208 - g_ps2RecompiledFunctionTable[128190] = bhEne01_MV05_0x17d300; // 0x17d300 - g_ps2RecompiledFunctionTable[128215] = bhEne01_MV05_0x17d300; // 0x17d364 - g_ps2RecompiledFunctionTable[128232] = bhEne01_MV05_0x17d300; // 0x17d3a8 - g_ps2RecompiledFunctionTable[128250] = bhEne01_MV05_0x17d300; // 0x17d3f0 - g_ps2RecompiledFunctionTable[128264] = bhEne01_MV05_0x17d300; // 0x17d428 - g_ps2RecompiledFunctionTable[128280] = bhEne01_MV05_0x17d300; // 0x17d468 - g_ps2RecompiledFunctionTable[128302] = bhEne01_MV05_0x17d300; // 0x17d4c0 - g_ps2RecompiledFunctionTable[128332] = bhEne01_MV05_0x17d300; // 0x17d538 - g_ps2RecompiledFunctionTable[128358] = bhEne01_MV05_0x17d300; // 0x17d5a0 - g_ps2RecompiledFunctionTable[128370] = bhEne01_MV05_0x17d300; // 0x17d5d0 - g_ps2RecompiledFunctionTable[128382] = bhEne01_MV05_0x17d300; // 0x17d600 - g_ps2RecompiledFunctionTable[128394] = bhEne01_MV05_0x17d300; // 0x17d630 - g_ps2RecompiledFunctionTable[128405] = bhEne01_MV05_0x17d300; // 0x17d65c - g_ps2RecompiledFunctionTable[128470] = bhEne01_MV06_0x17d760; // 0x17d760 - g_ps2RecompiledFunctionTable[128487] = bhEne01_MV06_0x17d760; // 0x17d7a4 - g_ps2RecompiledFunctionTable[128499] = bhEne01_MV06_0x17d760; // 0x17d7d4 - g_ps2RecompiledFunctionTable[128510] = bhEne01_MV06_0x17d760; // 0x17d800 - g_ps2RecompiledFunctionTable[128528] = bhEne01_MV06_0x17d760; // 0x17d848 - g_ps2RecompiledFunctionTable[128543] = bhEne01_MV06_0x17d760; // 0x17d884 - g_ps2RecompiledFunctionTable[128574] = bhEne01_MV07_0x17d900; // 0x17d900 - g_ps2RecompiledFunctionTable[128591] = bhEne01_MV07_0x17d900; // 0x17d944 - g_ps2RecompiledFunctionTable[128603] = bhEne01_MV07_0x17d900; // 0x17d974 - g_ps2RecompiledFunctionTable[128616] = bhEne01_MV07_0x17d900; // 0x17d9a8 - g_ps2RecompiledFunctionTable[128694] = bhEne01_MV08_0x17dae0; // 0x17dae0 - g_ps2RecompiledFunctionTable[128716] = bhEne01_MV08_0x17dae0; // 0x17db38 - g_ps2RecompiledFunctionTable[128728] = bhEne01_MV08_0x17dae0; // 0x17db68 - g_ps2RecompiledFunctionTable[128884] = bhEne01_MV08_0x17dae0; // 0x17ddd8 - g_ps2RecompiledFunctionTable[128901] = bhEne01_MV08_0x17dae0; // 0x17de1c - g_ps2RecompiledFunctionTable[128968] = bhEne01_MV08_0x17dae0; // 0x17df28 - g_ps2RecompiledFunctionTable[128985] = bhEne01_MV08_0x17dae0; // 0x17df6c - g_ps2RecompiledFunctionTable[129116] = bhEne01_MV08_0x17dae0; // 0x17e178 - g_ps2RecompiledFunctionTable[129133] = bhEne01_MV08_0x17dae0; // 0x17e1bc - g_ps2RecompiledFunctionTable[129192] = bhEne01_MV08_0x17dae0; // 0x17e2a8 - g_ps2RecompiledFunctionTable[129214] = bhEne01_MV08_0x17dae0; // 0x17e300 - g_ps2RecompiledFunctionTable[129232] = bhEne01_MV08_0x17dae0; // 0x17e348 - g_ps2RecompiledFunctionTable[129248] = bhEne01_MV08_0x17dae0; // 0x17e388 - g_ps2RecompiledFunctionTable[129290] = bhEne01_MV09_0x17e430; // 0x17e430 - g_ps2RecompiledFunctionTable[129310] = bhEne01_MV09_0x17e430; // 0x17e480 - g_ps2RecompiledFunctionTable[129326] = bhEne01_MV09_0x17e430; // 0x17e4c0 - g_ps2RecompiledFunctionTable[129355] = bhEne01_MV09_0x17e430; // 0x17e534 - g_ps2RecompiledFunctionTable[129368] = bhEne01_MV09_0x17e430; // 0x17e568 - g_ps2RecompiledFunctionTable[129384] = bhEne01_MV09_0x17e430; // 0x17e5a8 - g_ps2RecompiledFunctionTable[129392] = bhEne01_MV09_0x17e430; // 0x17e5c8 - g_ps2RecompiledFunctionTable[129418] = bhEne01_MV10_0x17e630; // 0x17e630 - g_ps2RecompiledFunctionTable[129435] = bhEne01_MV10_0x17e630; // 0x17e674 - g_ps2RecompiledFunctionTable[129447] = bhEne01_MV10_0x17e630; // 0x17e6a4 - g_ps2RecompiledFunctionTable[129455] = bhEne01_MV10_0x17e630; // 0x17e6c4 - g_ps2RecompiledFunctionTable[129465] = bhEne01_MV10_0x17e630; // 0x17e6ec - g_ps2RecompiledFunctionTable[129506] = bhEne01_MV11_0x17e790; // 0x17e790 - g_ps2RecompiledFunctionTable[129522] = bhEne01_MV11_0x17e790; // 0x17e7d0 - g_ps2RecompiledFunctionTable[129539] = bhEne01_MV11_0x17e790; // 0x17e814 - g_ps2RecompiledFunctionTable[129560] = bhEne01_MV11_0x17e790; // 0x17e868 - g_ps2RecompiledFunctionTable[129570] = bhEne01_MV11_0x17e790; // 0x17e890 - g_ps2RecompiledFunctionTable[129578] = bhEne01_MV11_0x17e790; // 0x17e8b0 - g_ps2RecompiledFunctionTable[129587] = bhEne01_MV11_0x17e790; // 0x17e8d4 - g_ps2RecompiledFunctionTable[129666] = bhEne01_MV12_0x17ea10; // 0x17ea10 - g_ps2RecompiledFunctionTable[129683] = bhEne01_MV12_0x17ea10; // 0x17ea54 - g_ps2RecompiledFunctionTable[129700] = bhEne01_MV12_0x17ea10; // 0x17ea98 - g_ps2RecompiledFunctionTable[129754] = bhEne01_MV14_0x17eb70; // 0x17eb70 - g_ps2RecompiledFunctionTable[129779] = bhEne01_MV14_0x17eb70; // 0x17ebd4 - g_ps2RecompiledFunctionTable[129792] = bhEne01_MV14_0x17eb70; // 0x17ec08 - g_ps2RecompiledFunctionTable[129804] = bhEne01_MV14_0x17eb70; // 0x17ec38 - g_ps2RecompiledFunctionTable[129816] = bhEne01_MV14_0x17eb70; // 0x17ec68 - g_ps2RecompiledFunctionTable[129830] = bhEne01_MV15_0x17eca0; // 0x17eca0 - g_ps2RecompiledFunctionTable[129863] = bhEne01_MV15_0x17eca0; // 0x17ed24 - g_ps2RecompiledFunctionTable[129875] = bhEne01_MV15_0x17eca0; // 0x17ed54 - g_ps2RecompiledFunctionTable[129889] = bhEne01_MV15_0x17eca0; // 0x17ed8c - g_ps2RecompiledFunctionTable[129906] = bhEne01_MV15_0x17eca0; // 0x17edd0 - g_ps2RecompiledFunctionTable[129964] = bhEne01_MV15_0x17eca0; // 0x17eeb8 - g_ps2RecompiledFunctionTable[129981] = bhEne01_MV15_0x17eca0; // 0x17eefc - g_ps2RecompiledFunctionTable[130024] = bhEne01_MV15_0x17eca0; // 0x17efa8 - g_ps2RecompiledFunctionTable[130040] = bhEne01_MV15_0x17eca0; // 0x17efe8 - g_ps2RecompiledFunctionTable[130075] = bhEne01_MV15_0x17eca0; // 0x17f074 - g_ps2RecompiledFunctionTable[130088] = bhEne01_MV15_0x17eca0; // 0x17f0a8 - g_ps2RecompiledFunctionTable[130110] = bhEne01_MV16_0x17f100; // 0x17f100 - g_ps2RecompiledFunctionTable[130133] = bhEne01_MV16_0x17f100; // 0x17f15c - g_ps2RecompiledFunctionTable[130141] = bhEne01_MV16_0x17f100; // 0x17f17c - g_ps2RecompiledFunctionTable[130158] = bhEne01_MV16_0x17f100; // 0x17f1c0 - g_ps2RecompiledFunctionTable[130182] = bhEne01_MV16_0x17f100; // 0x17f220 - g_ps2RecompiledFunctionTable[130194] = bhEne01_MV16_0x17f100; // 0x17f250 - g_ps2RecompiledFunctionTable[130210] = bhEne01_NGType00_0x17f290; // 0x17f290 - g_ps2RecompiledFunctionTable[130211] = bhEne01_NGType00_0x17f290; // 0x17f294 - g_ps2RecompiledFunctionTable[130212] = bhEne01_NGType00_0x17f290; // 0x17f298 - g_ps2RecompiledFunctionTable[130213] = bhEne01_NGType00_0x17f290; // 0x17f29c - g_ps2RecompiledFunctionTable[130214] = bhEne01_NGType00_0x17f290; // 0x17f2a0 - g_ps2RecompiledFunctionTable[130215] = bhEne01_NGType00_0x17f290; // 0x17f2a4 - g_ps2RecompiledFunctionTable[130216] = bhEne01_NGType00_0x17f290; // 0x17f2a8 - g_ps2RecompiledFunctionTable[130217] = bhEne01_NGType00_0x17f290; // 0x17f2ac - g_ps2RecompiledFunctionTable[130218] = bhEne01_NGType00_0x17f290; // 0x17f2b0 - g_ps2RecompiledFunctionTable[130219] = bhEne01_NGType00_0x17f290; // 0x17f2b4 - g_ps2RecompiledFunctionTable[130220] = bhEne01_NGType00_0x17f290; // 0x17f2b8 - g_ps2RecompiledFunctionTable[130221] = bhEne01_NGType00_0x17f290; // 0x17f2bc - g_ps2RecompiledFunctionTable[130222] = bhEne01_NGType00_0x17f290; // 0x17f2c0 - g_ps2RecompiledFunctionTable[130223] = bhEne01_NGType00_0x17f290; // 0x17f2c4 - g_ps2RecompiledFunctionTable[130224] = bhEne01_NGType00_0x17f290; // 0x17f2c8 - g_ps2RecompiledFunctionTable[130225] = bhEne01_NGType00_0x17f290; // 0x17f2cc - g_ps2RecompiledFunctionTable[130226] = bhEne01_NGType00_0x17f290; // 0x17f2d0 - g_ps2RecompiledFunctionTable[130227] = bhEne01_NGType00_0x17f290; // 0x17f2d4 - g_ps2RecompiledFunctionTable[130228] = bhEne01_NGType00_0x17f290; // 0x17f2d8 - g_ps2RecompiledFunctionTable[130229] = bhEne01_NGType00_0x17f290; // 0x17f2dc - g_ps2RecompiledFunctionTable[130230] = bhEne01_NGType00_0x17f290; // 0x17f2e0 - g_ps2RecompiledFunctionTable[130231] = bhEne01_NGType00_0x17f290; // 0x17f2e4 - g_ps2RecompiledFunctionTable[130232] = bhEne01_NGType00_0x17f290; // 0x17f2e8 - g_ps2RecompiledFunctionTable[130233] = bhEne01_NGType00_0x17f290; // 0x17f2ec - g_ps2RecompiledFunctionTable[130234] = bhEne01_NGType00_0x17f290; // 0x17f2f0 - g_ps2RecompiledFunctionTable[130235] = bhEne01_NGType00_0x17f290; // 0x17f2f4 - g_ps2RecompiledFunctionTable[130236] = bhEne01_NGType00_0x17f290; // 0x17f2f8 - g_ps2RecompiledFunctionTable[130237] = bhEne01_NGType00_0x17f290; // 0x17f2fc - g_ps2RecompiledFunctionTable[130238] = bhEne01_NGType00_0x17f290; // 0x17f300 - g_ps2RecompiledFunctionTable[130239] = bhEne01_NGType00_0x17f290; // 0x17f304 - g_ps2RecompiledFunctionTable[130240] = bhEne01_NGType00_0x17f290; // 0x17f308 - g_ps2RecompiledFunctionTable[130241] = bhEne01_NGType00_0x17f290; // 0x17f30c - g_ps2RecompiledFunctionTable[130242] = bhEne01_NGType00_0x17f290; // 0x17f310 - g_ps2RecompiledFunctionTable[130243] = bhEne01_NGType00_0x17f290; // 0x17f314 - g_ps2RecompiledFunctionTable[130244] = bhEne01_NGType00_0x17f290; // 0x17f318 - g_ps2RecompiledFunctionTable[130246] = bhEne01_NG00_0x17f320; // 0x17f320 - g_ps2RecompiledFunctionTable[130279] = bhEne01_NG00_0x17f320; // 0x17f3a4 - g_ps2RecompiledFunctionTable[130291] = bhEne01_NG00_0x17f320; // 0x17f3d4 - g_ps2RecompiledFunctionTable[130303] = bhEne01_NG00_0x17f320; // 0x17f404 - g_ps2RecompiledFunctionTable[130315] = bhEne01_NG00_0x17f320; // 0x17f434 - g_ps2RecompiledFunctionTable[130326] = bhEne01_NG00_0x17f320; // 0x17f460 - g_ps2RecompiledFunctionTable[130376] = bhEne01_NG00_0x17f320; // 0x17f528 - g_ps2RecompiledFunctionTable[130381] = bhEne01_NG00_0x17f320; // 0x17f53c - g_ps2RecompiledFunctionTable[130384] = bhEne01_NG00_0x17f320; // 0x17f548 - g_ps2RecompiledFunctionTable[130388] = bhEne01_NG00_0x17f320; // 0x17f558 - g_ps2RecompiledFunctionTable[130441] = bhEne01_NG00_0x17f320; // 0x17f62c - g_ps2RecompiledFunctionTable[130461] = bhEne01_NG00_0x17f320; // 0x17f67c - g_ps2RecompiledFunctionTable[130473] = bhEne01_NG00_0x17f320; // 0x17f6ac - g_ps2RecompiledFunctionTable[130498] = bhEne01_NG00_0x17f320; // 0x17f710 - g_ps2RecompiledFunctionTable[130514] = bhEne01_NG00_0x17f320; // 0x17f750 - g_ps2RecompiledFunctionTable[130554] = bhEne01_NG00_0x17f320; // 0x17f7f0 - g_ps2RecompiledFunctionTable[130562] = bhEne01_NG00_0x17f320; // 0x17f810 - g_ps2RecompiledFunctionTable[130566] = bhEne01_NG00_0x17f320; // 0x17f820 - g_ps2RecompiledFunctionTable[130568] = bhEne01_NG00_0x17f320; // 0x17f828 - g_ps2RecompiledFunctionTable[130580] = bhEne01_NG00_0x17f320; // 0x17f858 - g_ps2RecompiledFunctionTable[130596] = bhEne01_NG00_0x17f320; // 0x17f898 - g_ps2RecompiledFunctionTable[130607] = bhEne01_NG00_0x17f320; // 0x17f8c4 - g_ps2RecompiledFunctionTable[130628] = bhEne01_NG00_0x17f320; // 0x17f918 - g_ps2RecompiledFunctionTable[130635] = bhEne01_NG00_0x17f320; // 0x17f934 - g_ps2RecompiledFunctionTable[130647] = bhEne01_NG00_0x17f320; // 0x17f964 - g_ps2RecompiledFunctionTable[130670] = bhEne01_NG00_0x17f320; // 0x17f9c0 - g_ps2RecompiledFunctionTable[130682] = bhEne01_NG00_0x17f320; // 0x17f9f0 - g_ps2RecompiledFunctionTable[130717] = bhEne01_NG00_0x17f320; // 0x17fa7c - g_ps2RecompiledFunctionTable[130733] = bhEne01_NG00_0x17f320; // 0x17fabc - g_ps2RecompiledFunctionTable[130768] = bhEne01_NG00_0x17f320; // 0x17fb48 - g_ps2RecompiledFunctionTable[130896] = bhEne01_NG00_0x17f320; // 0x17fd48 - g_ps2RecompiledFunctionTable[130918] = bhEne01_NG00_0x17f320; // 0x17fda0 - g_ps2RecompiledFunctionTable[130930] = bhEne01_NG00_0x17f320; // 0x17fdd0 - g_ps2RecompiledFunctionTable[130985] = bhEne01_NG00_0x17f320; // 0x17feac - g_ps2RecompiledFunctionTable[131050] = bhEne01_NG01_0x17ffb0; // 0x17ffb0 - g_ps2RecompiledFunctionTable[131077] = bhEne01_NG01_0x17ffb0; // 0x18001c - g_ps2RecompiledFunctionTable[131093] = bhEne01_NG01_0x17ffb0; // 0x18005c - g_ps2RecompiledFunctionTable[131122] = bhEne01_NG01_0x17ffb0; // 0x1800d0 - g_ps2RecompiledFunctionTable[131130] = bhEne01_NG01_0x17ffb0; // 0x1800f0 - g_ps2RecompiledFunctionTable[131134] = bhEne01_NG01_0x17ffb0; // 0x180100 - g_ps2RecompiledFunctionTable[131136] = bhEne01_NG01_0x17ffb0; // 0x180108 - g_ps2RecompiledFunctionTable[131148] = bhEne01_NG01_0x17ffb0; // 0x180138 - g_ps2RecompiledFunctionTable[131162] = bhEne01_NG01_0x17ffb0; // 0x180170 - g_ps2RecompiledFunctionTable[131175] = bhEne01_NG01_0x17ffb0; // 0x1801a4 - g_ps2RecompiledFunctionTable[131182] = bhEne01_NG01_0x17ffb0; // 0x1801c0 - g_ps2RecompiledFunctionTable[131194] = bhEne01_NG01_0x17ffb0; // 0x1801f0 - g_ps2RecompiledFunctionTable[131217] = bhEne01_NG01_0x17ffb0; // 0x18024c - g_ps2RecompiledFunctionTable[131229] = bhEne01_NG01_0x17ffb0; // 0x18027c - g_ps2RecompiledFunctionTable[131264] = bhEne01_NG01_0x17ffb0; // 0x180308 - g_ps2RecompiledFunctionTable[131280] = bhEne01_NG01_0x17ffb0; // 0x180348 - g_ps2RecompiledFunctionTable[131312] = bhEne01_NG01_0x17ffb0; // 0x1803c8 - g_ps2RecompiledFunctionTable[131455] = bhEne01_NG01_0x17ffb0; // 0x180604 - g_ps2RecompiledFunctionTable[131486] = bhEne01_NG02_0x180680; // 0x180680 - g_ps2RecompiledFunctionTable[131521] = bhEne01_NG02_0x180680; // 0x18070c - g_ps2RecompiledFunctionTable[131533] = bhEne01_NG02_0x180680; // 0x18073c - g_ps2RecompiledFunctionTable[131578] = bhEne01_NG02_0x180680; // 0x1807f0 - g_ps2RecompiledFunctionTable[131583] = bhEne01_NG02_0x180680; // 0x180804 - g_ps2RecompiledFunctionTable[131586] = bhEne01_NG02_0x180680; // 0x180810 - g_ps2RecompiledFunctionTable[131590] = bhEne01_NG02_0x180680; // 0x180820 - g_ps2RecompiledFunctionTable[131644] = bhEne01_NG02_0x180680; // 0x1808f8 - g_ps2RecompiledFunctionTable[131660] = bhEne01_NG02_0x180680; // 0x180938 - g_ps2RecompiledFunctionTable[131672] = bhEne01_NG02_0x180680; // 0x180968 - g_ps2RecompiledFunctionTable[131688] = bhEne01_NG02_0x180680; // 0x1809a8 - g_ps2RecompiledFunctionTable[131719] = bhEne01_NG02_0x180680; // 0x180a24 - g_ps2RecompiledFunctionTable[131726] = bhEne01_NG02_0x180680; // 0x180a40 - g_ps2RecompiledFunctionTable[131730] = bhEne01_NG02_0x180680; // 0x180a50 - g_ps2RecompiledFunctionTable[131748] = bhEne01_NG02_0x180680; // 0x180a98 - g_ps2RecompiledFunctionTable[131755] = bhEne01_NG02_0x180680; // 0x180ab4 - g_ps2RecompiledFunctionTable[131759] = bhEne01_NG02_0x180680; // 0x180ac4 - g_ps2RecompiledFunctionTable[131770] = bhEne01_NG02_0x180680; // 0x180af0 - g_ps2RecompiledFunctionTable[131814] = bhEne01_PlyDG00_0x180ba0; // 0x180ba0 - g_ps2RecompiledFunctionTable[132051] = bhEne01_PlyDG00_0x180ba0; // 0x180f54 - g_ps2RecompiledFunctionTable[132108] = bhEne01_PlyDG00_0x180ba0; // 0x181038 - g_ps2RecompiledFunctionTable[132116] = bhEne01_PlyDG00_0x180ba0; // 0x181058 - g_ps2RecompiledFunctionTable[132322] = bhEne01_PlyDG00_0x180ba0; // 0x181390 - g_ps2RecompiledFunctionTable[132413] = bhEne01_PlyDG00_0x180ba0; // 0x1814fc - g_ps2RecompiledFunctionTable[132432] = bhEne01_PlyDG00_0x180ba0; // 0x181548 - g_ps2RecompiledFunctionTable[132444] = bhEne01_PlyDG00_0x180ba0; // 0x181578 - g_ps2RecompiledFunctionTable[132554] = bhEne01_PlyDG01_0x181730; // 0x181730 - g_ps2RecompiledFunctionTable[132718] = bhEne01_PlyDG01_0x181730; // 0x1819c0 - g_ps2RecompiledFunctionTable[132933] = bhEne01_PlyDG01_0x181730; // 0x181d1c - g_ps2RecompiledFunctionTable[133088] = bhEne01_PlyDG01_0x181730; // 0x181f88 - g_ps2RecompiledFunctionTable[133126] = bhEne01_EnemyPushChk_0x182020; // 0x182020 - g_ps2RecompiledFunctionTable[133142] = bhEne01_EnemyPushChk_0x182020; // 0x182060 - g_ps2RecompiledFunctionTable[133204] = bhEne01_EnemyPushChk_0x182020; // 0x182158 - g_ps2RecompiledFunctionTable[133215] = bhEne01_EnemyPushChk_0x182020; // 0x182184 - g_ps2RecompiledFunctionTable[133234] = bhEne01_EnemyPushChk_0x182020; // 0x1821d0 - g_ps2RecompiledFunctionTable[133259] = bhEne01_EnemyPushChk_0x182020; // 0x182234 - g_ps2RecompiledFunctionTable[133275] = bhEne01_EnemyPushChk_0x182020; // 0x182274 - g_ps2RecompiledFunctionTable[133279] = bhEne01_EnemyPushChk_0x182020; // 0x182284 - g_ps2RecompiledFunctionTable[133309] = bhEne01_EnemyPushChk_0x182020; // 0x1822fc - g_ps2RecompiledFunctionTable[133313] = bhEne01_EnemyPushChk_0x182020; // 0x18230c - g_ps2RecompiledFunctionTable[133346] = bhEne01_DGType00_0x182390; // 0x182390 - g_ps2RecompiledFunctionTable[133347] = bhEne01_DGType00_0x182390; // 0x182394 - g_ps2RecompiledFunctionTable[133348] = bhEne01_DGType00_0x182390; // 0x182398 - g_ps2RecompiledFunctionTable[133349] = bhEne01_DGType00_0x182390; // 0x18239c - g_ps2RecompiledFunctionTable[133350] = bhEne01_DGType00_0x182390; // 0x1823a0 - g_ps2RecompiledFunctionTable[133351] = bhEne01_DGType00_0x182390; // 0x1823a4 - g_ps2RecompiledFunctionTable[133352] = bhEne01_DGType00_0x182390; // 0x1823a8 - g_ps2RecompiledFunctionTable[133353] = bhEne01_DGType00_0x182390; // 0x1823ac - g_ps2RecompiledFunctionTable[133354] = bhEne01_DGType02_0x1823b0; // 0x1823b0 - g_ps2RecompiledFunctionTable[133355] = bhEne01_DGType02_0x1823b0; // 0x1823b4 - g_ps2RecompiledFunctionTable[133356] = bhEne01_DGType02_0x1823b0; // 0x1823b8 - g_ps2RecompiledFunctionTable[133357] = bhEne01_DGType02_0x1823b0; // 0x1823bc - g_ps2RecompiledFunctionTable[133358] = bhEne01_DGType02_0x1823b0; // 0x1823c0 - g_ps2RecompiledFunctionTable[133359] = bhEne01_DGType02_0x1823b0; // 0x1823c4 - g_ps2RecompiledFunctionTable[133360] = bhEne01_DGType02_0x1823b0; // 0x1823c8 - g_ps2RecompiledFunctionTable[133361] = bhEne01_DGType02_0x1823b0; // 0x1823cc - g_ps2RecompiledFunctionTable[133362] = bhEne01_DG00_0x1823d0; // 0x1823d0 - g_ps2RecompiledFunctionTable[133391] = bhEne01_DG00_0x1823d0; // 0x182444 - g_ps2RecompiledFunctionTable[133407] = bhEne01_DG00_0x1823d0; // 0x182484 - g_ps2RecompiledFunctionTable[133446] = bhEne01_DG01_0x182520; // 0x182520 - g_ps2RecompiledFunctionTable[133475] = bhEne01_DG01_0x182520; // 0x182594 - g_ps2RecompiledFunctionTable[133491] = bhEne01_DG01_0x182520; // 0x1825d4 - g_ps2RecompiledFunctionTable[133534] = bhEne01_DG01_0x182520; // 0x182680 - g_ps2RecompiledFunctionTable[133562] = bhEne01_DG02_0x1826f0; // 0x1826f0 - g_ps2RecompiledFunctionTable[133591] = bhEne01_DG02_0x1826f0; // 0x182764 - g_ps2RecompiledFunctionTable[133607] = bhEne01_DG02_0x1826f0; // 0x1827a4 - g_ps2RecompiledFunctionTable[133637] = bhEne01_DG02_0x1826f0; // 0x18281c - g_ps2RecompiledFunctionTable[133645] = bhEne01_DG02_0x1826f0; // 0x18283c - g_ps2RecompiledFunctionTable[133677] = bhEne01_DG02_0x1826f0; // 0x1828bc - g_ps2RecompiledFunctionTable[133718] = bhEne01_DG03_0x182960; // 0x182960 - g_ps2RecompiledFunctionTable[133750] = bhEne01_DG03_0x182960; // 0x1829e0 - g_ps2RecompiledFunctionTable[133762] = bhEne01_DG03_0x182960; // 0x182a10 - g_ps2RecompiledFunctionTable[133801] = bhEne01_DG03_0x182960; // 0x182aac - g_ps2RecompiledFunctionTable[133807] = bhEne01_DG03_0x182960; // 0x182ac4 - g_ps2RecompiledFunctionTable[133827] = bhEne01_DG03_0x182960; // 0x182b14 - g_ps2RecompiledFunctionTable[133837] = bhEne01_DG03_0x182960; // 0x182b3c - g_ps2RecompiledFunctionTable[133849] = bhEne01_DG03_0x182960; // 0x182b6c - g_ps2RecompiledFunctionTable[133863] = bhEne01_DG03_0x182960; // 0x182ba4 - g_ps2RecompiledFunctionTable[133875] = bhEne01_DG03_0x182960; // 0x182bd4 - g_ps2RecompiledFunctionTable[133990] = bhEne01_DG03_0x182960; // 0x182da0 - g_ps2RecompiledFunctionTable[134002] = bhEne01_DG03_0x182960; // 0x182dd0 - g_ps2RecompiledFunctionTable[134134] = bhEne01_DG04_0x182fe0; // 0x182fe0 - g_ps2RecompiledFunctionTable[134165] = bhEne01_DG04_0x182fe0; // 0x18305c - g_ps2RecompiledFunctionTable[134181] = bhEne01_DG04_0x182fe0; // 0x18309c - g_ps2RecompiledFunctionTable[134195] = bhEne01_DG04_0x182fe0; // 0x1830d4 - g_ps2RecompiledFunctionTable[134200] = bhEne01_DG04_0x182fe0; // 0x1830e8 - g_ps2RecompiledFunctionTable[134240] = bhEne01_DG04_0x182fe0; // 0x183188 - g_ps2RecompiledFunctionTable[134254] = bhEne01_DG04_0x182fe0; // 0x1831c0 - g_ps2RecompiledFunctionTable[134265] = bhEne01_DG04_0x182fe0; // 0x1831ec - g_ps2RecompiledFunctionTable[134283] = bhEne01_DG04_0x182fe0; // 0x183234 - g_ps2RecompiledFunctionTable[134290] = bhEne01_DG04_0x182fe0; // 0x183250 - g_ps2RecompiledFunctionTable[134302] = bhEne01_DG04_0x182fe0; // 0x183280 - g_ps2RecompiledFunctionTable[134325] = bhEne01_DG04_0x182fe0; // 0x1832dc - g_ps2RecompiledFunctionTable[134337] = bhEne01_DG04_0x182fe0; // 0x18330c - g_ps2RecompiledFunctionTable[134367] = bhEne01_DG04_0x182fe0; // 0x183384 - g_ps2RecompiledFunctionTable[134506] = bhEne01_DG04_0x182fe0; // 0x1835b0 - g_ps2RecompiledFunctionTable[134523] = bhEne01_DG04_0x182fe0; // 0x1835f4 - g_ps2RecompiledFunctionTable[134614] = bhEne01_DG04_0x182fe0; // 0x183760 - g_ps2RecompiledFunctionTable[134643] = bhEne01_DG04_0x182fe0; // 0x1837d4 - g_ps2RecompiledFunctionTable[134660] = bhEne01_DG04_0x182fe0; // 0x183818 - g_ps2RecompiledFunctionTable[134706] = bhEne01_DG05_0x1838d0; // 0x1838d0 - g_ps2RecompiledFunctionTable[134726] = bhEne01_DG05_0x1838d0; // 0x183920 - g_ps2RecompiledFunctionTable[134810] = bhEne01_DG06_0x183a70; // 0x183a70 - g_ps2RecompiledFunctionTable[134830] = bhEne01_DG06_0x183a70; // 0x183ac0 - g_ps2RecompiledFunctionTable[134842] = bhEne01_DG06_0x183a70; // 0x183af0 - g_ps2RecompiledFunctionTable[134855] = bhEne01_DG06_0x183a70; // 0x183b24 - g_ps2RecompiledFunctionTable[134942] = bhEne01_DG06_0x183a70; // 0x183c80 - g_ps2RecompiledFunctionTable[134954] = bhEne01_DG06_0x183a70; // 0x183cb0 - g_ps2RecompiledFunctionTable[134998] = bhEne01_DG07_0x183d60; // 0x183d60 - g_ps2RecompiledFunctionTable[135058] = bhEne01_DG07_0x183d60; // 0x183e50 - g_ps2RecompiledFunctionTable[135097] = bhEne01_DG07_0x183d60; // 0x183eec - g_ps2RecompiledFunctionTable[135126] = bhEne01_DG07_0x183d60; // 0x183f60 - g_ps2RecompiledFunctionTable[135145] = bhEne01_DG07_0x183d60; // 0x183fac - g_ps2RecompiledFunctionTable[135173] = bhEne01_DG07_0x183d60; // 0x18401c - g_ps2RecompiledFunctionTable[135182] = bhEne01_DG07_0x183d60; // 0x184040 - g_ps2RecompiledFunctionTable[135184] = bhEne01_DG07_0x183d60; // 0x184048 - g_ps2RecompiledFunctionTable[135217] = bhEne01_DG07_0x183d60; // 0x1840cc - g_ps2RecompiledFunctionTable[135228] = bhEne01_DG07_0x183d60; // 0x1840f8 - g_ps2RecompiledFunctionTable[135237] = bhEne01_DG07_0x183d60; // 0x18411c - g_ps2RecompiledFunctionTable[135239] = bhEne01_DG07_0x183d60; // 0x184124 - g_ps2RecompiledFunctionTable[135272] = bhEne01_DG07_0x183d60; // 0x1841a8 - g_ps2RecompiledFunctionTable[135303] = bhEne01_DG07_0x183d60; // 0x184224 - g_ps2RecompiledFunctionTable[135330] = bhEne01_DG08_0x184290; // 0x184290 - g_ps2RecompiledFunctionTable[135371] = bhEne01_DG08_0x184290; // 0x184334 - g_ps2RecompiledFunctionTable[135380] = bhEne01_DG08_0x184290; // 0x184358 - g_ps2RecompiledFunctionTable[135386] = bhEne01_DG08_0x184290; // 0x184370 - g_ps2RecompiledFunctionTable[135407] = bhEne01_DG08_0x184290; // 0x1843c4 - g_ps2RecompiledFunctionTable[135503] = bhEne01_DG08_0x184290; // 0x184544 - g_ps2RecompiledFunctionTable[135515] = bhEne01_DG08_0x184290; // 0x184574 - g_ps2RecompiledFunctionTable[135533] = bhEne01_DG08_0x184290; // 0x1845bc - g_ps2RecompiledFunctionTable[135557] = bhEne01_DG08_0x184290; // 0x18461c - g_ps2RecompiledFunctionTable[135585] = bhEne01_DG08_0x184290; // 0x18468c - g_ps2RecompiledFunctionTable[135602] = bhEne01_DG08_0x184290; // 0x1846d0 - g_ps2RecompiledFunctionTable[135617] = bhEne01_DG08_0x184290; // 0x18470c - g_ps2RecompiledFunctionTable[135634] = bhEne01_DG08_0x184290; // 0x184750 - g_ps2RecompiledFunctionTable[135658] = bhEne01_DG08_0x184290; // 0x1847b0 - g_ps2RecompiledFunctionTable[135683] = bhEne01_DG08_0x184290; // 0x184814 - g_ps2RecompiledFunctionTable[135700] = bhEne01_DG08_0x184290; // 0x184858 - g_ps2RecompiledFunctionTable[135741] = bhEne01_DG08_0x184290; // 0x1848fc - g_ps2RecompiledFunctionTable[135778] = bhEne01_DG09_0x184990; // 0x184990 - g_ps2RecompiledFunctionTable[135807] = bhEne01_DG09_0x184990; // 0x184a04 - g_ps2RecompiledFunctionTable[135819] = bhEne01_DG09_0x184990; // 0x184a34 - g_ps2RecompiledFunctionTable[135835] = bhEne01_DG09_0x184990; // 0x184a74 - g_ps2RecompiledFunctionTable[135847] = bhEne01_DG09_0x184990; // 0x184aa4 - g_ps2RecompiledFunctionTable[135864] = bhEne01_DG09_0x184990; // 0x184ae8 - g_ps2RecompiledFunctionTable[135876] = bhEne01_DG09_0x184990; // 0x184b18 - g_ps2RecompiledFunctionTable[135888] = bhEne01_DG09_0x184990; // 0x184b48 - g_ps2RecompiledFunctionTable[135900] = bhEne01_DG09_0x184990; // 0x184b78 - g_ps2RecompiledFunctionTable[135974] = bhEne01_DG10_0x184ca0; // 0x184ca0 - g_ps2RecompiledFunctionTable[136021] = bhEne01_DG10_0x184ca0; // 0x184d5c - g_ps2RecompiledFunctionTable[136033] = bhEne01_DG10_0x184ca0; // 0x184d8c - g_ps2RecompiledFunctionTable[136170] = bhEne01_DG11_0x184fb0; // 0x184fb0 - g_ps2RecompiledFunctionTable[136211] = bhEne01_DG11_0x184fb0; // 0x185054 - g_ps2RecompiledFunctionTable[136227] = bhEne01_DG11_0x184fb0; // 0x185094 - g_ps2RecompiledFunctionTable[136282] = bhEne01_DG14_0x185170; // 0x185170 - g_ps2RecompiledFunctionTable[136339] = bhEne01_DG14_0x185170; // 0x185254 - g_ps2RecompiledFunctionTable[136358] = bhEne01_DG14_0x185170; // 0x1852a0 - g_ps2RecompiledFunctionTable[136360] = bhEne01_DG14_0x185170; // 0x1852a8 - g_ps2RecompiledFunctionTable[136372] = bhEne01_DG14_0x185170; // 0x1852d8 - g_ps2RecompiledFunctionTable[136392] = bhEne01_DG14_0x185170; // 0x185328 - g_ps2RecompiledFunctionTable[136411] = bhEne01_DG14_0x185170; // 0x185374 - g_ps2RecompiledFunctionTable[136413] = bhEne01_DG14_0x185170; // 0x18537c - g_ps2RecompiledFunctionTable[136425] = bhEne01_DG14_0x185170; // 0x1853ac - g_ps2RecompiledFunctionTable[136435] = bhEne01_DG14_0x185170; // 0x1853d4 - g_ps2RecompiledFunctionTable[136451] = bhEne01_DG14_0x185170; // 0x185414 - g_ps2RecompiledFunctionTable[136495] = bhEne01_DG14_0x185170; // 0x1854c4 - g_ps2RecompiledFunctionTable[136497] = bhEne01_DG14_0x185170; // 0x1854cc - g_ps2RecompiledFunctionTable[136504] = bhEne01_DG14_0x185170; // 0x1854e8 - g_ps2RecompiledFunctionTable[136513] = bhEne01_DG14_0x185170; // 0x18550c - g_ps2RecompiledFunctionTable[136515] = bhEne01_DG14_0x185170; // 0x185514 - g_ps2RecompiledFunctionTable[136546] = bhEne01_DG14_0x185170; // 0x185590 - g_ps2RecompiledFunctionTable[136555] = bhEne01_DG14_0x185170; // 0x1855b4 - g_ps2RecompiledFunctionTable[136557] = bhEne01_DG14_0x185170; // 0x1855bc - g_ps2RecompiledFunctionTable[136590] = bhEne01_DG14_0x185170; // 0x185640 - g_ps2RecompiledFunctionTable[136654] = bhEne01_DG15_0x185740; // 0x185740 - g_ps2RecompiledFunctionTable[136677] = bhEne01_DG15_0x185740; // 0x18579c - g_ps2RecompiledFunctionTable[136695] = bhEne01_DG15_0x185740; // 0x1857e4 - g_ps2RecompiledFunctionTable[136708] = bhEne01_DG15_0x185740; // 0x185818 - g_ps2RecompiledFunctionTable[136734] = bhEne01_DG16_0x185880; // 0x185880 - g_ps2RecompiledFunctionTable[136760] = bhEne01_DG16_0x185880; // 0x1858e8 - g_ps2RecompiledFunctionTable[136765] = bhEne01_DG16_0x185880; // 0x1858fc - g_ps2RecompiledFunctionTable[136774] = bhEne01_DG16_0x185880; // 0x185920 - g_ps2RecompiledFunctionTable[136791] = bhEne01_DG16_0x185880; // 0x185964 - g_ps2RecompiledFunctionTable[136848] = bhEne01_DG16_0x185880; // 0x185a48 - g_ps2RecompiledFunctionTable[136856] = bhEne01_DG16_0x185880; // 0x185a68 - g_ps2RecompiledFunctionTable[136894] = bhEne01_DDType00_0x185b00; // 0x185b00 - g_ps2RecompiledFunctionTable[136895] = bhEne01_DDType00_0x185b00; // 0x185b04 - g_ps2RecompiledFunctionTable[136896] = bhEne01_DDType00_0x185b00; // 0x185b08 - g_ps2RecompiledFunctionTable[136897] = bhEne01_DDType00_0x185b00; // 0x185b0c - g_ps2RecompiledFunctionTable[136898] = bhEne01_DDType00_0x185b00; // 0x185b10 - g_ps2RecompiledFunctionTable[136899] = bhEne01_DDType00_0x185b00; // 0x185b14 - g_ps2RecompiledFunctionTable[136900] = bhEne01_DDType00_0x185b00; // 0x185b18 - g_ps2RecompiledFunctionTable[136901] = bhEne01_DDType00_0x185b00; // 0x185b1c - g_ps2RecompiledFunctionTable[136902] = bhEne01_DDType02_0x185b20; // 0x185b20 - g_ps2RecompiledFunctionTable[136903] = bhEne01_DDType02_0x185b20; // 0x185b24 - g_ps2RecompiledFunctionTable[136904] = bhEne01_DDType02_0x185b20; // 0x185b28 - g_ps2RecompiledFunctionTable[136905] = bhEne01_DDType02_0x185b20; // 0x185b2c - g_ps2RecompiledFunctionTable[136906] = bhEne01_DDType02_0x185b20; // 0x185b30 - g_ps2RecompiledFunctionTable[136907] = bhEne01_DDType02_0x185b20; // 0x185b34 - g_ps2RecompiledFunctionTable[136908] = bhEne01_DDType02_0x185b20; // 0x185b38 - g_ps2RecompiledFunctionTable[136909] = bhEne01_DDType02_0x185b20; // 0x185b3c - g_ps2RecompiledFunctionTable[136910] = bhEne01_DD00_0x185b40; // 0x185b40 - g_ps2RecompiledFunctionTable[136937] = bhEne01_DD00_0x185b40; // 0x185bac - g_ps2RecompiledFunctionTable[136962] = bhEne01_DD00_0x185b40; // 0x185c10 - g_ps2RecompiledFunctionTable[136978] = bhEne01_DD00_0x185b40; // 0x185c50 - g_ps2RecompiledFunctionTable[137009] = bhEne01_DD00_0x185b40; // 0x185ccc - g_ps2RecompiledFunctionTable[137016] = bhEne01_DD00_0x185b40; // 0x185ce8 - g_ps2RecompiledFunctionTable[137026] = bhEne01_DD00_0x185b40; // 0x185d10 - g_ps2RecompiledFunctionTable[137035] = bhEne01_DD00_0x185b40; // 0x185d34 - g_ps2RecompiledFunctionTable[137049] = bhEne01_DD00_0x185b40; // 0x185d6c - g_ps2RecompiledFunctionTable[137067] = bhEne01_DD00_0x185b40; // 0x185db4 - g_ps2RecompiledFunctionTable[137088] = bhEne01_DD00_0x185b40; // 0x185e08 - g_ps2RecompiledFunctionTable[137102] = bhEne01_DD00_0x185b40; // 0x185e40 - g_ps2RecompiledFunctionTable[137148] = bhEne01_DD00_0x185b40; // 0x185ef8 - g_ps2RecompiledFunctionTable[137209] = bhEne01_DD00_0x185b40; // 0x185fec - g_ps2RecompiledFunctionTable[137213] = bhEne01_DD00_0x185b40; // 0x185ffc - g_ps2RecompiledFunctionTable[137215] = bhEne01_DD00_0x185b40; // 0x186004 - g_ps2RecompiledFunctionTable[137266] = bhEne01_DD00_0x185b40; // 0x1860d0 - g_ps2RecompiledFunctionTable[137270] = bhEne01_DD00_0x185b40; // 0x1860e0 - g_ps2RecompiledFunctionTable[137274] = bhEne01_DD00_0x185b40; // 0x1860f0 - g_ps2RecompiledFunctionTable[137279] = bhEne01_DD00_0x185b40; // 0x186104 - g_ps2RecompiledFunctionTable[137287] = bhEne01_DD00_0x185b40; // 0x186124 - g_ps2RecompiledFunctionTable[137302] = bhEne01_DD01_0x186160; // 0x186160 - g_ps2RecompiledFunctionTable[137341] = bhEne01_DD01_0x186160; // 0x1861fc - g_ps2RecompiledFunctionTable[137350] = bhEne01_DD02_0x186220; // 0x186220 - g_ps2RecompiledFunctionTable[137398] = bhEne01_DD02_0x186220; // 0x1862e0 - g_ps2RecompiledFunctionTable[137422] = bhEne01_DD02_0x186220; // 0x186340 - g_ps2RecompiledFunctionTable[137435] = bhEne01_DD02_0x186220; // 0x186374 - g_ps2RecompiledFunctionTable[137492] = bhEne01_DD02_0x186220; // 0x186458 - g_ps2RecompiledFunctionTable[137496] = bhEne01_DD02_0x186220; // 0x186468 - g_ps2RecompiledFunctionTable[137498] = bhEne01_DD02_0x186220; // 0x186470 - g_ps2RecompiledFunctionTable[137549] = bhEne01_DD02_0x186220; // 0x18653c - g_ps2RecompiledFunctionTable[137553] = bhEne01_DD02_0x186220; // 0x18654c - g_ps2RecompiledFunctionTable[137557] = bhEne01_DD02_0x186220; // 0x18655c - g_ps2RecompiledFunctionTable[137562] = bhEne01_DD02_0x186220; // 0x186570 - g_ps2RecompiledFunctionTable[137570] = bhEne01_DD02_0x186220; // 0x186590 - g_ps2RecompiledFunctionTable[137586] = bhEne01_DD03_0x1865d0; // 0x1865d0 - g_ps2RecompiledFunctionTable[137622] = bhEne01_ChgWalkMtn_0x186660; // 0x186660 - g_ps2RecompiledFunctionTable[137702] = bhEne01_ChgWalkMtn_0x186660; // 0x1867a0 - g_ps2RecompiledFunctionTable[137707] = bhEne01_ChgWalkMtn_0x186660; // 0x1867b4 - g_ps2RecompiledFunctionTable[137722] = bhEne01_ChgWalkMtn_0x186660; // 0x1867f0 - g_ps2RecompiledFunctionTable[137735] = bhEne01_ChgWalkMtn_0x186660; // 0x186824 - g_ps2RecompiledFunctionTable[137747] = bhEne01_ChgWalkMtn_0x186660; // 0x186854 - g_ps2RecompiledFunctionTable[137766] = bhEne01_SetMtn_0x1868a0; // 0x1868a0 - g_ps2RecompiledFunctionTable[137801] = bhEne01_SetMtn_0x1868a0; // 0x18692c - g_ps2RecompiledFunctionTable[137828] = bhEne01_SetMtn_0x1868a0; // 0x186998 - g_ps2RecompiledFunctionTable[137842] = bhEne01_SetMtn_0x1868a0; // 0x1869d0 - g_ps2RecompiledFunctionTable[137845] = bhEne01_SetMtn_0x1868a0; // 0x1869dc - g_ps2RecompiledFunctionTable[137939] = bhEne01_SetMtn_0x1868a0; // 0x186b54 - g_ps2RecompiledFunctionTable[137954] = bhEne01_SetMtn_0x1868a0; // 0x186b90 - g_ps2RecompiledFunctionTable[137968] = bhEne01_SetMtn_0x1868a0; // 0x186bc8 - g_ps2RecompiledFunctionTable[137989] = bhEne01_SetMtn_0x1868a0; // 0x186c1c - g_ps2RecompiledFunctionTable[137992] = bhEne01_SetMtn_0x1868a0; // 0x186c28 - g_ps2RecompiledFunctionTable[138011] = bhEne01_SetMtn_0x1868a0; // 0x186c74 - g_ps2RecompiledFunctionTable[138014] = bhEne01_SetMtn_0x1868a0; // 0x186c80 - g_ps2RecompiledFunctionTable[138096] = bhEne01_SetMtn_0x1868a0; // 0x186dc8 - g_ps2RecompiledFunctionTable[138106] = bhEne01_CheckMtnTbl_0x186df0; // 0x186df0 - g_ps2RecompiledFunctionTable[138107] = bhEne01_CheckMtnTbl_0x186df0; // 0x186df4 - g_ps2RecompiledFunctionTable[138108] = bhEne01_CheckMtnTbl_0x186df0; // 0x186df8 - g_ps2RecompiledFunctionTable[138109] = bhEne01_CheckMtnTbl_0x186df0; // 0x186dfc - g_ps2RecompiledFunctionTable[138110] = bhEne01_CheckMtnTbl_0x186df0; // 0x186e00 - g_ps2RecompiledFunctionTable[138111] = bhEne01_CheckMtnTbl_0x186df0; // 0x186e04 - g_ps2RecompiledFunctionTable[138112] = bhEne01_CheckMtnTbl_0x186df0; // 0x186e08 - g_ps2RecompiledFunctionTable[138113] = bhEne01_CheckMtnTbl_0x186df0; // 0x186e0c - g_ps2RecompiledFunctionTable[138114] = bhEne01_CheckMtnTbl_0x186df0; // 0x186e10 - g_ps2RecompiledFunctionTable[138115] = bhEne01_CheckMtnTbl_0x186df0; // 0x186e14 - g_ps2RecompiledFunctionTable[138116] = bhEne01_CheckMtnTbl_0x186df0; // 0x186e18 - g_ps2RecompiledFunctionTable[138117] = bhEne01_CheckMtnTbl_0x186df0; // 0x186e1c - g_ps2RecompiledFunctionTable[138118] = bhEne01_CheckMtnTbl_0x186df0; // 0x186e20 - g_ps2RecompiledFunctionTable[138119] = bhEne01_CheckMtnTbl_0x186df0; // 0x186e24 - g_ps2RecompiledFunctionTable[138120] = bhEne01_CheckMtnTbl_0x186df0; // 0x186e28 - g_ps2RecompiledFunctionTable[138121] = bhEne01_CheckMtnTbl_0x186df0; // 0x186e2c - g_ps2RecompiledFunctionTable[138122] = bhEne01_CheckMtnTbl_0x186df0; // 0x186e30 - g_ps2RecompiledFunctionTable[138123] = bhEne01_CheckMtnTbl_0x186df0; // 0x186e34 - g_ps2RecompiledFunctionTable[138124] = bhEne01_CheckMtnTbl_0x186df0; // 0x186e38 - g_ps2RecompiledFunctionTable[138125] = bhEne01_CheckMtnTbl_0x186df0; // 0x186e3c - g_ps2RecompiledFunctionTable[138126] = bhEne01_CheckMtnTbl_0x186df0; // 0x186e40 - g_ps2RecompiledFunctionTable[138127] = bhEne01_CheckMtnTbl_0x186df0; // 0x186e44 - g_ps2RecompiledFunctionTable[138128] = bhEne01_CheckMtnTbl_0x186df0; // 0x186e48 - g_ps2RecompiledFunctionTable[138129] = bhEne01_CheckMtnTbl_0x186df0; // 0x186e4c - g_ps2RecompiledFunctionTable[138130] = bhEne01_CheckMtnTbl_0x186df0; // 0x186e50 - g_ps2RecompiledFunctionTable[138131] = bhEne01_CheckMtnTbl_0x186df0; // 0x186e54 - g_ps2RecompiledFunctionTable[138132] = bhEne01_CheckMtnTbl_0x186df0; // 0x186e58 - g_ps2RecompiledFunctionTable[138133] = bhEne01_CheckMtnTbl_0x186df0; // 0x186e5c - g_ps2RecompiledFunctionTable[138134] = bhEne01_CheckMtnTbl_0x186df0; // 0x186e60 - g_ps2RecompiledFunctionTable[138135] = bhEne01_CheckMtnTbl_0x186df0; // 0x186e64 - g_ps2RecompiledFunctionTable[138136] = bhEne01_CheckMtnTbl_0x186df0; // 0x186e68 - g_ps2RecompiledFunctionTable[138137] = bhEne01_CheckMtnTbl_0x186df0; // 0x186e6c - g_ps2RecompiledFunctionTable[138138] = bhEne01_CheckMtnTbl_0x186df0; // 0x186e70 - g_ps2RecompiledFunctionTable[138139] = bhEne01_CheckMtnTbl_0x186df0; // 0x186e74 - g_ps2RecompiledFunctionTable[138140] = bhEne01_CheckMtnTbl_0x186df0; // 0x186e78 - g_ps2RecompiledFunctionTable[138141] = bhEne01_CheckMtnTbl_0x186df0; // 0x186e7c - g_ps2RecompiledFunctionTable[138142] = bhEne01_CheckMtnTbl_0x186df0; // 0x186e80 - g_ps2RecompiledFunctionTable[138143] = bhEne01_CheckMtnTbl_0x186df0; // 0x186e84 - g_ps2RecompiledFunctionTable[138144] = bhEne01_CheckMtnTbl_0x186df0; // 0x186e88 - g_ps2RecompiledFunctionTable[138145] = bhEne01_CheckMtnTbl_0x186df0; // 0x186e8c - g_ps2RecompiledFunctionTable[138146] = bhEne01_CheckMtnTbl_0x186df0; // 0x186e90 - g_ps2RecompiledFunctionTable[138147] = bhEne01_CheckMtnTbl_0x186df0; // 0x186e94 - g_ps2RecompiledFunctionTable[138148] = bhEne01_CheckMtnTbl_0x186df0; // 0x186e98 - g_ps2RecompiledFunctionTable[138149] = bhEne01_CheckMtnTbl_0x186df0; // 0x186e9c - g_ps2RecompiledFunctionTable[138150] = bhEne01_CheckMtnTbl_0x186df0; // 0x186ea0 - g_ps2RecompiledFunctionTable[138151] = bhEne01_CheckMtnTbl_0x186df0; // 0x186ea4 - g_ps2RecompiledFunctionTable[138152] = bhEne01_CheckMtnTbl_0x186df0; // 0x186ea8 - g_ps2RecompiledFunctionTable[138153] = bhEne01_CheckMtnTbl_0x186df0; // 0x186eac - g_ps2RecompiledFunctionTable[138154] = bhEne01_CheckMtnTbl_0x186df0; // 0x186eb0 - g_ps2RecompiledFunctionTable[138155] = bhEne01_CheckMtnTbl_0x186df0; // 0x186eb4 - g_ps2RecompiledFunctionTable[138156] = bhEne01_CheckMtnTbl_0x186df0; // 0x186eb8 - g_ps2RecompiledFunctionTable[138157] = bhEne01_CheckMtnTbl_0x186df0; // 0x186ebc - g_ps2RecompiledFunctionTable[138158] = bhEne01_CheckMtnTbl_0x186df0; // 0x186ec0 - g_ps2RecompiledFunctionTable[138159] = bhEne01_CheckMtnTbl_0x186df0; // 0x186ec4 - g_ps2RecompiledFunctionTable[138160] = bhEne01_CheckMtnTbl_0x186df0; // 0x186ec8 - g_ps2RecompiledFunctionTable[138161] = bhEne01_CheckMtnTbl_0x186df0; // 0x186ecc - g_ps2RecompiledFunctionTable[138162] = bhEne01_CheckMtnTbl_0x186df0; // 0x186ed0 - g_ps2RecompiledFunctionTable[138163] = bhEne01_CheckMtnTbl_0x186df0; // 0x186ed4 - g_ps2RecompiledFunctionTable[138164] = bhEne01_CheckMtnTbl_0x186df0; // 0x186ed8 - g_ps2RecompiledFunctionTable[138165] = bhEne01_CheckMtnTbl_0x186df0; // 0x186edc - g_ps2RecompiledFunctionTable[138166] = bhEne01_CheckMtnTbl_0x186df0; // 0x186ee0 - g_ps2RecompiledFunctionTable[138167] = bhEne01_CheckMtnTbl_0x186df0; // 0x186ee4 - g_ps2RecompiledFunctionTable[138168] = bhEne01_CheckMtnTbl_0x186df0; // 0x186ee8 - g_ps2RecompiledFunctionTable[138169] = bhEne01_CheckMtnTbl_0x186df0; // 0x186eec - g_ps2RecompiledFunctionTable[138170] = bhEne01_CheckMtnTbl_0x186df0; // 0x186ef0 - g_ps2RecompiledFunctionTable[138171] = bhEne01_CheckMtnTbl_0x186df0; // 0x186ef4 - g_ps2RecompiledFunctionTable[138172] = bhEne01_CheckMtnTbl_0x186df0; // 0x186ef8 - g_ps2RecompiledFunctionTable[138173] = bhEne01_CheckMtnTbl_0x186df0; // 0x186efc - g_ps2RecompiledFunctionTable[138174] = bhEne01_CheckMtnTbl_0x186df0; // 0x186f00 - g_ps2RecompiledFunctionTable[138175] = bhEne01_CheckMtnTbl_0x186df0; // 0x186f04 - g_ps2RecompiledFunctionTable[138176] = bhEne01_CheckMtnTbl_0x186df0; // 0x186f08 - g_ps2RecompiledFunctionTable[138177] = bhEne01_CheckMtnTbl_0x186df0; // 0x186f0c - g_ps2RecompiledFunctionTable[138178] = bhEne01_CheckMtnTbl_0x186df0; // 0x186f10 - g_ps2RecompiledFunctionTable[138179] = bhEne01_CheckMtnTbl_0x186df0; // 0x186f14 - g_ps2RecompiledFunctionTable[138180] = bhEne01_CheckMtnTbl_0x186df0; // 0x186f18 - g_ps2RecompiledFunctionTable[138181] = bhEne01_CheckMtnTbl_0x186df0; // 0x186f1c - g_ps2RecompiledFunctionTable[138182] = bhEne01_CheckMtnTbl_0x186df0; // 0x186f20 - g_ps2RecompiledFunctionTable[138183] = bhEne01_CheckMtnTbl_0x186df0; // 0x186f24 - g_ps2RecompiledFunctionTable[138184] = bhEne01_CheckMtnTbl_0x186df0; // 0x186f28 - g_ps2RecompiledFunctionTable[138185] = bhEne01_CheckMtnTbl_0x186df0; // 0x186f2c - g_ps2RecompiledFunctionTable[138186] = bhEne01_CheckMtnTbl_0x186df0; // 0x186f30 - g_ps2RecompiledFunctionTable[138187] = bhEne01_CheckMtnTbl_0x186df0; // 0x186f34 - g_ps2RecompiledFunctionTable[138188] = bhEne01_CheckMtnTbl_0x186df0; // 0x186f38 - g_ps2RecompiledFunctionTable[138189] = bhEne01_CheckMtnTbl_0x186df0; // 0x186f3c - g_ps2RecompiledFunctionTable[138190] = bhEne01_CheckMtnTbl_0x186df0; // 0x186f40 - g_ps2RecompiledFunctionTable[138191] = bhEne01_CheckMtnTbl_0x186df0; // 0x186f44 - g_ps2RecompiledFunctionTable[138192] = bhEne01_CheckMtnTbl_0x186df0; // 0x186f48 - g_ps2RecompiledFunctionTable[138193] = bhEne01_CheckMtnTbl_0x186df0; // 0x186f4c - g_ps2RecompiledFunctionTable[138194] = bhEne01_CheckMtnTbl_0x186df0; // 0x186f50 - g_ps2RecompiledFunctionTable[138195] = bhEne01_CheckMtnTbl_0x186df0; // 0x186f54 - g_ps2RecompiledFunctionTable[138196] = bhEne01_CheckMtnTbl_0x186df0; // 0x186f58 - g_ps2RecompiledFunctionTable[138197] = bhEne01_CheckMtnTbl_0x186df0; // 0x186f5c - g_ps2RecompiledFunctionTable[138198] = bhEne01_CheckMtnTbl_0x186df0; // 0x186f60 - g_ps2RecompiledFunctionTable[138199] = bhEne01_CheckMtnTbl_0x186df0; // 0x186f64 - g_ps2RecompiledFunctionTable[138200] = bhEne01_CheckMtnTbl_0x186df0; // 0x186f68 - g_ps2RecompiledFunctionTable[138201] = bhEne01_CheckMtnTbl_0x186df0; // 0x186f6c - g_ps2RecompiledFunctionTable[138202] = bhEne01_CheckMtnTbl_0x186df0; // 0x186f70 - g_ps2RecompiledFunctionTable[138203] = bhEne01_CheckMtnTbl_0x186df0; // 0x186f74 - g_ps2RecompiledFunctionTable[138204] = bhEne01_CheckMtnTbl_0x186df0; // 0x186f78 - g_ps2RecompiledFunctionTable[138205] = bhEne01_CheckMtnTbl_0x186df0; // 0x186f7c - g_ps2RecompiledFunctionTable[138206] = bhEne01_CheckMtnTbl_0x186df0; // 0x186f80 - g_ps2RecompiledFunctionTable[138207] = bhEne01_CheckMtnTbl_0x186df0; // 0x186f84 - g_ps2RecompiledFunctionTable[138208] = bhEne01_CheckMtnTbl_0x186df0; // 0x186f88 - g_ps2RecompiledFunctionTable[138209] = bhEne01_CheckMtnTbl_0x186df0; // 0x186f8c - g_ps2RecompiledFunctionTable[138210] = bhEne01_CheckMtnTbl_0x186df0; // 0x186f90 - g_ps2RecompiledFunctionTable[138211] = bhEne01_CheckMtnTbl_0x186df0; // 0x186f94 - g_ps2RecompiledFunctionTable[138212] = bhEne01_CheckMtnTbl_0x186df0; // 0x186f98 - g_ps2RecompiledFunctionTable[138213] = bhEne01_CheckMtnTbl_0x186df0; // 0x186f9c - g_ps2RecompiledFunctionTable[138214] = bhEne01_CheckMtnTbl_0x186df0; // 0x186fa0 - g_ps2RecompiledFunctionTable[138215] = bhEne01_CheckMtnTbl_0x186df0; // 0x186fa4 - g_ps2RecompiledFunctionTable[138216] = bhEne01_CheckMtnTbl_0x186df0; // 0x186fa8 - g_ps2RecompiledFunctionTable[138217] = bhEne01_CheckMtnTbl_0x186df0; // 0x186fac - g_ps2RecompiledFunctionTable[138218] = bhEne01_CheckMtnTbl_0x186df0; // 0x186fb0 - g_ps2RecompiledFunctionTable[138219] = bhEne01_CheckMtnTbl_0x186df0; // 0x186fb4 - g_ps2RecompiledFunctionTable[138220] = bhEne01_CheckMtnTbl_0x186df0; // 0x186fb8 - g_ps2RecompiledFunctionTable[138221] = bhEne01_CheckMtnTbl_0x186df0; // 0x186fbc - g_ps2RecompiledFunctionTable[138222] = bhEne01_CheckMtnTbl_0x186df0; // 0x186fc0 - g_ps2RecompiledFunctionTable[138223] = bhEne01_CheckMtnTbl_0x186df0; // 0x186fc4 - g_ps2RecompiledFunctionTable[138224] = bhEne01_CheckMtnTbl_0x186df0; // 0x186fc8 - g_ps2RecompiledFunctionTable[138225] = bhEne01_CheckMtnTbl_0x186df0; // 0x186fcc - g_ps2RecompiledFunctionTable[138226] = bhEne01_CheckMtnTbl_0x186df0; // 0x186fd0 - g_ps2RecompiledFunctionTable[138227] = bhEne01_CheckMtnTbl_0x186df0; // 0x186fd4 - g_ps2RecompiledFunctionTable[138228] = bhEne01_CheckMtnTbl_0x186df0; // 0x186fd8 - g_ps2RecompiledFunctionTable[138229] = bhEne01_CheckMtnTbl_0x186df0; // 0x186fdc - g_ps2RecompiledFunctionTable[138230] = bhEne01_CheckMtnTbl_0x186df0; // 0x186fe0 - g_ps2RecompiledFunctionTable[138231] = bhEne01_CheckMtnTbl_0x186df0; // 0x186fe4 - g_ps2RecompiledFunctionTable[138232] = bhEne01_CheckMtnTbl_0x186df0; // 0x186fe8 - g_ps2RecompiledFunctionTable[138233] = bhEne01_CheckMtnTbl_0x186df0; // 0x186fec - g_ps2RecompiledFunctionTable[138234] = bhEne01_CheckMtnTbl_0x186df0; // 0x186ff0 - g_ps2RecompiledFunctionTable[138235] = bhEne01_CheckMtnTbl_0x186df0; // 0x186ff4 - g_ps2RecompiledFunctionTable[138236] = bhEne01_CheckMtnTbl_0x186df0; // 0x186ff8 - g_ps2RecompiledFunctionTable[138237] = bhEne01_CheckMtnTbl_0x186df0; // 0x186ffc - g_ps2RecompiledFunctionTable[138238] = bhEne01_CheckMtnTbl_0x186df0; // 0x187000 - g_ps2RecompiledFunctionTable[138239] = bhEne01_CheckMtnTbl_0x186df0; // 0x187004 - g_ps2RecompiledFunctionTable[138240] = bhEne01_CheckMtnTbl_0x186df0; // 0x187008 - g_ps2RecompiledFunctionTable[138241] = bhEne01_CheckMtnTbl_0x186df0; // 0x18700c - g_ps2RecompiledFunctionTable[138242] = bhEne01_CheckMtnTbl_0x186df0; // 0x187010 - g_ps2RecompiledFunctionTable[138243] = bhEne01_CheckMtnTbl_0x186df0; // 0x187014 - g_ps2RecompiledFunctionTable[138244] = bhEne01_CheckMtnTbl_0x186df0; // 0x187018 - g_ps2RecompiledFunctionTable[138245] = bhEne01_CheckMtnTbl_0x186df0; // 0x18701c - g_ps2RecompiledFunctionTable[138246] = bhEne01_CheckMtnTbl_0x186df0; // 0x187020 - g_ps2RecompiledFunctionTable[138247] = bhEne01_CheckMtnTbl_0x186df0; // 0x187024 - g_ps2RecompiledFunctionTable[138248] = bhEne01_CheckMtnTbl_0x186df0; // 0x187028 - g_ps2RecompiledFunctionTable[138249] = bhEne01_CheckMtnTbl_0x186df0; // 0x18702c - g_ps2RecompiledFunctionTable[138250] = bhEne01_CheckMtnTbl_0x186df0; // 0x187030 - g_ps2RecompiledFunctionTable[138251] = bhEne01_CheckMtnTbl_0x186df0; // 0x187034 - g_ps2RecompiledFunctionTable[138252] = bhEne01_CheckMtnTbl_0x186df0; // 0x187038 - g_ps2RecompiledFunctionTable[138253] = bhEne01_CheckMtnTbl_0x186df0; // 0x18703c - g_ps2RecompiledFunctionTable[138254] = bhEne01_CheckMtnTbl_0x186df0; // 0x187040 - g_ps2RecompiledFunctionTable[138255] = bhEne01_CheckMtnTbl_0x186df0; // 0x187044 - g_ps2RecompiledFunctionTable[138256] = bhEne01_CheckMtnTbl_0x186df0; // 0x187048 - g_ps2RecompiledFunctionTable[138257] = bhEne01_CheckMtnTbl_0x186df0; // 0x18704c - g_ps2RecompiledFunctionTable[138258] = bhEne01_CheckMtnTbl_0x186df0; // 0x187050 - g_ps2RecompiledFunctionTable[138259] = bhEne01_CheckMtnTbl_0x186df0; // 0x187054 - g_ps2RecompiledFunctionTable[138260] = bhEne01_CheckMtnTbl_0x186df0; // 0x187058 - g_ps2RecompiledFunctionTable[138261] = bhEne01_CheckMtnTbl_0x186df0; // 0x18705c - g_ps2RecompiledFunctionTable[138262] = bhEne01_CheckMtnTbl_0x186df0; // 0x187060 - g_ps2RecompiledFunctionTable[138263] = bhEne01_CheckMtnTbl_0x186df0; // 0x187064 - g_ps2RecompiledFunctionTable[138264] = bhEne01_CheckMtnTbl_0x186df0; // 0x187068 - g_ps2RecompiledFunctionTable[138265] = bhEne01_CheckMtnTbl_0x186df0; // 0x18706c - g_ps2RecompiledFunctionTable[138266] = bhEne01_CheckMtnTbl_0x186df0; // 0x187070 - g_ps2RecompiledFunctionTable[138267] = bhEne01_CheckMtnTbl_0x186df0; // 0x187074 - g_ps2RecompiledFunctionTable[138268] = bhEne01_CheckMtnTbl_0x186df0; // 0x187078 - g_ps2RecompiledFunctionTable[138269] = bhEne01_CheckMtnTbl_0x186df0; // 0x18707c - g_ps2RecompiledFunctionTable[138270] = bhEne01_CheckMtnTbl_0x186df0; // 0x187080 - g_ps2RecompiledFunctionTable[138271] = bhEne01_CheckMtnTbl_0x186df0; // 0x187084 - g_ps2RecompiledFunctionTable[138272] = bhEne01_CheckMtnTbl_0x186df0; // 0x187088 - g_ps2RecompiledFunctionTable[138273] = bhEne01_CheckMtnTbl_0x186df0; // 0x18708c - g_ps2RecompiledFunctionTable[138274] = bhEne01_CheckMtnTbl_0x186df0; // 0x187090 - g_ps2RecompiledFunctionTable[138275] = bhEne01_CheckMtnTbl_0x186df0; // 0x187094 - g_ps2RecompiledFunctionTable[138276] = bhEne01_CheckMtnTbl_0x186df0; // 0x187098 - g_ps2RecompiledFunctionTable[138277] = bhEne01_CheckMtnTbl_0x186df0; // 0x18709c - g_ps2RecompiledFunctionTable[138278] = bhEne01_CheckMtnTbl_0x186df0; // 0x1870a0 - g_ps2RecompiledFunctionTable[138279] = bhEne01_CheckMtnTbl_0x186df0; // 0x1870a4 - g_ps2RecompiledFunctionTable[138280] = bhEne01_CheckMtnTbl_0x186df0; // 0x1870a8 - g_ps2RecompiledFunctionTable[138281] = bhEne01_CheckMtnTbl_0x186df0; // 0x1870ac - g_ps2RecompiledFunctionTable[138282] = bhEne01_CheckMtnTbl_0x186df0; // 0x1870b0 - g_ps2RecompiledFunctionTable[138283] = bhEne01_CheckMtnTbl_0x186df0; // 0x1870b4 - g_ps2RecompiledFunctionTable[138284] = bhEne01_CheckMtnTbl_0x186df0; // 0x1870b8 - g_ps2RecompiledFunctionTable[138285] = bhEne01_CheckMtnTbl_0x186df0; // 0x1870bc - g_ps2RecompiledFunctionTable[138286] = bhEne01_CheckMtnTbl_0x186df0; // 0x1870c0 - g_ps2RecompiledFunctionTable[138287] = bhEne01_CheckMtnTbl_0x186df0; // 0x1870c4 - g_ps2RecompiledFunctionTable[138288] = bhEne01_CheckMtnTbl_0x186df0; // 0x1870c8 - g_ps2RecompiledFunctionTable[138289] = bhEne01_CheckMtnTbl_0x186df0; // 0x1870cc - g_ps2RecompiledFunctionTable[138290] = bhEne01_CheckMtnTbl_0x186df0; // 0x1870d0 - g_ps2RecompiledFunctionTable[138291] = bhEne01_CheckMtnTbl_0x186df0; // 0x1870d4 - g_ps2RecompiledFunctionTable[138292] = bhEne01_CheckMtnTbl_0x186df0; // 0x1870d8 - g_ps2RecompiledFunctionTable[138293] = bhEne01_CheckMtnTbl_0x186df0; // 0x1870dc - g_ps2RecompiledFunctionTable[138294] = bhEne01_CheckMtnTbl_0x186df0; // 0x1870e0 - g_ps2RecompiledFunctionTable[138295] = bhEne01_CheckMtnTbl_0x186df0; // 0x1870e4 - g_ps2RecompiledFunctionTable[138296] = bhEne01_CheckMtnTbl_0x186df0; // 0x1870e8 - g_ps2RecompiledFunctionTable[138297] = bhEne01_CheckMtnTbl_0x186df0; // 0x1870ec - g_ps2RecompiledFunctionTable[138298] = bhEne01_CheckMtnTbl_0x186df0; // 0x1870f0 - g_ps2RecompiledFunctionTable[138299] = bhEne01_CheckMtnTbl_0x186df0; // 0x1870f4 - g_ps2RecompiledFunctionTable[138300] = bhEne01_CheckMtnTbl_0x186df0; // 0x1870f8 - g_ps2RecompiledFunctionTable[138301] = bhEne01_CheckMtnTbl_0x186df0; // 0x1870fc - g_ps2RecompiledFunctionTable[138302] = bhEne01_CheckMtnTbl_0x186df0; // 0x187100 - g_ps2RecompiledFunctionTable[138303] = bhEne01_CheckMtnTbl_0x186df0; // 0x187104 - g_ps2RecompiledFunctionTable[138304] = bhEne01_CheckMtnTbl_0x186df0; // 0x187108 - g_ps2RecompiledFunctionTable[138305] = bhEne01_CheckMtnTbl_0x186df0; // 0x18710c - g_ps2RecompiledFunctionTable[138306] = bhEne01_CheckMtnTbl_0x186df0; // 0x187110 - g_ps2RecompiledFunctionTable[138307] = bhEne01_CheckMtnTbl_0x186df0; // 0x187114 - g_ps2RecompiledFunctionTable[138308] = bhEne01_CheckMtnTbl_0x186df0; // 0x187118 - g_ps2RecompiledFunctionTable[138309] = bhEne01_CheckMtnTbl_0x186df0; // 0x18711c - g_ps2RecompiledFunctionTable[138310] = bhEne01_CheckMtnTbl_0x186df0; // 0x187120 - g_ps2RecompiledFunctionTable[138311] = bhEne01_CheckMtnTbl_0x186df0; // 0x187124 - g_ps2RecompiledFunctionTable[138312] = bhEne01_CheckMtnTbl_0x186df0; // 0x187128 - g_ps2RecompiledFunctionTable[138313] = bhEne01_CheckMtnTbl_0x186df0; // 0x18712c - g_ps2RecompiledFunctionTable[138314] = bhEne01_CheckMtnTbl_0x186df0; // 0x187130 - g_ps2RecompiledFunctionTable[138315] = bhEne01_CheckMtnTbl_0x186df0; // 0x187134 - g_ps2RecompiledFunctionTable[138316] = bhEne01_CheckMtnTbl_0x186df0; // 0x187138 - g_ps2RecompiledFunctionTable[138317] = bhEne01_CheckMtnTbl_0x186df0; // 0x18713c - g_ps2RecompiledFunctionTable[138318] = bhEne01_CheckMtnTbl_0x186df0; // 0x187140 - g_ps2RecompiledFunctionTable[138319] = bhEne01_CheckMtnTbl_0x186df0; // 0x187144 - g_ps2RecompiledFunctionTable[138320] = bhEne01_CheckMtnTbl_0x186df0; // 0x187148 - g_ps2RecompiledFunctionTable[138321] = bhEne01_CheckMtnTbl_0x186df0; // 0x18714c - g_ps2RecompiledFunctionTable[138322] = bhEne01_CheckMtnTbl_0x186df0; // 0x187150 - g_ps2RecompiledFunctionTable[138323] = bhEne01_CheckMtnTbl_0x186df0; // 0x187154 - g_ps2RecompiledFunctionTable[138324] = bhEne01_CheckMtnTbl_0x186df0; // 0x187158 - g_ps2RecompiledFunctionTable[138325] = bhEne01_CheckMtnTbl_0x186df0; // 0x18715c - g_ps2RecompiledFunctionTable[138326] = bhEne01_CheckMtnTbl_0x186df0; // 0x187160 - g_ps2RecompiledFunctionTable[138327] = bhEne01_CheckMtnTbl_0x186df0; // 0x187164 - g_ps2RecompiledFunctionTable[138328] = bhEne01_CheckMtnTbl_0x186df0; // 0x187168 - g_ps2RecompiledFunctionTable[138329] = bhEne01_CheckMtnTbl_0x186df0; // 0x18716c - g_ps2RecompiledFunctionTable[138330] = bhEne01_CheckMtnTbl_0x186df0; // 0x187170 - g_ps2RecompiledFunctionTable[138331] = bhEne01_CheckMtnTbl_0x186df0; // 0x187174 - g_ps2RecompiledFunctionTable[138332] = bhEne01_CheckMtnTbl_0x186df0; // 0x187178 - g_ps2RecompiledFunctionTable[138333] = bhEne01_CheckMtnTbl_0x186df0; // 0x18717c - g_ps2RecompiledFunctionTable[138334] = bhEne01_CheckMtnTbl_0x186df0; // 0x187180 - g_ps2RecompiledFunctionTable[138335] = bhEne01_CheckMtnTbl_0x186df0; // 0x187184 - g_ps2RecompiledFunctionTable[138336] = bhEne01_CheckMtnTbl_0x186df0; // 0x187188 - g_ps2RecompiledFunctionTable[138337] = bhEne01_CheckMtnTbl_0x186df0; // 0x18718c - g_ps2RecompiledFunctionTable[138338] = bhEne01_CheckMtnTbl_0x186df0; // 0x187190 - g_ps2RecompiledFunctionTable[138339] = bhEne01_CheckMtnTbl_0x186df0; // 0x187194 - g_ps2RecompiledFunctionTable[138340] = bhEne01_CheckMtnTbl_0x186df0; // 0x187198 - g_ps2RecompiledFunctionTable[138341] = bhEne01_CheckMtnTbl_0x186df0; // 0x18719c - g_ps2RecompiledFunctionTable[138342] = bhEne01_CheckMtnTbl_0x186df0; // 0x1871a0 - g_ps2RecompiledFunctionTable[138343] = bhEne01_CheckMtnTbl_0x186df0; // 0x1871a4 - g_ps2RecompiledFunctionTable[138344] = bhEne01_CheckMtnTbl_0x186df0; // 0x1871a8 - g_ps2RecompiledFunctionTable[138345] = bhEne01_CheckMtnTbl_0x186df0; // 0x1871ac - g_ps2RecompiledFunctionTable[138346] = bhEne01_CheckMtnTbl_0x186df0; // 0x1871b0 - g_ps2RecompiledFunctionTable[138347] = bhEne01_CheckMtnTbl_0x186df0; // 0x1871b4 - g_ps2RecompiledFunctionTable[138348] = bhEne01_CheckMtnTbl_0x186df0; // 0x1871b8 - g_ps2RecompiledFunctionTable[138349] = bhEne01_CheckMtnTbl_0x186df0; // 0x1871bc - g_ps2RecompiledFunctionTable[138350] = bhEne01_CheckMtnTbl_0x186df0; // 0x1871c0 - g_ps2RecompiledFunctionTable[138351] = bhEne01_CheckMtnTbl_0x186df0; // 0x1871c4 - g_ps2RecompiledFunctionTable[138352] = bhEne01_CheckMtnTbl_0x186df0; // 0x1871c8 - g_ps2RecompiledFunctionTable[138353] = bhEne01_CheckMtnTbl_0x186df0; // 0x1871cc - g_ps2RecompiledFunctionTable[138354] = bhEne01_CheckMtnTbl_0x186df0; // 0x1871d0 - g_ps2RecompiledFunctionTable[138355] = bhEne01_CheckMtnTbl_0x186df0; // 0x1871d4 - g_ps2RecompiledFunctionTable[138356] = bhEne01_CheckMtnTbl_0x186df0; // 0x1871d8 - g_ps2RecompiledFunctionTable[138357] = bhEne01_CheckMtnTbl_0x186df0; // 0x1871dc - g_ps2RecompiledFunctionTable[138358] = bhEne01_CheckMtnTbl_0x186df0; // 0x1871e0 - g_ps2RecompiledFunctionTable[138359] = bhEne01_CheckMtnTbl_0x186df0; // 0x1871e4 - g_ps2RecompiledFunctionTable[138360] = bhEne01_CheckMtnTbl_0x186df0; // 0x1871e8 - g_ps2RecompiledFunctionTable[138361] = bhEne01_CheckMtnTbl_0x186df0; // 0x1871ec - g_ps2RecompiledFunctionTable[138362] = bhEne01_CheckMtnTbl_0x186df0; // 0x1871f0 - g_ps2RecompiledFunctionTable[138363] = bhEne01_CheckMtnTbl_0x186df0; // 0x1871f4 - g_ps2RecompiledFunctionTable[138364] = bhEne01_CheckMtnTbl_0x186df0; // 0x1871f8 - g_ps2RecompiledFunctionTable[138365] = bhEne01_CheckMtnTbl_0x186df0; // 0x1871fc - g_ps2RecompiledFunctionTable[138366] = bhEne01_CheckMtnTbl_0x186df0; // 0x187200 - g_ps2RecompiledFunctionTable[138367] = bhEne01_CheckMtnTbl_0x186df0; // 0x187204 - g_ps2RecompiledFunctionTable[138368] = bhEne01_CheckMtnTbl_0x186df0; // 0x187208 - g_ps2RecompiledFunctionTable[138369] = bhEne01_CheckMtnTbl_0x186df0; // 0x18720c - g_ps2RecompiledFunctionTable[138370] = bhEne01_CheckMtnTbl_0x186df0; // 0x187210 - g_ps2RecompiledFunctionTable[138371] = bhEne01_CheckMtnTbl_0x186df0; // 0x187214 - g_ps2RecompiledFunctionTable[138372] = bhEne01_CheckMtnTbl_0x186df0; // 0x187218 - g_ps2RecompiledFunctionTable[138373] = bhEne01_CheckMtnTbl_0x186df0; // 0x18721c - g_ps2RecompiledFunctionTable[138374] = bhEne01_CheckMtnTbl_0x186df0; // 0x187220 - g_ps2RecompiledFunctionTable[138375] = bhEne01_CheckMtnTbl_0x186df0; // 0x187224 - g_ps2RecompiledFunctionTable[138376] = bhEne01_CheckMtnTbl_0x186df0; // 0x187228 - g_ps2RecompiledFunctionTable[138377] = bhEne01_CheckMtnTbl_0x186df0; // 0x18722c - g_ps2RecompiledFunctionTable[138378] = bhEne01_CheckMtnTbl_0x186df0; // 0x187230 - g_ps2RecompiledFunctionTable[138379] = bhEne01_CheckMtnTbl_0x186df0; // 0x187234 - g_ps2RecompiledFunctionTable[138380] = bhEne01_CheckMtnTbl_0x186df0; // 0x187238 - g_ps2RecompiledFunctionTable[138381] = bhEne01_CheckMtnTbl_0x186df0; // 0x18723c - g_ps2RecompiledFunctionTable[138382] = bhEne01_CheckMtnTbl_0x186df0; // 0x187240 - g_ps2RecompiledFunctionTable[138383] = bhEne01_CheckMtnTbl_0x186df0; // 0x187244 - g_ps2RecompiledFunctionTable[138384] = bhEne01_CheckMtnTbl_0x186df0; // 0x187248 - g_ps2RecompiledFunctionTable[138385] = bhEne01_CheckMtnTbl_0x186df0; // 0x18724c - g_ps2RecompiledFunctionTable[138386] = bhEne01_CheckMtnTbl_0x186df0; // 0x187250 - g_ps2RecompiledFunctionTable[138387] = bhEne01_CheckMtnTbl_0x186df0; // 0x187254 - g_ps2RecompiledFunctionTable[138388] = bhEne01_CheckMtnTbl_0x186df0; // 0x187258 - g_ps2RecompiledFunctionTable[138389] = bhEne01_CheckMtnTbl_0x186df0; // 0x18725c - g_ps2RecompiledFunctionTable[138390] = bhEne01_CheckMtnTbl_0x186df0; // 0x187260 - g_ps2RecompiledFunctionTable[138391] = bhEne01_CheckMtnTbl_0x186df0; // 0x187264 - g_ps2RecompiledFunctionTable[138392] = bhEne01_CheckMtnTbl_0x186df0; // 0x187268 - g_ps2RecompiledFunctionTable[138393] = bhEne01_CheckMtnTbl_0x186df0; // 0x18726c - g_ps2RecompiledFunctionTable[138394] = bhEne01_CheckMtnTbl_0x186df0; // 0x187270 - g_ps2RecompiledFunctionTable[138395] = bhEne01_CheckMtnTbl_0x186df0; // 0x187274 - g_ps2RecompiledFunctionTable[138396] = bhEne01_CheckMtnTbl_0x186df0; // 0x187278 - g_ps2RecompiledFunctionTable[138397] = bhEne01_CheckMtnTbl_0x186df0; // 0x18727c - g_ps2RecompiledFunctionTable[138398] = bhEne01_CheckMtnTbl_0x186df0; // 0x187280 - g_ps2RecompiledFunctionTable[138399] = bhEne01_CheckMtnTbl_0x186df0; // 0x187284 - g_ps2RecompiledFunctionTable[138400] = bhEne01_CheckMtnTbl_0x186df0; // 0x187288 - g_ps2RecompiledFunctionTable[138401] = bhEne01_CheckMtnTbl_0x186df0; // 0x18728c - g_ps2RecompiledFunctionTable[138402] = bhEne01_CheckMtnTbl_0x186df0; // 0x187290 - g_ps2RecompiledFunctionTable[138403] = bhEne01_CheckMtnTbl_0x186df0; // 0x187294 - g_ps2RecompiledFunctionTable[138404] = bhEne01_CheckMtnTbl_0x186df0; // 0x187298 - g_ps2RecompiledFunctionTable[138405] = bhEne01_CheckMtnTbl_0x186df0; // 0x18729c - g_ps2RecompiledFunctionTable[138406] = bhEne01_CheckMtnTbl_0x186df0; // 0x1872a0 - g_ps2RecompiledFunctionTable[138407] = bhEne01_CheckMtnTbl_0x186df0; // 0x1872a4 - g_ps2RecompiledFunctionTable[138408] = bhEne01_CheckMtnTbl_0x186df0; // 0x1872a8 - g_ps2RecompiledFunctionTable[138409] = bhEne01_CheckMtnTbl_0x186df0; // 0x1872ac - g_ps2RecompiledFunctionTable[138410] = bhEne01_CheckMtnTbl_0x186df0; // 0x1872b0 - g_ps2RecompiledFunctionTable[138411] = bhEne01_CheckMtnTbl_0x186df0; // 0x1872b4 - g_ps2RecompiledFunctionTable[138412] = bhEne01_CheckMtnTbl_0x186df0; // 0x1872b8 - g_ps2RecompiledFunctionTable[138413] = bhEne01_CheckMtnTbl_0x186df0; // 0x1872bc - g_ps2RecompiledFunctionTable[138414] = bhEne01_CheckMtnTbl_0x186df0; // 0x1872c0 - g_ps2RecompiledFunctionTable[138415] = bhEne01_CheckMtnTbl_0x186df0; // 0x1872c4 - g_ps2RecompiledFunctionTable[138416] = bhEne01_CheckMtnTbl_0x186df0; // 0x1872c8 - g_ps2RecompiledFunctionTable[138417] = bhEne01_CheckMtnTbl_0x186df0; // 0x1872cc - g_ps2RecompiledFunctionTable[138418] = bhEne01_CheckMtnTbl_0x186df0; // 0x1872d0 - g_ps2RecompiledFunctionTable[138419] = bhEne01_CheckMtnTbl_0x186df0; // 0x1872d4 - g_ps2RecompiledFunctionTable[138420] = bhEne01_CheckMtnTbl_0x186df0; // 0x1872d8 - g_ps2RecompiledFunctionTable[138421] = bhEne01_CheckMtnTbl_0x186df0; // 0x1872dc - g_ps2RecompiledFunctionTable[138422] = bhEne01_CheckMtnTbl_0x186df0; // 0x1872e0 - g_ps2RecompiledFunctionTable[138423] = bhEne01_CheckMtnTbl_0x186df0; // 0x1872e4 - g_ps2RecompiledFunctionTable[138424] = bhEne01_CheckMtnTbl_0x186df0; // 0x1872e8 - g_ps2RecompiledFunctionTable[138425] = bhEne01_CheckMtnTbl_0x186df0; // 0x1872ec - g_ps2RecompiledFunctionTable[138426] = bhEne01_CheckMtnTbl_0x186df0; // 0x1872f0 - g_ps2RecompiledFunctionTable[138427] = bhEne01_CheckMtnTbl_0x186df0; // 0x1872f4 - g_ps2RecompiledFunctionTable[138428] = bhEne01_CheckMtnTbl_0x186df0; // 0x1872f8 - g_ps2RecompiledFunctionTable[138429] = bhEne01_CheckMtnTbl_0x186df0; // 0x1872fc - g_ps2RecompiledFunctionTable[138430] = bhEne01_CheckMtnTbl_0x186df0; // 0x187300 - g_ps2RecompiledFunctionTable[138431] = bhEne01_CheckMtnTbl_0x186df0; // 0x187304 - g_ps2RecompiledFunctionTable[138432] = bhEne01_CheckMtnTbl_0x186df0; // 0x187308 - g_ps2RecompiledFunctionTable[138433] = bhEne01_CheckMtnTbl_0x186df0; // 0x18730c - g_ps2RecompiledFunctionTable[138434] = bhEne01_CheckMtnTbl_0x186df0; // 0x187310 - g_ps2RecompiledFunctionTable[138435] = bhEne01_CheckMtnTbl_0x186df0; // 0x187314 - g_ps2RecompiledFunctionTable[138436] = bhEne01_CheckMtnTbl_0x186df0; // 0x187318 - g_ps2RecompiledFunctionTable[138437] = bhEne01_CheckMtnTbl_0x186df0; // 0x18731c - g_ps2RecompiledFunctionTable[138438] = bhEne01_CheckMtnTbl_0x186df0; // 0x187320 - g_ps2RecompiledFunctionTable[138439] = bhEne01_CheckMtnTbl_0x186df0; // 0x187324 - g_ps2RecompiledFunctionTable[138440] = bhEne01_CheckMtnTbl_0x186df0; // 0x187328 - g_ps2RecompiledFunctionTable[138441] = bhEne01_CheckMtnTbl_0x186df0; // 0x18732c - g_ps2RecompiledFunctionTable[138442] = bhEne01_CheckMtnTbl_0x186df0; // 0x187330 - g_ps2RecompiledFunctionTable[138443] = bhEne01_CheckMtnTbl_0x186df0; // 0x187334 - g_ps2RecompiledFunctionTable[138444] = bhEne01_CheckMtnTbl_0x186df0; // 0x187338 - g_ps2RecompiledFunctionTable[138445] = bhEne01_CheckMtnTbl_0x186df0; // 0x18733c - g_ps2RecompiledFunctionTable[138446] = bhEne01_CheckMtnTbl_0x186df0; // 0x187340 - g_ps2RecompiledFunctionTable[138447] = bhEne01_CheckMtnTbl_0x186df0; // 0x187344 - g_ps2RecompiledFunctionTable[138448] = bhEne01_CheckMtnTbl_0x186df0; // 0x187348 - g_ps2RecompiledFunctionTable[138449] = bhEne01_CheckMtnTbl_0x186df0; // 0x18734c - g_ps2RecompiledFunctionTable[138450] = bhEne01_CheckMtnTbl_0x186df0; // 0x187350 - g_ps2RecompiledFunctionTable[138451] = bhEne01_CheckMtnTbl_0x186df0; // 0x187354 - g_ps2RecompiledFunctionTable[138452] = bhEne01_CheckMtnTbl_0x186df0; // 0x187358 - g_ps2RecompiledFunctionTable[138453] = bhEne01_CheckMtnTbl_0x186df0; // 0x18735c - g_ps2RecompiledFunctionTable[138454] = bhEne01_CheckMtnTbl_0x186df0; // 0x187360 - g_ps2RecompiledFunctionTable[138455] = bhEne01_CheckMtnTbl_0x186df0; // 0x187364 - g_ps2RecompiledFunctionTable[138456] = bhEne01_CheckMtnTbl_0x186df0; // 0x187368 - g_ps2RecompiledFunctionTable[138457] = bhEne01_CheckMtnTbl_0x186df0; // 0x18736c - g_ps2RecompiledFunctionTable[138458] = bhEne01_CheckMtnTbl_0x186df0; // 0x187370 - g_ps2RecompiledFunctionTable[138459] = bhEne01_CheckMtnTbl_0x186df0; // 0x187374 - g_ps2RecompiledFunctionTable[138460] = bhEne01_CheckMtnTbl_0x186df0; // 0x187378 - g_ps2RecompiledFunctionTable[138461] = bhEne01_CheckMtnTbl_0x186df0; // 0x18737c - g_ps2RecompiledFunctionTable[138462] = bhEne01_CheckMtnTbl_0x186df0; // 0x187380 - g_ps2RecompiledFunctionTable[138463] = bhEne01_CheckMtnTbl_0x186df0; // 0x187384 - g_ps2RecompiledFunctionTable[138464] = bhEne01_CheckMtnTbl_0x186df0; // 0x187388 - g_ps2RecompiledFunctionTable[138465] = bhEne01_CheckMtnTbl_0x186df0; // 0x18738c - g_ps2RecompiledFunctionTable[138466] = bhEne01_CheckMtnTbl_0x186df0; // 0x187390 - g_ps2RecompiledFunctionTable[138467] = bhEne01_CheckMtnTbl_0x186df0; // 0x187394 - g_ps2RecompiledFunctionTable[138468] = bhEne01_CheckMtnTbl_0x186df0; // 0x187398 - g_ps2RecompiledFunctionTable[138469] = bhEne01_CheckMtnTbl_0x186df0; // 0x18739c - g_ps2RecompiledFunctionTable[138470] = bhEne01_CheckMtnTbl_0x186df0; // 0x1873a0 - g_ps2RecompiledFunctionTable[138471] = bhEne01_CheckMtnTbl_0x186df0; // 0x1873a4 - g_ps2RecompiledFunctionTable[138472] = bhEne01_CheckMtnTbl_0x186df0; // 0x1873a8 - g_ps2RecompiledFunctionTable[138473] = bhEne01_CheckMtnTbl_0x186df0; // 0x1873ac - g_ps2RecompiledFunctionTable[138474] = bhEne01_CheckMtnTbl_0x186df0; // 0x1873b0 - g_ps2RecompiledFunctionTable[138475] = bhEne01_CheckMtnTbl_0x186df0; // 0x1873b4 - g_ps2RecompiledFunctionTable[138476] = bhEne01_CheckMtnTbl_0x186df0; // 0x1873b8 - g_ps2RecompiledFunctionTable[138477] = bhEne01_CheckMtnTbl_0x186df0; // 0x1873bc - g_ps2RecompiledFunctionTable[138478] = bhEne01_CheckMtnTbl_0x186df0; // 0x1873c0 - g_ps2RecompiledFunctionTable[138479] = bhEne01_CheckMtnTbl_0x186df0; // 0x1873c4 - g_ps2RecompiledFunctionTable[138480] = bhEne01_CheckMtnTbl_0x186df0; // 0x1873c8 - g_ps2RecompiledFunctionTable[138481] = bhEne01_CheckMtnTbl_0x186df0; // 0x1873cc - g_ps2RecompiledFunctionTable[138482] = bhEne01_CheckMtnTbl_0x186df0; // 0x1873d0 - g_ps2RecompiledFunctionTable[138483] = bhEne01_CheckMtnTbl_0x186df0; // 0x1873d4 - g_ps2RecompiledFunctionTable[138484] = bhEne01_CheckMtnTbl_0x186df0; // 0x1873d8 - g_ps2RecompiledFunctionTable[138485] = bhEne01_CheckMtnTbl_0x186df0; // 0x1873dc - g_ps2RecompiledFunctionTable[138486] = bhEne01_CheckMtnTbl_0x186df0; // 0x1873e0 - g_ps2RecompiledFunctionTable[138487] = bhEne01_CheckMtnTbl_0x186df0; // 0x1873e4 - g_ps2RecompiledFunctionTable[138488] = bhEne01_CheckMtnTbl_0x186df0; // 0x1873e8 - g_ps2RecompiledFunctionTable[138489] = bhEne01_CheckMtnTbl_0x186df0; // 0x1873ec - g_ps2RecompiledFunctionTable[138490] = bhEne01_CheckMtnTbl_0x186df0; // 0x1873f0 - g_ps2RecompiledFunctionTable[138491] = bhEne01_CheckMtnTbl_0x186df0; // 0x1873f4 - g_ps2RecompiledFunctionTable[138492] = bhEne01_CheckMtnTbl_0x186df0; // 0x1873f8 - g_ps2RecompiledFunctionTable[138493] = bhEne01_CheckMtnTbl_0x186df0; // 0x1873fc - g_ps2RecompiledFunctionTable[138494] = bhEne01_CheckMtnTbl_0x186df0; // 0x187400 - g_ps2RecompiledFunctionTable[138495] = bhEne01_CheckMtnTbl_0x186df0; // 0x187404 - g_ps2RecompiledFunctionTable[138496] = bhEne01_CheckMtnTbl_0x186df0; // 0x187408 - g_ps2RecompiledFunctionTable[138497] = bhEne01_CheckMtnTbl_0x186df0; // 0x18740c - g_ps2RecompiledFunctionTable[138498] = bhEne01_CheckMtnTbl_0x186df0; // 0x187410 - g_ps2RecompiledFunctionTable[138499] = bhEne01_CheckMtnTbl_0x186df0; // 0x187414 - g_ps2RecompiledFunctionTable[138500] = bhEne01_CheckMtnTbl_0x186df0; // 0x187418 - g_ps2RecompiledFunctionTable[138501] = bhEne01_CheckMtnTbl_0x186df0; // 0x18741c - g_ps2RecompiledFunctionTable[138502] = bhEne01_CheckMtnTbl_0x186df0; // 0x187420 - g_ps2RecompiledFunctionTable[138503] = bhEne01_CheckMtnTbl_0x186df0; // 0x187424 - g_ps2RecompiledFunctionTable[138504] = bhEne01_CheckMtnTbl_0x186df0; // 0x187428 - g_ps2RecompiledFunctionTable[138505] = bhEne01_CheckMtnTbl_0x186df0; // 0x18742c - g_ps2RecompiledFunctionTable[138506] = bhEne01_CheckMtnTbl_0x186df0; // 0x187430 - g_ps2RecompiledFunctionTable[138507] = bhEne01_CheckMtnTbl_0x186df0; // 0x187434 - g_ps2RecompiledFunctionTable[138508] = bhEne01_CheckMtnTbl_0x186df0; // 0x187438 - g_ps2RecompiledFunctionTable[138509] = bhEne01_CheckMtnTbl_0x186df0; // 0x18743c - g_ps2RecompiledFunctionTable[138510] = bhEne01_CheckMtnTbl_0x186df0; // 0x187440 - g_ps2RecompiledFunctionTable[138511] = bhEne01_CheckMtnTbl_0x186df0; // 0x187444 - g_ps2RecompiledFunctionTable[138512] = bhEne01_CheckMtnTbl_0x186df0; // 0x187448 - g_ps2RecompiledFunctionTable[138513] = bhEne01_CheckMtnTbl_0x186df0; // 0x18744c - g_ps2RecompiledFunctionTable[138514] = bhEne01_CheckMtnTbl_0x186df0; // 0x187450 - g_ps2RecompiledFunctionTable[138515] = bhEne01_CheckMtnTbl_0x186df0; // 0x187454 - g_ps2RecompiledFunctionTable[138516] = bhEne01_CheckMtnTbl_0x186df0; // 0x187458 - g_ps2RecompiledFunctionTable[138517] = bhEne01_CheckMtnTbl_0x186df0; // 0x18745c - g_ps2RecompiledFunctionTable[138518] = bhEne01_CheckMtnTbl_0x186df0; // 0x187460 - g_ps2RecompiledFunctionTable[138519] = bhEne01_CheckMtnTbl_0x186df0; // 0x187464 - g_ps2RecompiledFunctionTable[138520] = bhEne01_CheckMtnTbl_0x186df0; // 0x187468 - g_ps2RecompiledFunctionTable[138521] = bhEne01_CheckMtnTbl_0x186df0; // 0x18746c - g_ps2RecompiledFunctionTable[138522] = bhEne01_CheckMtnTbl_0x186df0; // 0x187470 - g_ps2RecompiledFunctionTable[138523] = bhEne01_CheckMtnTbl_0x186df0; // 0x187474 - g_ps2RecompiledFunctionTable[138524] = bhEne01_CheckMtnTbl_0x186df0; // 0x187478 - g_ps2RecompiledFunctionTable[138525] = bhEne01_CheckMtnTbl_0x186df0; // 0x18747c - g_ps2RecompiledFunctionTable[138526] = bhEne01_CheckMtnTbl_0x186df0; // 0x187480 - g_ps2RecompiledFunctionTable[138527] = bhEne01_CheckMtnTbl_0x186df0; // 0x187484 - g_ps2RecompiledFunctionTable[138528] = bhEne01_CheckMtnTbl_0x186df0; // 0x187488 - g_ps2RecompiledFunctionTable[138529] = bhEne01_CheckMtnTbl_0x186df0; // 0x18748c - g_ps2RecompiledFunctionTable[138530] = bhEne01_CheckMtnTbl_0x186df0; // 0x187490 - g_ps2RecompiledFunctionTable[138531] = bhEne01_CheckMtnTbl_0x186df0; // 0x187494 - g_ps2RecompiledFunctionTable[138532] = bhEne01_CheckMtnTbl_0x186df0; // 0x187498 - g_ps2RecompiledFunctionTable[138533] = bhEne01_CheckMtnTbl_0x186df0; // 0x18749c - g_ps2RecompiledFunctionTable[138534] = bhEne01_CheckMtnTbl_0x186df0; // 0x1874a0 - g_ps2RecompiledFunctionTable[138535] = bhEne01_CheckMtnTbl_0x186df0; // 0x1874a4 - g_ps2RecompiledFunctionTable[138536] = bhEne01_CheckMtnTbl_0x186df0; // 0x1874a8 - g_ps2RecompiledFunctionTable[138537] = bhEne01_CheckMtnTbl_0x186df0; // 0x1874ac - g_ps2RecompiledFunctionTable[138538] = bhEne01_CheckMtnTbl_0x186df0; // 0x1874b0 - g_ps2RecompiledFunctionTable[138539] = bhEne01_CheckMtnTbl_0x186df0; // 0x1874b4 - g_ps2RecompiledFunctionTable[138540] = bhEne01_CheckMtnTbl_0x186df0; // 0x1874b8 - g_ps2RecompiledFunctionTable[138541] = bhEne01_CheckMtnTbl_0x186df0; // 0x1874bc - g_ps2RecompiledFunctionTable[138542] = bhEne01_CheckMtnTbl_0x186df0; // 0x1874c0 - g_ps2RecompiledFunctionTable[138543] = bhEne01_CheckMtnTbl_0x186df0; // 0x1874c4 - g_ps2RecompiledFunctionTable[138544] = bhEne01_CheckMtnTbl_0x186df0; // 0x1874c8 - g_ps2RecompiledFunctionTable[138545] = bhEne01_CheckMtnTbl_0x186df0; // 0x1874cc - g_ps2RecompiledFunctionTable[138546] = bhEne01_CheckMtnTbl_0x186df0; // 0x1874d0 - g_ps2RecompiledFunctionTable[138547] = bhEne01_CheckMtnTbl_0x186df0; // 0x1874d4 - g_ps2RecompiledFunctionTable[138548] = bhEne01_CheckMtnTbl_0x186df0; // 0x1874d8 - g_ps2RecompiledFunctionTable[138549] = bhEne01_CheckMtnTbl_0x186df0; // 0x1874dc - g_ps2RecompiledFunctionTable[138550] = bhEne01_CheckMtnTbl_0x186df0; // 0x1874e0 - g_ps2RecompiledFunctionTable[138551] = bhEne01_CheckMtnTbl_0x186df0; // 0x1874e4 - g_ps2RecompiledFunctionTable[138552] = bhEne01_CheckMtnTbl_0x186df0; // 0x1874e8 - g_ps2RecompiledFunctionTable[138553] = bhEne01_CheckMtnTbl_0x186df0; // 0x1874ec - g_ps2RecompiledFunctionTable[138554] = bhEne01_CheckMtnTbl_0x186df0; // 0x1874f0 - g_ps2RecompiledFunctionTable[138555] = bhEne01_CheckMtnTbl_0x186df0; // 0x1874f4 - g_ps2RecompiledFunctionTable[138556] = bhEne01_CheckMtnTbl_0x186df0; // 0x1874f8 - g_ps2RecompiledFunctionTable[138557] = bhEne01_CheckMtnTbl_0x186df0; // 0x1874fc - g_ps2RecompiledFunctionTable[138558] = bhEne01_CheckMtnTbl_0x186df0; // 0x187500 - g_ps2RecompiledFunctionTable[138559] = bhEne01_CheckMtnTbl_0x186df0; // 0x187504 - g_ps2RecompiledFunctionTable[138560] = bhEne01_CheckMtnTbl_0x186df0; // 0x187508 - g_ps2RecompiledFunctionTable[138561] = bhEne01_CheckMtnTbl_0x186df0; // 0x18750c - g_ps2RecompiledFunctionTable[138562] = bhEne01_CheckMtnTbl_0x186df0; // 0x187510 - g_ps2RecompiledFunctionTable[138563] = bhEne01_CheckMtnTbl_0x186df0; // 0x187514 - g_ps2RecompiledFunctionTable[138564] = bhEne01_CheckMtnTbl_0x186df0; // 0x187518 - g_ps2RecompiledFunctionTable[138565] = bhEne01_CheckMtnTbl_0x186df0; // 0x18751c - g_ps2RecompiledFunctionTable[138566] = bhEne01_CheckMtnTbl_0x186df0; // 0x187520 - g_ps2RecompiledFunctionTable[138567] = bhEne01_CheckMtnTbl_0x186df0; // 0x187524 - g_ps2RecompiledFunctionTable[138568] = bhEne01_CheckMtnTbl_0x186df0; // 0x187528 - g_ps2RecompiledFunctionTable[138569] = bhEne01_CheckMtnTbl_0x186df0; // 0x18752c - g_ps2RecompiledFunctionTable[138570] = bhEne01_CheckMtnTbl_0x186df0; // 0x187530 - g_ps2RecompiledFunctionTable[138571] = bhEne01_CheckMtnTbl_0x186df0; // 0x187534 - g_ps2RecompiledFunctionTable[138572] = bhEne01_CheckMtnTbl_0x186df0; // 0x187538 - g_ps2RecompiledFunctionTable[138574] = bhEne01_KamiEffect_0x187540; // 0x187540 - g_ps2RecompiledFunctionTable[138583] = bhEne01_KamiEffect_0x187540; // 0x187564 - g_ps2RecompiledFunctionTable[138592] = bhEne01_KamiEffect_0x187540; // 0x187588 - g_ps2RecompiledFunctionTable[138607] = bhEne01_KamiEffect_0x187540; // 0x1875c4 - g_ps2RecompiledFunctionTable[138616] = bhEne01_KamiEffect_0x187540; // 0x1875e8 - g_ps2RecompiledFunctionTable[138630] = bhEne01_WaterEffect_0x187620; // 0x187620 - g_ps2RecompiledFunctionTable[138647] = bhEne01_WaterEffect_0x187620; // 0x187664 - g_ps2RecompiledFunctionTable[138656] = bhEne01_WaterEffect_0x187620; // 0x187688 - g_ps2RecompiledFunctionTable[138671] = bhEne01_WaterEffect_0x187620; // 0x1876c4 - g_ps2RecompiledFunctionTable[138682] = bhEne01_WaterEffect_0x187620; // 0x1876f0 - g_ps2RecompiledFunctionTable[138685] = bhEne01_WaterEffect_0x187620; // 0x1876fc - g_ps2RecompiledFunctionTable[138689] = bhEne01_WaterEffect_0x187620; // 0x18770c - g_ps2RecompiledFunctionTable[138720] = bhEne01_WaterEffect_0x187620; // 0x187788 - g_ps2RecompiledFunctionTable[138734] = bhEne01_WaterEffect_0x187620; // 0x1877c0 - g_ps2RecompiledFunctionTable[138744] = bhEne01_WaterEffect_0x187620; // 0x1877e8 - g_ps2RecompiledFunctionTable[138762] = bhEne01_NeckBloodEffect_0x187830; // 0x187830 - g_ps2RecompiledFunctionTable[138782] = bhEne01_NeckBloodEffect_0x187830; // 0x187880 - g_ps2RecompiledFunctionTable[138789] = bhEne01_NeckBloodEffect_0x187830; // 0x18789c - g_ps2RecompiledFunctionTable[138792] = bhEne01_NeckBloodEffect_0x187830; // 0x1878a8 - g_ps2RecompiledFunctionTable[138797] = bhEne01_NeckBloodEffect_0x187830; // 0x1878bc - g_ps2RecompiledFunctionTable[138801] = bhEne01_NeckBloodEffect_0x187830; // 0x1878cc - g_ps2RecompiledFunctionTable[138804] = bhEne01_NeckBloodEffect_0x187830; // 0x1878d8 - g_ps2RecompiledFunctionTable[138811] = bhEne01_NeckBloodEffect_0x187830; // 0x1878f4 - g_ps2RecompiledFunctionTable[138820] = bhEne01_NeckBloodEffect_0x187830; // 0x187918 - g_ps2RecompiledFunctionTable[138822] = bhEne01_NeckBloodEffect_0x187830; // 0x187920 - g_ps2RecompiledFunctionTable[138825] = bhEne01_NeckBloodEffect_0x187830; // 0x18792c - g_ps2RecompiledFunctionTable[138830] = bhEne01_NeckBloodEffect_0x187830; // 0x187940 - g_ps2RecompiledFunctionTable[138833] = bhEne01_NeckBloodEffect_0x187830; // 0x18794c - g_ps2RecompiledFunctionTable[138836] = bhEne01_NeckBloodEffect_0x187830; // 0x187958 - g_ps2RecompiledFunctionTable[138842] = bhEne01_NeckBloodEffect_0x187830; // 0x187970 - g_ps2RecompiledFunctionTable[138851] = bhEne01_NeckBloodEffect_0x187830; // 0x187994 - g_ps2RecompiledFunctionTable[138866] = bhEne01_NeckBloodEffect2_0x1879d0; // 0x1879d0 - g_ps2RecompiledFunctionTable[138896] = bhEne01_NeckBloodEffect2_0x1879d0; // 0x187a48 - g_ps2RecompiledFunctionTable[138901] = bhEne01_NeckBloodEffect2_0x1879d0; // 0x187a5c - g_ps2RecompiledFunctionTable[138904] = bhEne01_NeckBloodEffect2_0x1879d0; // 0x187a68 - g_ps2RecompiledFunctionTable[138909] = bhEne01_NeckBloodEffect2_0x1879d0; // 0x187a7c - g_ps2RecompiledFunctionTable[138913] = bhEne01_NeckBloodEffect2_0x1879d0; // 0x187a8c - g_ps2RecompiledFunctionTable[138916] = bhEne01_NeckBloodEffect2_0x1879d0; // 0x187a98 - g_ps2RecompiledFunctionTable[138923] = bhEne01_NeckBloodEffect2_0x1879d0; // 0x187ab4 - g_ps2RecompiledFunctionTable[138932] = bhEne01_NeckBloodEffect2_0x1879d0; // 0x187ad8 - g_ps2RecompiledFunctionTable[138935] = bhEne01_NeckBloodEffect2_0x1879d0; // 0x187ae4 - g_ps2RecompiledFunctionTable[138938] = bhEne01_NeckBloodEffect2_0x1879d0; // 0x187af0 - g_ps2RecompiledFunctionTable[138943] = bhEne01_NeckBloodEffect2_0x1879d0; // 0x187b04 - g_ps2RecompiledFunctionTable[138946] = bhEne01_NeckBloodEffect2_0x1879d0; // 0x187b10 - g_ps2RecompiledFunctionTable[138949] = bhEne01_NeckBloodEffect2_0x1879d0; // 0x187b1c - g_ps2RecompiledFunctionTable[138955] = bhEne01_NeckBloodEffect2_0x1879d0; // 0x187b34 - g_ps2RecompiledFunctionTable[138964] = bhEne01_NeckBloodEffect2_0x1879d0; // 0x187b58 - g_ps2RecompiledFunctionTable[138974] = bhEne01_NeckBloodEffect2_0x1879d0; // 0x187b80 - g_ps2RecompiledFunctionTable[138976] = bhEne01_NeckBloodEffect2_0x1879d0; // 0x187b88 - g_ps2RecompiledFunctionTable[138979] = bhEne01_NeckBloodEffect2_0x1879d0; // 0x187b94 - g_ps2RecompiledFunctionTable[138984] = bhEne01_NeckBloodEffect2_0x1879d0; // 0x187ba8 - g_ps2RecompiledFunctionTable[138987] = bhEne01_NeckBloodEffect2_0x1879d0; // 0x187bb4 - g_ps2RecompiledFunctionTable[138990] = bhEne01_NeckBloodEffect2_0x1879d0; // 0x187bc0 - g_ps2RecompiledFunctionTable[138996] = bhEne01_NeckBloodEffect2_0x1879d0; // 0x187bd8 - g_ps2RecompiledFunctionTable[139005] = bhEne01_NeckBloodEffect2_0x1879d0; // 0x187bfc - g_ps2RecompiledFunctionTable[139015] = bhEne01_NeckBloodEffect2_0x1879d0; // 0x187c24 - g_ps2RecompiledFunctionTable[139017] = bhEne01_NeckBloodEffect2_0x1879d0; // 0x187c2c - g_ps2RecompiledFunctionTable[139020] = bhEne01_NeckBloodEffect2_0x1879d0; // 0x187c38 - g_ps2RecompiledFunctionTable[139025] = bhEne01_NeckBloodEffect2_0x1879d0; // 0x187c4c - g_ps2RecompiledFunctionTable[139028] = bhEne01_NeckBloodEffect2_0x1879d0; // 0x187c58 - g_ps2RecompiledFunctionTable[139031] = bhEne01_NeckBloodEffect2_0x1879d0; // 0x187c64 - g_ps2RecompiledFunctionTable[139037] = bhEne01_NeckBloodEffect2_0x1879d0; // 0x187c7c - g_ps2RecompiledFunctionTable[139046] = bhEne01_NeckBloodEffect2_0x1879d0; // 0x187ca0 - g_ps2RecompiledFunctionTable[139062] = bhEne01_ExpHeadEffect_0x187ce0; // 0x187ce0 - g_ps2RecompiledFunctionTable[139082] = bhEne01_ExpHeadEffect_0x187ce0; // 0x187d30 - g_ps2RecompiledFunctionTable[139084] = bhEne01_ExpHeadEffect_0x187ce0; // 0x187d38 - g_ps2RecompiledFunctionTable[139089] = bhEne01_ExpHeadEffect_0x187ce0; // 0x187d4c - g_ps2RecompiledFunctionTable[139092] = bhEne01_ExpHeadEffect_0x187ce0; // 0x187d58 - g_ps2RecompiledFunctionTable[139096] = bhEne01_ExpHeadEffect_0x187ce0; // 0x187d68 - g_ps2RecompiledFunctionTable[139099] = bhEne01_ExpHeadEffect_0x187ce0; // 0x187d74 - g_ps2RecompiledFunctionTable[139102] = bhEne01_ExpHeadEffect_0x187ce0; // 0x187d80 - g_ps2RecompiledFunctionTable[139107] = bhEne01_ExpHeadEffect_0x187ce0; // 0x187d94 - g_ps2RecompiledFunctionTable[139113] = bhEne01_ExpHeadEffect_0x187ce0; // 0x187dac - g_ps2RecompiledFunctionTable[139126] = bhEne01_ExpHeadEffect2_0x187de0; // 0x187de0 - g_ps2RecompiledFunctionTable[139148] = bhEne01_ExpHeadEffect2_0x187de0; // 0x187e38 - g_ps2RecompiledFunctionTable[139184] = bhEne01_ExpHeadEffect2_0x187de0; // 0x187ec8 - g_ps2RecompiledFunctionTable[139218] = bhEne01_NikuhenEffect_0x187f50; // 0x187f50 - g_ps2RecompiledFunctionTable[139234] = bhEne01_NikuhenEffect_0x187f50; // 0x187f90 - g_ps2RecompiledFunctionTable[139239] = bhEne01_NikuhenEffect_0x187f50; // 0x187fa4 - g_ps2RecompiledFunctionTable[139241] = bhEne01_NikuhenEffect_0x187f50; // 0x187fac - g_ps2RecompiledFunctionTable[139244] = bhEne01_NikuhenEffect_0x187f50; // 0x187fb8 - g_ps2RecompiledFunctionTable[139248] = bhEne01_NikuhenEffect_0x187f50; // 0x187fc8 - g_ps2RecompiledFunctionTable[139251] = bhEne01_NikuhenEffect_0x187f50; // 0x187fd4 - g_ps2RecompiledFunctionTable[139254] = bhEne01_NikuhenEffect_0x187f50; // 0x187fe0 - g_ps2RecompiledFunctionTable[139259] = bhEne01_NikuhenEffect_0x187f50; // 0x187ff4 - g_ps2RecompiledFunctionTable[139265] = bhEne01_NikuhenEffect_0x187f50; // 0x18800c - g_ps2RecompiledFunctionTable[139282] = bhEne01_ExpLegEffect_0x188050; // 0x188050 - g_ps2RecompiledFunctionTable[139309] = bhEne01_ExpLegEffect_0x188050; // 0x1880bc - g_ps2RecompiledFunctionTable[139311] = bhEne01_ExpLegEffect_0x188050; // 0x1880c4 - g_ps2RecompiledFunctionTable[139320] = bhEne01_ExpLegEffect_0x188050; // 0x1880e8 - g_ps2RecompiledFunctionTable[139323] = bhEne01_ExpLegEffect_0x188050; // 0x1880f4 - g_ps2RecompiledFunctionTable[139326] = bhEne01_ExpLegEffect_0x188050; // 0x188100 - g_ps2RecompiledFunctionTable[139330] = bhEne01_ExpLegEffect_0x188050; // 0x188110 - g_ps2RecompiledFunctionTable[139334] = bhEne01_ExpLegEffect_0x188050; // 0x188120 - g_ps2RecompiledFunctionTable[139337] = bhEne01_ExpLegEffect_0x188050; // 0x18812c - g_ps2RecompiledFunctionTable[139341] = bhEne01_ExpLegEffect_0x188050; // 0x18813c - g_ps2RecompiledFunctionTable[139349] = bhEne01_ExpLegEffect_0x188050; // 0x18815c - g_ps2RecompiledFunctionTable[139355] = bhEne01_ExpLegEffect_0x188050; // 0x188174 - g_ps2RecompiledFunctionTable[139430] = bhEne01_ExpLegEffect_0x188050; // 0x1882a0 - g_ps2RecompiledFunctionTable[139438] = bhEne01_ExpLegEffect_0x188050; // 0x1882c0 - g_ps2RecompiledFunctionTable[139440] = bhEne01_ExpLegEffect_0x188050; // 0x1882c8 - g_ps2RecompiledFunctionTable[139442] = bhEne01_ExpLegEffect_0x188050; // 0x1882d0 - g_ps2RecompiledFunctionTable[139486] = bhEne01_ExpLegEffect_0x188050; // 0x188380 - g_ps2RecompiledFunctionTable[139506] = bhEne01_ExpLegEffect_0x188050; // 0x1883d0 - g_ps2RecompiledFunctionTable[139508] = bhEne01_ExpLegEffect_0x188050; // 0x1883d8 - g_ps2RecompiledFunctionTable[139525] = bhEne01_ExpLegEffect_0x188050; // 0x18841c - g_ps2RecompiledFunctionTable[139528] = bhEne01_ExpLegEffect_0x188050; // 0x188428 - g_ps2RecompiledFunctionTable[139532] = bhEne01_ExpLegEffect_0x188050; // 0x188438 - g_ps2RecompiledFunctionTable[139535] = bhEne01_ExpLegEffect_0x188050; // 0x188444 - g_ps2RecompiledFunctionTable[139538] = bhEne01_ExpLegEffect_0x188050; // 0x188450 - g_ps2RecompiledFunctionTable[139566] = bhEne01_ExpWormEffect_0x1884c0; // 0x1884c0 - g_ps2RecompiledFunctionTable[139615] = bhEne01_ExpWormEffect_0x1884c0; // 0x188584 - g_ps2RecompiledFunctionTable[139637] = bhEne01_ExpWormEffect_0x1884c0; // 0x1885dc - g_ps2RecompiledFunctionTable[139640] = bhEne01_ExpWormEffect_0x1884c0; // 0x1885e8 - g_ps2RecompiledFunctionTable[139642] = bhEne01_ExpWormEffect_0x1884c0; // 0x1885f0 - g_ps2RecompiledFunctionTable[139677] = bhEne01_ExpWormEffect_0x1884c0; // 0x18867c - g_ps2RecompiledFunctionTable[139697] = bhEne01_ExpWormEffect_0x1884c0; // 0x1886cc - g_ps2RecompiledFunctionTable[139699] = bhEne01_ExpWormEffect_0x1884c0; // 0x1886d4 - g_ps2RecompiledFunctionTable[139716] = bhEne01_ExpWormEffect_0x1884c0; // 0x188718 - g_ps2RecompiledFunctionTable[139719] = bhEne01_ExpWormEffect_0x1884c0; // 0x188724 - g_ps2RecompiledFunctionTable[139723] = bhEne01_ExpWormEffect_0x1884c0; // 0x188734 - g_ps2RecompiledFunctionTable[139727] = bhEne01_ExpWormEffect_0x1884c0; // 0x188744 - g_ps2RecompiledFunctionTable[139730] = bhEne01_ExpWormEffect_0x1884c0; // 0x188750 - g_ps2RecompiledFunctionTable[139750] = bhEne01_ExpWormEffect_0x1884c0; // 0x1887a0 - g_ps2RecompiledFunctionTable[139759] = bhEne01_ExpWormEffect_0x1884c0; // 0x1887c4 - g_ps2RecompiledFunctionTable[139762] = bhEne01_ExpWormEffect_0x1884c0; // 0x1887d0 - g_ps2RecompiledFunctionTable[139765] = bhEne01_ExpWormEffect_0x1884c0; // 0x1887dc - g_ps2RecompiledFunctionTable[139774] = bhEne01_ExpWormEffect_0x1884c0; // 0x188800 - g_ps2RecompiledFunctionTable[139782] = bhEne01_ExpWormEffect_0x1884c0; // 0x188820 - g_ps2RecompiledFunctionTable[139785] = bhEne01_ExpWormEffect_0x1884c0; // 0x18882c - g_ps2RecompiledFunctionTable[139795] = bhEne01_ExpWormEffect_0x1884c0; // 0x188854 - g_ps2RecompiledFunctionTable[139801] = bhEne01_ExpWormEffect_0x1884c0; // 0x18886c - g_ps2RecompiledFunctionTable[139859] = bhEne01_ExpWormEffect_0x1884c0; // 0x188954 - g_ps2RecompiledFunctionTable[139861] = bhEne01_ExpWormEffect_0x1884c0; // 0x18895c - g_ps2RecompiledFunctionTable[139864] = bhEne01_ExpWormEffect_0x1884c0; // 0x188968 - g_ps2RecompiledFunctionTable[139869] = bhEne01_ExpWormEffect_0x1884c0; // 0x18897c - g_ps2RecompiledFunctionTable[139872] = bhEne01_ExpWormEffect_0x1884c0; // 0x188988 - g_ps2RecompiledFunctionTable[139875] = bhEne01_ExpWormEffect_0x1884c0; // 0x188994 - g_ps2RecompiledFunctionTable[139893] = bhEne01_ExpWormEffect_0x1884c0; // 0x1889dc - g_ps2RecompiledFunctionTable[139917] = bhEne01_ExpWormEffect_0x1884c0; // 0x188a3c - g_ps2RecompiledFunctionTable[139920] = bhEne01_ExpWormEffect_0x1884c0; // 0x188a48 - g_ps2RecompiledFunctionTable[139925] = bhEne01_ExpWormEffect_0x1884c0; // 0x188a5c - g_ps2RecompiledFunctionTable[139928] = bhEne01_ExpWormEffect_0x1884c0; // 0x188a68 - g_ps2RecompiledFunctionTable[139931] = bhEne01_ExpWormEffect_0x1884c0; // 0x188a74 - g_ps2RecompiledFunctionTable[139949] = bhEne01_ExpWormEffect_0x1884c0; // 0x188abc - g_ps2RecompiledFunctionTable[139990] = bhEne01_PoisonEffect_0x188b60; // 0x188b60 - g_ps2RecompiledFunctionTable[140026] = bhEne01_PoisonEffect_0x188b60; // 0x188bf0 - g_ps2RecompiledFunctionTable[140052] = bhEne01_PoisonEffect_0x188b60; // 0x188c58 - g_ps2RecompiledFunctionTable[140061] = bhEne01_PoisonEffect_0x188b60; // 0x188c7c - g_ps2RecompiledFunctionTable[140081] = bhEne01_PoisonEffect_0x188b60; // 0x188ccc - g_ps2RecompiledFunctionTable[140098] = bhEne01_LinkFireEffect_0x188d10; // 0x188d10 - g_ps2RecompiledFunctionTable[140141] = bhEne01_LinkFireEffect_0x188d10; // 0x188dbc - g_ps2RecompiledFunctionTable[140194] = bhEne01_LinkFireEffect_0x188d10; // 0x188e90 - g_ps2RecompiledFunctionTable[140215] = bhEne01_LinkFireEffect_0x188d10; // 0x188ee4 - g_ps2RecompiledFunctionTable[140243] = bhEne01_LinkFireEffect_0x188d10; // 0x188f54 - g_ps2RecompiledFunctionTable[140275] = bhEne01_LinkFireEffect_0x188d10; // 0x188fd4 - g_ps2RecompiledFunctionTable[140306] = bhEne01_ChgTextID_0x189050; // 0x189050 - g_ps2RecompiledFunctionTable[140386] = bhEne01_SePlay_0x189190; // 0x189190 - g_ps2RecompiledFunctionTable[140420] = bhEne01_SePlay_0x189190; // 0x189218 - g_ps2RecompiledFunctionTable[140424] = bhEne01_SePlay_0x189190; // 0x189228 - g_ps2RecompiledFunctionTable[140456] = bhEne01_SePlay_0x189190; // 0x1892a8 - g_ps2RecompiledFunctionTable[140462] = bhEne01_GetWalkMotion_0x1892c0; // 0x1892c0 - g_ps2RecompiledFunctionTable[140477] = bhEne01_GetWalkMotion_0x1892c0; // 0x1892fc - g_ps2RecompiledFunctionTable[140500] = bhEne01_GetWalkMotion_0x1892c0; // 0x189358 - g_ps2RecompiledFunctionTable[140526] = bhEne01_FastCheck_0x1893c0; // 0x1893c0 - g_ps2RecompiledFunctionTable[140537] = bhEne01_FastCheck_0x1893c0; // 0x1893ec - g_ps2RecompiledFunctionTable[140566] = bhEne01_CmnFlgCheck_0x189460; // 0x189460 - g_ps2RecompiledFunctionTable[140576] = bhEne01_CmnFlgCheck_0x189460; // 0x189488 - g_ps2RecompiledFunctionTable[140610] = bhEne01_FastWalkCheck_0x189510; // 0x189510 - g_ps2RecompiledFunctionTable[140621] = bhEne01_FastWalkCheck_0x189510; // 0x18953c - g_ps2RecompiledFunctionTable[140658] = bhEne01_ZulzulCheck_0x1895d0; // 0x1895d0 - g_ps2RecompiledFunctionTable[140687] = bhEne01_ZulzulCheck_0x1895d0; // 0x189644 - g_ps2RecompiledFunctionTable[140695] = bhEne01_ZulzulCheck_0x1895d0; // 0x189664 - g_ps2RecompiledFunctionTable[140703] = bhEne01_ZulzulCheck_0x1895d0; // 0x189684 - g_ps2RecompiledFunctionTable[140711] = bhEne01_ZulzulCheck_0x1895d0; // 0x1896a4 - g_ps2RecompiledFunctionTable[140714] = bhEne01_ZulzulCheck_0x1895d0; // 0x1896b0 - g_ps2RecompiledFunctionTable[140719] = bhEne01_ZulzulCheck_0x1895d0; // 0x1896c4 - g_ps2RecompiledFunctionTable[140740] = bhEne01_ZulzulCheck_0x1895d0; // 0x189718 - g_ps2RecompiledFunctionTable[140753] = bhEne01_ZulzulCheck_0x1895d0; // 0x18974c - g_ps2RecompiledFunctionTable[140778] = bhEne01_GakeotiCheck_0x1897b0; // 0x1897b0 - g_ps2RecompiledFunctionTable[140788] = bhEne01_GakeotiCheck_0x1897b0; // 0x1897d8 - g_ps2RecompiledFunctionTable[140800] = bhEne01_GakeotiCheck_0x1897b0; // 0x189808 - g_ps2RecompiledFunctionTable[140805] = bhEne01_GakeotiCheck_0x1897b0; // 0x18981c - g_ps2RecompiledFunctionTable[140811] = bhEne01_GakeotiCheck_0x1897b0; // 0x189834 - g_ps2RecompiledFunctionTable[140818] = bhEne01_DansaCheck_0x189850; // 0x189850 - g_ps2RecompiledFunctionTable[140828] = bhEne01_DansaCheck_0x189850; // 0x189878 - g_ps2RecompiledFunctionTable[140836] = bhEne01_DansaCheck_0x189850; // 0x189898 - g_ps2RecompiledFunctionTable[140845] = bhEne01_DansaCheck_0x189850; // 0x1898bc - g_ps2RecompiledFunctionTable[140874] = bhEne01_PoisonCheck_0x189930; // 0x189930 - g_ps2RecompiledFunctionTable[140893] = bhEne01_PoisonCheck_0x189930; // 0x18997c - g_ps2RecompiledFunctionTable[140935] = bhEne01_PoisonCheck_0x189930; // 0x189a24 - g_ps2RecompiledFunctionTable[140976] = bhEne01_PoisonCheck_0x189930; // 0x189ac8 - g_ps2RecompiledFunctionTable[141019] = bhEne01_PoisonCheck_0x189930; // 0x189b74 - g_ps2RecompiledFunctionTable[141042] = bhEne01_EatCheck_0x189bd0; // 0x189bd0 - g_ps2RecompiledFunctionTable[141095] = bhEne01_EatCheck_0x189bd0; // 0x189ca4 - g_ps2RecompiledFunctionTable[141110] = bhEne01_EatCheck_0x189bd0; // 0x189ce0 - g_ps2RecompiledFunctionTable[141154] = bhEne01_EatCheck_0x189bd0; // 0x189d90 - g_ps2RecompiledFunctionTable[141161] = bhEne01_EatCheck_0x189bd0; // 0x189dac - g_ps2RecompiledFunctionTable[141198] = bhEne01_WormCheck_0x189e40; // 0x189e40 - g_ps2RecompiledFunctionTable[141254] = bhEne01_WormCheck_0x189e40; // 0x189f20 - g_ps2RecompiledFunctionTable[141279] = bhEne01_WormCheck_0x189e40; // 0x189f84 - g_ps2RecompiledFunctionTable[141328] = bhEne01_WormCheck_0x189e40; // 0x18a048 - g_ps2RecompiledFunctionTable[141366] = bhEne01_KaidanCheck_0x18a0e0; // 0x18a0e0 - g_ps2RecompiledFunctionTable[141395] = bhEne01_KaidanCheck_0x18a0e0; // 0x18a154 - g_ps2RecompiledFunctionTable[141430] = bhEne01_KaidanCheck_0x18a0e0; // 0x18a1e0 - g_ps2RecompiledFunctionTable[141454] = bhEne01_KaidanCheck_0x18a0e0; // 0x18a240 - g_ps2RecompiledFunctionTable[141469] = bhEne01_KaidanCheck_0x18a0e0; // 0x18a27c - g_ps2RecompiledFunctionTable[141478] = bhEne01_CutLeg_0x18a2a0; // 0x18a2a0 - g_ps2RecompiledFunctionTable[141496] = bhEne01_CutLeg_0x18a2a0; // 0x18a2e8 - g_ps2RecompiledFunctionTable[141500] = bhEne01_CutLeg_0x18a2a0; // 0x18a2f8 - g_ps2RecompiledFunctionTable[141510] = bhEne01_CutLeg_0x18a2a0; // 0x18a320 - g_ps2RecompiledFunctionTable[141514] = bhEne01_CutLeg_0x18a2a0; // 0x18a330 - g_ps2RecompiledFunctionTable[141522] = bhEne01_CutHead_0x18a350; // 0x18a350 - g_ps2RecompiledFunctionTable[141526] = bhEne01_FlyingCap_0x18a360; // 0x18a360 - g_ps2RecompiledFunctionTable[141535] = bhEne01_FlyingCap_0x18a360; // 0x18a384 - g_ps2RecompiledFunctionTable[141578] = bhEne01_FlyingCap_0x18a360; // 0x18a430 - g_ps2RecompiledFunctionTable[141590] = bhEne01_Dummy_0x18a460; // 0x18a460 - g_ps2RecompiledFunctionTable[141594] = bhEne01_Brain02B_0x18a470; // 0x18a470 - g_ps2RecompiledFunctionTable[141612] = bhEne01_Brain02B_0x18a470; // 0x18a4b8 - g_ps2RecompiledFunctionTable[141638] = bhEne01_MVType00B_0x18a520; // 0x18a520 - g_ps2RecompiledFunctionTable[141639] = bhEne01_MVType00B_0x18a520; // 0x18a524 - g_ps2RecompiledFunctionTable[141640] = bhEne01_MVType00B_0x18a520; // 0x18a528 - g_ps2RecompiledFunctionTable[141641] = bhEne01_MVType00B_0x18a520; // 0x18a52c - g_ps2RecompiledFunctionTable[141642] = bhEne01_MVType00B_0x18a520; // 0x18a530 - g_ps2RecompiledFunctionTable[141643] = bhEne01_MVType00B_0x18a520; // 0x18a534 - g_ps2RecompiledFunctionTable[141644] = bhEne01_MVType00B_0x18a520; // 0x18a538 - g_ps2RecompiledFunctionTable[141645] = bhEne01_MVType00B_0x18a520; // 0x18a53c - g_ps2RecompiledFunctionTable[141646] = bhEne01_MVType02B_0x18a540; // 0x18a540 - g_ps2RecompiledFunctionTable[141647] = bhEne01_MVType02B_0x18a540; // 0x18a544 - g_ps2RecompiledFunctionTable[141648] = bhEne01_MVType02B_0x18a540; // 0x18a548 - g_ps2RecompiledFunctionTable[141649] = bhEne01_MVType02B_0x18a540; // 0x18a54c - g_ps2RecompiledFunctionTable[141650] = bhEne01_MVType02B_0x18a540; // 0x18a550 - g_ps2RecompiledFunctionTable[141651] = bhEne01_MVType02B_0x18a540; // 0x18a554 - g_ps2RecompiledFunctionTable[141652] = bhEne01_MVType02B_0x18a540; // 0x18a558 - g_ps2RecompiledFunctionTable[141653] = bhEne01_MVType02B_0x18a540; // 0x18a55c - g_ps2RecompiledFunctionTable[141654] = bhEne01_MVType02B_0x18a540; // 0x18a560 - g_ps2RecompiledFunctionTable[141655] = bhEne01_MVType02B_0x18a540; // 0x18a564 - g_ps2RecompiledFunctionTable[141656] = bhEne01_MVType02B_0x18a540; // 0x18a568 - g_ps2RecompiledFunctionTable[141657] = bhEne01_MVType02B_0x18a540; // 0x18a56c - g_ps2RecompiledFunctionTable[141658] = bhEne01_MVType02B_0x18a540; // 0x18a570 - g_ps2RecompiledFunctionTable[141659] = bhEne01_MVType02B_0x18a540; // 0x18a574 - g_ps2RecompiledFunctionTable[141660] = bhEne01_MVType02B_0x18a540; // 0x18a578 - g_ps2RecompiledFunctionTable[141661] = bhEne01_MVType02B_0x18a540; // 0x18a57c - g_ps2RecompiledFunctionTable[141662] = bhEne01_MVType02B_0x18a540; // 0x18a580 - g_ps2RecompiledFunctionTable[141663] = bhEne01_MVType02B_0x18a540; // 0x18a584 - g_ps2RecompiledFunctionTable[141664] = bhEne01_MVType02B_0x18a540; // 0x18a588 - g_ps2RecompiledFunctionTable[141665] = bhEne01_MVType02B_0x18a540; // 0x18a58c - g_ps2RecompiledFunctionTable[141666] = bhEne01_MVType02B_0x18a540; // 0x18a590 - g_ps2RecompiledFunctionTable[141667] = bhEne01_MVType02B_0x18a540; // 0x18a594 - g_ps2RecompiledFunctionTable[141668] = bhEne01_MVType02B_0x18a540; // 0x18a598 - g_ps2RecompiledFunctionTable[141669] = bhEne01_MVType02B_0x18a540; // 0x18a59c - g_ps2RecompiledFunctionTable[141670] = bhEne01_MVType02B_0x18a540; // 0x18a5a0 - g_ps2RecompiledFunctionTable[141671] = bhEne01_MVType02B_0x18a540; // 0x18a5a4 - g_ps2RecompiledFunctionTable[141672] = bhEne01_MVType02B_0x18a540; // 0x18a5a8 - g_ps2RecompiledFunctionTable[141673] = bhEne01_MVType02B_0x18a540; // 0x18a5ac - g_ps2RecompiledFunctionTable[141674] = bhEne01_MVType02B_0x18a540; // 0x18a5b0 - g_ps2RecompiledFunctionTable[141675] = bhEne01_MVType02B_0x18a540; // 0x18a5b4 - g_ps2RecompiledFunctionTable[141676] = bhEne01_MVType02B_0x18a540; // 0x18a5b8 - g_ps2RecompiledFunctionTable[141677] = bhEne01_MVType02B_0x18a540; // 0x18a5bc - g_ps2RecompiledFunctionTable[141678] = bhEne01_MVType02B_0x18a540; // 0x18a5c0 - g_ps2RecompiledFunctionTable[141679] = bhEne01_MVType02B_0x18a540; // 0x18a5c4 - g_ps2RecompiledFunctionTable[141680] = bhEne01_MVType02B_0x18a540; // 0x18a5c8 - g_ps2RecompiledFunctionTable[141681] = bhEne01_MVType02B_0x18a540; // 0x18a5cc - g_ps2RecompiledFunctionTable[141682] = bhEne01_MVType02B_0x18a540; // 0x18a5d0 - g_ps2RecompiledFunctionTable[141683] = bhEne01_MVType02B_0x18a540; // 0x18a5d4 - g_ps2RecompiledFunctionTable[141684] = bhEne01_MVType02B_0x18a540; // 0x18a5d8 - g_ps2RecompiledFunctionTable[141685] = bhEne01_MVType02B_0x18a540; // 0x18a5dc - g_ps2RecompiledFunctionTable[141686] = bhEne01_MVType02B_0x18a540; // 0x18a5e0 - g_ps2RecompiledFunctionTable[141687] = bhEne01_MVType02B_0x18a540; // 0x18a5e4 - g_ps2RecompiledFunctionTable[141688] = bhEne01_MVType02B_0x18a540; // 0x18a5e8 - g_ps2RecompiledFunctionTable[141689] = bhEne01_MVType02B_0x18a540; // 0x18a5ec - g_ps2RecompiledFunctionTable[141690] = bhEne01_MVType02B_0x18a540; // 0x18a5f0 - g_ps2RecompiledFunctionTable[141691] = bhEne01_MVType02B_0x18a540; // 0x18a5f4 - g_ps2RecompiledFunctionTable[141692] = bhEne01_MVType02B_0x18a540; // 0x18a5f8 - g_ps2RecompiledFunctionTable[141693] = bhEne01_MVType02B_0x18a540; // 0x18a5fc - g_ps2RecompiledFunctionTable[141694] = bhEne01_MVType02B_0x18a540; // 0x18a600 - g_ps2RecompiledFunctionTable[141695] = bhEne01_MVType02B_0x18a540; // 0x18a604 - g_ps2RecompiledFunctionTable[141696] = bhEne01_MVType02B_0x18a540; // 0x18a608 - g_ps2RecompiledFunctionTable[141697] = bhEne01_MVType02B_0x18a540; // 0x18a60c - g_ps2RecompiledFunctionTable[141698] = bhEne01_MVType02B_0x18a540; // 0x18a610 - g_ps2RecompiledFunctionTable[141699] = bhEne01_MVType02B_0x18a540; // 0x18a614 - g_ps2RecompiledFunctionTable[141700] = bhEne01_MVType02B_0x18a540; // 0x18a618 - g_ps2RecompiledFunctionTable[141701] = bhEne01_MVType02B_0x18a540; // 0x18a61c - g_ps2RecompiledFunctionTable[141702] = bhEne01_MVType02B_0x18a540; // 0x18a620 - g_ps2RecompiledFunctionTable[141703] = bhEne01_MVType02B_0x18a540; // 0x18a624 - g_ps2RecompiledFunctionTable[141704] = bhEne01_MVType02B_0x18a540; // 0x18a628 - g_ps2RecompiledFunctionTable[141705] = bhEne01_MVType02B_0x18a540; // 0x18a62c - g_ps2RecompiledFunctionTable[141706] = bhEne01_MVType02B_0x18a540; // 0x18a630 - g_ps2RecompiledFunctionTable[141707] = bhEne01_MVType02B_0x18a540; // 0x18a634 - g_ps2RecompiledFunctionTable[141708] = bhEne01_MVType02B_0x18a540; // 0x18a638 - g_ps2RecompiledFunctionTable[141709] = bhEne01_MVType02B_0x18a540; // 0x18a63c - g_ps2RecompiledFunctionTable[141710] = bhEne01_MVType02B_0x18a540; // 0x18a640 - g_ps2RecompiledFunctionTable[141711] = bhEne01_MVType02B_0x18a540; // 0x18a644 - g_ps2RecompiledFunctionTable[141712] = bhEne01_MVType02B_0x18a540; // 0x18a648 - g_ps2RecompiledFunctionTable[141713] = bhEne01_MVType02B_0x18a540; // 0x18a64c - g_ps2RecompiledFunctionTable[141714] = bhEne01_MVType02B_0x18a540; // 0x18a650 - g_ps2RecompiledFunctionTable[141715] = bhEne01_MVType02B_0x18a540; // 0x18a654 - g_ps2RecompiledFunctionTable[141716] = bhEne01_MVType02B_0x18a540; // 0x18a658 - g_ps2RecompiledFunctionTable[141717] = bhEne01_MVType02B_0x18a540; // 0x18a65c - g_ps2RecompiledFunctionTable[141718] = bhEne01_MVType02B_0x18a540; // 0x18a660 - g_ps2RecompiledFunctionTable[141722] = bhEne01_MV13B_0x18a670; // 0x18a670 - g_ps2RecompiledFunctionTable[141737] = bhEne01_MV13B_0x18a670; // 0x18a6ac - g_ps2RecompiledFunctionTable[141758] = bhEne01_MV13B_0x18a670; // 0x18a700 - g_ps2RecompiledFunctionTable[141762] = bhEne01_NGType00B_0x18a710; // 0x18a710 - g_ps2RecompiledFunctionTable[141763] = bhEne01_NGType00B_0x18a710; // 0x18a714 - g_ps2RecompiledFunctionTable[141764] = bhEne01_NGType00B_0x18a710; // 0x18a718 - g_ps2RecompiledFunctionTable[141765] = bhEne01_NGType00B_0x18a710; // 0x18a71c - g_ps2RecompiledFunctionTable[141766] = bhEne01_NGType00B_0x18a710; // 0x18a720 - g_ps2RecompiledFunctionTable[141767] = bhEne01_NGType00B_0x18a710; // 0x18a724 - g_ps2RecompiledFunctionTable[141768] = bhEne01_NGType00B_0x18a710; // 0x18a728 - g_ps2RecompiledFunctionTable[141769] = bhEne01_NGType00B_0x18a710; // 0x18a72c - g_ps2RecompiledFunctionTable[141770] = bhEne01_NGType00B_0x18a710; // 0x18a730 - g_ps2RecompiledFunctionTable[141771] = bhEne01_NGType00B_0x18a710; // 0x18a734 - g_ps2RecompiledFunctionTable[141772] = bhEne01_NGType00B_0x18a710; // 0x18a738 - g_ps2RecompiledFunctionTable[141773] = bhEne01_NGType00B_0x18a710; // 0x18a73c - g_ps2RecompiledFunctionTable[141774] = bhEne01_NGType00B_0x18a710; // 0x18a740 - g_ps2RecompiledFunctionTable[141775] = bhEne01_NGType00B_0x18a710; // 0x18a744 - g_ps2RecompiledFunctionTable[141776] = bhEne01_NGType00B_0x18a710; // 0x18a748 - g_ps2RecompiledFunctionTable[141777] = bhEne01_NGType00B_0x18a710; // 0x18a74c - g_ps2RecompiledFunctionTable[141778] = bhEne01_NGType00B_0x18a710; // 0x18a750 - g_ps2RecompiledFunctionTable[141779] = bhEne01_NGType00B_0x18a710; // 0x18a754 - g_ps2RecompiledFunctionTable[141780] = bhEne01_NGType00B_0x18a710; // 0x18a758 - g_ps2RecompiledFunctionTable[141781] = bhEne01_NGType00B_0x18a710; // 0x18a75c - g_ps2RecompiledFunctionTable[141782] = bhEne01_NGType00B_0x18a710; // 0x18a760 - g_ps2RecompiledFunctionTable[141783] = bhEne01_NGType00B_0x18a710; // 0x18a764 - g_ps2RecompiledFunctionTable[141784] = bhEne01_NGType00B_0x18a710; // 0x18a768 - g_ps2RecompiledFunctionTable[141785] = bhEne01_NGType00B_0x18a710; // 0x18a76c - g_ps2RecompiledFunctionTable[141786] = bhEne01_NGType00B_0x18a710; // 0x18a770 - g_ps2RecompiledFunctionTable[141787] = bhEne01_NGType00B_0x18a710; // 0x18a774 - g_ps2RecompiledFunctionTable[141788] = bhEne01_NGType00B_0x18a710; // 0x18a778 - g_ps2RecompiledFunctionTable[141789] = bhEne01_NGType00B_0x18a710; // 0x18a77c - g_ps2RecompiledFunctionTable[141790] = bhEne01_NGType00B_0x18a710; // 0x18a780 - g_ps2RecompiledFunctionTable[141791] = bhEne01_NGType00B_0x18a710; // 0x18a784 - g_ps2RecompiledFunctionTable[141792] = bhEne01_NGType00B_0x18a710; // 0x18a788 - g_ps2RecompiledFunctionTable[141793] = bhEne01_NGType00B_0x18a710; // 0x18a78c - g_ps2RecompiledFunctionTable[141794] = bhEne01_NGType00B_0x18a710; // 0x18a790 - g_ps2RecompiledFunctionTable[141795] = bhEne01_NGType00B_0x18a710; // 0x18a794 - g_ps2RecompiledFunctionTable[141796] = bhEne01_NGType00B_0x18a710; // 0x18a798 - g_ps2RecompiledFunctionTable[141798] = bhEne01_NG03B_0x18a7a0; // 0x18a7a0 - g_ps2RecompiledFunctionTable[141824] = bhEne01_NG03B_0x18a7a0; // 0x18a808 - g_ps2RecompiledFunctionTable[141835] = bhEne01_NG03B_0x18a7a0; // 0x18a834 - g_ps2RecompiledFunctionTable[141867] = bhEne01_NG03B_0x18a7a0; // 0x18a8b4 - g_ps2RecompiledFunctionTable[141889] = bhEne01_NG03B_0x18a7a0; // 0x18a90c - g_ps2RecompiledFunctionTable[141901] = bhEne01_NG03B_0x18a7a0; // 0x18a93c - g_ps2RecompiledFunctionTable[141925] = bhEne01_NG03B_0x18a7a0; // 0x18a99c - g_ps2RecompiledFunctionTable[141933] = bhEne01_NG03B_0x18a7a0; // 0x18a9bc - g_ps2RecompiledFunctionTable[141960] = bhEne01_NG03B_0x18a7a0; // 0x18aa28 - g_ps2RecompiledFunctionTable[141974] = bhEne01_NG03B_0x18a7a0; // 0x18aa60 - g_ps2RecompiledFunctionTable[141982] = bhEne01_NG03B_0x18a7a0; // 0x18aa80 - g_ps2RecompiledFunctionTable[141988] = bhEne01_NG03B_0x18a7a0; // 0x18aa98 - g_ps2RecompiledFunctionTable[141996] = bhEne01_NG03B_0x18a7a0; // 0x18aab8 - g_ps2RecompiledFunctionTable[142030] = bhEne01_DGType00B_0x18ab40; // 0x18ab40 - g_ps2RecompiledFunctionTable[142031] = bhEne01_DGType00B_0x18ab40; // 0x18ab44 - g_ps2RecompiledFunctionTable[142032] = bhEne01_DGType00B_0x18ab40; // 0x18ab48 - g_ps2RecompiledFunctionTable[142033] = bhEne01_DGType00B_0x18ab40; // 0x18ab4c - g_ps2RecompiledFunctionTable[142034] = bhEne01_DGType00B_0x18ab40; // 0x18ab50 - g_ps2RecompiledFunctionTable[142035] = bhEne01_DGType00B_0x18ab40; // 0x18ab54 - g_ps2RecompiledFunctionTable[142036] = bhEne01_DGType00B_0x18ab40; // 0x18ab58 - g_ps2RecompiledFunctionTable[142037] = bhEne01_DGType00B_0x18ab40; // 0x18ab5c - g_ps2RecompiledFunctionTable[142038] = bhEne01_DGType02B_0x18ab60; // 0x18ab60 - g_ps2RecompiledFunctionTable[142039] = bhEne01_DGType02B_0x18ab60; // 0x18ab64 - g_ps2RecompiledFunctionTable[142040] = bhEne01_DGType02B_0x18ab60; // 0x18ab68 - g_ps2RecompiledFunctionTable[142041] = bhEne01_DGType02B_0x18ab60; // 0x18ab6c - g_ps2RecompiledFunctionTable[142042] = bhEne01_DGType02B_0x18ab60; // 0x18ab70 - g_ps2RecompiledFunctionTable[142043] = bhEne01_DGType02B_0x18ab60; // 0x18ab74 - g_ps2RecompiledFunctionTable[142044] = bhEne01_DGType02B_0x18ab60; // 0x18ab78 - g_ps2RecompiledFunctionTable[142045] = bhEne01_DGType02B_0x18ab60; // 0x18ab7c - g_ps2RecompiledFunctionTable[142046] = bhEne01_DDType00B_0x18ab80; // 0x18ab80 - g_ps2RecompiledFunctionTable[142047] = bhEne01_DDType00B_0x18ab80; // 0x18ab84 - g_ps2RecompiledFunctionTable[142048] = bhEne01_DDType00B_0x18ab80; // 0x18ab88 - g_ps2RecompiledFunctionTable[142049] = bhEne01_DDType00B_0x18ab80; // 0x18ab8c - g_ps2RecompiledFunctionTable[142050] = bhEne01_DDType00B_0x18ab80; // 0x18ab90 - g_ps2RecompiledFunctionTable[142051] = bhEne01_DDType00B_0x18ab80; // 0x18ab94 - g_ps2RecompiledFunctionTable[142052] = bhEne01_DDType00B_0x18ab80; // 0x18ab98 - g_ps2RecompiledFunctionTable[142053] = bhEne01_DDType00B_0x18ab80; // 0x18ab9c - g_ps2RecompiledFunctionTable[142054] = bhEne01_DDType02B_0x18aba0; // 0x18aba0 - g_ps2RecompiledFunctionTable[142055] = bhEne01_DDType02B_0x18aba0; // 0x18aba4 - g_ps2RecompiledFunctionTable[142056] = bhEne01_DDType02B_0x18aba0; // 0x18aba8 - g_ps2RecompiledFunctionTable[142057] = bhEne01_DDType02B_0x18aba0; // 0x18abac - g_ps2RecompiledFunctionTable[142058] = bhEne01_DDType02B_0x18aba0; // 0x18abb0 - g_ps2RecompiledFunctionTable[142059] = bhEne01_DDType02B_0x18aba0; // 0x18abb4 - g_ps2RecompiledFunctionTable[142060] = bhEne01_DDType02B_0x18aba0; // 0x18abb8 - g_ps2RecompiledFunctionTable[142061] = bhEne01_DDType02B_0x18aba0; // 0x18abbc - g_ps2RecompiledFunctionTable[142062] = bhEne01_DG05B_0x18abc0; // 0x18abc0 - g_ps2RecompiledFunctionTable[142083] = bhEne01_DG05B_0x18abc0; // 0x18ac14 - g_ps2RecompiledFunctionTable[142097] = bhEne01_DG05B_0x18abc0; // 0x18ac4c - g_ps2RecompiledFunctionTable[142105] = bhEne01_DG05B_0x18abc0; // 0x18ac6c - g_ps2RecompiledFunctionTable[142158] = bhEne01_DG05B_0x18abc0; // 0x18ad40 - g_ps2RecompiledFunctionTable[142170] = bhEne01_DG05B_0x18abc0; // 0x18ad70 - g_ps2RecompiledFunctionTable[142194] = bhEne01_DG05B_0x18abc0; // 0x18add0 - g_ps2RecompiledFunctionTable[142200] = bhEne01_DG05B_0x18abc0; // 0x18ade8 - g_ps2RecompiledFunctionTable[142221] = bhEne01_DG05B_0x18abc0; // 0x18ae3c - g_ps2RecompiledFunctionTable[142274] = bhEne01_DG09B_0x18af10; // 0x18af10 - g_ps2RecompiledFunctionTable[142298] = bhEne01_DG09B_0x18af10; // 0x18af70 - g_ps2RecompiledFunctionTable[142306] = bhEne01_DG09B_0x18af10; // 0x18af90 - g_ps2RecompiledFunctionTable[142351] = bhEne01_DG09B_0x18af10; // 0x18b044 - g_ps2RecompiledFunctionTable[142368] = bhEne01_DG09B_0x18af10; // 0x18b088 - g_ps2RecompiledFunctionTable[142372] = bhEne01_DG09B_0x18af10; // 0x18b098 - g_ps2RecompiledFunctionTable[142375] = bhEne01_DG09B_0x18af10; // 0x18b0a4 - g_ps2RecompiledFunctionTable[142386] = bhEne01_DG09B_0x18af10; // 0x18b0d0 - g_ps2RecompiledFunctionTable[142393] = bhEne01_DG09B_0x18af10; // 0x18b0ec - g_ps2RecompiledFunctionTable[142428] = bhEne01_DG09B_0x18af10; // 0x18b178 - g_ps2RecompiledFunctionTable[142452] = bhEne01_DG09B_0x18af10; // 0x18b1d8 - g_ps2RecompiledFunctionTable[142458] = bhEne01_DG09B_0x18af10; // 0x18b1f0 - g_ps2RecompiledFunctionTable[142469] = bhEne01_DG09B_0x18af10; // 0x18b21c - g_ps2RecompiledFunctionTable[142493] = bhEne01_DG09B_0x18af10; // 0x18b27c - g_ps2RecompiledFunctionTable[142500] = bhEne01_DG09B_0x18af10; // 0x18b298 - g_ps2RecompiledFunctionTable[142525] = bhEne01_DG09B_0x18af10; // 0x18b2fc - g_ps2RecompiledFunctionTable[142539] = bhEne01_DG09B_0x18af10; // 0x18b334 - g_ps2RecompiledFunctionTable[142590] = bhEne01_DG12B_0x18b400; // 0x18b400 - g_ps2RecompiledFunctionTable[142610] = bhEne01_DG12B_0x18b400; // 0x18b450 - g_ps2RecompiledFunctionTable[142624] = bhEne01_DG12B_0x18b400; // 0x18b488 - g_ps2RecompiledFunctionTable[142632] = bhEne01_DG12B_0x18b400; // 0x18b4a8 - g_ps2RecompiledFunctionTable[142674] = bhEne01_DG13B_0x18b550; // 0x18b550 - g_ps2RecompiledFunctionTable[142691] = bhEne01_DG13B_0x18b550; // 0x18b594 - g_ps2RecompiledFunctionTable[142702] = bhEne01_DG13B_0x18b550; // 0x18b5c0 - g_ps2RecompiledFunctionTable[142730] = bhEne01_DD02B_0x18b630; // 0x18b630 - g_ps2RecompiledFunctionTable[142774] = bhEne01_DD02B_0x18b630; // 0x18b6e0 - g_ps2RecompiledFunctionTable[142783] = bhEne01_DD02B_0x18b630; // 0x18b704 - g_ps2RecompiledFunctionTable[142807] = bhEne01_DD02B_0x18b630; // 0x18b764 - g_ps2RecompiledFunctionTable[142820] = bhEne01_DD02B_0x18b630; // 0x18b798 - g_ps2RecompiledFunctionTable[142877] = bhEne01_DD02B_0x18b630; // 0x18b87c - g_ps2RecompiledFunctionTable[142881] = bhEne01_DD02B_0x18b630; // 0x18b88c - g_ps2RecompiledFunctionTable[142883] = bhEne01_DD02B_0x18b630; // 0x18b894 - g_ps2RecompiledFunctionTable[142934] = bhEne01_DD02B_0x18b630; // 0x18b960 - g_ps2RecompiledFunctionTable[142938] = bhEne01_DD02B_0x18b630; // 0x18b970 - g_ps2RecompiledFunctionTable[142942] = bhEne01_DD02B_0x18b630; // 0x18b980 - g_ps2RecompiledFunctionTable[142947] = bhEne01_DD02B_0x18b630; // 0x18b994 - g_ps2RecompiledFunctionTable[142955] = bhEne01_DD02B_0x18b630; // 0x18b9b4 - g_ps2RecompiledFunctionTable[142970] = bhEne01_RotNeck_0x18b9f0; // 0x18b9f0 - g_ps2RecompiledFunctionTable[143006] = bhEne01_RotNeck_0x18b9f0; // 0x18ba80 - g_ps2RecompiledFunctionTable[143014] = bhEne01_SideRotNeck_0x18baa0; // 0x18baa0 - g_ps2RecompiledFunctionTable[143033] = bhEne01_SideRotNeck_0x18baa0; // 0x18baec - g_ps2RecompiledFunctionTable[143094] = bhSearchPlayer2_0x18bbe0; // 0x18bbe0 - g_ps2RecompiledFunctionTable[143115] = bhSearchPlayer2_0x18bbe0; // 0x18bc34 - g_ps2RecompiledFunctionTable[143130] = bhEne01Parent_0x18bc70; // 0x18bc70 - g_ps2RecompiledFunctionTable[143131] = bhEne01Parent_0x18bc70; // 0x18bc74 - g_ps2RecompiledFunctionTable[143132] = bhEne01Parent_0x18bc70; // 0x18bc78 - g_ps2RecompiledFunctionTable[143133] = bhEne01Parent_0x18bc70; // 0x18bc7c - g_ps2RecompiledFunctionTable[143134] = bhEne01Parent_0x18bc70; // 0x18bc80 - g_ps2RecompiledFunctionTable[143135] = bhEne01Parent_0x18bc70; // 0x18bc84 - g_ps2RecompiledFunctionTable[143136] = bhEne01Parent_0x18bc70; // 0x18bc88 - g_ps2RecompiledFunctionTable[143137] = bhEne01Parent_0x18bc70; // 0x18bc8c - g_ps2RecompiledFunctionTable[143138] = bhEne01Parent_Init_0x18bc90; // 0x18bc90 - g_ps2RecompiledFunctionTable[143150] = bhEne01Parent_Move_0x18bcc0; // 0x18bcc0 - g_ps2RecompiledFunctionTable[143154] = bhEne01Parent_Move_0x18bcc0; // 0x18bcd0 - g_ps2RecompiledFunctionTable[143156] = bhEne01Parent_Move_0x18bcc0; // 0x18bcd8 - g_ps2RecompiledFunctionTable[143162] = bhEne01Parent_NearestCheck_0x18bcf0; // 0x18bcf0 - g_ps2RecompiledFunctionTable[143172] = bhEne01Parent_NearestCheck_0x18bcf0; // 0x18bd18 - g_ps2RecompiledFunctionTable[143226] = bhEne01Parent_NoKaidanCheck_0x18bdf0; // 0x18bdf0 - g_ps2RecompiledFunctionTable[143235] = bhEne01Parent_NoKaidanCheck_0x18bdf0; // 0x18be14 - g_ps2RecompiledFunctionTable[143261] = bhEne01Parent_NoKaidanCheck_0x18bdf0; // 0x18be7c - g_ps2RecompiledFunctionTable[143314] = bhEne01Parent_NoKaidanCheck_0x18bdf0; // 0x18bf50 - g_ps2RecompiledFunctionTable[143326] = bhEne01Arm_0x18bf80; // 0x18bf80 - g_ps2RecompiledFunctionTable[143327] = bhEne01Arm_0x18bf80; // 0x18bf84 - g_ps2RecompiledFunctionTable[143328] = bhEne01Arm_0x18bf80; // 0x18bf88 - g_ps2RecompiledFunctionTable[143329] = bhEne01Arm_0x18bf80; // 0x18bf8c - g_ps2RecompiledFunctionTable[143330] = bhEne01Arm_0x18bf80; // 0x18bf90 - g_ps2RecompiledFunctionTable[143331] = bhEne01Arm_0x18bf80; // 0x18bf94 - g_ps2RecompiledFunctionTable[143332] = bhEne01Arm_0x18bf80; // 0x18bf98 - g_ps2RecompiledFunctionTable[143333] = bhEne01Arm_0x18bf80; // 0x18bf9c - g_ps2RecompiledFunctionTable[143334] = bhEne01Arm_Init_0x18bfa0; // 0x18bfa0 - g_ps2RecompiledFunctionTable[143347] = bhEne01Arm_Init_0x18bfa0; // 0x18bfd4 - g_ps2RecompiledFunctionTable[143366] = bhEne01Arm_Move_0x18c020; // 0x18c020 - g_ps2RecompiledFunctionTable[143370] = bhEne01Arm_MV00_0x18c030; // 0x18c030 - g_ps2RecompiledFunctionTable[143374] = bhEne01Arm_Damage_0x18c040; // 0x18c040 - g_ps2RecompiledFunctionTable[143375] = bhEne01Arm_Damage_0x18c040; // 0x18c044 - g_ps2RecompiledFunctionTable[143376] = bhEne01Arm_Damage_0x18c040; // 0x18c048 - g_ps2RecompiledFunctionTable[143377] = bhEne01Arm_Damage_0x18c040; // 0x18c04c - g_ps2RecompiledFunctionTable[143378] = bhEne01Arm_Damage_0x18c040; // 0x18c050 - g_ps2RecompiledFunctionTable[143379] = bhEne01Arm_Damage_0x18c040; // 0x18c054 - g_ps2RecompiledFunctionTable[143380] = bhEne01Arm_Damage_0x18c040; // 0x18c058 - g_ps2RecompiledFunctionTable[143381] = bhEne01Arm_Damage_0x18c040; // 0x18c05c - g_ps2RecompiledFunctionTable[143382] = bhEne01Arm_DG00_0x18c060; // 0x18c060 - g_ps2RecompiledFunctionTable[143433] = bhEne01Arm_DG00_0x18c060; // 0x18c12c - g_ps2RecompiledFunctionTable[143440] = bhEne01Arm_DG00_0x18c060; // 0x18c148 - g_ps2RecompiledFunctionTable[143465] = bhEne01Arm_DG00_0x18c060; // 0x18c1ac - g_ps2RecompiledFunctionTable[143467] = bhEne01Arm_DG00_0x18c060; // 0x18c1b4 - g_ps2RecompiledFunctionTable[143472] = bhEne01Arm_DG00_0x18c060; // 0x18c1c8 - g_ps2RecompiledFunctionTable[143477] = bhEne01Arm_DG00_0x18c060; // 0x18c1dc - g_ps2RecompiledFunctionTable[143505] = bhEne01Arm_DG00_0x18c060; // 0x18c24c - g_ps2RecompiledFunctionTable[143520] = bhEne01Arm_DG00_0x18c060; // 0x18c288 - g_ps2RecompiledFunctionTable[143526] = bhEne01Arm_DG00_0x18c060; // 0x18c2a0 - g_ps2RecompiledFunctionTable[143578] = bhEne01Arm_DG00_0x18c060; // 0x18c370 - g_ps2RecompiledFunctionTable[143581] = bhEne01Arm_DG00_0x18c060; // 0x18c37c - g_ps2RecompiledFunctionTable[143595] = bhEne01Arm_DG00_0x18c060; // 0x18c3b4 - g_ps2RecompiledFunctionTable[143614] = bhEne01Arm_DG00_0x18c060; // 0x18c400 - g_ps2RecompiledFunctionTable[143616] = bhEne01Arm_DG00_0x18c060; // 0x18c408 - g_ps2RecompiledFunctionTable[143624] = bhEne01Arm_DG00_0x18c060; // 0x18c428 - g_ps2RecompiledFunctionTable[143632] = bhEne01Arm_DG00_0x18c060; // 0x18c448 - g_ps2RecompiledFunctionTable[143683] = bhEne01Arm_DG00_0x18c060; // 0x18c514 - g_ps2RecompiledFunctionTable[143685] = bhEne01Arm_DG00_0x18c060; // 0x18c51c - g_ps2RecompiledFunctionTable[143690] = bhEne01Arm_DG00_0x18c060; // 0x18c530 - g_ps2RecompiledFunctionTable[143695] = bhEne01Arm_DG00_0x18c060; // 0x18c544 - g_ps2RecompiledFunctionTable[143714] = bhEne01Arm_DG01_0x18c590; // 0x18c590 - g_ps2RecompiledFunctionTable[143743] = bhEne01Arm_DG01_0x18c590; // 0x18c604 - g_ps2RecompiledFunctionTable[143746] = bhEne01Arm_DG01_0x18c590; // 0x18c610 - g_ps2RecompiledFunctionTable[143752] = bhEne01Arm_DG01_0x18c590; // 0x18c628 - g_ps2RecompiledFunctionTable[143757] = bhEne01Arm_DG01_0x18c590; // 0x18c63c - g_ps2RecompiledFunctionTable[143762] = bhEne01Arm_DG01_0x18c590; // 0x18c650 - g_ps2RecompiledFunctionTable[143807] = bhEne01Arm_DG01_0x18c590; // 0x18c704 - g_ps2RecompiledFunctionTable[143814] = bhEne01Arm_DG01_0x18c590; // 0x18c720 - g_ps2RecompiledFunctionTable[143823] = bhEne01Arm_DG01_0x18c590; // 0x18c744 - g_ps2RecompiledFunctionTable[143831] = bhEne01Arm_DG01_0x18c590; // 0x18c764 - g_ps2RecompiledFunctionTable[143843] = bhEne01Arm_DG01_0x18c590; // 0x18c794 - g_ps2RecompiledFunctionTable[143877] = bhEne01Arm_DG01_0x18c590; // 0x18c81c - g_ps2RecompiledFunctionTable[143879] = bhEne01Arm_DG01_0x18c590; // 0x18c824 - g_ps2RecompiledFunctionTable[143887] = bhEne01Arm_DG01_0x18c590; // 0x18c844 - g_ps2RecompiledFunctionTable[143895] = bhEne01Arm_DG01_0x18c590; // 0x18c864 - g_ps2RecompiledFunctionTable[143925] = bhEne01Arm_DG01_0x18c590; // 0x18c8dc - g_ps2RecompiledFunctionTable[143932] = bhEne01Arm_DG01_0x18c590; // 0x18c8f8 - g_ps2RecompiledFunctionTable[143968] = bhEne01Arm_DG01_0x18c590; // 0x18c988 - g_ps2RecompiledFunctionTable[143970] = bhEne01Arm_DG01_0x18c590; // 0x18c990 - g_ps2RecompiledFunctionTable[143975] = bhEne01Arm_DG01_0x18c590; // 0x18c9a4 - g_ps2RecompiledFunctionTable[143980] = bhEne01Arm_DG01_0x18c590; // 0x18c9b8 - g_ps2RecompiledFunctionTable[144031] = bhEne01Arm_DG01_0x18c590; // 0x18ca84 - g_ps2RecompiledFunctionTable[144037] = bhEne01Arm_DG01_0x18c590; // 0x18ca9c - g_ps2RecompiledFunctionTable[144054] = bhEne01Arm_DG01_0x18c590; // 0x18cae0 - g_ps2RecompiledFunctionTable[144061] = bhEne01Arm_DG01_0x18c590; // 0x18cafc - g_ps2RecompiledFunctionTable[144066] = bhEne01Arm_DG01_0x18c590; // 0x18cb10 - g_ps2RecompiledFunctionTable[144071] = bhEne01Arm_DG01_0x18c590; // 0x18cb24 - g_ps2RecompiledFunctionTable[144112] = bhEne01Arm_DG01_0x18c590; // 0x18cbc8 - g_ps2RecompiledFunctionTable[144116] = bhEne01Arm_DG01_0x18c590; // 0x18cbd8 - g_ps2RecompiledFunctionTable[144120] = bhEne01Arm_DG01_0x18c590; // 0x18cbe8 - g_ps2RecompiledFunctionTable[144138] = bhEne01Arm_DG01_0x18c590; // 0x18cc30 - g_ps2RecompiledFunctionTable[144143] = bhEne01Arm_DG01_0x18c590; // 0x18cc44 - g_ps2RecompiledFunctionTable[144150] = bhEne01Arm_DG01_0x18c590; // 0x18cc60 - g_ps2RecompiledFunctionTable[144155] = bhEne01Arm_DG01_0x18c590; // 0x18cc74 - g_ps2RecompiledFunctionTable[144160] = bhEne01Arm_DG01_0x18c590; // 0x18cc88 - g_ps2RecompiledFunctionTable[144201] = bhEne01Arm_DG01_0x18c590; // 0x18cd2c - g_ps2RecompiledFunctionTable[144205] = bhEne01Arm_DG01_0x18c590; // 0x18cd3c - g_ps2RecompiledFunctionTable[144209] = bhEne01Arm_DG01_0x18c590; // 0x18cd4c - g_ps2RecompiledFunctionTable[144253] = bhEne01Arm_DG01_0x18c590; // 0x18cdfc - g_ps2RecompiledFunctionTable[144255] = bhEne01Arm_DG01_0x18c590; // 0x18ce04 - g_ps2RecompiledFunctionTable[144260] = bhEne01Arm_DG01_0x18c590; // 0x18ce18 - g_ps2RecompiledFunctionTable[144265] = bhEne01Arm_DG01_0x18c590; // 0x18ce2c - g_ps2RecompiledFunctionTable[144290] = bhEne01Leg_0x18ce90; // 0x18ce90 - g_ps2RecompiledFunctionTable[144291] = bhEne01Leg_0x18ce90; // 0x18ce94 - g_ps2RecompiledFunctionTable[144292] = bhEne01Leg_0x18ce90; // 0x18ce98 - g_ps2RecompiledFunctionTable[144293] = bhEne01Leg_0x18ce90; // 0x18ce9c - g_ps2RecompiledFunctionTable[144294] = bhEne01Leg_0x18ce90; // 0x18cea0 - g_ps2RecompiledFunctionTable[144295] = bhEne01Leg_0x18ce90; // 0x18cea4 - g_ps2RecompiledFunctionTable[144296] = bhEne01Leg_0x18ce90; // 0x18cea8 - g_ps2RecompiledFunctionTable[144297] = bhEne01Leg_0x18ce90; // 0x18ceac - g_ps2RecompiledFunctionTable[144298] = bhEne01Leg_Init_0x18ceb0; // 0x18ceb0 - g_ps2RecompiledFunctionTable[144311] = bhEne01Leg_Init_0x18ceb0; // 0x18cee4 - g_ps2RecompiledFunctionTable[144330] = bhEne01Leg_Move_0x18cf30; // 0x18cf30 - g_ps2RecompiledFunctionTable[144334] = bhEne01Leg_MV00_0x18cf40; // 0x18cf40 - g_ps2RecompiledFunctionTable[144338] = bhEne01Leg_Damage_0x18cf50; // 0x18cf50 - g_ps2RecompiledFunctionTable[144339] = bhEne01Leg_Damage_0x18cf50; // 0x18cf54 - g_ps2RecompiledFunctionTable[144340] = bhEne01Leg_Damage_0x18cf50; // 0x18cf58 - g_ps2RecompiledFunctionTable[144341] = bhEne01Leg_Damage_0x18cf50; // 0x18cf5c - g_ps2RecompiledFunctionTable[144342] = bhEne01Leg_Damage_0x18cf50; // 0x18cf60 - g_ps2RecompiledFunctionTable[144343] = bhEne01Leg_Damage_0x18cf50; // 0x18cf64 - g_ps2RecompiledFunctionTable[144344] = bhEne01Leg_Damage_0x18cf50; // 0x18cf68 - g_ps2RecompiledFunctionTable[144345] = bhEne01Leg_Damage_0x18cf50; // 0x18cf6c - g_ps2RecompiledFunctionTable[144346] = bhEne01Leg_DG00_0x18cf70; // 0x18cf70 - g_ps2RecompiledFunctionTable[144379] = bhEne01Leg_DG00_0x18cf70; // 0x18cff4 - g_ps2RecompiledFunctionTable[144388] = bhEne01Leg_DG00_0x18cf70; // 0x18d018 - g_ps2RecompiledFunctionTable[144410] = bhEne01Leg_DG00_0x18cf70; // 0x18d070 - g_ps2RecompiledFunctionTable[144428] = bhEne01Leg_DG00_0x18cf70; // 0x18d0b8 - g_ps2RecompiledFunctionTable[144445] = bhEne01Leg_DG00_0x18cf70; // 0x18d0fc - g_ps2RecompiledFunctionTable[144450] = bhEne01Leg_DG00_0x18cf70; // 0x18d110 - g_ps2RecompiledFunctionTable[144478] = bhEne01Leg_DG00_0x18cf70; // 0x18d180 - g_ps2RecompiledFunctionTable[144483] = bhEne01Leg_DG00_0x18cf70; // 0x18d194 - g_ps2RecompiledFunctionTable[144488] = bhEne01Leg_DG00_0x18cf70; // 0x18d1a8 - g_ps2RecompiledFunctionTable[144498] = bhEne01Leg_DG00_0x18cf70; // 0x18d1d0 - g_ps2RecompiledFunctionTable[144506] = bhEne01Leg_DG00_0x18cf70; // 0x18d1f0 - g_ps2RecompiledFunctionTable[144514] = bhEne01Leg_DG00_0x18cf70; // 0x18d210 - g_ps2RecompiledFunctionTable[144522] = bhEne01Head_0x18d230; // 0x18d230 - g_ps2RecompiledFunctionTable[144523] = bhEne01Head_0x18d230; // 0x18d234 - g_ps2RecompiledFunctionTable[144524] = bhEne01Head_0x18d230; // 0x18d238 - g_ps2RecompiledFunctionTable[144525] = bhEne01Head_0x18d230; // 0x18d23c - g_ps2RecompiledFunctionTable[144526] = bhEne01Head_0x18d230; // 0x18d240 - g_ps2RecompiledFunctionTable[144527] = bhEne01Head_0x18d230; // 0x18d244 - g_ps2RecompiledFunctionTable[144528] = bhEne01Head_0x18d230; // 0x18d248 - g_ps2RecompiledFunctionTable[144529] = bhEne01Head_0x18d230; // 0x18d24c - g_ps2RecompiledFunctionTable[144530] = bhEne01Head_Init_0x18d250; // 0x18d250 - g_ps2RecompiledFunctionTable[144543] = bhEne01Head_Init_0x18d250; // 0x18d284 - g_ps2RecompiledFunctionTable[144562] = bhEne01Head_Move_0x18d2d0; // 0x18d2d0 - g_ps2RecompiledFunctionTable[144566] = bhEne01Head_MV00_0x18d2e0; // 0x18d2e0 - g_ps2RecompiledFunctionTable[144570] = bhEne01Head_Damage_0x18d2f0; // 0x18d2f0 - g_ps2RecompiledFunctionTable[144571] = bhEne01Head_Damage_0x18d2f0; // 0x18d2f4 - g_ps2RecompiledFunctionTable[144572] = bhEne01Head_Damage_0x18d2f0; // 0x18d2f8 - g_ps2RecompiledFunctionTable[144573] = bhEne01Head_Damage_0x18d2f0; // 0x18d2fc - g_ps2RecompiledFunctionTable[144574] = bhEne01Head_Damage_0x18d2f0; // 0x18d300 - g_ps2RecompiledFunctionTable[144575] = bhEne01Head_Damage_0x18d2f0; // 0x18d304 - g_ps2RecompiledFunctionTable[144576] = bhEne01Head_Damage_0x18d2f0; // 0x18d308 - g_ps2RecompiledFunctionTable[144577] = bhEne01Head_Damage_0x18d2f0; // 0x18d30c - g_ps2RecompiledFunctionTable[144578] = bhEne01Head_DG00_0x18d310; // 0x18d310 - g_ps2RecompiledFunctionTable[144639] = bhEne01Head_DG00_0x18d310; // 0x18d404 - g_ps2RecompiledFunctionTable[144648] = bhEne01Head_DG00_0x18d310; // 0x18d428 - g_ps2RecompiledFunctionTable[144650] = bhEne01Head_DG00_0x18d310; // 0x18d430 - g_ps2RecompiledFunctionTable[144653] = bhEne01Head_DG00_0x18d310; // 0x18d43c - g_ps2RecompiledFunctionTable[144661] = bhEne01Head_DG00_0x18d310; // 0x18d45c - g_ps2RecompiledFunctionTable[144663] = bhEne01Head_DG00_0x18d310; // 0x18d464 - g_ps2RecompiledFunctionTable[144665] = bhEne01Head_DG00_0x18d310; // 0x18d46c - g_ps2RecompiledFunctionTable[144668] = bhEne01Head_DG00_0x18d310; // 0x18d478 - g_ps2RecompiledFunctionTable[144671] = bhEne01Head_DG00_0x18d310; // 0x18d484 - g_ps2RecompiledFunctionTable[144680] = bhEne01Head_DG00_0x18d310; // 0x18d4a8 - g_ps2RecompiledFunctionTable[144683] = bhEne01Head_DG00_0x18d310; // 0x18d4b4 - g_ps2RecompiledFunctionTable[144690] = bhEne01Head_DG00_0x18d310; // 0x18d4d0 - g_ps2RecompiledFunctionTable[144695] = bhEne01Head_DG00_0x18d310; // 0x18d4e4 - g_ps2RecompiledFunctionTable[144711] = bhEne01Head_DG00_0x18d310; // 0x18d524 - g_ps2RecompiledFunctionTable[144713] = bhEne01Head_DG00_0x18d310; // 0x18d52c - g_ps2RecompiledFunctionTable[144724] = bhEne01Head_DG00_0x18d310; // 0x18d558 - g_ps2RecompiledFunctionTable[144733] = bhEne01Head_DG00_0x18d310; // 0x18d57c - g_ps2RecompiledFunctionTable[144737] = bhEne01Head_DG00_0x18d310; // 0x18d58c - g_ps2RecompiledFunctionTable[144739] = bhEne01Head_DG00_0x18d310; // 0x18d594 - g_ps2RecompiledFunctionTable[144757] = bhEne01Head_DG00_0x18d310; // 0x18d5dc - g_ps2RecompiledFunctionTable[144767] = bhEne01Head_DG00_0x18d310; // 0x18d604 - g_ps2RecompiledFunctionTable[144776] = bhEne01Head_DG00_0x18d310; // 0x18d628 - g_ps2RecompiledFunctionTable[144784] = bhEne01Head_DG00_0x18d310; // 0x18d648 - g_ps2RecompiledFunctionTable[144794] = bhEne01Head_DG00_0x18d310; // 0x18d670 - g_ps2RecompiledFunctionTable[144804] = bhEne01Head_DG00_0x18d310; // 0x18d698 - g_ps2RecompiledFunctionTable[144808] = bhEne01Head_DG00_0x18d310; // 0x18d6a8 - g_ps2RecompiledFunctionTable[144810] = bhEne01Head_DG00_0x18d310; // 0x18d6b0 - g_ps2RecompiledFunctionTable[144813] = bhEne01Head_DG00_0x18d310; // 0x18d6bc - g_ps2RecompiledFunctionTable[144816] = bhEne01Head_DG00_0x18d310; // 0x18d6c8 - g_ps2RecompiledFunctionTable[144824] = bhEne01Head_DG00_0x18d310; // 0x18d6e8 - g_ps2RecompiledFunctionTable[144826] = bhEne01Head_DG00_0x18d310; // 0x18d6f0 - g_ps2RecompiledFunctionTable[144829] = bhEne01Head_DG00_0x18d310; // 0x18d6fc - g_ps2RecompiledFunctionTable[144832] = bhEne01Head_DG00_0x18d310; // 0x18d708 - g_ps2RecompiledFunctionTable[144840] = bhEne01Head_DG00_0x18d310; // 0x18d728 - g_ps2RecompiledFunctionTable[144842] = bhEne01Head_DG00_0x18d310; // 0x18d730 - g_ps2RecompiledFunctionTable[144848] = bhEne01Head_DG00_0x18d310; // 0x18d748 - g_ps2RecompiledFunctionTable[144856] = bhEne01Head_DG00_0x18d310; // 0x18d768 - g_ps2RecompiledFunctionTable[144861] = bhEne01Head_DG00_0x18d310; // 0x18d77c - g_ps2RecompiledFunctionTable[144906] = bhEne01Cap_0x18d830; // 0x18d830 - g_ps2RecompiledFunctionTable[144907] = bhEne01Cap_0x18d830; // 0x18d834 - g_ps2RecompiledFunctionTable[144908] = bhEne01Cap_0x18d830; // 0x18d838 - g_ps2RecompiledFunctionTable[144909] = bhEne01Cap_0x18d830; // 0x18d83c - g_ps2RecompiledFunctionTable[144910] = bhEne01Cap_0x18d830; // 0x18d840 - g_ps2RecompiledFunctionTable[144911] = bhEne01Cap_0x18d830; // 0x18d844 - g_ps2RecompiledFunctionTable[144912] = bhEne01Cap_0x18d830; // 0x18d848 - g_ps2RecompiledFunctionTable[144913] = bhEne01Cap_0x18d830; // 0x18d84c - g_ps2RecompiledFunctionTable[144914] = bhEne01Cap_0x18d830; // 0x18d850 - g_ps2RecompiledFunctionTable[144915] = bhEne01Cap_0x18d830; // 0x18d854 - g_ps2RecompiledFunctionTable[144916] = bhEne01Cap_0x18d830; // 0x18d858 - g_ps2RecompiledFunctionTable[144917] = bhEne01Cap_0x18d830; // 0x18d85c - g_ps2RecompiledFunctionTable[144918] = bhEne01Cap_0x18d830; // 0x18d860 - g_ps2RecompiledFunctionTable[144919] = bhEne01Cap_0x18d830; // 0x18d864 - g_ps2RecompiledFunctionTable[144920] = bhEne01Cap_0x18d830; // 0x18d868 - g_ps2RecompiledFunctionTable[144921] = bhEne01Cap_0x18d830; // 0x18d86c - g_ps2RecompiledFunctionTable[144922] = bhEne01Cap_0x18d830; // 0x18d870 - g_ps2RecompiledFunctionTable[144923] = bhEne01Cap_0x18d830; // 0x18d874 - g_ps2RecompiledFunctionTable[144924] = bhEne01Cap_0x18d830; // 0x18d878 - g_ps2RecompiledFunctionTable[144925] = bhEne01Cap_0x18d830; // 0x18d87c - g_ps2RecompiledFunctionTable[144926] = bhEne01Cap_0x18d830; // 0x18d880 - g_ps2RecompiledFunctionTable[144927] = bhEne01Cap_0x18d830; // 0x18d884 - g_ps2RecompiledFunctionTable[144928] = bhEne01Cap_0x18d830; // 0x18d888 - g_ps2RecompiledFunctionTable[144929] = bhEne01Cap_0x18d830; // 0x18d88c - g_ps2RecompiledFunctionTable[144930] = bhEne01Cap_0x18d830; // 0x18d890 - g_ps2RecompiledFunctionTable[144931] = bhEne01Cap_0x18d830; // 0x18d894 - g_ps2RecompiledFunctionTable[144932] = bhEne01Cap_0x18d830; // 0x18d898 - g_ps2RecompiledFunctionTable[144933] = bhEne01Cap_0x18d830; // 0x18d89c - g_ps2RecompiledFunctionTable[144934] = bhEne01Cap_0x18d830; // 0x18d8a0 - g_ps2RecompiledFunctionTable[144935] = bhEne01Cap_0x18d830; // 0x18d8a4 - g_ps2RecompiledFunctionTable[144936] = bhEne01Cap_0x18d830; // 0x18d8a8 - g_ps2RecompiledFunctionTable[144937] = bhEne01Cap_0x18d830; // 0x18d8ac - g_ps2RecompiledFunctionTable[144938] = bhEne01Cap_Init_0x18d8b0; // 0x18d8b0 - g_ps2RecompiledFunctionTable[144951] = bhEne01Cap_Init_0x18d8b0; // 0x18d8e4 - g_ps2RecompiledFunctionTable[144982] = bhEne01Cap_Move_0x18d960; // 0x18d960 - g_ps2RecompiledFunctionTable[144986] = bhEne01Cap_MV00_0x18d970; // 0x18d970 - g_ps2RecompiledFunctionTable[144990] = bhEne01Cap_Damage_0x18d980; // 0x18d980 - g_ps2RecompiledFunctionTable[144991] = bhEne01Cap_Damage_0x18d980; // 0x18d984 - g_ps2RecompiledFunctionTable[144992] = bhEne01Cap_Damage_0x18d980; // 0x18d988 - g_ps2RecompiledFunctionTable[144993] = bhEne01Cap_Damage_0x18d980; // 0x18d98c - g_ps2RecompiledFunctionTable[144994] = bhEne01Cap_Damage_0x18d980; // 0x18d990 - g_ps2RecompiledFunctionTable[144995] = bhEne01Cap_Damage_0x18d980; // 0x18d994 - g_ps2RecompiledFunctionTable[144996] = bhEne01Cap_Damage_0x18d980; // 0x18d998 - g_ps2RecompiledFunctionTable[144997] = bhEne01Cap_Damage_0x18d980; // 0x18d99c - g_ps2RecompiledFunctionTable[144998] = bhEne01Cap_DG00_0x18d9a0; // 0x18d9a0 - g_ps2RecompiledFunctionTable[145042] = bhEne01Cap_DG00_0x18d9a0; // 0x18da50 - g_ps2RecompiledFunctionTable[145057] = bhEne01Cap_DG00_0x18d9a0; // 0x18da8c - g_ps2RecompiledFunctionTable[145061] = bhEne01Cap_DG00_0x18d9a0; // 0x18da9c - g_ps2RecompiledFunctionTable[145072] = bhEne01Cap_DG00_0x18d9a0; // 0x18dac8 - g_ps2RecompiledFunctionTable[145081] = bhEne01Cap_DG00_0x18d9a0; // 0x18daec - g_ps2RecompiledFunctionTable[145091] = bhEne01Cap_DG00_0x18d9a0; // 0x18db14 - g_ps2RecompiledFunctionTable[145095] = bhEne01Cap_DG00_0x18d9a0; // 0x18db24 - g_ps2RecompiledFunctionTable[145125] = bhEne01Cap_DG00_0x18d9a0; // 0x18db9c - g_ps2RecompiledFunctionTable[145132] = bhEne01Cap_DG00_0x18d9a0; // 0x18dbb8 - g_ps2RecompiledFunctionTable[145154] = bhEne01Cap_DG00_0x18d9a0; // 0x18dc10 - g_ps2RecompiledFunctionTable[145171] = bhEne01Cap_DG00_0x18d9a0; // 0x18dc54 - g_ps2RecompiledFunctionTable[145174] = bhEne01Cap_DG00_0x18d9a0; // 0x18dc60 - g_ps2RecompiledFunctionTable[145183] = bhEne01Cap_DG00_0x18d9a0; // 0x18dc84 - g_ps2RecompiledFunctionTable[145185] = bhEne01Cap_DG00_0x18d9a0; // 0x18dc8c - g_ps2RecompiledFunctionTable[145188] = bhEne01Cap_DG00_0x18d9a0; // 0x18dc98 - g_ps2RecompiledFunctionTable[145191] = bhEne01Cap_DG00_0x18d9a0; // 0x18dca4 - g_ps2RecompiledFunctionTable[145199] = bhEne01Cap_DG00_0x18d9a0; // 0x18dcc4 - g_ps2RecompiledFunctionTable[145201] = bhEne01Cap_DG00_0x18d9a0; // 0x18dccc - g_ps2RecompiledFunctionTable[145204] = bhEne01Cap_DG00_0x18d9a0; // 0x18dcd8 - g_ps2RecompiledFunctionTable[145211] = bhEne01Cap_DG00_0x18d9a0; // 0x18dcf4 - g_ps2RecompiledFunctionTable[145216] = bhEne01Cap_DG00_0x18d9a0; // 0x18dd08 - g_ps2RecompiledFunctionTable[145243] = bhEne01Cap_DG00_0x18d9a0; // 0x18dd74 - g_ps2RecompiledFunctionTable[145256] = bhEne01Cap_DG00_0x18d9a0; // 0x18dda8 - g_ps2RecompiledFunctionTable[145271] = bhEne01Cap_DG00_0x18d9a0; // 0x18dde4 - g_ps2RecompiledFunctionTable[145282] = bhEne01Cap_DG01_0x18de10; // 0x18de10 - g_ps2RecompiledFunctionTable[145322] = bhEne01Cap_DG01_0x18de10; // 0x18deb0 - g_ps2RecompiledFunctionTable[145332] = bhEne01Cap_DG01_0x18de10; // 0x18ded8 - g_ps2RecompiledFunctionTable[145348] = bhEne01Cap_DG01_0x18de10; // 0x18df18 - g_ps2RecompiledFunctionTable[145351] = bhEne01Cap_DG01_0x18de10; // 0x18df24 - g_ps2RecompiledFunctionTable[145367] = bhEne01Cap_DG01_0x18de10; // 0x18df64 - g_ps2RecompiledFunctionTable[145392] = bhEne01Cap_DG01_0x18de10; // 0x18dfc8 - g_ps2RecompiledFunctionTable[145395] = bhEne01Cap_DG01_0x18de10; // 0x18dfd4 - g_ps2RecompiledFunctionTable[145407] = bhEne01Cap_DG01_0x18de10; // 0x18e004 - g_ps2RecompiledFunctionTable[145413] = bhEne01Cap_DG01_0x18de10; // 0x18e01c - g_ps2RecompiledFunctionTable[145417] = bhEne01Cap_DG01_0x18de10; // 0x18e02c - g_ps2RecompiledFunctionTable[145427] = bhEne01Cap_DG01_0x18de10; // 0x18e054 - g_ps2RecompiledFunctionTable[145430] = bhEne01Cap_DG01_0x18de10; // 0x18e060 - g_ps2RecompiledFunctionTable[145433] = bhEne01Cap_DG01_0x18de10; // 0x18e06c - g_ps2RecompiledFunctionTable[145444] = bhEne01Cap_DG01_0x18de10; // 0x18e098 - g_ps2RecompiledFunctionTable[145447] = bhEne01Cap_DG01_0x18de10; // 0x18e0a4 - g_ps2RecompiledFunctionTable[145449] = bhEne01Cap_DG01_0x18de10; // 0x18e0ac - g_ps2RecompiledFunctionTable[145469] = bhEne01Cap_DG01_0x18de10; // 0x18e0fc - g_ps2RecompiledFunctionTable[145478] = bhEne01Worm_0x18e120; // 0x18e120 - g_ps2RecompiledFunctionTable[145479] = bhEne01Worm_0x18e120; // 0x18e124 - g_ps2RecompiledFunctionTable[145480] = bhEne01Worm_0x18e120; // 0x18e128 - g_ps2RecompiledFunctionTable[145481] = bhEne01Worm_0x18e120; // 0x18e12c - g_ps2RecompiledFunctionTable[145482] = bhEne01Worm_0x18e120; // 0x18e130 - g_ps2RecompiledFunctionTable[145483] = bhEne01Worm_0x18e120; // 0x18e134 - g_ps2RecompiledFunctionTable[145484] = bhEne01Worm_0x18e120; // 0x18e138 - g_ps2RecompiledFunctionTable[145485] = bhEne01Worm_0x18e120; // 0x18e13c - g_ps2RecompiledFunctionTable[145486] = bhEne01Worm_0x18e120; // 0x18e140 - g_ps2RecompiledFunctionTable[145487] = bhEne01Worm_0x18e120; // 0x18e144 - g_ps2RecompiledFunctionTable[145488] = bhEne01Worm_0x18e120; // 0x18e148 - g_ps2RecompiledFunctionTable[145489] = bhEne01Worm_0x18e120; // 0x18e14c - g_ps2RecompiledFunctionTable[145490] = bhEne01Worm_0x18e120; // 0x18e150 - g_ps2RecompiledFunctionTable[145491] = bhEne01Worm_0x18e120; // 0x18e154 - g_ps2RecompiledFunctionTable[145492] = bhEne01Worm_0x18e120; // 0x18e158 - g_ps2RecompiledFunctionTable[145493] = bhEne01Worm_0x18e120; // 0x18e15c - g_ps2RecompiledFunctionTable[145494] = bhEne01Worm_0x18e120; // 0x18e160 - g_ps2RecompiledFunctionTable[145495] = bhEne01Worm_0x18e120; // 0x18e164 - g_ps2RecompiledFunctionTable[145496] = bhEne01Worm_0x18e120; // 0x18e168 - g_ps2RecompiledFunctionTable[145497] = bhEne01Worm_0x18e120; // 0x18e16c - g_ps2RecompiledFunctionTable[145498] = bhEne01Worm_0x18e120; // 0x18e170 - g_ps2RecompiledFunctionTable[145499] = bhEne01Worm_0x18e120; // 0x18e174 - g_ps2RecompiledFunctionTable[145500] = bhEne01Worm_0x18e120; // 0x18e178 - g_ps2RecompiledFunctionTable[145501] = bhEne01Worm_0x18e120; // 0x18e17c - g_ps2RecompiledFunctionTable[145502] = bhEne01Worm_0x18e120; // 0x18e180 - g_ps2RecompiledFunctionTable[145503] = bhEne01Worm_0x18e120; // 0x18e184 - g_ps2RecompiledFunctionTable[145504] = bhEne01Worm_0x18e120; // 0x18e188 - g_ps2RecompiledFunctionTable[145505] = bhEne01Worm_0x18e120; // 0x18e18c - g_ps2RecompiledFunctionTable[145506] = bhEne01Worm_0x18e120; // 0x18e190 - g_ps2RecompiledFunctionTable[145507] = bhEne01Worm_0x18e120; // 0x18e194 - g_ps2RecompiledFunctionTable[145508] = bhEne01Worm_0x18e120; // 0x18e198 - g_ps2RecompiledFunctionTable[145509] = bhEne01Worm_0x18e120; // 0x18e19c - g_ps2RecompiledFunctionTable[145510] = bhEne01Worm_0x18e120; // 0x18e1a0 - g_ps2RecompiledFunctionTable[145511] = bhEne01Worm_0x18e120; // 0x18e1a4 - g_ps2RecompiledFunctionTable[145512] = bhEne01Worm_0x18e120; // 0x18e1a8 - g_ps2RecompiledFunctionTable[145514] = bhEne01Worm_Init_0x18e1b0; // 0x18e1b0 - g_ps2RecompiledFunctionTable[145541] = bhEne01Worm_Init_0x18e1b0; // 0x18e21c - g_ps2RecompiledFunctionTable[145586] = bhEne01Worm_Move_0x18e2d0; // 0x18e2d0 - g_ps2RecompiledFunctionTable[145587] = bhEne01Worm_Move_0x18e2d0; // 0x18e2d4 - g_ps2RecompiledFunctionTable[145588] = bhEne01Worm_Move_0x18e2d0; // 0x18e2d8 - g_ps2RecompiledFunctionTable[145589] = bhEne01Worm_Move_0x18e2d0; // 0x18e2dc - g_ps2RecompiledFunctionTable[145590] = bhEne01Worm_Move_0x18e2d0; // 0x18e2e0 - g_ps2RecompiledFunctionTable[145591] = bhEne01Worm_Move_0x18e2d0; // 0x18e2e4 - g_ps2RecompiledFunctionTable[145592] = bhEne01Worm_Move_0x18e2d0; // 0x18e2e8 - g_ps2RecompiledFunctionTable[145593] = bhEne01Worm_Move_0x18e2d0; // 0x18e2ec - g_ps2RecompiledFunctionTable[145594] = bhEne01Worm_MV00_0x18e2f0; // 0x18e2f0 - g_ps2RecompiledFunctionTable[145598] = bhEne01Worm_MV01_0x18e300; // 0x18e300 - g_ps2RecompiledFunctionTable[145633] = bhEne01Worm_MV01_0x18e300; // 0x18e38c - g_ps2RecompiledFunctionTable[145641] = bhEne01Worm_MV01_0x18e300; // 0x18e3ac - g_ps2RecompiledFunctionTable[145649] = bhEne01Worm_MV01_0x18e300; // 0x18e3cc - g_ps2RecompiledFunctionTable[145655] = bhEne01Worm_MV01_0x18e300; // 0x18e3e4 - g_ps2RecompiledFunctionTable[145662] = bhEne01Worm_MV01_0x18e300; // 0x18e400 - g_ps2RecompiledFunctionTable[145670] = bhEne01Worm_MV01_0x18e300; // 0x18e420 - g_ps2RecompiledFunctionTable[145679] = bhEne01Worm_MV01_0x18e300; // 0x18e444 - g_ps2RecompiledFunctionTable[145704] = bhEne01Worm_MV01_0x18e300; // 0x18e4a8 - g_ps2RecompiledFunctionTable[145709] = bhEne01Worm_MV01_0x18e300; // 0x18e4bc - g_ps2RecompiledFunctionTable[145724] = bhEne01Worm_MV01_0x18e300; // 0x18e4f8 - g_ps2RecompiledFunctionTable[145736] = bhEne01Worm_MV01_0x18e300; // 0x18e528 - g_ps2RecompiledFunctionTable[145806] = bhEne01Worm_MV01_0x18e300; // 0x18e640 - g_ps2RecompiledFunctionTable[145811] = bhEne01Worm_MV01_0x18e300; // 0x18e654 - g_ps2RecompiledFunctionTable[145832] = bhEne01Worm_MV01_0x18e300; // 0x18e6a8 - g_ps2RecompiledFunctionTable[145851] = bhEne01Worm_MV01_0x18e300; // 0x18e6f4 - g_ps2RecompiledFunctionTable[145860] = bhEne01Worm_MV01_0x18e300; // 0x18e718 - g_ps2RecompiledFunctionTable[145937] = bhEne01Worm_MV01_0x18e300; // 0x18e84c - g_ps2RecompiledFunctionTable[145944] = bhEne01Worm_MV01_0x18e300; // 0x18e868 - g_ps2RecompiledFunctionTable[145961] = bhEne01Worm_MV01_0x18e300; // 0x18e8ac - g_ps2RecompiledFunctionTable[145990] = bhEne01Worm_MV01_0x18e300; // 0x18e920 - g_ps2RecompiledFunctionTable[146070] = bhEne01Worm_MV02_0x18ea60; // 0x18ea60 - g_ps2RecompiledFunctionTable[146101] = bhEne01Worm_MV02_0x18ea60; // 0x18eadc - g_ps2RecompiledFunctionTable[146141] = bhEne01Worm_MV02_0x18ea60; // 0x18eb7c - g_ps2RecompiledFunctionTable[146152] = bhEne01Worm_MV02_0x18ea60; // 0x18eba8 - g_ps2RecompiledFunctionTable[146243] = bhEne01Worm_MV02_0x18ea60; // 0x18ed14 - g_ps2RecompiledFunctionTable[146356] = bhEne01Worm_MV02_0x18ea60; // 0x18eed8 - g_ps2RecompiledFunctionTable[146363] = bhEne01Worm_MV02_0x18ea60; // 0x18eef4 - g_ps2RecompiledFunctionTable[146380] = bhEne01Worm_MV02_0x18ea60; // 0x18ef38 - g_ps2RecompiledFunctionTable[146455] = bhEne01Worm_MV02_0x18ea60; // 0x18f064 - g_ps2RecompiledFunctionTable[146461] = bhEne01Worm_MV02_0x18ea60; // 0x18f07c - g_ps2RecompiledFunctionTable[146546] = bhEne01Bom_0x18f1d0; // 0x18f1d0 - g_ps2RecompiledFunctionTable[146547] = bhEne01Bom_0x18f1d0; // 0x18f1d4 - g_ps2RecompiledFunctionTable[146548] = bhEne01Bom_0x18f1d0; // 0x18f1d8 - g_ps2RecompiledFunctionTable[146549] = bhEne01Bom_0x18f1d0; // 0x18f1dc - g_ps2RecompiledFunctionTable[146550] = bhEne01Bom_0x18f1d0; // 0x18f1e0 - g_ps2RecompiledFunctionTable[146551] = bhEne01Bom_0x18f1d0; // 0x18f1e4 - g_ps2RecompiledFunctionTable[146552] = bhEne01Bom_0x18f1d0; // 0x18f1e8 - g_ps2RecompiledFunctionTable[146553] = bhEne01Bom_0x18f1d0; // 0x18f1ec - g_ps2RecompiledFunctionTable[146554] = bhEne01Bom_0x18f1d0; // 0x18f1f0 - g_ps2RecompiledFunctionTable[146555] = bhEne01Bom_0x18f1d0; // 0x18f1f4 - g_ps2RecompiledFunctionTable[146556] = bhEne01Bom_0x18f1d0; // 0x18f1f8 - g_ps2RecompiledFunctionTable[146557] = bhEne01Bom_0x18f1d0; // 0x18f1fc - g_ps2RecompiledFunctionTable[146558] = bhEne01Bom_0x18f1d0; // 0x18f200 - g_ps2RecompiledFunctionTable[146559] = bhEne01Bom_0x18f1d0; // 0x18f204 - g_ps2RecompiledFunctionTable[146560] = bhEne01Bom_0x18f1d0; // 0x18f208 - g_ps2RecompiledFunctionTable[146561] = bhEne01Bom_0x18f1d0; // 0x18f20c - g_ps2RecompiledFunctionTable[146562] = bhEne01Bom_0x18f1d0; // 0x18f210 - g_ps2RecompiledFunctionTable[146563] = bhEne01Bom_0x18f1d0; // 0x18f214 - g_ps2RecompiledFunctionTable[146564] = bhEne01Bom_0x18f1d0; // 0x18f218 - g_ps2RecompiledFunctionTable[146565] = bhEne01Bom_0x18f1d0; // 0x18f21c - g_ps2RecompiledFunctionTable[146566] = bhEne01Bom_0x18f1d0; // 0x18f220 - g_ps2RecompiledFunctionTable[146567] = bhEne01Bom_0x18f1d0; // 0x18f224 - g_ps2RecompiledFunctionTable[146568] = bhEne01Bom_0x18f1d0; // 0x18f228 - g_ps2RecompiledFunctionTable[146569] = bhEne01Bom_0x18f1d0; // 0x18f22c - g_ps2RecompiledFunctionTable[146570] = bhEne01Bom_0x18f1d0; // 0x18f230 - g_ps2RecompiledFunctionTable[146571] = bhEne01Bom_0x18f1d0; // 0x18f234 - g_ps2RecompiledFunctionTable[146572] = bhEne01Bom_0x18f1d0; // 0x18f238 - g_ps2RecompiledFunctionTable[146573] = bhEne01Bom_0x18f1d0; // 0x18f23c - g_ps2RecompiledFunctionTable[146574] = bhEne01Bom_0x18f1d0; // 0x18f240 - g_ps2RecompiledFunctionTable[146575] = bhEne01Bom_0x18f1d0; // 0x18f244 - g_ps2RecompiledFunctionTable[146576] = bhEne01Bom_0x18f1d0; // 0x18f248 - g_ps2RecompiledFunctionTable[146577] = bhEne01Bom_0x18f1d0; // 0x18f24c - g_ps2RecompiledFunctionTable[146578] = bhEne01Bom_0x18f1d0; // 0x18f250 - g_ps2RecompiledFunctionTable[146579] = bhEne01Bom_0x18f1d0; // 0x18f254 - g_ps2RecompiledFunctionTable[146580] = bhEne01Bom_0x18f1d0; // 0x18f258 - g_ps2RecompiledFunctionTable[146581] = bhEne01Bom_0x18f1d0; // 0x18f25c - g_ps2RecompiledFunctionTable[146582] = bhEne01Bom_0x18f1d0; // 0x18f260 - g_ps2RecompiledFunctionTable[146583] = bhEne01Bom_0x18f1d0; // 0x18f264 - g_ps2RecompiledFunctionTable[146584] = bhEne01Bom_0x18f1d0; // 0x18f268 - g_ps2RecompiledFunctionTable[146585] = bhEne01Bom_0x18f1d0; // 0x18f26c - g_ps2RecompiledFunctionTable[146586] = bhEne01Bom_0x18f1d0; // 0x18f270 - g_ps2RecompiledFunctionTable[146587] = bhEne01Bom_0x18f1d0; // 0x18f274 - g_ps2RecompiledFunctionTable[146588] = bhEne01Bom_0x18f1d0; // 0x18f278 - g_ps2RecompiledFunctionTable[146589] = bhEne01Bom_0x18f1d0; // 0x18f27c - g_ps2RecompiledFunctionTable[146590] = bhEne01Bom_0x18f1d0; // 0x18f280 - g_ps2RecompiledFunctionTable[146591] = bhEne01Bom_0x18f1d0; // 0x18f284 - g_ps2RecompiledFunctionTable[146592] = bhEne01Bom_0x18f1d0; // 0x18f288 - g_ps2RecompiledFunctionTable[146593] = bhEne01Bom_0x18f1d0; // 0x18f28c - g_ps2RecompiledFunctionTable[146594] = bhEne01Bom_0x18f1d0; // 0x18f290 - g_ps2RecompiledFunctionTable[146595] = bhEne01Bom_0x18f1d0; // 0x18f294 - g_ps2RecompiledFunctionTable[146596] = bhEne01Bom_0x18f1d0; // 0x18f298 - g_ps2RecompiledFunctionTable[146597] = bhEne01Bom_0x18f1d0; // 0x18f29c - g_ps2RecompiledFunctionTable[146598] = bhEne01Bom_0x18f1d0; // 0x18f2a0 - g_ps2RecompiledFunctionTable[146599] = bhEne01Bom_0x18f1d0; // 0x18f2a4 - g_ps2RecompiledFunctionTable[146600] = bhEne01Bom_0x18f1d0; // 0x18f2a8 - g_ps2RecompiledFunctionTable[146601] = bhEne01Bom_0x18f1d0; // 0x18f2ac - g_ps2RecompiledFunctionTable[146602] = bhEne01Bom_0x18f1d0; // 0x18f2b0 - g_ps2RecompiledFunctionTable[146603] = bhEne01Bom_0x18f1d0; // 0x18f2b4 - g_ps2RecompiledFunctionTable[146604] = bhEne01Bom_0x18f1d0; // 0x18f2b8 - g_ps2RecompiledFunctionTable[146605] = bhEne01Bom_0x18f1d0; // 0x18f2bc - g_ps2RecompiledFunctionTable[146606] = bhEne01Bom_0x18f1d0; // 0x18f2c0 - g_ps2RecompiledFunctionTable[146607] = bhEne01Bom_0x18f1d0; // 0x18f2c4 - g_ps2RecompiledFunctionTable[146608] = bhEne01Bom_0x18f1d0; // 0x18f2c8 - g_ps2RecompiledFunctionTable[146609] = bhEne01Bom_0x18f1d0; // 0x18f2cc - g_ps2RecompiledFunctionTable[146610] = bhEne01Bom_0x18f1d0; // 0x18f2d0 - g_ps2RecompiledFunctionTable[146611] = bhEne01Bom_0x18f1d0; // 0x18f2d4 - g_ps2RecompiledFunctionTable[146612] = bhEne01Bom_0x18f1d0; // 0x18f2d8 - g_ps2RecompiledFunctionTable[146613] = bhEne01Bom_0x18f1d0; // 0x18f2dc - g_ps2RecompiledFunctionTable[146614] = bhEne01Bom_0x18f1d0; // 0x18f2e0 - g_ps2RecompiledFunctionTable[146615] = bhEne01Bom_0x18f1d0; // 0x18f2e4 - g_ps2RecompiledFunctionTable[146616] = bhEne01Bom_0x18f1d0; // 0x18f2e8 - g_ps2RecompiledFunctionTable[146617] = bhEne01Bom_0x18f1d0; // 0x18f2ec - g_ps2RecompiledFunctionTable[146618] = bhEne01Bom_Init_0x18f2f0; // 0x18f2f0 - g_ps2RecompiledFunctionTable[146631] = bhEne01Bom_Init_0x18f2f0; // 0x18f324 - g_ps2RecompiledFunctionTable[146670] = bhEne01Bom_Move_0x18f3c0; // 0x18f3c0 - g_ps2RecompiledFunctionTable[146715] = bhEne01Bom_Move_0x18f3c0; // 0x18f474 - g_ps2RecompiledFunctionTable[146735] = bhEne01Bom_Move_0x18f3c0; // 0x18f4c4 - g_ps2RecompiledFunctionTable[146739] = bhEne01Bom_Move_0x18f3c0; // 0x18f4d4 - g_ps2RecompiledFunctionTable[146754] = bhEne01Scope_0x18f510; // 0x18f510 - g_ps2RecompiledFunctionTable[146755] = bhEne01Scope_0x18f510; // 0x18f514 - g_ps2RecompiledFunctionTable[146756] = bhEne01Scope_0x18f510; // 0x18f518 - g_ps2RecompiledFunctionTable[146757] = bhEne01Scope_0x18f510; // 0x18f51c - g_ps2RecompiledFunctionTable[146758] = bhEne01Scope_0x18f510; // 0x18f520 - g_ps2RecompiledFunctionTable[146759] = bhEne01Scope_0x18f510; // 0x18f524 - g_ps2RecompiledFunctionTable[146760] = bhEne01Scope_0x18f510; // 0x18f528 - g_ps2RecompiledFunctionTable[146761] = bhEne01Scope_0x18f510; // 0x18f52c - g_ps2RecompiledFunctionTable[146762] = bhEne01Scope_0x18f510; // 0x18f530 - g_ps2RecompiledFunctionTable[146763] = bhEne01Scope_0x18f510; // 0x18f534 - g_ps2RecompiledFunctionTable[146764] = bhEne01Scope_0x18f510; // 0x18f538 - g_ps2RecompiledFunctionTable[146765] = bhEne01Scope_0x18f510; // 0x18f53c - g_ps2RecompiledFunctionTable[146766] = bhEne01Scope_0x18f510; // 0x18f540 - g_ps2RecompiledFunctionTable[146767] = bhEne01Scope_0x18f510; // 0x18f544 - g_ps2RecompiledFunctionTable[146768] = bhEne01Scope_0x18f510; // 0x18f548 - g_ps2RecompiledFunctionTable[146769] = bhEne01Scope_0x18f510; // 0x18f54c - g_ps2RecompiledFunctionTable[146770] = bhEne01Scope_0x18f510; // 0x18f550 - g_ps2RecompiledFunctionTable[146771] = bhEne01Scope_0x18f510; // 0x18f554 - g_ps2RecompiledFunctionTable[146772] = bhEne01Scope_0x18f510; // 0x18f558 - g_ps2RecompiledFunctionTable[146773] = bhEne01Scope_0x18f510; // 0x18f55c - g_ps2RecompiledFunctionTable[146774] = bhEne01Scope_0x18f510; // 0x18f560 - g_ps2RecompiledFunctionTable[146775] = bhEne01Scope_0x18f510; // 0x18f564 - g_ps2RecompiledFunctionTable[146776] = bhEne01Scope_0x18f510; // 0x18f568 - g_ps2RecompiledFunctionTable[146777] = bhEne01Scope_0x18f510; // 0x18f56c - g_ps2RecompiledFunctionTable[146778] = bhEne01Scope_0x18f510; // 0x18f570 - g_ps2RecompiledFunctionTable[146779] = bhEne01Scope_0x18f510; // 0x18f574 - g_ps2RecompiledFunctionTable[146780] = bhEne01Scope_0x18f510; // 0x18f578 - g_ps2RecompiledFunctionTable[146781] = bhEne01Scope_0x18f510; // 0x18f57c - g_ps2RecompiledFunctionTable[146782] = bhEne01Scope_0x18f510; // 0x18f580 - g_ps2RecompiledFunctionTable[146783] = bhEne01Scope_0x18f510; // 0x18f584 - g_ps2RecompiledFunctionTable[146784] = bhEne01Scope_0x18f510; // 0x18f588 - g_ps2RecompiledFunctionTable[146785] = bhEne01Scope_0x18f510; // 0x18f58c - g_ps2RecompiledFunctionTable[146786] = bhEne01Scope_0x18f510; // 0x18f590 - g_ps2RecompiledFunctionTable[146787] = bhEne01Scope_0x18f510; // 0x18f594 - g_ps2RecompiledFunctionTable[146790] = bhEne01Scope_Init_0x18f5a0; // 0x18f5a0 - g_ps2RecompiledFunctionTable[146814] = bhEne01Scope_Move_0x18f600; // 0x18f600 - g_ps2RecompiledFunctionTable[146818] = bhEne01Scope_Effect_0x18f610; // 0x18f610 - g_ps2RecompiledFunctionTable[146877] = bhEne01Scope_Effect_0x18f610; // 0x18f6fc - g_ps2RecompiledFunctionTable[146885] = bhEne01Scope_Effect_0x18f610; // 0x18f71c - g_ps2RecompiledFunctionTable[146894] = bhEne01Scope_Effect_0x18f610; // 0x18f740 - g_ps2RecompiledFunctionTable[146904] = bhEne01Scope_Effect_0x18f610; // 0x18f768 - g_ps2RecompiledFunctionTable[146909] = bhEne01Scope_Effect_0x18f610; // 0x18f77c - g_ps2RecompiledFunctionTable[146922] = bhEne01Scope_Effect_0x18f610; // 0x18f7b0 - g_ps2RecompiledFunctionTable[146927] = bhEne01Scope_Effect_0x18f610; // 0x18f7c4 - g_ps2RecompiledFunctionTable[146932] = bhEne01Scope_Effect_0x18f610; // 0x18f7d8 - g_ps2RecompiledFunctionTable[146937] = bhEne01Scope_Effect_0x18f610; // 0x18f7ec - g_ps2RecompiledFunctionTable[146954] = bhEne02_0x18f830; // 0x18f830 - g_ps2RecompiledFunctionTable[146955] = bhEne02_0x18f830; // 0x18f834 - g_ps2RecompiledFunctionTable[146956] = bhEne02_0x18f830; // 0x18f838 - g_ps2RecompiledFunctionTable[146957] = bhEne02_0x18f830; // 0x18f83c - g_ps2RecompiledFunctionTable[146958] = bhEne02_0x18f830; // 0x18f840 - g_ps2RecompiledFunctionTable[146959] = bhEne02_0x18f830; // 0x18f844 - g_ps2RecompiledFunctionTable[146960] = bhEne02_0x18f830; // 0x18f848 - g_ps2RecompiledFunctionTable[146961] = bhEne02_0x18f830; // 0x18f84c - g_ps2RecompiledFunctionTable[146962] = bhEne02_0x18f830; // 0x18f850 - g_ps2RecompiledFunctionTable[146963] = bhEne02_0x18f830; // 0x18f854 - g_ps2RecompiledFunctionTable[146964] = bhEne02_0x18f830; // 0x18f858 - g_ps2RecompiledFunctionTable[146965] = bhEne02_0x18f830; // 0x18f85c - g_ps2RecompiledFunctionTable[146966] = bhEne02_0x18f830; // 0x18f860 - g_ps2RecompiledFunctionTable[146967] = bhEne02_0x18f830; // 0x18f864 - g_ps2RecompiledFunctionTable[146968] = bhEne02_0x18f830; // 0x18f868 - g_ps2RecompiledFunctionTable[146969] = bhEne02_0x18f830; // 0x18f86c - g_ps2RecompiledFunctionTable[146970] = bhEne02_0x18f830; // 0x18f870 - g_ps2RecompiledFunctionTable[146971] = bhEne02_0x18f830; // 0x18f874 - g_ps2RecompiledFunctionTable[146972] = bhEne02_0x18f830; // 0x18f878 - g_ps2RecompiledFunctionTable[146973] = bhEne02_0x18f830; // 0x18f87c - g_ps2RecompiledFunctionTable[146974] = bhEne02_0x18f830; // 0x18f880 - g_ps2RecompiledFunctionTable[146975] = bhEne02_0x18f830; // 0x18f884 - g_ps2RecompiledFunctionTable[146976] = bhEne02_0x18f830; // 0x18f888 - g_ps2RecompiledFunctionTable[146977] = bhEne02_0x18f830; // 0x18f88c - g_ps2RecompiledFunctionTable[146978] = bhEne02_0x18f830; // 0x18f890 - g_ps2RecompiledFunctionTable[146979] = bhEne02_0x18f830; // 0x18f894 - g_ps2RecompiledFunctionTable[146980] = bhEne02_0x18f830; // 0x18f898 - g_ps2RecompiledFunctionTable[146981] = bhEne02_0x18f830; // 0x18f89c - g_ps2RecompiledFunctionTable[146982] = bhEne02_0x18f830; // 0x18f8a0 - g_ps2RecompiledFunctionTable[146983] = bhEne02_0x18f830; // 0x18f8a4 - g_ps2RecompiledFunctionTable[146984] = bhEne02_0x18f830; // 0x18f8a8 - g_ps2RecompiledFunctionTable[146985] = bhEne02_0x18f830; // 0x18f8ac - g_ps2RecompiledFunctionTable[146986] = bhEne02_0x18f830; // 0x18f8b0 - g_ps2RecompiledFunctionTable[146987] = bhEne02_0x18f830; // 0x18f8b4 - g_ps2RecompiledFunctionTable[146988] = bhEne02_0x18f830; // 0x18f8b8 - g_ps2RecompiledFunctionTable[146989] = bhEne02_0x18f830; // 0x18f8bc - g_ps2RecompiledFunctionTable[146990] = bhEne02_0x18f830; // 0x18f8c0 - g_ps2RecompiledFunctionTable[146991] = bhEne02_0x18f830; // 0x18f8c4 - g_ps2RecompiledFunctionTable[146992] = bhEne02_0x18f830; // 0x18f8c8 - g_ps2RecompiledFunctionTable[146993] = bhEne02_0x18f830; // 0x18f8cc - g_ps2RecompiledFunctionTable[146994] = bhEne02_0x18f830; // 0x18f8d0 - g_ps2RecompiledFunctionTable[146995] = bhEne02_0x18f830; // 0x18f8d4 - g_ps2RecompiledFunctionTable[146996] = bhEne02_0x18f830; // 0x18f8d8 - g_ps2RecompiledFunctionTable[146997] = bhEne02_0x18f830; // 0x18f8dc - g_ps2RecompiledFunctionTable[146998] = bhEne02_0x18f830; // 0x18f8e0 - g_ps2RecompiledFunctionTable[146999] = bhEne02_0x18f830; // 0x18f8e4 - g_ps2RecompiledFunctionTable[147000] = bhEne02_0x18f830; // 0x18f8e8 - g_ps2RecompiledFunctionTable[147001] = bhEne02_0x18f830; // 0x18f8ec - g_ps2RecompiledFunctionTable[147002] = bhEne02_0x18f830; // 0x18f8f0 - g_ps2RecompiledFunctionTable[147003] = bhEne02_0x18f830; // 0x18f8f4 - g_ps2RecompiledFunctionTable[147004] = bhEne02_0x18f830; // 0x18f8f8 - g_ps2RecompiledFunctionTable[147005] = bhEne02_0x18f830; // 0x18f8fc - g_ps2RecompiledFunctionTable[147006] = bhEne02_0x18f830; // 0x18f900 - g_ps2RecompiledFunctionTable[147007] = bhEne02_0x18f830; // 0x18f904 - g_ps2RecompiledFunctionTable[147008] = bhEne02_0x18f830; // 0x18f908 - g_ps2RecompiledFunctionTable[147009] = bhEne02_0x18f830; // 0x18f90c - g_ps2RecompiledFunctionTable[147010] = bhEne02_0x18f830; // 0x18f910 - g_ps2RecompiledFunctionTable[147011] = bhEne02_0x18f830; // 0x18f914 - g_ps2RecompiledFunctionTable[147012] = bhEne02_0x18f830; // 0x18f918 - g_ps2RecompiledFunctionTable[147013] = bhEne02_0x18f830; // 0x18f91c - g_ps2RecompiledFunctionTable[147014] = bhEne02_Init_0x18f920; // 0x18f920 - g_ps2RecompiledFunctionTable[147067] = bhEne02_Init_0x18f920; // 0x18f9f4 - g_ps2RecompiledFunctionTable[147074] = bhEne02_Init_0x18f920; // 0x18fa10 - g_ps2RecompiledFunctionTable[147100] = bhEne02_Init_0x18f920; // 0x18fa78 - g_ps2RecompiledFunctionTable[147115] = bhEne02_Init_0x18f920; // 0x18fab4 - g_ps2RecompiledFunctionTable[147121] = bhEne02_Init_0x18f920; // 0x18facc - g_ps2RecompiledFunctionTable[147146] = bhEne02_Init_0x18f920; // 0x18fb30 - g_ps2RecompiledFunctionTable[147258] = bhEne02_Brain_0x18fcf0; // 0x18fcf0 - g_ps2RecompiledFunctionTable[147262] = bhEne02_BR00_0x18fd00; // 0x18fd00 - g_ps2RecompiledFunctionTable[147281] = bhEne02_BR00_0x18fd00; // 0x18fd4c - g_ps2RecompiledFunctionTable[147295] = bhEne02_BR00_0x18fd00; // 0x18fd84 - g_ps2RecompiledFunctionTable[147303] = bhEne02_BR00_0x18fd00; // 0x18fda4 - g_ps2RecompiledFunctionTable[147309] = bhEne02_BR00_0x18fd00; // 0x18fdbc - g_ps2RecompiledFunctionTable[147315] = bhEne02_BR00_0x18fd00; // 0x18fdd4 - g_ps2RecompiledFunctionTable[147319] = bhEne02_BR00_0x18fd00; // 0x18fde4 - g_ps2RecompiledFunctionTable[147325] = bhEne02_BR00_0x18fd00; // 0x18fdfc - g_ps2RecompiledFunctionTable[147337] = bhEne02_BR00_0x18fd00; // 0x18fe2c - g_ps2RecompiledFunctionTable[147350] = bhEne02_BR00_0x18fd00; // 0x18fe60 - g_ps2RecompiledFunctionTable[147368] = bhEne02_BR00_0x18fd00; // 0x18fea8 - g_ps2RecompiledFunctionTable[147381] = bhEne02_BR00_0x18fd00; // 0x18fedc - g_ps2RecompiledFunctionTable[147387] = bhEne02_BR00_0x18fd00; // 0x18fef4 - g_ps2RecompiledFunctionTable[147400] = bhEne02_BR00_0x18fd00; // 0x18ff28 - g_ps2RecompiledFunctionTable[147414] = bhEne02_BR00_0x18fd00; // 0x18ff60 - g_ps2RecompiledFunctionTable[147422] = bhEne02_BR00_0x18fd00; // 0x18ff80 - g_ps2RecompiledFunctionTable[147428] = bhEne02_BR00_0x18fd00; // 0x18ff98 - g_ps2RecompiledFunctionTable[147434] = bhEne02_BR00_0x18fd00; // 0x18ffb0 - g_ps2RecompiledFunctionTable[147438] = bhEne02_BR00_0x18fd00; // 0x18ffc0 - g_ps2RecompiledFunctionTable[147444] = bhEne02_BR00_0x18fd00; // 0x18ffd8 - g_ps2RecompiledFunctionTable[147456] = bhEne02_BR00_0x18fd00; // 0x190008 - g_ps2RecompiledFunctionTable[147469] = bhEne02_BR00_0x18fd00; // 0x19003c - g_ps2RecompiledFunctionTable[147494] = bhEne02_Move_0x1900a0; // 0x1900a0 - g_ps2RecompiledFunctionTable[147495] = bhEne02_Move_0x1900a0; // 0x1900a4 - g_ps2RecompiledFunctionTable[147496] = bhEne02_Move_0x1900a0; // 0x1900a8 - g_ps2RecompiledFunctionTable[147497] = bhEne02_Move_0x1900a0; // 0x1900ac - g_ps2RecompiledFunctionTable[147498] = bhEne02_Move_0x1900a0; // 0x1900b0 - g_ps2RecompiledFunctionTable[147499] = bhEne02_Move_0x1900a0; // 0x1900b4 - g_ps2RecompiledFunctionTable[147500] = bhEne02_Move_0x1900a0; // 0x1900b8 - g_ps2RecompiledFunctionTable[147501] = bhEne02_Move_0x1900a0; // 0x1900bc - g_ps2RecompiledFunctionTable[147502] = bhEne02_Move_0x1900a0; // 0x1900c0 - g_ps2RecompiledFunctionTable[147503] = bhEne02_Move_0x1900a0; // 0x1900c4 - g_ps2RecompiledFunctionTable[147504] = bhEne02_Move_0x1900a0; // 0x1900c8 - g_ps2RecompiledFunctionTable[147505] = bhEne02_Move_0x1900a0; // 0x1900cc - g_ps2RecompiledFunctionTable[147506] = bhEne02_Move_0x1900a0; // 0x1900d0 - g_ps2RecompiledFunctionTable[147507] = bhEne02_Move_0x1900a0; // 0x1900d4 - g_ps2RecompiledFunctionTable[147508] = bhEne02_Move_0x1900a0; // 0x1900d8 - g_ps2RecompiledFunctionTable[147509] = bhEne02_Move_0x1900a0; // 0x1900dc - g_ps2RecompiledFunctionTable[147510] = bhEne02_Move_0x1900a0; // 0x1900e0 - g_ps2RecompiledFunctionTable[147511] = bhEne02_Move_0x1900a0; // 0x1900e4 - g_ps2RecompiledFunctionTable[147512] = bhEne02_Move_0x1900a0; // 0x1900e8 - g_ps2RecompiledFunctionTable[147513] = bhEne02_Move_0x1900a0; // 0x1900ec - g_ps2RecompiledFunctionTable[147514] = bhEne02_Move_0x1900a0; // 0x1900f0 - g_ps2RecompiledFunctionTable[147515] = bhEne02_Move_0x1900a0; // 0x1900f4 - g_ps2RecompiledFunctionTable[147516] = bhEne02_Move_0x1900a0; // 0x1900f8 - g_ps2RecompiledFunctionTable[147517] = bhEne02_Move_0x1900a0; // 0x1900fc - g_ps2RecompiledFunctionTable[147518] = bhEne02_Move_0x1900a0; // 0x190100 - g_ps2RecompiledFunctionTable[147519] = bhEne02_Move_0x1900a0; // 0x190104 - g_ps2RecompiledFunctionTable[147520] = bhEne02_Move_0x1900a0; // 0x190108 - g_ps2RecompiledFunctionTable[147521] = bhEne02_Move_0x1900a0; // 0x19010c - g_ps2RecompiledFunctionTable[147522] = bhEne02_Move_0x1900a0; // 0x190110 - g_ps2RecompiledFunctionTable[147523] = bhEne02_Move_0x1900a0; // 0x190114 - g_ps2RecompiledFunctionTable[147524] = bhEne02_Move_0x1900a0; // 0x190118 - g_ps2RecompiledFunctionTable[147525] = bhEne02_Move_0x1900a0; // 0x19011c - g_ps2RecompiledFunctionTable[147526] = bhEne02_Move_0x1900a0; // 0x190120 - g_ps2RecompiledFunctionTable[147530] = bhEne02_MV00_0x190130; // 0x190130 - g_ps2RecompiledFunctionTable[147563] = bhEne02_MV00_0x190130; // 0x1901b4 - g_ps2RecompiledFunctionTable[147576] = bhEne02_MV00_0x190130; // 0x1901e8 - g_ps2RecompiledFunctionTable[147580] = bhEne02_MV00_0x190130; // 0x1901f8 - g_ps2RecompiledFunctionTable[147593] = bhEne02_MV00_0x190130; // 0x19022c - g_ps2RecompiledFunctionTable[147610] = bhEne02_MV00_0x190130; // 0x190270 - g_ps2RecompiledFunctionTable[147617] = bhEne02_MV00_0x190130; // 0x19028c - g_ps2RecompiledFunctionTable[147625] = bhEne02_MV00_0x190130; // 0x1902ac - g_ps2RecompiledFunctionTable[147632] = bhEne02_MV00_0x190130; // 0x1902c8 - g_ps2RecompiledFunctionTable[147662] = bhEne02_MV00_0x190130; // 0x190340 - g_ps2RecompiledFunctionTable[147694] = bhEne02_MV00_0x190130; // 0x1903c0 - g_ps2RecompiledFunctionTable[147702] = bhEne02_MV00_0x190130; // 0x1903e0 - g_ps2RecompiledFunctionTable[147714] = bhEne02_MV00_0x190130; // 0x190410 - g_ps2RecompiledFunctionTable[147722] = bhEne02_MV00_0x190130; // 0x190430 - g_ps2RecompiledFunctionTable[147729] = bhEne02_MV00_0x190130; // 0x19044c - g_ps2RecompiledFunctionTable[147742] = bhEne02_MV00_0x190130; // 0x190480 - g_ps2RecompiledFunctionTable[147752] = bhEne02_MV00_0x190130; // 0x1904a8 - g_ps2RecompiledFunctionTable[147760] = bhEne02_MV00_0x190130; // 0x1904c8 - g_ps2RecompiledFunctionTable[147767] = bhEne02_MV00_0x190130; // 0x1904e4 - g_ps2RecompiledFunctionTable[147774] = bhEne02_MV02_0x190500; // 0x190500 - g_ps2RecompiledFunctionTable[147838] = bhEne02_MV02_0x190500; // 0x190600 - g_ps2RecompiledFunctionTable[147874] = bhEne02_MV02_0x190500; // 0x190690 - g_ps2RecompiledFunctionTable[147930] = bhEne02_MV02_0x190500; // 0x190770 - g_ps2RecompiledFunctionTable[147961] = bhEne02_MV02_0x190500; // 0x1907ec - g_ps2RecompiledFunctionTable[147964] = bhEne02_MV02_0x190500; // 0x1907f8 - g_ps2RecompiledFunctionTable[147975] = bhEne02_MV02_0x190500; // 0x190824 - g_ps2RecompiledFunctionTable[147996] = bhEne02_MV02_0x190500; // 0x190878 - g_ps2RecompiledFunctionTable[147999] = bhEne02_MV02_0x190500; // 0x190884 - g_ps2RecompiledFunctionTable[148054] = bhEne02_MV02_0x190500; // 0x190960 - g_ps2RecompiledFunctionTable[148069] = bhEne02_MV02_0x190500; // 0x19099c - g_ps2RecompiledFunctionTable[148097] = bhEne02_MV02_0x190500; // 0x190a0c - g_ps2RecompiledFunctionTable[148119] = bhEne02_MV02_0x190500; // 0x190a64 - g_ps2RecompiledFunctionTable[148124] = bhEne02_MV02_0x190500; // 0x190a78 - g_ps2RecompiledFunctionTable[148132] = bhEne02_MV02_0x190500; // 0x190a98 - g_ps2RecompiledFunctionTable[148135] = bhEne02_MV02_0x190500; // 0x190aa4 - g_ps2RecompiledFunctionTable[148144] = bhEne02_MV02_0x190500; // 0x190ac8 - g_ps2RecompiledFunctionTable[148154] = bhEne02_MV02_0x190500; // 0x190af0 - g_ps2RecompiledFunctionTable[148170] = bhEne02_MV02_0x190500; // 0x190b30 - g_ps2RecompiledFunctionTable[148180] = bhEne02_MV02_0x190500; // 0x190b58 - g_ps2RecompiledFunctionTable[148233] = bhEne02_MV02_0x190500; // 0x190c2c - g_ps2RecompiledFunctionTable[148242] = bhEne02_MV02_0x190500; // 0x190c50 - g_ps2RecompiledFunctionTable[148255] = bhEne02_MV02_0x190500; // 0x190c84 - g_ps2RecompiledFunctionTable[148286] = bhEne02_MV02_0x190500; // 0x190d00 - g_ps2RecompiledFunctionTable[148295] = bhEne02_MV02_0x190500; // 0x190d24 - g_ps2RecompiledFunctionTable[148308] = bhEne02_MV02_0x190500; // 0x190d58 - g_ps2RecompiledFunctionTable[148404] = bhEne02_MV02_0x190500; // 0x190ed8 - g_ps2RecompiledFunctionTable[148407] = bhEne02_MV02_0x190500; // 0x190ee4 - g_ps2RecompiledFunctionTable[148450] = bhEne02_MV03_0x190f90; // 0x190f90 - g_ps2RecompiledFunctionTable[148462] = bhEne02_MV03_0x190f90; // 0x190fc0 - g_ps2RecompiledFunctionTable[148498] = bhEne02_MV03_0x190f90; // 0x191050 - g_ps2RecompiledFunctionTable[148560] = bhEne02_MV03_0x190f90; // 0x191148 - g_ps2RecompiledFunctionTable[148572] = bhEne02_MV03_0x190f90; // 0x191178 - g_ps2RecompiledFunctionTable[148586] = bhEne02_MV03_0x190f90; // 0x1911b0 - g_ps2RecompiledFunctionTable[148595] = bhEne02_MV03_0x190f90; // 0x1911d4 - g_ps2RecompiledFunctionTable[148608] = bhEne02_MV03_0x190f90; // 0x191208 - g_ps2RecompiledFunctionTable[148615] = bhEne02_MV03_0x190f90; // 0x191224 - g_ps2RecompiledFunctionTable[148628] = bhEne02_MV03_0x190f90; // 0x191258 - g_ps2RecompiledFunctionTable[148645] = bhEne02_MV03_0x190f90; // 0x19129c - g_ps2RecompiledFunctionTable[148663] = bhEne02_MV03_0x190f90; // 0x1912e4 - g_ps2RecompiledFunctionTable[148669] = bhEne02_MV03_0x190f90; // 0x1912fc - g_ps2RecompiledFunctionTable[148707] = bhEne02_MV03_0x190f90; // 0x191394 - g_ps2RecompiledFunctionTable[148718] = bhEne02_MV03_0x190f90; // 0x1913c0 - g_ps2RecompiledFunctionTable[148727] = bhEne02_MV03_0x190f90; // 0x1913e4 - g_ps2RecompiledFunctionTable[148733] = bhEne02_MV03_0x190f90; // 0x1913fc - g_ps2RecompiledFunctionTable[148742] = bhEne02_MV03_0x190f90; // 0x191420 - g_ps2RecompiledFunctionTable[148745] = bhEne02_MV03_0x190f90; // 0x19142c - g_ps2RecompiledFunctionTable[148780] = bhEne02_MV03_0x190f90; // 0x1914b8 - g_ps2RecompiledFunctionTable[148809] = bhEne02_MV03_0x190f90; // 0x19152c - g_ps2RecompiledFunctionTable[148822] = bhEne02_MV03_0x190f90; // 0x191560 - g_ps2RecompiledFunctionTable[148834] = bhEne02_MV03_0x190f90; // 0x191590 - g_ps2RecompiledFunctionTable[148882] = bhEne02_MV03_0x190f90; // 0x191650 - g_ps2RecompiledFunctionTable[148888] = bhEne02_MV03_0x190f90; // 0x191668 - g_ps2RecompiledFunctionTable[148892] = bhEne02_MV03_0x190f90; // 0x191678 - g_ps2RecompiledFunctionTable[148904] = bhEne02_MV03_0x190f90; // 0x1916a8 - g_ps2RecompiledFunctionTable[148945] = bhEne02_MV03_0x190f90; // 0x19174c - g_ps2RecompiledFunctionTable[148957] = bhEne02_MV03_0x190f90; // 0x19177c - g_ps2RecompiledFunctionTable[148970] = bhEne02_MV03_0x190f90; // 0x1917b0 - g_ps2RecompiledFunctionTable[148994] = bhEne02_MV04_0x191810; // 0x191810 - g_ps2RecompiledFunctionTable[149055] = bhEne02_MV04_0x191810; // 0x191904 - g_ps2RecompiledFunctionTable[149063] = bhEne02_MV04_0x191810; // 0x191924 - g_ps2RecompiledFunctionTable[149094] = bhEne02_MV04_0x191810; // 0x1919a0 - g_ps2RecompiledFunctionTable[149109] = bhEne02_MV04_0x191810; // 0x1919dc - g_ps2RecompiledFunctionTable[149126] = bhEne02_MV04_0x191810; // 0x191a20 - g_ps2RecompiledFunctionTable[149148] = bhEne02_MV04_0x191810; // 0x191a78 - g_ps2RecompiledFunctionTable[149153] = bhEne02_MV04_0x191810; // 0x191a8c - g_ps2RecompiledFunctionTable[149161] = bhEne02_MV04_0x191810; // 0x191aac - g_ps2RecompiledFunctionTable[149164] = bhEne02_MV04_0x191810; // 0x191ab8 - g_ps2RecompiledFunctionTable[149173] = bhEne02_MV04_0x191810; // 0x191adc - g_ps2RecompiledFunctionTable[149183] = bhEne02_MV04_0x191810; // 0x191b04 - g_ps2RecompiledFunctionTable[149205] = bhEne02_MV04_0x191810; // 0x191b5c - g_ps2RecompiledFunctionTable[149260] = bhEne02_MV04_0x191810; // 0x191c38 - g_ps2RecompiledFunctionTable[149269] = bhEne02_MV04_0x191810; // 0x191c5c - g_ps2RecompiledFunctionTable[149282] = bhEne02_MV04_0x191810; // 0x191c90 - g_ps2RecompiledFunctionTable[149313] = bhEne02_MV04_0x191810; // 0x191d0c - g_ps2RecompiledFunctionTable[149322] = bhEne02_MV04_0x191810; // 0x191d30 - g_ps2RecompiledFunctionTable[149335] = bhEne02_MV04_0x191810; // 0x191d64 - g_ps2RecompiledFunctionTable[149378] = bhEne02_MV05_0x191e10; // 0x191e10 - g_ps2RecompiledFunctionTable[149394] = bhEne02_MV05_0x191e10; // 0x191e50 - g_ps2RecompiledFunctionTable[149442] = bhEne02_Nage_0x191f10; // 0x191f10 - g_ps2RecompiledFunctionTable[149446] = bhEne02_Damage_0x191f20; // 0x191f20 - g_ps2RecompiledFunctionTable[149447] = bhEne02_Damage_0x191f20; // 0x191f24 - g_ps2RecompiledFunctionTable[149448] = bhEne02_Damage_0x191f20; // 0x191f28 - g_ps2RecompiledFunctionTable[149449] = bhEne02_Damage_0x191f20; // 0x191f2c - g_ps2RecompiledFunctionTable[149450] = bhEne02_Damage_0x191f20; // 0x191f30 - g_ps2RecompiledFunctionTable[149451] = bhEne02_Damage_0x191f20; // 0x191f34 - g_ps2RecompiledFunctionTable[149452] = bhEne02_Damage_0x191f20; // 0x191f38 - g_ps2RecompiledFunctionTable[149453] = bhEne02_Damage_0x191f20; // 0x191f3c - g_ps2RecompiledFunctionTable[149454] = bhEne02_Damage_0x191f20; // 0x191f40 - g_ps2RecompiledFunctionTable[149455] = bhEne02_Damage_0x191f20; // 0x191f44 - g_ps2RecompiledFunctionTable[149456] = bhEne02_Damage_0x191f20; // 0x191f48 - g_ps2RecompiledFunctionTable[149457] = bhEne02_Damage_0x191f20; // 0x191f4c - g_ps2RecompiledFunctionTable[149458] = bhEne02_Damage_0x191f20; // 0x191f50 - g_ps2RecompiledFunctionTable[149459] = bhEne02_Damage_0x191f20; // 0x191f54 - g_ps2RecompiledFunctionTable[149460] = bhEne02_Damage_0x191f20; // 0x191f58 - g_ps2RecompiledFunctionTable[149461] = bhEne02_Damage_0x191f20; // 0x191f5c - g_ps2RecompiledFunctionTable[149462] = bhEne02_Damage_0x191f20; // 0x191f60 - g_ps2RecompiledFunctionTable[149463] = bhEne02_Damage_0x191f20; // 0x191f64 - g_ps2RecompiledFunctionTable[149464] = bhEne02_Damage_0x191f20; // 0x191f68 - g_ps2RecompiledFunctionTable[149465] = bhEne02_Damage_0x191f20; // 0x191f6c - g_ps2RecompiledFunctionTable[149466] = bhEne02_Damage_0x191f20; // 0x191f70 - g_ps2RecompiledFunctionTable[149467] = bhEne02_Damage_0x191f20; // 0x191f74 - g_ps2RecompiledFunctionTable[149468] = bhEne02_Damage_0x191f20; // 0x191f78 - g_ps2RecompiledFunctionTable[149469] = bhEne02_Damage_0x191f20; // 0x191f7c - g_ps2RecompiledFunctionTable[149470] = bhEne02_Damage_0x191f20; // 0x191f80 - g_ps2RecompiledFunctionTable[149471] = bhEne02_Damage_0x191f20; // 0x191f84 - g_ps2RecompiledFunctionTable[149472] = bhEne02_Damage_0x191f20; // 0x191f88 - g_ps2RecompiledFunctionTable[149473] = bhEne02_Damage_0x191f20; // 0x191f8c - g_ps2RecompiledFunctionTable[149474] = bhEne02_Damage_0x191f20; // 0x191f90 - g_ps2RecompiledFunctionTable[149475] = bhEne02_Damage_0x191f20; // 0x191f94 - g_ps2RecompiledFunctionTable[149476] = bhEne02_Damage_0x191f20; // 0x191f98 - g_ps2RecompiledFunctionTable[149477] = bhEne02_Damage_0x191f20; // 0x191f9c - g_ps2RecompiledFunctionTable[149478] = bhEne02_Damage_0x191f20; // 0x191fa0 - g_ps2RecompiledFunctionTable[149479] = bhEne02_Damage_0x191f20; // 0x191fa4 - g_ps2RecompiledFunctionTable[149480] = bhEne02_Damage_0x191f20; // 0x191fa8 - g_ps2RecompiledFunctionTable[149481] = bhEne02_Damage_0x191f20; // 0x191fac - g_ps2RecompiledFunctionTable[149482] = bhEne02_Damage_0x191f20; // 0x191fb0 - g_ps2RecompiledFunctionTable[149483] = bhEne02_Damage_0x191f20; // 0x191fb4 - g_ps2RecompiledFunctionTable[149484] = bhEne02_Damage_0x191f20; // 0x191fb8 - g_ps2RecompiledFunctionTable[149485] = bhEne02_Damage_0x191f20; // 0x191fbc - g_ps2RecompiledFunctionTable[149486] = bhEne02_Damage_0x191f20; // 0x191fc0 - g_ps2RecompiledFunctionTable[149487] = bhEne02_Damage_0x191f20; // 0x191fc4 - g_ps2RecompiledFunctionTable[149488] = bhEne02_Damage_0x191f20; // 0x191fc8 - g_ps2RecompiledFunctionTable[149489] = bhEne02_Damage_0x191f20; // 0x191fcc - g_ps2RecompiledFunctionTable[149490] = bhEne02_Damage_0x191f20; // 0x191fd0 - g_ps2RecompiledFunctionTable[149491] = bhEne02_Damage_0x191f20; // 0x191fd4 - g_ps2RecompiledFunctionTable[149492] = bhEne02_Damage_0x191f20; // 0x191fd8 - g_ps2RecompiledFunctionTable[149493] = bhEne02_Damage_0x191f20; // 0x191fdc - g_ps2RecompiledFunctionTable[149494] = bhEne02_Damage_0x191f20; // 0x191fe0 - g_ps2RecompiledFunctionTable[149495] = bhEne02_Damage_0x191f20; // 0x191fe4 - g_ps2RecompiledFunctionTable[149496] = bhEne02_Damage_0x191f20; // 0x191fe8 - g_ps2RecompiledFunctionTable[149497] = bhEne02_Damage_0x191f20; // 0x191fec - g_ps2RecompiledFunctionTable[149498] = bhEne02_Damage_0x191f20; // 0x191ff0 - g_ps2RecompiledFunctionTable[149499] = bhEne02_Damage_0x191f20; // 0x191ff4 - g_ps2RecompiledFunctionTable[149500] = bhEne02_Damage_0x191f20; // 0x191ff8 - g_ps2RecompiledFunctionTable[149501] = bhEne02_Damage_0x191f20; // 0x191ffc - g_ps2RecompiledFunctionTable[149502] = bhEne02_Damage_0x191f20; // 0x192000 - g_ps2RecompiledFunctionTable[149503] = bhEne02_Damage_0x191f20; // 0x192004 - g_ps2RecompiledFunctionTable[149504] = bhEne02_Damage_0x191f20; // 0x192008 - g_ps2RecompiledFunctionTable[149505] = bhEne02_Damage_0x191f20; // 0x19200c - g_ps2RecompiledFunctionTable[149506] = bhEne02_Damage_0x191f20; // 0x192010 - g_ps2RecompiledFunctionTable[149507] = bhEne02_Damage_0x191f20; // 0x192014 - g_ps2RecompiledFunctionTable[149508] = bhEne02_Damage_0x191f20; // 0x192018 - g_ps2RecompiledFunctionTable[149509] = bhEne02_Damage_0x191f20; // 0x19201c - g_ps2RecompiledFunctionTable[149510] = bhEne02_Damage_0x191f20; // 0x192020 - g_ps2RecompiledFunctionTable[149511] = bhEne02_Damage_0x191f20; // 0x192024 - g_ps2RecompiledFunctionTable[149512] = bhEne02_Damage_0x191f20; // 0x192028 - g_ps2RecompiledFunctionTable[149513] = bhEne02_Damage_0x191f20; // 0x19202c - g_ps2RecompiledFunctionTable[149514] = bhEne02_Damage_0x191f20; // 0x192030 - g_ps2RecompiledFunctionTable[149515] = bhEne02_Damage_0x191f20; // 0x192034 - g_ps2RecompiledFunctionTable[149516] = bhEne02_Damage_0x191f20; // 0x192038 - g_ps2RecompiledFunctionTable[149517] = bhEne02_Damage_0x191f20; // 0x19203c - g_ps2RecompiledFunctionTable[149518] = bhEne02_Damage_0x191f20; // 0x192040 - g_ps2RecompiledFunctionTable[149519] = bhEne02_Damage_0x191f20; // 0x192044 - g_ps2RecompiledFunctionTable[149520] = bhEne02_Damage_0x191f20; // 0x192048 - g_ps2RecompiledFunctionTable[149521] = bhEne02_Damage_0x191f20; // 0x19204c - g_ps2RecompiledFunctionTable[149522] = bhEne02_Damage_0x191f20; // 0x192050 - g_ps2RecompiledFunctionTable[149523] = bhEne02_Damage_0x191f20; // 0x192054 - g_ps2RecompiledFunctionTable[149524] = bhEne02_Damage_0x191f20; // 0x192058 - g_ps2RecompiledFunctionTable[149525] = bhEne02_Damage_0x191f20; // 0x19205c - g_ps2RecompiledFunctionTable[149526] = bhEne02_Damage_0x191f20; // 0x192060 - g_ps2RecompiledFunctionTable[149527] = bhEne02_Damage_0x191f20; // 0x192064 - g_ps2RecompiledFunctionTable[149528] = bhEne02_Damage_0x191f20; // 0x192068 - g_ps2RecompiledFunctionTable[149530] = bhEne02_DG00_0x192070; // 0x192070 - g_ps2RecompiledFunctionTable[149534] = bhEne02_DG01_0x192080; // 0x192080 - g_ps2RecompiledFunctionTable[149586] = bhEne02_Die_0x192150; // 0x192150 - g_ps2RecompiledFunctionTable[149587] = bhEne02_Die_0x192150; // 0x192154 - g_ps2RecompiledFunctionTable[149588] = bhEne02_Die_0x192150; // 0x192158 - g_ps2RecompiledFunctionTable[149589] = bhEne02_Die_0x192150; // 0x19215c - g_ps2RecompiledFunctionTable[149590] = bhEne02_Die_0x192150; // 0x192160 - g_ps2RecompiledFunctionTable[149591] = bhEne02_Die_0x192150; // 0x192164 - g_ps2RecompiledFunctionTable[149592] = bhEne02_Die_0x192150; // 0x192168 - g_ps2RecompiledFunctionTable[149593] = bhEne02_Die_0x192150; // 0x19216c - g_ps2RecompiledFunctionTable[149594] = bhEne02_DD00_0x192170; // 0x192170 - g_ps2RecompiledFunctionTable[149665] = bhEne02_DD00_0x192170; // 0x19228c - g_ps2RecompiledFunctionTable[149675] = bhEne02_DD00_0x192170; // 0x1922b4 - g_ps2RecompiledFunctionTable[149685] = bhEne02_DD00_0x192170; // 0x1922dc - g_ps2RecompiledFunctionTable[149696] = bhEne02_DD00_0x192170; // 0x192308 - g_ps2RecompiledFunctionTable[149719] = bhEne02_DD00_0x192170; // 0x192364 - g_ps2RecompiledFunctionTable[149726] = bhEne02_DD00_0x192170; // 0x192380 - g_ps2RecompiledFunctionTable[149728] = bhEne02_DD00_0x192170; // 0x192388 - g_ps2RecompiledFunctionTable[149732] = bhEne02_DD00_0x192170; // 0x192398 - g_ps2RecompiledFunctionTable[149736] = bhEne02_DD00_0x192170; // 0x1923a8 - g_ps2RecompiledFunctionTable[149852] = bhEne02_DD00_0x192170; // 0x192578 - g_ps2RecompiledFunctionTable[149855] = bhEne02_DD00_0x192170; // 0x192584 - g_ps2RecompiledFunctionTable[149859] = bhEne02_DD00_0x192170; // 0x192594 - g_ps2RecompiledFunctionTable[149868] = bhEne02_DD00_0x192170; // 0x1925b8 - g_ps2RecompiledFunctionTable[149878] = bhEne02_DD00_0x192170; // 0x1925e0 - g_ps2RecompiledFunctionTable[149935] = bhEne02_DD00_0x192170; // 0x1926c4 - g_ps2RecompiledFunctionTable[149948] = bhEne02_DD00_0x192170; // 0x1926f8 - g_ps2RecompiledFunctionTable[149960] = bhEne02_DD00_0x192170; // 0x192728 - g_ps2RecompiledFunctionTable[150007] = bhEne02_DD00_0x192170; // 0x1927e4 - g_ps2RecompiledFunctionTable[150013] = bhEne02_DD00_0x192170; // 0x1927fc - g_ps2RecompiledFunctionTable[150051] = bhEne02_DD00_0x192170; // 0x192894 - g_ps2RecompiledFunctionTable[150062] = bhEne02_DD00_0x192170; // 0x1928c0 - g_ps2RecompiledFunctionTable[150090] = bhEne02_DD00_0x192170; // 0x192930 - g_ps2RecompiledFunctionTable[150103] = bhEne02_DD00_0x192170; // 0x192964 - g_ps2RecompiledFunctionTable[150115] = bhEne02_DD00_0x192170; // 0x192994 - g_ps2RecompiledFunctionTable[150262] = bhEne02_DD01_0x192be0; // 0x192be0 - g_ps2RecompiledFunctionTable[150342] = bhEne02_SetSandEffect_0x192d20; // 0x192d20 - g_ps2RecompiledFunctionTable[150350] = bhEne02_SetSandEffectEV_0x192d40; // 0x192d40 - g_ps2RecompiledFunctionTable[150362] = bhEne02_SetSandEffectMain_0x192d70; // 0x192d70 - g_ps2RecompiledFunctionTable[150363] = bhEne02_SetSandEffectMain_0x192d70; // 0x192d74 - g_ps2RecompiledFunctionTable[150364] = bhEne02_SetSandEffectMain_0x192d70; // 0x192d78 - g_ps2RecompiledFunctionTable[150365] = bhEne02_SetSandEffectMain_0x192d70; // 0x192d7c - g_ps2RecompiledFunctionTable[150366] = bhEne02_SetSandEffectMain_0x192d70; // 0x192d80 - g_ps2RecompiledFunctionTable[150367] = bhEne02_SetSandEffectMain_0x192d70; // 0x192d84 - g_ps2RecompiledFunctionTable[150368] = bhEne02_SetSandEffectMain_0x192d70; // 0x192d88 - g_ps2RecompiledFunctionTable[150369] = bhEne02_SetSandEffectMain_0x192d70; // 0x192d8c - g_ps2RecompiledFunctionTable[150370] = bhEne02_SetSandEffectMain_0x192d70; // 0x192d90 - g_ps2RecompiledFunctionTable[150371] = bhEne02_SetSandEffectMain_0x192d70; // 0x192d94 - g_ps2RecompiledFunctionTable[150372] = bhEne02_SetSandEffectMain_0x192d70; // 0x192d98 - g_ps2RecompiledFunctionTable[150373] = bhEne02_SetSandEffectMain_0x192d70; // 0x192d9c - g_ps2RecompiledFunctionTable[150374] = bhEne02_SetSandEffectMain_0x192d70; // 0x192da0 - g_ps2RecompiledFunctionTable[150375] = bhEne02_SetSandEffectMain_0x192d70; // 0x192da4 - g_ps2RecompiledFunctionTable[150376] = bhEne02_SetSandEffectMain_0x192d70; // 0x192da8 - g_ps2RecompiledFunctionTable[150377] = bhEne02_SetSandEffectMain_0x192d70; // 0x192dac - g_ps2RecompiledFunctionTable[150378] = bhEne02_SetSandEffectMain_0x192d70; // 0x192db0 - g_ps2RecompiledFunctionTable[150379] = bhEne02_SetSandEffectMain_0x192d70; // 0x192db4 - g_ps2RecompiledFunctionTable[150380] = bhEne02_SetSandEffectMain_0x192d70; // 0x192db8 - g_ps2RecompiledFunctionTable[150381] = bhEne02_SetSandEffectMain_0x192d70; // 0x192dbc - g_ps2RecompiledFunctionTable[150382] = bhEne02_SetSandEffectMain_0x192d70; // 0x192dc0 - g_ps2RecompiledFunctionTable[150383] = bhEne02_SetSandEffectMain_0x192d70; // 0x192dc4 - g_ps2RecompiledFunctionTable[150384] = bhEne02_SetSandEffectMain_0x192d70; // 0x192dc8 - g_ps2RecompiledFunctionTable[150385] = bhEne02_SetSandEffectMain_0x192d70; // 0x192dcc - g_ps2RecompiledFunctionTable[150386] = bhEne02_SetSandEffectMain_0x192d70; // 0x192dd0 - g_ps2RecompiledFunctionTable[150387] = bhEne02_SetSandEffectMain_0x192d70; // 0x192dd4 - g_ps2RecompiledFunctionTable[150388] = bhEne02_SetSandEffectMain_0x192d70; // 0x192dd8 - g_ps2RecompiledFunctionTable[150389] = bhEne02_SetSandEffectMain_0x192d70; // 0x192ddc - g_ps2RecompiledFunctionTable[150390] = bhEne02_SetSandEffectMain_0x192d70; // 0x192de0 - g_ps2RecompiledFunctionTable[150391] = bhEne02_SetSandEffectMain_0x192d70; // 0x192de4 - g_ps2RecompiledFunctionTable[150392] = bhEne02_SetSandEffectMain_0x192d70; // 0x192de8 - g_ps2RecompiledFunctionTable[150393] = bhEne02_SetSandEffectMain_0x192d70; // 0x192dec - g_ps2RecompiledFunctionTable[150394] = bhEne02_SetSandEffectMain_0x192d70; // 0x192df0 - g_ps2RecompiledFunctionTable[150395] = bhEne02_SetSandEffectMain_0x192d70; // 0x192df4 - g_ps2RecompiledFunctionTable[150396] = bhEne02_SetSandEffectMain_0x192d70; // 0x192df8 - g_ps2RecompiledFunctionTable[150397] = bhEne02_SetSandEffectMain_0x192d70; // 0x192dfc - g_ps2RecompiledFunctionTable[150398] = bhEne02_SetSandEffectMain_0x192d70; // 0x192e00 - g_ps2RecompiledFunctionTable[150399] = bhEne02_SetSandEffectMain_0x192d70; // 0x192e04 - g_ps2RecompiledFunctionTable[150400] = bhEne02_SetSandEffectMain_0x192d70; // 0x192e08 - g_ps2RecompiledFunctionTable[150401] = bhEne02_SetSandEffectMain_0x192d70; // 0x192e0c - g_ps2RecompiledFunctionTable[150402] = bhEne02_SetSandEffectMain_0x192d70; // 0x192e10 - g_ps2RecompiledFunctionTable[150403] = bhEne02_SetSandEffectMain_0x192d70; // 0x192e14 - g_ps2RecompiledFunctionTable[150404] = bhEne02_SetSandEffectMain_0x192d70; // 0x192e18 - g_ps2RecompiledFunctionTable[150405] = bhEne02_SetSandEffectMain_0x192d70; // 0x192e1c - g_ps2RecompiledFunctionTable[150406] = bhEne02_SetSandEffectMain_0x192d70; // 0x192e20 - g_ps2RecompiledFunctionTable[150407] = bhEne02_SetSandEffectMain_0x192d70; // 0x192e24 - g_ps2RecompiledFunctionTable[150408] = bhEne02_SetSandEffectMain_0x192d70; // 0x192e28 - g_ps2RecompiledFunctionTable[150409] = bhEne02_SetSandEffectMain_0x192d70; // 0x192e2c - g_ps2RecompiledFunctionTable[150410] = bhEne02_SetSandEffectMain_0x192d70; // 0x192e30 - g_ps2RecompiledFunctionTable[150411] = bhEne02_SetSandEffectMain_0x192d70; // 0x192e34 - g_ps2RecompiledFunctionTable[150412] = bhEne02_SetSandEffectMain_0x192d70; // 0x192e38 - g_ps2RecompiledFunctionTable[150413] = bhEne02_SetSandEffectMain_0x192d70; // 0x192e3c - g_ps2RecompiledFunctionTable[150414] = bhEne02_SetSandEffectMain_0x192d70; // 0x192e40 - g_ps2RecompiledFunctionTable[150415] = bhEne02_SetSandEffectMain_0x192d70; // 0x192e44 - g_ps2RecompiledFunctionTable[150416] = bhEne02_SetSandEffectMain_0x192d70; // 0x192e48 - g_ps2RecompiledFunctionTable[150417] = bhEne02_SetSandEffectMain_0x192d70; // 0x192e4c - g_ps2RecompiledFunctionTable[150418] = bhEne02_SetSandEffectMain_0x192d70; // 0x192e50 - g_ps2RecompiledFunctionTable[150419] = bhEne02_SetSandEffectMain_0x192d70; // 0x192e54 - g_ps2RecompiledFunctionTable[150420] = bhEne02_SetSandEffectMain_0x192d70; // 0x192e58 - g_ps2RecompiledFunctionTable[150421] = bhEne02_SetSandEffectMain_0x192d70; // 0x192e5c - g_ps2RecompiledFunctionTable[150422] = bhEne02_SetSandEffectMain_0x192d70; // 0x192e60 - g_ps2RecompiledFunctionTable[150423] = bhEne02_SetSandEffectMain_0x192d70; // 0x192e64 - g_ps2RecompiledFunctionTable[150424] = bhEne02_SetSandEffectMain_0x192d70; // 0x192e68 - g_ps2RecompiledFunctionTable[150425] = bhEne02_SetSandEffectMain_0x192d70; // 0x192e6c - g_ps2RecompiledFunctionTable[150426] = bhEne02_SetSandEffectMain_0x192d70; // 0x192e70 - g_ps2RecompiledFunctionTable[150427] = bhEne02_SetSandEffectMain_0x192d70; // 0x192e74 - g_ps2RecompiledFunctionTable[150428] = bhEne02_SetSandEffectMain_0x192d70; // 0x192e78 - g_ps2RecompiledFunctionTable[150429] = bhEne02_SetSandEffectMain_0x192d70; // 0x192e7c - g_ps2RecompiledFunctionTable[150430] = bhEne02_SetSandEffectMain_0x192d70; // 0x192e80 - g_ps2RecompiledFunctionTable[150431] = bhEne02_SetSandEffectMain_0x192d70; // 0x192e84 - g_ps2RecompiledFunctionTable[150432] = bhEne02_SetSandEffectMain_0x192d70; // 0x192e88 - g_ps2RecompiledFunctionTable[150433] = bhEne02_SetSandEffectMain_0x192d70; // 0x192e8c - g_ps2RecompiledFunctionTable[150434] = bhEne02_SetSandEffectMain_0x192d70; // 0x192e90 - g_ps2RecompiledFunctionTable[150435] = bhEne02_SetSandEffectMain_0x192d70; // 0x192e94 - g_ps2RecompiledFunctionTable[150436] = bhEne02_SetSandEffectMain_0x192d70; // 0x192e98 - g_ps2RecompiledFunctionTable[150437] = bhEne02_SetSandEffectMain_0x192d70; // 0x192e9c - g_ps2RecompiledFunctionTable[150438] = bhEne02_SetSandEffectMain_0x192d70; // 0x192ea0 - g_ps2RecompiledFunctionTable[150439] = bhEne02_SetSandEffectMain_0x192d70; // 0x192ea4 - g_ps2RecompiledFunctionTable[150440] = bhEne02_SetSandEffectMain_0x192d70; // 0x192ea8 - g_ps2RecompiledFunctionTable[150441] = bhEne02_SetSandEffectMain_0x192d70; // 0x192eac - g_ps2RecompiledFunctionTable[150442] = bhEne02_SetSandEffectMain_0x192d70; // 0x192eb0 - g_ps2RecompiledFunctionTable[150443] = bhEne02_SetSandEffectMain_0x192d70; // 0x192eb4 - g_ps2RecompiledFunctionTable[150444] = bhEne02_SetSandEffectMain_0x192d70; // 0x192eb8 - g_ps2RecompiledFunctionTable[150445] = bhEne02_SetSandEffectMain_0x192d70; // 0x192ebc - g_ps2RecompiledFunctionTable[150446] = bhEne02_SetSandEffectMain_0x192d70; // 0x192ec0 - g_ps2RecompiledFunctionTable[150447] = bhEne02_SetSandEffectMain_0x192d70; // 0x192ec4 - g_ps2RecompiledFunctionTable[150448] = bhEne02_SetSandEffectMain_0x192d70; // 0x192ec8 - g_ps2RecompiledFunctionTable[150449] = bhEne02_SetSandEffectMain_0x192d70; // 0x192ecc - g_ps2RecompiledFunctionTable[150450] = bhEne02_SetSandEffectMain_0x192d70; // 0x192ed0 - g_ps2RecompiledFunctionTable[150451] = bhEne02_SetSandEffectMain_0x192d70; // 0x192ed4 - g_ps2RecompiledFunctionTable[150452] = bhEne02_SetSandEffectMain_0x192d70; // 0x192ed8 - g_ps2RecompiledFunctionTable[150453] = bhEne02_SetSandEffectMain_0x192d70; // 0x192edc - g_ps2RecompiledFunctionTable[150454] = bhEne02_SetSandEffectMain_0x192d70; // 0x192ee0 - g_ps2RecompiledFunctionTable[150455] = bhEne02_SetSandEffectMain_0x192d70; // 0x192ee4 - g_ps2RecompiledFunctionTable[150456] = bhEne02_SetSandEffectMain_0x192d70; // 0x192ee8 - g_ps2RecompiledFunctionTable[150457] = bhEne02_SetSandEffectMain_0x192d70; // 0x192eec - g_ps2RecompiledFunctionTable[150458] = bhEne02_SetSandEffectMain_0x192d70; // 0x192ef0 - g_ps2RecompiledFunctionTable[150459] = bhEne02_SetSandEffectMain_0x192d70; // 0x192ef4 - g_ps2RecompiledFunctionTable[150460] = bhEne02_SetSandEffectMain_0x192d70; // 0x192ef8 - g_ps2RecompiledFunctionTable[150461] = bhEne02_SetSandEffectMain_0x192d70; // 0x192efc - g_ps2RecompiledFunctionTable[150462] = bhEne02_SetSandEffectMain_0x192d70; // 0x192f00 - g_ps2RecompiledFunctionTable[150463] = bhEne02_SetSandEffectMain_0x192d70; // 0x192f04 - g_ps2RecompiledFunctionTable[150464] = bhEne02_SetSandEffectMain_0x192d70; // 0x192f08 - g_ps2RecompiledFunctionTable[150465] = bhEne02_SetSandEffectMain_0x192d70; // 0x192f0c - g_ps2RecompiledFunctionTable[150466] = bhEne02_SetSandEffectMain_0x192d70; // 0x192f10 - g_ps2RecompiledFunctionTable[150467] = bhEne02_SetSandEffectMain_0x192d70; // 0x192f14 - g_ps2RecompiledFunctionTable[150468] = bhEne02_SetSandEffectMain_0x192d70; // 0x192f18 - g_ps2RecompiledFunctionTable[150469] = bhEne02_SetSandEffectMain_0x192d70; // 0x192f1c - g_ps2RecompiledFunctionTable[150470] = bhEne02_SetSandEffectMain_0x192d70; // 0x192f20 - g_ps2RecompiledFunctionTable[150471] = bhEne02_SetSandEffectMain_0x192d70; // 0x192f24 - g_ps2RecompiledFunctionTable[150472] = bhEne02_SetSandEffectMain_0x192d70; // 0x192f28 - g_ps2RecompiledFunctionTable[150473] = bhEne02_SetSandEffectMain_0x192d70; // 0x192f2c - g_ps2RecompiledFunctionTable[150474] = bhEne02_SetSandEffectMain_0x192d70; // 0x192f30 - g_ps2RecompiledFunctionTable[150475] = bhEne02_SetSandEffectMain_0x192d70; // 0x192f34 - g_ps2RecompiledFunctionTable[150476] = bhEne02_SetSandEffectMain_0x192d70; // 0x192f38 - g_ps2RecompiledFunctionTable[150477] = bhEne02_SetSandEffectMain_0x192d70; // 0x192f3c - g_ps2RecompiledFunctionTable[150478] = bhEne02_SetSandEffectMain_0x192d70; // 0x192f40 - g_ps2RecompiledFunctionTable[150479] = bhEne02_SetSandEffectMain_0x192d70; // 0x192f44 - g_ps2RecompiledFunctionTable[150480] = bhEne02_SetSandEffectMain_0x192d70; // 0x192f48 - g_ps2RecompiledFunctionTable[150481] = bhEne02_SetSandEffectMain_0x192d70; // 0x192f4c - g_ps2RecompiledFunctionTable[150482] = bhEne02_SetSandEffectMain_0x192d70; // 0x192f50 - g_ps2RecompiledFunctionTable[150483] = bhEne02_SetSandEffectMain_0x192d70; // 0x192f54 - g_ps2RecompiledFunctionTable[150484] = bhEne02_SetSandEffectMain_0x192d70; // 0x192f58 - g_ps2RecompiledFunctionTable[150485] = bhEne02_SetSandEffectMain_0x192d70; // 0x192f5c - g_ps2RecompiledFunctionTable[150486] = bhEne02_SetSandEffectMain_0x192d70; // 0x192f60 - g_ps2RecompiledFunctionTable[150487] = bhEne02_SetSandEffectMain_0x192d70; // 0x192f64 - g_ps2RecompiledFunctionTable[150488] = bhEne02_SetSandEffectMain_0x192d70; // 0x192f68 - g_ps2RecompiledFunctionTable[150489] = bhEne02_SetSandEffectMain_0x192d70; // 0x192f6c - g_ps2RecompiledFunctionTable[150490] = bhEne02_SetSandEffectMain_0x192d70; // 0x192f70 - g_ps2RecompiledFunctionTable[150491] = bhEne02_SetSandEffectMain_0x192d70; // 0x192f74 - g_ps2RecompiledFunctionTable[150492] = bhEne02_SetSandEffectMain_0x192d70; // 0x192f78 - g_ps2RecompiledFunctionTable[150493] = bhEne02_SetSandEffectMain_0x192d70; // 0x192f7c - g_ps2RecompiledFunctionTable[150494] = bhEne02_SetSandEffectMain_0x192d70; // 0x192f80 - g_ps2RecompiledFunctionTable[150495] = bhEne02_SetSandEffectMain_0x192d70; // 0x192f84 - g_ps2RecompiledFunctionTable[150496] = bhEne02_SetSandEffectMain_0x192d70; // 0x192f88 - g_ps2RecompiledFunctionTable[150497] = bhEne02_SetSandEffectMain_0x192d70; // 0x192f8c - g_ps2RecompiledFunctionTable[150498] = bhEne02_SetSandEffectMain_0x192d70; // 0x192f90 - g_ps2RecompiledFunctionTable[150499] = bhEne02_SetSandEffectMain_0x192d70; // 0x192f94 - g_ps2RecompiledFunctionTable[150500] = bhEne02_SetSandEffectMain_0x192d70; // 0x192f98 - g_ps2RecompiledFunctionTable[150501] = bhEne02_SetSandEffectMain_0x192d70; // 0x192f9c - g_ps2RecompiledFunctionTable[150502] = bhEne02_SetSandEffectMain_0x192d70; // 0x192fa0 - g_ps2RecompiledFunctionTable[150503] = bhEne02_SetSandEffectMain_0x192d70; // 0x192fa4 - g_ps2RecompiledFunctionTable[150504] = bhEne02_SetSandEffectMain_0x192d70; // 0x192fa8 - g_ps2RecompiledFunctionTable[150505] = bhEne02_SetSandEffectMain_0x192d70; // 0x192fac - g_ps2RecompiledFunctionTable[150506] = bhEne02_SetSandEffectMain_0x192d70; // 0x192fb0 - g_ps2RecompiledFunctionTable[150507] = bhEne02_SetSandEffectMain_0x192d70; // 0x192fb4 - g_ps2RecompiledFunctionTable[150508] = bhEne02_SetSandEffectMain_0x192d70; // 0x192fb8 - g_ps2RecompiledFunctionTable[150509] = bhEne02_SetSandEffectMain_0x192d70; // 0x192fbc - g_ps2RecompiledFunctionTable[150510] = bhEne02_SetSandEffectMain_0x192d70; // 0x192fc0 - g_ps2RecompiledFunctionTable[150511] = bhEne02_SetSandEffectMain_0x192d70; // 0x192fc4 - g_ps2RecompiledFunctionTable[150512] = bhEne02_SetSandEffectMain_0x192d70; // 0x192fc8 - g_ps2RecompiledFunctionTable[150513] = bhEne02_SetSandEffectMain_0x192d70; // 0x192fcc - g_ps2RecompiledFunctionTable[150514] = bhEne02_SetSandEffectMain_0x192d70; // 0x192fd0 - g_ps2RecompiledFunctionTable[150515] = bhEne02_SetSandEffectMain_0x192d70; // 0x192fd4 - g_ps2RecompiledFunctionTable[150516] = bhEne02_SetSandEffectMain_0x192d70; // 0x192fd8 - g_ps2RecompiledFunctionTable[150517] = bhEne02_SetSandEffectMain_0x192d70; // 0x192fdc - g_ps2RecompiledFunctionTable[150518] = bhEne02_SetSandEffectMain_0x192d70; // 0x192fe0 - g_ps2RecompiledFunctionTable[150519] = bhEne02_SetSandEffectMain_0x192d70; // 0x192fe4 - g_ps2RecompiledFunctionTable[150520] = bhEne02_SetSandEffectMain_0x192d70; // 0x192fe8 - g_ps2RecompiledFunctionTable[150521] = bhEne02_SetSandEffectMain_0x192d70; // 0x192fec - g_ps2RecompiledFunctionTable[150522] = bhEne02_SetSandEffectMain_0x192d70; // 0x192ff0 - g_ps2RecompiledFunctionTable[150523] = bhEne02_SetSandEffectMain_0x192d70; // 0x192ff4 - g_ps2RecompiledFunctionTable[150524] = bhEne02_SetSandEffectMain_0x192d70; // 0x192ff8 - g_ps2RecompiledFunctionTable[150525] = bhEne02_SetSandEffectMain_0x192d70; // 0x192ffc - g_ps2RecompiledFunctionTable[150526] = bhEne02_SetSandEffectMain_0x192d70; // 0x193000 - g_ps2RecompiledFunctionTable[150527] = bhEne02_SetSandEffectMain_0x192d70; // 0x193004 - g_ps2RecompiledFunctionTable[150528] = bhEne02_SetSandEffectMain_0x192d70; // 0x193008 - g_ps2RecompiledFunctionTable[150529] = bhEne02_SetSandEffectMain_0x192d70; // 0x19300c - g_ps2RecompiledFunctionTable[150530] = bhEne02_SetSandEffectMain_0x192d70; // 0x193010 - g_ps2RecompiledFunctionTable[150531] = bhEne02_SetSandEffectMain_0x192d70; // 0x193014 - g_ps2RecompiledFunctionTable[150532] = bhEne02_SetSandEffectMain_0x192d70; // 0x193018 - g_ps2RecompiledFunctionTable[150533] = bhEne02_SetSandEffectMain_0x192d70; // 0x19301c - g_ps2RecompiledFunctionTable[150534] = bhEne02_SetSandEffectMain_0x192d70; // 0x193020 - g_ps2RecompiledFunctionTable[150535] = bhEne02_SetSandEffectMain_0x192d70; // 0x193024 - g_ps2RecompiledFunctionTable[150536] = bhEne02_SetSandEffectMain_0x192d70; // 0x193028 - g_ps2RecompiledFunctionTable[150537] = bhEne02_SetSandEffectMain_0x192d70; // 0x19302c - g_ps2RecompiledFunctionTable[150538] = bhEne02_SetSandEffectMain_0x192d70; // 0x193030 - g_ps2RecompiledFunctionTable[150539] = bhEne02_SetSandEffectMain_0x192d70; // 0x193034 - g_ps2RecompiledFunctionTable[150540] = bhEne02_SetSandEffectMain_0x192d70; // 0x193038 - g_ps2RecompiledFunctionTable[150541] = bhEne02_SetSandEffectMain_0x192d70; // 0x19303c - g_ps2RecompiledFunctionTable[150542] = bhEne02_SetSandEffectMain_0x192d70; // 0x193040 - g_ps2RecompiledFunctionTable[150543] = bhEne02_SetSandEffectMain_0x192d70; // 0x193044 - g_ps2RecompiledFunctionTable[150544] = bhEne02_SetSandEffectMain_0x192d70; // 0x193048 - g_ps2RecompiledFunctionTable[150545] = bhEne02_SetSandEffectMain_0x192d70; // 0x19304c - g_ps2RecompiledFunctionTable[150546] = bhEne02_SetSandEffectMain_0x192d70; // 0x193050 - g_ps2RecompiledFunctionTable[150547] = bhEne02_SetSandEffectMain_0x192d70; // 0x193054 - g_ps2RecompiledFunctionTable[150548] = bhEne02_SetSandEffectMain_0x192d70; // 0x193058 - g_ps2RecompiledFunctionTable[150549] = bhEne02_SetSandEffectMain_0x192d70; // 0x19305c - g_ps2RecompiledFunctionTable[150550] = bhEne02_SetSandEffectMain_0x192d70; // 0x193060 - g_ps2RecompiledFunctionTable[150551] = bhEne02_SetSandEffectMain_0x192d70; // 0x193064 - g_ps2RecompiledFunctionTable[150552] = bhEne02_SetSandEffectMain_0x192d70; // 0x193068 - g_ps2RecompiledFunctionTable[150553] = bhEne02_SetSandEffectMain_0x192d70; // 0x19306c - g_ps2RecompiledFunctionTable[150554] = bhEne02_SetSandEffectMain_0x192d70; // 0x193070 - g_ps2RecompiledFunctionTable[150555] = bhEne02_SetSandEffectMain_0x192d70; // 0x193074 - g_ps2RecompiledFunctionTable[150556] = bhEne02_SetSandEffectMain_0x192d70; // 0x193078 - g_ps2RecompiledFunctionTable[150557] = bhEne02_SetSandEffectMain_0x192d70; // 0x19307c - g_ps2RecompiledFunctionTable[150558] = bhEne02_SetSandEffectMain_0x192d70; // 0x193080 - g_ps2RecompiledFunctionTable[150559] = bhEne02_SetSandEffectMain_0x192d70; // 0x193084 - g_ps2RecompiledFunctionTable[150560] = bhEne02_SetSandEffectMain_0x192d70; // 0x193088 - g_ps2RecompiledFunctionTable[150561] = bhEne02_SetSandEffectMain_0x192d70; // 0x19308c - g_ps2RecompiledFunctionTable[150562] = bhEne02_SetSandEffectMain_0x192d70; // 0x193090 - g_ps2RecompiledFunctionTable[150563] = bhEne02_SetSandEffectMain_0x192d70; // 0x193094 - g_ps2RecompiledFunctionTable[150564] = bhEne02_SetSandEffectMain_0x192d70; // 0x193098 - g_ps2RecompiledFunctionTable[150565] = bhEne02_SetSandEffectMain_0x192d70; // 0x19309c - g_ps2RecompiledFunctionTable[150566] = bhEne02_SetSandEffectMain_0x192d70; // 0x1930a0 - g_ps2RecompiledFunctionTable[150567] = bhEne02_SetSandEffectMain_0x192d70; // 0x1930a4 - g_ps2RecompiledFunctionTable[150568] = bhEne02_SetSandEffectMain_0x192d70; // 0x1930a8 - g_ps2RecompiledFunctionTable[150569] = bhEne02_SetSandEffectMain_0x192d70; // 0x1930ac - g_ps2RecompiledFunctionTable[150570] = bhEne02_SetSandEffectMain_0x192d70; // 0x1930b0 - g_ps2RecompiledFunctionTable[150571] = bhEne02_SetSandEffectMain_0x192d70; // 0x1930b4 - g_ps2RecompiledFunctionTable[150572] = bhEne02_SetSandEffectMain_0x192d70; // 0x1930b8 - g_ps2RecompiledFunctionTable[150573] = bhEne02_SetSandEffectMain_0x192d70; // 0x1930bc - g_ps2RecompiledFunctionTable[150574] = bhEne02_SetSandEffectMain_0x192d70; // 0x1930c0 - g_ps2RecompiledFunctionTable[150575] = bhEne02_SetSandEffectMain_0x192d70; // 0x1930c4 - g_ps2RecompiledFunctionTable[150576] = bhEne02_SetSandEffectMain_0x192d70; // 0x1930c8 - g_ps2RecompiledFunctionTable[150577] = bhEne02_SetSandEffectMain_0x192d70; // 0x1930cc - g_ps2RecompiledFunctionTable[150578] = bhEne02_SetSandEffectMain_0x192d70; // 0x1930d0 - g_ps2RecompiledFunctionTable[150579] = bhEne02_SetSandEffectMain_0x192d70; // 0x1930d4 - g_ps2RecompiledFunctionTable[150580] = bhEne02_SetSandEffectMain_0x192d70; // 0x1930d8 - g_ps2RecompiledFunctionTable[150581] = bhEne02_SetSandEffectMain_0x192d70; // 0x1930dc - g_ps2RecompiledFunctionTable[150582] = bhEne02_SetSandEffectMain_0x192d70; // 0x1930e0 - g_ps2RecompiledFunctionTable[150583] = bhEne02_SetSandEffectMain_0x192d70; // 0x1930e4 - g_ps2RecompiledFunctionTable[150584] = bhEne02_SetSandEffectMain_0x192d70; // 0x1930e8 - g_ps2RecompiledFunctionTable[150585] = bhEne02_SetSandEffectMain_0x192d70; // 0x1930ec - g_ps2RecompiledFunctionTable[150586] = bhEne02_SetSandEffectMain_0x192d70; // 0x1930f0 - g_ps2RecompiledFunctionTable[150587] = bhEne02_SetSandEffectMain_0x192d70; // 0x1930f4 - g_ps2RecompiledFunctionTable[150588] = bhEne02_SetSandEffectMain_0x192d70; // 0x1930f8 - g_ps2RecompiledFunctionTable[150589] = bhEne02_SetSandEffectMain_0x192d70; // 0x1930fc - g_ps2RecompiledFunctionTable[150590] = bhEne02_SetSandEffectMain_0x192d70; // 0x193100 - g_ps2RecompiledFunctionTable[150591] = bhEne02_SetSandEffectMain_0x192d70; // 0x193104 - g_ps2RecompiledFunctionTable[150592] = bhEne02_SetSandEffectMain_0x192d70; // 0x193108 - g_ps2RecompiledFunctionTable[150593] = bhEne02_SetSandEffectMain_0x192d70; // 0x19310c - g_ps2RecompiledFunctionTable[150594] = bhEne02_SetSandEffectMain_0x192d70; // 0x193110 - g_ps2RecompiledFunctionTable[150595] = bhEne02_SetSandEffectMain_0x192d70; // 0x193114 - g_ps2RecompiledFunctionTable[150596] = bhEne02_SetSandEffectMain_0x192d70; // 0x193118 - g_ps2RecompiledFunctionTable[150597] = bhEne02_SetSandEffectMain_0x192d70; // 0x19311c - g_ps2RecompiledFunctionTable[150598] = bhEne02_SetSandEffectMain_0x192d70; // 0x193120 - g_ps2RecompiledFunctionTable[150599] = bhEne02_SetSandEffectMain_0x192d70; // 0x193124 - g_ps2RecompiledFunctionTable[150600] = bhEne02_SetSandEffectMain_0x192d70; // 0x193128 - g_ps2RecompiledFunctionTable[150601] = bhEne02_SetSandEffectMain_0x192d70; // 0x19312c - g_ps2RecompiledFunctionTable[150602] = bhEne02_SetSandEffectMain_0x192d70; // 0x193130 - g_ps2RecompiledFunctionTable[150603] = bhEne02_SetSandEffectMain_0x192d70; // 0x193134 - g_ps2RecompiledFunctionTable[150604] = bhEne02_SetSandEffectMain_0x192d70; // 0x193138 - g_ps2RecompiledFunctionTable[150605] = bhEne02_SetSandEffectMain_0x192d70; // 0x19313c - g_ps2RecompiledFunctionTable[150606] = bhEne02_SetSandEffectMain_0x192d70; // 0x193140 - g_ps2RecompiledFunctionTable[150607] = bhEne02_SetSandEffectMain_0x192d70; // 0x193144 - g_ps2RecompiledFunctionTable[150608] = bhEne02_SetSandEffectMain_0x192d70; // 0x193148 - g_ps2RecompiledFunctionTable[150609] = bhEne02_SetSandEffectMain_0x192d70; // 0x19314c - g_ps2RecompiledFunctionTable[150610] = bhEne02_SetSandEffectMain_0x192d70; // 0x193150 - g_ps2RecompiledFunctionTable[150611] = bhEne02_SetSandEffectMain_0x192d70; // 0x193154 - g_ps2RecompiledFunctionTable[150612] = bhEne02_SetSandEffectMain_0x192d70; // 0x193158 - g_ps2RecompiledFunctionTable[150613] = bhEne02_SetSandEffectMain_0x192d70; // 0x19315c - g_ps2RecompiledFunctionTable[150614] = bhEne02_SetSandEffectMain_0x192d70; // 0x193160 - g_ps2RecompiledFunctionTable[150615] = bhEne02_SetSandEffectMain_0x192d70; // 0x193164 - g_ps2RecompiledFunctionTable[150616] = bhEne02_SetSandEffectMain_0x192d70; // 0x193168 - g_ps2RecompiledFunctionTable[150617] = bhEne02_SetSandEffectMain_0x192d70; // 0x19316c - g_ps2RecompiledFunctionTable[150618] = bhEne02_SetSandEffectMain_0x192d70; // 0x193170 - g_ps2RecompiledFunctionTable[150619] = bhEne02_SetSandEffectMain_0x192d70; // 0x193174 - g_ps2RecompiledFunctionTable[150620] = bhEne02_SetSandEffectMain_0x192d70; // 0x193178 - g_ps2RecompiledFunctionTable[150621] = bhEne02_SetSandEffectMain_0x192d70; // 0x19317c - g_ps2RecompiledFunctionTable[150622] = bhEne02_SetSandEffectMain_0x192d70; // 0x193180 - g_ps2RecompiledFunctionTable[150623] = bhEne02_SetSandEffectMain_0x192d70; // 0x193184 - g_ps2RecompiledFunctionTable[150624] = bhEne02_SetSandEffectMain_0x192d70; // 0x193188 - g_ps2RecompiledFunctionTable[150625] = bhEne02_SetSandEffectMain_0x192d70; // 0x19318c - g_ps2RecompiledFunctionTable[150626] = bhEne02_SetSandEffectMain_0x192d70; // 0x193190 - g_ps2RecompiledFunctionTable[150627] = bhEne02_SetSandEffectMain_0x192d70; // 0x193194 - g_ps2RecompiledFunctionTable[150628] = bhEne02_SetSandEffectMain_0x192d70; // 0x193198 - g_ps2RecompiledFunctionTable[150629] = bhEne02_SetSandEffectMain_0x192d70; // 0x19319c - g_ps2RecompiledFunctionTable[150630] = bhEne02_SetSandEffectMain_0x192d70; // 0x1931a0 - g_ps2RecompiledFunctionTable[150631] = bhEne02_SetSandEffectMain_0x192d70; // 0x1931a4 - g_ps2RecompiledFunctionTable[150632] = bhEne02_SetSandEffectMain_0x192d70; // 0x1931a8 - g_ps2RecompiledFunctionTable[150633] = bhEne02_SetSandEffectMain_0x192d70; // 0x1931ac - g_ps2RecompiledFunctionTable[150634] = bhEne02_SetSandEffectMain_0x192d70; // 0x1931b0 - g_ps2RecompiledFunctionTable[150635] = bhEne02_SetSandEffectMain_0x192d70; // 0x1931b4 - g_ps2RecompiledFunctionTable[150636] = bhEne02_SetSandEffectMain_0x192d70; // 0x1931b8 - g_ps2RecompiledFunctionTable[150637] = bhEne02_SetSandEffectMain_0x192d70; // 0x1931bc - g_ps2RecompiledFunctionTable[150638] = bhEne02_SetSandEffectMain_0x192d70; // 0x1931c0 - g_ps2RecompiledFunctionTable[150639] = bhEne02_SetSandEffectMain_0x192d70; // 0x1931c4 - g_ps2RecompiledFunctionTable[150640] = bhEne02_SetSandEffectMain_0x192d70; // 0x1931c8 - g_ps2RecompiledFunctionTable[150641] = bhEne02_SetSandEffectMain_0x192d70; // 0x1931cc - g_ps2RecompiledFunctionTable[150642] = bhEne02_SetSandEffectMain_0x192d70; // 0x1931d0 - g_ps2RecompiledFunctionTable[150643] = bhEne02_SetSandEffectMain_0x192d70; // 0x1931d4 - g_ps2RecompiledFunctionTable[150644] = bhEne02_SetSandEffectMain_0x192d70; // 0x1931d8 - g_ps2RecompiledFunctionTable[150645] = bhEne02_SetSandEffectMain_0x192d70; // 0x1931dc - g_ps2RecompiledFunctionTable[150646] = bhEne02_SetSandEffectMain_0x192d70; // 0x1931e0 - g_ps2RecompiledFunctionTable[150647] = bhEne02_SetSandEffectMain_0x192d70; // 0x1931e4 - g_ps2RecompiledFunctionTable[150648] = bhEne02_SetSandEffectMain_0x192d70; // 0x1931e8 - g_ps2RecompiledFunctionTable[150649] = bhEne02_SetSandEffectMain_0x192d70; // 0x1931ec - g_ps2RecompiledFunctionTable[150650] = bhEne02_SetSandEffectMain_0x192d70; // 0x1931f0 - g_ps2RecompiledFunctionTable[150651] = bhEne02_SetSandEffectMain_0x192d70; // 0x1931f4 - g_ps2RecompiledFunctionTable[150652] = bhEne02_SetSandEffectMain_0x192d70; // 0x1931f8 - g_ps2RecompiledFunctionTable[150653] = bhEne02_SetSandEffectMain_0x192d70; // 0x1931fc - g_ps2RecompiledFunctionTable[150654] = bhEne02_SetSandEffectMain_0x192d70; // 0x193200 - g_ps2RecompiledFunctionTable[150655] = bhEne02_SetSandEffectMain_0x192d70; // 0x193204 - g_ps2RecompiledFunctionTable[150656] = bhEne02_SetSandEffectMain_0x192d70; // 0x193208 - g_ps2RecompiledFunctionTable[150657] = bhEne02_SetSandEffectMain_0x192d70; // 0x19320c - g_ps2RecompiledFunctionTable[150658] = bhEne02_SetSandEffectMain_0x192d70; // 0x193210 - g_ps2RecompiledFunctionTable[150659] = bhEne02_SetSandEffectMain_0x192d70; // 0x193214 - g_ps2RecompiledFunctionTable[150660] = bhEne02_SetSandEffectMain_0x192d70; // 0x193218 - g_ps2RecompiledFunctionTable[150661] = bhEne02_SetSandEffectMain_0x192d70; // 0x19321c - g_ps2RecompiledFunctionTable[150662] = bhEne02_SetSandEffectMain_0x192d70; // 0x193220 - g_ps2RecompiledFunctionTable[150663] = bhEne02_SetSandEffectMain_0x192d70; // 0x193224 - g_ps2RecompiledFunctionTable[150664] = bhEne02_SetSandEffectMain_0x192d70; // 0x193228 - g_ps2RecompiledFunctionTable[150665] = bhEne02_SetSandEffectMain_0x192d70; // 0x19322c - g_ps2RecompiledFunctionTable[150666] = bhEne02_SetSandEffectMain_0x192d70; // 0x193230 - g_ps2RecompiledFunctionTable[150667] = bhEne02_SetSandEffectMain_0x192d70; // 0x193234 - g_ps2RecompiledFunctionTable[150668] = bhEne02_SetSandEffectMain_0x192d70; // 0x193238 - g_ps2RecompiledFunctionTable[150669] = bhEne02_SetSandEffectMain_0x192d70; // 0x19323c - g_ps2RecompiledFunctionTable[150670] = bhEne02_SetSandEffectMain_0x192d70; // 0x193240 - g_ps2RecompiledFunctionTable[150671] = bhEne02_SetSandEffectMain_0x192d70; // 0x193244 - g_ps2RecompiledFunctionTable[150672] = bhEne02_SetSandEffectMain_0x192d70; // 0x193248 - g_ps2RecompiledFunctionTable[150673] = bhEne02_SetSandEffectMain_0x192d70; // 0x19324c - g_ps2RecompiledFunctionTable[150674] = bhEne02_SetSandEffectMain_0x192d70; // 0x193250 - g_ps2RecompiledFunctionTable[150675] = bhEne02_SetSandEffectMain_0x192d70; // 0x193254 - g_ps2RecompiledFunctionTable[150676] = bhEne02_SetSandEffectMain_0x192d70; // 0x193258 - g_ps2RecompiledFunctionTable[150677] = bhEne02_SetSandEffectMain_0x192d70; // 0x19325c - g_ps2RecompiledFunctionTable[150678] = bhEne02_SetSandEffectMain_0x192d70; // 0x193260 - g_ps2RecompiledFunctionTable[150679] = bhEne02_SetSandEffectMain_0x192d70; // 0x193264 - g_ps2RecompiledFunctionTable[150680] = bhEne02_SetSandEffectMain_0x192d70; // 0x193268 - g_ps2RecompiledFunctionTable[150681] = bhEne02_SetSandEffectMain_0x192d70; // 0x19326c - g_ps2RecompiledFunctionTable[150682] = bhEne02_SetSandEffectMain_0x192d70; // 0x193270 - g_ps2RecompiledFunctionTable[150683] = bhEne02_SetSandEffectMain_0x192d70; // 0x193274 - g_ps2RecompiledFunctionTable[150684] = bhEne02_SetSandEffectMain_0x192d70; // 0x193278 - g_ps2RecompiledFunctionTable[150685] = bhEne02_SetSandEffectMain_0x192d70; // 0x19327c - g_ps2RecompiledFunctionTable[150686] = bhEne02_SetSandEffectMain_0x192d70; // 0x193280 - g_ps2RecompiledFunctionTable[150687] = bhEne02_SetSandEffectMain_0x192d70; // 0x193284 - g_ps2RecompiledFunctionTable[150688] = bhEne02_SetSandEffectMain_0x192d70; // 0x193288 - g_ps2RecompiledFunctionTable[150689] = bhEne02_SetSandEffectMain_0x192d70; // 0x19328c - g_ps2RecompiledFunctionTable[150690] = bhEne02_SetSandEffectMain_0x192d70; // 0x193290 - g_ps2RecompiledFunctionTable[150691] = bhEne02_SetSandEffectMain_0x192d70; // 0x193294 - g_ps2RecompiledFunctionTable[150692] = bhEne02_SetSandEffectMain_0x192d70; // 0x193298 - g_ps2RecompiledFunctionTable[150693] = bhEne02_SetSandEffectMain_0x192d70; // 0x19329c - g_ps2RecompiledFunctionTable[150694] = bhEne02_SetSandEffectMain_0x192d70; // 0x1932a0 - g_ps2RecompiledFunctionTable[150695] = bhEne02_SetSandEffectMain_0x192d70; // 0x1932a4 - g_ps2RecompiledFunctionTable[150696] = bhEne02_SetSandEffectMain_0x192d70; // 0x1932a8 - g_ps2RecompiledFunctionTable[150697] = bhEne02_SetSandEffectMain_0x192d70; // 0x1932ac - g_ps2RecompiledFunctionTable[150698] = bhEne02_SetSandEffectMain_0x192d70; // 0x1932b0 - g_ps2RecompiledFunctionTable[150699] = bhEne02_SetSandEffectMain_0x192d70; // 0x1932b4 - g_ps2RecompiledFunctionTable[150700] = bhEne02_SetSandEffectMain_0x192d70; // 0x1932b8 - g_ps2RecompiledFunctionTable[150701] = bhEne02_SetSandEffectMain_0x192d70; // 0x1932bc - g_ps2RecompiledFunctionTable[150702] = bhEne02_SetSandEffectMain_0x192d70; // 0x1932c0 - g_ps2RecompiledFunctionTable[150703] = bhEne02_SetSandEffectMain_0x192d70; // 0x1932c4 - g_ps2RecompiledFunctionTable[150704] = bhEne02_SetSandEffectMain_0x192d70; // 0x1932c8 - g_ps2RecompiledFunctionTable[150705] = bhEne02_SetSandEffectMain_0x192d70; // 0x1932cc - g_ps2RecompiledFunctionTable[150706] = bhEne02_SetSandEffectMain_0x192d70; // 0x1932d0 - g_ps2RecompiledFunctionTable[150707] = bhEne02_SetSandEffectMain_0x192d70; // 0x1932d4 - g_ps2RecompiledFunctionTable[150708] = bhEne02_SetSandEffectMain_0x192d70; // 0x1932d8 - g_ps2RecompiledFunctionTable[150709] = bhEne02_SetSandEffectMain_0x192d70; // 0x1932dc - g_ps2RecompiledFunctionTable[150710] = bhEne02_SetSandEffectMain_0x192d70; // 0x1932e0 - g_ps2RecompiledFunctionTable[150711] = bhEne02_SetSandEffectMain_0x192d70; // 0x1932e4 - g_ps2RecompiledFunctionTable[150712] = bhEne02_SetSandEffectMain_0x192d70; // 0x1932e8 - g_ps2RecompiledFunctionTable[150713] = bhEne02_SetSandEffectMain_0x192d70; // 0x1932ec - g_ps2RecompiledFunctionTable[150714] = bhEne02_SetSandEffectMain_0x192d70; // 0x1932f0 - g_ps2RecompiledFunctionTable[150715] = bhEne02_SetSandEffectMain_0x192d70; // 0x1932f4 - g_ps2RecompiledFunctionTable[150716] = bhEne02_SetSandEffectMain_0x192d70; // 0x1932f8 - g_ps2RecompiledFunctionTable[150717] = bhEne02_SetSandEffectMain_0x192d70; // 0x1932fc - g_ps2RecompiledFunctionTable[150718] = bhEne02_SetSandEffectMain_0x192d70; // 0x193300 - g_ps2RecompiledFunctionTable[150719] = bhEne02_SetSandEffectMain_0x192d70; // 0x193304 - g_ps2RecompiledFunctionTable[150720] = bhEne02_SetSandEffectMain_0x192d70; // 0x193308 - g_ps2RecompiledFunctionTable[150721] = bhEne02_SetSandEffectMain_0x192d70; // 0x19330c - g_ps2RecompiledFunctionTable[150722] = bhEne02_SetSandEffectMain_0x192d70; // 0x193310 - g_ps2RecompiledFunctionTable[150723] = bhEne02_SetSandEffectMain_0x192d70; // 0x193314 - g_ps2RecompiledFunctionTable[150724] = bhEne02_SetSandEffectMain_0x192d70; // 0x193318 - g_ps2RecompiledFunctionTable[150725] = bhEne02_SetSandEffectMain_0x192d70; // 0x19331c - g_ps2RecompiledFunctionTable[150726] = bhEne02_SetSandEffectMain_0x192d70; // 0x193320 - g_ps2RecompiledFunctionTable[150727] = bhEne02_SetSandEffectMain_0x192d70; // 0x193324 - g_ps2RecompiledFunctionTable[150728] = bhEne02_SetSandEffectMain_0x192d70; // 0x193328 - g_ps2RecompiledFunctionTable[150729] = bhEne02_SetSandEffectMain_0x192d70; // 0x19332c - g_ps2RecompiledFunctionTable[150730] = bhEne02_SetSandEffectMain_0x192d70; // 0x193330 - g_ps2RecompiledFunctionTable[150731] = bhEne02_SetSandEffectMain_0x192d70; // 0x193334 - g_ps2RecompiledFunctionTable[150732] = bhEne02_SetSandEffectMain_0x192d70; // 0x193338 - g_ps2RecompiledFunctionTable[150733] = bhEne02_SetSandEffectMain_0x192d70; // 0x19333c - g_ps2RecompiledFunctionTable[150734] = bhEne02_SetSandEffectMain_0x192d70; // 0x193340 - g_ps2RecompiledFunctionTable[150735] = bhEne02_SetSandEffectMain_0x192d70; // 0x193344 - g_ps2RecompiledFunctionTable[150736] = bhEne02_SetSandEffectMain_0x192d70; // 0x193348 - g_ps2RecompiledFunctionTable[150737] = bhEne02_SetSandEffectMain_0x192d70; // 0x19334c - g_ps2RecompiledFunctionTable[150738] = bhEne02_SetSandEffectMain_0x192d70; // 0x193350 - g_ps2RecompiledFunctionTable[150739] = bhEne02_SetSandEffectMain_0x192d70; // 0x193354 - g_ps2RecompiledFunctionTable[150740] = bhEne02_SetSandEffectMain_0x192d70; // 0x193358 - g_ps2RecompiledFunctionTable[150741] = bhEne02_SetSandEffectMain_0x192d70; // 0x19335c - g_ps2RecompiledFunctionTable[150742] = bhEne02_SetSandEffectMain_0x192d70; // 0x193360 - g_ps2RecompiledFunctionTable[150743] = bhEne02_SetSandEffectMain_0x192d70; // 0x193364 - g_ps2RecompiledFunctionTable[150744] = bhEne02_SetSandEffectMain_0x192d70; // 0x193368 - g_ps2RecompiledFunctionTable[150745] = bhEne02_SetSandEffectMain_0x192d70; // 0x19336c - g_ps2RecompiledFunctionTable[150746] = bhEne02_SetSandEffectMain_0x192d70; // 0x193370 - g_ps2RecompiledFunctionTable[150747] = bhEne02_SetSandEffectMain_0x192d70; // 0x193374 - g_ps2RecompiledFunctionTable[150748] = bhEne02_SetSandEffectMain_0x192d70; // 0x193378 - g_ps2RecompiledFunctionTable[150749] = bhEne02_SetSandEffectMain_0x192d70; // 0x19337c - g_ps2RecompiledFunctionTable[150750] = bhEne02_SetSandEffectMain_0x192d70; // 0x193380 - g_ps2RecompiledFunctionTable[150751] = bhEne02_SetSandEffectMain_0x192d70; // 0x193384 - g_ps2RecompiledFunctionTable[150752] = bhEne02_SetSandEffectMain_0x192d70; // 0x193388 - g_ps2RecompiledFunctionTable[150753] = bhEne02_SetSandEffectMain_0x192d70; // 0x19338c - g_ps2RecompiledFunctionTable[150754] = bhEne02_SetSandEffectMain_0x192d70; // 0x193390 - g_ps2RecompiledFunctionTable[150755] = bhEne02_SetSandEffectMain_0x192d70; // 0x193394 - g_ps2RecompiledFunctionTable[150756] = bhEne02_SetSandEffectMain_0x192d70; // 0x193398 - g_ps2RecompiledFunctionTable[150757] = bhEne02_SetSandEffectMain_0x192d70; // 0x19339c - g_ps2RecompiledFunctionTable[150758] = bhEne02_SetSandEffectMain_0x192d70; // 0x1933a0 - g_ps2RecompiledFunctionTable[150759] = bhEne02_SetSandEffectMain_0x192d70; // 0x1933a4 - g_ps2RecompiledFunctionTable[150760] = bhEne02_SetSandEffectMain_0x192d70; // 0x1933a8 - g_ps2RecompiledFunctionTable[150761] = bhEne02_SetSandEffectMain_0x192d70; // 0x1933ac - g_ps2RecompiledFunctionTable[150762] = bhEne02_SetSandEffectMain_0x192d70; // 0x1933b0 - g_ps2RecompiledFunctionTable[150763] = bhEne02_SetSandEffectMain_0x192d70; // 0x1933b4 - g_ps2RecompiledFunctionTable[150764] = bhEne02_SetSandEffectMain_0x192d70; // 0x1933b8 - g_ps2RecompiledFunctionTable[150765] = bhEne02_SetSandEffectMain_0x192d70; // 0x1933bc - g_ps2RecompiledFunctionTable[150766] = bhEne02_SetSandEffectMain_0x192d70; // 0x1933c0 - g_ps2RecompiledFunctionTable[150767] = bhEne02_SetSandEffectMain_0x192d70; // 0x1933c4 - g_ps2RecompiledFunctionTable[150768] = bhEne02_SetSandEffectMain_0x192d70; // 0x1933c8 - g_ps2RecompiledFunctionTable[150769] = bhEne02_SetSandEffectMain_0x192d70; // 0x1933cc - g_ps2RecompiledFunctionTable[150770] = bhEne02_SetSandEffectMain_0x192d70; // 0x1933d0 - g_ps2RecompiledFunctionTable[150771] = bhEne02_SetSandEffectMain_0x192d70; // 0x1933d4 - g_ps2RecompiledFunctionTable[150772] = bhEne02_SetSandEffectMain_0x192d70; // 0x1933d8 - g_ps2RecompiledFunctionTable[150773] = bhEne02_SetSandEffectMain_0x192d70; // 0x1933dc - g_ps2RecompiledFunctionTable[150774] = bhEne02_SetSandEffectMain_0x192d70; // 0x1933e0 - g_ps2RecompiledFunctionTable[150775] = bhEne02_SetSandEffectMain_0x192d70; // 0x1933e4 - g_ps2RecompiledFunctionTable[150776] = bhEne02_SetSandEffectMain_0x192d70; // 0x1933e8 - g_ps2RecompiledFunctionTable[150777] = bhEne02_SetSandEffectMain_0x192d70; // 0x1933ec - g_ps2RecompiledFunctionTable[150778] = bhEne02_SetSandEffectMain_0x192d70; // 0x1933f0 - g_ps2RecompiledFunctionTable[150779] = bhEne02_SetSandEffectMain_0x192d70; // 0x1933f4 - g_ps2RecompiledFunctionTable[150780] = bhEne02_SetSandEffectMain_0x192d70; // 0x1933f8 - g_ps2RecompiledFunctionTable[150781] = bhEne02_SetSandEffectMain_0x192d70; // 0x1933fc - g_ps2RecompiledFunctionTable[150782] = bhEne02_SetSandEffectMain_0x192d70; // 0x193400 - g_ps2RecompiledFunctionTable[150783] = bhEne02_SetSandEffectMain_0x192d70; // 0x193404 - g_ps2RecompiledFunctionTable[150784] = bhEne02_SetSandEffectMain_0x192d70; // 0x193408 - g_ps2RecompiledFunctionTable[150785] = bhEne02_SetSandEffectMain_0x192d70; // 0x19340c - g_ps2RecompiledFunctionTable[150786] = bhEne02_SetSandEffectMain_0x192d70; // 0x193410 - g_ps2RecompiledFunctionTable[150787] = bhEne02_SetSandEffectMain_0x192d70; // 0x193414 - g_ps2RecompiledFunctionTable[150788] = bhEne02_SetSandEffectMain_0x192d70; // 0x193418 - g_ps2RecompiledFunctionTable[150789] = bhEne02_SetSandEffectMain_0x192d70; // 0x19341c - g_ps2RecompiledFunctionTable[150790] = bhEne02_SetSandEffectMain_0x192d70; // 0x193420 - g_ps2RecompiledFunctionTable[150791] = bhEne02_SetSandEffectMain_0x192d70; // 0x193424 - g_ps2RecompiledFunctionTable[150792] = bhEne02_SetSandEffectMain_0x192d70; // 0x193428 - g_ps2RecompiledFunctionTable[150793] = bhEne02_SetSandEffectMain_0x192d70; // 0x19342c - g_ps2RecompiledFunctionTable[150794] = bhEne02_SetSandEffectMain_0x192d70; // 0x193430 - g_ps2RecompiledFunctionTable[150795] = bhEne02_SetSandEffectMain_0x192d70; // 0x193434 - g_ps2RecompiledFunctionTable[150796] = bhEne02_SetSandEffectMain_0x192d70; // 0x193438 - g_ps2RecompiledFunctionTable[150797] = bhEne02_SetSandEffectMain_0x192d70; // 0x19343c - g_ps2RecompiledFunctionTable[150798] = bhEne02_SetSandEffectMain_0x192d70; // 0x193440 - g_ps2RecompiledFunctionTable[150799] = bhEne02_SetSandEffectMain_0x192d70; // 0x193444 - g_ps2RecompiledFunctionTable[150800] = bhEne02_SetSandEffectMain_0x192d70; // 0x193448 - g_ps2RecompiledFunctionTable[150801] = bhEne02_SetSandEffectMain_0x192d70; // 0x19344c - g_ps2RecompiledFunctionTable[150802] = bhEne02_SetSandEffectMain_0x192d70; // 0x193450 - g_ps2RecompiledFunctionTable[150803] = bhEne02_SetSandEffectMain_0x192d70; // 0x193454 - g_ps2RecompiledFunctionTable[150804] = bhEne02_SetSandEffectMain_0x192d70; // 0x193458 - g_ps2RecompiledFunctionTable[150805] = bhEne02_SetSandEffectMain_0x192d70; // 0x19345c - g_ps2RecompiledFunctionTable[150806] = bhEne02_SetSandEffectMain_0x192d70; // 0x193460 - g_ps2RecompiledFunctionTable[150807] = bhEne02_SetSandEffectMain_0x192d70; // 0x193464 - g_ps2RecompiledFunctionTable[150808] = bhEne02_SetSandEffectMain_0x192d70; // 0x193468 - g_ps2RecompiledFunctionTable[150809] = bhEne02_SetSandEffectMain_0x192d70; // 0x19346c - g_ps2RecompiledFunctionTable[150810] = bhEne02_SetSandEffectMain_0x192d70; // 0x193470 - g_ps2RecompiledFunctionTable[150811] = bhEne02_SetSandEffectMain_0x192d70; // 0x193474 - g_ps2RecompiledFunctionTable[150812] = bhEne02_SetSandEffectMain_0x192d70; // 0x193478 - g_ps2RecompiledFunctionTable[150813] = bhEne02_SetSandEffectMain_0x192d70; // 0x19347c - g_ps2RecompiledFunctionTable[150814] = bhEne02_SetSandEffectMain_0x192d70; // 0x193480 - g_ps2RecompiledFunctionTable[150815] = bhEne02_SetSandEffectMain_0x192d70; // 0x193484 - g_ps2RecompiledFunctionTable[150816] = bhEne02_SetSandEffectMain_0x192d70; // 0x193488 - g_ps2RecompiledFunctionTable[150817] = bhEne02_SetSandEffectMain_0x192d70; // 0x19348c - g_ps2RecompiledFunctionTable[150818] = bhEne02_SetSandEffectMain_0x192d70; // 0x193490 - g_ps2RecompiledFunctionTable[150819] = bhEne02_SetSandEffectMain_0x192d70; // 0x193494 - g_ps2RecompiledFunctionTable[150820] = bhEne02_SetSandEffectMain_0x192d70; // 0x193498 - g_ps2RecompiledFunctionTable[150821] = bhEne02_SetSandEffectMain_0x192d70; // 0x19349c - g_ps2RecompiledFunctionTable[150822] = bhEne02_SetSandEffectMain_0x192d70; // 0x1934a0 - g_ps2RecompiledFunctionTable[150823] = bhEne02_SetSandEffectMain_0x192d70; // 0x1934a4 - g_ps2RecompiledFunctionTable[150824] = bhEne02_SetSandEffectMain_0x192d70; // 0x1934a8 - g_ps2RecompiledFunctionTable[150825] = bhEne02_SetSandEffectMain_0x192d70; // 0x1934ac - g_ps2RecompiledFunctionTable[150826] = bhEne02_SetSandEffectMain_0x192d70; // 0x1934b0 - g_ps2RecompiledFunctionTable[150827] = bhEne02_SetSandEffectMain_0x192d70; // 0x1934b4 - g_ps2RecompiledFunctionTable[150828] = bhEne02_SetSandEffectMain_0x192d70; // 0x1934b8 - g_ps2RecompiledFunctionTable[150829] = bhEne02_SetSandEffectMain_0x192d70; // 0x1934bc - g_ps2RecompiledFunctionTable[150830] = bhEne02_SetSandEffectMain_0x192d70; // 0x1934c0 - g_ps2RecompiledFunctionTable[150831] = bhEne02_SetSandEffectMain_0x192d70; // 0x1934c4 - g_ps2RecompiledFunctionTable[150832] = bhEne02_SetSandEffectMain_0x192d70; // 0x1934c8 - g_ps2RecompiledFunctionTable[150833] = bhEne02_SetSandEffectMain_0x192d70; // 0x1934cc - g_ps2RecompiledFunctionTable[150834] = bhEne02_SetSandEffectMain_0x192d70; // 0x1934d0 - g_ps2RecompiledFunctionTable[150835] = bhEne02_SetSandEffectMain_0x192d70; // 0x1934d4 - g_ps2RecompiledFunctionTable[150836] = bhEne02_SetSandEffectMain_0x192d70; // 0x1934d8 - g_ps2RecompiledFunctionTable[150837] = bhEne02_SetSandEffectMain_0x192d70; // 0x1934dc - g_ps2RecompiledFunctionTable[150838] = bhEne02_SetSandEffectMain_0x192d70; // 0x1934e0 - g_ps2RecompiledFunctionTable[150839] = bhEne02_SetSandEffectMain_0x192d70; // 0x1934e4 - g_ps2RecompiledFunctionTable[150840] = bhEne02_SetSandEffectMain_0x192d70; // 0x1934e8 - g_ps2RecompiledFunctionTable[150841] = bhEne02_SetSandEffectMain_0x192d70; // 0x1934ec - g_ps2RecompiledFunctionTable[150842] = bhEne02_SetSandEffectMain_0x192d70; // 0x1934f0 - g_ps2RecompiledFunctionTable[150843] = bhEne02_SetSandEffectMain_0x192d70; // 0x1934f4 - g_ps2RecompiledFunctionTable[150844] = bhEne02_SetSandEffectMain_0x192d70; // 0x1934f8 - g_ps2RecompiledFunctionTable[150845] = bhEne02_SetSandEffectMain_0x192d70; // 0x1934fc - g_ps2RecompiledFunctionTable[150846] = bhEne02_SetSandEffectMain_0x192d70; // 0x193500 - g_ps2RecompiledFunctionTable[150847] = bhEne02_SetSandEffectMain_0x192d70; // 0x193504 - g_ps2RecompiledFunctionTable[150848] = bhEne02_SetSandEffectMain_0x192d70; // 0x193508 - g_ps2RecompiledFunctionTable[150849] = bhEne02_SetSandEffectMain_0x192d70; // 0x19350c - g_ps2RecompiledFunctionTable[150850] = bhEne02_SetSandEffectMain_0x192d70; // 0x193510 - g_ps2RecompiledFunctionTable[150851] = bhEne02_SetSandEffectMain_0x192d70; // 0x193514 - g_ps2RecompiledFunctionTable[150852] = bhEne02_SetSandEffectMain_0x192d70; // 0x193518 - g_ps2RecompiledFunctionTable[150853] = bhEne02_SetSandEffectMain_0x192d70; // 0x19351c - g_ps2RecompiledFunctionTable[150854] = bhEne02_SetSandEffectMain_0x192d70; // 0x193520 - g_ps2RecompiledFunctionTable[150855] = bhEne02_SetSandEffectMain_0x192d70; // 0x193524 - g_ps2RecompiledFunctionTable[150856] = bhEne02_SetSandEffectMain_0x192d70; // 0x193528 - g_ps2RecompiledFunctionTable[150857] = bhEne02_SetSandEffectMain_0x192d70; // 0x19352c - g_ps2RecompiledFunctionTable[150858] = bhEne02_SetSandEffectMain_0x192d70; // 0x193530 - g_ps2RecompiledFunctionTable[150859] = bhEne02_SetSandEffectMain_0x192d70; // 0x193534 - g_ps2RecompiledFunctionTable[150860] = bhEne02_SetSandEffectMain_0x192d70; // 0x193538 - g_ps2RecompiledFunctionTable[150861] = bhEne02_SetSandEffectMain_0x192d70; // 0x19353c - g_ps2RecompiledFunctionTable[150862] = bhEne02_SetSandEffectMain_0x192d70; // 0x193540 - g_ps2RecompiledFunctionTable[150863] = bhEne02_SetSandEffectMain_0x192d70; // 0x193544 - g_ps2RecompiledFunctionTable[150864] = bhEne02_SetSandEffectMain_0x192d70; // 0x193548 - g_ps2RecompiledFunctionTable[150865] = bhEne02_SetSandEffectMain_0x192d70; // 0x19354c - g_ps2RecompiledFunctionTable[150866] = bhEne02_SetSandEffectMain_0x192d70; // 0x193550 - g_ps2RecompiledFunctionTable[150867] = bhEne02_SetSandEffectMain_0x192d70; // 0x193554 - g_ps2RecompiledFunctionTable[150868] = bhEne02_SetSandEffectMain_0x192d70; // 0x193558 - g_ps2RecompiledFunctionTable[150869] = bhEne02_SetSandEffectMain_0x192d70; // 0x19355c - g_ps2RecompiledFunctionTable[150870] = bhEne02_SetSandEffectMain_0x192d70; // 0x193560 - g_ps2RecompiledFunctionTable[150871] = bhEne02_SetSandEffectMain_0x192d70; // 0x193564 - g_ps2RecompiledFunctionTable[150872] = bhEne02_SetSandEffectMain_0x192d70; // 0x193568 - g_ps2RecompiledFunctionTable[150873] = bhEne02_SetSandEffectMain_0x192d70; // 0x19356c - g_ps2RecompiledFunctionTable[150874] = bhEne02_SetSandEffectMain_0x192d70; // 0x193570 - g_ps2RecompiledFunctionTable[150875] = bhEne02_SetSandEffectMain_0x192d70; // 0x193574 - g_ps2RecompiledFunctionTable[150876] = bhEne02_SetSandEffectMain_0x192d70; // 0x193578 - g_ps2RecompiledFunctionTable[150877] = bhEne02_SetSandEffectMain_0x192d70; // 0x19357c - g_ps2RecompiledFunctionTable[150878] = bhEne02_SetSandEffectMain_0x192d70; // 0x193580 - g_ps2RecompiledFunctionTable[150879] = bhEne02_SetSandEffectMain_0x192d70; // 0x193584 - g_ps2RecompiledFunctionTable[150880] = bhEne02_SetSandEffectMain_0x192d70; // 0x193588 - g_ps2RecompiledFunctionTable[150881] = bhEne02_SetSandEffectMain_0x192d70; // 0x19358c - g_ps2RecompiledFunctionTable[150882] = bhEne02_SetSandEffectMain_0x192d70; // 0x193590 - g_ps2RecompiledFunctionTable[150883] = bhEne02_SetSandEffectMain_0x192d70; // 0x193594 - g_ps2RecompiledFunctionTable[150884] = bhEne02_SetSandEffectMain_0x192d70; // 0x193598 - g_ps2RecompiledFunctionTable[150885] = bhEne02_SetSandEffectMain_0x192d70; // 0x19359c - g_ps2RecompiledFunctionTable[150886] = bhEne02_SetSandEffectMain_0x192d70; // 0x1935a0 - g_ps2RecompiledFunctionTable[150887] = bhEne02_SetSandEffectMain_0x192d70; // 0x1935a4 - g_ps2RecompiledFunctionTable[150888] = bhEne02_SetSandEffectMain_0x192d70; // 0x1935a8 - g_ps2RecompiledFunctionTable[150889] = bhEne02_SetSandEffectMain_0x192d70; // 0x1935ac - g_ps2RecompiledFunctionTable[150890] = bhEne02_SetSandEffectMain_0x192d70; // 0x1935b0 - g_ps2RecompiledFunctionTable[150891] = bhEne02_SetSandEffectMain_0x192d70; // 0x1935b4 - g_ps2RecompiledFunctionTable[150892] = bhEne02_SetSandEffectMain_0x192d70; // 0x1935b8 - g_ps2RecompiledFunctionTable[150893] = bhEne02_SetSandEffectMain_0x192d70; // 0x1935bc - g_ps2RecompiledFunctionTable[150894] = bhEne02_SetSandEffectMain_0x192d70; // 0x1935c0 - g_ps2RecompiledFunctionTable[150895] = bhEne02_SetSandEffectMain_0x192d70; // 0x1935c4 - g_ps2RecompiledFunctionTable[150896] = bhEne02_SetSandEffectMain_0x192d70; // 0x1935c8 - g_ps2RecompiledFunctionTable[150897] = bhEne02_SetSandEffectMain_0x192d70; // 0x1935cc - g_ps2RecompiledFunctionTable[150898] = bhEne02_SetSandEffectMain_0x192d70; // 0x1935d0 - g_ps2RecompiledFunctionTable[150899] = bhEne02_SetSandEffectMain_0x192d70; // 0x1935d4 - g_ps2RecompiledFunctionTable[150900] = bhEne02_SetSandEffectMain_0x192d70; // 0x1935d8 - g_ps2RecompiledFunctionTable[150901] = bhEne02_SetSandEffectMain_0x192d70; // 0x1935dc - g_ps2RecompiledFunctionTable[150902] = bhEne02_SetSandEffectMain_0x192d70; // 0x1935e0 - g_ps2RecompiledFunctionTable[150903] = bhEne02_SetSandEffectMain_0x192d70; // 0x1935e4 - g_ps2RecompiledFunctionTable[150904] = bhEne02_SetSandEffectMain_0x192d70; // 0x1935e8 - g_ps2RecompiledFunctionTable[150905] = bhEne02_SetSandEffectMain_0x192d70; // 0x1935ec - g_ps2RecompiledFunctionTable[150906] = bhEne02_SetSandEffectMain_0x192d70; // 0x1935f0 - g_ps2RecompiledFunctionTable[150907] = bhEne02_SetSandEffectMain_0x192d70; // 0x1935f4 - g_ps2RecompiledFunctionTable[150908] = bhEne02_SetSandEffectMain_0x192d70; // 0x1935f8 - g_ps2RecompiledFunctionTable[150909] = bhEne02_SetSandEffectMain_0x192d70; // 0x1935fc - g_ps2RecompiledFunctionTable[150910] = bhEne02_SetSandEffectMain_0x192d70; // 0x193600 - g_ps2RecompiledFunctionTable[150911] = bhEne02_SetSandEffectMain_0x192d70; // 0x193604 - g_ps2RecompiledFunctionTable[150912] = bhEne02_SetSandEffectMain_0x192d70; // 0x193608 - g_ps2RecompiledFunctionTable[150913] = bhEne02_SetSandEffectMain_0x192d70; // 0x19360c - g_ps2RecompiledFunctionTable[150914] = bhEne02_SetSandEffectMain_0x192d70; // 0x193610 - g_ps2RecompiledFunctionTable[150915] = bhEne02_SetSandEffectMain_0x192d70; // 0x193614 - g_ps2RecompiledFunctionTable[150916] = bhEne02_SetSandEffectMain_0x192d70; // 0x193618 - g_ps2RecompiledFunctionTable[150917] = bhEne02_SetSandEffectMain_0x192d70; // 0x19361c - g_ps2RecompiledFunctionTable[150918] = bhEne02_SetSandEffectMain_0x192d70; // 0x193620 - g_ps2RecompiledFunctionTable[150919] = bhEne02_SetSandEffectMain_0x192d70; // 0x193624 - g_ps2RecompiledFunctionTable[150920] = bhEne02_SetSandEffectMain_0x192d70; // 0x193628 - g_ps2RecompiledFunctionTable[150921] = bhEne02_SetSandEffectMain_0x192d70; // 0x19362c - g_ps2RecompiledFunctionTable[150922] = bhEne02_SetSandEffectMain_0x192d70; // 0x193630 - g_ps2RecompiledFunctionTable[150923] = bhEne02_SetSandEffectMain_0x192d70; // 0x193634 - g_ps2RecompiledFunctionTable[150924] = bhEne02_SetSandEffectMain_0x192d70; // 0x193638 - g_ps2RecompiledFunctionTable[150925] = bhEne02_SetSandEffectMain_0x192d70; // 0x19363c - g_ps2RecompiledFunctionTable[150926] = bhEne02_SetSandEffectMain_0x192d70; // 0x193640 - g_ps2RecompiledFunctionTable[150927] = bhEne02_SetSandEffectMain_0x192d70; // 0x193644 - g_ps2RecompiledFunctionTable[150928] = bhEne02_SetSandEffectMain_0x192d70; // 0x193648 - g_ps2RecompiledFunctionTable[150929] = bhEne02_SetSandEffectMain_0x192d70; // 0x19364c - g_ps2RecompiledFunctionTable[150930] = bhEne02_SetSandEffectMain_0x192d70; // 0x193650 - g_ps2RecompiledFunctionTable[150931] = bhEne02_SetSandEffectMain_0x192d70; // 0x193654 - g_ps2RecompiledFunctionTable[150932] = bhEne02_SetSandEffectMain_0x192d70; // 0x193658 - g_ps2RecompiledFunctionTable[150933] = bhEne02_SetSandEffectMain_0x192d70; // 0x19365c - g_ps2RecompiledFunctionTable[150934] = bhEne02_SetSandEffectMain_0x192d70; // 0x193660 - g_ps2RecompiledFunctionTable[150935] = bhEne02_SetSandEffectMain_0x192d70; // 0x193664 - g_ps2RecompiledFunctionTable[150936] = bhEne02_SetSandEffectMain_0x192d70; // 0x193668 - g_ps2RecompiledFunctionTable[150937] = bhEne02_SetSandEffectMain_0x192d70; // 0x19366c - g_ps2RecompiledFunctionTable[150938] = bhEne02_SetSandEffectMain_0x192d70; // 0x193670 - g_ps2RecompiledFunctionTable[150939] = bhEne02_SetSandEffectMain_0x192d70; // 0x193674 - g_ps2RecompiledFunctionTable[150940] = bhEne02_SetSandEffectMain_0x192d70; // 0x193678 - g_ps2RecompiledFunctionTable[150941] = bhEne02_SetSandEffectMain_0x192d70; // 0x19367c - g_ps2RecompiledFunctionTable[150942] = bhEne02_SetSandEffectMain_0x192d70; // 0x193680 - g_ps2RecompiledFunctionTable[150943] = bhEne02_SetSandEffectMain_0x192d70; // 0x193684 - g_ps2RecompiledFunctionTable[150944] = bhEne02_SetSandEffectMain_0x192d70; // 0x193688 - g_ps2RecompiledFunctionTable[150945] = bhEne02_SetSandEffectMain_0x192d70; // 0x19368c - g_ps2RecompiledFunctionTable[150946] = bhEne02_SetSandEffectMain_0x192d70; // 0x193690 - g_ps2RecompiledFunctionTable[150947] = bhEne02_SetSandEffectMain_0x192d70; // 0x193694 - g_ps2RecompiledFunctionTable[150948] = bhEne02_SetSandEffectMain_0x192d70; // 0x193698 - g_ps2RecompiledFunctionTable[150949] = bhEne02_SetSandEffectMain_0x192d70; // 0x19369c - g_ps2RecompiledFunctionTable[150950] = bhEne02_SetSandEffectMain_0x192d70; // 0x1936a0 - g_ps2RecompiledFunctionTable[150951] = bhEne02_SetSandEffectMain_0x192d70; // 0x1936a4 - g_ps2RecompiledFunctionTable[150952] = bhEne02_SetSandEffectMain_0x192d70; // 0x1936a8 - g_ps2RecompiledFunctionTable[150953] = bhEne02_SetSandEffectMain_0x192d70; // 0x1936ac - g_ps2RecompiledFunctionTable[150954] = bhEne02_SetSandEffectMain_0x192d70; // 0x1936b0 - g_ps2RecompiledFunctionTable[150955] = bhEne02_SetSandEffectMain_0x192d70; // 0x1936b4 - g_ps2RecompiledFunctionTable[150956] = bhEne02_SetSandEffectMain_0x192d70; // 0x1936b8 - g_ps2RecompiledFunctionTable[150957] = bhEne02_SetSandEffectMain_0x192d70; // 0x1936bc - g_ps2RecompiledFunctionTable[150958] = bhEne02_SetSandEffectMain_0x192d70; // 0x1936c0 - g_ps2RecompiledFunctionTable[150959] = bhEne02_SetSandEffectMain_0x192d70; // 0x1936c4 - g_ps2RecompiledFunctionTable[150960] = bhEne02_SetSandEffectMain_0x192d70; // 0x1936c8 - g_ps2RecompiledFunctionTable[150961] = bhEne02_SetSandEffectMain_0x192d70; // 0x1936cc - g_ps2RecompiledFunctionTable[150962] = bhEne02_SetSandEffectMain_0x192d70; // 0x1936d0 - g_ps2RecompiledFunctionTable[150963] = bhEne02_SetSandEffectMain_0x192d70; // 0x1936d4 - g_ps2RecompiledFunctionTable[150964] = bhEne02_SetSandEffectMain_0x192d70; // 0x1936d8 - g_ps2RecompiledFunctionTable[150965] = bhEne02_SetSandEffectMain_0x192d70; // 0x1936dc - g_ps2RecompiledFunctionTable[150966] = bhEne02_SetSandEffectMain_0x192d70; // 0x1936e0 - g_ps2RecompiledFunctionTable[150967] = bhEne02_SetSandEffectMain_0x192d70; // 0x1936e4 - g_ps2RecompiledFunctionTable[150968] = bhEne02_SetSandEffectMain_0x192d70; // 0x1936e8 - g_ps2RecompiledFunctionTable[150969] = bhEne02_SetSandEffectMain_0x192d70; // 0x1936ec - g_ps2RecompiledFunctionTable[150970] = bhEne02_SetSandEffectMain_0x192d70; // 0x1936f0 - g_ps2RecompiledFunctionTable[150971] = bhEne02_SetSandEffectMain_0x192d70; // 0x1936f4 - g_ps2RecompiledFunctionTable[150972] = bhEne02_SetSandEffectMain_0x192d70; // 0x1936f8 - g_ps2RecompiledFunctionTable[150973] = bhEne02_SetSandEffectMain_0x192d70; // 0x1936fc - g_ps2RecompiledFunctionTable[150974] = bhEne02_SetSandEffectMain_0x192d70; // 0x193700 - g_ps2RecompiledFunctionTable[150975] = bhEne02_SetSandEffectMain_0x192d70; // 0x193704 - g_ps2RecompiledFunctionTable[150976] = bhEne02_SetSandEffectMain_0x192d70; // 0x193708 - g_ps2RecompiledFunctionTable[150977] = bhEne02_SetSandEffectMain_0x192d70; // 0x19370c - g_ps2RecompiledFunctionTable[150978] = bhEne02_SetSandEffectMain_0x192d70; // 0x193710 - g_ps2RecompiledFunctionTable[150979] = bhEne02_SetSandEffectMain_0x192d70; // 0x193714 - g_ps2RecompiledFunctionTable[150980] = bhEne02_SetSandEffectMain_0x192d70; // 0x193718 - g_ps2RecompiledFunctionTable[150981] = bhEne02_SetSandEffectMain_0x192d70; // 0x19371c - g_ps2RecompiledFunctionTable[150982] = bhEne02_SetSandEffectMain_0x192d70; // 0x193720 - g_ps2RecompiledFunctionTable[150983] = bhEne02_SetSandEffectMain_0x192d70; // 0x193724 - g_ps2RecompiledFunctionTable[150984] = bhEne02_SetSandEffectMain_0x192d70; // 0x193728 - g_ps2RecompiledFunctionTable[150985] = bhEne02_SetSandEffectMain_0x192d70; // 0x19372c - g_ps2RecompiledFunctionTable[150986] = bhEne02_SetSandEffectMain_0x192d70; // 0x193730 - g_ps2RecompiledFunctionTable[150987] = bhEne02_SetSandEffectMain_0x192d70; // 0x193734 - g_ps2RecompiledFunctionTable[150988] = bhEne02_SetSandEffectMain_0x192d70; // 0x193738 - g_ps2RecompiledFunctionTable[150989] = bhEne02_SetSandEffectMain_0x192d70; // 0x19373c - g_ps2RecompiledFunctionTable[150990] = bhEne02_SetSandEffectMain_0x192d70; // 0x193740 - g_ps2RecompiledFunctionTable[150991] = bhEne02_SetSandEffectMain_0x192d70; // 0x193744 - g_ps2RecompiledFunctionTable[150992] = bhEne02_SetSandEffectMain_0x192d70; // 0x193748 - g_ps2RecompiledFunctionTable[150993] = bhEne02_SetSandEffectMain_0x192d70; // 0x19374c - g_ps2RecompiledFunctionTable[150994] = bhEne02_SetSandEffectMain_0x192d70; // 0x193750 - g_ps2RecompiledFunctionTable[150995] = bhEne02_SetSandEffectMain_0x192d70; // 0x193754 - g_ps2RecompiledFunctionTable[150996] = bhEne02_SetSandEffectMain_0x192d70; // 0x193758 - g_ps2RecompiledFunctionTable[150997] = bhEne02_SetSandEffectMain_0x192d70; // 0x19375c - g_ps2RecompiledFunctionTable[150998] = bhEne02_SetSandEffectMain_0x192d70; // 0x193760 - g_ps2RecompiledFunctionTable[150999] = bhEne02_SetSandEffectMain_0x192d70; // 0x193764 - g_ps2RecompiledFunctionTable[151000] = bhEne02_SetSandEffectMain_0x192d70; // 0x193768 - g_ps2RecompiledFunctionTable[151001] = bhEne02_SetSandEffectMain_0x192d70; // 0x19376c - g_ps2RecompiledFunctionTable[151002] = bhEne02_SetSandEffectMain_0x192d70; // 0x193770 - g_ps2RecompiledFunctionTable[151003] = bhEne02_SetSandEffectMain_0x192d70; // 0x193774 - g_ps2RecompiledFunctionTable[151004] = bhEne02_SetSandEffectMain_0x192d70; // 0x193778 - g_ps2RecompiledFunctionTable[151005] = bhEne02_SetSandEffectMain_0x192d70; // 0x19377c - g_ps2RecompiledFunctionTable[151006] = bhEne02_SetSandEffectMain_0x192d70; // 0x193780 - g_ps2RecompiledFunctionTable[151007] = bhEne02_SetSandEffectMain_0x192d70; // 0x193784 - g_ps2RecompiledFunctionTable[151008] = bhEne02_SetSandEffectMain_0x192d70; // 0x193788 - g_ps2RecompiledFunctionTable[151009] = bhEne02_SetSandEffectMain_0x192d70; // 0x19378c - g_ps2RecompiledFunctionTable[151010] = bhEne02_SetSandEffectMain_0x192d70; // 0x193790 - g_ps2RecompiledFunctionTable[151011] = bhEne02_SetSandEffectMain_0x192d70; // 0x193794 - g_ps2RecompiledFunctionTable[151012] = bhEne02_SetSandEffectMain_0x192d70; // 0x193798 - g_ps2RecompiledFunctionTable[151013] = bhEne02_SetSandEffectMain_0x192d70; // 0x19379c - g_ps2RecompiledFunctionTable[151014] = bhEne02_SetSandEffectMain_0x192d70; // 0x1937a0 - g_ps2RecompiledFunctionTable[151015] = bhEne02_SetSandEffectMain_0x192d70; // 0x1937a4 - g_ps2RecompiledFunctionTable[151016] = bhEne02_SetSandEffectMain_0x192d70; // 0x1937a8 - g_ps2RecompiledFunctionTable[151017] = bhEne02_SetSandEffectMain_0x192d70; // 0x1937ac - g_ps2RecompiledFunctionTable[151018] = bhEne02_SetSandEffectMain_0x192d70; // 0x1937b0 - g_ps2RecompiledFunctionTable[151019] = bhEne02_SetSandEffectMain_0x192d70; // 0x1937b4 - g_ps2RecompiledFunctionTable[151020] = bhEne02_SetSandEffectMain_0x192d70; // 0x1937b8 - g_ps2RecompiledFunctionTable[151021] = bhEne02_SetSandEffectMain_0x192d70; // 0x1937bc - g_ps2RecompiledFunctionTable[151022] = bhEne02_SetSandEffectMain_0x192d70; // 0x1937c0 - g_ps2RecompiledFunctionTable[151023] = bhEne02_SetSandEffectMain_0x192d70; // 0x1937c4 - g_ps2RecompiledFunctionTable[151024] = bhEne02_SetSandEffectMain_0x192d70; // 0x1937c8 - g_ps2RecompiledFunctionTable[151025] = bhEne02_SetSandEffectMain_0x192d70; // 0x1937cc - g_ps2RecompiledFunctionTable[151026] = bhEne02_SetSandEffectMain_0x192d70; // 0x1937d0 - g_ps2RecompiledFunctionTable[151027] = bhEne02_SetSandEffectMain_0x192d70; // 0x1937d4 - g_ps2RecompiledFunctionTable[151028] = bhEne02_SetSandEffectMain_0x192d70; // 0x1937d8 - g_ps2RecompiledFunctionTable[151029] = bhEne02_SetSandEffectMain_0x192d70; // 0x1937dc - g_ps2RecompiledFunctionTable[151030] = bhEne02_SetSandEffectMain_0x192d70; // 0x1937e0 - g_ps2RecompiledFunctionTable[151031] = bhEne02_SetSandEffectMain_0x192d70; // 0x1937e4 - g_ps2RecompiledFunctionTable[151032] = bhEne02_SetSandEffectMain_0x192d70; // 0x1937e8 - g_ps2RecompiledFunctionTable[151033] = bhEne02_SetSandEffectMain_0x192d70; // 0x1937ec - g_ps2RecompiledFunctionTable[151034] = bhEne02_SetSandEffectMain_0x192d70; // 0x1937f0 - g_ps2RecompiledFunctionTable[151035] = bhEne02_SetSandEffectMain_0x192d70; // 0x1937f4 - g_ps2RecompiledFunctionTable[151036] = bhEne02_SetSandEffectMain_0x192d70; // 0x1937f8 - g_ps2RecompiledFunctionTable[151037] = bhEne02_SetSandEffectMain_0x192d70; // 0x1937fc - g_ps2RecompiledFunctionTable[151038] = bhEne02_SetSandEffectMain_0x192d70; // 0x193800 - g_ps2RecompiledFunctionTable[151039] = bhEne02_SetSandEffectMain_0x192d70; // 0x193804 - g_ps2RecompiledFunctionTable[151040] = bhEne02_SetSandEffectMain_0x192d70; // 0x193808 - g_ps2RecompiledFunctionTable[151041] = bhEne02_SetSandEffectMain_0x192d70; // 0x19380c - g_ps2RecompiledFunctionTable[151042] = bhEne02_SetSandEffectMain_0x192d70; // 0x193810 - g_ps2RecompiledFunctionTable[151043] = bhEne02_SetSandEffectMain_0x192d70; // 0x193814 - g_ps2RecompiledFunctionTable[151044] = bhEne02_SetSandEffectMain_0x192d70; // 0x193818 - g_ps2RecompiledFunctionTable[151045] = bhEne02_SetSandEffectMain_0x192d70; // 0x19381c - g_ps2RecompiledFunctionTable[151046] = bhEne02_SetSandEffectMain_0x192d70; // 0x193820 - g_ps2RecompiledFunctionTable[151047] = bhEne02_SetSandEffectMain_0x192d70; // 0x193824 - g_ps2RecompiledFunctionTable[151048] = bhEne02_SetSandEffectMain_0x192d70; // 0x193828 - g_ps2RecompiledFunctionTable[151049] = bhEne02_SetSandEffectMain_0x192d70; // 0x19382c - g_ps2RecompiledFunctionTable[151050] = bhEne02_SetSandEffectMain_0x192d70; // 0x193830 - g_ps2RecompiledFunctionTable[151051] = bhEne02_SetSandEffectMain_0x192d70; // 0x193834 - g_ps2RecompiledFunctionTable[151052] = bhEne02_SetSandEffectMain_0x192d70; // 0x193838 - g_ps2RecompiledFunctionTable[151053] = bhEne02_SetSandEffectMain_0x192d70; // 0x19383c - g_ps2RecompiledFunctionTable[151054] = bhEne02_SetSandEffectMain_0x192d70; // 0x193840 - g_ps2RecompiledFunctionTable[151055] = bhEne02_SetSandEffectMain_0x192d70; // 0x193844 - g_ps2RecompiledFunctionTable[151056] = bhEne02_SetSandEffectMain_0x192d70; // 0x193848 - g_ps2RecompiledFunctionTable[151057] = bhEne02_SetSandEffectMain_0x192d70; // 0x19384c - g_ps2RecompiledFunctionTable[151058] = bhEne02_SetSandEffectMain_0x192d70; // 0x193850 - g_ps2RecompiledFunctionTable[151059] = bhEne02_SetSandEffectMain_0x192d70; // 0x193854 - g_ps2RecompiledFunctionTable[151060] = bhEne02_SetSandEffectMain_0x192d70; // 0x193858 - g_ps2RecompiledFunctionTable[151061] = bhEne02_SetSandEffectMain_0x192d70; // 0x19385c - g_ps2RecompiledFunctionTable[151062] = bhEne02_SetSandEffectMain_0x192d70; // 0x193860 - g_ps2RecompiledFunctionTable[151063] = bhEne02_SetSandEffectMain_0x192d70; // 0x193864 - g_ps2RecompiledFunctionTable[151064] = bhEne02_SetSandEffectMain_0x192d70; // 0x193868 - g_ps2RecompiledFunctionTable[151065] = bhEne02_SetSandEffectMain_0x192d70; // 0x19386c - g_ps2RecompiledFunctionTable[151066] = bhEne02_SetSandEffectMain_0x192d70; // 0x193870 - g_ps2RecompiledFunctionTable[151067] = bhEne02_SetSandEffectMain_0x192d70; // 0x193874 - g_ps2RecompiledFunctionTable[151068] = bhEne02_SetSandEffectMain_0x192d70; // 0x193878 - g_ps2RecompiledFunctionTable[151069] = bhEne02_SetSandEffectMain_0x192d70; // 0x19387c - g_ps2RecompiledFunctionTable[151070] = bhEne02_SetSandEffectMain_0x192d70; // 0x193880 - g_ps2RecompiledFunctionTable[151071] = bhEne02_SetSandEffectMain_0x192d70; // 0x193884 - g_ps2RecompiledFunctionTable[151072] = bhEne02_SetSandEffectMain_0x192d70; // 0x193888 - g_ps2RecompiledFunctionTable[151073] = bhEne02_SetSandEffectMain_0x192d70; // 0x19388c - g_ps2RecompiledFunctionTable[151074] = bhEne02_SetSandEffectMain_0x192d70; // 0x193890 - g_ps2RecompiledFunctionTable[151075] = bhEne02_SetSandEffectMain_0x192d70; // 0x193894 - g_ps2RecompiledFunctionTable[151076] = bhEne02_SetSandEffectMain_0x192d70; // 0x193898 - g_ps2RecompiledFunctionTable[151077] = bhEne02_SetSandEffectMain_0x192d70; // 0x19389c - g_ps2RecompiledFunctionTable[151078] = bhEne02_SetSandEffectMain_0x192d70; // 0x1938a0 - g_ps2RecompiledFunctionTable[151079] = bhEne02_SetSandEffectMain_0x192d70; // 0x1938a4 - g_ps2RecompiledFunctionTable[151080] = bhEne02_SetSandEffectMain_0x192d70; // 0x1938a8 - g_ps2RecompiledFunctionTable[151081] = bhEne02_SetSandEffectMain_0x192d70; // 0x1938ac - g_ps2RecompiledFunctionTable[151082] = bhEne02_SetSandEffectMain_0x192d70; // 0x1938b0 - g_ps2RecompiledFunctionTable[151083] = bhEne02_SetSandEffectMain_0x192d70; // 0x1938b4 - g_ps2RecompiledFunctionTable[151084] = bhEne02_SetSandEffectMain_0x192d70; // 0x1938b8 - g_ps2RecompiledFunctionTable[151085] = bhEne02_SetSandEffectMain_0x192d70; // 0x1938bc - g_ps2RecompiledFunctionTable[151086] = bhEne02_SetSandEffectMain_0x192d70; // 0x1938c0 - g_ps2RecompiledFunctionTable[151087] = bhEne02_SetSandEffectMain_0x192d70; // 0x1938c4 - g_ps2RecompiledFunctionTable[151088] = bhEne02_SetSandEffectMain_0x192d70; // 0x1938c8 - g_ps2RecompiledFunctionTable[151089] = bhEne02_SetSandEffectMain_0x192d70; // 0x1938cc - g_ps2RecompiledFunctionTable[151090] = bhEne02_SetSandEffectMain_0x192d70; // 0x1938d0 - g_ps2RecompiledFunctionTable[151091] = bhEne02_SetSandEffectMain_0x192d70; // 0x1938d4 - g_ps2RecompiledFunctionTable[151092] = bhEne02_SetSandEffectMain_0x192d70; // 0x1938d8 - g_ps2RecompiledFunctionTable[151093] = bhEne02_SetSandEffectMain_0x192d70; // 0x1938dc - g_ps2RecompiledFunctionTable[151094] = bhEne02_SetSandEffectMain_0x192d70; // 0x1938e0 - g_ps2RecompiledFunctionTable[151095] = bhEne02_SetSandEffectMain_0x192d70; // 0x1938e4 - g_ps2RecompiledFunctionTable[151096] = bhEne02_SetSandEffectMain_0x192d70; // 0x1938e8 - g_ps2RecompiledFunctionTable[151097] = bhEne02_SetSandEffectMain_0x192d70; // 0x1938ec - g_ps2RecompiledFunctionTable[151098] = bhEne02_SetSandEffectMain_0x192d70; // 0x1938f0 - g_ps2RecompiledFunctionTable[151099] = bhEne02_SetSandEffectMain_0x192d70; // 0x1938f4 - g_ps2RecompiledFunctionTable[151100] = bhEne02_SetSandEffectMain_0x192d70; // 0x1938f8 - g_ps2RecompiledFunctionTable[151101] = bhEne02_SetSandEffectMain_0x192d70; // 0x1938fc - g_ps2RecompiledFunctionTable[151102] = bhEne02_SetSandEffectMain_0x192d70; // 0x193900 - g_ps2RecompiledFunctionTable[151103] = bhEne02_SetSandEffectMain_0x192d70; // 0x193904 - g_ps2RecompiledFunctionTable[151104] = bhEne02_SetSandEffectMain_0x192d70; // 0x193908 - g_ps2RecompiledFunctionTable[151105] = bhEne02_SetSandEffectMain_0x192d70; // 0x19390c - g_ps2RecompiledFunctionTable[151106] = bhEne02_SetSandEffectMain_0x192d70; // 0x193910 - g_ps2RecompiledFunctionTable[151107] = bhEne02_SetSandEffectMain_0x192d70; // 0x193914 - g_ps2RecompiledFunctionTable[151108] = bhEne02_SetSandEffectMain_0x192d70; // 0x193918 - g_ps2RecompiledFunctionTable[151109] = bhEne02_SetSandEffectMain_0x192d70; // 0x19391c - g_ps2RecompiledFunctionTable[151110] = bhEne02_SetSandEffectMain_0x192d70; // 0x193920 - g_ps2RecompiledFunctionTable[151111] = bhEne02_SetSandEffectMain_0x192d70; // 0x193924 - g_ps2RecompiledFunctionTable[151112] = bhEne02_SetSandEffectMain_0x192d70; // 0x193928 - g_ps2RecompiledFunctionTable[151113] = bhEne02_SetSandEffectMain_0x192d70; // 0x19392c - g_ps2RecompiledFunctionTable[151114] = bhEne02_SetSandEffectMain_0x192d70; // 0x193930 - g_ps2RecompiledFunctionTable[151115] = bhEne02_SetSandEffectMain_0x192d70; // 0x193934 - g_ps2RecompiledFunctionTable[151116] = bhEne02_SetSandEffectMain_0x192d70; // 0x193938 - g_ps2RecompiledFunctionTable[151117] = bhEne02_SetSandEffectMain_0x192d70; // 0x19393c - g_ps2RecompiledFunctionTable[151118] = bhEne02_SetSandEffectMain_0x192d70; // 0x193940 - g_ps2RecompiledFunctionTable[151119] = bhEne02_SetSandEffectMain_0x192d70; // 0x193944 - g_ps2RecompiledFunctionTable[151120] = bhEne02_SetSandEffectMain_0x192d70; // 0x193948 - g_ps2RecompiledFunctionTable[151121] = bhEne02_SetSandEffectMain_0x192d70; // 0x19394c - g_ps2RecompiledFunctionTable[151122] = bhEne02_SetSandEffectMain_0x192d70; // 0x193950 - g_ps2RecompiledFunctionTable[151123] = bhEne02_SetSandEffectMain_0x192d70; // 0x193954 - g_ps2RecompiledFunctionTable[151124] = bhEne02_SetSandEffectMain_0x192d70; // 0x193958 - g_ps2RecompiledFunctionTable[151125] = bhEne02_SetSandEffectMain_0x192d70; // 0x19395c - g_ps2RecompiledFunctionTable[151126] = bhEne02_SetSandEffectMain_0x192d70; // 0x193960 - g_ps2RecompiledFunctionTable[151127] = bhEne02_SetSandEffectMain_0x192d70; // 0x193964 - g_ps2RecompiledFunctionTable[151128] = bhEne02_SetSandEffectMain_0x192d70; // 0x193968 - g_ps2RecompiledFunctionTable[151129] = bhEne02_SetSandEffectMain_0x192d70; // 0x19396c - g_ps2RecompiledFunctionTable[151130] = bhEne02_SetSandEffectMain_0x192d70; // 0x193970 - g_ps2RecompiledFunctionTable[151131] = bhEne02_SetSandEffectMain_0x192d70; // 0x193974 - g_ps2RecompiledFunctionTable[151132] = bhEne02_SetSandEffectMain_0x192d70; // 0x193978 - g_ps2RecompiledFunctionTable[151133] = bhEne02_SetSandEffectMain_0x192d70; // 0x19397c - g_ps2RecompiledFunctionTable[151134] = bhEne02_SetSandEffectMain_0x192d70; // 0x193980 - g_ps2RecompiledFunctionTable[151135] = bhEne02_SetSandEffectMain_0x192d70; // 0x193984 - g_ps2RecompiledFunctionTable[151136] = bhEne02_SetSandEffectMain_0x192d70; // 0x193988 - g_ps2RecompiledFunctionTable[151137] = bhEne02_SetSandEffectMain_0x192d70; // 0x19398c - g_ps2RecompiledFunctionTable[151138] = bhEne02_SetSandEffectMain_0x192d70; // 0x193990 - g_ps2RecompiledFunctionTable[151139] = bhEne02_SetSandEffectMain_0x192d70; // 0x193994 - g_ps2RecompiledFunctionTable[151140] = bhEne02_SetSandEffectMain_0x192d70; // 0x193998 - g_ps2RecompiledFunctionTable[151141] = bhEne02_SetSandEffectMain_0x192d70; // 0x19399c - g_ps2RecompiledFunctionTable[151142] = bhEne02_SetSandEffectMain_0x192d70; // 0x1939a0 - g_ps2RecompiledFunctionTable[151143] = bhEne02_SetSandEffectMain_0x192d70; // 0x1939a4 - g_ps2RecompiledFunctionTable[151144] = bhEne02_SetSandEffectMain_0x192d70; // 0x1939a8 - g_ps2RecompiledFunctionTable[151145] = bhEne02_SetSandEffectMain_0x192d70; // 0x1939ac - g_ps2RecompiledFunctionTable[151146] = bhEne02_SetSandEffectMain_0x192d70; // 0x1939b0 - g_ps2RecompiledFunctionTable[151147] = bhEne02_SetSandEffectMain_0x192d70; // 0x1939b4 - g_ps2RecompiledFunctionTable[151148] = bhEne02_SetSandEffectMain_0x192d70; // 0x1939b8 - g_ps2RecompiledFunctionTable[151149] = bhEne02_SetSandEffectMain_0x192d70; // 0x1939bc - g_ps2RecompiledFunctionTable[151150] = bhEne02_SetSandEffectMain_0x192d70; // 0x1939c0 - g_ps2RecompiledFunctionTable[151151] = bhEne02_SetSandEffectMain_0x192d70; // 0x1939c4 - g_ps2RecompiledFunctionTable[151152] = bhEne02_SetSandEffectMain_0x192d70; // 0x1939c8 - g_ps2RecompiledFunctionTable[151153] = bhEne02_SetSandEffectMain_0x192d70; // 0x1939cc - g_ps2RecompiledFunctionTable[151154] = bhEne02_SetSandEffectMain_0x192d70; // 0x1939d0 - g_ps2RecompiledFunctionTable[151155] = bhEne02_SetSandEffectMain_0x192d70; // 0x1939d4 - g_ps2RecompiledFunctionTable[151156] = bhEne02_SetSandEffectMain_0x192d70; // 0x1939d8 - g_ps2RecompiledFunctionTable[151157] = bhEne02_SetSandEffectMain_0x192d70; // 0x1939dc - g_ps2RecompiledFunctionTable[151158] = bhEne02_SetSandEffectMain_0x192d70; // 0x1939e0 - g_ps2RecompiledFunctionTable[151159] = bhEne02_SetSandEffectMain_0x192d70; // 0x1939e4 - g_ps2RecompiledFunctionTable[151160] = bhEne02_SetSandEffectMain_0x192d70; // 0x1939e8 - g_ps2RecompiledFunctionTable[151161] = bhEne02_SetSandEffectMain_0x192d70; // 0x1939ec - g_ps2RecompiledFunctionTable[151162] = bhEne02_SetSandEffectMain_0x192d70; // 0x1939f0 - g_ps2RecompiledFunctionTable[151163] = bhEne02_SetSandEffectMain_0x192d70; // 0x1939f4 - g_ps2RecompiledFunctionTable[151164] = bhEne02_SetSandEffectMain_0x192d70; // 0x1939f8 - g_ps2RecompiledFunctionTable[151165] = bhEne02_SetSandEffectMain_0x192d70; // 0x1939fc - g_ps2RecompiledFunctionTable[151166] = bhEne02_SetSandEffectMain_0x192d70; // 0x193a00 - g_ps2RecompiledFunctionTable[151167] = bhEne02_SetSandEffectMain_0x192d70; // 0x193a04 - g_ps2RecompiledFunctionTable[151168] = bhEne02_SetSandEffectMain_0x192d70; // 0x193a08 - g_ps2RecompiledFunctionTable[151169] = bhEne02_SetSandEffectMain_0x192d70; // 0x193a0c - g_ps2RecompiledFunctionTable[151170] = bhEne02_SetSandEffectMain_0x192d70; // 0x193a10 - g_ps2RecompiledFunctionTable[151171] = bhEne02_SetSandEffectMain_0x192d70; // 0x193a14 - g_ps2RecompiledFunctionTable[151172] = bhEne02_SetSandEffectMain_0x192d70; // 0x193a18 - g_ps2RecompiledFunctionTable[151173] = bhEne02_SetSandEffectMain_0x192d70; // 0x193a1c - g_ps2RecompiledFunctionTable[151174] = bhEne02_SetSandEffectMain_0x192d70; // 0x193a20 - g_ps2RecompiledFunctionTable[151175] = bhEne02_SetSandEffectMain_0x192d70; // 0x193a24 - g_ps2RecompiledFunctionTable[151176] = bhEne02_SetSandEffectMain_0x192d70; // 0x193a28 - g_ps2RecompiledFunctionTable[151177] = bhEne02_SetSandEffectMain_0x192d70; // 0x193a2c - g_ps2RecompiledFunctionTable[151178] = bhEne02_SetSandEffectMain_0x192d70; // 0x193a30 - g_ps2RecompiledFunctionTable[151179] = bhEne02_SetSandEffectMain_0x192d70; // 0x193a34 - g_ps2RecompiledFunctionTable[151180] = bhEne02_SetSandEffectMain_0x192d70; // 0x193a38 - g_ps2RecompiledFunctionTable[151181] = bhEne02_SetSandEffectMain_0x192d70; // 0x193a3c - g_ps2RecompiledFunctionTable[151182] = bhEne02_SetSandEffectMain_0x192d70; // 0x193a40 - g_ps2RecompiledFunctionTable[151183] = bhEne02_SetSandEffectMain_0x192d70; // 0x193a44 - g_ps2RecompiledFunctionTable[151184] = bhEne02_SetSandEffectMain_0x192d70; // 0x193a48 - g_ps2RecompiledFunctionTable[151185] = bhEne02_SetSandEffectMain_0x192d70; // 0x193a4c - g_ps2RecompiledFunctionTable[151186] = bhEne02_SetSandEffectMain_0x192d70; // 0x193a50 - g_ps2RecompiledFunctionTable[151187] = bhEne02_SetSandEffectMain_0x192d70; // 0x193a54 - g_ps2RecompiledFunctionTable[151188] = bhEne02_SetSandEffectMain_0x192d70; // 0x193a58 - g_ps2RecompiledFunctionTable[151189] = bhEne02_SetSandEffectMain_0x192d70; // 0x193a5c - g_ps2RecompiledFunctionTable[151190] = bhEne02_SetSandEffectMain_0x192d70; // 0x193a60 - g_ps2RecompiledFunctionTable[151191] = bhEne02_SetSandEffectMain_0x192d70; // 0x193a64 - g_ps2RecompiledFunctionTable[151192] = bhEne02_SetSandEffectMain_0x192d70; // 0x193a68 - g_ps2RecompiledFunctionTable[151193] = bhEne02_SetSandEffectMain_0x192d70; // 0x193a6c - g_ps2RecompiledFunctionTable[151194] = bhEne02_SetSandEffectMain_0x192d70; // 0x193a70 - g_ps2RecompiledFunctionTable[151195] = bhEne02_SetSandEffectMain_0x192d70; // 0x193a74 - g_ps2RecompiledFunctionTable[151196] = bhEne02_SetSandEffectMain_0x192d70; // 0x193a78 - g_ps2RecompiledFunctionTable[151197] = bhEne02_SetSandEffectMain_0x192d70; // 0x193a7c - g_ps2RecompiledFunctionTable[151198] = bhEne02_SetSandEffectMain_0x192d70; // 0x193a80 - g_ps2RecompiledFunctionTable[151199] = bhEne02_SetSandEffectMain_0x192d70; // 0x193a84 - g_ps2RecompiledFunctionTable[151200] = bhEne02_SetSandEffectMain_0x192d70; // 0x193a88 - g_ps2RecompiledFunctionTable[151201] = bhEne02_SetSandEffectMain_0x192d70; // 0x193a8c - g_ps2RecompiledFunctionTable[151202] = bhEne02_SetSandEffectMain_0x192d70; // 0x193a90 - g_ps2RecompiledFunctionTable[151203] = bhEne02_SetSandEffectMain_0x192d70; // 0x193a94 - g_ps2RecompiledFunctionTable[151204] = bhEne02_SetSandEffectMain_0x192d70; // 0x193a98 - g_ps2RecompiledFunctionTable[151205] = bhEne02_SetSandEffectMain_0x192d70; // 0x193a9c - g_ps2RecompiledFunctionTable[151206] = bhEne02_SetSandEffectMain_0x192d70; // 0x193aa0 - g_ps2RecompiledFunctionTable[151207] = bhEne02_SetSandEffectMain_0x192d70; // 0x193aa4 - g_ps2RecompiledFunctionTable[151208] = bhEne02_SetSandEffectMain_0x192d70; // 0x193aa8 - g_ps2RecompiledFunctionTable[151209] = bhEne02_SetSandEffectMain_0x192d70; // 0x193aac - g_ps2RecompiledFunctionTable[151210] = bhEne02_SetSandEffectMain_0x192d70; // 0x193ab0 - g_ps2RecompiledFunctionTable[151211] = bhEne02_SetSandEffectMain_0x192d70; // 0x193ab4 - g_ps2RecompiledFunctionTable[151212] = bhEne02_SetSandEffectMain_0x192d70; // 0x193ab8 - g_ps2RecompiledFunctionTable[151213] = bhEne02_SetSandEffectMain_0x192d70; // 0x193abc - g_ps2RecompiledFunctionTable[151214] = bhEne02_SetSandEffectMain_0x192d70; // 0x193ac0 - g_ps2RecompiledFunctionTable[151215] = bhEne02_SetSandEffectMain_0x192d70; // 0x193ac4 - g_ps2RecompiledFunctionTable[151216] = bhEne02_SetSandEffectMain_0x192d70; // 0x193ac8 - g_ps2RecompiledFunctionTable[151217] = bhEne02_SetSandEffectMain_0x192d70; // 0x193acc - g_ps2RecompiledFunctionTable[151218] = bhEne02_SetSandEffectMain_0x192d70; // 0x193ad0 - g_ps2RecompiledFunctionTable[151219] = bhEne02_SetSandEffectMain_0x192d70; // 0x193ad4 - g_ps2RecompiledFunctionTable[151220] = bhEne02_SetSandEffectMain_0x192d70; // 0x193ad8 - g_ps2RecompiledFunctionTable[151221] = bhEne02_SetSandEffectMain_0x192d70; // 0x193adc - g_ps2RecompiledFunctionTable[151222] = bhEne02_SetSandEffectMain_0x192d70; // 0x193ae0 - g_ps2RecompiledFunctionTable[151223] = bhEne02_SetSandEffectMain_0x192d70; // 0x193ae4 - g_ps2RecompiledFunctionTable[151224] = bhEne02_SetSandEffectMain_0x192d70; // 0x193ae8 - g_ps2RecompiledFunctionTable[151225] = bhEne02_SetSandEffectMain_0x192d70; // 0x193aec - g_ps2RecompiledFunctionTable[151226] = bhEne02_SetSandEffectMain_0x192d70; // 0x193af0 - g_ps2RecompiledFunctionTable[151227] = bhEne02_SetSandEffectMain_0x192d70; // 0x193af4 - g_ps2RecompiledFunctionTable[151228] = bhEne02_SetSandEffectMain_0x192d70; // 0x193af8 - g_ps2RecompiledFunctionTable[151229] = bhEne02_SetSandEffectMain_0x192d70; // 0x193afc - g_ps2RecompiledFunctionTable[151230] = bhEne02_SetSandEffectMain_0x192d70; // 0x193b00 - g_ps2RecompiledFunctionTable[151231] = bhEne02_SetSandEffectMain_0x192d70; // 0x193b04 - g_ps2RecompiledFunctionTable[151232] = bhEne02_SetSandEffectMain_0x192d70; // 0x193b08 - g_ps2RecompiledFunctionTable[151233] = bhEne02_SetSandEffectMain_0x192d70; // 0x193b0c - g_ps2RecompiledFunctionTable[151234] = bhEne02_SetSandEffectMain_0x192d70; // 0x193b10 - g_ps2RecompiledFunctionTable[151235] = bhEne02_SetSandEffectMain_0x192d70; // 0x193b14 - g_ps2RecompiledFunctionTable[151236] = bhEne02_SetSandEffectMain_0x192d70; // 0x193b18 - g_ps2RecompiledFunctionTable[151237] = bhEne02_SetSandEffectMain_0x192d70; // 0x193b1c - g_ps2RecompiledFunctionTable[151238] = bhEne02_SetSandEffectMain_0x192d70; // 0x193b20 - g_ps2RecompiledFunctionTable[151239] = bhEne02_SetSandEffectMain_0x192d70; // 0x193b24 - g_ps2RecompiledFunctionTable[151240] = bhEne02_SetSandEffectMain_0x192d70; // 0x193b28 - g_ps2RecompiledFunctionTable[151241] = bhEne02_SetSandEffectMain_0x192d70; // 0x193b2c - g_ps2RecompiledFunctionTable[151242] = bhEne02_SetSandEffectMain_0x192d70; // 0x193b30 - g_ps2RecompiledFunctionTable[151243] = bhEne02_SetSandEffectMain_0x192d70; // 0x193b34 - g_ps2RecompiledFunctionTable[151244] = bhEne02_SetSandEffectMain_0x192d70; // 0x193b38 - g_ps2RecompiledFunctionTable[151245] = bhEne02_SetSandEffectMain_0x192d70; // 0x193b3c - g_ps2RecompiledFunctionTable[151246] = bhEne02_SetSandEffectMain_0x192d70; // 0x193b40 - g_ps2RecompiledFunctionTable[151247] = bhEne02_SetSandEffectMain_0x192d70; // 0x193b44 - g_ps2RecompiledFunctionTable[151248] = bhEne02_SetSandEffectMain_0x192d70; // 0x193b48 - g_ps2RecompiledFunctionTable[151249] = bhEne02_SetSandEffectMain_0x192d70; // 0x193b4c - g_ps2RecompiledFunctionTable[151250] = bhEne02_SetSandEffectMain_0x192d70; // 0x193b50 - g_ps2RecompiledFunctionTable[151251] = bhEne02_SetSandEffectMain_0x192d70; // 0x193b54 - g_ps2RecompiledFunctionTable[151252] = bhEne02_SetSandEffectMain_0x192d70; // 0x193b58 - g_ps2RecompiledFunctionTable[151253] = bhEne02_SetSandEffectMain_0x192d70; // 0x193b5c - g_ps2RecompiledFunctionTable[151254] = bhEne02_SetSandEffectMain_0x192d70; // 0x193b60 - g_ps2RecompiledFunctionTable[151255] = bhEne02_SetSandEffectMain_0x192d70; // 0x193b64 - g_ps2RecompiledFunctionTable[151256] = bhEne02_SetSandEffectMain_0x192d70; // 0x193b68 - g_ps2RecompiledFunctionTable[151257] = bhEne02_SetSandEffectMain_0x192d70; // 0x193b6c - g_ps2RecompiledFunctionTable[151258] = bhEne02_SetSandEffectMain_0x192d70; // 0x193b70 - g_ps2RecompiledFunctionTable[151259] = bhEne02_SetSandEffectMain_0x192d70; // 0x193b74 - g_ps2RecompiledFunctionTable[151260] = bhEne02_SetSandEffectMain_0x192d70; // 0x193b78 - g_ps2RecompiledFunctionTable[151261] = bhEne02_SetSandEffectMain_0x192d70; // 0x193b7c - g_ps2RecompiledFunctionTable[151262] = bhEne02_SetSandEffectMain_0x192d70; // 0x193b80 - g_ps2RecompiledFunctionTable[151263] = bhEne02_SetSandEffectMain_0x192d70; // 0x193b84 - g_ps2RecompiledFunctionTable[151264] = bhEne02_SetSandEffectMain_0x192d70; // 0x193b88 - g_ps2RecompiledFunctionTable[151265] = bhEne02_SetSandEffectMain_0x192d70; // 0x193b8c - g_ps2RecompiledFunctionTable[151266] = bhEne02_SetSandEffectMain_0x192d70; // 0x193b90 - g_ps2RecompiledFunctionTable[151267] = bhEne02_SetSandEffectMain_0x192d70; // 0x193b94 - g_ps2RecompiledFunctionTable[151268] = bhEne02_SetSandEffectMain_0x192d70; // 0x193b98 - g_ps2RecompiledFunctionTable[151269] = bhEne02_SetSandEffectMain_0x192d70; // 0x193b9c - g_ps2RecompiledFunctionTable[151270] = bhEne02_SetSandEffectMain_0x192d70; // 0x193ba0 - g_ps2RecompiledFunctionTable[151271] = bhEne02_SetSandEffectMain_0x192d70; // 0x193ba4 - g_ps2RecompiledFunctionTable[151272] = bhEne02_SetSandEffectMain_0x192d70; // 0x193ba8 - g_ps2RecompiledFunctionTable[151273] = bhEne02_SetSandEffectMain_0x192d70; // 0x193bac - g_ps2RecompiledFunctionTable[151274] = bhEne02_SetSandEffectMain_0x192d70; // 0x193bb0 - g_ps2RecompiledFunctionTable[151275] = bhEne02_SetSandEffectMain_0x192d70; // 0x193bb4 - g_ps2RecompiledFunctionTable[151276] = bhEne02_SetSandEffectMain_0x192d70; // 0x193bb8 - g_ps2RecompiledFunctionTable[151277] = bhEne02_SetSandEffectMain_0x192d70; // 0x193bbc - g_ps2RecompiledFunctionTable[151278] = bhEne02_SetSandEffectMain_0x192d70; // 0x193bc0 - g_ps2RecompiledFunctionTable[151279] = bhEne02_SetSandEffectMain_0x192d70; // 0x193bc4 - g_ps2RecompiledFunctionTable[151280] = bhEne02_SetSandEffectMain_0x192d70; // 0x193bc8 - g_ps2RecompiledFunctionTable[151281] = bhEne02_SetSandEffectMain_0x192d70; // 0x193bcc - g_ps2RecompiledFunctionTable[151282] = bhEne02_SetSandEffectMain_0x192d70; // 0x193bd0 - g_ps2RecompiledFunctionTable[151283] = bhEne02_SetSandEffectMain_0x192d70; // 0x193bd4 - g_ps2RecompiledFunctionTable[151284] = bhEne02_SetSandEffectMain_0x192d70; // 0x193bd8 - g_ps2RecompiledFunctionTable[151285] = bhEne02_SetSandEffectMain_0x192d70; // 0x193bdc - g_ps2RecompiledFunctionTable[151286] = bhEne02_SetSandEffectMain_0x192d70; // 0x193be0 - g_ps2RecompiledFunctionTable[151287] = bhEne02_SetSandEffectMain_0x192d70; // 0x193be4 - g_ps2RecompiledFunctionTable[151288] = bhEne02_SetSandEffectMain_0x192d70; // 0x193be8 - g_ps2RecompiledFunctionTable[151289] = bhEne02_SetSandEffectMain_0x192d70; // 0x193bec - g_ps2RecompiledFunctionTable[151290] = bhEne02_SetSandEffectMain_0x192d70; // 0x193bf0 - g_ps2RecompiledFunctionTable[151291] = bhEne02_SetSandEffectMain_0x192d70; // 0x193bf4 - g_ps2RecompiledFunctionTable[151292] = bhEne02_SetSandEffectMain_0x192d70; // 0x193bf8 - g_ps2RecompiledFunctionTable[151293] = bhEne02_SetSandEffectMain_0x192d70; // 0x193bfc - g_ps2RecompiledFunctionTable[151294] = bhEne02_SetSandEffectMain_0x192d70; // 0x193c00 - g_ps2RecompiledFunctionTable[151295] = bhEne02_SetSandEffectMain_0x192d70; // 0x193c04 - g_ps2RecompiledFunctionTable[151296] = bhEne02_SetSandEffectMain_0x192d70; // 0x193c08 - g_ps2RecompiledFunctionTable[151297] = bhEne02_SetSandEffectMain_0x192d70; // 0x193c0c - g_ps2RecompiledFunctionTable[151298] = bhEne02_SetSandEffectMain_0x192d70; // 0x193c10 - g_ps2RecompiledFunctionTable[151299] = bhEne02_SetSandEffectMain_0x192d70; // 0x193c14 - g_ps2RecompiledFunctionTable[151300] = bhEne02_SetSandEffectMain_0x192d70; // 0x193c18 - g_ps2RecompiledFunctionTable[151301] = bhEne02_SetSandEffectMain_0x192d70; // 0x193c1c - g_ps2RecompiledFunctionTable[151302] = bhEne02_SetSandEffectMain_0x192d70; // 0x193c20 - g_ps2RecompiledFunctionTable[151303] = bhEne02_SetSandEffectMain_0x192d70; // 0x193c24 - g_ps2RecompiledFunctionTable[151304] = bhEne02_SetSandEffectMain_0x192d70; // 0x193c28 - g_ps2RecompiledFunctionTable[151305] = bhEne02_SetSandEffectMain_0x192d70; // 0x193c2c - g_ps2RecompiledFunctionTable[151306] = bhEne02_SetSandEffectMain_0x192d70; // 0x193c30 - g_ps2RecompiledFunctionTable[151307] = bhEne02_SetSandEffectMain_0x192d70; // 0x193c34 - g_ps2RecompiledFunctionTable[151308] = bhEne02_SetSandEffectMain_0x192d70; // 0x193c38 - g_ps2RecompiledFunctionTable[151309] = bhEne02_SetSandEffectMain_0x192d70; // 0x193c3c - g_ps2RecompiledFunctionTable[151310] = bhEne02_SetSandEffectMain_0x192d70; // 0x193c40 - g_ps2RecompiledFunctionTable[151311] = bhEne02_SetSandEffectMain_0x192d70; // 0x193c44 - g_ps2RecompiledFunctionTable[151312] = bhEne02_SetSandEffectMain_0x192d70; // 0x193c48 - g_ps2RecompiledFunctionTable[151313] = bhEne02_SetSandEffectMain_0x192d70; // 0x193c4c - g_ps2RecompiledFunctionTable[151314] = bhEne02_SetSandEffectMain_0x192d70; // 0x193c50 - g_ps2RecompiledFunctionTable[151315] = bhEne02_SetSandEffectMain_0x192d70; // 0x193c54 - g_ps2RecompiledFunctionTable[151316] = bhEne02_SetSandEffectMain_0x192d70; // 0x193c58 - g_ps2RecompiledFunctionTable[151317] = bhEne02_SetSandEffectMain_0x192d70; // 0x193c5c - g_ps2RecompiledFunctionTable[151318] = bhEne02_SetSandEffectMain_0x192d70; // 0x193c60 - g_ps2RecompiledFunctionTable[151319] = bhEne02_SetSandEffectMain_0x192d70; // 0x193c64 - g_ps2RecompiledFunctionTable[151320] = bhEne02_SetSandEffectMain_0x192d70; // 0x193c68 - g_ps2RecompiledFunctionTable[151321] = bhEne02_SetSandEffectMain_0x192d70; // 0x193c6c - g_ps2RecompiledFunctionTable[151322] = bhEne02_SetSandEffectMain_0x192d70; // 0x193c70 - g_ps2RecompiledFunctionTable[151323] = bhEne02_SetSandEffectMain_0x192d70; // 0x193c74 - g_ps2RecompiledFunctionTable[151324] = bhEne02_SetSandEffectMain_0x192d70; // 0x193c78 - g_ps2RecompiledFunctionTable[151325] = bhEne02_SetSandEffectMain_0x192d70; // 0x193c7c - g_ps2RecompiledFunctionTable[151326] = bhEne02_SetSandEffectMain_0x192d70; // 0x193c80 - g_ps2RecompiledFunctionTable[151327] = bhEne02_SetSandEffectMain_0x192d70; // 0x193c84 - g_ps2RecompiledFunctionTable[151328] = bhEne02_SetSandEffectMain_0x192d70; // 0x193c88 - g_ps2RecompiledFunctionTable[151329] = bhEne02_SetSandEffectMain_0x192d70; // 0x193c8c - g_ps2RecompiledFunctionTable[151330] = bhEne02_SetSandEffectMain_0x192d70; // 0x193c90 - g_ps2RecompiledFunctionTable[151331] = bhEne02_SetSandEffectMain_0x192d70; // 0x193c94 - g_ps2RecompiledFunctionTable[151332] = bhEne02_SetSandEffectMain_0x192d70; // 0x193c98 - g_ps2RecompiledFunctionTable[151333] = bhEne02_SetSandEffectMain_0x192d70; // 0x193c9c - g_ps2RecompiledFunctionTable[151334] = bhEne02_SetSandEffectMain_0x192d70; // 0x193ca0 - g_ps2RecompiledFunctionTable[151335] = bhEne02_SetSandEffectMain_0x192d70; // 0x193ca4 - g_ps2RecompiledFunctionTable[151336] = bhEne02_SetSandEffectMain_0x192d70; // 0x193ca8 - g_ps2RecompiledFunctionTable[151337] = bhEne02_SetSandEffectMain_0x192d70; // 0x193cac - g_ps2RecompiledFunctionTable[151338] = bhEne02_SetSandEffectMain_0x192d70; // 0x193cb0 - g_ps2RecompiledFunctionTable[151339] = bhEne02_SetSandEffectMain_0x192d70; // 0x193cb4 - g_ps2RecompiledFunctionTable[151340] = bhEne02_SetSandEffectMain_0x192d70; // 0x193cb8 - g_ps2RecompiledFunctionTable[151341] = bhEne02_SetSandEffectMain_0x192d70; // 0x193cbc - g_ps2RecompiledFunctionTable[151342] = bhEne02_SetSandEffectMain_0x192d70; // 0x193cc0 - g_ps2RecompiledFunctionTable[151343] = bhEne02_SetSandEffectMain_0x192d70; // 0x193cc4 - g_ps2RecompiledFunctionTable[151344] = bhEne02_SetSandEffectMain_0x192d70; // 0x193cc8 - g_ps2RecompiledFunctionTable[151345] = bhEne02_SetSandEffectMain_0x192d70; // 0x193ccc - g_ps2RecompiledFunctionTable[151346] = bhEne02_SetSandEffectMain_0x192d70; // 0x193cd0 - g_ps2RecompiledFunctionTable[151347] = bhEne02_SetSandEffectMain_0x192d70; // 0x193cd4 - g_ps2RecompiledFunctionTable[151348] = bhEne02_SetSandEffectMain_0x192d70; // 0x193cd8 - g_ps2RecompiledFunctionTable[151349] = bhEne02_SetSandEffectMain_0x192d70; // 0x193cdc - g_ps2RecompiledFunctionTable[151350] = bhEne02_SetSandEffectMain_0x192d70; // 0x193ce0 - g_ps2RecompiledFunctionTable[151351] = bhEne02_SetSandEffectMain_0x192d70; // 0x193ce4 - g_ps2RecompiledFunctionTable[151352] = bhEne02_SetSandEffectMain_0x192d70; // 0x193ce8 - g_ps2RecompiledFunctionTable[151353] = bhEne02_SetSandEffectMain_0x192d70; // 0x193cec - g_ps2RecompiledFunctionTable[151354] = bhEne02_SetSandEffectMain_0x192d70; // 0x193cf0 - g_ps2RecompiledFunctionTable[151355] = bhEne02_SetSandEffectMain_0x192d70; // 0x193cf4 - g_ps2RecompiledFunctionTable[151356] = bhEne02_SetSandEffectMain_0x192d70; // 0x193cf8 - g_ps2RecompiledFunctionTable[151357] = bhEne02_SetSandEffectMain_0x192d70; // 0x193cfc - g_ps2RecompiledFunctionTable[151358] = bhEne02_SetSandEffectMain_0x192d70; // 0x193d00 - g_ps2RecompiledFunctionTable[151359] = bhEne02_SetSandEffectMain_0x192d70; // 0x193d04 - g_ps2RecompiledFunctionTable[151360] = bhEne02_SetSandEffectMain_0x192d70; // 0x193d08 - g_ps2RecompiledFunctionTable[151361] = bhEne02_SetSandEffectMain_0x192d70; // 0x193d0c - g_ps2RecompiledFunctionTable[151362] = bhEne02_SetSandEffectMain_0x192d70; // 0x193d10 - g_ps2RecompiledFunctionTable[151363] = bhEne02_SetSandEffectMain_0x192d70; // 0x193d14 - g_ps2RecompiledFunctionTable[151364] = bhEne02_SetSandEffectMain_0x192d70; // 0x193d18 - g_ps2RecompiledFunctionTable[151365] = bhEne02_SetSandEffectMain_0x192d70; // 0x193d1c - g_ps2RecompiledFunctionTable[151366] = bhEne02_SetSandEffectMain_0x192d70; // 0x193d20 - g_ps2RecompiledFunctionTable[151367] = bhEne02_SetSandEffectMain_0x192d70; // 0x193d24 - g_ps2RecompiledFunctionTable[151368] = bhEne02_SetSandEffectMain_0x192d70; // 0x193d28 - g_ps2RecompiledFunctionTable[151369] = bhEne02_SetSandEffectMain_0x192d70; // 0x193d2c - g_ps2RecompiledFunctionTable[151370] = bhEne02_SetSandEffectMain_0x192d70; // 0x193d30 - g_ps2RecompiledFunctionTable[151371] = bhEne02_SetSandEffectMain_0x192d70; // 0x193d34 - g_ps2RecompiledFunctionTable[151372] = bhEne02_SetSandEffectMain_0x192d70; // 0x193d38 - g_ps2RecompiledFunctionTable[151373] = bhEne02_SetSandEffectMain_0x192d70; // 0x193d3c - g_ps2RecompiledFunctionTable[151374] = bhEne02_SetSandEffectMain_0x192d70; // 0x193d40 - g_ps2RecompiledFunctionTable[151375] = bhEne02_SetSandEffectMain_0x192d70; // 0x193d44 - g_ps2RecompiledFunctionTable[151376] = bhEne02_SetSandEffectMain_0x192d70; // 0x193d48 - g_ps2RecompiledFunctionTable[151377] = bhEne02_SetSandEffectMain_0x192d70; // 0x193d4c - g_ps2RecompiledFunctionTable[151378] = bhEne02_SetSandEffectMain_0x192d70; // 0x193d50 - g_ps2RecompiledFunctionTable[151379] = bhEne02_SetSandEffectMain_0x192d70; // 0x193d54 - g_ps2RecompiledFunctionTable[151380] = bhEne02_SetSandEffectMain_0x192d70; // 0x193d58 - g_ps2RecompiledFunctionTable[151381] = bhEne02_SetSandEffectMain_0x192d70; // 0x193d5c - g_ps2RecompiledFunctionTable[151382] = bhEne02_SetSandEffectMain_0x192d70; // 0x193d60 - g_ps2RecompiledFunctionTable[151383] = bhEne02_SetSandEffectMain_0x192d70; // 0x193d64 - g_ps2RecompiledFunctionTable[151384] = bhEne02_SetSandEffectMain_0x192d70; // 0x193d68 - g_ps2RecompiledFunctionTable[151385] = bhEne02_SetSandEffectMain_0x192d70; // 0x193d6c - g_ps2RecompiledFunctionTable[151386] = bhEne02_SetSandEffectMain_0x192d70; // 0x193d70 - g_ps2RecompiledFunctionTable[151387] = bhEne02_SetSandEffectMain_0x192d70; // 0x193d74 - g_ps2RecompiledFunctionTable[151388] = bhEne02_SetSandEffectMain_0x192d70; // 0x193d78 - g_ps2RecompiledFunctionTable[151389] = bhEne02_SetSandEffectMain_0x192d70; // 0x193d7c - g_ps2RecompiledFunctionTable[151390] = bhEne02_SetSandEffectMain_0x192d70; // 0x193d80 - g_ps2RecompiledFunctionTable[151391] = bhEne02_SetSandEffectMain_0x192d70; // 0x193d84 - g_ps2RecompiledFunctionTable[151392] = bhEne02_SetSandEffectMain_0x192d70; // 0x193d88 - g_ps2RecompiledFunctionTable[151393] = bhEne02_SetSandEffectMain_0x192d70; // 0x193d8c - g_ps2RecompiledFunctionTable[151394] = bhEne02_SetSandEffectMain_0x192d70; // 0x193d90 - g_ps2RecompiledFunctionTable[151395] = bhEne02_SetSandEffectMain_0x192d70; // 0x193d94 - g_ps2RecompiledFunctionTable[151396] = bhEne02_SetSandEffectMain_0x192d70; // 0x193d98 - g_ps2RecompiledFunctionTable[151397] = bhEne02_SetSandEffectMain_0x192d70; // 0x193d9c - g_ps2RecompiledFunctionTable[151398] = bhEne02_SetSandEffectMain_0x192d70; // 0x193da0 - g_ps2RecompiledFunctionTable[151399] = bhEne02_SetSandEffectMain_0x192d70; // 0x193da4 - g_ps2RecompiledFunctionTable[151400] = bhEne02_SetSandEffectMain_0x192d70; // 0x193da8 - g_ps2RecompiledFunctionTable[151401] = bhEne02_SetSandEffectMain_0x192d70; // 0x193dac - g_ps2RecompiledFunctionTable[151402] = bhEne02_SetSandEffectMain_0x192d70; // 0x193db0 - g_ps2RecompiledFunctionTable[151403] = bhEne02_SetSandEffectMain_0x192d70; // 0x193db4 - g_ps2RecompiledFunctionTable[151404] = bhEne02_SetSandEffectMain_0x192d70; // 0x193db8 - g_ps2RecompiledFunctionTable[151405] = bhEne02_SetSandEffectMain_0x192d70; // 0x193dbc - g_ps2RecompiledFunctionTable[151406] = bhEne02_SetSandEffectMain_0x192d70; // 0x193dc0 - g_ps2RecompiledFunctionTable[151407] = bhEne02_SetSandEffectMain_0x192d70; // 0x193dc4 - g_ps2RecompiledFunctionTable[151408] = bhEne02_SetSandEffectMain_0x192d70; // 0x193dc8 - g_ps2RecompiledFunctionTable[151409] = bhEne02_SetSandEffectMain_0x192d70; // 0x193dcc - g_ps2RecompiledFunctionTable[151410] = bhEne02_SetSandEffectMain_0x192d70; // 0x193dd0 - g_ps2RecompiledFunctionTable[151411] = bhEne02_SetSandEffectMain_0x192d70; // 0x193dd4 - g_ps2RecompiledFunctionTable[151412] = bhEne02_SetSandEffectMain_0x192d70; // 0x193dd8 - g_ps2RecompiledFunctionTable[151413] = bhEne02_SetSandEffectMain_0x192d70; // 0x193ddc - g_ps2RecompiledFunctionTable[151414] = bhEne02_SetSandEffectMain_0x192d70; // 0x193de0 - g_ps2RecompiledFunctionTable[151415] = bhEne02_SetSandEffectMain_0x192d70; // 0x193de4 - g_ps2RecompiledFunctionTable[151416] = bhEne02_SetSandEffectMain_0x192d70; // 0x193de8 - g_ps2RecompiledFunctionTable[151417] = bhEne02_SetSandEffectMain_0x192d70; // 0x193dec - g_ps2RecompiledFunctionTable[151418] = bhEne02_SetSandEffectMain_0x192d70; // 0x193df0 - g_ps2RecompiledFunctionTable[151419] = bhEne02_SetSandEffectMain_0x192d70; // 0x193df4 - g_ps2RecompiledFunctionTable[151420] = bhEne02_SetSandEffectMain_0x192d70; // 0x193df8 - g_ps2RecompiledFunctionTable[151421] = bhEne02_SetSandEffectMain_0x192d70; // 0x193dfc - g_ps2RecompiledFunctionTable[151422] = bhEne02_SetSandEffectMain_0x192d70; // 0x193e00 - g_ps2RecompiledFunctionTable[151423] = bhEne02_SetSandEffectMain_0x192d70; // 0x193e04 - g_ps2RecompiledFunctionTable[151424] = bhEne02_SetSandEffectMain_0x192d70; // 0x193e08 - g_ps2RecompiledFunctionTable[151425] = bhEne02_SetSandEffectMain_0x192d70; // 0x193e0c - g_ps2RecompiledFunctionTable[151426] = bhEne02_SetSandEffectMain_0x192d70; // 0x193e10 - g_ps2RecompiledFunctionTable[151427] = bhEne02_SetSandEffectMain_0x192d70; // 0x193e14 - g_ps2RecompiledFunctionTable[151428] = bhEne02_SetSandEffectMain_0x192d70; // 0x193e18 - g_ps2RecompiledFunctionTable[151429] = bhEne02_SetSandEffectMain_0x192d70; // 0x193e1c - g_ps2RecompiledFunctionTable[151430] = bhEne02_SetSandEffectMain_0x192d70; // 0x193e20 - g_ps2RecompiledFunctionTable[151431] = bhEne02_SetSandEffectMain_0x192d70; // 0x193e24 - g_ps2RecompiledFunctionTable[151432] = bhEne02_SetSandEffectMain_0x192d70; // 0x193e28 - g_ps2RecompiledFunctionTable[151433] = bhEne02_SetSandEffectMain_0x192d70; // 0x193e2c - g_ps2RecompiledFunctionTable[151434] = bhEne02_SetSandEffectMain_0x192d70; // 0x193e30 - g_ps2RecompiledFunctionTable[151435] = bhEne02_SetSandEffectMain_0x192d70; // 0x193e34 - g_ps2RecompiledFunctionTable[151436] = bhEne02_SetSandEffectMain_0x192d70; // 0x193e38 - g_ps2RecompiledFunctionTable[151437] = bhEne02_SetSandEffectMain_0x192d70; // 0x193e3c - g_ps2RecompiledFunctionTable[151438] = bhEne02_SetSandEffectMain_0x192d70; // 0x193e40 - g_ps2RecompiledFunctionTable[151439] = bhEne02_SetSandEffectMain_0x192d70; // 0x193e44 - g_ps2RecompiledFunctionTable[151440] = bhEne02_SetSandEffectMain_0x192d70; // 0x193e48 - g_ps2RecompiledFunctionTable[151441] = bhEne02_SetSandEffectMain_0x192d70; // 0x193e4c - g_ps2RecompiledFunctionTable[151442] = bhEne02_SetSandEffectMain_0x192d70; // 0x193e50 - g_ps2RecompiledFunctionTable[151443] = bhEne02_SetSandEffectMain_0x192d70; // 0x193e54 - g_ps2RecompiledFunctionTable[151444] = bhEne02_SetSandEffectMain_0x192d70; // 0x193e58 - g_ps2RecompiledFunctionTable[151445] = bhEne02_SetSandEffectMain_0x192d70; // 0x193e5c - g_ps2RecompiledFunctionTable[151446] = bhEne02_SetSandEffectMain_0x192d70; // 0x193e60 - g_ps2RecompiledFunctionTable[151447] = bhEne02_SetSandEffectMain_0x192d70; // 0x193e64 - g_ps2RecompiledFunctionTable[151448] = bhEne02_SetSandEffectMain_0x192d70; // 0x193e68 - g_ps2RecompiledFunctionTable[151449] = bhEne02_SetSandEffectMain_0x192d70; // 0x193e6c - g_ps2RecompiledFunctionTable[151450] = bhEne02_SetSandEffectMain_0x192d70; // 0x193e70 - g_ps2RecompiledFunctionTable[151451] = bhEne02_SetSandEffectMain_0x192d70; // 0x193e74 - g_ps2RecompiledFunctionTable[151452] = bhEne02_SetSandEffectMain_0x192d70; // 0x193e78 - g_ps2RecompiledFunctionTable[151453] = bhEne02_SetSandEffectMain_0x192d70; // 0x193e7c - g_ps2RecompiledFunctionTable[151454] = bhEne02_SetSandEffectMain_0x192d70; // 0x193e80 - g_ps2RecompiledFunctionTable[151455] = bhEne02_SetSandEffectMain_0x192d70; // 0x193e84 - g_ps2RecompiledFunctionTable[151456] = bhEne02_SetSandEffectMain_0x192d70; // 0x193e88 - g_ps2RecompiledFunctionTable[151457] = bhEne02_SetSandEffectMain_0x192d70; // 0x193e8c - g_ps2RecompiledFunctionTable[151458] = bhEne02_SetSandEffectMain_0x192d70; // 0x193e90 - g_ps2RecompiledFunctionTable[151459] = bhEne02_SetSandEffectMain_0x192d70; // 0x193e94 - g_ps2RecompiledFunctionTable[151460] = bhEne02_SetSandEffectMain_0x192d70; // 0x193e98 - g_ps2RecompiledFunctionTable[151461] = bhEne02_SetSandEffectMain_0x192d70; // 0x193e9c - g_ps2RecompiledFunctionTable[151462] = bhEne02_SetSandEffectMain_0x192d70; // 0x193ea0 - g_ps2RecompiledFunctionTable[151463] = bhEne02_SetSandEffectMain_0x192d70; // 0x193ea4 - g_ps2RecompiledFunctionTable[151464] = bhEne02_SetSandEffectMain_0x192d70; // 0x193ea8 - g_ps2RecompiledFunctionTable[151465] = bhEne02_SetSandEffectMain_0x192d70; // 0x193eac - g_ps2RecompiledFunctionTable[151466] = bhEne02_SetSandEffectMain_0x192d70; // 0x193eb0 - g_ps2RecompiledFunctionTable[151467] = bhEne02_SetSandEffectMain_0x192d70; // 0x193eb4 - g_ps2RecompiledFunctionTable[151468] = bhEne02_SetSandEffectMain_0x192d70; // 0x193eb8 - g_ps2RecompiledFunctionTable[151469] = bhEne02_SetSandEffectMain_0x192d70; // 0x193ebc - g_ps2RecompiledFunctionTable[151470] = bhEne02_SetSandEffectMain_0x192d70; // 0x193ec0 - g_ps2RecompiledFunctionTable[151471] = bhEne02_SetSandEffectMain_0x192d70; // 0x193ec4 - g_ps2RecompiledFunctionTable[151472] = bhEne02_SetSandEffectMain_0x192d70; // 0x193ec8 - g_ps2RecompiledFunctionTable[151473] = bhEne02_SetSandEffectMain_0x192d70; // 0x193ecc - g_ps2RecompiledFunctionTable[151474] = bhEne02_SetSandEffectMain_0x192d70; // 0x193ed0 - g_ps2RecompiledFunctionTable[151475] = bhEne02_SetSandEffectMain_0x192d70; // 0x193ed4 - g_ps2RecompiledFunctionTable[151476] = bhEne02_SetSandEffectMain_0x192d70; // 0x193ed8 - g_ps2RecompiledFunctionTable[151477] = bhEne02_SetSandEffectMain_0x192d70; // 0x193edc - g_ps2RecompiledFunctionTable[151478] = bhEne02_SetSandEffectMain_0x192d70; // 0x193ee0 - g_ps2RecompiledFunctionTable[151479] = bhEne02_SetSandEffectMain_0x192d70; // 0x193ee4 - g_ps2RecompiledFunctionTable[151480] = bhEne02_SetSandEffectMain_0x192d70; // 0x193ee8 - g_ps2RecompiledFunctionTable[151481] = bhEne02_SetSandEffectMain_0x192d70; // 0x193eec - g_ps2RecompiledFunctionTable[151482] = bhEne02_SetSandEffectMain_0x192d70; // 0x193ef0 - g_ps2RecompiledFunctionTable[151483] = bhEne02_SetSandEffectMain_0x192d70; // 0x193ef4 - g_ps2RecompiledFunctionTable[151484] = bhEne02_SetSandEffectMain_0x192d70; // 0x193ef8 - g_ps2RecompiledFunctionTable[151485] = bhEne02_SetSandEffectMain_0x192d70; // 0x193efc - g_ps2RecompiledFunctionTable[151486] = bhEne02_SetSandEffectMain_0x192d70; // 0x193f00 - g_ps2RecompiledFunctionTable[151487] = bhEne02_SetSandEffectMain_0x192d70; // 0x193f04 - g_ps2RecompiledFunctionTable[151488] = bhEne02_SetSandEffectMain_0x192d70; // 0x193f08 - g_ps2RecompiledFunctionTable[151489] = bhEne02_SetSandEffectMain_0x192d70; // 0x193f0c - g_ps2RecompiledFunctionTable[151490] = bhEne02_SetSandEffectMain_0x192d70; // 0x193f10 - g_ps2RecompiledFunctionTable[151491] = bhEne02_SetSandEffectMain_0x192d70; // 0x193f14 - g_ps2RecompiledFunctionTable[151492] = bhEne02_SetSandEffectMain_0x192d70; // 0x193f18 - g_ps2RecompiledFunctionTable[151493] = bhEne02_SetSandEffectMain_0x192d70; // 0x193f1c - g_ps2RecompiledFunctionTable[151494] = bhEne02_SetSandEffectMain_0x192d70; // 0x193f20 - g_ps2RecompiledFunctionTable[151495] = bhEne02_SetSandEffectMain_0x192d70; // 0x193f24 - g_ps2RecompiledFunctionTable[151496] = bhEne02_SetSandEffectMain_0x192d70; // 0x193f28 - g_ps2RecompiledFunctionTable[151497] = bhEne02_SetSandEffectMain_0x192d70; // 0x193f2c - g_ps2RecompiledFunctionTable[151498] = bhEne02_SetSandEffectMain_0x192d70; // 0x193f30 - g_ps2RecompiledFunctionTable[151499] = bhEne02_SetSandEffectMain_0x192d70; // 0x193f34 - g_ps2RecompiledFunctionTable[151500] = bhEne02_SetSandEffectMain_0x192d70; // 0x193f38 - g_ps2RecompiledFunctionTable[151501] = bhEne02_SetSandEffectMain_0x192d70; // 0x193f3c - g_ps2RecompiledFunctionTable[151502] = bhEne02_SetSandEffectMain_0x192d70; // 0x193f40 - g_ps2RecompiledFunctionTable[151503] = bhEne02_SetSandEffectMain_0x192d70; // 0x193f44 - g_ps2RecompiledFunctionTable[151504] = bhEne02_SetSandEffectMain_0x192d70; // 0x193f48 - g_ps2RecompiledFunctionTable[151505] = bhEne02_SetSandEffectMain_0x192d70; // 0x193f4c - g_ps2RecompiledFunctionTable[151506] = bhEne02_SetSandEffectMain_0x192d70; // 0x193f50 - g_ps2RecompiledFunctionTable[151507] = bhEne02_SetSandEffectMain_0x192d70; // 0x193f54 - g_ps2RecompiledFunctionTable[151508] = bhEne02_SetSandEffectMain_0x192d70; // 0x193f58 - g_ps2RecompiledFunctionTable[151509] = bhEne02_SetSandEffectMain_0x192d70; // 0x193f5c - g_ps2RecompiledFunctionTable[151510] = bhEne02_SetSandEffectMain_0x192d70; // 0x193f60 - g_ps2RecompiledFunctionTable[151511] = bhEne02_SetSandEffectMain_0x192d70; // 0x193f64 - g_ps2RecompiledFunctionTable[151512] = bhEne02_SetSandEffectMain_0x192d70; // 0x193f68 - g_ps2RecompiledFunctionTable[151513] = bhEne02_SetSandEffectMain_0x192d70; // 0x193f6c - g_ps2RecompiledFunctionTable[151514] = bhEne02_SetSandEffectMain_0x192d70; // 0x193f70 - g_ps2RecompiledFunctionTable[151515] = bhEne02_SetSandEffectMain_0x192d70; // 0x193f74 - g_ps2RecompiledFunctionTable[151516] = bhEne02_SetSandEffectMain_0x192d70; // 0x193f78 - g_ps2RecompiledFunctionTable[151517] = bhEne02_SetSandEffectMain_0x192d70; // 0x193f7c - g_ps2RecompiledFunctionTable[151518] = bhEne02_SetSandEffectMain_0x192d70; // 0x193f80 - g_ps2RecompiledFunctionTable[151519] = bhEne02_SetSandEffectMain_0x192d70; // 0x193f84 - g_ps2RecompiledFunctionTable[151520] = bhEne02_SetSandEffectMain_0x192d70; // 0x193f88 - g_ps2RecompiledFunctionTable[151521] = bhEne02_SetSandEffectMain_0x192d70; // 0x193f8c - g_ps2RecompiledFunctionTable[151522] = bhEne02_SetSandEffectMain_0x192d70; // 0x193f90 - g_ps2RecompiledFunctionTable[151523] = bhEne02_SetSandEffectMain_0x192d70; // 0x193f94 - g_ps2RecompiledFunctionTable[151524] = bhEne02_SetSandEffectMain_0x192d70; // 0x193f98 - g_ps2RecompiledFunctionTable[151525] = bhEne02_SetSandEffectMain_0x192d70; // 0x193f9c - g_ps2RecompiledFunctionTable[151526] = bhEne02_SetSandEffectMain_0x192d70; // 0x193fa0 - g_ps2RecompiledFunctionTable[151527] = bhEne02_SetSandEffectMain_0x192d70; // 0x193fa4 - g_ps2RecompiledFunctionTable[151528] = bhEne02_SetSandEffectMain_0x192d70; // 0x193fa8 - g_ps2RecompiledFunctionTable[151529] = bhEne02_SetSandEffectMain_0x192d70; // 0x193fac - g_ps2RecompiledFunctionTable[151530] = bhEne02_SetSandEffectMain_0x192d70; // 0x193fb0 - g_ps2RecompiledFunctionTable[151531] = bhEne02_SetSandEffectMain_0x192d70; // 0x193fb4 - g_ps2RecompiledFunctionTable[151532] = bhEne02_SetSandEffectMain_0x192d70; // 0x193fb8 - g_ps2RecompiledFunctionTable[151533] = bhEne02_SetSandEffectMain_0x192d70; // 0x193fbc - g_ps2RecompiledFunctionTable[151534] = bhEne02_SetSandEffectMain_0x192d70; // 0x193fc0 - g_ps2RecompiledFunctionTable[151535] = bhEne02_SetSandEffectMain_0x192d70; // 0x193fc4 - g_ps2RecompiledFunctionTable[151536] = bhEne02_SetSandEffectMain_0x192d70; // 0x193fc8 - g_ps2RecompiledFunctionTable[151537] = bhEne02_SetSandEffectMain_0x192d70; // 0x193fcc - g_ps2RecompiledFunctionTable[151538] = bhEne02_SetSandEffectMain_0x192d70; // 0x193fd0 - g_ps2RecompiledFunctionTable[151539] = bhEne02_SetSandEffectMain_0x192d70; // 0x193fd4 - g_ps2RecompiledFunctionTable[151540] = bhEne02_SetSandEffectMain_0x192d70; // 0x193fd8 - g_ps2RecompiledFunctionTable[151541] = bhEne02_SetSandEffectMain_0x192d70; // 0x193fdc - g_ps2RecompiledFunctionTable[151542] = bhEne02_SetSandEffectMain_0x192d70; // 0x193fe0 - g_ps2RecompiledFunctionTable[151543] = bhEne02_SetSandEffectMain_0x192d70; // 0x193fe4 - g_ps2RecompiledFunctionTable[151544] = bhEne02_SetSandEffectMain_0x192d70; // 0x193fe8 - g_ps2RecompiledFunctionTable[151545] = bhEne02_SetSandEffectMain_0x192d70; // 0x193fec - g_ps2RecompiledFunctionTable[151546] = bhEne02_SetSandEffectMain_0x192d70; // 0x193ff0 - g_ps2RecompiledFunctionTable[151547] = bhEne02_SetSandEffectMain_0x192d70; // 0x193ff4 - g_ps2RecompiledFunctionTable[151548] = bhEne02_SetSandEffectMain_0x192d70; // 0x193ff8 - g_ps2RecompiledFunctionTable[151549] = bhEne02_SetSandEffectMain_0x192d70; // 0x193ffc - g_ps2RecompiledFunctionTable[151550] = bhEne02_SetSandEffectMain_0x192d70; // 0x194000 - g_ps2RecompiledFunctionTable[151551] = bhEne02_SetSandEffectMain_0x192d70; // 0x194004 - g_ps2RecompiledFunctionTable[151552] = bhEne02_SetSandEffectMain_0x192d70; // 0x194008 - g_ps2RecompiledFunctionTable[151553] = bhEne02_SetSandEffectMain_0x192d70; // 0x19400c - g_ps2RecompiledFunctionTable[151554] = bhEne02_SetSandSpr_0x194010; // 0x194010 - g_ps2RecompiledFunctionTable[151650] = bhEne02_SetSandSpr_0x194010; // 0x194190 - g_ps2RecompiledFunctionTable[151656] = bhEne02_SetSandSpr_0x194010; // 0x1941a8 - g_ps2RecompiledFunctionTable[151671] = bhEne02_SetSandSpr_0x194010; // 0x1941e4 - g_ps2RecompiledFunctionTable[151680] = bhEne02_SetSandSpr_0x194010; // 0x194208 - g_ps2RecompiledFunctionTable[151706] = bhEne02_SandEffect_0x194270; // 0x194270 - g_ps2RecompiledFunctionTable[151721] = bhEne02_SandEffect_0x194270; // 0x1942ac - g_ps2RecompiledFunctionTable[151727] = bhEne02_SandEffect_0x194270; // 0x1942c4 - g_ps2RecompiledFunctionTable[151740] = bhEne02_SandEffect_0x194270; // 0x1942f8 - g_ps2RecompiledFunctionTable[151743] = bhEne02_SandEffect_0x194270; // 0x194304 - g_ps2RecompiledFunctionTable[151747] = bhEne02_SandEffect_0x194270; // 0x194314 - g_ps2RecompiledFunctionTable[151763] = bhEne02_SandEffect_0x194270; // 0x194354 - g_ps2RecompiledFunctionTable[151786] = bhEne02_SandEffectP_0x1943b0; // 0x1943b0 - g_ps2RecompiledFunctionTable[151808] = bhEne02_SandEffectP_0x1943b0; // 0x194408 - g_ps2RecompiledFunctionTable[151816] = bhEne02_SandEffectP_0x1943b0; // 0x194428 - g_ps2RecompiledFunctionTable[151830] = bhEne02_SandEffectP_0x1943b0; // 0x194460 - g_ps2RecompiledFunctionTable[151835] = bhEne02_SandEffectP_0x1943b0; // 0x194474 - g_ps2RecompiledFunctionTable[151839] = bhEne02_SandEffectP_0x1943b0; // 0x194484 - g_ps2RecompiledFunctionTable[151860] = bhEne02_SandEffectP_0x1943b0; // 0x1944d8 - g_ps2RecompiledFunctionTable[151862] = bhEne02_SandEffectP_0x1943b0; // 0x1944e0 - g_ps2RecompiledFunctionTable[151879] = bhEne02_SandEffectP_0x1943b0; // 0x194524 - g_ps2RecompiledFunctionTable[151897] = bhEne02_SandEffectP_0x1943b0; // 0x19456c - g_ps2RecompiledFunctionTable[151921] = bhEne02_SandEffectP_0x1943b0; // 0x1945cc - g_ps2RecompiledFunctionTable[151926] = bhEne02_SandEffectP_0x1943b0; // 0x1945e0 - g_ps2RecompiledFunctionTable[151928] = bhEne02_SandEffectP_0x1943b0; // 0x1945e8 - g_ps2RecompiledFunctionTable[151945] = bhEne02_SandEffectP_0x1943b0; // 0x19462c - g_ps2RecompiledFunctionTable[151962] = bhEne02_SandEffectP_0x1943b0; // 0x194670 - g_ps2RecompiledFunctionTable[151984] = bhEne02_SandEffectP_0x1943b0; // 0x1946c8 - g_ps2RecompiledFunctionTable[152014] = bhEne02_PlayerControl_0x194740; // 0x194740 - g_ps2RecompiledFunctionTable[152127] = bhEne02_PlayerControl_0x194740; // 0x194904 - g_ps2RecompiledFunctionTable[152130] = bhEne02_PlayerControl_0x194740; // 0x194910 - g_ps2RecompiledFunctionTable[152144] = bhEne02_PlayerControl_0x194740; // 0x194948 - g_ps2RecompiledFunctionTable[152156] = bhEne02_PlayerControl_0x194740; // 0x194978 - g_ps2RecompiledFunctionTable[152258] = bhEne02_PlayerControl_0x194740; // 0x194b10 - g_ps2RecompiledFunctionTable[152299] = bhEne02_PlayerControl_0x194740; // 0x194bb4 - g_ps2RecompiledFunctionTable[152393] = bhEne02_PlayerControl_0x194740; // 0x194d2c - g_ps2RecompiledFunctionTable[152396] = bhEne02_PlayerControl_0x194740; // 0x194d38 - g_ps2RecompiledFunctionTable[152485] = bhEne02_PlayerControl_0x194740; // 0x194e9c - g_ps2RecompiledFunctionTable[152488] = bhEne02_PlayerControl_0x194740; // 0x194ea8 - g_ps2RecompiledFunctionTable[152502] = bhEne02_PlayerControl_0x194740; // 0x194ee0 - g_ps2RecompiledFunctionTable[152514] = bhEne02_PlayerControl_0x194740; // 0x194f10 - g_ps2RecompiledFunctionTable[152607] = bhEne02_PlayerControl_0x194740; // 0x195084 - g_ps2RecompiledFunctionTable[152618] = bhEne02_DamageInit_0x1950b0; // 0x1950b0 - g_ps2RecompiledFunctionTable[152627] = bhEne02_DamageInit_0x1950b0; // 0x1950d4 - g_ps2RecompiledFunctionTable[152654] = bhEne02_DamageInit_0x1950b0; // 0x195140 - g_ps2RecompiledFunctionTable[152710] = bhEne02_SetSandParticle_0x195220; // 0x195220 - g_ps2RecompiledFunctionTable[152774] = bhEne02_SetSandParticle_0x195220; // 0x195320 - g_ps2RecompiledFunctionTable[152806] = bhEne02_CheckWall_0x1953a0; // 0x1953a0 - g_ps2RecompiledFunctionTable[152822] = bhEne02_CheckWall_0x1953a0; // 0x1953e0 - g_ps2RecompiledFunctionTable[152827] = bhEne02_CheckWall_0x1953a0; // 0x1953f4 - g_ps2RecompiledFunctionTable[152841] = bhEne02_CheckWall_0x1953a0; // 0x19542c - g_ps2RecompiledFunctionTable[152850] = bhEne02_CheckWall_0x1953a0; // 0x195450 - g_ps2RecompiledFunctionTable[152858] = bhEne02_CameraControl_0x195470; // 0x195470 - g_ps2RecompiledFunctionTable[152875] = bhEne02_CameraControl_0x195470; // 0x1954b4 - g_ps2RecompiledFunctionTable[152892] = bhEne02_CameraControl_0x195470; // 0x1954f8 - g_ps2RecompiledFunctionTable[152909] = bhEne02_CameraControl_0x195470; // 0x19553c - g_ps2RecompiledFunctionTable[152935] = bhEne02_CameraControl_0x195470; // 0x1955a4 - g_ps2RecompiledFunctionTable[152952] = bhEne02_CameraControl_0x195470; // 0x1955e8 - g_ps2RecompiledFunctionTable[152969] = bhEne02_CameraControl_0x195470; // 0x19562c - g_ps2RecompiledFunctionTable[153002] = bhEne02_WarpCheck_0x1956b0; // 0x1956b0 - g_ps2RecompiledFunctionTable[153013] = bhEne02_WarpCheck_0x1956b0; // 0x1956dc - g_ps2RecompiledFunctionTable[153032] = bhEne02_WarpCheck_0x1956b0; // 0x195728 - g_ps2RecompiledFunctionTable[153044] = bhEne02_WarpCheck_0x1956b0; // 0x195758 - g_ps2RecompiledFunctionTable[153070] = bhEne02_WarpCheck_0x1956b0; // 0x1957c0 - g_ps2RecompiledFunctionTable[153080] = bhEne02_WarpCheck_0x1956b0; // 0x1957e8 - g_ps2RecompiledFunctionTable[153102] = bhEne02_FallingRock_0x195840; // 0x195840 - g_ps2RecompiledFunctionTable[153113] = bhEne02_FallingRock_0x195840; // 0x19586c - g_ps2RecompiledFunctionTable[153126] = bhEne02_FallingRock_0x195840; // 0x1958a0 - g_ps2RecompiledFunctionTable[153129] = bhEne02_FallingRock_0x195840; // 0x1958ac - g_ps2RecompiledFunctionTable[153140] = bhEne02_FallingRock_0x195840; // 0x1958d8 - g_ps2RecompiledFunctionTable[153147] = bhEne02_FallingRock_0x195840; // 0x1958f4 - g_ps2RecompiledFunctionTable[153161] = bhEne02_FallingRock_0x195840; // 0x19592c - g_ps2RecompiledFunctionTable[153185] = bhEne02_FallingRock_0x195840; // 0x19598c - g_ps2RecompiledFunctionTable[153205] = bhEne02_FallingRock_0x195840; // 0x1959dc - g_ps2RecompiledFunctionTable[153218] = bhEne02_FallingRock_0x195840; // 0x195a10 - g_ps2RecompiledFunctionTable[153246] = bhEne02_CallSE_0x195a80; // 0x195a80 - g_ps2RecompiledFunctionTable[153292] = bhEne02_CallSE_0x195a80; // 0x195b38 - g_ps2RecompiledFunctionTable[153300] = bhEne02_CallSE_0x195a80; // 0x195b58 - g_ps2RecompiledFunctionTable[153308] = bhEne02_CallSE_0x195a80; // 0x195b78 - g_ps2RecompiledFunctionTable[153316] = bhEne02_CallSE_0x195a80; // 0x195b98 - g_ps2RecompiledFunctionTable[153325] = bhEne02_CallSE_0x195a80; // 0x195bbc - g_ps2RecompiledFunctionTable[153334] = bhEne02_CallSE_0x195a80; // 0x195be0 - g_ps2RecompiledFunctionTable[153343] = bhEne02_CallSE_0x195a80; // 0x195c04 - g_ps2RecompiledFunctionTable[153353] = bhEne02_CallSE_0x195a80; // 0x195c2c - g_ps2RecompiledFunctionTable[153362] = bhEne02_CallSE_0x195a80; // 0x195c50 - g_ps2RecompiledFunctionTable[153369] = bhEne02_CallSE_0x195a80; // 0x195c6c - g_ps2RecompiledFunctionTable[153377] = bhEne02_CallSE_0x195a80; // 0x195c8c - g_ps2RecompiledFunctionTable[153384] = bhEne02_CallSE_0x195a80; // 0x195ca8 - g_ps2RecompiledFunctionTable[153392] = bhEne02_CallSE_0x195a80; // 0x195cc8 - g_ps2RecompiledFunctionTable[153401] = bhEne02_CallSE_0x195a80; // 0x195cec - g_ps2RecompiledFunctionTable[153410] = bhEne02_CallSE_0x195a80; // 0x195d10 - g_ps2RecompiledFunctionTable[153419] = bhEne02_CallSE_0x195a80; // 0x195d34 - g_ps2RecompiledFunctionTable[153426] = bhEne02_CallSE_0x195a80; // 0x195d50 - g_ps2RecompiledFunctionTable[153434] = bhEne02_HitMark_0x195d70; // 0x195d70 - g_ps2RecompiledFunctionTable[153475] = bhEne02_HitMark_0x195d70; // 0x195e14 - g_ps2RecompiledFunctionTable[153501] = bhEne02_HitMark_0x195d70; // 0x195e7c - g_ps2RecompiledFunctionTable[153520] = bhEne02_HitMark_0x195d70; // 0x195ec8 - g_ps2RecompiledFunctionTable[153547] = bhEne02_HitMark_0x195d70; // 0x195f34 - g_ps2RecompiledFunctionTable[153571] = bhEne02_HitMark_0x195d70; // 0x195f94 - g_ps2RecompiledFunctionTable[153585] = bhEne02_HitMark_0x195d70; // 0x195fcc - g_ps2RecompiledFunctionTable[153600] = bhEne02_HitMark_0x195d70; // 0x196008 - g_ps2RecompiledFunctionTable[153614] = bhEne02_HitMark_0x195d70; // 0x196040 - g_ps2RecompiledFunctionTable[153618] = bhEne02_HitMark_0x195d70; // 0x196050 - g_ps2RecompiledFunctionTable[153644] = bhEne02_HitMark_0x195d70; // 0x1960b8 - g_ps2RecompiledFunctionTable[153663] = bhEne02_HitMark_0x195d70; // 0x196104 - g_ps2RecompiledFunctionTable[153678] = bhEne02_HitMark_0x195d70; // 0x196140 - g_ps2RecompiledFunctionTable[153691] = bhEne02_HitMark_0x195d70; // 0x196174 - g_ps2RecompiledFunctionTable[153704] = bhEne02_HitMark_0x195d70; // 0x1961a8 - g_ps2RecompiledFunctionTable[153710] = bhEne02_HitMark_0x195d70; // 0x1961c0 - g_ps2RecompiledFunctionTable[153728] = bhEne02_HitMark_0x195d70; // 0x196208 - g_ps2RecompiledFunctionTable[153754] = bhEne02_HitMark_0x195d70; // 0x196270 - g_ps2RecompiledFunctionTable[153773] = bhEne02_HitMark_0x195d70; // 0x1962bc - g_ps2RecompiledFunctionTable[153791] = bhEne02_HitMark_0x195d70; // 0x196304 - g_ps2RecompiledFunctionTable[153802] = bhEne02sub_0x196330; // 0x196330 - g_ps2RecompiledFunctionTable[153803] = bhEne02sub_0x196330; // 0x196334 - g_ps2RecompiledFunctionTable[153804] = bhEne02sub_0x196330; // 0x196338 - g_ps2RecompiledFunctionTable[153805] = bhEne02sub_0x196330; // 0x19633c - g_ps2RecompiledFunctionTable[153806] = bhEne02sub_0x196330; // 0x196340 - g_ps2RecompiledFunctionTable[153807] = bhEne02sub_0x196330; // 0x196344 - g_ps2RecompiledFunctionTable[153808] = bhEne02sub_0x196330; // 0x196348 - g_ps2RecompiledFunctionTable[153809] = bhEne02sub_0x196330; // 0x19634c - g_ps2RecompiledFunctionTable[153810] = bhEne02sub_Init_0x196350; // 0x196350 - g_ps2RecompiledFunctionTable[153834] = bhEne02sub_Move_0x1963b0; // 0x1963b0 - g_ps2RecompiledFunctionTable[153835] = bhEne02sub_Move_0x1963b0; // 0x1963b4 - g_ps2RecompiledFunctionTable[153836] = bhEne02sub_Move_0x1963b0; // 0x1963b8 - g_ps2RecompiledFunctionTable[153837] = bhEne02sub_Move_0x1963b0; // 0x1963bc - g_ps2RecompiledFunctionTable[153838] = bhEne02sub_Move_0x1963b0; // 0x1963c0 - g_ps2RecompiledFunctionTable[153839] = bhEne02sub_Move_0x1963b0; // 0x1963c4 - g_ps2RecompiledFunctionTable[153840] = bhEne02sub_Move_0x1963b0; // 0x1963c8 - g_ps2RecompiledFunctionTable[153841] = bhEne02sub_Move_0x1963b0; // 0x1963cc - g_ps2RecompiledFunctionTable[153842] = bhEne02sub_MV00_0x1963d0; // 0x1963d0 - g_ps2RecompiledFunctionTable[153846] = bhEne02sub_MV01_0x1963e0; // 0x1963e0 - g_ps2RecompiledFunctionTable[153890] = bhEne02sub_MV01_0x1963e0; // 0x196490 - g_ps2RecompiledFunctionTable[153914] = bhEne02sub_MV02_0x1964f0; // 0x1964f0 - g_ps2RecompiledFunctionTable[153943] = bhEne02sub_MV02_0x1964f0; // 0x196564 - g_ps2RecompiledFunctionTable[153970] = bhEne02sub_MV03_0x1965d0; // 0x1965d0 - g_ps2RecompiledFunctionTable[153997] = bhEne02sub_MV03_0x1965d0; // 0x19663c - g_ps2RecompiledFunctionTable[154010] = bhEne02sub_MV03_0x1965d0; // 0x196670 - g_ps2RecompiledFunctionTable[154032] = bhEne02sub_MV03_0x1965d0; // 0x1966c8 - g_ps2RecompiledFunctionTable[154097] = bhEne02sub_MV03_0x1965d0; // 0x1967cc - g_ps2RecompiledFunctionTable[154126] = bhEne02sub_MV04_0x196840; // 0x196840 - g_ps2RecompiledFunctionTable[154150] = bhEne02sub_MV04_0x196840; // 0x1968a0 - g_ps2RecompiledFunctionTable[154158] = bhEne02sub_MV04_0x196840; // 0x1968c0 - g_ps2RecompiledFunctionTable[154183] = bhEne02sub_MV04_0x196840; // 0x196924 - g_ps2RecompiledFunctionTable[154191] = bhEne02sub_MV04_0x196840; // 0x196944 - g_ps2RecompiledFunctionTable[154201] = bhEne02sub_MV04_0x196840; // 0x19696c - g_ps2RecompiledFunctionTable[154222] = bhEne03_0x1969c0; // 0x1969c0 - g_ps2RecompiledFunctionTable[154223] = bhEne03_0x1969c0; // 0x1969c4 - g_ps2RecompiledFunctionTable[154224] = bhEne03_0x1969c0; // 0x1969c8 - g_ps2RecompiledFunctionTable[154225] = bhEne03_0x1969c0; // 0x1969cc - g_ps2RecompiledFunctionTable[154226] = bhEne03_0x1969c0; // 0x1969d0 - g_ps2RecompiledFunctionTable[154227] = bhEne03_0x1969c0; // 0x1969d4 - g_ps2RecompiledFunctionTable[154228] = bhEne03_0x1969c0; // 0x1969d8 - g_ps2RecompiledFunctionTable[154229] = bhEne03_0x1969c0; // 0x1969dc - g_ps2RecompiledFunctionTable[154230] = bhEne03_0x1969c0; // 0x1969e0 - g_ps2RecompiledFunctionTable[154231] = bhEne03_0x1969c0; // 0x1969e4 - g_ps2RecompiledFunctionTable[154232] = bhEne03_0x1969c0; // 0x1969e8 - g_ps2RecompiledFunctionTable[154233] = bhEne03_0x1969c0; // 0x1969ec - g_ps2RecompiledFunctionTable[154234] = bhEne03_0x1969c0; // 0x1969f0 - g_ps2RecompiledFunctionTable[154235] = bhEne03_0x1969c0; // 0x1969f4 - g_ps2RecompiledFunctionTable[154236] = bhEne03_0x1969c0; // 0x1969f8 - g_ps2RecompiledFunctionTable[154237] = bhEne03_0x1969c0; // 0x1969fc - g_ps2RecompiledFunctionTable[154238] = bhEne03_0x1969c0; // 0x196a00 - g_ps2RecompiledFunctionTable[154239] = bhEne03_0x1969c0; // 0x196a04 - g_ps2RecompiledFunctionTable[154240] = bhEne03_0x1969c0; // 0x196a08 - g_ps2RecompiledFunctionTable[154241] = bhEne03_0x1969c0; // 0x196a0c - g_ps2RecompiledFunctionTable[154242] = bhEne03_0x1969c0; // 0x196a10 - g_ps2RecompiledFunctionTable[154243] = bhEne03_0x1969c0; // 0x196a14 - g_ps2RecompiledFunctionTable[154244] = bhEne03_0x1969c0; // 0x196a18 - g_ps2RecompiledFunctionTable[154245] = bhEne03_0x1969c0; // 0x196a1c - g_ps2RecompiledFunctionTable[154246] = bhEne03_0x1969c0; // 0x196a20 - g_ps2RecompiledFunctionTable[154247] = bhEne03_0x1969c0; // 0x196a24 - g_ps2RecompiledFunctionTable[154248] = bhEne03_0x1969c0; // 0x196a28 - g_ps2RecompiledFunctionTable[154249] = bhEne03_0x1969c0; // 0x196a2c - g_ps2RecompiledFunctionTable[154250] = bhEne03_0x1969c0; // 0x196a30 - g_ps2RecompiledFunctionTable[154251] = bhEne03_0x1969c0; // 0x196a34 - g_ps2RecompiledFunctionTable[154252] = bhEne03_0x1969c0; // 0x196a38 - g_ps2RecompiledFunctionTable[154253] = bhEne03_0x1969c0; // 0x196a3c - g_ps2RecompiledFunctionTable[154254] = bhEne03_0x1969c0; // 0x196a40 - g_ps2RecompiledFunctionTable[154255] = bhEne03_0x1969c0; // 0x196a44 - g_ps2RecompiledFunctionTable[154256] = bhEne03_0x1969c0; // 0x196a48 - g_ps2RecompiledFunctionTable[154257] = bhEne03_0x1969c0; // 0x196a4c - g_ps2RecompiledFunctionTable[154258] = bhEne03_0x1969c0; // 0x196a50 - g_ps2RecompiledFunctionTable[154259] = bhEne03_0x1969c0; // 0x196a54 - g_ps2RecompiledFunctionTable[154260] = bhEne03_0x1969c0; // 0x196a58 - g_ps2RecompiledFunctionTable[154261] = bhEne03_0x1969c0; // 0x196a5c - g_ps2RecompiledFunctionTable[154262] = bhEne03_0x1969c0; // 0x196a60 - g_ps2RecompiledFunctionTable[154263] = bhEne03_0x1969c0; // 0x196a64 - g_ps2RecompiledFunctionTable[154264] = bhEne03_0x1969c0; // 0x196a68 - g_ps2RecompiledFunctionTable[154265] = bhEne03_0x1969c0; // 0x196a6c - g_ps2RecompiledFunctionTable[154266] = bhEne03_0x1969c0; // 0x196a70 - g_ps2RecompiledFunctionTable[154267] = bhEne03_0x1969c0; // 0x196a74 - g_ps2RecompiledFunctionTable[154268] = bhEne03_0x1969c0; // 0x196a78 - g_ps2RecompiledFunctionTable[154269] = bhEne03_0x1969c0; // 0x196a7c - g_ps2RecompiledFunctionTable[154270] = bhEne03_0x1969c0; // 0x196a80 - g_ps2RecompiledFunctionTable[154271] = bhEne03_0x1969c0; // 0x196a84 - g_ps2RecompiledFunctionTable[154272] = bhEne03_0x1969c0; // 0x196a88 - g_ps2RecompiledFunctionTable[154273] = bhEne03_0x1969c0; // 0x196a8c - g_ps2RecompiledFunctionTable[154274] = bhEne03_0x1969c0; // 0x196a90 - g_ps2RecompiledFunctionTable[154275] = bhEne03_0x1969c0; // 0x196a94 - g_ps2RecompiledFunctionTable[154276] = bhEne03_0x1969c0; // 0x196a98 - g_ps2RecompiledFunctionTable[154277] = bhEne03_0x1969c0; // 0x196a9c - g_ps2RecompiledFunctionTable[154278] = bhEne03_0x1969c0; // 0x196aa0 - g_ps2RecompiledFunctionTable[154279] = bhEne03_0x1969c0; // 0x196aa4 - g_ps2RecompiledFunctionTable[154280] = bhEne03_0x1969c0; // 0x196aa8 - g_ps2RecompiledFunctionTable[154281] = bhEne03_0x1969c0; // 0x196aac - g_ps2RecompiledFunctionTable[154282] = bhEne03_0x1969c0; // 0x196ab0 - g_ps2RecompiledFunctionTable[154283] = bhEne03_0x1969c0; // 0x196ab4 - g_ps2RecompiledFunctionTable[154284] = bhEne03_0x1969c0; // 0x196ab8 - g_ps2RecompiledFunctionTable[154285] = bhEne03_0x1969c0; // 0x196abc - g_ps2RecompiledFunctionTable[154286] = bhEne03_0x1969c0; // 0x196ac0 - g_ps2RecompiledFunctionTable[154287] = bhEne03_0x1969c0; // 0x196ac4 - g_ps2RecompiledFunctionTable[154288] = bhEne03_0x1969c0; // 0x196ac8 - g_ps2RecompiledFunctionTable[154289] = bhEne03_0x1969c0; // 0x196acc - g_ps2RecompiledFunctionTable[154290] = bhEne03_0x1969c0; // 0x196ad0 - g_ps2RecompiledFunctionTable[154291] = bhEne03_0x1969c0; // 0x196ad4 - g_ps2RecompiledFunctionTable[154292] = bhEne03_0x1969c0; // 0x196ad8 - g_ps2RecompiledFunctionTable[154293] = bhEne03_0x1969c0; // 0x196adc - g_ps2RecompiledFunctionTable[154294] = bhEne03_0x1969c0; // 0x196ae0 - g_ps2RecompiledFunctionTable[154295] = bhEne03_0x1969c0; // 0x196ae4 - g_ps2RecompiledFunctionTable[154296] = bhEne03_0x1969c0; // 0x196ae8 - g_ps2RecompiledFunctionTable[154297] = bhEne03_0x1969c0; // 0x196aec - g_ps2RecompiledFunctionTable[154298] = bhEne03_0x1969c0; // 0x196af0 - g_ps2RecompiledFunctionTable[154299] = bhEne03_0x1969c0; // 0x196af4 - g_ps2RecompiledFunctionTable[154300] = bhEne03_0x1969c0; // 0x196af8 - g_ps2RecompiledFunctionTable[154301] = bhEne03_0x1969c0; // 0x196afc - g_ps2RecompiledFunctionTable[154302] = bhEne03_0x1969c0; // 0x196b00 - g_ps2RecompiledFunctionTable[154303] = bhEne03_0x1969c0; // 0x196b04 - g_ps2RecompiledFunctionTable[154304] = bhEne03_0x1969c0; // 0x196b08 - g_ps2RecompiledFunctionTable[154305] = bhEne03_0x1969c0; // 0x196b0c - g_ps2RecompiledFunctionTable[154306] = bhEne03_0x1969c0; // 0x196b10 - g_ps2RecompiledFunctionTable[154307] = bhEne03_0x1969c0; // 0x196b14 - g_ps2RecompiledFunctionTable[154308] = bhEne03_0x1969c0; // 0x196b18 - g_ps2RecompiledFunctionTable[154309] = bhEne03_0x1969c0; // 0x196b1c - g_ps2RecompiledFunctionTable[154310] = bhEne03_0x1969c0; // 0x196b20 - g_ps2RecompiledFunctionTable[154311] = bhEne03_0x1969c0; // 0x196b24 - g_ps2RecompiledFunctionTable[154312] = bhEne03_0x1969c0; // 0x196b28 - g_ps2RecompiledFunctionTable[154313] = bhEne03_0x1969c0; // 0x196b2c - g_ps2RecompiledFunctionTable[154314] = bhEne03_0x1969c0; // 0x196b30 - g_ps2RecompiledFunctionTable[154315] = bhEne03_0x1969c0; // 0x196b34 - g_ps2RecompiledFunctionTable[154316] = bhEne03_0x1969c0; // 0x196b38 - g_ps2RecompiledFunctionTable[154317] = bhEne03_0x1969c0; // 0x196b3c - g_ps2RecompiledFunctionTable[154318] = bhEne03_0x1969c0; // 0x196b40 - g_ps2RecompiledFunctionTable[154319] = bhEne03_0x1969c0; // 0x196b44 - g_ps2RecompiledFunctionTable[154320] = bhEne03_0x1969c0; // 0x196b48 - g_ps2RecompiledFunctionTable[154321] = bhEne03_0x1969c0; // 0x196b4c - g_ps2RecompiledFunctionTable[154322] = bhEne03_0x1969c0; // 0x196b50 - g_ps2RecompiledFunctionTable[154323] = bhEne03_0x1969c0; // 0x196b54 - g_ps2RecompiledFunctionTable[154324] = bhEne03_0x1969c0; // 0x196b58 - g_ps2RecompiledFunctionTable[154325] = bhEne03_0x1969c0; // 0x196b5c - g_ps2RecompiledFunctionTable[154326] = bhEne03_0x1969c0; // 0x196b60 - g_ps2RecompiledFunctionTable[154327] = bhEne03_0x1969c0; // 0x196b64 - g_ps2RecompiledFunctionTable[154328] = bhEne03_0x1969c0; // 0x196b68 - g_ps2RecompiledFunctionTable[154329] = bhEne03_0x1969c0; // 0x196b6c - g_ps2RecompiledFunctionTable[154330] = bhEne03_0x1969c0; // 0x196b70 - g_ps2RecompiledFunctionTable[154331] = bhEne03_0x1969c0; // 0x196b74 - g_ps2RecompiledFunctionTable[154332] = bhEne03_0x1969c0; // 0x196b78 - g_ps2RecompiledFunctionTable[154333] = bhEne03_0x1969c0; // 0x196b7c - g_ps2RecompiledFunctionTable[154334] = bhEne03_0x1969c0; // 0x196b80 - g_ps2RecompiledFunctionTable[154335] = bhEne03_0x1969c0; // 0x196b84 - g_ps2RecompiledFunctionTable[154336] = bhEne03_0x1969c0; // 0x196b88 - g_ps2RecompiledFunctionTable[154337] = bhEne03_0x1969c0; // 0x196b8c - g_ps2RecompiledFunctionTable[154338] = bhEne03_0x1969c0; // 0x196b90 - g_ps2RecompiledFunctionTable[154339] = bhEne03_0x1969c0; // 0x196b94 - g_ps2RecompiledFunctionTable[154340] = bhEne03_0x1969c0; // 0x196b98 - g_ps2RecompiledFunctionTable[154341] = bhEne03_0x1969c0; // 0x196b9c - g_ps2RecompiledFunctionTable[154342] = bhEne03_0x1969c0; // 0x196ba0 - g_ps2RecompiledFunctionTable[154343] = bhEne03_0x1969c0; // 0x196ba4 - g_ps2RecompiledFunctionTable[154344] = bhEne03_0x1969c0; // 0x196ba8 - g_ps2RecompiledFunctionTable[154345] = bhEne03_0x1969c0; // 0x196bac - g_ps2RecompiledFunctionTable[154346] = bhEne03_0x1969c0; // 0x196bb0 - g_ps2RecompiledFunctionTable[154347] = bhEne03_0x1969c0; // 0x196bb4 - g_ps2RecompiledFunctionTable[154348] = bhEne03_0x1969c0; // 0x196bb8 - g_ps2RecompiledFunctionTable[154349] = bhEne03_0x1969c0; // 0x196bbc - g_ps2RecompiledFunctionTable[154350] = bhEne03_0x1969c0; // 0x196bc0 - g_ps2RecompiledFunctionTable[154351] = bhEne03_0x1969c0; // 0x196bc4 - g_ps2RecompiledFunctionTable[154352] = bhEne03_0x1969c0; // 0x196bc8 - g_ps2RecompiledFunctionTable[154353] = bhEne03_0x1969c0; // 0x196bcc - g_ps2RecompiledFunctionTable[154354] = bhEne03_0x1969c0; // 0x196bd0 - g_ps2RecompiledFunctionTable[154355] = bhEne03_0x1969c0; // 0x196bd4 - g_ps2RecompiledFunctionTable[154356] = bhEne03_0x1969c0; // 0x196bd8 - g_ps2RecompiledFunctionTable[154357] = bhEne03_0x1969c0; // 0x196bdc - g_ps2RecompiledFunctionTable[154358] = bhEne03_0x1969c0; // 0x196be0 - g_ps2RecompiledFunctionTable[154359] = bhEne03_0x1969c0; // 0x196be4 - g_ps2RecompiledFunctionTable[154360] = bhEne03_0x1969c0; // 0x196be8 - g_ps2RecompiledFunctionTable[154361] = bhEne03_0x1969c0; // 0x196bec - g_ps2RecompiledFunctionTable[154362] = bhEne03_0x1969c0; // 0x196bf0 - g_ps2RecompiledFunctionTable[154363] = bhEne03_0x1969c0; // 0x196bf4 - g_ps2RecompiledFunctionTable[154364] = bhEne03_0x1969c0; // 0x196bf8 - g_ps2RecompiledFunctionTable[154365] = bhEne03_0x1969c0; // 0x196bfc - g_ps2RecompiledFunctionTable[154366] = bhEne03_0x1969c0; // 0x196c00 - g_ps2RecompiledFunctionTable[154367] = bhEne03_0x1969c0; // 0x196c04 - g_ps2RecompiledFunctionTable[154368] = bhEne03_0x1969c0; // 0x196c08 - g_ps2RecompiledFunctionTable[154369] = bhEne03_0x1969c0; // 0x196c0c - g_ps2RecompiledFunctionTable[154370] = bhEne03_0x1969c0; // 0x196c10 - g_ps2RecompiledFunctionTable[154371] = bhEne03_0x1969c0; // 0x196c14 - g_ps2RecompiledFunctionTable[154372] = bhEne03_0x1969c0; // 0x196c18 - g_ps2RecompiledFunctionTable[154373] = bhEne03_0x1969c0; // 0x196c1c - g_ps2RecompiledFunctionTable[154374] = bhEne03_0x1969c0; // 0x196c20 - g_ps2RecompiledFunctionTable[154375] = bhEne03_0x1969c0; // 0x196c24 - g_ps2RecompiledFunctionTable[154376] = bhEne03_0x1969c0; // 0x196c28 - g_ps2RecompiledFunctionTable[154377] = bhEne03_0x1969c0; // 0x196c2c - g_ps2RecompiledFunctionTable[154378] = bhEne03_0x1969c0; // 0x196c30 - g_ps2RecompiledFunctionTable[154379] = bhEne03_0x1969c0; // 0x196c34 - g_ps2RecompiledFunctionTable[154380] = bhEne03_0x1969c0; // 0x196c38 - g_ps2RecompiledFunctionTable[154381] = bhEne03_0x1969c0; // 0x196c3c - g_ps2RecompiledFunctionTable[154382] = bhEne03_0x1969c0; // 0x196c40 - g_ps2RecompiledFunctionTable[154383] = bhEne03_0x1969c0; // 0x196c44 - g_ps2RecompiledFunctionTable[154384] = bhEne03_0x1969c0; // 0x196c48 - g_ps2RecompiledFunctionTable[154385] = bhEne03_0x1969c0; // 0x196c4c - g_ps2RecompiledFunctionTable[154386] = bhEne03_0x1969c0; // 0x196c50 - g_ps2RecompiledFunctionTable[154387] = bhEne03_0x1969c0; // 0x196c54 - g_ps2RecompiledFunctionTable[154388] = bhEne03_0x1969c0; // 0x196c58 - g_ps2RecompiledFunctionTable[154389] = bhEne03_0x1969c0; // 0x196c5c - g_ps2RecompiledFunctionTable[154390] = bhEne03_0x1969c0; // 0x196c60 - g_ps2RecompiledFunctionTable[154391] = bhEne03_0x1969c0; // 0x196c64 - g_ps2RecompiledFunctionTable[154392] = bhEne03_0x1969c0; // 0x196c68 - g_ps2RecompiledFunctionTable[154393] = bhEne03_0x1969c0; // 0x196c6c - g_ps2RecompiledFunctionTable[154394] = bhEne03_0x1969c0; // 0x196c70 - g_ps2RecompiledFunctionTable[154395] = bhEne03_0x1969c0; // 0x196c74 - g_ps2RecompiledFunctionTable[154396] = bhEne03_0x1969c0; // 0x196c78 - g_ps2RecompiledFunctionTable[154397] = bhEne03_0x1969c0; // 0x196c7c - g_ps2RecompiledFunctionTable[154398] = bhEne03_0x1969c0; // 0x196c80 - g_ps2RecompiledFunctionTable[154399] = bhEne03_0x1969c0; // 0x196c84 - g_ps2RecompiledFunctionTable[154400] = bhEne03_0x1969c0; // 0x196c88 - g_ps2RecompiledFunctionTable[154401] = bhEne03_0x1969c0; // 0x196c8c - g_ps2RecompiledFunctionTable[154402] = bhEne03_0x1969c0; // 0x196c90 - g_ps2RecompiledFunctionTable[154403] = bhEne03_0x1969c0; // 0x196c94 - g_ps2RecompiledFunctionTable[154404] = bhEne03_0x1969c0; // 0x196c98 - g_ps2RecompiledFunctionTable[154405] = bhEne03_0x1969c0; // 0x196c9c - g_ps2RecompiledFunctionTable[154406] = bhEne03_0x1969c0; // 0x196ca0 - g_ps2RecompiledFunctionTable[154407] = bhEne03_0x1969c0; // 0x196ca4 - g_ps2RecompiledFunctionTable[154408] = bhEne03_0x1969c0; // 0x196ca8 - g_ps2RecompiledFunctionTable[154409] = bhEne03_0x1969c0; // 0x196cac - g_ps2RecompiledFunctionTable[154410] = bhEne03_0x1969c0; // 0x196cb0 - g_ps2RecompiledFunctionTable[154411] = bhEne03_0x1969c0; // 0x196cb4 - g_ps2RecompiledFunctionTable[154412] = bhEne03_0x1969c0; // 0x196cb8 - g_ps2RecompiledFunctionTable[154413] = bhEne03_0x1969c0; // 0x196cbc - g_ps2RecompiledFunctionTable[154414] = bhEne03_0x1969c0; // 0x196cc0 - g_ps2RecompiledFunctionTable[154415] = bhEne03_0x1969c0; // 0x196cc4 - g_ps2RecompiledFunctionTable[154416] = bhEne03_0x1969c0; // 0x196cc8 - g_ps2RecompiledFunctionTable[154417] = bhEne03_0x1969c0; // 0x196ccc - g_ps2RecompiledFunctionTable[154418] = bhEne03_0x1969c0; // 0x196cd0 - g_ps2RecompiledFunctionTable[154419] = bhEne03_0x1969c0; // 0x196cd4 - g_ps2RecompiledFunctionTable[154420] = bhEne03_0x1969c0; // 0x196cd8 - g_ps2RecompiledFunctionTable[154421] = bhEne03_0x1969c0; // 0x196cdc - g_ps2RecompiledFunctionTable[154422] = bhEne03_0x1969c0; // 0x196ce0 - g_ps2RecompiledFunctionTable[154423] = bhEne03_0x1969c0; // 0x196ce4 - g_ps2RecompiledFunctionTable[154424] = bhEne03_0x1969c0; // 0x196ce8 - g_ps2RecompiledFunctionTable[154425] = bhEne03_0x1969c0; // 0x196cec - g_ps2RecompiledFunctionTable[154426] = bhEne03_0x1969c0; // 0x196cf0 - g_ps2RecompiledFunctionTable[154427] = bhEne03_0x1969c0; // 0x196cf4 - g_ps2RecompiledFunctionTable[154428] = bhEne03_0x1969c0; // 0x196cf8 - g_ps2RecompiledFunctionTable[154429] = bhEne03_0x1969c0; // 0x196cfc - g_ps2RecompiledFunctionTable[154430] = bhEne03_0x1969c0; // 0x196d00 - g_ps2RecompiledFunctionTable[154431] = bhEne03_0x1969c0; // 0x196d04 - g_ps2RecompiledFunctionTable[154432] = bhEne03_0x1969c0; // 0x196d08 - g_ps2RecompiledFunctionTable[154433] = bhEne03_0x1969c0; // 0x196d0c - g_ps2RecompiledFunctionTable[154434] = bhEne03_Init_0x196d10; // 0x196d10 - g_ps2RecompiledFunctionTable[154477] = bhEne03_Init_0x196d10; // 0x196dbc - g_ps2RecompiledFunctionTable[154488] = bhEne03_Init_0x196d10; // 0x196de8 - g_ps2RecompiledFunctionTable[154499] = bhEne03_Init_0x196d10; // 0x196e14 - g_ps2RecompiledFunctionTable[154514] = bhEne03_Init_0x196d10; // 0x196e50 - g_ps2RecompiledFunctionTable[154526] = bhEne03_Init_0x196d10; // 0x196e80 - g_ps2RecompiledFunctionTable[154549] = bhEne03_Init_0x196d10; // 0x196edc - g_ps2RecompiledFunctionTable[154555] = bhEne03_Init_0x196d10; // 0x196ef4 - g_ps2RecompiledFunctionTable[154599] = bhEne03_Init_0x196d10; // 0x196fa4 - g_ps2RecompiledFunctionTable[154602] = bhEne03_Init_0x196d10; // 0x196fb0 - g_ps2RecompiledFunctionTable[154608] = bhEne03_Init_0x196d10; // 0x196fc8 - g_ps2RecompiledFunctionTable[154641] = bhEne03_Init_0x196d10; // 0x19704c - g_ps2RecompiledFunctionTable[154652] = bhEne03_Init_0x196d10; // 0x197078 - g_ps2RecompiledFunctionTable[154689] = bhEne03_Init_0x196d10; // 0x19710c - g_ps2RecompiledFunctionTable[154699] = bhEne03_Init_0x196d10; // 0x197134 - g_ps2RecompiledFunctionTable[154710] = bhEne03_Init_0x196d10; // 0x197160 - g_ps2RecompiledFunctionTable[154720] = bhEne03_Init_0x196d10; // 0x197188 - g_ps2RecompiledFunctionTable[154723] = bhEne03_Init_0x196d10; // 0x197194 - g_ps2RecompiledFunctionTable[154743] = bhEne03_Init_0x196d10; // 0x1971e4 - g_ps2RecompiledFunctionTable[154751] = bhEne03_Init_0x196d10; // 0x197204 - g_ps2RecompiledFunctionTable[154763] = bhEne03_Init_0x196d10; // 0x197234 - g_ps2RecompiledFunctionTable[154805] = bhEne03_Init_0x196d10; // 0x1972dc - g_ps2RecompiledFunctionTable[154837] = bhEne03_Init_0x196d10; // 0x19735c - g_ps2RecompiledFunctionTable[154845] = bhEne03_Init_0x196d10; // 0x19737c - g_ps2RecompiledFunctionTable[154849] = bhEne03_Init_0x196d10; // 0x19738c - g_ps2RecompiledFunctionTable[154874] = bhEne03_Brain_0x1973f0; // 0x1973f0 - g_ps2RecompiledFunctionTable[154875] = bhEne03_Brain_0x1973f0; // 0x1973f4 - g_ps2RecompiledFunctionTable[154876] = bhEne03_Brain_0x1973f0; // 0x1973f8 - g_ps2RecompiledFunctionTable[154877] = bhEne03_Brain_0x1973f0; // 0x1973fc - g_ps2RecompiledFunctionTable[154878] = bhEne03_Brain_0x1973f0; // 0x197400 - g_ps2RecompiledFunctionTable[154879] = bhEne03_Brain_0x1973f0; // 0x197404 - g_ps2RecompiledFunctionTable[154880] = bhEne03_Brain_0x1973f0; // 0x197408 - g_ps2RecompiledFunctionTable[154881] = bhEne03_Brain_0x1973f0; // 0x19740c - g_ps2RecompiledFunctionTable[154882] = bhEne03_Brain_0x1973f0; // 0x197410 - g_ps2RecompiledFunctionTable[154883] = bhEne03_Brain_0x1973f0; // 0x197414 - g_ps2RecompiledFunctionTable[154884] = bhEne03_Brain_0x1973f0; // 0x197418 - g_ps2RecompiledFunctionTable[154885] = bhEne03_Brain_0x1973f0; // 0x19741c - g_ps2RecompiledFunctionTable[154886] = bhEne03_Brain_0x1973f0; // 0x197420 - g_ps2RecompiledFunctionTable[154887] = bhEne03_Brain_0x1973f0; // 0x197424 - g_ps2RecompiledFunctionTable[154888] = bhEne03_Brain_0x1973f0; // 0x197428 - g_ps2RecompiledFunctionTable[154889] = bhEne03_Brain_0x1973f0; // 0x19742c - g_ps2RecompiledFunctionTable[154890] = bhEne03_Brain_0x1973f0; // 0x197430 - g_ps2RecompiledFunctionTable[154891] = bhEne03_Brain_0x1973f0; // 0x197434 - g_ps2RecompiledFunctionTable[154892] = bhEne03_Brain_0x1973f0; // 0x197438 - g_ps2RecompiledFunctionTable[154893] = bhEne03_Brain_0x1973f0; // 0x19743c - g_ps2RecompiledFunctionTable[154894] = bhEne03_Brain_0x1973f0; // 0x197440 - g_ps2RecompiledFunctionTable[154895] = bhEne03_Brain_0x1973f0; // 0x197444 - g_ps2RecompiledFunctionTable[154896] = bhEne03_Brain_0x1973f0; // 0x197448 - g_ps2RecompiledFunctionTable[154897] = bhEne03_Brain_0x1973f0; // 0x19744c - g_ps2RecompiledFunctionTable[154898] = bhEne03_BR00_0x197450; // 0x197450 - g_ps2RecompiledFunctionTable[154908] = bhEne03_BR00_0x197450; // 0x197478 - g_ps2RecompiledFunctionTable[154913] = bhEne03_BR00_0x197450; // 0x19748c - g_ps2RecompiledFunctionTable[154986] = bhEne03_BR00_0x197450; // 0x1975b0 - g_ps2RecompiledFunctionTable[155002] = bhEne03_BR00_0x197450; // 0x1975f0 - g_ps2RecompiledFunctionTable[155010] = bhEne03_BR00_0x197450; // 0x197610 - g_ps2RecompiledFunctionTable[155023] = bhEne03_BR00_0x197450; // 0x197644 - g_ps2RecompiledFunctionTable[155046] = bhEne03_BR00_0x197450; // 0x1976a0 - g_ps2RecompiledFunctionTable[155056] = bhEne03_BR00_0x197450; // 0x1976c8 - g_ps2RecompiledFunctionTable[155080] = bhEne03_BR00_0x197450; // 0x197728 - g_ps2RecompiledFunctionTable[155098] = bhEne03_BR00_0x197450; // 0x197770 - g_ps2RecompiledFunctionTable[155103] = bhEne03_BR00_0x197450; // 0x197784 - g_ps2RecompiledFunctionTable[155130] = bhEne03_BR00_0x197450; // 0x1977f0 - g_ps2RecompiledFunctionTable[155140] = bhEne03_BR00_0x197450; // 0x197818 - g_ps2RecompiledFunctionTable[155162] = bhEne03_BR00_0x197450; // 0x197870 - g_ps2RecompiledFunctionTable[155190] = bhEne03_BR01_0x1978e0; // 0x1978e0 - g_ps2RecompiledFunctionTable[155219] = bhEne03_BR01_0x1978e0; // 0x197954 - g_ps2RecompiledFunctionTable[155225] = bhEne03_BR01_0x1978e0; // 0x19796c - g_ps2RecompiledFunctionTable[155231] = bhEne03_BR01_0x1978e0; // 0x197984 - g_ps2RecompiledFunctionTable[155236] = bhEne03_BR01_0x1978e0; // 0x197998 - g_ps2RecompiledFunctionTable[155275] = bhEne03_BR01_0x1978e0; // 0x197a34 - g_ps2RecompiledFunctionTable[155301] = bhEne03_BR01_0x1978e0; // 0x197a9c - g_ps2RecompiledFunctionTable[155333] = bhEne03_BR01_0x1978e0; // 0x197b1c - g_ps2RecompiledFunctionTable[155349] = bhEne03_BR01_0x1978e0; // 0x197b5c - g_ps2RecompiledFunctionTable[155379] = bhEne03_BR01_0x1978e0; // 0x197bd4 - g_ps2RecompiledFunctionTable[155387] = bhEne03_BR01_0x1978e0; // 0x197bf4 - g_ps2RecompiledFunctionTable[155400] = bhEne03_BR01_0x1978e0; // 0x197c28 - g_ps2RecompiledFunctionTable[155428] = bhEne03_BR01_0x1978e0; // 0x197c98 - g_ps2RecompiledFunctionTable[155448] = bhEne03_BR01_0x1978e0; // 0x197ce8 - g_ps2RecompiledFunctionTable[155462] = bhEne03_BR02_0x197d20; // 0x197d20 - g_ps2RecompiledFunctionTable[155471] = bhEne03_BR02_0x197d20; // 0x197d44 - g_ps2RecompiledFunctionTable[155476] = bhEne03_BR02_0x197d20; // 0x197d58 - g_ps2RecompiledFunctionTable[155493] = bhEne03_BR02_0x197d20; // 0x197d9c - g_ps2RecompiledFunctionTable[155503] = bhEne03_BR02_0x197d20; // 0x197dc4 - g_ps2RecompiledFunctionTable[155522] = bhEne03_Move_0x197e10; // 0x197e10 - g_ps2RecompiledFunctionTable[155523] = bhEne03_Move_0x197e10; // 0x197e14 - g_ps2RecompiledFunctionTable[155524] = bhEne03_Move_0x197e10; // 0x197e18 - g_ps2RecompiledFunctionTable[155525] = bhEne03_Move_0x197e10; // 0x197e1c - g_ps2RecompiledFunctionTable[155526] = bhEne03_Move_0x197e10; // 0x197e20 - g_ps2RecompiledFunctionTable[155527] = bhEne03_Move_0x197e10; // 0x197e24 - g_ps2RecompiledFunctionTable[155528] = bhEne03_Move_0x197e10; // 0x197e28 - g_ps2RecompiledFunctionTable[155529] = bhEne03_Move_0x197e10; // 0x197e2c - g_ps2RecompiledFunctionTable[155530] = bhEne03_Move_0x197e10; // 0x197e30 - g_ps2RecompiledFunctionTable[155531] = bhEne03_Move_0x197e10; // 0x197e34 - g_ps2RecompiledFunctionTable[155532] = bhEne03_Move_0x197e10; // 0x197e38 - g_ps2RecompiledFunctionTable[155533] = bhEne03_Move_0x197e10; // 0x197e3c - g_ps2RecompiledFunctionTable[155534] = bhEne03_Move_0x197e10; // 0x197e40 - g_ps2RecompiledFunctionTable[155535] = bhEne03_Move_0x197e10; // 0x197e44 - g_ps2RecompiledFunctionTable[155536] = bhEne03_Move_0x197e10; // 0x197e48 - g_ps2RecompiledFunctionTable[155537] = bhEne03_Move_0x197e10; // 0x197e4c - g_ps2RecompiledFunctionTable[155538] = bhEne03_Move_0x197e10; // 0x197e50 - g_ps2RecompiledFunctionTable[155539] = bhEne03_Move_0x197e10; // 0x197e54 - g_ps2RecompiledFunctionTable[155540] = bhEne03_Move_0x197e10; // 0x197e58 - g_ps2RecompiledFunctionTable[155541] = bhEne03_Move_0x197e10; // 0x197e5c - g_ps2RecompiledFunctionTable[155542] = bhEne03_Move_0x197e10; // 0x197e60 - g_ps2RecompiledFunctionTable[155543] = bhEne03_Move_0x197e10; // 0x197e64 - g_ps2RecompiledFunctionTable[155544] = bhEne03_Move_0x197e10; // 0x197e68 - g_ps2RecompiledFunctionTable[155545] = bhEne03_Move_0x197e10; // 0x197e6c - g_ps2RecompiledFunctionTable[155546] = bhEne03_Move_0x197e10; // 0x197e70 - g_ps2RecompiledFunctionTable[155547] = bhEne03_Move_0x197e10; // 0x197e74 - g_ps2RecompiledFunctionTable[155548] = bhEne03_Move_0x197e10; // 0x197e78 - g_ps2RecompiledFunctionTable[155549] = bhEne03_Move_0x197e10; // 0x197e7c - g_ps2RecompiledFunctionTable[155550] = bhEne03_Move_0x197e10; // 0x197e80 - g_ps2RecompiledFunctionTable[155551] = bhEne03_Move_0x197e10; // 0x197e84 - g_ps2RecompiledFunctionTable[155552] = bhEne03_Move_0x197e10; // 0x197e88 - g_ps2RecompiledFunctionTable[155553] = bhEne03_Move_0x197e10; // 0x197e8c - g_ps2RecompiledFunctionTable[155554] = bhEne03_Move_0x197e10; // 0x197e90 - g_ps2RecompiledFunctionTable[155555] = bhEne03_Move_0x197e10; // 0x197e94 - g_ps2RecompiledFunctionTable[155558] = bhEne03_MV00_0x197ea0; // 0x197ea0 - g_ps2RecompiledFunctionTable[155595] = bhEne03_MV00_0x197ea0; // 0x197f34 - g_ps2RecompiledFunctionTable[155612] = bhEne03_MV00_0x197ea0; // 0x197f78 - g_ps2RecompiledFunctionTable[155634] = bhEne03_MV01_0x197fd0; // 0x197fd0 - g_ps2RecompiledFunctionTable[155678] = bhEne03_MV01_0x197fd0; // 0x198080 - g_ps2RecompiledFunctionTable[155697] = bhEne03_MV01_0x197fd0; // 0x1980cc - g_ps2RecompiledFunctionTable[155725] = bhEne03_MV01_0x197fd0; // 0x19813c - g_ps2RecompiledFunctionTable[155732] = bhEne03_MV01_0x197fd0; // 0x198158 - g_ps2RecompiledFunctionTable[155742] = bhEne03_MV01_0x197fd0; // 0x198180 - g_ps2RecompiledFunctionTable[155755] = bhEne03_MV01_0x197fd0; // 0x1981b4 - g_ps2RecompiledFunctionTable[155761] = bhEne03_MV01_0x197fd0; // 0x1981cc - g_ps2RecompiledFunctionTable[155791] = bhEne03_MV01_0x197fd0; // 0x198244 - g_ps2RecompiledFunctionTable[155795] = bhEne03_MV01_0x197fd0; // 0x198254 - g_ps2RecompiledFunctionTable[155810] = bhEne03_MV02_0x198290; // 0x198290 - g_ps2RecompiledFunctionTable[155816] = bhEne03_MV02_0x198290; // 0x1982a8 - g_ps2RecompiledFunctionTable[155841] = bhEne03_MV02_0x198290; // 0x19830c - g_ps2RecompiledFunctionTable[155857] = bhEne03_MV02_0x198290; // 0x19834c - g_ps2RecompiledFunctionTable[155870] = bhEne03_MV03_0x198380; // 0x198380 - g_ps2RecompiledFunctionTable[155900] = bhEne03_MV03_0x198380; // 0x1983f8 - g_ps2RecompiledFunctionTable[155923] = bhEne03_MV03_0x198380; // 0x198454 - g_ps2RecompiledFunctionTable[155942] = bhEne03_MV03_0x198380; // 0x1984a0 - g_ps2RecompiledFunctionTable[155949] = bhEne03_MV03_0x198380; // 0x1984bc - g_ps2RecompiledFunctionTable[155958] = bhEne03_MV03_0x198380; // 0x1984e0 - g_ps2RecompiledFunctionTable[155974] = bhEne03_MV03_0x198380; // 0x198520 - g_ps2RecompiledFunctionTable[155989] = bhEne03_MV03_0x198380; // 0x19855c - g_ps2RecompiledFunctionTable[155993] = bhEne03_MV03_0x198380; // 0x19856c - g_ps2RecompiledFunctionTable[156007] = bhEne03_MV03_0x198380; // 0x1985a4 - g_ps2RecompiledFunctionTable[156014] = bhEne03_MV03_0x198380; // 0x1985c0 - g_ps2RecompiledFunctionTable[156018] = bhEne03_MV03_0x198380; // 0x1985d0 - g_ps2RecompiledFunctionTable[156030] = bhEne03_MV04_0x198600; // 0x198600 - g_ps2RecompiledFunctionTable[156046] = bhEne03_MV04_0x198600; // 0x198640 - g_ps2RecompiledFunctionTable[156055] = bhEne03_MV04_0x198600; // 0x198664 - g_ps2RecompiledFunctionTable[156070] = bhEne03_MV04_0x198600; // 0x1986a0 - g_ps2RecompiledFunctionTable[156074] = bhEne03_MV04_0x198600; // 0x1986b0 - g_ps2RecompiledFunctionTable[156080] = bhEne03_MV04_0x198600; // 0x1986c8 - g_ps2RecompiledFunctionTable[156094] = bhEne03_MV05_0x198700; // 0x198700 - g_ps2RecompiledFunctionTable[156154] = bhEne03_MV05_0x198700; // 0x1987f0 - g_ps2RecompiledFunctionTable[156157] = bhEne03_MV05_0x198700; // 0x1987fc - g_ps2RecompiledFunctionTable[156227] = bhEne03_MV05_0x198700; // 0x198914 - g_ps2RecompiledFunctionTable[156249] = bhEne03_MV05_0x198700; // 0x19896c - g_ps2RecompiledFunctionTable[156286] = bhEne03_MV06_0x198a00; // 0x198a00 - g_ps2RecompiledFunctionTable[156328] = bhEne03_MV06_0x198a00; // 0x198aa8 - g_ps2RecompiledFunctionTable[156333] = bhEne03_MV06_0x198a00; // 0x198abc - g_ps2RecompiledFunctionTable[156341] = bhEne03_MV06_0x198a00; // 0x198adc - g_ps2RecompiledFunctionTable[156346] = bhEne03_MV06_0x198a00; // 0x198af0 - g_ps2RecompiledFunctionTable[156356] = bhEne03_MV06_0x198a00; // 0x198b18 - g_ps2RecompiledFunctionTable[156361] = bhEne03_MV06_0x198a00; // 0x198b2c - g_ps2RecompiledFunctionTable[156371] = bhEne03_MV06_0x198a00; // 0x198b54 - g_ps2RecompiledFunctionTable[156422] = bhEne03_MV07_0x198c20; // 0x198c20 - g_ps2RecompiledFunctionTable[156482] = bhEne03_MV07_0x198c20; // 0x198d10 - g_ps2RecompiledFunctionTable[156485] = bhEne03_MV07_0x198c20; // 0x198d1c - g_ps2RecompiledFunctionTable[156561] = bhEne03_MV07_0x198c20; // 0x198e4c - g_ps2RecompiledFunctionTable[156583] = bhEne03_MV07_0x198c20; // 0x198ea4 - g_ps2RecompiledFunctionTable[156618] = bhEne03_MV08_0x198f30; // 0x198f30 - g_ps2RecompiledFunctionTable[156672] = bhEne03_MV08_0x198f30; // 0x199008 - g_ps2RecompiledFunctionTable[156677] = bhEne03_MV08_0x198f30; // 0x19901c - g_ps2RecompiledFunctionTable[156685] = bhEne03_MV08_0x198f30; // 0x19903c - g_ps2RecompiledFunctionTable[156690] = bhEne03_MV08_0x198f30; // 0x199050 - g_ps2RecompiledFunctionTable[156700] = bhEne03_MV08_0x198f30; // 0x199078 - g_ps2RecompiledFunctionTable[156705] = bhEne03_MV08_0x198f30; // 0x19908c - g_ps2RecompiledFunctionTable[156715] = bhEne03_MV08_0x198f30; // 0x1990b4 - g_ps2RecompiledFunctionTable[156758] = bhEne03_MV09_0x199160; // 0x199160 - g_ps2RecompiledFunctionTable[156827] = bhEne03_MV09_0x199160; // 0x199274 - g_ps2RecompiledFunctionTable[156860] = bhEne03_MV09_0x199160; // 0x1992f8 - g_ps2RecompiledFunctionTable[156866] = bhEne03_MV10_0x199310; // 0x199310 - g_ps2RecompiledFunctionTable[156916] = bhEne03_MV10_0x199310; // 0x1993d8 - g_ps2RecompiledFunctionTable[156922] = bhEne03_MV11_0x1993f0; // 0x1993f0 - g_ps2RecompiledFunctionTable[156989] = bhEne03_MV11_0x1993f0; // 0x1994fc - g_ps2RecompiledFunctionTable[157007] = bhEne03_MV11_0x1993f0; // 0x199544 - g_ps2RecompiledFunctionTable[157009] = bhEne03_MV11_0x1993f0; // 0x19954c - g_ps2RecompiledFunctionTable[157102] = bhEne03_MV12_0x1996c0; // 0x1996c0 - g_ps2RecompiledFunctionTable[157106] = bhEne03_MV13_0x1996d0; // 0x1996d0 - g_ps2RecompiledFunctionTable[157110] = bhEne03_MV14_0x1996e0; // 0x1996e0 - g_ps2RecompiledFunctionTable[157162] = bhEne03_MV14_0x1996e0; // 0x1997b0 - g_ps2RecompiledFunctionTable[157201] = bhEne03_MV14_0x1996e0; // 0x19984c - g_ps2RecompiledFunctionTable[157282] = bhEne03_MV15_0x199990; // 0x199990 - g_ps2RecompiledFunctionTable[157339] = bhEne03_MV15_0x199990; // 0x199a74 - g_ps2RecompiledFunctionTable[157371] = bhEne03_MV15_0x199990; // 0x199af4 - g_ps2RecompiledFunctionTable[157380] = bhEne03_MV15_0x199990; // 0x199b18 - g_ps2RecompiledFunctionTable[157382] = bhEne03_MV15_0x199990; // 0x199b20 - g_ps2RecompiledFunctionTable[157384] = bhEne03_MV15_0x199990; // 0x199b28 - g_ps2RecompiledFunctionTable[157389] = bhEne03_MV15_0x199990; // 0x199b3c - g_ps2RecompiledFunctionTable[157393] = bhEne03_MV15_0x199990; // 0x199b4c - g_ps2RecompiledFunctionTable[157396] = bhEne03_MV15_0x199990; // 0x199b58 - g_ps2RecompiledFunctionTable[157398] = bhEne03_MV15_0x199990; // 0x199b60 - g_ps2RecompiledFunctionTable[157405] = bhEne03_MV15_0x199990; // 0x199b7c - g_ps2RecompiledFunctionTable[157490] = bhEne03_MV16_0x199cd0; // 0x199cd0 - g_ps2RecompiledFunctionTable[157560] = bhEne03_MV16_0x199cd0; // 0x199de8 - g_ps2RecompiledFunctionTable[157569] = bhEne03_MV16_0x199cd0; // 0x199e0c - g_ps2RecompiledFunctionTable[157576] = bhEne03_MV16_0x199cd0; // 0x199e28 - g_ps2RecompiledFunctionTable[157606] = bhEne03_MV17_0x199ea0; // 0x199ea0 - g_ps2RecompiledFunctionTable[157626] = bhEne03_MV17_0x199ea0; // 0x199ef0 - g_ps2RecompiledFunctionTable[157651] = bhEne03_MV17_0x199ea0; // 0x199f54 - g_ps2RecompiledFunctionTable[157673] = bhEne03_MV17_0x199ea0; // 0x199fac - g_ps2RecompiledFunctionTable[157675] = bhEne03_MV17_0x199ea0; // 0x199fb4 - g_ps2RecompiledFunctionTable[157685] = bhEne03_MV17_0x199ea0; // 0x199fdc - g_ps2RecompiledFunctionTable[157698] = bhEne03_MV17_0x199ea0; // 0x19a010 - g_ps2RecompiledFunctionTable[157722] = bhEne03_MV17_0x199ea0; // 0x19a070 - g_ps2RecompiledFunctionTable[157733] = bhEne03_MV17_0x199ea0; // 0x19a09c - g_ps2RecompiledFunctionTable[157737] = bhEne03_MV17_0x199ea0; // 0x19a0ac - g_ps2RecompiledFunctionTable[157750] = bhEne03_MV18_0x19a0e0; // 0x19a0e0 - g_ps2RecompiledFunctionTable[157801] = bhEne03_MV18_0x19a0e0; // 0x19a1ac - g_ps2RecompiledFunctionTable[157831] = bhEne03_MV18_0x19a0e0; // 0x19a224 - g_ps2RecompiledFunctionTable[157840] = bhEne03_MV18_0x19a0e0; // 0x19a248 - g_ps2RecompiledFunctionTable[157842] = bhEne03_MV18_0x19a0e0; // 0x19a250 - g_ps2RecompiledFunctionTable[157844] = bhEne03_MV18_0x19a0e0; // 0x19a258 - g_ps2RecompiledFunctionTable[157849] = bhEne03_MV18_0x19a0e0; // 0x19a26c - g_ps2RecompiledFunctionTable[157853] = bhEne03_MV18_0x19a0e0; // 0x19a27c - g_ps2RecompiledFunctionTable[157856] = bhEne03_MV18_0x19a0e0; // 0x19a288 - g_ps2RecompiledFunctionTable[157858] = bhEne03_MV18_0x19a0e0; // 0x19a290 - g_ps2RecompiledFunctionTable[157870] = bhEne03_MV18_0x19a0e0; // 0x19a2c0 - g_ps2RecompiledFunctionTable[157946] = bhEne03_MV19_0x19a3f0; // 0x19a3f0 - g_ps2RecompiledFunctionTable[157989] = bhEne03_MV19_0x19a3f0; // 0x19a49c - g_ps2RecompiledFunctionTable[157994] = bhEne03_MV19_0x19a3f0; // 0x19a4b0 - g_ps2RecompiledFunctionTable[158008] = bhEne03_MV19_0x19a3f0; // 0x19a4e8 - g_ps2RecompiledFunctionTable[158014] = bhEne03_MV19_0x19a3f0; // 0x19a500 - g_ps2RecompiledFunctionTable[158020] = bhEne03_MV19_0x19a3f0; // 0x19a518 - g_ps2RecompiledFunctionTable[158042] = bhEne03_MV19_0x19a3f0; // 0x19a570 - g_ps2RecompiledFunctionTable[158058] = bhEne03_MV19_0x19a3f0; // 0x19a5b0 - g_ps2RecompiledFunctionTable[158066] = bhEne03_MV19_0x19a3f0; // 0x19a5d0 - g_ps2RecompiledFunctionTable[158077] = bhEne03_MV19_0x19a3f0; // 0x19a5fc - g_ps2RecompiledFunctionTable[158086] = bhEne03_MV19_0x19a3f0; // 0x19a620 - g_ps2RecompiledFunctionTable[158101] = bhEne03_MV19_0x19a3f0; // 0x19a65c - g_ps2RecompiledFunctionTable[158117] = bhEne03_MV19_0x19a3f0; // 0x19a69c - g_ps2RecompiledFunctionTable[158125] = bhEne03_MV19_0x19a3f0; // 0x19a6bc - g_ps2RecompiledFunctionTable[158136] = bhEne03_MV19_0x19a3f0; // 0x19a6e8 - g_ps2RecompiledFunctionTable[158146] = bhEne03_MV19_0x19a3f0; // 0x19a710 - g_ps2RecompiledFunctionTable[158162] = bhEne03_MV19_0x19a3f0; // 0x19a750 - g_ps2RecompiledFunctionTable[158167] = bhEne03_MV19_0x19a3f0; // 0x19a764 - g_ps2RecompiledFunctionTable[158196] = bhEne03_MV19_0x19a3f0; // 0x19a7d8 - g_ps2RecompiledFunctionTable[158206] = bhEne03_Nage_0x19a800; // 0x19a800 - g_ps2RecompiledFunctionTable[158207] = bhEne03_Nage_0x19a800; // 0x19a804 - g_ps2RecompiledFunctionTable[158208] = bhEne03_Nage_0x19a800; // 0x19a808 - g_ps2RecompiledFunctionTable[158209] = bhEne03_Nage_0x19a800; // 0x19a80c - g_ps2RecompiledFunctionTable[158210] = bhEne03_Nage_0x19a800; // 0x19a810 - g_ps2RecompiledFunctionTable[158211] = bhEne03_Nage_0x19a800; // 0x19a814 - g_ps2RecompiledFunctionTable[158212] = bhEne03_Nage_0x19a800; // 0x19a818 - g_ps2RecompiledFunctionTable[158213] = bhEne03_Nage_0x19a800; // 0x19a81c - g_ps2RecompiledFunctionTable[158214] = bhEne03_NG00_0x19a820; // 0x19a820 - g_ps2RecompiledFunctionTable[158260] = bhEne03_NG00_0x19a820; // 0x19a8d8 - g_ps2RecompiledFunctionTable[158292] = bhEne03_NG00_0x19a820; // 0x19a958 - g_ps2RecompiledFunctionTable[158354] = bhEne03_NG00_0x19a820; // 0x19aa50 - g_ps2RecompiledFunctionTable[158376] = bhEne03_NG00_0x19a820; // 0x19aaa8 - g_ps2RecompiledFunctionTable[158472] = bhEne03_NG00_0x19a820; // 0x19ac28 - g_ps2RecompiledFunctionTable[158482] = bhEne03_NG00_0x19a820; // 0x19ac50 - g_ps2RecompiledFunctionTable[158495] = bhEne03_NG00_0x19a820; // 0x19ac84 - g_ps2RecompiledFunctionTable[158498] = bhEne03_NG00_0x19a820; // 0x19ac90 - g_ps2RecompiledFunctionTable[158513] = bhEne03_NG00_0x19a820; // 0x19accc - g_ps2RecompiledFunctionTable[158516] = bhEne03_NG00_0x19a820; // 0x19acd8 - g_ps2RecompiledFunctionTable[158535] = bhEne03_NG00_0x19a820; // 0x19ad24 - g_ps2RecompiledFunctionTable[158568] = bhEne03_NG00_0x19a820; // 0x19ada8 - g_ps2RecompiledFunctionTable[158606] = bhEne03_NG00_0x19a820; // 0x19ae40 - g_ps2RecompiledFunctionTable[158615] = bhEne03_NG00_0x19a820; // 0x19ae64 - g_ps2RecompiledFunctionTable[158627] = bhEne03_NG00_0x19a820; // 0x19ae94 - g_ps2RecompiledFunctionTable[158630] = bhEne03_NG00_0x19a820; // 0x19aea0 - g_ps2RecompiledFunctionTable[158643] = bhEne03_NG00_0x19a820; // 0x19aed4 - g_ps2RecompiledFunctionTable[158646] = bhEne03_NG00_0x19a820; // 0x19aee0 - g_ps2RecompiledFunctionTable[158664] = bhEne03_NG00_0x19a820; // 0x19af28 - g_ps2RecompiledFunctionTable[158686] = bhEne03_NG00_0x19a820; // 0x19af80 - g_ps2RecompiledFunctionTable[158689] = bhEne03_NG00_0x19a820; // 0x19af8c - g_ps2RecompiledFunctionTable[158708] = bhEne03_NG00_0x19a820; // 0x19afd8 - g_ps2RecompiledFunctionTable[158745] = bhEne03_NG00_0x19a820; // 0x19b06c - g_ps2RecompiledFunctionTable[158759] = bhEne03_NG00_0x19a820; // 0x19b0a4 - g_ps2RecompiledFunctionTable[158774] = bhEne03_NG01_0x19b0e0; // 0x19b0e0 - g_ps2RecompiledFunctionTable[158817] = bhEne03_NG01_0x19b0e0; // 0x19b18c - g_ps2RecompiledFunctionTable[158849] = bhEne03_NG01_0x19b0e0; // 0x19b20c - g_ps2RecompiledFunctionTable[158915] = bhEne03_NG01_0x19b0e0; // 0x19b314 - g_ps2RecompiledFunctionTable[158974] = bhEne03_NG01_0x19b0e0; // 0x19b400 - g_ps2RecompiledFunctionTable[158977] = bhEne03_NG01_0x19b0e0; // 0x19b40c - g_ps2RecompiledFunctionTable[158996] = bhEne03_NG01_0x19b0e0; // 0x19b458 - g_ps2RecompiledFunctionTable[159033] = bhEne03_NG01_0x19b0e0; // 0x19b4ec - g_ps2RecompiledFunctionTable[159047] = bhEne03_NG01_0x19b0e0; // 0x19b524 - g_ps2RecompiledFunctionTable[159067] = bhEne03_NG01_0x19b0e0; // 0x19b574 - g_ps2RecompiledFunctionTable[159077] = bhEne03_NG01_0x19b0e0; // 0x19b59c - g_ps2RecompiledFunctionTable[159099] = bhEne03_NG01_0x19b0e0; // 0x19b5f4 - g_ps2RecompiledFunctionTable[159115] = bhEne03_NG01_0x19b0e0; // 0x19b634 - g_ps2RecompiledFunctionTable[159127] = bhEne03_NG01_0x19b0e0; // 0x19b664 - g_ps2RecompiledFunctionTable[159142] = bhEne03_NG01_0x19b0e0; // 0x19b6a0 - g_ps2RecompiledFunctionTable[159145] = bhEne03_NG01_0x19b0e0; // 0x19b6ac - g_ps2RecompiledFunctionTable[159164] = bhEne03_NG01_0x19b0e0; // 0x19b6f8 - g_ps2RecompiledFunctionTable[159194] = bhEne03_NG01_0x19b0e0; // 0x19b770 - g_ps2RecompiledFunctionTable[159248] = bhEne03_NG01_0x19b0e0; // 0x19b848 - g_ps2RecompiledFunctionTable[159257] = bhEne03_NG01_0x19b0e0; // 0x19b86c - g_ps2RecompiledFunctionTable[159269] = bhEne03_NG01_0x19b0e0; // 0x19b89c - g_ps2RecompiledFunctionTable[159272] = bhEne03_NG01_0x19b0e0; // 0x19b8a8 - g_ps2RecompiledFunctionTable[159285] = bhEne03_NG01_0x19b0e0; // 0x19b8dc - g_ps2RecompiledFunctionTable[159288] = bhEne03_NG01_0x19b0e0; // 0x19b8e8 - g_ps2RecompiledFunctionTable[159307] = bhEne03_NG01_0x19b0e0; // 0x19b934 - g_ps2RecompiledFunctionTable[159326] = bhEne03_Damage_0x19b980; // 0x19b980 - g_ps2RecompiledFunctionTable[159327] = bhEne03_Damage_0x19b980; // 0x19b984 - g_ps2RecompiledFunctionTable[159328] = bhEne03_Damage_0x19b980; // 0x19b988 - g_ps2RecompiledFunctionTable[159329] = bhEne03_Damage_0x19b980; // 0x19b98c - g_ps2RecompiledFunctionTable[159330] = bhEne03_Damage_0x19b980; // 0x19b990 - g_ps2RecompiledFunctionTable[159331] = bhEne03_Damage_0x19b980; // 0x19b994 - g_ps2RecompiledFunctionTable[159332] = bhEne03_Damage_0x19b980; // 0x19b998 - g_ps2RecompiledFunctionTable[159333] = bhEne03_Damage_0x19b980; // 0x19b99c - g_ps2RecompiledFunctionTable[159334] = bhEne03_Damage_0x19b980; // 0x19b9a0 - g_ps2RecompiledFunctionTable[159335] = bhEne03_Damage_0x19b980; // 0x19b9a4 - g_ps2RecompiledFunctionTable[159336] = bhEne03_Damage_0x19b980; // 0x19b9a8 - g_ps2RecompiledFunctionTable[159337] = bhEne03_Damage_0x19b980; // 0x19b9ac - g_ps2RecompiledFunctionTable[159338] = bhEne03_Damage_0x19b980; // 0x19b9b0 - g_ps2RecompiledFunctionTable[159339] = bhEne03_Damage_0x19b980; // 0x19b9b4 - g_ps2RecompiledFunctionTable[159340] = bhEne03_Damage_0x19b980; // 0x19b9b8 - g_ps2RecompiledFunctionTable[159341] = bhEne03_Damage_0x19b980; // 0x19b9bc - g_ps2RecompiledFunctionTable[159342] = bhEne03_Damage_0x19b980; // 0x19b9c0 - g_ps2RecompiledFunctionTable[159343] = bhEne03_Damage_0x19b980; // 0x19b9c4 - g_ps2RecompiledFunctionTable[159344] = bhEne03_Damage_0x19b980; // 0x19b9c8 - g_ps2RecompiledFunctionTable[159345] = bhEne03_Damage_0x19b980; // 0x19b9cc - g_ps2RecompiledFunctionTable[159346] = bhEne03_Damage_0x19b980; // 0x19b9d0 - g_ps2RecompiledFunctionTable[159347] = bhEne03_Damage_0x19b980; // 0x19b9d4 - g_ps2RecompiledFunctionTable[159348] = bhEne03_Damage_0x19b980; // 0x19b9d8 - g_ps2RecompiledFunctionTable[159349] = bhEne03_Damage_0x19b980; // 0x19b9dc - g_ps2RecompiledFunctionTable[159350] = bhEne03_Damage_0x19b980; // 0x19b9e0 - g_ps2RecompiledFunctionTable[159351] = bhEne03_Damage_0x19b980; // 0x19b9e4 - g_ps2RecompiledFunctionTable[159352] = bhEne03_Damage_0x19b980; // 0x19b9e8 - g_ps2RecompiledFunctionTable[159353] = bhEne03_Damage_0x19b980; // 0x19b9ec - g_ps2RecompiledFunctionTable[159354] = bhEne03_Damage_0x19b980; // 0x19b9f0 - g_ps2RecompiledFunctionTable[159355] = bhEne03_Damage_0x19b980; // 0x19b9f4 - g_ps2RecompiledFunctionTable[159356] = bhEne03_Damage_0x19b980; // 0x19b9f8 - g_ps2RecompiledFunctionTable[159357] = bhEne03_Damage_0x19b980; // 0x19b9fc - g_ps2RecompiledFunctionTable[159358] = bhEne03_Damage_0x19b980; // 0x19ba00 - g_ps2RecompiledFunctionTable[159359] = bhEne03_Damage_0x19b980; // 0x19ba04 - g_ps2RecompiledFunctionTable[159360] = bhEne03_Damage_0x19b980; // 0x19ba08 - g_ps2RecompiledFunctionTable[159361] = bhEne03_Damage_0x19b980; // 0x19ba0c - g_ps2RecompiledFunctionTable[159362] = bhEne03_Damage_0x19b980; // 0x19ba10 - g_ps2RecompiledFunctionTable[159363] = bhEne03_Damage_0x19b980; // 0x19ba14 - g_ps2RecompiledFunctionTable[159364] = bhEne03_Damage_0x19b980; // 0x19ba18 - g_ps2RecompiledFunctionTable[159365] = bhEne03_Damage_0x19b980; // 0x19ba1c - g_ps2RecompiledFunctionTable[159366] = bhEne03_Damage_0x19b980; // 0x19ba20 - g_ps2RecompiledFunctionTable[159367] = bhEne03_Damage_0x19b980; // 0x19ba24 - g_ps2RecompiledFunctionTable[159368] = bhEne03_Damage_0x19b980; // 0x19ba28 - g_ps2RecompiledFunctionTable[159369] = bhEne03_Damage_0x19b980; // 0x19ba2c - g_ps2RecompiledFunctionTable[159370] = bhEne03_Damage_0x19b980; // 0x19ba30 - g_ps2RecompiledFunctionTable[159371] = bhEne03_Damage_0x19b980; // 0x19ba34 - g_ps2RecompiledFunctionTable[159372] = bhEne03_Damage_0x19b980; // 0x19ba38 - g_ps2RecompiledFunctionTable[159373] = bhEne03_Damage_0x19b980; // 0x19ba3c - g_ps2RecompiledFunctionTable[159374] = bhEne03_Damage_0x19b980; // 0x19ba40 - g_ps2RecompiledFunctionTable[159375] = bhEne03_Damage_0x19b980; // 0x19ba44 - g_ps2RecompiledFunctionTable[159376] = bhEne03_Damage_0x19b980; // 0x19ba48 - g_ps2RecompiledFunctionTable[159377] = bhEne03_Damage_0x19b980; // 0x19ba4c - g_ps2RecompiledFunctionTable[159378] = bhEne03_Damage_0x19b980; // 0x19ba50 - g_ps2RecompiledFunctionTable[159379] = bhEne03_Damage_0x19b980; // 0x19ba54 - g_ps2RecompiledFunctionTable[159380] = bhEne03_Damage_0x19b980; // 0x19ba58 - g_ps2RecompiledFunctionTable[159381] = bhEne03_Damage_0x19b980; // 0x19ba5c - g_ps2RecompiledFunctionTable[159382] = bhEne03_Damage_0x19b980; // 0x19ba60 - g_ps2RecompiledFunctionTable[159383] = bhEne03_Damage_0x19b980; // 0x19ba64 - g_ps2RecompiledFunctionTable[159384] = bhEne03_Damage_0x19b980; // 0x19ba68 - g_ps2RecompiledFunctionTable[159385] = bhEne03_Damage_0x19b980; // 0x19ba6c - g_ps2RecompiledFunctionTable[159386] = bhEne03_Damage_0x19b980; // 0x19ba70 - g_ps2RecompiledFunctionTable[159387] = bhEne03_Damage_0x19b980; // 0x19ba74 - g_ps2RecompiledFunctionTable[159388] = bhEne03_Damage_0x19b980; // 0x19ba78 - g_ps2RecompiledFunctionTable[159389] = bhEne03_Damage_0x19b980; // 0x19ba7c - g_ps2RecompiledFunctionTable[159390] = bhEne03_Damage_0x19b980; // 0x19ba80 - g_ps2RecompiledFunctionTable[159391] = bhEne03_Damage_0x19b980; // 0x19ba84 - g_ps2RecompiledFunctionTable[159392] = bhEne03_Damage_0x19b980; // 0x19ba88 - g_ps2RecompiledFunctionTable[159393] = bhEne03_Damage_0x19b980; // 0x19ba8c - g_ps2RecompiledFunctionTable[159394] = bhEne03_Damage_0x19b980; // 0x19ba90 - g_ps2RecompiledFunctionTable[159395] = bhEne03_Damage_0x19b980; // 0x19ba94 - g_ps2RecompiledFunctionTable[159396] = bhEne03_Damage_0x19b980; // 0x19ba98 - g_ps2RecompiledFunctionTable[159397] = bhEne03_Damage_0x19b980; // 0x19ba9c - g_ps2RecompiledFunctionTable[159398] = bhEne03_Damage_0x19b980; // 0x19baa0 - g_ps2RecompiledFunctionTable[159399] = bhEne03_Damage_0x19b980; // 0x19baa4 - g_ps2RecompiledFunctionTable[159400] = bhEne03_Damage_0x19b980; // 0x19baa8 - g_ps2RecompiledFunctionTable[159401] = bhEne03_Damage_0x19b980; // 0x19baac - g_ps2RecompiledFunctionTable[159402] = bhEne03_Damage_0x19b980; // 0x19bab0 - g_ps2RecompiledFunctionTable[159403] = bhEne03_Damage_0x19b980; // 0x19bab4 - g_ps2RecompiledFunctionTable[159404] = bhEne03_Damage_0x19b980; // 0x19bab8 - g_ps2RecompiledFunctionTable[159405] = bhEne03_Damage_0x19b980; // 0x19babc - g_ps2RecompiledFunctionTable[159406] = bhEne03_Damage_0x19b980; // 0x19bac0 - g_ps2RecompiledFunctionTable[159407] = bhEne03_Damage_0x19b980; // 0x19bac4 - g_ps2RecompiledFunctionTable[159408] = bhEne03_Damage_0x19b980; // 0x19bac8 - g_ps2RecompiledFunctionTable[159409] = bhEne03_Damage_0x19b980; // 0x19bacc - g_ps2RecompiledFunctionTable[159410] = bhEne03_Damage_0x19b980; // 0x19bad0 - g_ps2RecompiledFunctionTable[159411] = bhEne03_Damage_0x19b980; // 0x19bad4 - g_ps2RecompiledFunctionTable[159412] = bhEne03_Damage_0x19b980; // 0x19bad8 - g_ps2RecompiledFunctionTable[159413] = bhEne03_Damage_0x19b980; // 0x19badc - g_ps2RecompiledFunctionTable[159414] = bhEne03_Damage_0x19b980; // 0x19bae0 - g_ps2RecompiledFunctionTable[159415] = bhEne03_Damage_0x19b980; // 0x19bae4 - g_ps2RecompiledFunctionTable[159416] = bhEne03_Damage_0x19b980; // 0x19bae8 - g_ps2RecompiledFunctionTable[159417] = bhEne03_Damage_0x19b980; // 0x19baec - g_ps2RecompiledFunctionTable[159418] = bhEne03_Damage_0x19b980; // 0x19baf0 - g_ps2RecompiledFunctionTable[159419] = bhEne03_Damage_0x19b980; // 0x19baf4 - g_ps2RecompiledFunctionTable[159420] = bhEne03_Damage_0x19b980; // 0x19baf8 - g_ps2RecompiledFunctionTable[159421] = bhEne03_Damage_0x19b980; // 0x19bafc - g_ps2RecompiledFunctionTable[159422] = bhEne03_Damage_0x19b980; // 0x19bb00 - g_ps2RecompiledFunctionTable[159423] = bhEne03_Damage_0x19b980; // 0x19bb04 - g_ps2RecompiledFunctionTable[159424] = bhEne03_Damage_0x19b980; // 0x19bb08 - g_ps2RecompiledFunctionTable[159425] = bhEne03_Damage_0x19b980; // 0x19bb0c - g_ps2RecompiledFunctionTable[159426] = bhEne03_Damage_0x19b980; // 0x19bb10 - g_ps2RecompiledFunctionTable[159430] = bhEne03_DG00_0x19bb20; // 0x19bb20 - g_ps2RecompiledFunctionTable[159434] = bhEne03_DG01_0x19bb30; // 0x19bb30 - g_ps2RecompiledFunctionTable[159482] = bhEne03_DG02_0x19bbf0; // 0x19bbf0 - g_ps2RecompiledFunctionTable[159520] = bhEne03_DG02_0x19bbf0; // 0x19bc88 - g_ps2RecompiledFunctionTable[159523] = bhEne03_DG02_0x19bbf0; // 0x19bc94 - g_ps2RecompiledFunctionTable[159543] = bhEne03_DG02_0x19bbf0; // 0x19bce4 - g_ps2RecompiledFunctionTable[159654] = bhEne03_DG02_0x19bbf0; // 0x19bea0 - g_ps2RecompiledFunctionTable[159686] = bhEne03_DG03_0x19bf20; // 0x19bf20 - g_ps2RecompiledFunctionTable[159734] = bhEne03_DG04_0x19bfe0; // 0x19bfe0 - g_ps2RecompiledFunctionTable[159784] = bhEne03_DG04_0x19bfe0; // 0x19c0a8 - g_ps2RecompiledFunctionTable[159790] = bhEne03_DG04_0x19bfe0; // 0x19c0c0 - g_ps2RecompiledFunctionTable[159796] = bhEne03_DG04_0x19bfe0; // 0x19c0d8 - g_ps2RecompiledFunctionTable[159801] = bhEne03_DG04_0x19bfe0; // 0x19c0ec - g_ps2RecompiledFunctionTable[159802] = bhEne03_DG04_0x19bfe0; // 0x19c0f0 - g_ps2RecompiledFunctionTable[159806] = bhEne03_DG04_0x19bfe0; // 0x19c100 - g_ps2RecompiledFunctionTable[159822] = bhEne03_DG04_0x19bfe0; // 0x19c140 - g_ps2RecompiledFunctionTable[159841] = bhEne03_DG04_0x19bfe0; // 0x19c18c - g_ps2RecompiledFunctionTable[159863] = bhEne03_DG04_0x19bfe0; // 0x19c1e4 - g_ps2RecompiledFunctionTable[159870] = bhEne03_DG04_0x19bfe0; // 0x19c200 - g_ps2RecompiledFunctionTable[159877] = bhEne03_DG04_0x19bfe0; // 0x19c21c - g_ps2RecompiledFunctionTable[159889] = bhEne03_DG04_0x19bfe0; // 0x19c24c - g_ps2RecompiledFunctionTable[159892] = bhEne03_DG04_0x19bfe0; // 0x19c258 - g_ps2RecompiledFunctionTable[159900] = bhEne03_DG04_0x19bfe0; // 0x19c278 - g_ps2RecompiledFunctionTable[159916] = bhEne03_DG04_0x19bfe0; // 0x19c2b8 - g_ps2RecompiledFunctionTable[159935] = bhEne03_DG04_0x19bfe0; // 0x19c304 - g_ps2RecompiledFunctionTable[159955] = bhEne03_DG04_0x19bfe0; // 0x19c354 - g_ps2RecompiledFunctionTable[159961] = bhEne03_DG04_0x19bfe0; // 0x19c36c - g_ps2RecompiledFunctionTable[159986] = bhEne03_DG05_0x19c3d0; // 0x19c3d0 - g_ps2RecompiledFunctionTable[159990] = bhEne03_DG06_0x19c3e0; // 0x19c3e0 - g_ps2RecompiledFunctionTable[160034] = bhEne03_DG07_0x19c490; // 0x19c490 - g_ps2RecompiledFunctionTable[160080] = bhEne03_DG07_0x19c490; // 0x19c548 - g_ps2RecompiledFunctionTable[160102] = bhEne03_DG07_0x19c490; // 0x19c5a0 - g_ps2RecompiledFunctionTable[160107] = bhEne03_DG07_0x19c490; // 0x19c5b4 - g_ps2RecompiledFunctionTable[160112] = bhEne03_DG07_0x19c490; // 0x19c5c8 - g_ps2RecompiledFunctionTable[160117] = bhEne03_DG07_0x19c490; // 0x19c5dc - g_ps2RecompiledFunctionTable[160122] = bhEne03_DG07_0x19c490; // 0x19c5f0 - g_ps2RecompiledFunctionTable[160125] = bhEne03_DG07_0x19c490; // 0x19c5fc - g_ps2RecompiledFunctionTable[160127] = bhEne03_DG07_0x19c490; // 0x19c604 - g_ps2RecompiledFunctionTable[160134] = bhEne03_DG07_0x19c490; // 0x19c620 - g_ps2RecompiledFunctionTable[160202] = bhEne03_DG08_0x19c730; // 0x19c730 - g_ps2RecompiledFunctionTable[160239] = bhEne03_DG08_0x19c730; // 0x19c7c4 - g_ps2RecompiledFunctionTable[160262] = bhEne03_DG09_0x19c820; // 0x19c820 - g_ps2RecompiledFunctionTable[160299] = bhEne03_DG09_0x19c820; // 0x19c8b4 - g_ps2RecompiledFunctionTable[160322] = bhEne03_DG10_0x19c910; // 0x19c910 - g_ps2RecompiledFunctionTable[160412] = bhEne03_DG10_0x19c910; // 0x19ca78 - g_ps2RecompiledFunctionTable[160440] = bhEne03_DG10_0x19c910; // 0x19cae8 - g_ps2RecompiledFunctionTable[160449] = bhEne03_DG10_0x19c910; // 0x19cb0c - g_ps2RecompiledFunctionTable[160451] = bhEne03_DG10_0x19c910; // 0x19cb14 - g_ps2RecompiledFunctionTable[160453] = bhEne03_DG10_0x19c910; // 0x19cb1c - g_ps2RecompiledFunctionTable[160458] = bhEne03_DG10_0x19c910; // 0x19cb30 - g_ps2RecompiledFunctionTable[160466] = bhEne03_DG10_0x19c910; // 0x19cb50 - g_ps2RecompiledFunctionTable[160469] = bhEne03_DG10_0x19c910; // 0x19cb5c - g_ps2RecompiledFunctionTable[160471] = bhEne03_DG10_0x19c910; // 0x19cb64 - g_ps2RecompiledFunctionTable[160488] = bhEne03_DG10_0x19c910; // 0x19cba8 - g_ps2RecompiledFunctionTable[160522] = bhEne03_DG10_0x19c910; // 0x19cc30 - g_ps2RecompiledFunctionTable[160550] = bhEne03_DG11_0x19cca0; // 0x19cca0 - g_ps2RecompiledFunctionTable[160569] = bhEne03_DG11_0x19cca0; // 0x19ccec - g_ps2RecompiledFunctionTable[160588] = bhEne03_DG11_0x19cca0; // 0x19cd38 - g_ps2RecompiledFunctionTable[160684] = bhEne03_DG11_0x19cca0; // 0x19ceb8 - g_ps2RecompiledFunctionTable[160693] = bhEne03_DG11_0x19cca0; // 0x19cedc - g_ps2RecompiledFunctionTable[160695] = bhEne03_DG11_0x19cca0; // 0x19cee4 - g_ps2RecompiledFunctionTable[160697] = bhEne03_DG11_0x19cca0; // 0x19ceec - g_ps2RecompiledFunctionTable[160702] = bhEne03_DG11_0x19cca0; // 0x19cf00 - g_ps2RecompiledFunctionTable[160719] = bhEne03_DG11_0x19cca0; // 0x19cf44 - g_ps2RecompiledFunctionTable[160722] = bhEne03_DG11_0x19cca0; // 0x19cf50 - g_ps2RecompiledFunctionTable[160724] = bhEne03_DG11_0x19cca0; // 0x19cf58 - g_ps2RecompiledFunctionTable[160729] = bhEne03_DG11_0x19cca0; // 0x19cf6c - g_ps2RecompiledFunctionTable[160737] = bhEne03_DG11_0x19cca0; // 0x19cf8c - g_ps2RecompiledFunctionTable[160740] = bhEne03_DG11_0x19cca0; // 0x19cf98 - g_ps2RecompiledFunctionTable[160742] = bhEne03_DG11_0x19cca0; // 0x19cfa0 - g_ps2RecompiledFunctionTable[160752] = bhEne03_DG11_0x19cca0; // 0x19cfc8 - g_ps2RecompiledFunctionTable[160862] = bhEne03_DG12_0x19d180; // 0x19d180 - g_ps2RecompiledFunctionTable[160884] = bhEne03_DG12_0x19d180; // 0x19d1d8 - g_ps2RecompiledFunctionTable[160908] = bhEne03_DG12_0x19d180; // 0x19d238 - g_ps2RecompiledFunctionTable[160915] = bhEne03_DG12_0x19d180; // 0x19d254 - g_ps2RecompiledFunctionTable[160938] = bhEne03_DG12_0x19d180; // 0x19d2b0 - g_ps2RecompiledFunctionTable[160984] = bhEne03_DG12_0x19d180; // 0x19d368 - g_ps2RecompiledFunctionTable[160987] = bhEne03_DG12_0x19d180; // 0x19d374 - g_ps2RecompiledFunctionTable[161024] = bhEne03_DG12_0x19d180; // 0x19d408 - g_ps2RecompiledFunctionTable[161033] = bhEne03_DG12_0x19d180; // 0x19d42c - g_ps2RecompiledFunctionTable[161035] = bhEne03_DG12_0x19d180; // 0x19d434 - g_ps2RecompiledFunctionTable[161037] = bhEne03_DG12_0x19d180; // 0x19d43c - g_ps2RecompiledFunctionTable[161042] = bhEne03_DG12_0x19d180; // 0x19d450 - g_ps2RecompiledFunctionTable[161050] = bhEne03_DG12_0x19d180; // 0x19d470 - g_ps2RecompiledFunctionTable[161053] = bhEne03_DG12_0x19d180; // 0x19d47c - g_ps2RecompiledFunctionTable[161055] = bhEne03_DG12_0x19d180; // 0x19d484 - g_ps2RecompiledFunctionTable[161060] = bhEne03_DG12_0x19d180; // 0x19d498 - g_ps2RecompiledFunctionTable[161068] = bhEne03_DG12_0x19d180; // 0x19d4b8 - g_ps2RecompiledFunctionTable[161071] = bhEne03_DG12_0x19d180; // 0x19d4c4 - g_ps2RecompiledFunctionTable[161073] = bhEne03_DG12_0x19d180; // 0x19d4cc - g_ps2RecompiledFunctionTable[161083] = bhEne03_DG12_0x19d180; // 0x19d4f4 - g_ps2RecompiledFunctionTable[161153] = bhEne03_DG12_0x19d180; // 0x19d60c - g_ps2RecompiledFunctionTable[161174] = bhEne03_Die_0x19d660; // 0x19d660 - g_ps2RecompiledFunctionTable[161175] = bhEne03_Die_0x19d660; // 0x19d664 - g_ps2RecompiledFunctionTable[161176] = bhEne03_Die_0x19d660; // 0x19d668 - g_ps2RecompiledFunctionTable[161177] = bhEne03_Die_0x19d660; // 0x19d66c - g_ps2RecompiledFunctionTable[161178] = bhEne03_Die_0x19d660; // 0x19d670 - g_ps2RecompiledFunctionTable[161179] = bhEne03_Die_0x19d660; // 0x19d674 - g_ps2RecompiledFunctionTable[161180] = bhEne03_Die_0x19d660; // 0x19d678 - g_ps2RecompiledFunctionTable[161181] = bhEne03_Die_0x19d660; // 0x19d67c - g_ps2RecompiledFunctionTable[161182] = bhEne03_DD00_0x19d680; // 0x19d680 - g_ps2RecompiledFunctionTable[161219] = bhEne03_DD00_0x19d680; // 0x19d714 - g_ps2RecompiledFunctionTable[161268] = bhEne03_DD00_0x19d680; // 0x19d7d8 - g_ps2RecompiledFunctionTable[161285] = bhEne03_DD00_0x19d680; // 0x19d81c - g_ps2RecompiledFunctionTable[161292] = bhEne03_DD00_0x19d680; // 0x19d838 - g_ps2RecompiledFunctionTable[161298] = bhEne03_DD01_0x19d850; // 0x19d850 - g_ps2RecompiledFunctionTable[161336] = bhEne03_DD01_0x19d850; // 0x19d8e8 - g_ps2RecompiledFunctionTable[161355] = bhEne03_DD01_0x19d850; // 0x19d934 - g_ps2RecompiledFunctionTable[161403] = bhEne03_DD01_0x19d850; // 0x19d9f4 - g_ps2RecompiledFunctionTable[161423] = bhEne03_DD01_0x19d850; // 0x19da44 - g_ps2RecompiledFunctionTable[161479] = bhEne03_DD01_0x19d850; // 0x19db24 - g_ps2RecompiledFunctionTable[161488] = bhEne03_DD01_0x19d850; // 0x19db48 - g_ps2RecompiledFunctionTable[161490] = bhEne03_DD01_0x19d850; // 0x19db50 - g_ps2RecompiledFunctionTable[161492] = bhEne03_DD01_0x19d850; // 0x19db58 - g_ps2RecompiledFunctionTable[161497] = bhEne03_DD01_0x19d850; // 0x19db6c - g_ps2RecompiledFunctionTable[161514] = bhEne03_DD01_0x19d850; // 0x19dbb0 - g_ps2RecompiledFunctionTable[161517] = bhEne03_DD01_0x19d850; // 0x19dbbc - g_ps2RecompiledFunctionTable[161519] = bhEne03_DD01_0x19d850; // 0x19dbc4 - g_ps2RecompiledFunctionTable[161529] = bhEne03_DD01_0x19d850; // 0x19dbec - g_ps2RecompiledFunctionTable[161591] = bhEne03_DD01_0x19d850; // 0x19dce4 - g_ps2RecompiledFunctionTable[161598] = bhEne03_DD01_0x19d850; // 0x19dd00 - g_ps2RecompiledFunctionTable[161618] = bhEne03_DD02_0x19dd50; // 0x19dd50 - g_ps2RecompiledFunctionTable[161654] = bhEne03_DD02_0x19dd50; // 0x19dde0 - g_ps2RecompiledFunctionTable[161674] = bhEne03_DD02_0x19dd50; // 0x19de30 - g_ps2RecompiledFunctionTable[161731] = bhEne03_DD02_0x19dd50; // 0x19df14 - g_ps2RecompiledFunctionTable[161795] = bhEne03_DD02_0x19dd50; // 0x19e014 - g_ps2RecompiledFunctionTable[161806] = bhEne03_DD02_0x19dd50; // 0x19e040 - g_ps2RecompiledFunctionTable[161813] = bhEne03_DD02_0x19dd50; // 0x19e05c - g_ps2RecompiledFunctionTable[161830] = bhEne03_DD03_0x19e0a0; // 0x19e0a0 - g_ps2RecompiledFunctionTable[161853] = bhEne03_DD03_0x19e0a0; // 0x19e0fc - g_ps2RecompiledFunctionTable[161860] = bhEne03_DD03_0x19e0a0; // 0x19e118 - g_ps2RecompiledFunctionTable[161866] = bhEne03_DD03_0x19e0a0; // 0x19e130 - g_ps2RecompiledFunctionTable[161872] = bhEne03_DD03_0x19e0a0; // 0x19e148 - g_ps2RecompiledFunctionTable[161877] = bhEne03_DD03_0x19e0a0; // 0x19e15c - g_ps2RecompiledFunctionTable[161966] = bhEne03_DD03_0x19e0a0; // 0x19e2c0 - g_ps2RecompiledFunctionTable[161969] = bhEne03_DD03_0x19e0a0; // 0x19e2cc - g_ps2RecompiledFunctionTable[161972] = bhEne03_DD03_0x19e0a0; // 0x19e2d8 - g_ps2RecompiledFunctionTable[161975] = bhEne03_DD03_0x19e0a0; // 0x19e2e4 - g_ps2RecompiledFunctionTable[161978] = bhEne03_DD03_0x19e0a0; // 0x19e2f0 - g_ps2RecompiledFunctionTable[161981] = bhEne03_DD03_0x19e0a0; // 0x19e2fc - g_ps2RecompiledFunctionTable[161984] = bhEne03_DD03_0x19e0a0; // 0x19e308 - g_ps2RecompiledFunctionTable[161987] = bhEne03_DD03_0x19e0a0; // 0x19e314 - g_ps2RecompiledFunctionTable[161998] = bhEne03_DD04_0x19e340; // 0x19e340 - g_ps2RecompiledFunctionTable[162016] = bhEne03_DD04_0x19e340; // 0x19e388 - g_ps2RecompiledFunctionTable[162113] = bhEne03_DD04_0x19e340; // 0x19e50c - g_ps2RecompiledFunctionTable[162135] = bhEne03_DD04_0x19e340; // 0x19e564 - g_ps2RecompiledFunctionTable[162140] = bhEne03_DD04_0x19e340; // 0x19e578 - g_ps2RecompiledFunctionTable[162145] = bhEne03_DD04_0x19e340; // 0x19e58c - g_ps2RecompiledFunctionTable[162150] = bhEne03_DD04_0x19e340; // 0x19e5a0 - g_ps2RecompiledFunctionTable[162155] = bhEne03_DD04_0x19e340; // 0x19e5b4 - g_ps2RecompiledFunctionTable[162158] = bhEne03_DD04_0x19e340; // 0x19e5c0 - g_ps2RecompiledFunctionTable[162160] = bhEne03_DD04_0x19e340; // 0x19e5c8 - g_ps2RecompiledFunctionTable[162167] = bhEne03_DD04_0x19e340; // 0x19e5e4 - g_ps2RecompiledFunctionTable[162274] = bhEne03_DD05_0x19e790; // 0x19e790 - g_ps2RecompiledFunctionTable[162326] = bhEne03_DD05_0x19e790; // 0x19e860 - g_ps2RecompiledFunctionTable[162333] = bhEne03_DD05_0x19e790; // 0x19e87c - g_ps2RecompiledFunctionTable[162338] = bhEne03_DGDirCheck_0x19e890; // 0x19e890 - g_ps2RecompiledFunctionTable[162355] = bhEne03_DGDirCheck_0x19e890; // 0x19e8d4 - g_ps2RecompiledFunctionTable[162370] = bhEne03_SearchPlayer_0x19e910; // 0x19e910 - g_ps2RecompiledFunctionTable[162395] = bhEne03_SearchPlayer_0x19e910; // 0x19e974 - g_ps2RecompiledFunctionTable[162397] = bhEne03_SearchPlayer_0x19e910; // 0x19e97c - g_ps2RecompiledFunctionTable[162401] = bhEne03_SearchPlayer_0x19e910; // 0x19e98c - g_ps2RecompiledFunctionTable[162404] = bhEne03_SearchPlayer_0x19e910; // 0x19e998 - g_ps2RecompiledFunctionTable[162409] = bhEne03_SearchPlayer_0x19e910; // 0x19e9ac - g_ps2RecompiledFunctionTable[162448] = bhEne03_SearchPlayer_0x19e910; // 0x19ea48 - g_ps2RecompiledFunctionTable[162478] = bhEne03_DirTarget_0x19eac0; // 0x19eac0 - g_ps2RecompiledFunctionTable[162499] = bhEne03_DirTarget_0x19eac0; // 0x19eb14 - g_ps2RecompiledFunctionTable[162501] = bhEne03_DirTarget_0x19eac0; // 0x19eb1c - g_ps2RecompiledFunctionTable[162505] = bhEne03_DirTarget_0x19eac0; // 0x19eb2c - g_ps2RecompiledFunctionTable[162508] = bhEne03_DirTarget_0x19eac0; // 0x19eb38 - g_ps2RecompiledFunctionTable[162511] = bhEne03_DirTarget_0x19eac0; // 0x19eb44 - g_ps2RecompiledFunctionTable[162526] = bhEne03_GoAHead_0x19eb80; // 0x19eb80 - g_ps2RecompiledFunctionTable[162550] = bhEne03_GetPartsPos_0x19ebe0; // 0x19ebe0 - g_ps2RecompiledFunctionTable[162561] = bhEne03_GetPartsPos_0x19ebe0; // 0x19ec0c - g_ps2RecompiledFunctionTable[162563] = bhEne03_GetPartsPos_0x19ebe0; // 0x19ec14 - g_ps2RecompiledFunctionTable[162565] = bhEne03_GetPartsPos_0x19ebe0; // 0x19ec1c - g_ps2RecompiledFunctionTable[162568] = bhEne03_GetPartsPos_0x19ebe0; // 0x19ec28 - g_ps2RecompiledFunctionTable[162571] = bhEne03_GetPartsPos_0x19ebe0; // 0x19ec34 - g_ps2RecompiledFunctionTable[162580] = bhEne03_GetPartsPos_0x19ebe0; // 0x19ec58 - g_ps2RecompiledFunctionTable[162583] = bhEne03_GetPartsPos_0x19ebe0; // 0x19ec64 - g_ps2RecompiledFunctionTable[162591] = bhEne03_GetPartsPos_0x19ebe0; // 0x19ec84 - g_ps2RecompiledFunctionTable[162593] = bhEne03_GetPartsPos_0x19ebe0; // 0x19ec8c - g_ps2RecompiledFunctionTable[162602] = bhEne03_MakeMatrix_0x19ecb0; // 0x19ecb0 - g_ps2RecompiledFunctionTable[162618] = bhEne03_MakeMatrix_0x19ecb0; // 0x19ecf0 - g_ps2RecompiledFunctionTable[162633] = bhEne03_MakeMatrix_0x19ecb0; // 0x19ed2c - g_ps2RecompiledFunctionTable[162636] = bhEne03_MakeMatrix_0x19ecb0; // 0x19ed38 - g_ps2RecompiledFunctionTable[162641] = bhEne03_MakeMatrix_0x19ecb0; // 0x19ed4c - g_ps2RecompiledFunctionTable[162644] = bhEne03_MakeMatrix_0x19ecb0; // 0x19ed58 - g_ps2RecompiledFunctionTable[162647] = bhEne03_MakeMatrix_0x19ecb0; // 0x19ed64 - g_ps2RecompiledFunctionTable[162652] = bhEne03_MakeMatrix_0x19ecb0; // 0x19ed78 - g_ps2RecompiledFunctionTable[162656] = bhEne03_MakeMatrix_0x19ecb0; // 0x19ed88 - g_ps2RecompiledFunctionTable[162659] = bhEne03_MakeMatrix_0x19ecb0; // 0x19ed94 - g_ps2RecompiledFunctionTable[162662] = bhEne03_MakeMatrix_0x19ecb0; // 0x19eda0 - g_ps2RecompiledFunctionTable[162667] = bhEne03_MakeMatrix_0x19ecb0; // 0x19edb4 - g_ps2RecompiledFunctionTable[162671] = bhEne03_MakeMatrix_0x19ecb0; // 0x19edc4 - g_ps2RecompiledFunctionTable[162674] = bhEne03_MakeMatrix_0x19ecb0; // 0x19edd0 - g_ps2RecompiledFunctionTable[162679] = bhEne03_MakeMatrix_0x19ecb0; // 0x19ede4 - g_ps2RecompiledFunctionTable[162683] = bhEne03_MakeMatrix_0x19ecb0; // 0x19edf4 - g_ps2RecompiledFunctionTable[162686] = bhEne03_MakeMatrix_0x19ecb0; // 0x19ee00 - g_ps2RecompiledFunctionTable[162691] = bhEne03_MakeMatrix_0x19ecb0; // 0x19ee14 - g_ps2RecompiledFunctionTable[162695] = bhEne03_MakeMatrix_0x19ecb0; // 0x19ee24 - g_ps2RecompiledFunctionTable[162698] = bhEne03_MakeMatrix_0x19ecb0; // 0x19ee30 - g_ps2RecompiledFunctionTable[162701] = bhEne03_MakeMatrix_0x19ecb0; // 0x19ee3c - g_ps2RecompiledFunctionTable[162710] = bhEne03_HidePartsSub0_0x19ee60; // 0x19ee60 - g_ps2RecompiledFunctionTable[162722] = bhEne03_HidePartsSub0_0x19ee60; // 0x19ee90 - g_ps2RecompiledFunctionTable[162727] = bhEne03_HidePartsSub0_0x19ee60; // 0x19eea4 - g_ps2RecompiledFunctionTable[162734] = bhEne03_HidePartsSub1_0x19eec0; // 0x19eec0 - g_ps2RecompiledFunctionTable[162747] = bhEne03_HidePartsSub1_0x19eec0; // 0x19eef4 - g_ps2RecompiledFunctionTable[162752] = bhEne03_HidePartsSub1_0x19eec0; // 0x19ef08 - g_ps2RecompiledFunctionTable[162758] = bhEne03_HideParts_0x19ef20; // 0x19ef20 - g_ps2RecompiledFunctionTable[162778] = bhEne03_HideParts_0x19ef20; // 0x19ef70 - g_ps2RecompiledFunctionTable[162789] = bhEne03_HideParts_0x19ef20; // 0x19ef9c - g_ps2RecompiledFunctionTable[162794] = bhEne03_CollisionWalls_0x19efb0; // 0x19efb0 - g_ps2RecompiledFunctionTable[162819] = bhEne03_CollisionWalls_0x19efb0; // 0x19f014 - g_ps2RecompiledFunctionTable[162843] = bhEne03_CollisionWalls_0x19efb0; // 0x19f074 - g_ps2RecompiledFunctionTable[162847] = bhEne03_CollisionWalls_0x19efb0; // 0x19f084 - g_ps2RecompiledFunctionTable[162867] = bhEne03_CollisionWalls_0x19efb0; // 0x19f0d4 - g_ps2RecompiledFunctionTable[162919] = bhEne03_CollisionWalls_0x19efb0; // 0x19f1a4 - g_ps2RecompiledFunctionTable[162946] = bhEne03_CollisionWalls_0x19efb0; // 0x19f210 - g_ps2RecompiledFunctionTable[162976] = bhEne03_CollisionWalls_0x19efb0; // 0x19f288 - g_ps2RecompiledFunctionTable[163008] = bhEne03_CollisionWalls_0x19efb0; // 0x19f308 - g_ps2RecompiledFunctionTable[163035] = bhEne03_CollisionWalls_0x19efb0; // 0x19f374 - g_ps2RecompiledFunctionTable[163098] = bhEne03_GetWall_0x19f470; // 0x19f470 - g_ps2RecompiledFunctionTable[163141] = bhEne03_GetWall_0x19f470; // 0x19f51c - g_ps2RecompiledFunctionTable[163146] = bhEne03_Collision_0x19f530; // 0x19f530 - g_ps2RecompiledFunctionTable[163147] = bhEne03_Collision_0x19f530; // 0x19f534 - g_ps2RecompiledFunctionTable[163148] = bhEne03_Collision_0x19f530; // 0x19f538 - g_ps2RecompiledFunctionTable[163149] = bhEne03_Collision_0x19f530; // 0x19f53c - g_ps2RecompiledFunctionTable[163150] = bhEne03_Collision_0x19f530; // 0x19f540 - g_ps2RecompiledFunctionTable[163151] = bhEne03_Collision_0x19f530; // 0x19f544 - g_ps2RecompiledFunctionTable[163152] = bhEne03_Collision_0x19f530; // 0x19f548 - g_ps2RecompiledFunctionTable[163153] = bhEne03_Collision_0x19f530; // 0x19f54c - g_ps2RecompiledFunctionTable[163154] = bhEne03_Collision_0x19f530; // 0x19f550 - g_ps2RecompiledFunctionTable[163155] = bhEne03_Collision_0x19f530; // 0x19f554 - g_ps2RecompiledFunctionTable[163156] = bhEne03_Collision_0x19f530; // 0x19f558 - g_ps2RecompiledFunctionTable[163157] = bhEne03_Collision_0x19f530; // 0x19f55c - g_ps2RecompiledFunctionTable[163158] = bhEne03_Collision_0x19f530; // 0x19f560 - g_ps2RecompiledFunctionTable[163159] = bhEne03_Collision_0x19f530; // 0x19f564 - g_ps2RecompiledFunctionTable[163160] = bhEne03_Collision_0x19f530; // 0x19f568 - g_ps2RecompiledFunctionTable[163161] = bhEne03_Collision_0x19f530; // 0x19f56c - g_ps2RecompiledFunctionTable[163162] = bhEne03_Collision_0x19f530; // 0x19f570 - g_ps2RecompiledFunctionTable[163163] = bhEne03_Collision_0x19f530; // 0x19f574 - g_ps2RecompiledFunctionTable[163164] = bhEne03_Collision_0x19f530; // 0x19f578 - g_ps2RecompiledFunctionTable[163165] = bhEne03_Collision_0x19f530; // 0x19f57c - g_ps2RecompiledFunctionTable[163166] = bhEne03_Collision_0x19f530; // 0x19f580 - g_ps2RecompiledFunctionTable[163167] = bhEne03_Collision_0x19f530; // 0x19f584 - g_ps2RecompiledFunctionTable[163168] = bhEne03_Collision_0x19f530; // 0x19f588 - g_ps2RecompiledFunctionTable[163169] = bhEne03_Collision_0x19f530; // 0x19f58c - g_ps2RecompiledFunctionTable[163170] = bhEne03_Collision_0x19f530; // 0x19f590 - g_ps2RecompiledFunctionTable[163171] = bhEne03_Collision_0x19f530; // 0x19f594 - g_ps2RecompiledFunctionTable[163172] = bhEne03_Collision_0x19f530; // 0x19f598 - g_ps2RecompiledFunctionTable[163173] = bhEne03_Collision_0x19f530; // 0x19f59c - g_ps2RecompiledFunctionTable[163174] = bhEne03_Collision_0x19f530; // 0x19f5a0 - g_ps2RecompiledFunctionTable[163175] = bhEne03_Collision_0x19f530; // 0x19f5a4 - g_ps2RecompiledFunctionTable[163176] = bhEne03_Collision_0x19f530; // 0x19f5a8 - g_ps2RecompiledFunctionTable[163177] = bhEne03_Collision_0x19f530; // 0x19f5ac - g_ps2RecompiledFunctionTable[163178] = bhEne03_Collision_0x19f530; // 0x19f5b0 - g_ps2RecompiledFunctionTable[163179] = bhEne03_Collision_0x19f530; // 0x19f5b4 - g_ps2RecompiledFunctionTable[163180] = bhEne03_Collision_0x19f530; // 0x19f5b8 - g_ps2RecompiledFunctionTable[163181] = bhEne03_Collision_0x19f530; // 0x19f5bc - g_ps2RecompiledFunctionTable[163182] = bhEne03_Collision_0x19f530; // 0x19f5c0 - g_ps2RecompiledFunctionTable[163183] = bhEne03_Collision_0x19f530; // 0x19f5c4 - g_ps2RecompiledFunctionTable[163184] = bhEne03_Collision_0x19f530; // 0x19f5c8 - g_ps2RecompiledFunctionTable[163185] = bhEne03_Collision_0x19f530; // 0x19f5cc - g_ps2RecompiledFunctionTable[163186] = bhEne03_Collision_0x19f530; // 0x19f5d0 - g_ps2RecompiledFunctionTable[163187] = bhEne03_Collision_0x19f530; // 0x19f5d4 - g_ps2RecompiledFunctionTable[163188] = bhEne03_Collision_0x19f530; // 0x19f5d8 - g_ps2RecompiledFunctionTable[163189] = bhEne03_Collision_0x19f530; // 0x19f5dc - g_ps2RecompiledFunctionTable[163190] = bhEne03_Collision_0x19f530; // 0x19f5e0 - g_ps2RecompiledFunctionTable[163191] = bhEne03_Collision_0x19f530; // 0x19f5e4 - g_ps2RecompiledFunctionTable[163192] = bhEne03_Collision_0x19f530; // 0x19f5e8 - g_ps2RecompiledFunctionTable[163193] = bhEne03_Collision_0x19f530; // 0x19f5ec - g_ps2RecompiledFunctionTable[163194] = bhEne03_Collision_0x19f530; // 0x19f5f0 - g_ps2RecompiledFunctionTable[163195] = bhEne03_Collision_0x19f530; // 0x19f5f4 - g_ps2RecompiledFunctionTable[163196] = bhEne03_Collision_0x19f530; // 0x19f5f8 - g_ps2RecompiledFunctionTable[163197] = bhEne03_Collision_0x19f530; // 0x19f5fc - g_ps2RecompiledFunctionTable[163198] = bhEne03_Collision_0x19f530; // 0x19f600 - g_ps2RecompiledFunctionTable[163199] = bhEne03_Collision_0x19f530; // 0x19f604 - g_ps2RecompiledFunctionTable[163200] = bhEne03_Collision_0x19f530; // 0x19f608 - g_ps2RecompiledFunctionTable[163201] = bhEne03_Collision_0x19f530; // 0x19f60c - g_ps2RecompiledFunctionTable[163202] = bhEne03_Collision_0x19f530; // 0x19f610 - g_ps2RecompiledFunctionTable[163203] = bhEne03_Collision_0x19f530; // 0x19f614 - g_ps2RecompiledFunctionTable[163204] = bhEne03_Collision_0x19f530; // 0x19f618 - g_ps2RecompiledFunctionTable[163205] = bhEne03_Collision_0x19f530; // 0x19f61c - g_ps2RecompiledFunctionTable[163206] = bhEne03_Collision_0x19f530; // 0x19f620 - g_ps2RecompiledFunctionTable[163207] = bhEne03_Collision_0x19f530; // 0x19f624 - g_ps2RecompiledFunctionTable[163208] = bhEne03_Collision_0x19f530; // 0x19f628 - g_ps2RecompiledFunctionTable[163209] = bhEne03_Collision_0x19f530; // 0x19f62c - g_ps2RecompiledFunctionTable[163210] = bhEne03_Collision_0x19f530; // 0x19f630 - g_ps2RecompiledFunctionTable[163211] = bhEne03_Collision_0x19f530; // 0x19f634 - g_ps2RecompiledFunctionTable[163212] = bhEne03_Collision_0x19f530; // 0x19f638 - g_ps2RecompiledFunctionTable[163213] = bhEne03_Collision_0x19f530; // 0x19f63c - g_ps2RecompiledFunctionTable[163214] = bhEne03_Collision_0x19f530; // 0x19f640 - g_ps2RecompiledFunctionTable[163215] = bhEne03_Collision_0x19f530; // 0x19f644 - g_ps2RecompiledFunctionTable[163216] = bhEne03_Collision_0x19f530; // 0x19f648 - g_ps2RecompiledFunctionTable[163217] = bhEne03_Collision_0x19f530; // 0x19f64c - g_ps2RecompiledFunctionTable[163218] = bhEne03_Collision_0x19f530; // 0x19f650 - g_ps2RecompiledFunctionTable[163219] = bhEne03_Collision_0x19f530; // 0x19f654 - g_ps2RecompiledFunctionTable[163220] = bhEne03_Collision_0x19f530; // 0x19f658 - g_ps2RecompiledFunctionTable[163221] = bhEne03_Collision_0x19f530; // 0x19f65c - g_ps2RecompiledFunctionTable[163222] = bhEne03_Collision_0x19f530; // 0x19f660 - g_ps2RecompiledFunctionTable[163223] = bhEne03_Collision_0x19f530; // 0x19f664 - g_ps2RecompiledFunctionTable[163224] = bhEne03_Collision_0x19f530; // 0x19f668 - g_ps2RecompiledFunctionTable[163225] = bhEne03_Collision_0x19f530; // 0x19f66c - g_ps2RecompiledFunctionTable[163226] = bhEne03_Collision_0x19f530; // 0x19f670 - g_ps2RecompiledFunctionTable[163227] = bhEne03_Collision_0x19f530; // 0x19f674 - g_ps2RecompiledFunctionTable[163228] = bhEne03_Collision_0x19f530; // 0x19f678 - g_ps2RecompiledFunctionTable[163229] = bhEne03_Collision_0x19f530; // 0x19f67c - g_ps2RecompiledFunctionTable[163230] = bhEne03_Collision_0x19f530; // 0x19f680 - g_ps2RecompiledFunctionTable[163231] = bhEne03_Collision_0x19f530; // 0x19f684 - g_ps2RecompiledFunctionTable[163232] = bhEne03_Collision_0x19f530; // 0x19f688 - g_ps2RecompiledFunctionTable[163233] = bhEne03_Collision_0x19f530; // 0x19f68c - g_ps2RecompiledFunctionTable[163234] = bhEne03_Collision_0x19f530; // 0x19f690 - g_ps2RecompiledFunctionTable[163235] = bhEne03_Collision_0x19f530; // 0x19f694 - g_ps2RecompiledFunctionTable[163236] = bhEne03_Collision_0x19f530; // 0x19f698 - g_ps2RecompiledFunctionTable[163237] = bhEne03_Collision_0x19f530; // 0x19f69c - g_ps2RecompiledFunctionTable[163238] = bhEne03_Collision_0x19f530; // 0x19f6a0 - g_ps2RecompiledFunctionTable[163239] = bhEne03_Collision_0x19f530; // 0x19f6a4 - g_ps2RecompiledFunctionTable[163240] = bhEne03_Collision_0x19f530; // 0x19f6a8 - g_ps2RecompiledFunctionTable[163241] = bhEne03_Collision_0x19f530; // 0x19f6ac - g_ps2RecompiledFunctionTable[163242] = bhEne03_Collision_0x19f530; // 0x19f6b0 - g_ps2RecompiledFunctionTable[163243] = bhEne03_Collision_0x19f530; // 0x19f6b4 - g_ps2RecompiledFunctionTable[163244] = bhEne03_Collision_0x19f530; // 0x19f6b8 - g_ps2RecompiledFunctionTable[163245] = bhEne03_Collision_0x19f530; // 0x19f6bc - g_ps2RecompiledFunctionTable[163246] = bhEne03_Collision_0x19f530; // 0x19f6c0 - g_ps2RecompiledFunctionTable[163247] = bhEne03_Collision_0x19f530; // 0x19f6c4 - g_ps2RecompiledFunctionTable[163248] = bhEne03_Collision_0x19f530; // 0x19f6c8 - g_ps2RecompiledFunctionTable[163249] = bhEne03_Collision_0x19f530; // 0x19f6cc - g_ps2RecompiledFunctionTable[163250] = bhEne03_Collision_0x19f530; // 0x19f6d0 - g_ps2RecompiledFunctionTable[163251] = bhEne03_Collision_0x19f530; // 0x19f6d4 - g_ps2RecompiledFunctionTable[163252] = bhEne03_Collision_0x19f530; // 0x19f6d8 - g_ps2RecompiledFunctionTable[163253] = bhEne03_Collision_0x19f530; // 0x19f6dc - g_ps2RecompiledFunctionTable[163254] = bhEne03_Collision_0x19f530; // 0x19f6e0 - g_ps2RecompiledFunctionTable[163255] = bhEne03_Collision_0x19f530; // 0x19f6e4 - g_ps2RecompiledFunctionTable[163256] = bhEne03_Collision_0x19f530; // 0x19f6e8 - g_ps2RecompiledFunctionTable[163257] = bhEne03_Collision_0x19f530; // 0x19f6ec - g_ps2RecompiledFunctionTable[163258] = bhEne03_Collision_0x19f530; // 0x19f6f0 - g_ps2RecompiledFunctionTable[163259] = bhEne03_Collision_0x19f530; // 0x19f6f4 - g_ps2RecompiledFunctionTable[163260] = bhEne03_Collision_0x19f530; // 0x19f6f8 - g_ps2RecompiledFunctionTable[163261] = bhEne03_Collision_0x19f530; // 0x19f6fc - g_ps2RecompiledFunctionTable[163262] = bhEne03_Collision_0x19f530; // 0x19f700 - g_ps2RecompiledFunctionTable[163263] = bhEne03_Collision_0x19f530; // 0x19f704 - g_ps2RecompiledFunctionTable[163264] = bhEne03_Collision_0x19f530; // 0x19f708 - g_ps2RecompiledFunctionTable[163265] = bhEne03_Collision_0x19f530; // 0x19f70c - g_ps2RecompiledFunctionTable[163266] = bhEne03_Collision_0x19f530; // 0x19f710 - g_ps2RecompiledFunctionTable[163267] = bhEne03_Collision_0x19f530; // 0x19f714 - g_ps2RecompiledFunctionTable[163268] = bhEne03_Collision_0x19f530; // 0x19f718 - g_ps2RecompiledFunctionTable[163269] = bhEne03_Collision_0x19f530; // 0x19f71c - g_ps2RecompiledFunctionTable[163270] = bhEne03_Collision_0x19f530; // 0x19f720 - g_ps2RecompiledFunctionTable[163271] = bhEne03_Collision_0x19f530; // 0x19f724 - g_ps2RecompiledFunctionTable[163272] = bhEne03_Collision_0x19f530; // 0x19f728 - g_ps2RecompiledFunctionTable[163273] = bhEne03_Collision_0x19f530; // 0x19f72c - g_ps2RecompiledFunctionTable[163274] = bhEne03_Collision_0x19f530; // 0x19f730 - g_ps2RecompiledFunctionTable[163275] = bhEne03_Collision_0x19f530; // 0x19f734 - g_ps2RecompiledFunctionTable[163276] = bhEne03_Collision_0x19f530; // 0x19f738 - g_ps2RecompiledFunctionTable[163277] = bhEne03_Collision_0x19f530; // 0x19f73c - g_ps2RecompiledFunctionTable[163278] = bhEne03_Collision_0x19f530; // 0x19f740 - g_ps2RecompiledFunctionTable[163279] = bhEne03_Collision_0x19f530; // 0x19f744 - g_ps2RecompiledFunctionTable[163280] = bhEne03_Collision_0x19f530; // 0x19f748 - g_ps2RecompiledFunctionTable[163281] = bhEne03_Collision_0x19f530; // 0x19f74c - g_ps2RecompiledFunctionTable[163282] = bhEne03_Collision2_0x19f750; // 0x19f750 - g_ps2RecompiledFunctionTable[163283] = bhEne03_Collision2_0x19f750; // 0x19f754 - g_ps2RecompiledFunctionTable[163284] = bhEne03_Collision2_0x19f750; // 0x19f758 - g_ps2RecompiledFunctionTable[163285] = bhEne03_Collision2_0x19f750; // 0x19f75c - g_ps2RecompiledFunctionTable[163286] = bhEne03_Collision2_0x19f750; // 0x19f760 - g_ps2RecompiledFunctionTable[163287] = bhEne03_Collision2_0x19f750; // 0x19f764 - g_ps2RecompiledFunctionTable[163288] = bhEne03_Collision2_0x19f750; // 0x19f768 - g_ps2RecompiledFunctionTable[163289] = bhEne03_Collision2_0x19f750; // 0x19f76c - g_ps2RecompiledFunctionTable[163290] = bhEne03_Collision2_0x19f750; // 0x19f770 - g_ps2RecompiledFunctionTable[163291] = bhEne03_Collision2_0x19f750; // 0x19f774 - g_ps2RecompiledFunctionTable[163292] = bhEne03_Collision2_0x19f750; // 0x19f778 - g_ps2RecompiledFunctionTable[163293] = bhEne03_Collision2_0x19f750; // 0x19f77c - g_ps2RecompiledFunctionTable[163294] = bhEne03_Collision2_0x19f750; // 0x19f780 - g_ps2RecompiledFunctionTable[163295] = bhEne03_Collision2_0x19f750; // 0x19f784 - g_ps2RecompiledFunctionTable[163296] = bhEne03_Collision2_0x19f750; // 0x19f788 - g_ps2RecompiledFunctionTable[163297] = bhEne03_Collision2_0x19f750; // 0x19f78c - g_ps2RecompiledFunctionTable[163298] = bhEne03_Collision2_0x19f750; // 0x19f790 - g_ps2RecompiledFunctionTable[163299] = bhEne03_Collision2_0x19f750; // 0x19f794 - g_ps2RecompiledFunctionTable[163300] = bhEne03_Collision2_0x19f750; // 0x19f798 - g_ps2RecompiledFunctionTable[163301] = bhEne03_Collision2_0x19f750; // 0x19f79c - g_ps2RecompiledFunctionTable[163302] = bhEne03_Collision2_0x19f750; // 0x19f7a0 - g_ps2RecompiledFunctionTable[163303] = bhEne03_Collision2_0x19f750; // 0x19f7a4 - g_ps2RecompiledFunctionTable[163304] = bhEne03_Collision2_0x19f750; // 0x19f7a8 - g_ps2RecompiledFunctionTable[163305] = bhEne03_Collision2_0x19f750; // 0x19f7ac - g_ps2RecompiledFunctionTable[163306] = bhEne03_Collision2_0x19f750; // 0x19f7b0 - g_ps2RecompiledFunctionTable[163307] = bhEne03_Collision2_0x19f750; // 0x19f7b4 - g_ps2RecompiledFunctionTable[163308] = bhEne03_Collision2_0x19f750; // 0x19f7b8 - g_ps2RecompiledFunctionTable[163309] = bhEne03_Collision2_0x19f750; // 0x19f7bc - g_ps2RecompiledFunctionTable[163310] = bhEne03_Collision2_0x19f750; // 0x19f7c0 - g_ps2RecompiledFunctionTable[163311] = bhEne03_Collision2_0x19f750; // 0x19f7c4 - g_ps2RecompiledFunctionTable[163312] = bhEne03_Collision2_0x19f750; // 0x19f7c8 - g_ps2RecompiledFunctionTable[163313] = bhEne03_Collision2_0x19f750; // 0x19f7cc - g_ps2RecompiledFunctionTable[163314] = bhEne03_Collision2_0x19f750; // 0x19f7d0 - g_ps2RecompiledFunctionTable[163315] = bhEne03_Collision2_0x19f750; // 0x19f7d4 - g_ps2RecompiledFunctionTable[163316] = bhEne03_Collision2_0x19f750; // 0x19f7d8 - g_ps2RecompiledFunctionTable[163317] = bhEne03_Collision2_0x19f750; // 0x19f7dc - g_ps2RecompiledFunctionTable[163318] = bhEne03_Collision2_0x19f750; // 0x19f7e0 - g_ps2RecompiledFunctionTable[163319] = bhEne03_Collision2_0x19f750; // 0x19f7e4 - g_ps2RecompiledFunctionTable[163320] = bhEne03_Collision2_0x19f750; // 0x19f7e8 - g_ps2RecompiledFunctionTable[163321] = bhEne03_Collision2_0x19f750; // 0x19f7ec - g_ps2RecompiledFunctionTable[163322] = bhEne03_Collision2_0x19f750; // 0x19f7f0 - g_ps2RecompiledFunctionTable[163323] = bhEne03_Collision2_0x19f750; // 0x19f7f4 - g_ps2RecompiledFunctionTable[163324] = bhEne03_Collision2_0x19f750; // 0x19f7f8 - g_ps2RecompiledFunctionTable[163325] = bhEne03_Collision2_0x19f750; // 0x19f7fc - g_ps2RecompiledFunctionTable[163326] = bhEne03_Collision2_0x19f750; // 0x19f800 - g_ps2RecompiledFunctionTable[163327] = bhEne03_Collision2_0x19f750; // 0x19f804 - g_ps2RecompiledFunctionTable[163328] = bhEne03_Collision2_0x19f750; // 0x19f808 - g_ps2RecompiledFunctionTable[163329] = bhEne03_Collision2_0x19f750; // 0x19f80c - g_ps2RecompiledFunctionTable[163330] = bhEne03_Collision2_0x19f750; // 0x19f810 - g_ps2RecompiledFunctionTable[163331] = bhEne03_Collision2_0x19f750; // 0x19f814 - g_ps2RecompiledFunctionTable[163332] = bhEne03_Collision2_0x19f750; // 0x19f818 - g_ps2RecompiledFunctionTable[163333] = bhEne03_Collision2_0x19f750; // 0x19f81c - g_ps2RecompiledFunctionTable[163334] = bhEne03_Collision2_0x19f750; // 0x19f820 - g_ps2RecompiledFunctionTable[163335] = bhEne03_Collision2_0x19f750; // 0x19f824 - g_ps2RecompiledFunctionTable[163336] = bhEne03_Collision2_0x19f750; // 0x19f828 - g_ps2RecompiledFunctionTable[163337] = bhEne03_Collision2_0x19f750; // 0x19f82c - g_ps2RecompiledFunctionTable[163338] = bhEne03_Collision2_0x19f750; // 0x19f830 - g_ps2RecompiledFunctionTable[163339] = bhEne03_Collision2_0x19f750; // 0x19f834 - g_ps2RecompiledFunctionTable[163340] = bhEne03_Collision2_0x19f750; // 0x19f838 - g_ps2RecompiledFunctionTable[163341] = bhEne03_Collision2_0x19f750; // 0x19f83c - g_ps2RecompiledFunctionTable[163342] = bhEne03_Collision2_0x19f750; // 0x19f840 - g_ps2RecompiledFunctionTable[163343] = bhEne03_Collision2_0x19f750; // 0x19f844 - g_ps2RecompiledFunctionTable[163344] = bhEne03_Collision2_0x19f750; // 0x19f848 - g_ps2RecompiledFunctionTable[163345] = bhEne03_Collision2_0x19f750; // 0x19f84c - g_ps2RecompiledFunctionTable[163346] = bhEne03_Collision2_0x19f750; // 0x19f850 - g_ps2RecompiledFunctionTable[163347] = bhEne03_Collision2_0x19f750; // 0x19f854 - g_ps2RecompiledFunctionTable[163348] = bhEne03_Collision2_0x19f750; // 0x19f858 - g_ps2RecompiledFunctionTable[163349] = bhEne03_Collision2_0x19f750; // 0x19f85c - g_ps2RecompiledFunctionTable[163350] = bhEne03_Collision2_0x19f750; // 0x19f860 - g_ps2RecompiledFunctionTable[163351] = bhEne03_Collision2_0x19f750; // 0x19f864 - g_ps2RecompiledFunctionTable[163352] = bhEne03_Collision2_0x19f750; // 0x19f868 - g_ps2RecompiledFunctionTable[163353] = bhEne03_Collision2_0x19f750; // 0x19f86c - g_ps2RecompiledFunctionTable[163354] = bhEne03_Collision2_0x19f750; // 0x19f870 - g_ps2RecompiledFunctionTable[163355] = bhEne03_Collision2_0x19f750; // 0x19f874 - g_ps2RecompiledFunctionTable[163356] = bhEne03_Collision2_0x19f750; // 0x19f878 - g_ps2RecompiledFunctionTable[163357] = bhEne03_Collision2_0x19f750; // 0x19f87c - g_ps2RecompiledFunctionTable[163358] = bhEne03_Collision2_0x19f750; // 0x19f880 - g_ps2RecompiledFunctionTable[163359] = bhEne03_Collision2_0x19f750; // 0x19f884 - g_ps2RecompiledFunctionTable[163360] = bhEne03_Collision2_0x19f750; // 0x19f888 - g_ps2RecompiledFunctionTable[163361] = bhEne03_Collision2_0x19f750; // 0x19f88c - g_ps2RecompiledFunctionTable[163362] = bhEne03_Collision2_0x19f750; // 0x19f890 - g_ps2RecompiledFunctionTable[163363] = bhEne03_Collision2_0x19f750; // 0x19f894 - g_ps2RecompiledFunctionTable[163364] = bhEne03_Collision2_0x19f750; // 0x19f898 - g_ps2RecompiledFunctionTable[163365] = bhEne03_Collision2_0x19f750; // 0x19f89c - g_ps2RecompiledFunctionTable[163366] = bhEne03_Collision2_0x19f750; // 0x19f8a0 - g_ps2RecompiledFunctionTable[163367] = bhEne03_Collision2_0x19f750; // 0x19f8a4 - g_ps2RecompiledFunctionTable[163368] = bhEne03_Collision2_0x19f750; // 0x19f8a8 - g_ps2RecompiledFunctionTable[163369] = bhEne03_Collision2_0x19f750; // 0x19f8ac - g_ps2RecompiledFunctionTable[163370] = bhEne03_Collision2_0x19f750; // 0x19f8b0 - g_ps2RecompiledFunctionTable[163371] = bhEne03_Collision2_0x19f750; // 0x19f8b4 - g_ps2RecompiledFunctionTable[163372] = bhEne03_Collision2_0x19f750; // 0x19f8b8 - g_ps2RecompiledFunctionTable[163373] = bhEne03_Collision2_0x19f750; // 0x19f8bc - g_ps2RecompiledFunctionTable[163374] = bhEne03_Collision2_0x19f750; // 0x19f8c0 - g_ps2RecompiledFunctionTable[163375] = bhEne03_Collision2_0x19f750; // 0x19f8c4 - g_ps2RecompiledFunctionTable[163376] = bhEne03_Collision2_0x19f750; // 0x19f8c8 - g_ps2RecompiledFunctionTable[163377] = bhEne03_Collision2_0x19f750; // 0x19f8cc - g_ps2RecompiledFunctionTable[163378] = bhEne03_Collision2_0x19f750; // 0x19f8d0 - g_ps2RecompiledFunctionTable[163379] = bhEne03_Collision2_0x19f750; // 0x19f8d4 - g_ps2RecompiledFunctionTable[163380] = bhEne03_Collision2_0x19f750; // 0x19f8d8 - g_ps2RecompiledFunctionTable[163381] = bhEne03_Collision2_0x19f750; // 0x19f8dc - g_ps2RecompiledFunctionTable[163382] = bhEne03_Collision2_0x19f750; // 0x19f8e0 - g_ps2RecompiledFunctionTable[163383] = bhEne03_Collision2_0x19f750; // 0x19f8e4 - g_ps2RecompiledFunctionTable[163384] = bhEne03_Collision2_0x19f750; // 0x19f8e8 - g_ps2RecompiledFunctionTable[163385] = bhEne03_Collision2_0x19f750; // 0x19f8ec - g_ps2RecompiledFunctionTable[163386] = bhEne03_Collision2_0x19f750; // 0x19f8f0 - g_ps2RecompiledFunctionTable[163387] = bhEne03_Collision2_0x19f750; // 0x19f8f4 - g_ps2RecompiledFunctionTable[163388] = bhEne03_Collision2_0x19f750; // 0x19f8f8 - g_ps2RecompiledFunctionTable[163389] = bhEne03_Collision2_0x19f750; // 0x19f8fc - g_ps2RecompiledFunctionTable[163390] = bhEne03_Collision2_0x19f750; // 0x19f900 - g_ps2RecompiledFunctionTable[163391] = bhEne03_Collision2_0x19f750; // 0x19f904 - g_ps2RecompiledFunctionTable[163392] = bhEne03_Collision2_0x19f750; // 0x19f908 - g_ps2RecompiledFunctionTable[163393] = bhEne03_Collision2_0x19f750; // 0x19f90c - g_ps2RecompiledFunctionTable[163394] = bhEne03_Collision2_0x19f750; // 0x19f910 - g_ps2RecompiledFunctionTable[163395] = bhEne03_Collision2_0x19f750; // 0x19f914 - g_ps2RecompiledFunctionTable[163396] = bhEne03_Collision2_0x19f750; // 0x19f918 - g_ps2RecompiledFunctionTable[163397] = bhEne03_Collision2_0x19f750; // 0x19f91c - g_ps2RecompiledFunctionTable[163398] = bhEne03_Collision2_0x19f750; // 0x19f920 - g_ps2RecompiledFunctionTable[163399] = bhEne03_Collision2_0x19f750; // 0x19f924 - g_ps2RecompiledFunctionTable[163400] = bhEne03_Collision2_0x19f750; // 0x19f928 - g_ps2RecompiledFunctionTable[163401] = bhEne03_Collision2_0x19f750; // 0x19f92c - g_ps2RecompiledFunctionTable[163402] = bhEne03_Collision2_0x19f750; // 0x19f930 - g_ps2RecompiledFunctionTable[163403] = bhEne03_Collision2_0x19f750; // 0x19f934 - g_ps2RecompiledFunctionTable[163404] = bhEne03_Collision2_0x19f750; // 0x19f938 - g_ps2RecompiledFunctionTable[163405] = bhEne03_Collision2_0x19f750; // 0x19f93c - g_ps2RecompiledFunctionTable[163406] = bhEne03_Collision2_0x19f750; // 0x19f940 - g_ps2RecompiledFunctionTable[163407] = bhEne03_Collision2_0x19f750; // 0x19f944 - g_ps2RecompiledFunctionTable[163408] = bhEne03_Collision2_0x19f750; // 0x19f948 - g_ps2RecompiledFunctionTable[163409] = bhEne03_Collision2_0x19f750; // 0x19f94c - g_ps2RecompiledFunctionTable[163410] = bhEne03_Collision2_0x19f750; // 0x19f950 - g_ps2RecompiledFunctionTable[163411] = bhEne03_Collision2_0x19f750; // 0x19f954 - g_ps2RecompiledFunctionTable[163412] = bhEne03_Collision2_0x19f750; // 0x19f958 - g_ps2RecompiledFunctionTable[163413] = bhEne03_Collision2_0x19f750; // 0x19f95c - g_ps2RecompiledFunctionTable[163414] = bhEne03_Collision2_0x19f750; // 0x19f960 - g_ps2RecompiledFunctionTable[163415] = bhEne03_Collision2_0x19f750; // 0x19f964 - g_ps2RecompiledFunctionTable[163416] = bhEne03_Collision2_0x19f750; // 0x19f968 - g_ps2RecompiledFunctionTable[163417] = bhEne03_Collision2_0x19f750; // 0x19f96c - g_ps2RecompiledFunctionTable[163418] = bhEne03_Collision2_0x19f750; // 0x19f970 - g_ps2RecompiledFunctionTable[163419] = bhEne03_Collision2_0x19f750; // 0x19f974 - g_ps2RecompiledFunctionTable[163420] = bhEne03_Collision2_0x19f750; // 0x19f978 - g_ps2RecompiledFunctionTable[163421] = bhEne03_Collision2_0x19f750; // 0x19f97c - g_ps2RecompiledFunctionTable[163422] = bhEne03_Collision2_0x19f750; // 0x19f980 - g_ps2RecompiledFunctionTable[163426] = bhEne03_CollisionWallBox_0x19f990; // 0x19f990 - g_ps2RecompiledFunctionTable[163519] = bhEne03_CollisionWallBox_0x19f990; // 0x19fb04 - g_ps2RecompiledFunctionTable[163523] = bhEne03_CollisionWallBox_0x19f990; // 0x19fb14 - g_ps2RecompiledFunctionTable[163527] = bhEne03_CollisionWallBox_0x19f990; // 0x19fb24 - g_ps2RecompiledFunctionTable[163550] = bhEne03_CollisionWallBox_0x19f990; // 0x19fb80 - g_ps2RecompiledFunctionTable[163584] = bhEne03_CollisionWallBox_0x19f990; // 0x19fc08 - g_ps2RecompiledFunctionTable[163613] = bhEne03_CollisionWallBox_0x19f990; // 0x19fc7c - g_ps2RecompiledFunctionTable[163642] = bhEne03_CollisionWallBox_0x19f990; // 0x19fcf0 - g_ps2RecompiledFunctionTable[163702] = bhEne03_CollisionWallGround_0x19fde0; // 0x19fde0 - g_ps2RecompiledFunctionTable[163748] = bhEne03_CollisionWallGround_0x19fde0; // 0x19fe98 - g_ps2RecompiledFunctionTable[163754] = bhEne03_CollisionWallCylinder_0x19feb0; // 0x19feb0 - g_ps2RecompiledFunctionTable[163788] = bhEne03_CollisionWallCylinder_0x19feb0; // 0x19ff38 - g_ps2RecompiledFunctionTable[163821] = bhEne03_CollisionWallCylinder_0x19feb0; // 0x19ffbc - g_ps2RecompiledFunctionTable[163828] = bhEne03_CollisionWallCylinder_0x19feb0; // 0x19ffd8 - g_ps2RecompiledFunctionTable[163858] = bhEne03_CollisionWallSlope_0x1a0050; // 0x1a0050 - g_ps2RecompiledFunctionTable[163996] = bhEne03_CollisionWallSlope_0x1a0050; // 0x1a0278 - g_ps2RecompiledFunctionTable[164006] = bhEne03_CollisionWallSlope_0x1a0050; // 0x1a02a0 - g_ps2RecompiledFunctionTable[164053] = bhEne03_CollisionWallSlope_0x1a0050; // 0x1a035c - g_ps2RecompiledFunctionTable[164142] = bhEne03_CollisionWallSlope_0x1a0050; // 0x1a04c0 - g_ps2RecompiledFunctionTable[164203] = bhEne03_CollisionWallSlope_0x1a0050; // 0x1a05b4 - g_ps2RecompiledFunctionTable[164246] = bhEne03_CollisionWallTriangle_0x1a0660; // 0x1a0660 - g_ps2RecompiledFunctionTable[164356] = bhEne03_CollisionWallTriangle_0x1a0660; // 0x1a0818 - g_ps2RecompiledFunctionTable[164411] = bhEne03_CollisionWallTriangle_0x1a0660; // 0x1a08f4 - g_ps2RecompiledFunctionTable[164428] = bhEne03_CollisionWallTriangle_0x1a0660; // 0x1a0938 - g_ps2RecompiledFunctionTable[164478] = bhEne03_CollisionWallTriangle_0x1a0660; // 0x1a0a00 - g_ps2RecompiledFunctionTable[164481] = bhEne03_CollisionWallTriangle_0x1a0660; // 0x1a0a0c - g_ps2RecompiledFunctionTable[164537] = bhEne03_CollisionWallTriangle_0x1a0660; // 0x1a0aec - g_ps2RecompiledFunctionTable[164554] = bhEne03_CollisionBoxEdge_0x1a0b30; // 0x1a0b30 - g_ps2RecompiledFunctionTable[164622] = bhEne03_CollisionBoxEdge_0x1a0b30; // 0x1a0c40 - g_ps2RecompiledFunctionTable[164638] = bhEne03_CollisionBoxEdge_0x1a0b30; // 0x1a0c80 - g_ps2RecompiledFunctionTable[164653] = bhEne03_CollisionBoxEdge_0x1a0b30; // 0x1a0cbc - g_ps2RecompiledFunctionTable[164669] = bhEne03_CollisionBoxEdge_0x1a0b30; // 0x1a0cfc - g_ps2RecompiledFunctionTable[164685] = bhEne03_CollisionBoxEdge_0x1a0b30; // 0x1a0d3c - g_ps2RecompiledFunctionTable[164701] = bhEne03_CollisionBoxEdge_0x1a0b30; // 0x1a0d7c - g_ps2RecompiledFunctionTable[164717] = bhEne03_CollisionBoxEdge_0x1a0b30; // 0x1a0dbc - g_ps2RecompiledFunctionTable[164734] = bhEne03_CollisionBoxEdge_0x1a0b30; // 0x1a0e00 - g_ps2RecompiledFunctionTable[164752] = bhEne03_CollisionBoxEdge_0x1a0b30; // 0x1a0e48 - g_ps2RecompiledFunctionTable[164768] = bhEne03_CollisionBoxEdge_0x1a0b30; // 0x1a0e88 - g_ps2RecompiledFunctionTable[164783] = bhEne03_CollisionBoxEdge_0x1a0b30; // 0x1a0ec4 - g_ps2RecompiledFunctionTable[164799] = bhEne03_CollisionBoxEdge_0x1a0b30; // 0x1a0f04 - g_ps2RecompiledFunctionTable[164818] = bhEne03_CollisionBoxEdge2_0x1a0f50; // 0x1a0f50 - g_ps2RecompiledFunctionTable[165056] = bhEne03_CollisionBoxEdge2_0x1a0f50; // 0x1a1308 - g_ps2RecompiledFunctionTable[165068] = bhEne03_CollisionBoxEdge2_0x1a0f50; // 0x1a1338 - g_ps2RecompiledFunctionTable[165072] = bhEne03_CollisionBoxEdge2_0x1a0f50; // 0x1a1348 - g_ps2RecompiledFunctionTable[165081] = bhEne03_CollisionBoxEdge2_0x1a0f50; // 0x1a136c - g_ps2RecompiledFunctionTable[165102] = bhEne03_CollisionLine_0x1a13c0; // 0x1a13c0 - g_ps2RecompiledFunctionTable[165110] = bhEne03_CollisionLine_0x1a13c0; // 0x1a13e0 - g_ps2RecompiledFunctionTable[165115] = bhEne03_CollisionLine_0x1a13c0; // 0x1a13f4 - g_ps2RecompiledFunctionTable[165134] = bhEne03_CollisionLine2_0x1a1440; // 0x1a1440 - g_ps2RecompiledFunctionTable[165156] = bhEne03_CollisionLine2_0x1a1440; // 0x1a1498 - g_ps2RecompiledFunctionTable[165159] = bhEne03_CollisionLine2_0x1a1440; // 0x1a14a4 - g_ps2RecompiledFunctionTable[165162] = bhEne03_CollisionLine2_0x1a1440; // 0x1a14b0 - g_ps2RecompiledFunctionTable[165165] = bhEne03_CollisionLine2_0x1a1440; // 0x1a14bc - g_ps2RecompiledFunctionTable[165168] = bhEne03_CollisionLine2_0x1a1440; // 0x1a14c8 - g_ps2RecompiledFunctionTable[165174] = bhEne03_SetModelFlg_0x1a14e0; // 0x1a14e0 - g_ps2RecompiledFunctionTable[165178] = bhEne03_SetModelFlg_0x1a14e0; // 0x1a14f0 - g_ps2RecompiledFunctionTable[165194] = bhEne03_AddNullTrans_0x1a1530; // 0x1a1530 - g_ps2RecompiledFunctionTable[165207] = bhEne03_AddNullTrans_0x1a1530; // 0x1a1564 - g_ps2RecompiledFunctionTable[165222] = bhEne03_CheckClimbWall_0x1a15a0; // 0x1a15a0 - g_ps2RecompiledFunctionTable[165226] = bhEne03_CheckClimbDownWall_0x1a15b0; // 0x1a15b0 - g_ps2RecompiledFunctionTable[165230] = bhEne03_AvoidWall_0x1a15c0; // 0x1a15c0 - g_ps2RecompiledFunctionTable[165234] = bhEne03_DiveSpace_0x1a15d0; // 0x1a15d0 - g_ps2RecompiledFunctionTable[165257] = bhEne03_DiveSpace_0x1a15d0; // 0x1a162c - g_ps2RecompiledFunctionTable[165301] = bhEne03_DiveSpace_0x1a15d0; // 0x1a16dc - g_ps2RecompiledFunctionTable[165329] = bhEne03_DiveSpace_0x1a15d0; // 0x1a174c - g_ps2RecompiledFunctionTable[165341] = bhEne03_DiveSpace_0x1a15d0; // 0x1a177c - g_ps2RecompiledFunctionTable[165350] = bhEne03_GetWallDir_0x1a17a0; // 0x1a17a0 - g_ps2RecompiledFunctionTable[165398] = bhEne03_DamageInit_0x1a1860; // 0x1a1860 - g_ps2RecompiledFunctionTable[165399] = bhEne03_DamageInit_0x1a1860; // 0x1a1864 - g_ps2RecompiledFunctionTable[165400] = bhEne03_DamageInit_0x1a1860; // 0x1a1868 - g_ps2RecompiledFunctionTable[165401] = bhEne03_DamageInit_0x1a1860; // 0x1a186c - g_ps2RecompiledFunctionTable[165402] = bhEne03_DamageInit_0x1a1860; // 0x1a1870 - g_ps2RecompiledFunctionTable[165403] = bhEne03_DamageInit_0x1a1860; // 0x1a1874 - g_ps2RecompiledFunctionTable[165404] = bhEne03_DamageInit_0x1a1860; // 0x1a1878 - g_ps2RecompiledFunctionTable[165405] = bhEne03_DamageInit_0x1a1860; // 0x1a187c - g_ps2RecompiledFunctionTable[165406] = bhEne03_DamageInit_0x1a1860; // 0x1a1880 - g_ps2RecompiledFunctionTable[165407] = bhEne03_DamageInit_0x1a1860; // 0x1a1884 - g_ps2RecompiledFunctionTable[165408] = bhEne03_DamageInit_0x1a1860; // 0x1a1888 - g_ps2RecompiledFunctionTable[165409] = bhEne03_DamageInit_0x1a1860; // 0x1a188c - g_ps2RecompiledFunctionTable[165410] = bhEne03_DamageInit_0x1a1860; // 0x1a1890 - g_ps2RecompiledFunctionTable[165411] = bhEne03_DamageInit_0x1a1860; // 0x1a1894 - g_ps2RecompiledFunctionTable[165412] = bhEne03_DamageInit_0x1a1860; // 0x1a1898 - g_ps2RecompiledFunctionTable[165413] = bhEne03_DamageInit_0x1a1860; // 0x1a189c - g_ps2RecompiledFunctionTable[165414] = bhEne03_DamageInit_0x1a1860; // 0x1a18a0 - g_ps2RecompiledFunctionTable[165415] = bhEne03_DamageInit_0x1a1860; // 0x1a18a4 - g_ps2RecompiledFunctionTable[165416] = bhEne03_DamageInit_0x1a1860; // 0x1a18a8 - g_ps2RecompiledFunctionTable[165417] = bhEne03_DamageInit_0x1a1860; // 0x1a18ac - g_ps2RecompiledFunctionTable[165418] = bhEne03_DamageInit_0x1a1860; // 0x1a18b0 - g_ps2RecompiledFunctionTable[165419] = bhEne03_DamageInit_0x1a1860; // 0x1a18b4 - g_ps2RecompiledFunctionTable[165420] = bhEne03_DamageInit_0x1a1860; // 0x1a18b8 - g_ps2RecompiledFunctionTable[165421] = bhEne03_DamageInit_0x1a1860; // 0x1a18bc - g_ps2RecompiledFunctionTable[165422] = bhEne03_DamageInit_0x1a1860; // 0x1a18c0 - g_ps2RecompiledFunctionTable[165423] = bhEne03_DamageInit_0x1a1860; // 0x1a18c4 - g_ps2RecompiledFunctionTable[165424] = bhEne03_DamageInit_0x1a1860; // 0x1a18c8 - g_ps2RecompiledFunctionTable[165425] = bhEne03_DamageInit_0x1a1860; // 0x1a18cc - g_ps2RecompiledFunctionTable[165426] = bhEne03_DamageInit_0x1a1860; // 0x1a18d0 - g_ps2RecompiledFunctionTable[165427] = bhEne03_DamageInit_0x1a1860; // 0x1a18d4 - g_ps2RecompiledFunctionTable[165428] = bhEne03_DamageInit_0x1a1860; // 0x1a18d8 - g_ps2RecompiledFunctionTable[165429] = bhEne03_DamageInit_0x1a1860; // 0x1a18dc - g_ps2RecompiledFunctionTable[165430] = bhEne03_DamageInit_0x1a1860; // 0x1a18e0 - g_ps2RecompiledFunctionTable[165431] = bhEne03_DamageInit_0x1a1860; // 0x1a18e4 - g_ps2RecompiledFunctionTable[165432] = bhEne03_DamageInit_0x1a1860; // 0x1a18e8 - g_ps2RecompiledFunctionTable[165433] = bhEne03_DamageInit_0x1a1860; // 0x1a18ec - g_ps2RecompiledFunctionTable[165434] = bhEne03_DamageInit_0x1a1860; // 0x1a18f0 - g_ps2RecompiledFunctionTable[165435] = bhEne03_DamageInit_0x1a1860; // 0x1a18f4 - g_ps2RecompiledFunctionTable[165436] = bhEne03_DamageInit_0x1a1860; // 0x1a18f8 - g_ps2RecompiledFunctionTable[165437] = bhEne03_DamageInit_0x1a1860; // 0x1a18fc - g_ps2RecompiledFunctionTable[165438] = bhEne03_DamageInit_0x1a1860; // 0x1a1900 - g_ps2RecompiledFunctionTable[165439] = bhEne03_DamageInit_0x1a1860; // 0x1a1904 - g_ps2RecompiledFunctionTable[165440] = bhEne03_DamageInit_0x1a1860; // 0x1a1908 - g_ps2RecompiledFunctionTable[165441] = bhEne03_DamageInit_0x1a1860; // 0x1a190c - g_ps2RecompiledFunctionTable[165442] = bhEne03_DamageInit_0x1a1860; // 0x1a1910 - g_ps2RecompiledFunctionTable[165443] = bhEne03_DamageInit_0x1a1860; // 0x1a1914 - g_ps2RecompiledFunctionTable[165444] = bhEne03_DamageInit_0x1a1860; // 0x1a1918 - g_ps2RecompiledFunctionTable[165445] = bhEne03_DamageInit_0x1a1860; // 0x1a191c - g_ps2RecompiledFunctionTable[165446] = bhEne03_DamageInit_0x1a1860; // 0x1a1920 - g_ps2RecompiledFunctionTable[165447] = bhEne03_DamageInit_0x1a1860; // 0x1a1924 - g_ps2RecompiledFunctionTable[165448] = bhEne03_DamageInit_0x1a1860; // 0x1a1928 - g_ps2RecompiledFunctionTable[165449] = bhEne03_DamageInit_0x1a1860; // 0x1a192c - g_ps2RecompiledFunctionTable[165450] = bhEne03_DamageInit_0x1a1860; // 0x1a1930 - g_ps2RecompiledFunctionTable[165451] = bhEne03_DamageInit_0x1a1860; // 0x1a1934 - g_ps2RecompiledFunctionTable[165452] = bhEne03_DamageInit_0x1a1860; // 0x1a1938 - g_ps2RecompiledFunctionTable[165453] = bhEne03_DamageInit_0x1a1860; // 0x1a193c - g_ps2RecompiledFunctionTable[165454] = bhEne03_DamageInit_0x1a1860; // 0x1a1940 - g_ps2RecompiledFunctionTable[165455] = bhEne03_DamageInit_0x1a1860; // 0x1a1944 - g_ps2RecompiledFunctionTable[165456] = bhEne03_DamageInit_0x1a1860; // 0x1a1948 - g_ps2RecompiledFunctionTable[165457] = bhEne03_DamageInit_0x1a1860; // 0x1a194c - g_ps2RecompiledFunctionTable[165458] = bhEne03_DamageInit_0x1a1860; // 0x1a1950 - g_ps2RecompiledFunctionTable[165459] = bhEne03_DamageInit_0x1a1860; // 0x1a1954 - g_ps2RecompiledFunctionTable[165460] = bhEne03_DamageInit_0x1a1860; // 0x1a1958 - g_ps2RecompiledFunctionTable[165461] = bhEne03_DamageInit_0x1a1860; // 0x1a195c - g_ps2RecompiledFunctionTable[165462] = bhEne03_DamageInit_0x1a1860; // 0x1a1960 - g_ps2RecompiledFunctionTable[165463] = bhEne03_DamageInit_0x1a1860; // 0x1a1964 - g_ps2RecompiledFunctionTable[165464] = bhEne03_DamageInit_0x1a1860; // 0x1a1968 - g_ps2RecompiledFunctionTable[165465] = bhEne03_DamageInit_0x1a1860; // 0x1a196c - g_ps2RecompiledFunctionTable[165466] = bhEne03_DamageInit_0x1a1860; // 0x1a1970 - g_ps2RecompiledFunctionTable[165467] = bhEne03_DamageInit_0x1a1860; // 0x1a1974 - g_ps2RecompiledFunctionTable[165468] = bhEne03_DamageInit_0x1a1860; // 0x1a1978 - g_ps2RecompiledFunctionTable[165469] = bhEne03_DamageInit_0x1a1860; // 0x1a197c - g_ps2RecompiledFunctionTable[165470] = bhEne03_DamageInit_0x1a1860; // 0x1a1980 - g_ps2RecompiledFunctionTable[165471] = bhEne03_DamageInit_0x1a1860; // 0x1a1984 - g_ps2RecompiledFunctionTable[165472] = bhEne03_DamageInit_0x1a1860; // 0x1a1988 - g_ps2RecompiledFunctionTable[165473] = bhEne03_DamageInit_0x1a1860; // 0x1a198c - g_ps2RecompiledFunctionTable[165474] = bhEne03_DamageInit_0x1a1860; // 0x1a1990 - g_ps2RecompiledFunctionTable[165475] = bhEne03_DamageInit_0x1a1860; // 0x1a1994 - g_ps2RecompiledFunctionTable[165476] = bhEne03_DamageInit_0x1a1860; // 0x1a1998 - g_ps2RecompiledFunctionTable[165477] = bhEne03_DamageInit_0x1a1860; // 0x1a199c - g_ps2RecompiledFunctionTable[165478] = bhEne03_DamageInit_0x1a1860; // 0x1a19a0 - g_ps2RecompiledFunctionTable[165479] = bhEne03_DamageInit_0x1a1860; // 0x1a19a4 - g_ps2RecompiledFunctionTable[165480] = bhEne03_DamageInit_0x1a1860; // 0x1a19a8 - g_ps2RecompiledFunctionTable[165481] = bhEne03_DamageInit_0x1a1860; // 0x1a19ac - g_ps2RecompiledFunctionTable[165482] = bhEne03_DamageInit_0x1a1860; // 0x1a19b0 - g_ps2RecompiledFunctionTable[165483] = bhEne03_DamageInit_0x1a1860; // 0x1a19b4 - g_ps2RecompiledFunctionTable[165484] = bhEne03_DamageInit_0x1a1860; // 0x1a19b8 - g_ps2RecompiledFunctionTable[165485] = bhEne03_DamageInit_0x1a1860; // 0x1a19bc - g_ps2RecompiledFunctionTable[165486] = bhEne03_DamageInit_0x1a1860; // 0x1a19c0 - g_ps2RecompiledFunctionTable[165487] = bhEne03_DamageInit_0x1a1860; // 0x1a19c4 - g_ps2RecompiledFunctionTable[165488] = bhEne03_DamageInit_0x1a1860; // 0x1a19c8 - g_ps2RecompiledFunctionTable[165489] = bhEne03_DamageInit_0x1a1860; // 0x1a19cc - g_ps2RecompiledFunctionTable[165490] = bhEne03_DamageInit_0x1a1860; // 0x1a19d0 - g_ps2RecompiledFunctionTable[165491] = bhEne03_DamageInit_0x1a1860; // 0x1a19d4 - g_ps2RecompiledFunctionTable[165492] = bhEne03_DamageInit_0x1a1860; // 0x1a19d8 - g_ps2RecompiledFunctionTable[165493] = bhEne03_DamageInit_0x1a1860; // 0x1a19dc - g_ps2RecompiledFunctionTable[165494] = bhEne03_DamageInit_0x1a1860; // 0x1a19e0 - g_ps2RecompiledFunctionTable[165495] = bhEne03_DamageInit_0x1a1860; // 0x1a19e4 - g_ps2RecompiledFunctionTable[165496] = bhEne03_DamageInit_0x1a1860; // 0x1a19e8 - g_ps2RecompiledFunctionTable[165497] = bhEne03_DamageInit_0x1a1860; // 0x1a19ec - g_ps2RecompiledFunctionTable[165498] = bhEne03_DamageInit_0x1a1860; // 0x1a19f0 - g_ps2RecompiledFunctionTable[165499] = bhEne03_DamageInit_0x1a1860; // 0x1a19f4 - g_ps2RecompiledFunctionTable[165500] = bhEne03_DamageInit_0x1a1860; // 0x1a19f8 - g_ps2RecompiledFunctionTable[165501] = bhEne03_DamageInit_0x1a1860; // 0x1a19fc - g_ps2RecompiledFunctionTable[165502] = bhEne03_DamageInit_0x1a1860; // 0x1a1a00 - g_ps2RecompiledFunctionTable[165503] = bhEne03_DamageInit_0x1a1860; // 0x1a1a04 - g_ps2RecompiledFunctionTable[165504] = bhEne03_DamageInit_0x1a1860; // 0x1a1a08 - g_ps2RecompiledFunctionTable[165505] = bhEne03_DamageInit_0x1a1860; // 0x1a1a0c - g_ps2RecompiledFunctionTable[165506] = bhEne03_DamageInit_0x1a1860; // 0x1a1a10 - g_ps2RecompiledFunctionTable[165507] = bhEne03_DamageInit_0x1a1860; // 0x1a1a14 - g_ps2RecompiledFunctionTable[165508] = bhEne03_DamageInit_0x1a1860; // 0x1a1a18 - g_ps2RecompiledFunctionTable[165509] = bhEne03_DamageInit_0x1a1860; // 0x1a1a1c - g_ps2RecompiledFunctionTable[165510] = bhEne03_DamageInit_0x1a1860; // 0x1a1a20 - g_ps2RecompiledFunctionTable[165511] = bhEne03_DamageInit_0x1a1860; // 0x1a1a24 - g_ps2RecompiledFunctionTable[165512] = bhEne03_DamageInit_0x1a1860; // 0x1a1a28 - g_ps2RecompiledFunctionTable[165513] = bhEne03_DamageInit_0x1a1860; // 0x1a1a2c - g_ps2RecompiledFunctionTable[165514] = bhEne03_DamageInit_0x1a1860; // 0x1a1a30 - g_ps2RecompiledFunctionTable[165515] = bhEne03_DamageInit_0x1a1860; // 0x1a1a34 - g_ps2RecompiledFunctionTable[165516] = bhEne03_DamageInit_0x1a1860; // 0x1a1a38 - g_ps2RecompiledFunctionTable[165517] = bhEne03_DamageInit_0x1a1860; // 0x1a1a3c - g_ps2RecompiledFunctionTable[165518] = bhEne03_DamageInit_0x1a1860; // 0x1a1a40 - g_ps2RecompiledFunctionTable[165519] = bhEne03_DamageInit_0x1a1860; // 0x1a1a44 - g_ps2RecompiledFunctionTable[165520] = bhEne03_DamageInit_0x1a1860; // 0x1a1a48 - g_ps2RecompiledFunctionTable[165521] = bhEne03_DamageInit_0x1a1860; // 0x1a1a4c - g_ps2RecompiledFunctionTable[165522] = bhEne03_DamageInit_0x1a1860; // 0x1a1a50 - g_ps2RecompiledFunctionTable[165523] = bhEne03_DamageInit_0x1a1860; // 0x1a1a54 - g_ps2RecompiledFunctionTable[165524] = bhEne03_DamageInit_0x1a1860; // 0x1a1a58 - g_ps2RecompiledFunctionTable[165525] = bhEne03_DamageInit_0x1a1860; // 0x1a1a5c - g_ps2RecompiledFunctionTable[165526] = bhEne03_DamageInit_0x1a1860; // 0x1a1a60 - g_ps2RecompiledFunctionTable[165527] = bhEne03_DamageInit_0x1a1860; // 0x1a1a64 - g_ps2RecompiledFunctionTable[165528] = bhEne03_DamageInit_0x1a1860; // 0x1a1a68 - g_ps2RecompiledFunctionTable[165529] = bhEne03_DamageInit_0x1a1860; // 0x1a1a6c - g_ps2RecompiledFunctionTable[165530] = bhEne03_DamageInit_0x1a1860; // 0x1a1a70 - g_ps2RecompiledFunctionTable[165531] = bhEne03_DamageInit_0x1a1860; // 0x1a1a74 - g_ps2RecompiledFunctionTable[165532] = bhEne03_DamageInit_0x1a1860; // 0x1a1a78 - g_ps2RecompiledFunctionTable[165533] = bhEne03_DamageInit_0x1a1860; // 0x1a1a7c - g_ps2RecompiledFunctionTable[165534] = bhEne03_DamageInit_0x1a1860; // 0x1a1a80 - g_ps2RecompiledFunctionTable[165535] = bhEne03_DamageInit_0x1a1860; // 0x1a1a84 - g_ps2RecompiledFunctionTable[165536] = bhEne03_DamageInit_0x1a1860; // 0x1a1a88 - g_ps2RecompiledFunctionTable[165537] = bhEne03_DamageInit_0x1a1860; // 0x1a1a8c - g_ps2RecompiledFunctionTable[165538] = bhEne03_DamageInit_0x1a1860; // 0x1a1a90 - g_ps2RecompiledFunctionTable[165539] = bhEne03_DamageInit_0x1a1860; // 0x1a1a94 - g_ps2RecompiledFunctionTable[165540] = bhEne03_DamageInit_0x1a1860; // 0x1a1a98 - g_ps2RecompiledFunctionTable[165541] = bhEne03_DamageInit_0x1a1860; // 0x1a1a9c - g_ps2RecompiledFunctionTable[165542] = bhEne03_DamageInit_0x1a1860; // 0x1a1aa0 - g_ps2RecompiledFunctionTable[165543] = bhEne03_DamageInit_0x1a1860; // 0x1a1aa4 - g_ps2RecompiledFunctionTable[165544] = bhEne03_DamageInit_0x1a1860; // 0x1a1aa8 - g_ps2RecompiledFunctionTable[165545] = bhEne03_DamageInit_0x1a1860; // 0x1a1aac - g_ps2RecompiledFunctionTable[165546] = bhEne03_DamageInit_0x1a1860; // 0x1a1ab0 - g_ps2RecompiledFunctionTable[165547] = bhEne03_DamageInit_0x1a1860; // 0x1a1ab4 - g_ps2RecompiledFunctionTable[165548] = bhEne03_DamageInit_0x1a1860; // 0x1a1ab8 - g_ps2RecompiledFunctionTable[165549] = bhEne03_DamageInit_0x1a1860; // 0x1a1abc - g_ps2RecompiledFunctionTable[165550] = bhEne03_DamageInit_0x1a1860; // 0x1a1ac0 - g_ps2RecompiledFunctionTable[165551] = bhEne03_DamageInit_0x1a1860; // 0x1a1ac4 - g_ps2RecompiledFunctionTable[165552] = bhEne03_DamageInit_0x1a1860; // 0x1a1ac8 - g_ps2RecompiledFunctionTable[165553] = bhEne03_DamageInit_0x1a1860; // 0x1a1acc - g_ps2RecompiledFunctionTable[165554] = bhEne03_DamageInit_0x1a1860; // 0x1a1ad0 - g_ps2RecompiledFunctionTable[165555] = bhEne03_DamageInit_0x1a1860; // 0x1a1ad4 - g_ps2RecompiledFunctionTable[165556] = bhEne03_DamageInit_0x1a1860; // 0x1a1ad8 - g_ps2RecompiledFunctionTable[165557] = bhEne03_DamageInit_0x1a1860; // 0x1a1adc - g_ps2RecompiledFunctionTable[165558] = bhEne03_DamageInit_0x1a1860; // 0x1a1ae0 - g_ps2RecompiledFunctionTable[165559] = bhEne03_DamageInit_0x1a1860; // 0x1a1ae4 - g_ps2RecompiledFunctionTable[165560] = bhEne03_DamageInit_0x1a1860; // 0x1a1ae8 - g_ps2RecompiledFunctionTable[165561] = bhEne03_DamageInit_0x1a1860; // 0x1a1aec - g_ps2RecompiledFunctionTable[165562] = bhEne03_DamageInit_0x1a1860; // 0x1a1af0 - g_ps2RecompiledFunctionTable[165563] = bhEne03_DamageInit_0x1a1860; // 0x1a1af4 - g_ps2RecompiledFunctionTable[165564] = bhEne03_DamageInit_0x1a1860; // 0x1a1af8 - g_ps2RecompiledFunctionTable[165565] = bhEne03_DamageInit_0x1a1860; // 0x1a1afc - g_ps2RecompiledFunctionTable[165566] = bhEne03_DamageInit_0x1a1860; // 0x1a1b00 - g_ps2RecompiledFunctionTable[165567] = bhEne03_DamageInit_0x1a1860; // 0x1a1b04 - g_ps2RecompiledFunctionTable[165568] = bhEne03_DamageInit_0x1a1860; // 0x1a1b08 - g_ps2RecompiledFunctionTable[165569] = bhEne03_DamageInit_0x1a1860; // 0x1a1b0c - g_ps2RecompiledFunctionTable[165570] = bhEne03_DamageInit_0x1a1860; // 0x1a1b10 - g_ps2RecompiledFunctionTable[165571] = bhEne03_DamageInit_0x1a1860; // 0x1a1b14 - g_ps2RecompiledFunctionTable[165572] = bhEne03_DamageInit_0x1a1860; // 0x1a1b18 - g_ps2RecompiledFunctionTable[165573] = bhEne03_DamageInit_0x1a1860; // 0x1a1b1c - g_ps2RecompiledFunctionTable[165574] = bhEne03_DamageInit_0x1a1860; // 0x1a1b20 - g_ps2RecompiledFunctionTable[165575] = bhEne03_DamageInit_0x1a1860; // 0x1a1b24 - g_ps2RecompiledFunctionTable[165576] = bhEne03_DamageInit_0x1a1860; // 0x1a1b28 - g_ps2RecompiledFunctionTable[165577] = bhEne03_DamageInit_0x1a1860; // 0x1a1b2c - g_ps2RecompiledFunctionTable[165578] = bhEne03_DamageInit_0x1a1860; // 0x1a1b30 - g_ps2RecompiledFunctionTable[165579] = bhEne03_DamageInit_0x1a1860; // 0x1a1b34 - g_ps2RecompiledFunctionTable[165580] = bhEne03_DamageInit_0x1a1860; // 0x1a1b38 - g_ps2RecompiledFunctionTable[165581] = bhEne03_DamageInit_0x1a1860; // 0x1a1b3c - g_ps2RecompiledFunctionTable[165582] = bhEne03_DamageInit_0x1a1860; // 0x1a1b40 - g_ps2RecompiledFunctionTable[165583] = bhEne03_DamageInit_0x1a1860; // 0x1a1b44 - g_ps2RecompiledFunctionTable[165584] = bhEne03_DamageInit_0x1a1860; // 0x1a1b48 - g_ps2RecompiledFunctionTable[165585] = bhEne03_DamageInit_0x1a1860; // 0x1a1b4c - g_ps2RecompiledFunctionTable[165586] = bhEne03_DamageInit_0x1a1860; // 0x1a1b50 - g_ps2RecompiledFunctionTable[165587] = bhEne03_DamageInit_0x1a1860; // 0x1a1b54 - g_ps2RecompiledFunctionTable[165588] = bhEne03_DamageInit_0x1a1860; // 0x1a1b58 - g_ps2RecompiledFunctionTable[165589] = bhEne03_DamageInit_0x1a1860; // 0x1a1b5c - g_ps2RecompiledFunctionTable[165590] = bhEne03_DamageInit_0x1a1860; // 0x1a1b60 - g_ps2RecompiledFunctionTable[165591] = bhEne03_DamageInit_0x1a1860; // 0x1a1b64 - g_ps2RecompiledFunctionTable[165592] = bhEne03_DamageInit_0x1a1860; // 0x1a1b68 - g_ps2RecompiledFunctionTable[165593] = bhEne03_DamageInit_0x1a1860; // 0x1a1b6c - g_ps2RecompiledFunctionTable[165594] = bhEne03_DamageInit_0x1a1860; // 0x1a1b70 - g_ps2RecompiledFunctionTable[165595] = bhEne03_DamageInit_0x1a1860; // 0x1a1b74 - g_ps2RecompiledFunctionTable[165596] = bhEne03_DamageInit_0x1a1860; // 0x1a1b78 - g_ps2RecompiledFunctionTable[165597] = bhEne03_DamageInit_0x1a1860; // 0x1a1b7c - g_ps2RecompiledFunctionTable[165598] = bhEne03_DamageInit_0x1a1860; // 0x1a1b80 - g_ps2RecompiledFunctionTable[165599] = bhEne03_DamageInit_0x1a1860; // 0x1a1b84 - g_ps2RecompiledFunctionTable[165600] = bhEne03_DamageInit_0x1a1860; // 0x1a1b88 - g_ps2RecompiledFunctionTable[165601] = bhEne03_DamageInit_0x1a1860; // 0x1a1b8c - g_ps2RecompiledFunctionTable[165602] = bhEne03_DamageInit_0x1a1860; // 0x1a1b90 - g_ps2RecompiledFunctionTable[165603] = bhEne03_DamageInit_0x1a1860; // 0x1a1b94 - g_ps2RecompiledFunctionTable[165604] = bhEne03_DamageInit_0x1a1860; // 0x1a1b98 - g_ps2RecompiledFunctionTable[165605] = bhEne03_DamageInit_0x1a1860; // 0x1a1b9c - g_ps2RecompiledFunctionTable[165606] = bhEne03_DamageInit_0x1a1860; // 0x1a1ba0 - g_ps2RecompiledFunctionTable[165607] = bhEne03_DamageInit_0x1a1860; // 0x1a1ba4 - g_ps2RecompiledFunctionTable[165608] = bhEne03_DamageInit_0x1a1860; // 0x1a1ba8 - g_ps2RecompiledFunctionTable[165609] = bhEne03_DamageInit_0x1a1860; // 0x1a1bac - g_ps2RecompiledFunctionTable[165610] = bhEne03_DamageInit_0x1a1860; // 0x1a1bb0 - g_ps2RecompiledFunctionTable[165611] = bhEne03_DamageInit_0x1a1860; // 0x1a1bb4 - g_ps2RecompiledFunctionTable[165612] = bhEne03_DamageInit_0x1a1860; // 0x1a1bb8 - g_ps2RecompiledFunctionTable[165613] = bhEne03_DamageInit_0x1a1860; // 0x1a1bbc - g_ps2RecompiledFunctionTable[165614] = bhEne03_DamageInit_0x1a1860; // 0x1a1bc0 - g_ps2RecompiledFunctionTable[165615] = bhEne03_DamageInit_0x1a1860; // 0x1a1bc4 - g_ps2RecompiledFunctionTable[165616] = bhEne03_DamageInit_0x1a1860; // 0x1a1bc8 - g_ps2RecompiledFunctionTable[165617] = bhEne03_DamageInit_0x1a1860; // 0x1a1bcc - g_ps2RecompiledFunctionTable[165618] = bhEne03_DamageInit_0x1a1860; // 0x1a1bd0 - g_ps2RecompiledFunctionTable[165619] = bhEne03_DamageInit_0x1a1860; // 0x1a1bd4 - g_ps2RecompiledFunctionTable[165620] = bhEne03_DamageInit_0x1a1860; // 0x1a1bd8 - g_ps2RecompiledFunctionTable[165621] = bhEne03_DamageInit_0x1a1860; // 0x1a1bdc - g_ps2RecompiledFunctionTable[165622] = bhEne03_DamageInit_0x1a1860; // 0x1a1be0 - g_ps2RecompiledFunctionTable[165623] = bhEne03_DamageInit_0x1a1860; // 0x1a1be4 - g_ps2RecompiledFunctionTable[165624] = bhEne03_DamageInit_0x1a1860; // 0x1a1be8 - g_ps2RecompiledFunctionTable[165625] = bhEne03_DamageInit_0x1a1860; // 0x1a1bec - g_ps2RecompiledFunctionTable[165626] = bhEne03_DamageInit_0x1a1860; // 0x1a1bf0 - g_ps2RecompiledFunctionTable[165627] = bhEne03_DamageInit_0x1a1860; // 0x1a1bf4 - g_ps2RecompiledFunctionTable[165628] = bhEne03_DamageInit_0x1a1860; // 0x1a1bf8 - g_ps2RecompiledFunctionTable[165629] = bhEne03_DamageInit_0x1a1860; // 0x1a1bfc - g_ps2RecompiledFunctionTable[165630] = bhEne03_DamageInit_0x1a1860; // 0x1a1c00 - g_ps2RecompiledFunctionTable[165631] = bhEne03_DamageInit_0x1a1860; // 0x1a1c04 - g_ps2RecompiledFunctionTable[165632] = bhEne03_DamageInit_0x1a1860; // 0x1a1c08 - g_ps2RecompiledFunctionTable[165633] = bhEne03_DamageInit_0x1a1860; // 0x1a1c0c - g_ps2RecompiledFunctionTable[165634] = bhEne03_DamageInit_0x1a1860; // 0x1a1c10 - g_ps2RecompiledFunctionTable[165635] = bhEne03_DamageInit_0x1a1860; // 0x1a1c14 - g_ps2RecompiledFunctionTable[165636] = bhEne03_DamageInit_0x1a1860; // 0x1a1c18 - g_ps2RecompiledFunctionTable[165637] = bhEne03_DamageInit_0x1a1860; // 0x1a1c1c - g_ps2RecompiledFunctionTable[165638] = bhEne03_DamageInit_0x1a1860; // 0x1a1c20 - g_ps2RecompiledFunctionTable[165639] = bhEne03_DamageInit_0x1a1860; // 0x1a1c24 - g_ps2RecompiledFunctionTable[165640] = bhEne03_DamageInit_0x1a1860; // 0x1a1c28 - g_ps2RecompiledFunctionTable[165641] = bhEne03_DamageInit_0x1a1860; // 0x1a1c2c - g_ps2RecompiledFunctionTable[165642] = bhEne03_DamageInit_0x1a1860; // 0x1a1c30 - g_ps2RecompiledFunctionTable[165643] = bhEne03_DamageInit_0x1a1860; // 0x1a1c34 - g_ps2RecompiledFunctionTable[165644] = bhEne03_DamageInit_0x1a1860; // 0x1a1c38 - g_ps2RecompiledFunctionTable[165645] = bhEne03_DamageInit_0x1a1860; // 0x1a1c3c - g_ps2RecompiledFunctionTable[165646] = bhEne03_DamageInit_0x1a1860; // 0x1a1c40 - g_ps2RecompiledFunctionTable[165647] = bhEne03_DamageInit_0x1a1860; // 0x1a1c44 - g_ps2RecompiledFunctionTable[165648] = bhEne03_DamageInit_0x1a1860; // 0x1a1c48 - g_ps2RecompiledFunctionTable[165649] = bhEne03_DamageInit_0x1a1860; // 0x1a1c4c - g_ps2RecompiledFunctionTable[165650] = bhEne03_DamageInit_0x1a1860; // 0x1a1c50 - g_ps2RecompiledFunctionTable[165651] = bhEne03_DamageInit_0x1a1860; // 0x1a1c54 - g_ps2RecompiledFunctionTable[165652] = bhEne03_DamageInit_0x1a1860; // 0x1a1c58 - g_ps2RecompiledFunctionTable[165653] = bhEne03_DamageInit_0x1a1860; // 0x1a1c5c - g_ps2RecompiledFunctionTable[165654] = bhEne03_DamageInit_0x1a1860; // 0x1a1c60 - g_ps2RecompiledFunctionTable[165655] = bhEne03_DamageInit_0x1a1860; // 0x1a1c64 - g_ps2RecompiledFunctionTable[165656] = bhEne03_DamageInit_0x1a1860; // 0x1a1c68 - g_ps2RecompiledFunctionTable[165657] = bhEne03_DamageInit_0x1a1860; // 0x1a1c6c - g_ps2RecompiledFunctionTable[165658] = bhEne03_DamageInit_0x1a1860; // 0x1a1c70 - g_ps2RecompiledFunctionTable[165659] = bhEne03_DamageInit_0x1a1860; // 0x1a1c74 - g_ps2RecompiledFunctionTable[165660] = bhEne03_DamageInit_0x1a1860; // 0x1a1c78 - g_ps2RecompiledFunctionTable[165661] = bhEne03_DamageInit_0x1a1860; // 0x1a1c7c - g_ps2RecompiledFunctionTable[165662] = bhEne03_DamageInit_0x1a1860; // 0x1a1c80 - g_ps2RecompiledFunctionTable[165663] = bhEne03_DamageInit_0x1a1860; // 0x1a1c84 - g_ps2RecompiledFunctionTable[165664] = bhEne03_DamageInit_0x1a1860; // 0x1a1c88 - g_ps2RecompiledFunctionTable[165665] = bhEne03_DamageInit_0x1a1860; // 0x1a1c8c - g_ps2RecompiledFunctionTable[165666] = bhEne03_DamageInit_0x1a1860; // 0x1a1c90 - g_ps2RecompiledFunctionTable[165667] = bhEne03_DamageInit_0x1a1860; // 0x1a1c94 - g_ps2RecompiledFunctionTable[165668] = bhEne03_DamageInit_0x1a1860; // 0x1a1c98 - g_ps2RecompiledFunctionTable[165669] = bhEne03_DamageInit_0x1a1860; // 0x1a1c9c - g_ps2RecompiledFunctionTable[165670] = bhEne03_DamageInit_0x1a1860; // 0x1a1ca0 - g_ps2RecompiledFunctionTable[165671] = bhEne03_DamageInit_0x1a1860; // 0x1a1ca4 - g_ps2RecompiledFunctionTable[165672] = bhEne03_DamageInit_0x1a1860; // 0x1a1ca8 - g_ps2RecompiledFunctionTable[165673] = bhEne03_DamageInit_0x1a1860; // 0x1a1cac - g_ps2RecompiledFunctionTable[165674] = bhEne03_DamageInit_0x1a1860; // 0x1a1cb0 - g_ps2RecompiledFunctionTable[165675] = bhEne03_DamageInit_0x1a1860; // 0x1a1cb4 - g_ps2RecompiledFunctionTable[165676] = bhEne03_DamageInit_0x1a1860; // 0x1a1cb8 - g_ps2RecompiledFunctionTable[165677] = bhEne03_DamageInit_0x1a1860; // 0x1a1cbc - g_ps2RecompiledFunctionTable[165678] = bhEne03_DamageInit_0x1a1860; // 0x1a1cc0 - g_ps2RecompiledFunctionTable[165679] = bhEne03_DamageInit_0x1a1860; // 0x1a1cc4 - g_ps2RecompiledFunctionTable[165680] = bhEne03_DamageInit_0x1a1860; // 0x1a1cc8 - g_ps2RecompiledFunctionTable[165681] = bhEne03_DamageInit_0x1a1860; // 0x1a1ccc - g_ps2RecompiledFunctionTable[165682] = bhEne03_DamageInit_0x1a1860; // 0x1a1cd0 - g_ps2RecompiledFunctionTable[165683] = bhEne03_DamageInit_0x1a1860; // 0x1a1cd4 - g_ps2RecompiledFunctionTable[165684] = bhEne03_DamageInit_0x1a1860; // 0x1a1cd8 - g_ps2RecompiledFunctionTable[165685] = bhEne03_DamageInit_0x1a1860; // 0x1a1cdc - g_ps2RecompiledFunctionTable[165686] = bhEne03_DamageInit_0x1a1860; // 0x1a1ce0 - g_ps2RecompiledFunctionTable[165687] = bhEne03_DamageInit_0x1a1860; // 0x1a1ce4 - g_ps2RecompiledFunctionTable[165688] = bhEne03_DamageInit_0x1a1860; // 0x1a1ce8 - g_ps2RecompiledFunctionTable[165689] = bhEne03_DamageInit_0x1a1860; // 0x1a1cec - g_ps2RecompiledFunctionTable[165690] = bhEne03_DamageInit_0x1a1860; // 0x1a1cf0 - g_ps2RecompiledFunctionTable[165691] = bhEne03_DamageInit_0x1a1860; // 0x1a1cf4 - g_ps2RecompiledFunctionTable[165692] = bhEne03_DamageInit_0x1a1860; // 0x1a1cf8 - g_ps2RecompiledFunctionTable[165693] = bhEne03_DamageInit_0x1a1860; // 0x1a1cfc - g_ps2RecompiledFunctionTable[165694] = bhEne03_DamageInit_0x1a1860; // 0x1a1d00 - g_ps2RecompiledFunctionTable[165695] = bhEne03_DamageInit_0x1a1860; // 0x1a1d04 - g_ps2RecompiledFunctionTable[165696] = bhEne03_DamageInit_0x1a1860; // 0x1a1d08 - g_ps2RecompiledFunctionTable[165697] = bhEne03_DamageInit_0x1a1860; // 0x1a1d0c - g_ps2RecompiledFunctionTable[165698] = bhEne03_DamageInit_0x1a1860; // 0x1a1d10 - g_ps2RecompiledFunctionTable[165699] = bhEne03_DamageInit_0x1a1860; // 0x1a1d14 - g_ps2RecompiledFunctionTable[165700] = bhEne03_DamageInit_0x1a1860; // 0x1a1d18 - g_ps2RecompiledFunctionTable[165701] = bhEne03_DamageInit_0x1a1860; // 0x1a1d1c - g_ps2RecompiledFunctionTable[165702] = bhEne03_DamageInit_0x1a1860; // 0x1a1d20 - g_ps2RecompiledFunctionTable[165703] = bhEne03_DamageInit_0x1a1860; // 0x1a1d24 - g_ps2RecompiledFunctionTable[165704] = bhEne03_DamageInit_0x1a1860; // 0x1a1d28 - g_ps2RecompiledFunctionTable[165705] = bhEne03_DamageInit_0x1a1860; // 0x1a1d2c - g_ps2RecompiledFunctionTable[165706] = bhEne03_DamageInit_0x1a1860; // 0x1a1d30 - g_ps2RecompiledFunctionTable[165707] = bhEne03_DamageInit_0x1a1860; // 0x1a1d34 - g_ps2RecompiledFunctionTable[165708] = bhEne03_DamageInit_0x1a1860; // 0x1a1d38 - g_ps2RecompiledFunctionTable[165709] = bhEne03_DamageInit_0x1a1860; // 0x1a1d3c - g_ps2RecompiledFunctionTable[165710] = bhEne03_DamageInit_0x1a1860; // 0x1a1d40 - g_ps2RecompiledFunctionTable[165711] = bhEne03_DamageInit_0x1a1860; // 0x1a1d44 - g_ps2RecompiledFunctionTable[165712] = bhEne03_DamageInit_0x1a1860; // 0x1a1d48 - g_ps2RecompiledFunctionTable[165713] = bhEne03_DamageInit_0x1a1860; // 0x1a1d4c - g_ps2RecompiledFunctionTable[165714] = bhEne03_DamageInit_0x1a1860; // 0x1a1d50 - g_ps2RecompiledFunctionTable[165715] = bhEne03_DamageInit_0x1a1860; // 0x1a1d54 - g_ps2RecompiledFunctionTable[165716] = bhEne03_DamageInit_0x1a1860; // 0x1a1d58 - g_ps2RecompiledFunctionTable[165717] = bhEne03_DamageInit_0x1a1860; // 0x1a1d5c - g_ps2RecompiledFunctionTable[165718] = bhEne03_DamageInit_0x1a1860; // 0x1a1d60 - g_ps2RecompiledFunctionTable[165719] = bhEne03_DamageInit_0x1a1860; // 0x1a1d64 - g_ps2RecompiledFunctionTable[165720] = bhEne03_DamageInit_0x1a1860; // 0x1a1d68 - g_ps2RecompiledFunctionTable[165721] = bhEne03_DamageInit_0x1a1860; // 0x1a1d6c - g_ps2RecompiledFunctionTable[165722] = bhEne03_DamageInit_0x1a1860; // 0x1a1d70 - g_ps2RecompiledFunctionTable[165723] = bhEne03_DamageInit_0x1a1860; // 0x1a1d74 - g_ps2RecompiledFunctionTable[165724] = bhEne03_DamageInit_0x1a1860; // 0x1a1d78 - g_ps2RecompiledFunctionTable[165725] = bhEne03_DamageInit_0x1a1860; // 0x1a1d7c - g_ps2RecompiledFunctionTable[165726] = bhEne03_DamageInit_0x1a1860; // 0x1a1d80 - g_ps2RecompiledFunctionTable[165727] = bhEne03_DamageInit_0x1a1860; // 0x1a1d84 - g_ps2RecompiledFunctionTable[165728] = bhEne03_DamageInit_0x1a1860; // 0x1a1d88 - g_ps2RecompiledFunctionTable[165729] = bhEne03_DamageInit_0x1a1860; // 0x1a1d8c - g_ps2RecompiledFunctionTable[165730] = bhEne03_DamageInit_0x1a1860; // 0x1a1d90 - g_ps2RecompiledFunctionTable[165731] = bhEne03_DamageInit_0x1a1860; // 0x1a1d94 - g_ps2RecompiledFunctionTable[165732] = bhEne03_DamageInit_0x1a1860; // 0x1a1d98 - g_ps2RecompiledFunctionTable[165733] = bhEne03_DamageInit_0x1a1860; // 0x1a1d9c - g_ps2RecompiledFunctionTable[165734] = bhEne03_DamageInit_0x1a1860; // 0x1a1da0 - g_ps2RecompiledFunctionTable[165735] = bhEne03_DamageInit_0x1a1860; // 0x1a1da4 - g_ps2RecompiledFunctionTable[165736] = bhEne03_DamageInit_0x1a1860; // 0x1a1da8 - g_ps2RecompiledFunctionTable[165737] = bhEne03_DamageInit_0x1a1860; // 0x1a1dac - g_ps2RecompiledFunctionTable[165738] = bhEne03_DamageInit_0x1a1860; // 0x1a1db0 - g_ps2RecompiledFunctionTable[165739] = bhEne03_DamageInit_0x1a1860; // 0x1a1db4 - g_ps2RecompiledFunctionTable[165740] = bhEne03_DamageInit_0x1a1860; // 0x1a1db8 - g_ps2RecompiledFunctionTable[165741] = bhEne03_DamageInit_0x1a1860; // 0x1a1dbc - g_ps2RecompiledFunctionTable[165742] = bhEne03_DamageInit_0x1a1860; // 0x1a1dc0 - g_ps2RecompiledFunctionTable[165743] = bhEne03_DamageInit_0x1a1860; // 0x1a1dc4 - g_ps2RecompiledFunctionTable[165744] = bhEne03_DamageInit_0x1a1860; // 0x1a1dc8 - g_ps2RecompiledFunctionTable[165745] = bhEne03_DamageInit_0x1a1860; // 0x1a1dcc - g_ps2RecompiledFunctionTable[165746] = bhEne03_DamageInit_0x1a1860; // 0x1a1dd0 - g_ps2RecompiledFunctionTable[165747] = bhEne03_DamageInit_0x1a1860; // 0x1a1dd4 - g_ps2RecompiledFunctionTable[165748] = bhEne03_DamageInit_0x1a1860; // 0x1a1dd8 - g_ps2RecompiledFunctionTable[165749] = bhEne03_DamageInit_0x1a1860; // 0x1a1ddc - g_ps2RecompiledFunctionTable[165750] = bhEne03_DamageInit_0x1a1860; // 0x1a1de0 - g_ps2RecompiledFunctionTable[165751] = bhEne03_DamageInit_0x1a1860; // 0x1a1de4 - g_ps2RecompiledFunctionTable[165752] = bhEne03_DamageInit_0x1a1860; // 0x1a1de8 - g_ps2RecompiledFunctionTable[165753] = bhEne03_DamageInit_0x1a1860; // 0x1a1dec - g_ps2RecompiledFunctionTable[165754] = bhEne03_DamageInit_0x1a1860; // 0x1a1df0 - g_ps2RecompiledFunctionTable[165755] = bhEne03_DamageInit_0x1a1860; // 0x1a1df4 - g_ps2RecompiledFunctionTable[165756] = bhEne03_DamageInit_0x1a1860; // 0x1a1df8 - g_ps2RecompiledFunctionTable[165757] = bhEne03_DamageInit_0x1a1860; // 0x1a1dfc - g_ps2RecompiledFunctionTable[165758] = bhEne03_DamageInit_0x1a1860; // 0x1a1e00 - g_ps2RecompiledFunctionTable[165759] = bhEne03_DamageInit_0x1a1860; // 0x1a1e04 - g_ps2RecompiledFunctionTable[165760] = bhEne03_DamageInit_0x1a1860; // 0x1a1e08 - g_ps2RecompiledFunctionTable[165761] = bhEne03_DamageInit_0x1a1860; // 0x1a1e0c - g_ps2RecompiledFunctionTable[165762] = bhEne03_DamageInit_0x1a1860; // 0x1a1e10 - g_ps2RecompiledFunctionTable[165763] = bhEne03_DamageInit_0x1a1860; // 0x1a1e14 - g_ps2RecompiledFunctionTable[165764] = bhEne03_DamageInit_0x1a1860; // 0x1a1e18 - g_ps2RecompiledFunctionTable[165765] = bhEne03_DamageInit_0x1a1860; // 0x1a1e1c - g_ps2RecompiledFunctionTable[165766] = bhEne03_DamageInit_0x1a1860; // 0x1a1e20 - g_ps2RecompiledFunctionTable[165767] = bhEne03_DamageInit_0x1a1860; // 0x1a1e24 - g_ps2RecompiledFunctionTable[165768] = bhEne03_DamageInit_0x1a1860; // 0x1a1e28 - g_ps2RecompiledFunctionTable[165769] = bhEne03_DamageInit_0x1a1860; // 0x1a1e2c - g_ps2RecompiledFunctionTable[165770] = bhEne03_DamageInit_0x1a1860; // 0x1a1e30 - g_ps2RecompiledFunctionTable[165771] = bhEne03_DamageInit_0x1a1860; // 0x1a1e34 - g_ps2RecompiledFunctionTable[165772] = bhEne03_DamageInit_0x1a1860; // 0x1a1e38 - g_ps2RecompiledFunctionTable[165773] = bhEne03_DamageInit_0x1a1860; // 0x1a1e3c - g_ps2RecompiledFunctionTable[165774] = bhEne03_DamageInit_0x1a1860; // 0x1a1e40 - g_ps2RecompiledFunctionTable[165775] = bhEne03_DamageInit_0x1a1860; // 0x1a1e44 - g_ps2RecompiledFunctionTable[165776] = bhEne03_DamageInit_0x1a1860; // 0x1a1e48 - g_ps2RecompiledFunctionTable[165777] = bhEne03_DamageInit_0x1a1860; // 0x1a1e4c - g_ps2RecompiledFunctionTable[165778] = bhEne03_DamageInit_0x1a1860; // 0x1a1e50 - g_ps2RecompiledFunctionTable[165779] = bhEne03_DamageInit_0x1a1860; // 0x1a1e54 - g_ps2RecompiledFunctionTable[165780] = bhEne03_DamageInit_0x1a1860; // 0x1a1e58 - g_ps2RecompiledFunctionTable[165781] = bhEne03_DamageInit_0x1a1860; // 0x1a1e5c - g_ps2RecompiledFunctionTable[165782] = bhEne03_DamageInit_0x1a1860; // 0x1a1e60 - g_ps2RecompiledFunctionTable[165783] = bhEne03_DamageInit_0x1a1860; // 0x1a1e64 - g_ps2RecompiledFunctionTable[165784] = bhEne03_DamageInit_0x1a1860; // 0x1a1e68 - g_ps2RecompiledFunctionTable[165785] = bhEne03_DamageInit_0x1a1860; // 0x1a1e6c - g_ps2RecompiledFunctionTable[165786] = bhEne03_DamageInit_0x1a1860; // 0x1a1e70 - g_ps2RecompiledFunctionTable[165787] = bhEne03_DamageInit_0x1a1860; // 0x1a1e74 - g_ps2RecompiledFunctionTable[165788] = bhEne03_DamageInit_0x1a1860; // 0x1a1e78 - g_ps2RecompiledFunctionTable[165789] = bhEne03_DamageInit_0x1a1860; // 0x1a1e7c - g_ps2RecompiledFunctionTable[165790] = bhEne03_DamageInit_0x1a1860; // 0x1a1e80 - g_ps2RecompiledFunctionTable[165791] = bhEne03_DamageInit_0x1a1860; // 0x1a1e84 - g_ps2RecompiledFunctionTable[165792] = bhEne03_DamageInit_0x1a1860; // 0x1a1e88 - g_ps2RecompiledFunctionTable[165793] = bhEne03_DamageInit_0x1a1860; // 0x1a1e8c - g_ps2RecompiledFunctionTable[165794] = bhEne03_DamageInit_0x1a1860; // 0x1a1e90 - g_ps2RecompiledFunctionTable[165795] = bhEne03_DamageInit_0x1a1860; // 0x1a1e94 - g_ps2RecompiledFunctionTable[165796] = bhEne03_DamageInit_0x1a1860; // 0x1a1e98 - g_ps2RecompiledFunctionTable[165797] = bhEne03_DamageInit_0x1a1860; // 0x1a1e9c - g_ps2RecompiledFunctionTable[165798] = bhEne03_DamageInit_0x1a1860; // 0x1a1ea0 - g_ps2RecompiledFunctionTable[165799] = bhEne03_DamageInit_0x1a1860; // 0x1a1ea4 - g_ps2RecompiledFunctionTable[165800] = bhEne03_DamageInit_0x1a1860; // 0x1a1ea8 - g_ps2RecompiledFunctionTable[165801] = bhEne03_DamageInit_0x1a1860; // 0x1a1eac - g_ps2RecompiledFunctionTable[165802] = bhEne03_DamageInit_0x1a1860; // 0x1a1eb0 - g_ps2RecompiledFunctionTable[165803] = bhEne03_DamageInit_0x1a1860; // 0x1a1eb4 - g_ps2RecompiledFunctionTable[165804] = bhEne03_DamageInit_0x1a1860; // 0x1a1eb8 - g_ps2RecompiledFunctionTable[165805] = bhEne03_DamageInit_0x1a1860; // 0x1a1ebc - g_ps2RecompiledFunctionTable[165806] = bhEne03_DamageInit_0x1a1860; // 0x1a1ec0 - g_ps2RecompiledFunctionTable[165807] = bhEne03_DamageInit_0x1a1860; // 0x1a1ec4 - g_ps2RecompiledFunctionTable[165808] = bhEne03_DamageInit_0x1a1860; // 0x1a1ec8 - g_ps2RecompiledFunctionTable[165809] = bhEne03_DamageInit_0x1a1860; // 0x1a1ecc - g_ps2RecompiledFunctionTable[165810] = bhEne03_DamageInit_0x1a1860; // 0x1a1ed0 - g_ps2RecompiledFunctionTable[165811] = bhEne03_DamageInit_0x1a1860; // 0x1a1ed4 - g_ps2RecompiledFunctionTable[165812] = bhEne03_DamageInit_0x1a1860; // 0x1a1ed8 - g_ps2RecompiledFunctionTable[165813] = bhEne03_DamageInit_0x1a1860; // 0x1a1edc - g_ps2RecompiledFunctionTable[165814] = bhEne03_DamageInit_0x1a1860; // 0x1a1ee0 - g_ps2RecompiledFunctionTable[165815] = bhEne03_DamageInit_0x1a1860; // 0x1a1ee4 - g_ps2RecompiledFunctionTable[165816] = bhEne03_DamageInit_0x1a1860; // 0x1a1ee8 - g_ps2RecompiledFunctionTable[165817] = bhEne03_DamageInit_0x1a1860; // 0x1a1eec - g_ps2RecompiledFunctionTable[165818] = bhEne03_DamageInit_0x1a1860; // 0x1a1ef0 - g_ps2RecompiledFunctionTable[165819] = bhEne03_DamageInit_0x1a1860; // 0x1a1ef4 - g_ps2RecompiledFunctionTable[165820] = bhEne03_DamageInit_0x1a1860; // 0x1a1ef8 - g_ps2RecompiledFunctionTable[165821] = bhEne03_DamageInit_0x1a1860; // 0x1a1efc - g_ps2RecompiledFunctionTable[165822] = bhEne03_DamageInit_0x1a1860; // 0x1a1f00 - g_ps2RecompiledFunctionTable[165823] = bhEne03_DamageInit_0x1a1860; // 0x1a1f04 - g_ps2RecompiledFunctionTable[165824] = bhEne03_DamageInit_0x1a1860; // 0x1a1f08 - g_ps2RecompiledFunctionTable[165825] = bhEne03_DamageInit_0x1a1860; // 0x1a1f0c - g_ps2RecompiledFunctionTable[165826] = bhEne03_DamageInit_0x1a1860; // 0x1a1f10 - g_ps2RecompiledFunctionTable[165827] = bhEne03_DamageInit_0x1a1860; // 0x1a1f14 - g_ps2RecompiledFunctionTable[165828] = bhEne03_DamageInit_0x1a1860; // 0x1a1f18 - g_ps2RecompiledFunctionTable[165829] = bhEne03_DamageInit_0x1a1860; // 0x1a1f1c - g_ps2RecompiledFunctionTable[165830] = bhEne03_DamageInit_0x1a1860; // 0x1a1f20 - g_ps2RecompiledFunctionTable[165831] = bhEne03_DamageInit_0x1a1860; // 0x1a1f24 - g_ps2RecompiledFunctionTable[165832] = bhEne03_DamageInit_0x1a1860; // 0x1a1f28 - g_ps2RecompiledFunctionTable[165833] = bhEne03_DamageInit_0x1a1860; // 0x1a1f2c - g_ps2RecompiledFunctionTable[165834] = bhEne03_DamageInit_0x1a1860; // 0x1a1f30 - g_ps2RecompiledFunctionTable[165835] = bhEne03_DamageInit_0x1a1860; // 0x1a1f34 - g_ps2RecompiledFunctionTable[165836] = bhEne03_DamageInit_0x1a1860; // 0x1a1f38 - g_ps2RecompiledFunctionTable[165837] = bhEne03_DamageInit_0x1a1860; // 0x1a1f3c - g_ps2RecompiledFunctionTable[165838] = bhEne03_DamageInit_0x1a1860; // 0x1a1f40 - g_ps2RecompiledFunctionTable[165839] = bhEne03_DamageInit_0x1a1860; // 0x1a1f44 - g_ps2RecompiledFunctionTable[165840] = bhEne03_DamageInit_0x1a1860; // 0x1a1f48 - g_ps2RecompiledFunctionTable[165841] = bhEne03_DamageInit_0x1a1860; // 0x1a1f4c - g_ps2RecompiledFunctionTable[165842] = bhEne03_DamageInit_0x1a1860; // 0x1a1f50 - g_ps2RecompiledFunctionTable[165843] = bhEne03_DamageInit_0x1a1860; // 0x1a1f54 - g_ps2RecompiledFunctionTable[165844] = bhEne03_DamageInit_0x1a1860; // 0x1a1f58 - g_ps2RecompiledFunctionTable[165845] = bhEne03_DamageInit_0x1a1860; // 0x1a1f5c - g_ps2RecompiledFunctionTable[165846] = bhEne03_DamageInit_0x1a1860; // 0x1a1f60 - g_ps2RecompiledFunctionTable[165847] = bhEne03_DamageInit_0x1a1860; // 0x1a1f64 - g_ps2RecompiledFunctionTable[165848] = bhEne03_DamageInit_0x1a1860; // 0x1a1f68 - g_ps2RecompiledFunctionTable[165849] = bhEne03_DamageInit_0x1a1860; // 0x1a1f6c - g_ps2RecompiledFunctionTable[165850] = bhEne03_DamageInit_0x1a1860; // 0x1a1f70 - g_ps2RecompiledFunctionTable[165851] = bhEne03_DamageInit_0x1a1860; // 0x1a1f74 - g_ps2RecompiledFunctionTable[165852] = bhEne03_DamageInit_0x1a1860; // 0x1a1f78 - g_ps2RecompiledFunctionTable[165853] = bhEne03_DamageInit_0x1a1860; // 0x1a1f7c - g_ps2RecompiledFunctionTable[165854] = bhEne03_DamageInit_0x1a1860; // 0x1a1f80 - g_ps2RecompiledFunctionTable[165855] = bhEne03_DamageInit_0x1a1860; // 0x1a1f84 - g_ps2RecompiledFunctionTable[165856] = bhEne03_DamageInit_0x1a1860; // 0x1a1f88 - g_ps2RecompiledFunctionTable[165857] = bhEne03_DamageInit_0x1a1860; // 0x1a1f8c - g_ps2RecompiledFunctionTable[165858] = bhEne03_DamageInit_0x1a1860; // 0x1a1f90 - g_ps2RecompiledFunctionTable[165859] = bhEne03_DamageInit_0x1a1860; // 0x1a1f94 - g_ps2RecompiledFunctionTable[165860] = bhEne03_DamageInit_0x1a1860; // 0x1a1f98 - g_ps2RecompiledFunctionTable[165861] = bhEne03_DamageInit_0x1a1860; // 0x1a1f9c - g_ps2RecompiledFunctionTable[165862] = bhEne03_DamageInit_0x1a1860; // 0x1a1fa0 - g_ps2RecompiledFunctionTable[165863] = bhEne03_DamageInit_0x1a1860; // 0x1a1fa4 - g_ps2RecompiledFunctionTable[165864] = bhEne03_DamageInit_0x1a1860; // 0x1a1fa8 - g_ps2RecompiledFunctionTable[165865] = bhEne03_DamageInit_0x1a1860; // 0x1a1fac - g_ps2RecompiledFunctionTable[165866] = bhEne03_DamageInit_0x1a1860; // 0x1a1fb0 - g_ps2RecompiledFunctionTable[165867] = bhEne03_DamageInit_0x1a1860; // 0x1a1fb4 - g_ps2RecompiledFunctionTable[165868] = bhEne03_DamageInit_0x1a1860; // 0x1a1fb8 - g_ps2RecompiledFunctionTable[165869] = bhEne03_DamageInit_0x1a1860; // 0x1a1fbc - g_ps2RecompiledFunctionTable[165870] = bhEne03_DamageInit_0x1a1860; // 0x1a1fc0 - g_ps2RecompiledFunctionTable[165871] = bhEne03_DamageInit_0x1a1860; // 0x1a1fc4 - g_ps2RecompiledFunctionTable[165872] = bhEne03_DamageInit_0x1a1860; // 0x1a1fc8 - g_ps2RecompiledFunctionTable[165873] = bhEne03_DamageInit_0x1a1860; // 0x1a1fcc - g_ps2RecompiledFunctionTable[165874] = bhEne03_DamageInit_0x1a1860; // 0x1a1fd0 - g_ps2RecompiledFunctionTable[165875] = bhEne03_DamageInit_0x1a1860; // 0x1a1fd4 - g_ps2RecompiledFunctionTable[165876] = bhEne03_DamageInit_0x1a1860; // 0x1a1fd8 - g_ps2RecompiledFunctionTable[165877] = bhEne03_DamageInit_0x1a1860; // 0x1a1fdc - g_ps2RecompiledFunctionTable[165878] = bhEne03_DamageInit_0x1a1860; // 0x1a1fe0 - g_ps2RecompiledFunctionTable[165879] = bhEne03_DamageInit_0x1a1860; // 0x1a1fe4 - g_ps2RecompiledFunctionTable[165880] = bhEne03_DamageInit_0x1a1860; // 0x1a1fe8 - g_ps2RecompiledFunctionTable[165881] = bhEne03_DamageInit_0x1a1860; // 0x1a1fec - g_ps2RecompiledFunctionTable[165882] = bhEne03_DamageInit_0x1a1860; // 0x1a1ff0 - g_ps2RecompiledFunctionTable[165883] = bhEne03_DamageInit_0x1a1860; // 0x1a1ff4 - g_ps2RecompiledFunctionTable[165884] = bhEne03_DamageInit_0x1a1860; // 0x1a1ff8 - g_ps2RecompiledFunctionTable[165885] = bhEne03_DamageInit_0x1a1860; // 0x1a1ffc - g_ps2RecompiledFunctionTable[165886] = bhEne03_DamageInit_0x1a1860; // 0x1a2000 - g_ps2RecompiledFunctionTable[165887] = bhEne03_DamageInit_0x1a1860; // 0x1a2004 - g_ps2RecompiledFunctionTable[165888] = bhEne03_DamageInit_0x1a1860; // 0x1a2008 - g_ps2RecompiledFunctionTable[165889] = bhEne03_DamageInit_0x1a1860; // 0x1a200c - g_ps2RecompiledFunctionTable[165890] = bhEne03_DamageInit_0x1a1860; // 0x1a2010 - g_ps2RecompiledFunctionTable[165891] = bhEne03_DamageInit_0x1a1860; // 0x1a2014 - g_ps2RecompiledFunctionTable[165892] = bhEne03_DamageInit_0x1a1860; // 0x1a2018 - g_ps2RecompiledFunctionTable[165893] = bhEne03_DamageInit_0x1a1860; // 0x1a201c - g_ps2RecompiledFunctionTable[165894] = bhEne03_DamageInit_0x1a1860; // 0x1a2020 - g_ps2RecompiledFunctionTable[165895] = bhEne03_DamageInit_0x1a1860; // 0x1a2024 - g_ps2RecompiledFunctionTable[165896] = bhEne03_DamageInit_0x1a1860; // 0x1a2028 - g_ps2RecompiledFunctionTable[165897] = bhEne03_DamageInit_0x1a1860; // 0x1a202c - g_ps2RecompiledFunctionTable[165898] = bhEne03_DamageInit_0x1a1860; // 0x1a2030 - g_ps2RecompiledFunctionTable[165899] = bhEne03_DamageInit_0x1a1860; // 0x1a2034 - g_ps2RecompiledFunctionTable[165900] = bhEne03_DamageInit_0x1a1860; // 0x1a2038 - g_ps2RecompiledFunctionTable[165901] = bhEne03_DamageInit_0x1a1860; // 0x1a203c - g_ps2RecompiledFunctionTable[165902] = bhEne03_DamageInit_0x1a1860; // 0x1a2040 - g_ps2RecompiledFunctionTable[165903] = bhEne03_DamageInit_0x1a1860; // 0x1a2044 - g_ps2RecompiledFunctionTable[165904] = bhEne03_DamageInit_0x1a1860; // 0x1a2048 - g_ps2RecompiledFunctionTable[165905] = bhEne03_DamageInit_0x1a1860; // 0x1a204c - g_ps2RecompiledFunctionTable[165906] = bhEne03_DamageInit_0x1a1860; // 0x1a2050 - g_ps2RecompiledFunctionTable[165907] = bhEne03_DamageInit_0x1a1860; // 0x1a2054 - g_ps2RecompiledFunctionTable[165908] = bhEne03_DamageInit_0x1a1860; // 0x1a2058 - g_ps2RecompiledFunctionTable[165909] = bhEne03_DamageInit_0x1a1860; // 0x1a205c - g_ps2RecompiledFunctionTable[165910] = bhEne03_DamageInit_0x1a1860; // 0x1a2060 - g_ps2RecompiledFunctionTable[165911] = bhEne03_DamageInit_0x1a1860; // 0x1a2064 - g_ps2RecompiledFunctionTable[165912] = bhEne03_DamageInit_0x1a1860; // 0x1a2068 - g_ps2RecompiledFunctionTable[165913] = bhEne03_DamageInit_0x1a1860; // 0x1a206c - g_ps2RecompiledFunctionTable[165914] = bhEne03_DamageInit_0x1a1860; // 0x1a2070 - g_ps2RecompiledFunctionTable[165915] = bhEne03_DamageInit_0x1a1860; // 0x1a2074 - g_ps2RecompiledFunctionTable[165916] = bhEne03_DamageInit_0x1a1860; // 0x1a2078 - g_ps2RecompiledFunctionTable[165917] = bhEne03_DamageInit_0x1a1860; // 0x1a207c - g_ps2RecompiledFunctionTable[165918] = bhEne03_DamageInit_0x1a1860; // 0x1a2080 - g_ps2RecompiledFunctionTable[165919] = bhEne03_DamageInit_0x1a1860; // 0x1a2084 - g_ps2RecompiledFunctionTable[165920] = bhEne03_DamageInit_0x1a1860; // 0x1a2088 - g_ps2RecompiledFunctionTable[165921] = bhEne03_DamageInit_0x1a1860; // 0x1a208c - g_ps2RecompiledFunctionTable[165922] = bhEne03_DamageInit_0x1a1860; // 0x1a2090 - g_ps2RecompiledFunctionTable[165923] = bhEne03_DamageInit_0x1a1860; // 0x1a2094 - g_ps2RecompiledFunctionTable[165924] = bhEne03_DamageInit_0x1a1860; // 0x1a2098 - g_ps2RecompiledFunctionTable[165925] = bhEne03_DamageInit_0x1a1860; // 0x1a209c - g_ps2RecompiledFunctionTable[165926] = bhEne03_DamageInit_0x1a1860; // 0x1a20a0 - g_ps2RecompiledFunctionTable[165927] = bhEne03_DamageInit_0x1a1860; // 0x1a20a4 - g_ps2RecompiledFunctionTable[165928] = bhEne03_DamageInit_0x1a1860; // 0x1a20a8 - g_ps2RecompiledFunctionTable[165929] = bhEne03_DamageInit_0x1a1860; // 0x1a20ac - g_ps2RecompiledFunctionTable[165930] = bhEne03_DamageInit_0x1a1860; // 0x1a20b0 - g_ps2RecompiledFunctionTable[165931] = bhEne03_DamageInit_0x1a1860; // 0x1a20b4 - g_ps2RecompiledFunctionTable[165932] = bhEne03_DamageInit_0x1a1860; // 0x1a20b8 - g_ps2RecompiledFunctionTable[165933] = bhEne03_DamageInit_0x1a1860; // 0x1a20bc - g_ps2RecompiledFunctionTable[165934] = bhEne03_DamageInit_0x1a1860; // 0x1a20c0 - g_ps2RecompiledFunctionTable[165935] = bhEne03_DamageInit_0x1a1860; // 0x1a20c4 - g_ps2RecompiledFunctionTable[165936] = bhEne03_DamageInit_0x1a1860; // 0x1a20c8 - g_ps2RecompiledFunctionTable[165937] = bhEne03_DamageInit_0x1a1860; // 0x1a20cc - g_ps2RecompiledFunctionTable[165938] = bhEne03_DamageInit_0x1a1860; // 0x1a20d0 - g_ps2RecompiledFunctionTable[165939] = bhEne03_DamageInit_0x1a1860; // 0x1a20d4 - g_ps2RecompiledFunctionTable[165940] = bhEne03_DamageInit_0x1a1860; // 0x1a20d8 - g_ps2RecompiledFunctionTable[165941] = bhEne03_DamageInit_0x1a1860; // 0x1a20dc - g_ps2RecompiledFunctionTable[165942] = bhEne03_DamageInit_0x1a1860; // 0x1a20e0 - g_ps2RecompiledFunctionTable[165943] = bhEne03_DamageInit_0x1a1860; // 0x1a20e4 - g_ps2RecompiledFunctionTable[165944] = bhEne03_DamageInit_0x1a1860; // 0x1a20e8 - g_ps2RecompiledFunctionTable[165945] = bhEne03_DamageInit_0x1a1860; // 0x1a20ec - g_ps2RecompiledFunctionTable[165946] = bhEne03_DamageInit_0x1a1860; // 0x1a20f0 - g_ps2RecompiledFunctionTable[165950] = bhEne03_CheckJumpSpace_0x1a2100; // 0x1a2100 - g_ps2RecompiledFunctionTable[165986] = bhEne03_CheckJumpSpace_0x1a2100; // 0x1a2190 - g_ps2RecompiledFunctionTable[166007] = bhEne03_CheckJumpSpace_0x1a2100; // 0x1a21e4 - g_ps2RecompiledFunctionTable[166039] = bhEne03_CheckJumpSpace_0x1a2100; // 0x1a2264 - g_ps2RecompiledFunctionTable[166047] = bhEne03_CheckJumpSpace_0x1a2100; // 0x1a2284 - g_ps2RecompiledFunctionTable[166066] = bhEne03_CheckJumpSpace_0x1a2100; // 0x1a22d0 - g_ps2RecompiledFunctionTable[166097] = bhEne03_CheckJumpSpace_0x1a2100; // 0x1a234c - g_ps2RecompiledFunctionTable[166110] = bhEne03_CheckJumpSpace_0x1a2100; // 0x1a2380 - g_ps2RecompiledFunctionTable[166123] = bhEne03_CheckJumpSpace_0x1a2100; // 0x1a23b4 - g_ps2RecompiledFunctionTable[166150] = bhEne03_PlayerControl_0x1a2420; // 0x1a2420 - g_ps2RecompiledFunctionTable[166249] = bhEne03_PlayerControl_0x1a2420; // 0x1a25ac - g_ps2RecompiledFunctionTable[166252] = bhEne03_PlayerControl_0x1a2420; // 0x1a25b8 - g_ps2RecompiledFunctionTable[166466] = bhEne03_PlayerControl_0x1a2420; // 0x1a2910 - g_ps2RecompiledFunctionTable[166469] = bhEne03_PlayerControl_0x1a2420; // 0x1a291c - g_ps2RecompiledFunctionTable[166623] = bhEne03_PlayerControl_0x1a2420; // 0x1a2b84 - g_ps2RecompiledFunctionTable[166728] = bhEne03_PlayerControl_0x1a2420; // 0x1a2d28 - g_ps2RecompiledFunctionTable[166731] = bhEne03_PlayerControl_0x1a2420; // 0x1a2d34 - g_ps2RecompiledFunctionTable[166824] = bhEne03_PlayerControl_0x1a2420; // 0x1a2ea8 - g_ps2RecompiledFunctionTable[166827] = bhEne03_PlayerControl_0x1a2420; // 0x1a2eb4 - g_ps2RecompiledFunctionTable[166846] = bhEne03_CallSE_0x1a2f00; // 0x1a2f00 - g_ps2RecompiledFunctionTable[166943] = bhEne03_CallSE_0x1a2f00; // 0x1a3084 - g_ps2RecompiledFunctionTable[166962] = bhEne03_CallSE_0x1a2f00; // 0x1a30d0 - g_ps2RecompiledFunctionTable[166978] = bhEne03_CallSE_0x1a2f00; // 0x1a3110 - g_ps2RecompiledFunctionTable[166990] = bhEne03_CallSE_0x1a2f00; // 0x1a3140 - g_ps2RecompiledFunctionTable[167002] = bhEne03_CallSE_0x1a2f00; // 0x1a3170 - g_ps2RecompiledFunctionTable[167015] = bhEne03_CallSE_0x1a2f00; // 0x1a31a4 - g_ps2RecompiledFunctionTable[167023] = bhEne03_CallSE_0x1a2f00; // 0x1a31c4 - g_ps2RecompiledFunctionTable[167032] = bhEne03_CallSE_0x1a2f00; // 0x1a31e8 - g_ps2RecompiledFunctionTable[167041] = bhEne03_CallSE_0x1a2f00; // 0x1a320c - g_ps2RecompiledFunctionTable[167049] = bhEne03_CallSE_0x1a2f00; // 0x1a322c - g_ps2RecompiledFunctionTable[167056] = bhEne03_CallSE_0x1a2f00; // 0x1a3248 - g_ps2RecompiledFunctionTable[167064] = bhEne03_CallSE_0x1a2f00; // 0x1a3268 - g_ps2RecompiledFunctionTable[167077] = bhEne03_CallSE_0x1a2f00; // 0x1a329c - g_ps2RecompiledFunctionTable[167084] = bhEne03_CallSE_0x1a2f00; // 0x1a32b8 - g_ps2RecompiledFunctionTable[167093] = bhEne03_CallSE_0x1a2f00; // 0x1a32dc - g_ps2RecompiledFunctionTable[167102] = bhEne03_CallSE_0x1a2f00; // 0x1a3300 - g_ps2RecompiledFunctionTable[167111] = bhEne03_CallSE_0x1a2f00; // 0x1a3324 - g_ps2RecompiledFunctionTable[167119] = bhEne03_CallSE_0x1a2f00; // 0x1a3344 - g_ps2RecompiledFunctionTable[167128] = bhEne03_CallSE_0x1a2f00; // 0x1a3368 - g_ps2RecompiledFunctionTable[167144] = bhEne03_CallSE_0x1a2f00; // 0x1a33a8 - g_ps2RecompiledFunctionTable[167150] = bhEne03_Acid_0x1a33c0; // 0x1a33c0 - g_ps2RecompiledFunctionTable[167239] = bhEne03_Acid_0x1a33c0; // 0x1a3524 - g_ps2RecompiledFunctionTable[167241] = bhEne03_Acid_0x1a33c0; // 0x1a352c - g_ps2RecompiledFunctionTable[167275] = bhEne03_Acid_0x1a33c0; // 0x1a35b4 - g_ps2RecompiledFunctionTable[167301] = bhEne03_Acid_0x1a33c0; // 0x1a361c - g_ps2RecompiledFunctionTable[167303] = bhEne03_Acid_0x1a33c0; // 0x1a3624 - g_ps2RecompiledFunctionTable[167319] = bhEne03_Acid_0x1a33c0; // 0x1a3664 - g_ps2RecompiledFunctionTable[167322] = bhEne03_Acid_0x1a33c0; // 0x1a3670 - g_ps2RecompiledFunctionTable[167324] = bhEne03_Acid_0x1a33c0; // 0x1a3678 - g_ps2RecompiledFunctionTable[167338] = bhEne03_Acid_0x1a33c0; // 0x1a36b0 - g_ps2RecompiledFunctionTable[167341] = bhEne03_Acid_0x1a33c0; // 0x1a36bc - g_ps2RecompiledFunctionTable[167345] = bhEne03_Acid_0x1a33c0; // 0x1a36cc - g_ps2RecompiledFunctionTable[167347] = bhEne03_Acid_0x1a33c0; // 0x1a36d4 - g_ps2RecompiledFunctionTable[167386] = bhEne03_HitMark_0x1a3770; // 0x1a3770 - g_ps2RecompiledFunctionTable[167433] = bhEne03_HitMark_0x1a3770; // 0x1a382c - g_ps2RecompiledFunctionTable[167449] = bhEne03_HitMark_0x1a3770; // 0x1a386c - g_ps2RecompiledFunctionTable[167465] = bhEne03_HitMark_0x1a3770; // 0x1a38ac - g_ps2RecompiledFunctionTable[167492] = bhEne03_HitMark_0x1a3770; // 0x1a3918 - g_ps2RecompiledFunctionTable[167507] = bhEne03_HitMark_0x1a3770; // 0x1a3954 - g_ps2RecompiledFunctionTable[167521] = bhEne03_HitMark_0x1a3770; // 0x1a398c - g_ps2RecompiledFunctionTable[167531] = bhEne03_HitMark_0x1a3770; // 0x1a39b4 - g_ps2RecompiledFunctionTable[167547] = bhEne03_HitMark_0x1a3770; // 0x1a39f4 - g_ps2RecompiledFunctionTable[167563] = bhEne03_HitMark_0x1a3770; // 0x1a3a34 - g_ps2RecompiledFunctionTable[167578] = bhEne03_HitMark_0x1a3770; // 0x1a3a70 - g_ps2RecompiledFunctionTable[167591] = bhEne03_HitMark_0x1a3770; // 0x1a3aa4 - g_ps2RecompiledFunctionTable[167600] = bhEne03_HitMark_0x1a3770; // 0x1a3ac8 - g_ps2RecompiledFunctionTable[167624] = bhEne03_HitMark_0x1a3770; // 0x1a3b28 - g_ps2RecompiledFunctionTable[167640] = bhEne03_HitMark_0x1a3770; // 0x1a3b68 - g_ps2RecompiledFunctionTable[167656] = bhEne03_HitMark_0x1a3770; // 0x1a3ba8 - g_ps2RecompiledFunctionTable[167674] = bhEne03_HitMark_0x1a3770; // 0x1a3bf0 - g_ps2RecompiledFunctionTable[167690] = bhEne03_HitMark_0x1a3770; // 0x1a3c30 - g_ps2RecompiledFunctionTable[167702] = bhEne03s_0x1a3c60; // 0x1a3c60 - g_ps2RecompiledFunctionTable[167703] = bhEne03s_0x1a3c60; // 0x1a3c64 - g_ps2RecompiledFunctionTable[167704] = bhEne03s_0x1a3c60; // 0x1a3c68 - g_ps2RecompiledFunctionTable[167705] = bhEne03s_0x1a3c60; // 0x1a3c6c - g_ps2RecompiledFunctionTable[167706] = bhEne03s_0x1a3c60; // 0x1a3c70 - g_ps2RecompiledFunctionTable[167707] = bhEne03s_0x1a3c60; // 0x1a3c74 - g_ps2RecompiledFunctionTable[167708] = bhEne03s_0x1a3c60; // 0x1a3c78 - g_ps2RecompiledFunctionTable[167709] = bhEne03s_0x1a3c60; // 0x1a3c7c - g_ps2RecompiledFunctionTable[167710] = bhEne03s_Init_0x1a3c80; // 0x1a3c80 - g_ps2RecompiledFunctionTable[167730] = bhEne03s_Init_0x1a3c80; // 0x1a3cd0 - g_ps2RecompiledFunctionTable[167738] = bhEne03s_Move_0x1a3cf0; // 0x1a3cf0 - g_ps2RecompiledFunctionTable[167739] = bhEne03s_Move_0x1a3cf0; // 0x1a3cf4 - g_ps2RecompiledFunctionTable[167740] = bhEne03s_Move_0x1a3cf0; // 0x1a3cf8 - g_ps2RecompiledFunctionTable[167741] = bhEne03s_Move_0x1a3cf0; // 0x1a3cfc - g_ps2RecompiledFunctionTable[167742] = bhEne03s_Move_0x1a3cf0; // 0x1a3d00 - g_ps2RecompiledFunctionTable[167743] = bhEne03s_Move_0x1a3cf0; // 0x1a3d04 - g_ps2RecompiledFunctionTable[167744] = bhEne03s_Move_0x1a3cf0; // 0x1a3d08 - g_ps2RecompiledFunctionTable[167745] = bhEne03s_Move_0x1a3cf0; // 0x1a3d0c - g_ps2RecompiledFunctionTable[167746] = bhEne03s_Move_0x1a3cf0; // 0x1a3d10 - g_ps2RecompiledFunctionTable[167747] = bhEne03s_Move_0x1a3cf0; // 0x1a3d14 - g_ps2RecompiledFunctionTable[167748] = bhEne03s_Move_0x1a3cf0; // 0x1a3d18 - g_ps2RecompiledFunctionTable[167749] = bhEne03s_Move_0x1a3cf0; // 0x1a3d1c - g_ps2RecompiledFunctionTable[167750] = bhEne03s_Move_0x1a3cf0; // 0x1a3d20 - g_ps2RecompiledFunctionTable[167751] = bhEne03s_Move_0x1a3cf0; // 0x1a3d24 - g_ps2RecompiledFunctionTable[167752] = bhEne03s_Move_0x1a3cf0; // 0x1a3d28 - g_ps2RecompiledFunctionTable[167753] = bhEne03s_Move_0x1a3cf0; // 0x1a3d2c - g_ps2RecompiledFunctionTable[167754] = bhEne03s_Move_0x1a3cf0; // 0x1a3d30 - g_ps2RecompiledFunctionTable[167755] = bhEne03s_Move_0x1a3cf0; // 0x1a3d34 - g_ps2RecompiledFunctionTable[167756] = bhEne03s_Move_0x1a3cf0; // 0x1a3d38 - g_ps2RecompiledFunctionTable[167757] = bhEne03s_Move_0x1a3cf0; // 0x1a3d3c - g_ps2RecompiledFunctionTable[167758] = bhEne03s_Move_0x1a3cf0; // 0x1a3d40 - g_ps2RecompiledFunctionTable[167759] = bhEne03s_Move_0x1a3cf0; // 0x1a3d44 - g_ps2RecompiledFunctionTable[167760] = bhEne03s_Move_0x1a3cf0; // 0x1a3d48 - g_ps2RecompiledFunctionTable[167761] = bhEne03s_Move_0x1a3cf0; // 0x1a3d4c - g_ps2RecompiledFunctionTable[167762] = bhEne03s_Move_0x1a3cf0; // 0x1a3d50 - g_ps2RecompiledFunctionTable[167763] = bhEne03s_Move_0x1a3cf0; // 0x1a3d54 - g_ps2RecompiledFunctionTable[167764] = bhEne03s_Move_0x1a3cf0; // 0x1a3d58 - g_ps2RecompiledFunctionTable[167765] = bhEne03s_Move_0x1a3cf0; // 0x1a3d5c - g_ps2RecompiledFunctionTable[167766] = bhEne03s_Move_0x1a3cf0; // 0x1a3d60 - g_ps2RecompiledFunctionTable[167767] = bhEne03s_Move_0x1a3cf0; // 0x1a3d64 - g_ps2RecompiledFunctionTable[167768] = bhEne03s_Move_0x1a3cf0; // 0x1a3d68 - g_ps2RecompiledFunctionTable[167769] = bhEne03s_Move_0x1a3cf0; // 0x1a3d6c - g_ps2RecompiledFunctionTable[167770] = bhEne03s_MV00_0x1a3d70; // 0x1a3d70 - g_ps2RecompiledFunctionTable[167812] = bhEne03s_MV00_0x1a3d70; // 0x1a3e18 - g_ps2RecompiledFunctionTable[167828] = bhEne03s_MV00_0x1a3d70; // 0x1a3e58 - g_ps2RecompiledFunctionTable[167847] = bhEne03s_MV00_0x1a3d70; // 0x1a3ea4 - g_ps2RecompiledFunctionTable[167866] = bhEne03s_MV00_0x1a3d70; // 0x1a3ef0 - g_ps2RecompiledFunctionTable[167889] = bhEne03s_MV00_0x1a3d70; // 0x1a3f4c - g_ps2RecompiledFunctionTable[167914] = bhEne03s_MV00_0x1a3d70; // 0x1a3fb0 - g_ps2RecompiledFunctionTable[167942] = bhEne03s_MV00_0x1a3d70; // 0x1a4020 - g_ps2RecompiledFunctionTable[167944] = bhEne03s_MV00_0x1a3d70; // 0x1a4028 - g_ps2RecompiledFunctionTable[167957] = bhEne03s_MV00_0x1a3d70; // 0x1a405c - g_ps2RecompiledFunctionTable[167991] = bhEne03s_MV00_0x1a3d70; // 0x1a40e4 - g_ps2RecompiledFunctionTable[167996] = bhEne03s_MV00_0x1a3d70; // 0x1a40f8 - g_ps2RecompiledFunctionTable[168000] = bhEne03s_MV00_0x1a3d70; // 0x1a4108 - g_ps2RecompiledFunctionTable[168002] = bhEne03s_MV00_0x1a3d70; // 0x1a4110 - g_ps2RecompiledFunctionTable[168007] = bhEne03s_MV00_0x1a3d70; // 0x1a4124 - g_ps2RecompiledFunctionTable[168010] = bhEne03s_MV00_0x1a3d70; // 0x1a4130 - g_ps2RecompiledFunctionTable[168012] = bhEne03s_MV00_0x1a3d70; // 0x1a4138 - g_ps2RecompiledFunctionTable[168016] = bhEne03s_MV00_0x1a3d70; // 0x1a4148 - g_ps2RecompiledFunctionTable[168029] = bhEne03s_MV00_0x1a3d70; // 0x1a417c - g_ps2RecompiledFunctionTable[168042] = bhEne03s_MV00_0x1a3d70; // 0x1a41b0 - g_ps2RecompiledFunctionTable[168050] = bhEne03s_MV00_0x1a3d70; // 0x1a41d0 - g_ps2RecompiledFunctionTable[168068] = bhEne03s_MV00_0x1a3d70; // 0x1a4218 - g_ps2RecompiledFunctionTable[168092] = bhEne03s_MV00_0x1a3d70; // 0x1a4278 - g_ps2RecompiledFunctionTable[168095] = bhEne03s_MV00_0x1a3d70; // 0x1a4284 - g_ps2RecompiledFunctionTable[168097] = bhEne03s_MV00_0x1a3d70; // 0x1a428c - g_ps2RecompiledFunctionTable[168102] = bhEne03s_MV00_0x1a3d70; // 0x1a42a0 - g_ps2RecompiledFunctionTable[168113] = bhEne03s_MV00_0x1a3d70; // 0x1a42cc - g_ps2RecompiledFunctionTable[168115] = bhEne03s_MV00_0x1a3d70; // 0x1a42d4 - g_ps2RecompiledFunctionTable[168123] = bhEne03s_MV00_0x1a3d70; // 0x1a42f4 - g_ps2RecompiledFunctionTable[168126] = bhEne03s_MV00_0x1a3d70; // 0x1a4300 - g_ps2RecompiledFunctionTable[168128] = bhEne03s_MV00_0x1a3d70; // 0x1a4308 - g_ps2RecompiledFunctionTable[168138] = bhEne03s_MV00_0x1a3d70; // 0x1a4330 - g_ps2RecompiledFunctionTable[168157] = bhEne03s_MV00_0x1a3d70; // 0x1a437c - g_ps2RecompiledFunctionTable[168180] = bhEne03s_MV00_0x1a3d70; // 0x1a43d8 - g_ps2RecompiledFunctionTable[168194] = bhEne03s_Dummy_0x1a4410; // 0x1a4410 - g_ps2RecompiledFunctionTable[168198] = bhEne03s_WallCheck_0x1a4420; // 0x1a4420 - g_ps2RecompiledFunctionTable[168228] = bhEne03s_WallCheck_0x1a4420; // 0x1a4498 - g_ps2RecompiledFunctionTable[168235] = bhEne03s_WallCheck_0x1a4420; // 0x1a44b4 - g_ps2RecompiledFunctionTable[168258] = bhEne03s_WallCheck_0x1a4420; // 0x1a4510 - g_ps2RecompiledFunctionTable[168264] = bhEne03s_WallCheck_0x1a4420; // 0x1a4528 - g_ps2RecompiledFunctionTable[168266] = bhEne03s_WallCheck_0x1a4420; // 0x1a4530 - g_ps2RecompiledFunctionTable[168285] = bhEne03s_WallCheck_0x1a4420; // 0x1a457c - g_ps2RecompiledFunctionTable[168288] = bhEne03s_WallCheck_0x1a4420; // 0x1a4588 - g_ps2RecompiledFunctionTable[168311] = bhEne03s_WallCheck_0x1a4420; // 0x1a45e4 - g_ps2RecompiledFunctionTable[168368] = bhEne03s_WallCheck_0x1a4420; // 0x1a46c8 - g_ps2RecompiledFunctionTable[168386] = bhEne03s_WallCheck_0x1a4420; // 0x1a4710 - g_ps2RecompiledFunctionTable[168412] = bhEne03s_WallCheck_0x1a4420; // 0x1a4778 - g_ps2RecompiledFunctionTable[168472] = bhEne03s_WallCheck_0x1a4420; // 0x1a4868 - g_ps2RecompiledFunctionTable[168475] = bhEne03s_WallCheck_0x1a4420; // 0x1a4874 - g_ps2RecompiledFunctionTable[168477] = bhEne03s_WallCheck_0x1a4420; // 0x1a487c - g_ps2RecompiledFunctionTable[168485] = bhEne03s_WallCheck_0x1a4420; // 0x1a489c - g_ps2RecompiledFunctionTable[168487] = bhEne03s_WallCheck_0x1a4420; // 0x1a48a4 - g_ps2RecompiledFunctionTable[168538] = bhEne03s_WallCheck2_0x1a4970; // 0x1a4970 - g_ps2RecompiledFunctionTable[168558] = bhEne03s_WallCheck2_0x1a4970; // 0x1a49c0 - g_ps2RecompiledFunctionTable[168580] = bhEne03s_WallCheck2_0x1a4970; // 0x1a4a18 - g_ps2RecompiledFunctionTable[168584] = bhEne03s_WallCheck2_0x1a4970; // 0x1a4a28 - g_ps2RecompiledFunctionTable[168586] = bhEne03s_WallCheck2_0x1a4970; // 0x1a4a30 - g_ps2RecompiledFunctionTable[168602] = bhEne03s_WallCheck2_0x1a4970; // 0x1a4a70 - g_ps2RecompiledFunctionTable[168628] = bhEne03s_WallCheck2_0x1a4970; // 0x1a4ad8 - g_ps2RecompiledFunctionTable[168634] = bhEne03s_InitCollision_0x1a4af0; // 0x1a4af0 - g_ps2RecompiledFunctionTable[168723] = bhEne03s_InitCollision_0x1a4af0; // 0x1a4c54 - g_ps2RecompiledFunctionTable[168735] = bhEne03s_InitCollision_0x1a4af0; // 0x1a4c84 - g_ps2RecompiledFunctionTable[168737] = bhEne03s_InitCollision_0x1a4af0; // 0x1a4c8c - g_ps2RecompiledFunctionTable[168742] = bhEne03s_InitCollision_0x1a4af0; // 0x1a4ca0 - g_ps2RecompiledFunctionTable[168747] = bhEne03s_InitCollision_0x1a4af0; // 0x1a4cb4 - g_ps2RecompiledFunctionTable[168757] = bhEne03s_InitCollision_0x1a4af0; // 0x1a4cdc - g_ps2RecompiledFunctionTable[168761] = bhEne03s_InitCollision_0x1a4af0; // 0x1a4cec - g_ps2RecompiledFunctionTable[168777] = bhEne03s_InitCollision_0x1a4af0; // 0x1a4d2c - g_ps2RecompiledFunctionTable[168800] = bhEne03s_InitCollision_0x1a4af0; // 0x1a4d88 - g_ps2RecompiledFunctionTable[168802] = bhEne03s_InitCollision_0x1a4af0; // 0x1a4d90 - g_ps2RecompiledFunctionTable[168815] = bhEne03s_InitCollision_0x1a4af0; // 0x1a4dc4 - g_ps2RecompiledFunctionTable[168818] = bhEne03s_InitCollision_0x1a4af0; // 0x1a4dd0 - g_ps2RecompiledFunctionTable[168820] = bhEne03s_InitCollision_0x1a4af0; // 0x1a4dd8 - g_ps2RecompiledFunctionTable[168833] = bhEne03s_InitCollision_0x1a4af0; // 0x1a4e0c - g_ps2RecompiledFunctionTable[168836] = bhEne03s_InitCollision_0x1a4af0; // 0x1a4e18 - g_ps2RecompiledFunctionTable[168848] = bhEne03s_InitCollision_0x1a4af0; // 0x1a4e48 - g_ps2RecompiledFunctionTable[168850] = bhEne03s_InitCollision_0x1a4af0; // 0x1a4e50 - g_ps2RecompiledFunctionTable[168869] = bhEne03s_InitCollision_0x1a4af0; // 0x1a4e9c - g_ps2RecompiledFunctionTable[168878] = bhEne04_DmmyBrain_0x1a4ec0; // 0x1a4ec0 - g_ps2RecompiledFunctionTable[168882] = bhEne04_0x1a4ed0; // 0x1a4ed0 - g_ps2RecompiledFunctionTable[168889] = bhEne04_0x1a4ed0; // 0x1a4eec - g_ps2RecompiledFunctionTable[168891] = bhEne04_0x1a4ed0; // 0x1a4ef4 - g_ps2RecompiledFunctionTable[168897] = bhEne04_0x1a4ed0; // 0x1a4f0c - g_ps2RecompiledFunctionTable[168911] = bhEne04_0x1a4ed0; // 0x1a4f44 - g_ps2RecompiledFunctionTable[168915] = bhEne04_0x1a4ed0; // 0x1a4f54 - g_ps2RecompiledFunctionTable[168917] = bhEne04_0x1a4ed0; // 0x1a4f5c - g_ps2RecompiledFunctionTable[168919] = bhEne04_0x1a4ed0; // 0x1a4f64 - g_ps2RecompiledFunctionTable[168927] = bhEne04_0x1a4ed0; // 0x1a4f84 - g_ps2RecompiledFunctionTable[168941] = bhEne04_0x1a4ed0; // 0x1a4fbc - g_ps2RecompiledFunctionTable[168974] = bhEne04_MainLoop_0x1a5040; // 0x1a5040 - g_ps2RecompiledFunctionTable[168975] = bhEne04_MainLoop_0x1a5040; // 0x1a5044 - g_ps2RecompiledFunctionTable[168976] = bhEne04_MainLoop_0x1a5040; // 0x1a5048 - g_ps2RecompiledFunctionTable[168977] = bhEne04_MainLoop_0x1a5040; // 0x1a504c - g_ps2RecompiledFunctionTable[168978] = bhEne04_MainLoop_0x1a5040; // 0x1a5050 - g_ps2RecompiledFunctionTable[168979] = bhEne04_MainLoop_0x1a5040; // 0x1a5054 - g_ps2RecompiledFunctionTable[168980] = bhEne04_MainLoop_0x1a5040; // 0x1a5058 - g_ps2RecompiledFunctionTable[168981] = bhEne04_MainLoop_0x1a5040; // 0x1a505c - g_ps2RecompiledFunctionTable[168982] = bhEne04_MainLoop_0x1a5040; // 0x1a5060 - g_ps2RecompiledFunctionTable[168983] = bhEne04_MainLoop_0x1a5040; // 0x1a5064 - g_ps2RecompiledFunctionTable[168984] = bhEne04_MainLoop_0x1a5040; // 0x1a5068 - g_ps2RecompiledFunctionTable[168985] = bhEne04_MainLoop_0x1a5040; // 0x1a506c - g_ps2RecompiledFunctionTable[168986] = bhEne04_MainLoop_0x1a5040; // 0x1a5070 - g_ps2RecompiledFunctionTable[168987] = bhEne04_MainLoop_0x1a5040; // 0x1a5074 - g_ps2RecompiledFunctionTable[168988] = bhEne04_MainLoop_0x1a5040; // 0x1a5078 - g_ps2RecompiledFunctionTable[168989] = bhEne04_MainLoop_0x1a5040; // 0x1a507c - g_ps2RecompiledFunctionTable[168990] = bhEne04_MainLoop_0x1a5040; // 0x1a5080 - g_ps2RecompiledFunctionTable[168991] = bhEne04_MainLoop_0x1a5040; // 0x1a5084 - g_ps2RecompiledFunctionTable[168992] = bhEne04_MainLoop_0x1a5040; // 0x1a5088 - g_ps2RecompiledFunctionTable[168993] = bhEne04_MainLoop_0x1a5040; // 0x1a508c - g_ps2RecompiledFunctionTable[168994] = bhEne04_MainLoop_0x1a5040; // 0x1a5090 - g_ps2RecompiledFunctionTable[168995] = bhEne04_MainLoop_0x1a5040; // 0x1a5094 - g_ps2RecompiledFunctionTable[168996] = bhEne04_MainLoop_0x1a5040; // 0x1a5098 - g_ps2RecompiledFunctionTable[168997] = bhEne04_MainLoop_0x1a5040; // 0x1a509c - g_ps2RecompiledFunctionTable[168998] = bhEne04_MainLoop_0x1a5040; // 0x1a50a0 - g_ps2RecompiledFunctionTable[168999] = bhEne04_MainLoop_0x1a5040; // 0x1a50a4 - g_ps2RecompiledFunctionTable[169000] = bhEne04_MainLoop_0x1a5040; // 0x1a50a8 - g_ps2RecompiledFunctionTable[169001] = bhEne04_MainLoop_0x1a5040; // 0x1a50ac - g_ps2RecompiledFunctionTable[169002] = bhEne04_MainLoop_0x1a5040; // 0x1a50b0 - g_ps2RecompiledFunctionTable[169003] = bhEne04_MainLoop_0x1a5040; // 0x1a50b4 - g_ps2RecompiledFunctionTable[169004] = bhEne04_MainLoop_0x1a5040; // 0x1a50b8 - g_ps2RecompiledFunctionTable[169005] = bhEne04_MainLoop_0x1a5040; // 0x1a50bc - g_ps2RecompiledFunctionTable[169006] = bhEne04_MainLoop_0x1a5040; // 0x1a50c0 - g_ps2RecompiledFunctionTable[169007] = bhEne04_MainLoop_0x1a5040; // 0x1a50c4 - g_ps2RecompiledFunctionTable[169008] = bhEne04_MainLoop_0x1a5040; // 0x1a50c8 - g_ps2RecompiledFunctionTable[169009] = bhEne04_MainLoop_0x1a5040; // 0x1a50cc - g_ps2RecompiledFunctionTable[169010] = bhEne04_MainLoop_0x1a5040; // 0x1a50d0 - g_ps2RecompiledFunctionTable[169011] = bhEne04_MainLoop_0x1a5040; // 0x1a50d4 - g_ps2RecompiledFunctionTable[169012] = bhEne04_MainLoop_0x1a5040; // 0x1a50d8 - g_ps2RecompiledFunctionTable[169013] = bhEne04_MainLoop_0x1a5040; // 0x1a50dc - g_ps2RecompiledFunctionTable[169014] = bhEne04_MainLoop_0x1a5040; // 0x1a50e0 - g_ps2RecompiledFunctionTable[169015] = bhEne04_MainLoop_0x1a5040; // 0x1a50e4 - g_ps2RecompiledFunctionTable[169016] = bhEne04_MainLoop_0x1a5040; // 0x1a50e8 - g_ps2RecompiledFunctionTable[169017] = bhEne04_MainLoop_0x1a5040; // 0x1a50ec - g_ps2RecompiledFunctionTable[169018] = bhEne04_MainLoop_0x1a5040; // 0x1a50f0 - g_ps2RecompiledFunctionTable[169019] = bhEne04_MainLoop_0x1a5040; // 0x1a50f4 - g_ps2RecompiledFunctionTable[169020] = bhEne04_MainLoop_0x1a5040; // 0x1a50f8 - g_ps2RecompiledFunctionTable[169021] = bhEne04_MainLoop_0x1a5040; // 0x1a50fc - g_ps2RecompiledFunctionTable[169022] = bhEne04_MainLoop_0x1a5040; // 0x1a5100 - g_ps2RecompiledFunctionTable[169023] = bhEne04_MainLoop_0x1a5040; // 0x1a5104 - g_ps2RecompiledFunctionTable[169024] = bhEne04_MainLoop_0x1a5040; // 0x1a5108 - g_ps2RecompiledFunctionTable[169025] = bhEne04_MainLoop_0x1a5040; // 0x1a510c - g_ps2RecompiledFunctionTable[169026] = bhEne04_MainLoop_0x1a5040; // 0x1a5110 - g_ps2RecompiledFunctionTable[169027] = bhEne04_MainLoop_0x1a5040; // 0x1a5114 - g_ps2RecompiledFunctionTable[169028] = bhEne04_MainLoop_0x1a5040; // 0x1a5118 - g_ps2RecompiledFunctionTable[169029] = bhEne04_MainLoop_0x1a5040; // 0x1a511c - g_ps2RecompiledFunctionTable[169030] = bhEne04_MainLoop_0x1a5040; // 0x1a5120 - g_ps2RecompiledFunctionTable[169031] = bhEne04_MainLoop_0x1a5040; // 0x1a5124 - g_ps2RecompiledFunctionTable[169032] = bhEne04_MainLoop_0x1a5040; // 0x1a5128 - g_ps2RecompiledFunctionTable[169033] = bhEne04_MainLoop_0x1a5040; // 0x1a512c - g_ps2RecompiledFunctionTable[169034] = bhEne04_MainLoop_0x1a5040; // 0x1a5130 - g_ps2RecompiledFunctionTable[169035] = bhEne04_MainLoop_0x1a5040; // 0x1a5134 - g_ps2RecompiledFunctionTable[169036] = bhEne04_MainLoop_0x1a5040; // 0x1a5138 - g_ps2RecompiledFunctionTable[169037] = bhEne04_MainLoop_0x1a5040; // 0x1a513c - g_ps2RecompiledFunctionTable[169038] = bhEne04_MainLoop_0x1a5040; // 0x1a5140 - g_ps2RecompiledFunctionTable[169039] = bhEne04_MainLoop_0x1a5040; // 0x1a5144 - g_ps2RecompiledFunctionTable[169040] = bhEne04_MainLoop_0x1a5040; // 0x1a5148 - g_ps2RecompiledFunctionTable[169041] = bhEne04_MainLoop_0x1a5040; // 0x1a514c - g_ps2RecompiledFunctionTable[169042] = bhEne04_MainLoop_0x1a5040; // 0x1a5150 - g_ps2RecompiledFunctionTable[169043] = bhEne04_MainLoop_0x1a5040; // 0x1a5154 - g_ps2RecompiledFunctionTable[169044] = bhEne04_MainLoop_0x1a5040; // 0x1a5158 - g_ps2RecompiledFunctionTable[169045] = bhEne04_MainLoop_0x1a5040; // 0x1a515c - g_ps2RecompiledFunctionTable[169046] = bhEne04_MainLoop_0x1a5040; // 0x1a5160 - g_ps2RecompiledFunctionTable[169050] = bhEne04_SetCollision_0x1a5170; // 0x1a5170 - g_ps2RecompiledFunctionTable[169059] = bhEne04_SetCollision_0x1a5170; // 0x1a5194 - g_ps2RecompiledFunctionTable[169064] = bhEne04_SetCollision_0x1a5170; // 0x1a51a8 - g_ps2RecompiledFunctionTable[169068] = bhEne04_SetCollision_0x1a5170; // 0x1a51b8 - g_ps2RecompiledFunctionTable[169073] = bhEne04_SetCollision_0x1a5170; // 0x1a51cc - g_ps2RecompiledFunctionTable[169078] = bhEne04_SetCollision_0x1a5170; // 0x1a51e0 - g_ps2RecompiledFunctionTable[169086] = bhEne04_SetCollision_0x1a5170; // 0x1a5200 - g_ps2RecompiledFunctionTable[169098] = bhEne04_DmgChk_0x1a5230; // 0x1a5230 - g_ps2RecompiledFunctionTable[169113] = bhEne04_DmgChk_0x1a5230; // 0x1a526c - g_ps2RecompiledFunctionTable[169153] = bhEne04_DmgChk_0x1a5230; // 0x1a530c - g_ps2RecompiledFunctionTable[169180] = bhEne04_DmgChk_0x1a5230; // 0x1a5378 - g_ps2RecompiledFunctionTable[169254] = bhEne04_DmgChk_0x1a5230; // 0x1a54a0 - g_ps2RecompiledFunctionTable[169282] = bhEne04_ChgDmgMode_0x1a5510; // 0x1a5510 - g_ps2RecompiledFunctionTable[169329] = bhEne04_ChgDmgMode_0x1a5510; // 0x1a55cc - g_ps2RecompiledFunctionTable[169358] = bhEne04_DamageAdd_0x1a5640; // 0x1a5640 - g_ps2RecompiledFunctionTable[169389] = bhEne04_DamageAdd_0x1a5640; // 0x1a56bc - g_ps2RecompiledFunctionTable[169394] = bhEne04_DamageAdd_0x1a5640; // 0x1a56d0 - g_ps2RecompiledFunctionTable[169397] = bhEne04_DamageAdd_0x1a5640; // 0x1a56dc - g_ps2RecompiledFunctionTable[169417] = bhEne04_DamageAdd_0x1a5640; // 0x1a572c - g_ps2RecompiledFunctionTable[169424] = bhEne04_DamageAdd_0x1a5640; // 0x1a5748 - g_ps2RecompiledFunctionTable[169460] = bhEne04_DamageAdd_0x1a5640; // 0x1a57d8 - g_ps2RecompiledFunctionTable[169484] = bhEne04_DamageAdd_0x1a5640; // 0x1a5838 - g_ps2RecompiledFunctionTable[169495] = bhEne04_DamageAdd_0x1a5640; // 0x1a5864 - g_ps2RecompiledFunctionTable[169503] = bhEne04_DamageAdd_0x1a5640; // 0x1a5884 - g_ps2RecompiledFunctionTable[169519] = bhEne04_DamageAdd_0x1a5640; // 0x1a58c4 - g_ps2RecompiledFunctionTable[169526] = bhEne04_PlayerControl_0x1a58e0; // 0x1a58e0 - g_ps2RecompiledFunctionTable[169527] = bhEne04_PlayerControl_0x1a58e0; // 0x1a58e4 - g_ps2RecompiledFunctionTable[169528] = bhEne04_PlayerControl_0x1a58e0; // 0x1a58e8 - g_ps2RecompiledFunctionTable[169529] = bhEne04_PlayerControl_0x1a58e0; // 0x1a58ec - g_ps2RecompiledFunctionTable[169530] = bhEne04_PlayerControl_0x1a58e0; // 0x1a58f0 - g_ps2RecompiledFunctionTable[169531] = bhEne04_PlayerControl_0x1a58e0; // 0x1a58f4 - g_ps2RecompiledFunctionTable[169532] = bhEne04_PlayerControl_0x1a58e0; // 0x1a58f8 - g_ps2RecompiledFunctionTable[169533] = bhEne04_PlayerControl_0x1a58e0; // 0x1a58fc - g_ps2RecompiledFunctionTable[169534] = bhEne04_PlayerControl_0x1a58e0; // 0x1a5900 - g_ps2RecompiledFunctionTable[169535] = bhEne04_PlayerControl_0x1a58e0; // 0x1a5904 - g_ps2RecompiledFunctionTable[169536] = bhEne04_PlayerControl_0x1a58e0; // 0x1a5908 - g_ps2RecompiledFunctionTable[169537] = bhEne04_PlayerControl_0x1a58e0; // 0x1a590c - g_ps2RecompiledFunctionTable[169538] = bhEne04_PlayerControl_0x1a58e0; // 0x1a5910 - g_ps2RecompiledFunctionTable[169539] = bhEne04_PlayerControl_0x1a58e0; // 0x1a5914 - g_ps2RecompiledFunctionTable[169540] = bhEne04_PlayerControl_0x1a58e0; // 0x1a5918 - g_ps2RecompiledFunctionTable[169541] = bhEne04_PlayerControl_0x1a58e0; // 0x1a591c - g_ps2RecompiledFunctionTable[169542] = bhEne04_PlayerControl_0x1a58e0; // 0x1a5920 - g_ps2RecompiledFunctionTable[169543] = bhEne04_PlayerControl_0x1a58e0; // 0x1a5924 - g_ps2RecompiledFunctionTable[169544] = bhEne04_PlayerControl_0x1a58e0; // 0x1a5928 - g_ps2RecompiledFunctionTable[169545] = bhEne04_PlayerControl_0x1a58e0; // 0x1a592c - g_ps2RecompiledFunctionTable[169546] = bhEne04_PlayerControl_0x1a58e0; // 0x1a5930 - g_ps2RecompiledFunctionTable[169547] = bhEne04_PlayerControl_0x1a58e0; // 0x1a5934 - g_ps2RecompiledFunctionTable[169548] = bhEne04_PlayerControl_0x1a58e0; // 0x1a5938 - g_ps2RecompiledFunctionTable[169549] = bhEne04_PlayerControl_0x1a58e0; // 0x1a593c - g_ps2RecompiledFunctionTable[169550] = bhEne04_PlayerControl_0x1a58e0; // 0x1a5940 - g_ps2RecompiledFunctionTable[169551] = bhEne04_PlayerControl_0x1a58e0; // 0x1a5944 - g_ps2RecompiledFunctionTable[169554] = bhEne04_PlayerLink_0x1a5950; // 0x1a5950 - g_ps2RecompiledFunctionTable[169567] = bhEne04_PlayerLink_0x1a5950; // 0x1a5984 - g_ps2RecompiledFunctionTable[169572] = bhEne04_PlayerLink_0x1a5950; // 0x1a5998 - g_ps2RecompiledFunctionTable[169577] = bhEne04_PlayerLink_0x1a5950; // 0x1a59ac - g_ps2RecompiledFunctionTable[169582] = bhEne04_PlayerLink_0x1a5950; // 0x1a59c0 - g_ps2RecompiledFunctionTable[169598] = bhEne04_CollisionCheck_0x1a5a00; // 0x1a5a00 - g_ps2RecompiledFunctionTable[169617] = bhEne04_CollisionCheck_0x1a5a00; // 0x1a5a4c - g_ps2RecompiledFunctionTable[169620] = bhEne04_CollisionCheck_0x1a5a00; // 0x1a5a58 - g_ps2RecompiledFunctionTable[169622] = bhEne04_CollisionCheck_0x1a5a00; // 0x1a5a60 - g_ps2RecompiledFunctionTable[169626] = bhEne04_CollCheckWall_0x1a5a70; // 0x1a5a70 - g_ps2RecompiledFunctionTable[169658] = bhEne04_CollCheckWall_0x1a5a70; // 0x1a5af0 - g_ps2RecompiledFunctionTable[169670] = bhEne04_CollCheckWall_0x1a5a70; // 0x1a5b20 - g_ps2RecompiledFunctionTable[169689] = bhEne04_CollCheckWall_0x1a5a70; // 0x1a5b6c - g_ps2RecompiledFunctionTable[169698] = bhEne04_CollCheckWall_0x1a5a70; // 0x1a5b90 - g_ps2RecompiledFunctionTable[169716] = bhEne04_CollCheckWall_0x1a5a70; // 0x1a5bd8 - g_ps2RecompiledFunctionTable[169762] = bhEne04_CollCheckWall_0x1a5a70; // 0x1a5c90 - g_ps2RecompiledFunctionTable[169772] = bhEne04_CollCheckWall_0x1a5a70; // 0x1a5cb8 - g_ps2RecompiledFunctionTable[169798] = bhEne04_CollCheckWall_0x1a5a70; // 0x1a5d20 - g_ps2RecompiledFunctionTable[169808] = bhEne04_CollCheckWall_0x1a5a70; // 0x1a5d48 - g_ps2RecompiledFunctionTable[169826] = bhEne04_Init_0x1a5d90; // 0x1a5d90 - g_ps2RecompiledFunctionTable[169851] = bhEne04_Init_0x1a5d90; // 0x1a5df4 - g_ps2RecompiledFunctionTable[169865] = bhEne04_Init_0x1a5d90; // 0x1a5e2c - g_ps2RecompiledFunctionTable[169878] = bhEne04_Init_0x1a5d90; // 0x1a5e60 - g_ps2RecompiledFunctionTable[169900] = bhEne04_Init_0x1a5d90; // 0x1a5eb8 - g_ps2RecompiledFunctionTable[169906] = bhEne04_Init_0x1a5d90; // 0x1a5ed0 - g_ps2RecompiledFunctionTable[169942] = bhEne04_Init_0x1a5d90; // 0x1a5f60 - g_ps2RecompiledFunctionTable[169955] = bhEne04_Init_0x1a5d90; // 0x1a5f94 - g_ps2RecompiledFunctionTable[169982] = bhEne04_Move_0x1a6000; // 0x1a6000 - g_ps2RecompiledFunctionTable[169983] = bhEne04_Move_0x1a6000; // 0x1a6004 - g_ps2RecompiledFunctionTable[169984] = bhEne04_Move_0x1a6000; // 0x1a6008 - g_ps2RecompiledFunctionTable[169985] = bhEne04_Move_0x1a6000; // 0x1a600c - g_ps2RecompiledFunctionTable[169986] = bhEne04_Move_0x1a6000; // 0x1a6010 - g_ps2RecompiledFunctionTable[169987] = bhEne04_Move_0x1a6000; // 0x1a6014 - g_ps2RecompiledFunctionTable[169988] = bhEne04_Move_0x1a6000; // 0x1a6018 - g_ps2RecompiledFunctionTable[169989] = bhEne04_Move_0x1a6000; // 0x1a601c - g_ps2RecompiledFunctionTable[169990] = bhEne04_Move_0x1a6000; // 0x1a6020 - g_ps2RecompiledFunctionTable[169991] = bhEne04_Move_0x1a6000; // 0x1a6024 - g_ps2RecompiledFunctionTable[169992] = bhEne04_Move_0x1a6000; // 0x1a6028 - g_ps2RecompiledFunctionTable[169993] = bhEne04_Move_0x1a6000; // 0x1a602c - g_ps2RecompiledFunctionTable[169994] = bhEne04_Move_0x1a6000; // 0x1a6030 - g_ps2RecompiledFunctionTable[169998] = bhEne04_Nage_0x1a6040; // 0x1a6040 - g_ps2RecompiledFunctionTable[169999] = bhEne04_Nage_0x1a6040; // 0x1a6044 - g_ps2RecompiledFunctionTable[170000] = bhEne04_Nage_0x1a6040; // 0x1a6048 - g_ps2RecompiledFunctionTable[170001] = bhEne04_Nage_0x1a6040; // 0x1a604c - g_ps2RecompiledFunctionTable[170002] = bhEne04_Nage_0x1a6040; // 0x1a6050 - g_ps2RecompiledFunctionTable[170003] = bhEne04_Nage_0x1a6040; // 0x1a6054 - g_ps2RecompiledFunctionTable[170004] = bhEne04_Nage_0x1a6040; // 0x1a6058 - g_ps2RecompiledFunctionTable[170005] = bhEne04_Nage_0x1a6040; // 0x1a605c - g_ps2RecompiledFunctionTable[170006] = bhEne04_Nage_0x1a6040; // 0x1a6060 - g_ps2RecompiledFunctionTable[170007] = bhEne04_Nage_0x1a6040; // 0x1a6064 - g_ps2RecompiledFunctionTable[170008] = bhEne04_Nage_0x1a6040; // 0x1a6068 - g_ps2RecompiledFunctionTable[170009] = bhEne04_Nage_0x1a6040; // 0x1a606c - g_ps2RecompiledFunctionTable[170010] = bhEne04_Nage_0x1a6040; // 0x1a6070 - g_ps2RecompiledFunctionTable[170014] = bhEne04_Damage_0x1a6080; // 0x1a6080 - g_ps2RecompiledFunctionTable[170015] = bhEne04_Damage_0x1a6080; // 0x1a6084 - g_ps2RecompiledFunctionTable[170016] = bhEne04_Damage_0x1a6080; // 0x1a6088 - g_ps2RecompiledFunctionTable[170017] = bhEne04_Damage_0x1a6080; // 0x1a608c - g_ps2RecompiledFunctionTable[170018] = bhEne04_Damage_0x1a6080; // 0x1a6090 - g_ps2RecompiledFunctionTable[170019] = bhEne04_Damage_0x1a6080; // 0x1a6094 - g_ps2RecompiledFunctionTable[170020] = bhEne04_Damage_0x1a6080; // 0x1a6098 - g_ps2RecompiledFunctionTable[170021] = bhEne04_Damage_0x1a6080; // 0x1a609c - g_ps2RecompiledFunctionTable[170022] = bhEne04_Damage_0x1a6080; // 0x1a60a0 - g_ps2RecompiledFunctionTable[170023] = bhEne04_Damage_0x1a6080; // 0x1a60a4 - g_ps2RecompiledFunctionTable[170024] = bhEne04_Damage_0x1a6080; // 0x1a60a8 - g_ps2RecompiledFunctionTable[170025] = bhEne04_Damage_0x1a6080; // 0x1a60ac - g_ps2RecompiledFunctionTable[170026] = bhEne04_Damage_0x1a6080; // 0x1a60b0 - g_ps2RecompiledFunctionTable[170030] = bhEne04_Die_0x1a60c0; // 0x1a60c0 - g_ps2RecompiledFunctionTable[170031] = bhEne04_Die_0x1a60c0; // 0x1a60c4 - g_ps2RecompiledFunctionTable[170032] = bhEne04_Die_0x1a60c0; // 0x1a60c8 - g_ps2RecompiledFunctionTable[170033] = bhEne04_Die_0x1a60c0; // 0x1a60cc - g_ps2RecompiledFunctionTable[170034] = bhEne04_Die_0x1a60c0; // 0x1a60d0 - g_ps2RecompiledFunctionTable[170035] = bhEne04_Die_0x1a60c0; // 0x1a60d4 - g_ps2RecompiledFunctionTable[170036] = bhEne04_Die_0x1a60c0; // 0x1a60d8 - g_ps2RecompiledFunctionTable[170037] = bhEne04_Die_0x1a60c0; // 0x1a60dc - g_ps2RecompiledFunctionTable[170038] = bhEne04_Die_0x1a60c0; // 0x1a60e0 - g_ps2RecompiledFunctionTable[170039] = bhEne04_Die_0x1a60c0; // 0x1a60e4 - g_ps2RecompiledFunctionTable[170040] = bhEne04_Die_0x1a60c0; // 0x1a60e8 - g_ps2RecompiledFunctionTable[170041] = bhEne04_Die_0x1a60c0; // 0x1a60ec - g_ps2RecompiledFunctionTable[170042] = bhEne04_Die_0x1a60c0; // 0x1a60f0 - g_ps2RecompiledFunctionTable[170046] = bhEne04_MVType00_0x1a6100; // 0x1a6100 - g_ps2RecompiledFunctionTable[170047] = bhEne04_MVType00_0x1a6100; // 0x1a6104 - g_ps2RecompiledFunctionTable[170048] = bhEne04_MVType00_0x1a6100; // 0x1a6108 - g_ps2RecompiledFunctionTable[170049] = bhEne04_MVType00_0x1a6100; // 0x1a610c - g_ps2RecompiledFunctionTable[170050] = bhEne04_MVType00_0x1a6100; // 0x1a6110 - g_ps2RecompiledFunctionTable[170051] = bhEne04_MVType00_0x1a6100; // 0x1a6114 - g_ps2RecompiledFunctionTable[170052] = bhEne04_MVType00_0x1a6100; // 0x1a6118 - g_ps2RecompiledFunctionTable[170053] = bhEne04_MVType00_0x1a6100; // 0x1a611c - g_ps2RecompiledFunctionTable[170054] = bhEne04_MVType00_0x1a6100; // 0x1a6120 - g_ps2RecompiledFunctionTable[170055] = bhEne04_MVType00_0x1a6100; // 0x1a6124 - g_ps2RecompiledFunctionTable[170056] = bhEne04_MVType00_0x1a6100; // 0x1a6128 - g_ps2RecompiledFunctionTable[170057] = bhEne04_MVType00_0x1a6100; // 0x1a612c - g_ps2RecompiledFunctionTable[170058] = bhEne04_MVType00_0x1a6100; // 0x1a6130 - g_ps2RecompiledFunctionTable[170059] = bhEne04_MVType00_0x1a6100; // 0x1a6134 - g_ps2RecompiledFunctionTable[170060] = bhEne04_MVType00_0x1a6100; // 0x1a6138 - g_ps2RecompiledFunctionTable[170061] = bhEne04_MVType00_0x1a6100; // 0x1a613c - g_ps2RecompiledFunctionTable[170062] = bhEne04_MVType00_0x1a6100; // 0x1a6140 - g_ps2RecompiledFunctionTable[170063] = bhEne04_MVType00_0x1a6100; // 0x1a6144 - g_ps2RecompiledFunctionTable[170064] = bhEne04_MVType00_0x1a6100; // 0x1a6148 - g_ps2RecompiledFunctionTable[170065] = bhEne04_MVType00_0x1a6100; // 0x1a614c - g_ps2RecompiledFunctionTable[170066] = bhEne04_MVType00_0x1a6100; // 0x1a6150 - g_ps2RecompiledFunctionTable[170067] = bhEne04_MVType00_0x1a6100; // 0x1a6154 - g_ps2RecompiledFunctionTable[170068] = bhEne04_MVType00_0x1a6100; // 0x1a6158 - g_ps2RecompiledFunctionTable[170069] = bhEne04_MVType00_0x1a6100; // 0x1a615c - g_ps2RecompiledFunctionTable[170070] = bhEne04_MVType00_0x1a6100; // 0x1a6160 - g_ps2RecompiledFunctionTable[170071] = bhEne04_MVType00_0x1a6100; // 0x1a6164 - g_ps2RecompiledFunctionTable[170072] = bhEne04_MVType00_0x1a6100; // 0x1a6168 - g_ps2RecompiledFunctionTable[170073] = bhEne04_MVType00_0x1a6100; // 0x1a616c - g_ps2RecompiledFunctionTable[170074] = bhEne04_MVType00_0x1a6100; // 0x1a6170 - g_ps2RecompiledFunctionTable[170075] = bhEne04_MVType00_0x1a6100; // 0x1a6174 - g_ps2RecompiledFunctionTable[170076] = bhEne04_MVType00_0x1a6100; // 0x1a6178 - g_ps2RecompiledFunctionTable[170077] = bhEne04_MVType00_0x1a6100; // 0x1a617c - g_ps2RecompiledFunctionTable[170078] = bhEne04_MVType00_0x1a6100; // 0x1a6180 - g_ps2RecompiledFunctionTable[170079] = bhEne04_MVType00_0x1a6100; // 0x1a6184 - g_ps2RecompiledFunctionTable[170080] = bhEne04_MVType00_0x1a6100; // 0x1a6188 - g_ps2RecompiledFunctionTable[170081] = bhEne04_MVType00_0x1a6100; // 0x1a618c - g_ps2RecompiledFunctionTable[170082] = bhEne04_MVType00_0x1a6100; // 0x1a6190 - g_ps2RecompiledFunctionTable[170083] = bhEne04_MVType00_0x1a6100; // 0x1a6194 - g_ps2RecompiledFunctionTable[170084] = bhEne04_MVType00_0x1a6100; // 0x1a6198 - g_ps2RecompiledFunctionTable[170085] = bhEne04_MVType00_0x1a6100; // 0x1a619c - g_ps2RecompiledFunctionTable[170086] = bhEne04_MVType00_0x1a6100; // 0x1a61a0 - g_ps2RecompiledFunctionTable[170087] = bhEne04_MVType00_0x1a6100; // 0x1a61a4 - g_ps2RecompiledFunctionTable[170088] = bhEne04_MVType00_0x1a6100; // 0x1a61a8 - g_ps2RecompiledFunctionTable[170089] = bhEne04_MVType00_0x1a6100; // 0x1a61ac - g_ps2RecompiledFunctionTable[170090] = bhEne04_MVType00_0x1a6100; // 0x1a61b0 - g_ps2RecompiledFunctionTable[170091] = bhEne04_MVType00_0x1a6100; // 0x1a61b4 - g_ps2RecompiledFunctionTable[170092] = bhEne04_MVType00_0x1a6100; // 0x1a61b8 - g_ps2RecompiledFunctionTable[170093] = bhEne04_MVType00_0x1a6100; // 0x1a61bc - g_ps2RecompiledFunctionTable[170094] = bhEne04_MVType00_0x1a6100; // 0x1a61c0 - g_ps2RecompiledFunctionTable[170095] = bhEne04_MVType00_0x1a6100; // 0x1a61c4 - g_ps2RecompiledFunctionTable[170096] = bhEne04_MVType00_0x1a6100; // 0x1a61c8 - g_ps2RecompiledFunctionTable[170097] = bhEne04_MVType00_0x1a6100; // 0x1a61cc - g_ps2RecompiledFunctionTable[170098] = bhEne04_MVType00_0x1a6100; // 0x1a61d0 - g_ps2RecompiledFunctionTable[170099] = bhEne04_MVType00_0x1a6100; // 0x1a61d4 - g_ps2RecompiledFunctionTable[170100] = bhEne04_MVType00_0x1a6100; // 0x1a61d8 - g_ps2RecompiledFunctionTable[170101] = bhEne04_MVType00_0x1a6100; // 0x1a61dc - g_ps2RecompiledFunctionTable[170102] = bhEne04_MVType00_0x1a6100; // 0x1a61e0 - g_ps2RecompiledFunctionTable[170103] = bhEne04_MVType00_0x1a6100; // 0x1a61e4 - g_ps2RecompiledFunctionTable[170104] = bhEne04_MVType00_0x1a6100; // 0x1a61e8 - g_ps2RecompiledFunctionTable[170105] = bhEne04_MVType00_0x1a6100; // 0x1a61ec - g_ps2RecompiledFunctionTable[170106] = bhEne04_MVType00_0x1a6100; // 0x1a61f0 - g_ps2RecompiledFunctionTable[170107] = bhEne04_MVType00_0x1a6100; // 0x1a61f4 - g_ps2RecompiledFunctionTable[170108] = bhEne04_MVType00_0x1a6100; // 0x1a61f8 - g_ps2RecompiledFunctionTable[170109] = bhEne04_MVType00_0x1a6100; // 0x1a61fc - g_ps2RecompiledFunctionTable[170110] = bhEne04_MVType00_0x1a6100; // 0x1a6200 - g_ps2RecompiledFunctionTable[170111] = bhEne04_MVType00_0x1a6100; // 0x1a6204 - g_ps2RecompiledFunctionTable[170112] = bhEne04_MVType00_0x1a6100; // 0x1a6208 - g_ps2RecompiledFunctionTable[170113] = bhEne04_MVType00_0x1a6100; // 0x1a620c - g_ps2RecompiledFunctionTable[170114] = bhEne04_MVType00_0x1a6100; // 0x1a6210 - g_ps2RecompiledFunctionTable[170115] = bhEne04_MVType00_0x1a6100; // 0x1a6214 - g_ps2RecompiledFunctionTable[170116] = bhEne04_MVType00_0x1a6100; // 0x1a6218 - g_ps2RecompiledFunctionTable[170117] = bhEne04_MVType00_0x1a6100; // 0x1a621c - g_ps2RecompiledFunctionTable[170118] = bhEne04_MVType00_0x1a6100; // 0x1a6220 - g_ps2RecompiledFunctionTable[170119] = bhEne04_MVType00_0x1a6100; // 0x1a6224 - g_ps2RecompiledFunctionTable[170120] = bhEne04_MVType00_0x1a6100; // 0x1a6228 - g_ps2RecompiledFunctionTable[170121] = bhEne04_MVType00_0x1a6100; // 0x1a622c - g_ps2RecompiledFunctionTable[170122] = bhEne04_MVType00_0x1a6100; // 0x1a6230 - g_ps2RecompiledFunctionTable[170123] = bhEne04_MVType00_0x1a6100; // 0x1a6234 - g_ps2RecompiledFunctionTable[170124] = bhEne04_MVType00_0x1a6100; // 0x1a6238 - g_ps2RecompiledFunctionTable[170125] = bhEne04_MVType00_0x1a6100; // 0x1a623c - g_ps2RecompiledFunctionTable[170126] = bhEne04_MVType00_0x1a6100; // 0x1a6240 - g_ps2RecompiledFunctionTable[170127] = bhEne04_MVType00_0x1a6100; // 0x1a6244 - g_ps2RecompiledFunctionTable[170128] = bhEne04_MVType00_0x1a6100; // 0x1a6248 - g_ps2RecompiledFunctionTable[170129] = bhEne04_MVType00_0x1a6100; // 0x1a624c - g_ps2RecompiledFunctionTable[170130] = bhEne04_MVType00_0x1a6100; // 0x1a6250 - g_ps2RecompiledFunctionTable[170131] = bhEne04_MVType00_0x1a6100; // 0x1a6254 - g_ps2RecompiledFunctionTable[170132] = bhEne04_MVType00_0x1a6100; // 0x1a6258 - g_ps2RecompiledFunctionTable[170133] = bhEne04_MVType00_0x1a6100; // 0x1a625c - g_ps2RecompiledFunctionTable[170134] = bhEne04_MVType00_0x1a6100; // 0x1a6260 - g_ps2RecompiledFunctionTable[170135] = bhEne04_MVType00_0x1a6100; // 0x1a6264 - g_ps2RecompiledFunctionTable[170136] = bhEne04_MVType00_0x1a6100; // 0x1a6268 - g_ps2RecompiledFunctionTable[170137] = bhEne04_MVType00_0x1a6100; // 0x1a626c - g_ps2RecompiledFunctionTable[170138] = bhEne04_MVType00_0x1a6100; // 0x1a6270 - g_ps2RecompiledFunctionTable[170139] = bhEne04_MVType00_0x1a6100; // 0x1a6274 - g_ps2RecompiledFunctionTable[170140] = bhEne04_MVType00_0x1a6100; // 0x1a6278 - g_ps2RecompiledFunctionTable[170141] = bhEne04_MVType00_0x1a6100; // 0x1a627c - g_ps2RecompiledFunctionTable[170142] = bhEne04_MVType00_0x1a6100; // 0x1a6280 - g_ps2RecompiledFunctionTable[170143] = bhEne04_MVType00_0x1a6100; // 0x1a6284 - g_ps2RecompiledFunctionTable[170144] = bhEne04_MVType00_0x1a6100; // 0x1a6288 - g_ps2RecompiledFunctionTable[170145] = bhEne04_MVType00_0x1a6100; // 0x1a628c - g_ps2RecompiledFunctionTable[170146] = bhEne04_MVType00_0x1a6100; // 0x1a6290 - g_ps2RecompiledFunctionTable[170147] = bhEne04_MVType00_0x1a6100; // 0x1a6294 - g_ps2RecompiledFunctionTable[170148] = bhEne04_MVType00_0x1a6100; // 0x1a6298 - g_ps2RecompiledFunctionTable[170149] = bhEne04_MVType00_0x1a6100; // 0x1a629c - g_ps2RecompiledFunctionTable[170150] = bhEne04_MVType00_0x1a6100; // 0x1a62a0 - g_ps2RecompiledFunctionTable[170151] = bhEne04_MVType00_0x1a6100; // 0x1a62a4 - g_ps2RecompiledFunctionTable[170152] = bhEne04_MVType00_0x1a6100; // 0x1a62a8 - g_ps2RecompiledFunctionTable[170153] = bhEne04_MVType00_0x1a6100; // 0x1a62ac - g_ps2RecompiledFunctionTable[170154] = bhEne04_MVType00_0x1a6100; // 0x1a62b0 - g_ps2RecompiledFunctionTable[170155] = bhEne04_MVType00_0x1a6100; // 0x1a62b4 - g_ps2RecompiledFunctionTable[170156] = bhEne04_MVType00_0x1a6100; // 0x1a62b8 - g_ps2RecompiledFunctionTable[170157] = bhEne04_MVType00_0x1a6100; // 0x1a62bc - g_ps2RecompiledFunctionTable[170158] = bhEne04_MVType00_0x1a6100; // 0x1a62c0 - g_ps2RecompiledFunctionTable[170159] = bhEne04_MVType00_0x1a6100; // 0x1a62c4 - g_ps2RecompiledFunctionTable[170160] = bhEne04_MVType00_0x1a6100; // 0x1a62c8 - g_ps2RecompiledFunctionTable[170161] = bhEne04_MVType00_0x1a6100; // 0x1a62cc - g_ps2RecompiledFunctionTable[170162] = bhEne04_MVType00_0x1a6100; // 0x1a62d0 - g_ps2RecompiledFunctionTable[170163] = bhEne04_MVType00_0x1a6100; // 0x1a62d4 - g_ps2RecompiledFunctionTable[170164] = bhEne04_MVType00_0x1a6100; // 0x1a62d8 - g_ps2RecompiledFunctionTable[170165] = bhEne04_MVType00_0x1a6100; // 0x1a62dc - g_ps2RecompiledFunctionTable[170166] = bhEne04_MVType00_0x1a6100; // 0x1a62e0 - g_ps2RecompiledFunctionTable[170167] = bhEne04_MVType00_0x1a6100; // 0x1a62e4 - g_ps2RecompiledFunctionTable[170168] = bhEne04_MVType00_0x1a6100; // 0x1a62e8 - g_ps2RecompiledFunctionTable[170169] = bhEne04_MVType00_0x1a6100; // 0x1a62ec - g_ps2RecompiledFunctionTable[170170] = bhEne04_MVType00_0x1a6100; // 0x1a62f0 - g_ps2RecompiledFunctionTable[170171] = bhEne04_MVType00_0x1a6100; // 0x1a62f4 - g_ps2RecompiledFunctionTable[170172] = bhEne04_MVType00_0x1a6100; // 0x1a62f8 - g_ps2RecompiledFunctionTable[170173] = bhEne04_MVType00_0x1a6100; // 0x1a62fc - g_ps2RecompiledFunctionTable[170174] = bhEne04_MVType00_0x1a6100; // 0x1a6300 - g_ps2RecompiledFunctionTable[170175] = bhEne04_MVType00_0x1a6100; // 0x1a6304 - g_ps2RecompiledFunctionTable[170176] = bhEne04_MVType00_0x1a6100; // 0x1a6308 - g_ps2RecompiledFunctionTable[170177] = bhEne04_MVType00_0x1a6100; // 0x1a630c - g_ps2RecompiledFunctionTable[170178] = bhEne04_MVType00_0x1a6100; // 0x1a6310 - g_ps2RecompiledFunctionTable[170179] = bhEne04_MVType00_0x1a6100; // 0x1a6314 - g_ps2RecompiledFunctionTable[170180] = bhEne04_MVType00_0x1a6100; // 0x1a6318 - g_ps2RecompiledFunctionTable[170181] = bhEne04_MVType00_0x1a6100; // 0x1a631c - g_ps2RecompiledFunctionTable[170182] = bhEne04_MVType00_0x1a6100; // 0x1a6320 - g_ps2RecompiledFunctionTable[170183] = bhEne04_MVType00_0x1a6100; // 0x1a6324 - g_ps2RecompiledFunctionTable[170184] = bhEne04_MVType00_0x1a6100; // 0x1a6328 - g_ps2RecompiledFunctionTable[170185] = bhEne04_MVType00_0x1a6100; // 0x1a632c - g_ps2RecompiledFunctionTable[170186] = bhEne04_MVType00_0x1a6100; // 0x1a6330 - g_ps2RecompiledFunctionTable[170187] = bhEne04_MVType00_0x1a6100; // 0x1a6334 - g_ps2RecompiledFunctionTable[170188] = bhEne04_MVType00_0x1a6100; // 0x1a6338 - g_ps2RecompiledFunctionTable[170189] = bhEne04_MVType00_0x1a6100; // 0x1a633c - g_ps2RecompiledFunctionTable[170190] = bhEne04_MVType00_0x1a6100; // 0x1a6340 - g_ps2RecompiledFunctionTable[170191] = bhEne04_MVType00_0x1a6100; // 0x1a6344 - g_ps2RecompiledFunctionTable[170192] = bhEne04_MVType00_0x1a6100; // 0x1a6348 - g_ps2RecompiledFunctionTable[170193] = bhEne04_MVType00_0x1a6100; // 0x1a634c - g_ps2RecompiledFunctionTable[170194] = bhEne04_MVType00_0x1a6100; // 0x1a6350 - g_ps2RecompiledFunctionTable[170195] = bhEne04_MVType00_0x1a6100; // 0x1a6354 - g_ps2RecompiledFunctionTable[170196] = bhEne04_MVType00_0x1a6100; // 0x1a6358 - g_ps2RecompiledFunctionTable[170197] = bhEne04_MVType00_0x1a6100; // 0x1a635c - g_ps2RecompiledFunctionTable[170198] = bhEne04_MVType00_0x1a6100; // 0x1a6360 - g_ps2RecompiledFunctionTable[170199] = bhEne04_MVType00_0x1a6100; // 0x1a6364 - g_ps2RecompiledFunctionTable[170200] = bhEne04_MVType00_0x1a6100; // 0x1a6368 - g_ps2RecompiledFunctionTable[170201] = bhEne04_MVType00_0x1a6100; // 0x1a636c - g_ps2RecompiledFunctionTable[170202] = bhEne04_MVType00_0x1a6100; // 0x1a6370 - g_ps2RecompiledFunctionTable[170203] = bhEne04_MVType00_0x1a6100; // 0x1a6374 - g_ps2RecompiledFunctionTable[170204] = bhEne04_MVType00_0x1a6100; // 0x1a6378 - g_ps2RecompiledFunctionTable[170205] = bhEne04_MVType00_0x1a6100; // 0x1a637c - g_ps2RecompiledFunctionTable[170206] = bhEne04_MVType00_0x1a6100; // 0x1a6380 - g_ps2RecompiledFunctionTable[170207] = bhEne04_MVType00_0x1a6100; // 0x1a6384 - g_ps2RecompiledFunctionTable[170208] = bhEne04_MVType00_0x1a6100; // 0x1a6388 - g_ps2RecompiledFunctionTable[170209] = bhEne04_MVType00_0x1a6100; // 0x1a638c - g_ps2RecompiledFunctionTable[170210] = bhEne04_MVType00_0x1a6100; // 0x1a6390 - g_ps2RecompiledFunctionTable[170211] = bhEne04_MVType00_0x1a6100; // 0x1a6394 - g_ps2RecompiledFunctionTable[170212] = bhEne04_MVType00_0x1a6100; // 0x1a6398 - g_ps2RecompiledFunctionTable[170213] = bhEne04_MVType00_0x1a6100; // 0x1a639c - g_ps2RecompiledFunctionTable[170214] = bhEne04_MVType00_0x1a6100; // 0x1a63a0 - g_ps2RecompiledFunctionTable[170215] = bhEne04_MVType00_0x1a6100; // 0x1a63a4 - g_ps2RecompiledFunctionTable[170216] = bhEne04_MVType00_0x1a6100; // 0x1a63a8 - g_ps2RecompiledFunctionTable[170217] = bhEne04_MVType00_0x1a6100; // 0x1a63ac - g_ps2RecompiledFunctionTable[170218] = bhEne04_MVType00_0x1a6100; // 0x1a63b0 - g_ps2RecompiledFunctionTable[170219] = bhEne04_MVType00_0x1a6100; // 0x1a63b4 - g_ps2RecompiledFunctionTable[170220] = bhEne04_MVType00_0x1a6100; // 0x1a63b8 - g_ps2RecompiledFunctionTable[170221] = bhEne04_MVType00_0x1a6100; // 0x1a63bc - g_ps2RecompiledFunctionTable[170222] = bhEne04_MVType00_0x1a6100; // 0x1a63c0 - g_ps2RecompiledFunctionTable[170223] = bhEne04_MVType00_0x1a6100; // 0x1a63c4 - g_ps2RecompiledFunctionTable[170226] = bhEne04_MVType01_0x1a63d0; // 0x1a63d0 - g_ps2RecompiledFunctionTable[170227] = bhEne04_MVType01_0x1a63d0; // 0x1a63d4 - g_ps2RecompiledFunctionTable[170228] = bhEne04_MVType01_0x1a63d0; // 0x1a63d8 - g_ps2RecompiledFunctionTable[170229] = bhEne04_MVType01_0x1a63d0; // 0x1a63dc - g_ps2RecompiledFunctionTable[170230] = bhEne04_MVType01_0x1a63d0; // 0x1a63e0 - g_ps2RecompiledFunctionTable[170231] = bhEne04_MVType01_0x1a63d0; // 0x1a63e4 - g_ps2RecompiledFunctionTable[170232] = bhEne04_MVType01_0x1a63d0; // 0x1a63e8 - g_ps2RecompiledFunctionTable[170233] = bhEne04_MVType01_0x1a63d0; // 0x1a63ec - g_ps2RecompiledFunctionTable[170234] = bhEne04_MVType01_0x1a63d0; // 0x1a63f0 - g_ps2RecompiledFunctionTable[170235] = bhEne04_MVType01_0x1a63d0; // 0x1a63f4 - g_ps2RecompiledFunctionTable[170236] = bhEne04_MVType01_0x1a63d0; // 0x1a63f8 - g_ps2RecompiledFunctionTable[170237] = bhEne04_MVType01_0x1a63d0; // 0x1a63fc - g_ps2RecompiledFunctionTable[170238] = bhEne04_MVType01_0x1a63d0; // 0x1a6400 - g_ps2RecompiledFunctionTable[170239] = bhEne04_MVType01_0x1a63d0; // 0x1a6404 - g_ps2RecompiledFunctionTable[170240] = bhEne04_MVType01_0x1a63d0; // 0x1a6408 - g_ps2RecompiledFunctionTable[170241] = bhEne04_MVType01_0x1a63d0; // 0x1a640c - g_ps2RecompiledFunctionTable[170242] = bhEne04_MVType01_0x1a63d0; // 0x1a6410 - g_ps2RecompiledFunctionTable[170243] = bhEne04_MVType01_0x1a63d0; // 0x1a6414 - g_ps2RecompiledFunctionTable[170244] = bhEne04_MVType01_0x1a63d0; // 0x1a6418 - g_ps2RecompiledFunctionTable[170245] = bhEne04_MVType01_0x1a63d0; // 0x1a641c - g_ps2RecompiledFunctionTable[170246] = bhEne04_MVType01_0x1a63d0; // 0x1a6420 - g_ps2RecompiledFunctionTable[170247] = bhEne04_MVType01_0x1a63d0; // 0x1a6424 - g_ps2RecompiledFunctionTable[170248] = bhEne04_MVType01_0x1a63d0; // 0x1a6428 - g_ps2RecompiledFunctionTable[170249] = bhEne04_MVType01_0x1a63d0; // 0x1a642c - g_ps2RecompiledFunctionTable[170250] = bhEne04_MVType01_0x1a63d0; // 0x1a6430 - g_ps2RecompiledFunctionTable[170251] = bhEne04_MVType01_0x1a63d0; // 0x1a6434 - g_ps2RecompiledFunctionTable[170252] = bhEne04_MVType01_0x1a63d0; // 0x1a6438 - g_ps2RecompiledFunctionTable[170253] = bhEne04_MVType01_0x1a63d0; // 0x1a643c - g_ps2RecompiledFunctionTable[170254] = bhEne04_MVType01_0x1a63d0; // 0x1a6440 - g_ps2RecompiledFunctionTable[170255] = bhEne04_MVType01_0x1a63d0; // 0x1a6444 - g_ps2RecompiledFunctionTable[170256] = bhEne04_MVType01_0x1a63d0; // 0x1a6448 - g_ps2RecompiledFunctionTable[170257] = bhEne04_MVType01_0x1a63d0; // 0x1a644c - g_ps2RecompiledFunctionTable[170258] = bhEne04_MVType01_0x1a63d0; // 0x1a6450 - g_ps2RecompiledFunctionTable[170259] = bhEne04_MVType01_0x1a63d0; // 0x1a6454 - g_ps2RecompiledFunctionTable[170260] = bhEne04_MVType01_0x1a63d0; // 0x1a6458 - g_ps2RecompiledFunctionTable[170261] = bhEne04_MVType01_0x1a63d0; // 0x1a645c - g_ps2RecompiledFunctionTable[170262] = bhEne04_MVType01_0x1a63d0; // 0x1a6460 - g_ps2RecompiledFunctionTable[170263] = bhEne04_MVType01_0x1a63d0; // 0x1a6464 - g_ps2RecompiledFunctionTable[170264] = bhEne04_MVType01_0x1a63d0; // 0x1a6468 - g_ps2RecompiledFunctionTable[170265] = bhEne04_MVType01_0x1a63d0; // 0x1a646c - g_ps2RecompiledFunctionTable[170266] = bhEne04_MVType01_0x1a63d0; // 0x1a6470 - g_ps2RecompiledFunctionTable[170267] = bhEne04_MVType01_0x1a63d0; // 0x1a6474 - g_ps2RecompiledFunctionTable[170268] = bhEne04_MVType01_0x1a63d0; // 0x1a6478 - g_ps2RecompiledFunctionTable[170269] = bhEne04_MVType01_0x1a63d0; // 0x1a647c - g_ps2RecompiledFunctionTable[170270] = bhEne04_MVType01_0x1a63d0; // 0x1a6480 - g_ps2RecompiledFunctionTable[170271] = bhEne04_MVType01_0x1a63d0; // 0x1a6484 - g_ps2RecompiledFunctionTable[170272] = bhEne04_MVType01_0x1a63d0; // 0x1a6488 - g_ps2RecompiledFunctionTable[170273] = bhEne04_MVType01_0x1a63d0; // 0x1a648c - g_ps2RecompiledFunctionTable[170274] = bhEne04_MVType01_0x1a63d0; // 0x1a6490 - g_ps2RecompiledFunctionTable[170275] = bhEne04_MVType01_0x1a63d0; // 0x1a6494 - g_ps2RecompiledFunctionTable[170276] = bhEne04_MVType01_0x1a63d0; // 0x1a6498 - g_ps2RecompiledFunctionTable[170277] = bhEne04_MVType01_0x1a63d0; // 0x1a649c - g_ps2RecompiledFunctionTable[170278] = bhEne04_MVType01_0x1a63d0; // 0x1a64a0 - g_ps2RecompiledFunctionTable[170279] = bhEne04_MVType01_0x1a63d0; // 0x1a64a4 - g_ps2RecompiledFunctionTable[170280] = bhEne04_MVType01_0x1a63d0; // 0x1a64a8 - g_ps2RecompiledFunctionTable[170281] = bhEne04_MVType01_0x1a63d0; // 0x1a64ac - g_ps2RecompiledFunctionTable[170282] = bhEne04_MVType01_0x1a63d0; // 0x1a64b0 - g_ps2RecompiledFunctionTable[170283] = bhEne04_MVType01_0x1a63d0; // 0x1a64b4 - g_ps2RecompiledFunctionTable[170284] = bhEne04_MVType01_0x1a63d0; // 0x1a64b8 - g_ps2RecompiledFunctionTable[170285] = bhEne04_MVType01_0x1a63d0; // 0x1a64bc - g_ps2RecompiledFunctionTable[170286] = bhEne04_MVType01_0x1a63d0; // 0x1a64c0 - g_ps2RecompiledFunctionTable[170287] = bhEne04_MVType01_0x1a63d0; // 0x1a64c4 - g_ps2RecompiledFunctionTable[170288] = bhEne04_MVType01_0x1a63d0; // 0x1a64c8 - g_ps2RecompiledFunctionTable[170289] = bhEne04_MVType01_0x1a63d0; // 0x1a64cc - g_ps2RecompiledFunctionTable[170290] = bhEne04_MVType02_0x1a64d0; // 0x1a64d0 - g_ps2RecompiledFunctionTable[170291] = bhEne04_MVType02_0x1a64d0; // 0x1a64d4 - g_ps2RecompiledFunctionTable[170292] = bhEne04_MVType02_0x1a64d0; // 0x1a64d8 - g_ps2RecompiledFunctionTable[170293] = bhEne04_MVType02_0x1a64d0; // 0x1a64dc - g_ps2RecompiledFunctionTable[170294] = bhEne04_MVType02_0x1a64d0; // 0x1a64e0 - g_ps2RecompiledFunctionTable[170295] = bhEne04_MVType02_0x1a64d0; // 0x1a64e4 - g_ps2RecompiledFunctionTable[170296] = bhEne04_MVType02_0x1a64d0; // 0x1a64e8 - g_ps2RecompiledFunctionTable[170297] = bhEne04_MVType02_0x1a64d0; // 0x1a64ec - g_ps2RecompiledFunctionTable[170298] = bhEne04_MVType02_0x1a64d0; // 0x1a64f0 - g_ps2RecompiledFunctionTable[170299] = bhEne04_MVType02_0x1a64d0; // 0x1a64f4 - g_ps2RecompiledFunctionTable[170300] = bhEne04_MVType02_0x1a64d0; // 0x1a64f8 - g_ps2RecompiledFunctionTable[170301] = bhEne04_MVType02_0x1a64d0; // 0x1a64fc - g_ps2RecompiledFunctionTable[170302] = bhEne04_MVType02_0x1a64d0; // 0x1a6500 - g_ps2RecompiledFunctionTable[170303] = bhEne04_MVType02_0x1a64d0; // 0x1a6504 - g_ps2RecompiledFunctionTable[170304] = bhEne04_MVType02_0x1a64d0; // 0x1a6508 - g_ps2RecompiledFunctionTable[170305] = bhEne04_MVType02_0x1a64d0; // 0x1a650c - g_ps2RecompiledFunctionTable[170306] = bhEne04_MVType02_0x1a64d0; // 0x1a6510 - g_ps2RecompiledFunctionTable[170307] = bhEne04_MVType02_0x1a64d0; // 0x1a6514 - g_ps2RecompiledFunctionTable[170308] = bhEne04_MVType02_0x1a64d0; // 0x1a6518 - g_ps2RecompiledFunctionTable[170309] = bhEne04_MVType02_0x1a64d0; // 0x1a651c - g_ps2RecompiledFunctionTable[170310] = bhEne04_MVType02_0x1a64d0; // 0x1a6520 - g_ps2RecompiledFunctionTable[170311] = bhEne04_MVType02_0x1a64d0; // 0x1a6524 - g_ps2RecompiledFunctionTable[170312] = bhEne04_MVType02_0x1a64d0; // 0x1a6528 - g_ps2RecompiledFunctionTable[170313] = bhEne04_MVType02_0x1a64d0; // 0x1a652c - g_ps2RecompiledFunctionTable[170314] = bhEne04_MVType02_0x1a64d0; // 0x1a6530 - g_ps2RecompiledFunctionTable[170315] = bhEne04_MVType02_0x1a64d0; // 0x1a6534 - g_ps2RecompiledFunctionTable[170316] = bhEne04_MVType02_0x1a64d0; // 0x1a6538 - g_ps2RecompiledFunctionTable[170317] = bhEne04_MVType02_0x1a64d0; // 0x1a653c - g_ps2RecompiledFunctionTable[170318] = bhEne04_MVType02_0x1a64d0; // 0x1a6540 - g_ps2RecompiledFunctionTable[170319] = bhEne04_MVType02_0x1a64d0; // 0x1a6544 - g_ps2RecompiledFunctionTable[170320] = bhEne04_MVType02_0x1a64d0; // 0x1a6548 - g_ps2RecompiledFunctionTable[170321] = bhEne04_MVType02_0x1a64d0; // 0x1a654c - g_ps2RecompiledFunctionTable[170322] = bhEne04_MVType02_0x1a64d0; // 0x1a6550 - g_ps2RecompiledFunctionTable[170323] = bhEne04_MVType02_0x1a64d0; // 0x1a6554 - g_ps2RecompiledFunctionTable[170324] = bhEne04_MVType02_0x1a64d0; // 0x1a6558 - g_ps2RecompiledFunctionTable[170325] = bhEne04_MVType02_0x1a64d0; // 0x1a655c - g_ps2RecompiledFunctionTable[170326] = bhEne04_MVType02_0x1a64d0; // 0x1a6560 - g_ps2RecompiledFunctionTable[170327] = bhEne04_MVType02_0x1a64d0; // 0x1a6564 - g_ps2RecompiledFunctionTable[170328] = bhEne04_MVType02_0x1a64d0; // 0x1a6568 - g_ps2RecompiledFunctionTable[170329] = bhEne04_MVType02_0x1a64d0; // 0x1a656c - g_ps2RecompiledFunctionTable[170330] = bhEne04_MVType02_0x1a64d0; // 0x1a6570 - g_ps2RecompiledFunctionTable[170331] = bhEne04_MVType02_0x1a64d0; // 0x1a6574 - g_ps2RecompiledFunctionTable[170332] = bhEne04_MVType02_0x1a64d0; // 0x1a6578 - g_ps2RecompiledFunctionTable[170333] = bhEne04_MVType02_0x1a64d0; // 0x1a657c - g_ps2RecompiledFunctionTable[170334] = bhEne04_MVType02_0x1a64d0; // 0x1a6580 - g_ps2RecompiledFunctionTable[170335] = bhEne04_MVType02_0x1a64d0; // 0x1a6584 - g_ps2RecompiledFunctionTable[170336] = bhEne04_MVType02_0x1a64d0; // 0x1a6588 - g_ps2RecompiledFunctionTable[170337] = bhEne04_MVType02_0x1a64d0; // 0x1a658c - g_ps2RecompiledFunctionTable[170338] = bhEne04_MVType02_0x1a64d0; // 0x1a6590 - g_ps2RecompiledFunctionTable[170339] = bhEne04_MVType02_0x1a64d0; // 0x1a6594 - g_ps2RecompiledFunctionTable[170340] = bhEne04_MVType02_0x1a64d0; // 0x1a6598 - g_ps2RecompiledFunctionTable[170341] = bhEne04_MVType02_0x1a64d0; // 0x1a659c - g_ps2RecompiledFunctionTable[170342] = bhEne04_MVType02_0x1a64d0; // 0x1a65a0 - g_ps2RecompiledFunctionTable[170343] = bhEne04_MVType02_0x1a64d0; // 0x1a65a4 - g_ps2RecompiledFunctionTable[170344] = bhEne04_MVType02_0x1a64d0; // 0x1a65a8 - g_ps2RecompiledFunctionTable[170345] = bhEne04_MVType02_0x1a64d0; // 0x1a65ac - g_ps2RecompiledFunctionTable[170346] = bhEne04_MVType02_0x1a64d0; // 0x1a65b0 - g_ps2RecompiledFunctionTable[170347] = bhEne04_MVType02_0x1a64d0; // 0x1a65b4 - g_ps2RecompiledFunctionTable[170348] = bhEne04_MVType02_0x1a64d0; // 0x1a65b8 - g_ps2RecompiledFunctionTable[170349] = bhEne04_MVType02_0x1a64d0; // 0x1a65bc - g_ps2RecompiledFunctionTable[170350] = bhEne04_AtariCheck_0x1a65c0; // 0x1a65c0 - g_ps2RecompiledFunctionTable[170362] = bhEne04_AtariCheck_0x1a65c0; // 0x1a65f0 - g_ps2RecompiledFunctionTable[170403] = bhEne04_AtariCheck_0x1a65c0; // 0x1a6694 - g_ps2RecompiledFunctionTable[170452] = bhEne04_AtariCheck_0x1a65c0; // 0x1a6758 - g_ps2RecompiledFunctionTable[170463] = bhEne04_AtariCheck_0x1a65c0; // 0x1a6784 - g_ps2RecompiledFunctionTable[170506] = bhEne04_AtariCheck2_0x1a6830; // 0x1a6830 - g_ps2RecompiledFunctionTable[170518] = bhEne04_AtariCheck2_0x1a6830; // 0x1a6860 - g_ps2RecompiledFunctionTable[170545] = bhEne04_AtariCheck2_0x1a6830; // 0x1a68cc - g_ps2RecompiledFunctionTable[170597] = bhEne04_AtariCheck2_0x1a6830; // 0x1a699c - g_ps2RecompiledFunctionTable[170609] = bhEne04_AtariCheck2_0x1a6830; // 0x1a69cc - g_ps2RecompiledFunctionTable[170632] = bhEne04_AtariCheck2_0x1a6830; // 0x1a6a28 - g_ps2RecompiledFunctionTable[170658] = bhEne04_EnemyAtariCheck2_0x1a6a90; // 0x1a6a90 - g_ps2RecompiledFunctionTable[170674] = bhEne04_EnemyAtariCheck2_0x1a6a90; // 0x1a6ad0 - g_ps2RecompiledFunctionTable[170722] = bhEne04_EneSearch_0x1a6b90; // 0x1a6b90 - g_ps2RecompiledFunctionTable[170737] = bhEne04_EneSearch_0x1a6b90; // 0x1a6bcc - g_ps2RecompiledFunctionTable[170798] = bhEne04_Brain_0x1a6cc0; // 0x1a6cc0 - g_ps2RecompiledFunctionTable[170799] = bhEne04_Brain_0x1a6cc0; // 0x1a6cc4 - g_ps2RecompiledFunctionTable[170800] = bhEne04_Brain_0x1a6cc0; // 0x1a6cc8 - g_ps2RecompiledFunctionTable[170801] = bhEne04_Brain_0x1a6cc0; // 0x1a6ccc - g_ps2RecompiledFunctionTable[170802] = bhEne04_Brain_0x1a6cc0; // 0x1a6cd0 - g_ps2RecompiledFunctionTable[170803] = bhEne04_Brain_0x1a6cc0; // 0x1a6cd4 - g_ps2RecompiledFunctionTable[170804] = bhEne04_Brain_0x1a6cc0; // 0x1a6cd8 - g_ps2RecompiledFunctionTable[170805] = bhEne04_Brain_0x1a6cc0; // 0x1a6cdc - g_ps2RecompiledFunctionTable[170806] = bhEne04_Brain_0x1a6cc0; // 0x1a6ce0 - g_ps2RecompiledFunctionTable[170807] = bhEne04_Brain_0x1a6cc0; // 0x1a6ce4 - g_ps2RecompiledFunctionTable[170808] = bhEne04_Brain_0x1a6cc0; // 0x1a6ce8 - g_ps2RecompiledFunctionTable[170809] = bhEne04_Brain_0x1a6cc0; // 0x1a6cec - g_ps2RecompiledFunctionTable[170810] = bhEne04_Brain_0x1a6cc0; // 0x1a6cf0 - g_ps2RecompiledFunctionTable[170811] = bhEne04_Brain_0x1a6cc0; // 0x1a6cf4 - g_ps2RecompiledFunctionTable[170812] = bhEne04_Brain_0x1a6cc0; // 0x1a6cf8 - g_ps2RecompiledFunctionTable[170813] = bhEne04_Brain_0x1a6cc0; // 0x1a6cfc - g_ps2RecompiledFunctionTable[170814] = bhEne04_Brain_0x1a6cc0; // 0x1a6d00 - g_ps2RecompiledFunctionTable[170815] = bhEne04_Brain_0x1a6cc0; // 0x1a6d04 - g_ps2RecompiledFunctionTable[170816] = bhEne04_Brain_0x1a6cc0; // 0x1a6d08 - g_ps2RecompiledFunctionTable[170817] = bhEne04_Brain_0x1a6cc0; // 0x1a6d0c - g_ps2RecompiledFunctionTable[170818] = bhEne04_Brain_0x1a6cc0; // 0x1a6d10 - g_ps2RecompiledFunctionTable[170819] = bhEne04_Brain_0x1a6cc0; // 0x1a6d14 - g_ps2RecompiledFunctionTable[170820] = bhEne04_Brain_0x1a6cc0; // 0x1a6d18 - g_ps2RecompiledFunctionTable[170821] = bhEne04_Brain_0x1a6cc0; // 0x1a6d1c - g_ps2RecompiledFunctionTable[170822] = bhEne04_Brain_0x1a6cc0; // 0x1a6d20 - g_ps2RecompiledFunctionTable[170823] = bhEne04_Brain_0x1a6cc0; // 0x1a6d24 - g_ps2RecompiledFunctionTable[170824] = bhEne04_Brain_0x1a6cc0; // 0x1a6d28 - g_ps2RecompiledFunctionTable[170825] = bhEne04_Brain_0x1a6cc0; // 0x1a6d2c - g_ps2RecompiledFunctionTable[170826] = bhEne04_Brain_0x1a6cc0; // 0x1a6d30 - g_ps2RecompiledFunctionTable[170827] = bhEne04_Brain_0x1a6cc0; // 0x1a6d34 - g_ps2RecompiledFunctionTable[170828] = bhEne04_Brain_0x1a6cc0; // 0x1a6d38 - g_ps2RecompiledFunctionTable[170829] = bhEne04_Brain_0x1a6cc0; // 0x1a6d3c - g_ps2RecompiledFunctionTable[170830] = bhEne04_Brain_0x1a6cc0; // 0x1a6d40 - g_ps2RecompiledFunctionTable[170831] = bhEne04_Brain_0x1a6cc0; // 0x1a6d44 - g_ps2RecompiledFunctionTable[170832] = bhEne04_Brain_0x1a6cc0; // 0x1a6d48 - g_ps2RecompiledFunctionTable[170833] = bhEne04_Brain_0x1a6cc0; // 0x1a6d4c - g_ps2RecompiledFunctionTable[170834] = bhEne04_Brain_0x1a6cc0; // 0x1a6d50 - g_ps2RecompiledFunctionTable[170835] = bhEne04_Brain_0x1a6cc0; // 0x1a6d54 - g_ps2RecompiledFunctionTable[170836] = bhEne04_Brain_0x1a6cc0; // 0x1a6d58 - g_ps2RecompiledFunctionTable[170837] = bhEne04_Brain_0x1a6cc0; // 0x1a6d5c - g_ps2RecompiledFunctionTable[170838] = bhEne04_Brain_0x1a6cc0; // 0x1a6d60 - g_ps2RecompiledFunctionTable[170839] = bhEne04_Brain_0x1a6cc0; // 0x1a6d64 - g_ps2RecompiledFunctionTable[170840] = bhEne04_Brain_0x1a6cc0; // 0x1a6d68 - g_ps2RecompiledFunctionTable[170841] = bhEne04_Brain_0x1a6cc0; // 0x1a6d6c - g_ps2RecompiledFunctionTable[170842] = bhEne04_Brain_0x1a6cc0; // 0x1a6d70 - g_ps2RecompiledFunctionTable[170843] = bhEne04_Brain_0x1a6cc0; // 0x1a6d74 - g_ps2RecompiledFunctionTable[170844] = bhEne04_Brain_0x1a6cc0; // 0x1a6d78 - g_ps2RecompiledFunctionTable[170845] = bhEne04_Brain_0x1a6cc0; // 0x1a6d7c - g_ps2RecompiledFunctionTable[170846] = bhEne04_Brain_0x1a6cc0; // 0x1a6d80 - g_ps2RecompiledFunctionTable[170847] = bhEne04_Brain_0x1a6cc0; // 0x1a6d84 - g_ps2RecompiledFunctionTable[170848] = bhEne04_Brain_0x1a6cc0; // 0x1a6d88 - g_ps2RecompiledFunctionTable[170849] = bhEne04_Brain_0x1a6cc0; // 0x1a6d8c - g_ps2RecompiledFunctionTable[170850] = bhEne04_Brain_0x1a6cc0; // 0x1a6d90 - g_ps2RecompiledFunctionTable[170851] = bhEne04_Brain_0x1a6cc0; // 0x1a6d94 - g_ps2RecompiledFunctionTable[170852] = bhEne04_Brain_0x1a6cc0; // 0x1a6d98 - g_ps2RecompiledFunctionTable[170853] = bhEne04_Brain_0x1a6cc0; // 0x1a6d9c - g_ps2RecompiledFunctionTable[170854] = bhEne04_Brain_0x1a6cc0; // 0x1a6da0 - g_ps2RecompiledFunctionTable[170855] = bhEne04_Brain_0x1a6cc0; // 0x1a6da4 - g_ps2RecompiledFunctionTable[170856] = bhEne04_Brain_0x1a6cc0; // 0x1a6da8 - g_ps2RecompiledFunctionTable[170857] = bhEne04_Brain_0x1a6cc0; // 0x1a6dac - g_ps2RecompiledFunctionTable[170858] = bhEne04_Brain_0x1a6cc0; // 0x1a6db0 - g_ps2RecompiledFunctionTable[170859] = bhEne04_Brain_0x1a6cc0; // 0x1a6db4 - g_ps2RecompiledFunctionTable[170860] = bhEne04_Brain_0x1a6cc0; // 0x1a6db8 - g_ps2RecompiledFunctionTable[170861] = bhEne04_Brain_0x1a6cc0; // 0x1a6dbc - g_ps2RecompiledFunctionTable[170862] = bhEne04_Brain_0x1a6cc0; // 0x1a6dc0 - g_ps2RecompiledFunctionTable[170863] = bhEne04_Brain_0x1a6cc0; // 0x1a6dc4 - g_ps2RecompiledFunctionTable[170864] = bhEne04_Brain_0x1a6cc0; // 0x1a6dc8 - g_ps2RecompiledFunctionTable[170865] = bhEne04_Brain_0x1a6cc0; // 0x1a6dcc - g_ps2RecompiledFunctionTable[170866] = bhEne04_Brain_0x1a6cc0; // 0x1a6dd0 - g_ps2RecompiledFunctionTable[170867] = bhEne04_Brain_0x1a6cc0; // 0x1a6dd4 - g_ps2RecompiledFunctionTable[170868] = bhEne04_Brain_0x1a6cc0; // 0x1a6dd8 - g_ps2RecompiledFunctionTable[170869] = bhEne04_Brain_0x1a6cc0; // 0x1a6ddc - g_ps2RecompiledFunctionTable[170870] = bhEne04_Brain_0x1a6cc0; // 0x1a6de0 - g_ps2RecompiledFunctionTable[170871] = bhEne04_Brain_0x1a6cc0; // 0x1a6de4 - g_ps2RecompiledFunctionTable[170872] = bhEne04_Brain_0x1a6cc0; // 0x1a6de8 - g_ps2RecompiledFunctionTable[170874] = bhEne04_Brain00_0x1a6df0; // 0x1a6df0 - g_ps2RecompiledFunctionTable[170883] = bhEne04_Brain00_0x1a6df0; // 0x1a6e14 - g_ps2RecompiledFunctionTable[170926] = bhEne04_Brain01_0x1a6ec0; // 0x1a6ec0 - g_ps2RecompiledFunctionTable[170935] = bhEne04_Brain01_0x1a6ec0; // 0x1a6ee4 - g_ps2RecompiledFunctionTable[170982] = bhEne04_Brain02_0x1a6fa0; // 0x1a6fa0 - g_ps2RecompiledFunctionTable[171017] = bhEne04_Brain02_0x1a6fa0; // 0x1a702c - g_ps2RecompiledFunctionTable[171024] = bhEne04_Brain02_0x1a6fa0; // 0x1a7048 - g_ps2RecompiledFunctionTable[171052] = bhEne04_Brain02_0x1a6fa0; // 0x1a70b8 - g_ps2RecompiledFunctionTable[171062] = bhEne04_Brain02_0x1a6fa0; // 0x1a70e0 - g_ps2RecompiledFunctionTable[171069] = bhEne04_Brain02_0x1a6fa0; // 0x1a70fc - g_ps2RecompiledFunctionTable[171120] = bhEne04_Brain02_0x1a6fa0; // 0x1a71c8 - g_ps2RecompiledFunctionTable[171134] = bhEne04_Brain02_0x1a6fa0; // 0x1a7200 - g_ps2RecompiledFunctionTable[171176] = bhEne04_Brain02_0x1a6fa0; // 0x1a72a8 - g_ps2RecompiledFunctionTable[171185] = bhEne04_Brain02_0x1a6fa0; // 0x1a72cc - g_ps2RecompiledFunctionTable[171210] = bhEne04_Brain04_0x1a7330; // 0x1a7330 - g_ps2RecompiledFunctionTable[171259] = bhEne04_Brain04_0x1a7330; // 0x1a73f4 - g_ps2RecompiledFunctionTable[171278] = bhEne04_Brain04_0x1a7330; // 0x1a7440 - g_ps2RecompiledFunctionTable[171294] = bhEne04_Brain04_0x1a7330; // 0x1a7480 - g_ps2RecompiledFunctionTable[171310] = bhEne04_Brain06_0x1a74c0; // 0x1a74c0 - g_ps2RecompiledFunctionTable[171343] = bhEne04_Brain06_0x1a74c0; // 0x1a7544 - g_ps2RecompiledFunctionTable[171383] = bhEne04_Brain06_0x1a74c0; // 0x1a75e4 - g_ps2RecompiledFunctionTable[171434] = bhEne04_MV00_0x1a76b0; // 0x1a76b0 - g_ps2RecompiledFunctionTable[171455] = bhEne04_MV00_0x1a76b0; // 0x1a7704 - g_ps2RecompiledFunctionTable[171461] = bhEne04_MV00_0x1a76b0; // 0x1a771c - g_ps2RecompiledFunctionTable[171463] = bhEne04_MV00_0x1a76b0; // 0x1a7724 - g_ps2RecompiledFunctionTable[171502] = bhEne04_MV00_0x1a76b0; // 0x1a77c0 - g_ps2RecompiledFunctionTable[171562] = bhEne04_MV01_0x1a78b0; // 0x1a78b0 - g_ps2RecompiledFunctionTable[171598] = bhEne04_MV01_0x1a78b0; // 0x1a7940 - g_ps2RecompiledFunctionTable[171601] = bhEne04_MV01_0x1a78b0; // 0x1a794c - g_ps2RecompiledFunctionTable[171642] = bhEne04_MV01_0x1a78b0; // 0x1a79f0 - g_ps2RecompiledFunctionTable[171645] = bhEne04_MV01_0x1a78b0; // 0x1a79fc - g_ps2RecompiledFunctionTable[171657] = bhEne04_MV01_0x1a78b0; // 0x1a7a2c - g_ps2RecompiledFunctionTable[171661] = bhEne04_MV01_0x1a78b0; // 0x1a7a3c - g_ps2RecompiledFunctionTable[171692] = bhEne04_MV01_0x1a78b0; // 0x1a7ab8 - g_ps2RecompiledFunctionTable[171705] = bhEne04_MV01_0x1a78b0; // 0x1a7aec - g_ps2RecompiledFunctionTable[171727] = bhEne04_MV01_0x1a78b0; // 0x1a7b44 - g_ps2RecompiledFunctionTable[171734] = bhEne04_MV02_0x1a7b60; // 0x1a7b60 - g_ps2RecompiledFunctionTable[171758] = bhEne04_MV02_0x1a7b60; // 0x1a7bc0 - g_ps2RecompiledFunctionTable[171765] = bhEne04_MV02_0x1a7b60; // 0x1a7bdc - g_ps2RecompiledFunctionTable[171779] = bhEne04_MV02_0x1a7b60; // 0x1a7c14 - g_ps2RecompiledFunctionTable[171828] = bhEne04_MV02_0x1a7b60; // 0x1a7cd8 - g_ps2RecompiledFunctionTable[171850] = bhEne04_MV02_0x1a7b60; // 0x1a7d30 - g_ps2RecompiledFunctionTable[171860] = bhEne04_MV02_0x1a7b60; // 0x1a7d58 - g_ps2RecompiledFunctionTable[171866] = bhEne04_MV02_0x1a7b60; // 0x1a7d70 - g_ps2RecompiledFunctionTable[171876] = bhEne04_MV02_0x1a7b60; // 0x1a7d98 - g_ps2RecompiledFunctionTable[171928] = bhEne04_MV02_0x1a7b60; // 0x1a7e68 - g_ps2RecompiledFunctionTable[171967] = bhEne04_MV02_0x1a7b60; // 0x1a7f04 - g_ps2RecompiledFunctionTable[171979] = bhEne04_MV02_0x1a7b60; // 0x1a7f34 - g_ps2RecompiledFunctionTable[171983] = bhEne04_MV02_0x1a7b60; // 0x1a7f44 - g_ps2RecompiledFunctionTable[171994] = bhEne04_MV02_0x1a7b60; // 0x1a7f70 - g_ps2RecompiledFunctionTable[172015] = bhEne04_MV02_0x1a7b60; // 0x1a7fc4 - g_ps2RecompiledFunctionTable[172046] = bhEne04_MV02_0x1a7b60; // 0x1a8040 - g_ps2RecompiledFunctionTable[172049] = bhEne04_MV02_0x1a7b60; // 0x1a804c - g_ps2RecompiledFunctionTable[172053] = bhEne04_MV02_0x1a7b60; // 0x1a805c - g_ps2RecompiledFunctionTable[172061] = bhEne04_MV02_0x1a7b60; // 0x1a807c - g_ps2RecompiledFunctionTable[172074] = bhEne04_MV02_0x1a7b60; // 0x1a80b0 - g_ps2RecompiledFunctionTable[172085] = bhEne04_MV02_0x1a7b60; // 0x1a80dc - g_ps2RecompiledFunctionTable[172106] = bhEne04_MV02_0x1a7b60; // 0x1a8130 - g_ps2RecompiledFunctionTable[172121] = bhEne04_MV02_0x1a7b60; // 0x1a816c - g_ps2RecompiledFunctionTable[172137] = bhEne04_MV02_0x1a7b60; // 0x1a81ac - g_ps2RecompiledFunctionTable[172156] = bhEne04_MV02_0x1a7b60; // 0x1a81f8 - g_ps2RecompiledFunctionTable[172162] = bhEne04_MV03_0x1a8210; // 0x1a8210 - g_ps2RecompiledFunctionTable[172183] = bhEne04_MV03_0x1a8210; // 0x1a8264 - g_ps2RecompiledFunctionTable[172190] = bhEne04_MV03_0x1a8210; // 0x1a8280 - g_ps2RecompiledFunctionTable[172194] = bhEne04_MV03_0x1a8210; // 0x1a8290 - g_ps2RecompiledFunctionTable[172221] = bhEne04_MV03_0x1a8210; // 0x1a82fc - g_ps2RecompiledFunctionTable[172245] = bhEne04_MV03_0x1a8210; // 0x1a835c - g_ps2RecompiledFunctionTable[172280] = bhEne04_MV03_0x1a8210; // 0x1a83e8 - g_ps2RecompiledFunctionTable[172285] = bhEne04_MV03_0x1a8210; // 0x1a83fc - g_ps2RecompiledFunctionTable[172299] = bhEne04_MV03_0x1a8210; // 0x1a8434 - g_ps2RecompiledFunctionTable[172306] = bhEne04_MV04_0x1a8450; // 0x1a8450 - g_ps2RecompiledFunctionTable[172324] = bhEne04_MV04_0x1a8450; // 0x1a8498 - g_ps2RecompiledFunctionTable[172341] = bhEne04_MV04_0x1a8450; // 0x1a84dc - g_ps2RecompiledFunctionTable[172354] = bhEne04_MV04_0x1a8450; // 0x1a8510 - g_ps2RecompiledFunctionTable[172373] = bhEne04_MV04_0x1a8450; // 0x1a855c - g_ps2RecompiledFunctionTable[172398] = bhEne04_MV05_0x1a85c0; // 0x1a85c0 - g_ps2RecompiledFunctionTable[172428] = bhEne04_MV05_0x1a85c0; // 0x1a8638 - g_ps2RecompiledFunctionTable[172440] = bhEne04_MV05_0x1a85c0; // 0x1a8668 - g_ps2RecompiledFunctionTable[172457] = bhEne04_MV05_0x1a85c0; // 0x1a86ac - g_ps2RecompiledFunctionTable[172514] = bhEne04_MV06_0x1a8790; // 0x1a8790 - g_ps2RecompiledFunctionTable[172539] = bhEne04_MV06_0x1a8790; // 0x1a87f4 - g_ps2RecompiledFunctionTable[172541] = bhEne04_MV06_0x1a8790; // 0x1a87fc - g_ps2RecompiledFunctionTable[172553] = bhEne04_MV06_0x1a8790; // 0x1a882c - g_ps2RecompiledFunctionTable[172585] = bhEne04_MV06_0x1a8790; // 0x1a88ac - g_ps2RecompiledFunctionTable[172595] = bhEne04_MV06_0x1a8790; // 0x1a88d4 - g_ps2RecompiledFunctionTable[172609] = bhEne04_MV06_0x1a8790; // 0x1a890c - g_ps2RecompiledFunctionTable[172619] = bhEne04_MV06_0x1a8790; // 0x1a8934 - g_ps2RecompiledFunctionTable[172630] = bhEne04_MV06_0x1a8790; // 0x1a8960 - g_ps2RecompiledFunctionTable[172636] = bhEne04_MV06_0x1a8790; // 0x1a8978 - g_ps2RecompiledFunctionTable[172646] = bhEne04_MV06_0x1a8790; // 0x1a89a0 - g_ps2RecompiledFunctionTable[172650] = bhEne04_MV06_0x1a8790; // 0x1a89b0 - g_ps2RecompiledFunctionTable[172667] = bhEne04_MV06_0x1a8790; // 0x1a89f4 - g_ps2RecompiledFunctionTable[172672] = bhEne04_MV06_0x1a8790; // 0x1a8a08 - g_ps2RecompiledFunctionTable[172686] = bhEne04_MV07_0x1a8a40; // 0x1a8a40 - g_ps2RecompiledFunctionTable[172707] = bhEne04_MV07_0x1a8a40; // 0x1a8a94 - g_ps2RecompiledFunctionTable[172718] = bhEne04_MV07_0x1a8a40; // 0x1a8ac0 - g_ps2RecompiledFunctionTable[172742] = bhEne04_MV07_0x1a8a40; // 0x1a8b20 - g_ps2RecompiledFunctionTable[172770] = bhEne04_MV07_0x1a8a40; // 0x1a8b90 - g_ps2RecompiledFunctionTable[172808] = bhEne04_MV07_0x1a8a40; // 0x1a8c28 - g_ps2RecompiledFunctionTable[172821] = bhEne04_MV07_0x1a8a40; // 0x1a8c5c - g_ps2RecompiledFunctionTable[172828] = bhEne04_MV07_0x1a8a40; // 0x1a8c78 - g_ps2RecompiledFunctionTable[172849] = bhEne04_MV07_0x1a8a40; // 0x1a8ccc - g_ps2RecompiledFunctionTable[172855] = bhEne04_MV07_0x1a8a40; // 0x1a8ce4 - g_ps2RecompiledFunctionTable[172882] = bhEne04_MV07_0x1a8a40; // 0x1a8d50 - g_ps2RecompiledFunctionTable[172890] = bhEne04_MV07_0x1a8a40; // 0x1a8d70 - g_ps2RecompiledFunctionTable[172901] = bhEne04_MV07_0x1a8a40; // 0x1a8d9c - g_ps2RecompiledFunctionTable[172941] = bhEne04_MV07_0x1a8a40; // 0x1a8e3c - g_ps2RecompiledFunctionTable[172954] = bhEne04_MV07_0x1a8a40; // 0x1a8e70 - g_ps2RecompiledFunctionTable[172962] = bhEne04_MV07_0x1a8a40; // 0x1a8e90 - g_ps2RecompiledFunctionTable[172966] = bhEne04_MV07_0x1a8a40; // 0x1a8ea0 - g_ps2RecompiledFunctionTable[172971] = bhEne04_MV07_0x1a8a40; // 0x1a8eb4 - g_ps2RecompiledFunctionTable[172976] = bhEne04_MV07_0x1a8a40; // 0x1a8ec8 - g_ps2RecompiledFunctionTable[172995] = bhEne04_MV07_0x1a8a40; // 0x1a8f14 - g_ps2RecompiledFunctionTable[173008] = bhEne04_MV07_0x1a8a40; // 0x1a8f48 - g_ps2RecompiledFunctionTable[173014] = bhEne04_MV07_0x1a8a40; // 0x1a8f60 - g_ps2RecompiledFunctionTable[173066] = bhEne04_MV07_0x1a8a40; // 0x1a9030 - g_ps2RecompiledFunctionTable[173074] = bhEne04_MV07_0x1a8a40; // 0x1a9050 - g_ps2RecompiledFunctionTable[173110] = bhEne04_MV07_0x1a8a40; // 0x1a90e0 - g_ps2RecompiledFunctionTable[173114] = bhEne04_MV07_0x1a8a40; // 0x1a90f0 - g_ps2RecompiledFunctionTable[173116] = bhEne04_MV07_0x1a8a40; // 0x1a90f8 - g_ps2RecompiledFunctionTable[173120] = bhEne04_MV07_0x1a8a40; // 0x1a9108 - g_ps2RecompiledFunctionTable[173139] = bhEne04_MV07_0x1a8a40; // 0x1a9154 - g_ps2RecompiledFunctionTable[173147] = bhEne04_MV07_0x1a8a40; // 0x1a9174 - g_ps2RecompiledFunctionTable[173201] = bhEne04_MV07_0x1a8a40; // 0x1a924c - g_ps2RecompiledFunctionTable[173218] = bhEne04_MV08_0x1a9290; // 0x1a9290 - g_ps2RecompiledFunctionTable[173262] = bhEne04_MV08_0x1a9290; // 0x1a9340 - g_ps2RecompiledFunctionTable[173271] = bhEne04_MV08_0x1a9290; // 0x1a9364 - g_ps2RecompiledFunctionTable[173278] = bhEne04_MV08_0x1a9290; // 0x1a9380 - g_ps2RecompiledFunctionTable[173280] = bhEne04_MV08_0x1a9290; // 0x1a9388 - g_ps2RecompiledFunctionTable[173284] = bhEne04_MV08_0x1a9290; // 0x1a9398 - g_ps2RecompiledFunctionTable[173340] = bhEne04_MV08_0x1a9290; // 0x1a9478 - g_ps2RecompiledFunctionTable[173356] = bhEne04_MV08_0x1a9290; // 0x1a94b8 - g_ps2RecompiledFunctionTable[173406] = bhEne04_MV08_0x1a9290; // 0x1a9580 - g_ps2RecompiledFunctionTable[173415] = bhEne04_MV08_0x1a9290; // 0x1a95a4 - g_ps2RecompiledFunctionTable[173424] = bhEne04_MV08_0x1a9290; // 0x1a95c8 - g_ps2RecompiledFunctionTable[173461] = bhEne04_MV08_0x1a9290; // 0x1a965c - g_ps2RecompiledFunctionTable[173503] = bhEne04_MV08_0x1a9290; // 0x1a9704 - g_ps2RecompiledFunctionTable[173511] = bhEne04_MV08_0x1a9290; // 0x1a9724 - g_ps2RecompiledFunctionTable[173513] = bhEne04_MV08_0x1a9290; // 0x1a972c - g_ps2RecompiledFunctionTable[173575] = bhEne04_MV08_0x1a9290; // 0x1a9824 - g_ps2RecompiledFunctionTable[173603] = bhEne04_MV08_0x1a9290; // 0x1a9894 - g_ps2RecompiledFunctionTable[173606] = bhEne04_MV08_0x1a9290; // 0x1a98a0 - g_ps2RecompiledFunctionTable[173609] = bhEne04_MV08_0x1a9290; // 0x1a98ac - g_ps2RecompiledFunctionTable[173613] = bhEne04_MV08_0x1a9290; // 0x1a98bc - g_ps2RecompiledFunctionTable[173624] = bhEne04_MV08_0x1a9290; // 0x1a98e8 - g_ps2RecompiledFunctionTable[173645] = bhEne04_MV08_0x1a9290; // 0x1a993c - g_ps2RecompiledFunctionTable[173664] = bhEne04_MV08_0x1a9290; // 0x1a9988 - g_ps2RecompiledFunctionTable[173670] = bhEne04_MV09_0x1a99a0; // 0x1a99a0 - g_ps2RecompiledFunctionTable[173685] = bhEne04_MV09_0x1a99a0; // 0x1a99dc - g_ps2RecompiledFunctionTable[173711] = bhEne04_MV09_0x1a99a0; // 0x1a9a44 - g_ps2RecompiledFunctionTable[173734] = bhEne04_MV09_0x1a99a0; // 0x1a9aa0 - g_ps2RecompiledFunctionTable[173745] = bhEne04_MV09_0x1a99a0; // 0x1a9acc - g_ps2RecompiledFunctionTable[173786] = bhEne04_MV10_0x1a9b70; // 0x1a9b70 - g_ps2RecompiledFunctionTable[173801] = bhEne04_MV10_0x1a9b70; // 0x1a9bac - g_ps2RecompiledFunctionTable[173819] = bhEne04_MV10_0x1a9b70; // 0x1a9bf4 - g_ps2RecompiledFunctionTable[173822] = bhEne04_MV10_0x1a9b70; // 0x1a9c00 - g_ps2RecompiledFunctionTable[173832] = bhEne04_MV10_0x1a9b70; // 0x1a9c28 - g_ps2RecompiledFunctionTable[173843] = bhEne04_MV10_0x1a9b70; // 0x1a9c54 - g_ps2RecompiledFunctionTable[173882] = bhEne04_MV11_0x1a9cf0; // 0x1a9cf0 - g_ps2RecompiledFunctionTable[174001] = bhEne04_MV11_0x1a9cf0; // 0x1a9ecc - g_ps2RecompiledFunctionTable[174060] = bhEne04_MV11_0x1a9cf0; // 0x1a9fb8 - g_ps2RecompiledFunctionTable[174077] = bhEne04_MV11_0x1a9cf0; // 0x1a9ffc - g_ps2RecompiledFunctionTable[174082] = bhEne04_MV11_0x1a9cf0; // 0x1aa010 - g_ps2RecompiledFunctionTable[174114] = bhEne04_MV12_0x1aa090; // 0x1aa090 - g_ps2RecompiledFunctionTable[174136] = bhEne04_MV12_0x1aa090; // 0x1aa0e8 - g_ps2RecompiledFunctionTable[174150] = bhEne04_MV12_0x1aa090; // 0x1aa120 - g_ps2RecompiledFunctionTable[174154] = bhEne04_MV12_0x1aa090; // 0x1aa130 - g_ps2RecompiledFunctionTable[174170] = bhEne04_MV12_0x1aa090; // 0x1aa170 - g_ps2RecompiledFunctionTable[174186] = bhEne04_MV12_0x1aa090; // 0x1aa1b0 - g_ps2RecompiledFunctionTable[174205] = bhEne04_MV12_0x1aa090; // 0x1aa1fc - g_ps2RecompiledFunctionTable[174214] = bhEne04_Escape_0x1aa220; // 0x1aa220 - g_ps2RecompiledFunctionTable[174245] = bhEne04_Escape_0x1aa220; // 0x1aa29c - g_ps2RecompiledFunctionTable[174293] = bhEne04_Escape_0x1aa220; // 0x1aa35c - g_ps2RecompiledFunctionTable[174321] = bhEne04_Escape_0x1aa220; // 0x1aa3cc - g_ps2RecompiledFunctionTable[174374] = bhEne04_Escape_0x1aa220; // 0x1aa4a0 - g_ps2RecompiledFunctionTable[174379] = bhEne04_Escape_0x1aa220; // 0x1aa4b4 - g_ps2RecompiledFunctionTable[174418] = bhEne04_NGType00_0x1aa550; // 0x1aa550 - g_ps2RecompiledFunctionTable[174419] = bhEne04_NGType00_0x1aa550; // 0x1aa554 - g_ps2RecompiledFunctionTable[174420] = bhEne04_NGType00_0x1aa550; // 0x1aa558 - g_ps2RecompiledFunctionTable[174421] = bhEne04_NGType00_0x1aa550; // 0x1aa55c - g_ps2RecompiledFunctionTable[174422] = bhEne04_NGType00_0x1aa550; // 0x1aa560 - g_ps2RecompiledFunctionTable[174423] = bhEne04_NGType00_0x1aa550; // 0x1aa564 - g_ps2RecompiledFunctionTable[174424] = bhEne04_NGType00_0x1aa550; // 0x1aa568 - g_ps2RecompiledFunctionTable[174425] = bhEne04_NGType00_0x1aa550; // 0x1aa56c - g_ps2RecompiledFunctionTable[174426] = bhEne04_NGType00_0x1aa550; // 0x1aa570 - g_ps2RecompiledFunctionTable[174427] = bhEne04_NGType00_0x1aa550; // 0x1aa574 - g_ps2RecompiledFunctionTable[174428] = bhEne04_NGType00_0x1aa550; // 0x1aa578 - g_ps2RecompiledFunctionTable[174429] = bhEne04_NGType00_0x1aa550; // 0x1aa57c - g_ps2RecompiledFunctionTable[174430] = bhEne04_NGType00_0x1aa550; // 0x1aa580 - g_ps2RecompiledFunctionTable[174431] = bhEne04_NGType00_0x1aa550; // 0x1aa584 - g_ps2RecompiledFunctionTable[174432] = bhEne04_NGType00_0x1aa550; // 0x1aa588 - g_ps2RecompiledFunctionTable[174433] = bhEne04_NGType00_0x1aa550; // 0x1aa58c - g_ps2RecompiledFunctionTable[174434] = bhEne04_NGType00_0x1aa550; // 0x1aa590 - g_ps2RecompiledFunctionTable[174435] = bhEne04_NGType00_0x1aa550; // 0x1aa594 - g_ps2RecompiledFunctionTable[174436] = bhEne04_NGType00_0x1aa550; // 0x1aa598 - g_ps2RecompiledFunctionTable[174437] = bhEne04_NGType00_0x1aa550; // 0x1aa59c - g_ps2RecompiledFunctionTable[174438] = bhEne04_NGType00_0x1aa550; // 0x1aa5a0 - g_ps2RecompiledFunctionTable[174439] = bhEne04_NGType00_0x1aa550; // 0x1aa5a4 - g_ps2RecompiledFunctionTable[174440] = bhEne04_NGType00_0x1aa550; // 0x1aa5a8 - g_ps2RecompiledFunctionTable[174441] = bhEne04_NGType00_0x1aa550; // 0x1aa5ac - g_ps2RecompiledFunctionTable[174442] = bhEne04_NGType00_0x1aa550; // 0x1aa5b0 - g_ps2RecompiledFunctionTable[174443] = bhEne04_NGType00_0x1aa550; // 0x1aa5b4 - g_ps2RecompiledFunctionTable[174444] = bhEne04_NGType00_0x1aa550; // 0x1aa5b8 - g_ps2RecompiledFunctionTable[174445] = bhEne04_NGType00_0x1aa550; // 0x1aa5bc - g_ps2RecompiledFunctionTable[174446] = bhEne04_NGType00_0x1aa550; // 0x1aa5c0 - g_ps2RecompiledFunctionTable[174447] = bhEne04_NGType00_0x1aa550; // 0x1aa5c4 - g_ps2RecompiledFunctionTable[174448] = bhEne04_NGType00_0x1aa550; // 0x1aa5c8 - g_ps2RecompiledFunctionTable[174449] = bhEne04_NGType00_0x1aa550; // 0x1aa5cc - g_ps2RecompiledFunctionTable[174450] = bhEne04_NGType00_0x1aa550; // 0x1aa5d0 - g_ps2RecompiledFunctionTable[174451] = bhEne04_NGType00_0x1aa550; // 0x1aa5d4 - g_ps2RecompiledFunctionTable[174452] = bhEne04_NGType00_0x1aa550; // 0x1aa5d8 - g_ps2RecompiledFunctionTable[174454] = bhEne04_NG00_0x1aa5e0; // 0x1aa5e0 - g_ps2RecompiledFunctionTable[174478] = bhEne04_NG00_0x1aa5e0; // 0x1aa640 - g_ps2RecompiledFunctionTable[174485] = bhEne04_NG00_0x1aa5e0; // 0x1aa65c - g_ps2RecompiledFunctionTable[174535] = bhEne04_NG00_0x1aa5e0; // 0x1aa724 - g_ps2RecompiledFunctionTable[174544] = bhEne04_NG00_0x1aa5e0; // 0x1aa748 - g_ps2RecompiledFunctionTable[174548] = bhEne04_NG00_0x1aa5e0; // 0x1aa758 - g_ps2RecompiledFunctionTable[174558] = bhEne04_NG00_0x1aa5e0; // 0x1aa780 - g_ps2RecompiledFunctionTable[174581] = bhEne04_NG00_0x1aa5e0; // 0x1aa7dc - g_ps2RecompiledFunctionTable[174598] = bhEne04_NG00_0x1aa5e0; // 0x1aa820 - g_ps2RecompiledFunctionTable[174617] = bhEne04_NG00_0x1aa5e0; // 0x1aa86c - g_ps2RecompiledFunctionTable[174622] = bhEne04_NG00_0x1aa5e0; // 0x1aa880 - g_ps2RecompiledFunctionTable[174627] = bhEne04_NG00_0x1aa5e0; // 0x1aa894 - g_ps2RecompiledFunctionTable[174638] = bhEne04_NG00_0x1aa5e0; // 0x1aa8c0 - g_ps2RecompiledFunctionTable[174655] = bhEne04_NG00_0x1aa5e0; // 0x1aa904 - g_ps2RecompiledFunctionTable[174690] = bhEne04_NG01_0x1aa990; // 0x1aa990 - g_ps2RecompiledFunctionTable[174715] = bhEne04_NG01_0x1aa990; // 0x1aa9f4 - g_ps2RecompiledFunctionTable[174722] = bhEne04_NG01_0x1aa990; // 0x1aaa10 - g_ps2RecompiledFunctionTable[174779] = bhEne04_NG01_0x1aa990; // 0x1aaaf4 - g_ps2RecompiledFunctionTable[174798] = bhEne04_DGType00_0x1aab40; // 0x1aab40 - g_ps2RecompiledFunctionTable[174799] = bhEne04_DGType00_0x1aab40; // 0x1aab44 - g_ps2RecompiledFunctionTable[174800] = bhEne04_DGType00_0x1aab40; // 0x1aab48 - g_ps2RecompiledFunctionTable[174801] = bhEne04_DGType00_0x1aab40; // 0x1aab4c - g_ps2RecompiledFunctionTable[174802] = bhEne04_DGType00_0x1aab40; // 0x1aab50 - g_ps2RecompiledFunctionTable[174803] = bhEne04_DGType00_0x1aab40; // 0x1aab54 - g_ps2RecompiledFunctionTable[174804] = bhEne04_DGType00_0x1aab40; // 0x1aab58 - g_ps2RecompiledFunctionTable[174805] = bhEne04_DGType00_0x1aab40; // 0x1aab5c - g_ps2RecompiledFunctionTable[174806] = bhEne04_DG00_0x1aab60; // 0x1aab60 - g_ps2RecompiledFunctionTable[174823] = bhEne04_DG00_0x1aab60; // 0x1aaba4 - g_ps2RecompiledFunctionTable[174852] = bhEne04_DG00_0x1aab60; // 0x1aac18 - g_ps2RecompiledFunctionTable[174875] = bhEne04_DG00_0x1aab60; // 0x1aac74 - g_ps2RecompiledFunctionTable[174897] = bhEne04_DG00_0x1aab60; // 0x1aaccc - g_ps2RecompiledFunctionTable[174913] = bhEne04_DG00_0x1aab60; // 0x1aad0c - g_ps2RecompiledFunctionTable[174916] = bhEne04_DG00_0x1aab60; // 0x1aad18 - g_ps2RecompiledFunctionTable[174942] = bhEne04_DG00_0x1aab60; // 0x1aad80 - g_ps2RecompiledFunctionTable[174949] = bhEne04_DG00_0x1aab60; // 0x1aad9c - g_ps2RecompiledFunctionTable[174980] = bhEne04_DG00_0x1aab60; // 0x1aae18 - g_ps2RecompiledFunctionTable[175007] = bhEne04_DG00_0x1aab60; // 0x1aae84 - g_ps2RecompiledFunctionTable[175058] = bhEne04_DG01_0x1aaf50; // 0x1aaf50 - g_ps2RecompiledFunctionTable[175075] = bhEne04_DG01_0x1aaf50; // 0x1aaf94 - g_ps2RecompiledFunctionTable[175123] = bhEne04_DG01_0x1aaf50; // 0x1ab054 - g_ps2RecompiledFunctionTable[175133] = bhEne04_DG01_0x1aaf50; // 0x1ab07c - g_ps2RecompiledFunctionTable[175139] = bhEne04_DG01_0x1aaf50; // 0x1ab094 - g_ps2RecompiledFunctionTable[175141] = bhEne04_DG01_0x1aaf50; // 0x1ab09c - g_ps2RecompiledFunctionTable[175147] = bhEne04_DG01_0x1aaf50; // 0x1ab0b4 - g_ps2RecompiledFunctionTable[175152] = bhEne04_DG01_0x1aaf50; // 0x1ab0c8 - g_ps2RecompiledFunctionTable[175163] = bhEne04_DG01_0x1aaf50; // 0x1ab0f4 - g_ps2RecompiledFunctionTable[175172] = bhEne04_DG01_0x1aaf50; // 0x1ab118 - g_ps2RecompiledFunctionTable[175193] = bhEne04_DG01_0x1aaf50; // 0x1ab16c - g_ps2RecompiledFunctionTable[175196] = bhEne04_DG01_0x1aaf50; // 0x1ab178 - g_ps2RecompiledFunctionTable[175222] = bhEne04_DG01_0x1aaf50; // 0x1ab1e0 - g_ps2RecompiledFunctionTable[175235] = bhEne04_DG01_0x1aaf50; // 0x1ab214 - g_ps2RecompiledFunctionTable[175240] = bhEne04_DG01_0x1aaf50; // 0x1ab228 - g_ps2RecompiledFunctionTable[175284] = bhEne04_DG01_0x1aaf50; // 0x1ab2d8 - g_ps2RecompiledFunctionTable[175338] = bhEne04_DDType00_0x1ab3b0; // 0x1ab3b0 - g_ps2RecompiledFunctionTable[175339] = bhEne04_DDType00_0x1ab3b0; // 0x1ab3b4 - g_ps2RecompiledFunctionTable[175340] = bhEne04_DDType00_0x1ab3b0; // 0x1ab3b8 - g_ps2RecompiledFunctionTable[175341] = bhEne04_DDType00_0x1ab3b0; // 0x1ab3bc - g_ps2RecompiledFunctionTable[175342] = bhEne04_DDType00_0x1ab3b0; // 0x1ab3c0 - g_ps2RecompiledFunctionTable[175343] = bhEne04_DDType00_0x1ab3b0; // 0x1ab3c4 - g_ps2RecompiledFunctionTable[175344] = bhEne04_DDType00_0x1ab3b0; // 0x1ab3c8 - g_ps2RecompiledFunctionTable[175345] = bhEne04_DDType00_0x1ab3b0; // 0x1ab3cc - g_ps2RecompiledFunctionTable[175346] = bhEne04_DD00_0x1ab3d0; // 0x1ab3d0 - g_ps2RecompiledFunctionTable[175370] = bhEne04_DD00_0x1ab3d0; // 0x1ab430 - g_ps2RecompiledFunctionTable[175378] = bhEne04_PlyDG00_0x1ab450; // 0x1ab450 - g_ps2RecompiledFunctionTable[175464] = bhEne04_PlyDG00_0x1ab450; // 0x1ab5a8 - g_ps2RecompiledFunctionTable[175578] = bhEne04_PlyDG01_0x1ab770; // 0x1ab770 - g_ps2RecompiledFunctionTable[175688] = bhEne04_PlyDG01_0x1ab770; // 0x1ab928 - g_ps2RecompiledFunctionTable[175703] = bhEne04_PlyDG01_0x1ab770; // 0x1ab964 - g_ps2RecompiledFunctionTable[175718] = bhEne04_PlyDG01_0x1ab770; // 0x1ab9a0 - g_ps2RecompiledFunctionTable[175746] = bhEne04_PlyDamageCheck_0x1aba10; // 0x1aba10 - g_ps2RecompiledFunctionTable[175778] = bhEne04_PlyDamageCheck_0x1aba10; // 0x1aba90 - g_ps2RecompiledFunctionTable[175786] = bhEne04_PlyDamageCheck_0x1aba10; // 0x1abab0 - g_ps2RecompiledFunctionTable[175795] = bhEne04_PlyDamageCheck_0x1aba10; // 0x1abad4 - g_ps2RecompiledFunctionTable[175820] = bhEne04_PlyDamageCheck_0x1aba10; // 0x1abb38 - g_ps2RecompiledFunctionTable[175843] = bhEne04_PlyDamageCheck_0x1aba10; // 0x1abb94 - g_ps2RecompiledFunctionTable[175845] = bhEne04_PlyDamageCheck_0x1aba10; // 0x1abb9c - g_ps2RecompiledFunctionTable[175878] = bhEne04_SpeedUp_0x1abc20; // 0x1abc20 - g_ps2RecompiledFunctionTable[175894] = bhEne04_SpeedDown_0x1abc60; // 0x1abc60 - g_ps2RecompiledFunctionTable[175910] = bhEne04_RunMotion_0x1abca0; // 0x1abca0 - g_ps2RecompiledFunctionTable[175974] = bhEne04_ChgMtn_0x1abda0; // 0x1abda0 - g_ps2RecompiledFunctionTable[176002] = bhEne04_SetMtn_0x1abe10; // 0x1abe10 - g_ps2RecompiledFunctionTable[176014] = bhEne04_SetMtn_0x1abe10; // 0x1abe40 - g_ps2RecompiledFunctionTable[176029] = bhEne04_SetMtn_0x1abe10; // 0x1abe7c - g_ps2RecompiledFunctionTable[176090] = bhEne04_SetMtn_0x1abe10; // 0x1abf70 - g_ps2RecompiledFunctionTable[176099] = bhEne04_SetMtn_0x1abe10; // 0x1abf94 - g_ps2RecompiledFunctionTable[176228] = bhEne04_SetMtn_0x1abe10; // 0x1ac198 - g_ps2RecompiledFunctionTable[176238] = bhEne04_CheckMtnTbl_0x1ac1c0; // 0x1ac1c0 - g_ps2RecompiledFunctionTable[176261] = bhEne04_CheckMtnTbl_0x1ac1c0; // 0x1ac21c - g_ps2RecompiledFunctionTable[176266] = bhEne04_CheckMtnTbl_0x1ac1c0; // 0x1ac230 - g_ps2RecompiledFunctionTable[176275] = bhEne04_CheckMtnTbl_0x1ac1c0; // 0x1ac254 - g_ps2RecompiledFunctionTable[176292] = bhEne04_CheckMtnTbl_0x1ac1c0; // 0x1ac298 - g_ps2RecompiledFunctionTable[176298] = bhEne04_CheckMtnTbl_0x1ac1c0; // 0x1ac2b0 - g_ps2RecompiledFunctionTable[176306] = bhEne04_CheckMtnTbl_0x1ac1c0; // 0x1ac2d0 - g_ps2RecompiledFunctionTable[176326] = bhEne04_KaidanCheck_0x1ac320; // 0x1ac320 - g_ps2RecompiledFunctionTable[176349] = bhEne04_KaidanCheck_0x1ac320; // 0x1ac37c - g_ps2RecompiledFunctionTable[176380] = bhEne04_KaidanCheck_0x1ac320; // 0x1ac3f8 - g_ps2RecompiledFunctionTable[176404] = bhEne04_KaidanCheck_0x1ac320; // 0x1ac458 - g_ps2RecompiledFunctionTable[176419] = bhEne04_KaidanCheck_0x1ac320; // 0x1ac494 - g_ps2RecompiledFunctionTable[176426] = bhEne04_ShakeWire_0x1ac4b0; // 0x1ac4b0 - g_ps2RecompiledFunctionTable[176435] = bhEne04_ShakeWire_0x1ac4b0; // 0x1ac4d4 - g_ps2RecompiledFunctionTable[176473] = bhEne04_ShakeWire_0x1ac4b0; // 0x1ac56c - g_ps2RecompiledFunctionTable[176488] = bhEne04_ShakeWire_0x1ac4b0; // 0x1ac5a8 - g_ps2RecompiledFunctionTable[176522] = bhEne04_RotNeck_0x1ac630; // 0x1ac630 - g_ps2RecompiledFunctionTable[176534] = bhEne04_SearchNeck_0x1ac660; // 0x1ac660 - g_ps2RecompiledFunctionTable[176546] = bhEne04_SearchNeck_0x1ac660; // 0x1ac690 - g_ps2RecompiledFunctionTable[176557] = bhEne04_SearchNeck_0x1ac660; // 0x1ac6bc - g_ps2RecompiledFunctionTable[176602] = bhEne04_SePlay_0x1ac770; // 0x1ac770 - g_ps2RecompiledFunctionTable[176617] = bhEne04_SePlay_0x1ac770; // 0x1ac7ac - g_ps2RecompiledFunctionTable[176622] = bhEne05_0x1ac7c0; // 0x1ac7c0 - g_ps2RecompiledFunctionTable[176623] = bhEne05_0x1ac7c0; // 0x1ac7c4 - g_ps2RecompiledFunctionTable[176624] = bhEne05_0x1ac7c0; // 0x1ac7c8 - g_ps2RecompiledFunctionTable[176625] = bhEne05_0x1ac7c0; // 0x1ac7cc - g_ps2RecompiledFunctionTable[176626] = bhEne05_0x1ac7c0; // 0x1ac7d0 - g_ps2RecompiledFunctionTable[176627] = bhEne05_0x1ac7c0; // 0x1ac7d4 - g_ps2RecompiledFunctionTable[176628] = bhEne05_0x1ac7c0; // 0x1ac7d8 - g_ps2RecompiledFunctionTable[176629] = bhEne05_0x1ac7c0; // 0x1ac7dc - g_ps2RecompiledFunctionTable[176630] = bhEne05_0x1ac7c0; // 0x1ac7e0 - g_ps2RecompiledFunctionTable[176631] = bhEne05_0x1ac7c0; // 0x1ac7e4 - g_ps2RecompiledFunctionTable[176632] = bhEne05_0x1ac7c0; // 0x1ac7e8 - g_ps2RecompiledFunctionTable[176633] = bhEne05_0x1ac7c0; // 0x1ac7ec - g_ps2RecompiledFunctionTable[176634] = bhEne05_0x1ac7c0; // 0x1ac7f0 - g_ps2RecompiledFunctionTable[176635] = bhEne05_0x1ac7c0; // 0x1ac7f4 - g_ps2RecompiledFunctionTable[176636] = bhEne05_0x1ac7c0; // 0x1ac7f8 - g_ps2RecompiledFunctionTable[176637] = bhEne05_0x1ac7c0; // 0x1ac7fc - g_ps2RecompiledFunctionTable[176638] = bhEne05_0x1ac7c0; // 0x1ac800 - g_ps2RecompiledFunctionTable[176639] = bhEne05_0x1ac7c0; // 0x1ac804 - g_ps2RecompiledFunctionTable[176640] = bhEne05_0x1ac7c0; // 0x1ac808 - g_ps2RecompiledFunctionTable[176641] = bhEne05_0x1ac7c0; // 0x1ac80c - g_ps2RecompiledFunctionTable[176642] = bhEne05_0x1ac7c0; // 0x1ac810 - g_ps2RecompiledFunctionTable[176643] = bhEne05_0x1ac7c0; // 0x1ac814 - g_ps2RecompiledFunctionTable[176644] = bhEne05_0x1ac7c0; // 0x1ac818 - g_ps2RecompiledFunctionTable[176645] = bhEne05_0x1ac7c0; // 0x1ac81c - g_ps2RecompiledFunctionTable[176646] = bhEne05_0x1ac7c0; // 0x1ac820 - g_ps2RecompiledFunctionTable[176647] = bhEne05_0x1ac7c0; // 0x1ac824 - g_ps2RecompiledFunctionTable[176648] = bhEne05_0x1ac7c0; // 0x1ac828 - g_ps2RecompiledFunctionTable[176649] = bhEne05_0x1ac7c0; // 0x1ac82c - g_ps2RecompiledFunctionTable[176650] = bhEne05_0x1ac7c0; // 0x1ac830 - g_ps2RecompiledFunctionTable[176651] = bhEne05_0x1ac7c0; // 0x1ac834 - g_ps2RecompiledFunctionTable[176652] = bhEne05_0x1ac7c0; // 0x1ac838 - g_ps2RecompiledFunctionTable[176653] = bhEne05_0x1ac7c0; // 0x1ac83c - g_ps2RecompiledFunctionTable[176654] = bhEne05_0x1ac7c0; // 0x1ac840 - g_ps2RecompiledFunctionTable[176655] = bhEne05_0x1ac7c0; // 0x1ac844 - g_ps2RecompiledFunctionTable[176656] = bhEne05_0x1ac7c0; // 0x1ac848 - g_ps2RecompiledFunctionTable[176657] = bhEne05_0x1ac7c0; // 0x1ac84c - g_ps2RecompiledFunctionTable[176658] = bhEne05_0x1ac7c0; // 0x1ac850 - g_ps2RecompiledFunctionTable[176659] = bhEne05_0x1ac7c0; // 0x1ac854 - g_ps2RecompiledFunctionTable[176660] = bhEne05_0x1ac7c0; // 0x1ac858 - g_ps2RecompiledFunctionTable[176661] = bhEne05_0x1ac7c0; // 0x1ac85c - g_ps2RecompiledFunctionTable[176662] = bhEne05_0x1ac7c0; // 0x1ac860 - g_ps2RecompiledFunctionTable[176663] = bhEne05_0x1ac7c0; // 0x1ac864 - g_ps2RecompiledFunctionTable[176664] = bhEne05_0x1ac7c0; // 0x1ac868 - g_ps2RecompiledFunctionTable[176665] = bhEne05_0x1ac7c0; // 0x1ac86c - g_ps2RecompiledFunctionTable[176666] = bhEne05_0x1ac7c0; // 0x1ac870 - g_ps2RecompiledFunctionTable[176667] = bhEne05_0x1ac7c0; // 0x1ac874 - g_ps2RecompiledFunctionTable[176668] = bhEne05_0x1ac7c0; // 0x1ac878 - g_ps2RecompiledFunctionTable[176669] = bhEne05_0x1ac7c0; // 0x1ac87c - g_ps2RecompiledFunctionTable[176670] = bhEne05_0x1ac7c0; // 0x1ac880 - g_ps2RecompiledFunctionTable[176671] = bhEne05_0x1ac7c0; // 0x1ac884 - g_ps2RecompiledFunctionTable[176672] = bhEne05_0x1ac7c0; // 0x1ac888 - g_ps2RecompiledFunctionTable[176673] = bhEne05_0x1ac7c0; // 0x1ac88c - g_ps2RecompiledFunctionTable[176674] = bhEne05_0x1ac7c0; // 0x1ac890 - g_ps2RecompiledFunctionTable[176675] = bhEne05_0x1ac7c0; // 0x1ac894 - g_ps2RecompiledFunctionTable[176676] = bhEne05_0x1ac7c0; // 0x1ac898 - g_ps2RecompiledFunctionTable[176677] = bhEne05_0x1ac7c0; // 0x1ac89c - g_ps2RecompiledFunctionTable[176678] = bhEne05_0x1ac7c0; // 0x1ac8a0 - g_ps2RecompiledFunctionTable[176679] = bhEne05_0x1ac7c0; // 0x1ac8a4 - g_ps2RecompiledFunctionTable[176680] = bhEne05_0x1ac7c0; // 0x1ac8a8 - g_ps2RecompiledFunctionTable[176681] = bhEne05_0x1ac7c0; // 0x1ac8ac - g_ps2RecompiledFunctionTable[176682] = bhEne05_0x1ac7c0; // 0x1ac8b0 - g_ps2RecompiledFunctionTable[176683] = bhEne05_0x1ac7c0; // 0x1ac8b4 - g_ps2RecompiledFunctionTable[176684] = bhEne05_0x1ac7c0; // 0x1ac8b8 - g_ps2RecompiledFunctionTable[176685] = bhEne05_0x1ac7c0; // 0x1ac8bc - g_ps2RecompiledFunctionTable[176686] = bhEne05_0x1ac7c0; // 0x1ac8c0 - g_ps2RecompiledFunctionTable[176687] = bhEne05_0x1ac7c0; // 0x1ac8c4 - g_ps2RecompiledFunctionTable[176688] = bhEne05_0x1ac7c0; // 0x1ac8c8 - g_ps2RecompiledFunctionTable[176689] = bhEne05_0x1ac7c0; // 0x1ac8cc - g_ps2RecompiledFunctionTable[176690] = bhEne05_0x1ac7c0; // 0x1ac8d0 - g_ps2RecompiledFunctionTable[176691] = bhEne05_0x1ac7c0; // 0x1ac8d4 - g_ps2RecompiledFunctionTable[176692] = bhEne05_0x1ac7c0; // 0x1ac8d8 - g_ps2RecompiledFunctionTable[176693] = bhEne05_0x1ac7c0; // 0x1ac8dc - g_ps2RecompiledFunctionTable[176694] = bhEne05_0x1ac7c0; // 0x1ac8e0 - g_ps2RecompiledFunctionTable[176695] = bhEne05_0x1ac7c0; // 0x1ac8e4 - g_ps2RecompiledFunctionTable[176696] = bhEne05_0x1ac7c0; // 0x1ac8e8 - g_ps2RecompiledFunctionTable[176697] = bhEne05_0x1ac7c0; // 0x1ac8ec - g_ps2RecompiledFunctionTable[176698] = bhEne05_0x1ac7c0; // 0x1ac8f0 - g_ps2RecompiledFunctionTable[176699] = bhEne05_0x1ac7c0; // 0x1ac8f4 - g_ps2RecompiledFunctionTable[176700] = bhEne05_0x1ac7c0; // 0x1ac8f8 - g_ps2RecompiledFunctionTable[176701] = bhEne05_0x1ac7c0; // 0x1ac8fc - g_ps2RecompiledFunctionTable[176702] = bhEne05_0x1ac7c0; // 0x1ac900 - g_ps2RecompiledFunctionTable[176703] = bhEne05_0x1ac7c0; // 0x1ac904 - g_ps2RecompiledFunctionTable[176704] = bhEne05_0x1ac7c0; // 0x1ac908 - g_ps2RecompiledFunctionTable[176705] = bhEne05_0x1ac7c0; // 0x1ac90c - g_ps2RecompiledFunctionTable[176706] = bhEne05_0x1ac7c0; // 0x1ac910 - g_ps2RecompiledFunctionTable[176707] = bhEne05_0x1ac7c0; // 0x1ac914 - g_ps2RecompiledFunctionTable[176708] = bhEne05_0x1ac7c0; // 0x1ac918 - g_ps2RecompiledFunctionTable[176709] = bhEne05_0x1ac7c0; // 0x1ac91c - g_ps2RecompiledFunctionTable[176710] = bhEne05_0x1ac7c0; // 0x1ac920 - g_ps2RecompiledFunctionTable[176711] = bhEne05_0x1ac7c0; // 0x1ac924 - g_ps2RecompiledFunctionTable[176712] = bhEne05_0x1ac7c0; // 0x1ac928 - g_ps2RecompiledFunctionTable[176713] = bhEne05_0x1ac7c0; // 0x1ac92c - g_ps2RecompiledFunctionTable[176714] = bhEne05_0x1ac7c0; // 0x1ac930 - g_ps2RecompiledFunctionTable[176715] = bhEne05_0x1ac7c0; // 0x1ac934 - g_ps2RecompiledFunctionTable[176716] = bhEne05_0x1ac7c0; // 0x1ac938 - g_ps2RecompiledFunctionTable[176717] = bhEne05_0x1ac7c0; // 0x1ac93c - g_ps2RecompiledFunctionTable[176718] = bhEne05_0x1ac7c0; // 0x1ac940 - g_ps2RecompiledFunctionTable[176719] = bhEne05_0x1ac7c0; // 0x1ac944 - g_ps2RecompiledFunctionTable[176720] = bhEne05_0x1ac7c0; // 0x1ac948 - g_ps2RecompiledFunctionTable[176721] = bhEne05_0x1ac7c0; // 0x1ac94c - g_ps2RecompiledFunctionTable[176722] = bhEne05_0x1ac7c0; // 0x1ac950 - g_ps2RecompiledFunctionTable[176723] = bhEne05_0x1ac7c0; // 0x1ac954 - g_ps2RecompiledFunctionTable[176724] = bhEne05_0x1ac7c0; // 0x1ac958 - g_ps2RecompiledFunctionTable[176725] = bhEne05_0x1ac7c0; // 0x1ac95c - g_ps2RecompiledFunctionTable[176726] = bhEne05_0x1ac7c0; // 0x1ac960 - g_ps2RecompiledFunctionTable[176727] = bhEne05_0x1ac7c0; // 0x1ac964 - g_ps2RecompiledFunctionTable[176728] = bhEne05_0x1ac7c0; // 0x1ac968 - g_ps2RecompiledFunctionTable[176729] = bhEne05_0x1ac7c0; // 0x1ac96c - g_ps2RecompiledFunctionTable[176730] = bhEne05_0x1ac7c0; // 0x1ac970 - g_ps2RecompiledFunctionTable[176731] = bhEne05_0x1ac7c0; // 0x1ac974 - g_ps2RecompiledFunctionTable[176732] = bhEne05_0x1ac7c0; // 0x1ac978 - g_ps2RecompiledFunctionTable[176733] = bhEne05_0x1ac7c0; // 0x1ac97c - g_ps2RecompiledFunctionTable[176734] = bhEne05_0x1ac7c0; // 0x1ac980 - g_ps2RecompiledFunctionTable[176735] = bhEne05_0x1ac7c0; // 0x1ac984 - g_ps2RecompiledFunctionTable[176736] = bhEne05_0x1ac7c0; // 0x1ac988 - g_ps2RecompiledFunctionTable[176737] = bhEne05_0x1ac7c0; // 0x1ac98c - g_ps2RecompiledFunctionTable[176738] = bhEne05_0x1ac7c0; // 0x1ac990 - g_ps2RecompiledFunctionTable[176739] = bhEne05_0x1ac7c0; // 0x1ac994 - g_ps2RecompiledFunctionTable[176740] = bhEne05_0x1ac7c0; // 0x1ac998 - g_ps2RecompiledFunctionTable[176741] = bhEne05_0x1ac7c0; // 0x1ac99c - g_ps2RecompiledFunctionTable[176742] = bhEne05_0x1ac7c0; // 0x1ac9a0 - g_ps2RecompiledFunctionTable[176743] = bhEne05_0x1ac7c0; // 0x1ac9a4 - g_ps2RecompiledFunctionTable[176744] = bhEne05_0x1ac7c0; // 0x1ac9a8 - g_ps2RecompiledFunctionTable[176745] = bhEne05_0x1ac7c0; // 0x1ac9ac - g_ps2RecompiledFunctionTable[176746] = bhEne05_0x1ac7c0; // 0x1ac9b0 - g_ps2RecompiledFunctionTable[176747] = bhEne05_0x1ac7c0; // 0x1ac9b4 - g_ps2RecompiledFunctionTable[176748] = bhEne05_0x1ac7c0; // 0x1ac9b8 - g_ps2RecompiledFunctionTable[176749] = bhEne05_0x1ac7c0; // 0x1ac9bc - g_ps2RecompiledFunctionTable[176750] = bhEne05_0x1ac7c0; // 0x1ac9c0 - g_ps2RecompiledFunctionTable[176751] = bhEne05_0x1ac7c0; // 0x1ac9c4 - g_ps2RecompiledFunctionTable[176752] = bhEne05_0x1ac7c0; // 0x1ac9c8 - g_ps2RecompiledFunctionTable[176753] = bhEne05_0x1ac7c0; // 0x1ac9cc - g_ps2RecompiledFunctionTable[176754] = bhEne05_0x1ac7c0; // 0x1ac9d0 - g_ps2RecompiledFunctionTable[176755] = bhEne05_0x1ac7c0; // 0x1ac9d4 - g_ps2RecompiledFunctionTable[176756] = bhEne05_0x1ac7c0; // 0x1ac9d8 - g_ps2RecompiledFunctionTable[176757] = bhEne05_0x1ac7c0; // 0x1ac9dc - g_ps2RecompiledFunctionTable[176758] = bhEne05_0x1ac7c0; // 0x1ac9e0 - g_ps2RecompiledFunctionTable[176759] = bhEne05_0x1ac7c0; // 0x1ac9e4 - g_ps2RecompiledFunctionTable[176760] = bhEne05_0x1ac7c0; // 0x1ac9e8 - g_ps2RecompiledFunctionTable[176761] = bhEne05_0x1ac7c0; // 0x1ac9ec - g_ps2RecompiledFunctionTable[176762] = bhEne05_0x1ac7c0; // 0x1ac9f0 - g_ps2RecompiledFunctionTable[176763] = bhEne05_0x1ac7c0; // 0x1ac9f4 - g_ps2RecompiledFunctionTable[176764] = bhEne05_0x1ac7c0; // 0x1ac9f8 - g_ps2RecompiledFunctionTable[176765] = bhEne05_0x1ac7c0; // 0x1ac9fc - g_ps2RecompiledFunctionTable[176766] = bhEne05_0x1ac7c0; // 0x1aca00 - g_ps2RecompiledFunctionTable[176770] = bhEne05_Init_0x1aca10; // 0x1aca10 - g_ps2RecompiledFunctionTable[176803] = bhEne05_Init_0x1aca10; // 0x1aca94 - g_ps2RecompiledFunctionTable[176816] = bhEne05_Init_0x1aca10; // 0x1acac8 - g_ps2RecompiledFunctionTable[176825] = bhEne05_Init_0x1aca10; // 0x1acaec - g_ps2RecompiledFunctionTable[176838] = bhEne05_Init_0x1aca10; // 0x1acb20 - g_ps2RecompiledFunctionTable[176864] = bhEne05_Init_0x1aca10; // 0x1acb88 - g_ps2RecompiledFunctionTable[176871] = bhEne05_Init_0x1aca10; // 0x1acba4 - g_ps2RecompiledFunctionTable[176905] = bhEne05_Init_0x1aca10; // 0x1acc2c - g_ps2RecompiledFunctionTable[176908] = bhEne05_Init_0x1aca10; // 0x1acc38 - g_ps2RecompiledFunctionTable[176921] = bhEne05_Init_0x1aca10; // 0x1acc6c - g_ps2RecompiledFunctionTable[176942] = bhEne05_Init_0x1aca10; // 0x1accc0 - g_ps2RecompiledFunctionTable[176977] = bhEne05_Init_0x1aca10; // 0x1acd4c - g_ps2RecompiledFunctionTable[177046] = bhEne05_Brain_0x1ace60; // 0x1ace60 - g_ps2RecompiledFunctionTable[177047] = bhEne05_Brain_0x1ace60; // 0x1ace64 - g_ps2RecompiledFunctionTable[177048] = bhEne05_Brain_0x1ace60; // 0x1ace68 - g_ps2RecompiledFunctionTable[177049] = bhEne05_Brain_0x1ace60; // 0x1ace6c - g_ps2RecompiledFunctionTable[177050] = bhEne05_Brain_0x1ace60; // 0x1ace70 - g_ps2RecompiledFunctionTable[177051] = bhEne05_Brain_0x1ace60; // 0x1ace74 - g_ps2RecompiledFunctionTable[177052] = bhEne05_Brain_0x1ace60; // 0x1ace78 - g_ps2RecompiledFunctionTable[177053] = bhEne05_Brain_0x1ace60; // 0x1ace7c - g_ps2RecompiledFunctionTable[177054] = bhEne05_BR00_0x1ace80; // 0x1ace80 - g_ps2RecompiledFunctionTable[177091] = bhEne05_BR00_0x1ace80; // 0x1acf14 - g_ps2RecompiledFunctionTable[177147] = bhEne05_BR00_0x1ace80; // 0x1acff4 - g_ps2RecompiledFunctionTable[177154] = bhEne05_BR00_0x1ace80; // 0x1ad010 - g_ps2RecompiledFunctionTable[177172] = bhEne05_BR00_0x1ace80; // 0x1ad058 - g_ps2RecompiledFunctionTable[177200] = bhEne05_BR00_0x1ace80; // 0x1ad0c8 - g_ps2RecompiledFunctionTable[177225] = bhEne05_BR00_0x1ace80; // 0x1ad12c - g_ps2RecompiledFunctionTable[177336] = bhEne05_BR00_0x1ace80; // 0x1ad2e8 - g_ps2RecompiledFunctionTable[177357] = bhEne05_BR00_0x1ace80; // 0x1ad33c - g_ps2RecompiledFunctionTable[177366] = bhEne05_BR00_0x1ace80; // 0x1ad360 - g_ps2RecompiledFunctionTable[177435] = bhEne05_BR00_0x1ace80; // 0x1ad474 - g_ps2RecompiledFunctionTable[177551] = bhEne05_BR00_0x1ace80; // 0x1ad644 - g_ps2RecompiledFunctionTable[177565] = bhEne05_BR00_0x1ace80; // 0x1ad67c - g_ps2RecompiledFunctionTable[177574] = bhEne05_BR00_0x1ace80; // 0x1ad6a0 - g_ps2RecompiledFunctionTable[177599] = bhEne05_BR00_0x1ace80; // 0x1ad704 - g_ps2RecompiledFunctionTable[177615] = bhEne05_BR00_0x1ace80; // 0x1ad744 - g_ps2RecompiledFunctionTable[177622] = bhEne05_BR00_0x1ace80; // 0x1ad760 - g_ps2RecompiledFunctionTable[177635] = bhEne05_BR00_0x1ace80; // 0x1ad794 - g_ps2RecompiledFunctionTable[177668] = bhEne05_BR00_0x1ace80; // 0x1ad818 - g_ps2RecompiledFunctionTable[177677] = bhEne05_BR00_0x1ace80; // 0x1ad83c - g_ps2RecompiledFunctionTable[177695] = bhEne05_BR00_0x1ace80; // 0x1ad884 - g_ps2RecompiledFunctionTable[177765] = bhEne05_BR00_0x1ace80; // 0x1ad99c - g_ps2RecompiledFunctionTable[177786] = bhEne05_BR00_0x1ace80; // 0x1ad9f0 - g_ps2RecompiledFunctionTable[177810] = bhEne05_BR00_0x1ace80; // 0x1ada50 - g_ps2RecompiledFunctionTable[177817] = bhEne05_BR00_0x1ace80; // 0x1ada6c - g_ps2RecompiledFunctionTable[177830] = bhEne05_BR00_0x1ace80; // 0x1adaa0 - g_ps2RecompiledFunctionTable[177860] = bhEne05_BR00_0x1ace80; // 0x1adb18 - g_ps2RecompiledFunctionTable[177872] = bhEne05_BR00_0x1ace80; // 0x1adb48 - g_ps2RecompiledFunctionTable[177884] = bhEne05_BR00_0x1ace80; // 0x1adb78 - g_ps2RecompiledFunctionTable[177888] = bhEne05_BR00_0x1ace80; // 0x1adb88 - g_ps2RecompiledFunctionTable[177904] = bhEne05_BR00_0x1ace80; // 0x1adbc8 - g_ps2RecompiledFunctionTable[177941] = bhEne05_BR00_0x1ace80; // 0x1adc5c - g_ps2RecompiledFunctionTable[177954] = bhEne05_BR00_0x1ace80; // 0x1adc90 - g_ps2RecompiledFunctionTable[177964] = bhEne05_BR00_0x1ace80; // 0x1adcb8 - g_ps2RecompiledFunctionTable[177981] = bhEne05_BR00_0x1ace80; // 0x1adcfc - g_ps2RecompiledFunctionTable[177992] = bhEne05_BR00_0x1ace80; // 0x1add28 - g_ps2RecompiledFunctionTable[178005] = bhEne05_BR00_0x1ace80; // 0x1add5c - g_ps2RecompiledFunctionTable[178018] = bhEne05_BR01_0x1add90; // 0x1add90 - g_ps2RecompiledFunctionTable[178022] = bhEne05_BR02_0x1adda0; // 0x1adda0 - g_ps2RecompiledFunctionTable[178030] = bhEne05_Move_0x1addc0; // 0x1addc0 - g_ps2RecompiledFunctionTable[178031] = bhEne05_Move_0x1addc0; // 0x1addc4 - g_ps2RecompiledFunctionTable[178032] = bhEne05_Move_0x1addc0; // 0x1addc8 - g_ps2RecompiledFunctionTable[178033] = bhEne05_Move_0x1addc0; // 0x1addcc - g_ps2RecompiledFunctionTable[178034] = bhEne05_Move_0x1addc0; // 0x1addd0 - g_ps2RecompiledFunctionTable[178035] = bhEne05_Move_0x1addc0; // 0x1addd4 - g_ps2RecompiledFunctionTable[178036] = bhEne05_Move_0x1addc0; // 0x1addd8 - g_ps2RecompiledFunctionTable[178037] = bhEne05_Move_0x1addc0; // 0x1adddc - g_ps2RecompiledFunctionTable[178038] = bhEne05_Move_0x1addc0; // 0x1adde0 - g_ps2RecompiledFunctionTable[178039] = bhEne05_Move_0x1addc0; // 0x1adde4 - g_ps2RecompiledFunctionTable[178040] = bhEne05_Move_0x1addc0; // 0x1adde8 - g_ps2RecompiledFunctionTable[178041] = bhEne05_Move_0x1addc0; // 0x1addec - g_ps2RecompiledFunctionTable[178042] = bhEne05_Move_0x1addc0; // 0x1addf0 - g_ps2RecompiledFunctionTable[178043] = bhEne05_Move_0x1addc0; // 0x1addf4 - g_ps2RecompiledFunctionTable[178044] = bhEne05_Move_0x1addc0; // 0x1addf8 - g_ps2RecompiledFunctionTable[178045] = bhEne05_Move_0x1addc0; // 0x1addfc - g_ps2RecompiledFunctionTable[178046] = bhEne05_Move_0x1addc0; // 0x1ade00 - g_ps2RecompiledFunctionTable[178047] = bhEne05_Move_0x1addc0; // 0x1ade04 - g_ps2RecompiledFunctionTable[178048] = bhEne05_Move_0x1addc0; // 0x1ade08 - g_ps2RecompiledFunctionTable[178049] = bhEne05_Move_0x1addc0; // 0x1ade0c - g_ps2RecompiledFunctionTable[178050] = bhEne05_Move_0x1addc0; // 0x1ade10 - g_ps2RecompiledFunctionTable[178051] = bhEne05_Move_0x1addc0; // 0x1ade14 - g_ps2RecompiledFunctionTable[178052] = bhEne05_Move_0x1addc0; // 0x1ade18 - g_ps2RecompiledFunctionTable[178053] = bhEne05_Move_0x1addc0; // 0x1ade1c - g_ps2RecompiledFunctionTable[178054] = bhEne05_Move_0x1addc0; // 0x1ade20 - g_ps2RecompiledFunctionTable[178055] = bhEne05_Move_0x1addc0; // 0x1ade24 - g_ps2RecompiledFunctionTable[178056] = bhEne05_Move_0x1addc0; // 0x1ade28 - g_ps2RecompiledFunctionTable[178057] = bhEne05_Move_0x1addc0; // 0x1ade2c - g_ps2RecompiledFunctionTable[178058] = bhEne05_Move_0x1addc0; // 0x1ade30 - g_ps2RecompiledFunctionTable[178059] = bhEne05_Move_0x1addc0; // 0x1ade34 - g_ps2RecompiledFunctionTable[178060] = bhEne05_Move_0x1addc0; // 0x1ade38 - g_ps2RecompiledFunctionTable[178061] = bhEne05_Move_0x1addc0; // 0x1ade3c - g_ps2RecompiledFunctionTable[178062] = bhEne05_Move_0x1addc0; // 0x1ade40 - g_ps2RecompiledFunctionTable[178063] = bhEne05_Move_0x1addc0; // 0x1ade44 - g_ps2RecompiledFunctionTable[178064] = bhEne05_Move_0x1addc0; // 0x1ade48 - g_ps2RecompiledFunctionTable[178065] = bhEne05_Move_0x1addc0; // 0x1ade4c - g_ps2RecompiledFunctionTable[178066] = bhEne05_Move_0x1addc0; // 0x1ade50 - g_ps2RecompiledFunctionTable[178067] = bhEne05_Move_0x1addc0; // 0x1ade54 - g_ps2RecompiledFunctionTable[178068] = bhEne05_Move_0x1addc0; // 0x1ade58 - g_ps2RecompiledFunctionTable[178069] = bhEne05_Move_0x1addc0; // 0x1ade5c - g_ps2RecompiledFunctionTable[178070] = bhEne05_Move_0x1addc0; // 0x1ade60 - g_ps2RecompiledFunctionTable[178071] = bhEne05_Move_0x1addc0; // 0x1ade64 - g_ps2RecompiledFunctionTable[178072] = bhEne05_Move_0x1addc0; // 0x1ade68 - g_ps2RecompiledFunctionTable[178073] = bhEne05_Move_0x1addc0; // 0x1ade6c - g_ps2RecompiledFunctionTable[178074] = bhEne05_Move_0x1addc0; // 0x1ade70 - g_ps2RecompiledFunctionTable[178075] = bhEne05_Move_0x1addc0; // 0x1ade74 - g_ps2RecompiledFunctionTable[178076] = bhEne05_Move_0x1addc0; // 0x1ade78 - g_ps2RecompiledFunctionTable[178077] = bhEne05_Move_0x1addc0; // 0x1ade7c - g_ps2RecompiledFunctionTable[178078] = bhEne05_Move_0x1addc0; // 0x1ade80 - g_ps2RecompiledFunctionTable[178079] = bhEne05_Move_0x1addc0; // 0x1ade84 - g_ps2RecompiledFunctionTable[178080] = bhEne05_Move_0x1addc0; // 0x1ade88 - g_ps2RecompiledFunctionTable[178081] = bhEne05_Move_0x1addc0; // 0x1ade8c - g_ps2RecompiledFunctionTable[178082] = bhEne05_Move_0x1addc0; // 0x1ade90 - g_ps2RecompiledFunctionTable[178083] = bhEne05_Move_0x1addc0; // 0x1ade94 - g_ps2RecompiledFunctionTable[178084] = bhEne05_Move_0x1addc0; // 0x1ade98 - g_ps2RecompiledFunctionTable[178085] = bhEne05_Move_0x1addc0; // 0x1ade9c - g_ps2RecompiledFunctionTable[178086] = bhEne05_Move_0x1addc0; // 0x1adea0 - g_ps2RecompiledFunctionTable[178087] = bhEne05_Move_0x1addc0; // 0x1adea4 - g_ps2RecompiledFunctionTable[178088] = bhEne05_Move_0x1addc0; // 0x1adea8 - g_ps2RecompiledFunctionTable[178089] = bhEne05_Move_0x1addc0; // 0x1adeac - g_ps2RecompiledFunctionTable[178090] = bhEne05_Move_0x1addc0; // 0x1adeb0 - g_ps2RecompiledFunctionTable[178091] = bhEne05_Move_0x1addc0; // 0x1adeb4 - g_ps2RecompiledFunctionTable[178092] = bhEne05_Move_0x1addc0; // 0x1adeb8 - g_ps2RecompiledFunctionTable[178093] = bhEne05_Move_0x1addc0; // 0x1adebc - g_ps2RecompiledFunctionTable[178094] = bhEne05_Move_0x1addc0; // 0x1adec0 - g_ps2RecompiledFunctionTable[178095] = bhEne05_Move_0x1addc0; // 0x1adec4 - g_ps2RecompiledFunctionTable[178096] = bhEne05_Move_0x1addc0; // 0x1adec8 - g_ps2RecompiledFunctionTable[178097] = bhEne05_Move_0x1addc0; // 0x1adecc - g_ps2RecompiledFunctionTable[178098] = bhEne05_Move_0x1addc0; // 0x1aded0 - g_ps2RecompiledFunctionTable[178099] = bhEne05_Move_0x1addc0; // 0x1aded4 - g_ps2RecompiledFunctionTable[178100] = bhEne05_Move_0x1addc0; // 0x1aded8 - g_ps2RecompiledFunctionTable[178101] = bhEne05_Move_0x1addc0; // 0x1adedc - g_ps2RecompiledFunctionTable[178102] = bhEne05_Move_0x1addc0; // 0x1adee0 - g_ps2RecompiledFunctionTable[178103] = bhEne05_Move_0x1addc0; // 0x1adee4 - g_ps2RecompiledFunctionTable[178104] = bhEne05_Move_0x1addc0; // 0x1adee8 - g_ps2RecompiledFunctionTable[178105] = bhEne05_Move_0x1addc0; // 0x1adeec - g_ps2RecompiledFunctionTable[178106] = bhEne05_Move_0x1addc0; // 0x1adef0 - g_ps2RecompiledFunctionTable[178107] = bhEne05_Move_0x1addc0; // 0x1adef4 - g_ps2RecompiledFunctionTable[178110] = bhEne05_MV00_0x1adf00; // 0x1adf00 - g_ps2RecompiledFunctionTable[178154] = bhEne05_MV01_0x1adfb0; // 0x1adfb0 - g_ps2RecompiledFunctionTable[178210] = bhEne05_MV01_0x1adfb0; // 0x1ae090 - g_ps2RecompiledFunctionTable[178223] = bhEne05_MV01_0x1adfb0; // 0x1ae0c4 - g_ps2RecompiledFunctionTable[178237] = bhEne05_MV01_0x1adfb0; // 0x1ae0fc - g_ps2RecompiledFunctionTable[178247] = bhEne05_MV01_0x1adfb0; // 0x1ae124 - g_ps2RecompiledFunctionTable[178274] = bhEne05_MV01_0x1adfb0; // 0x1ae190 - g_ps2RecompiledFunctionTable[178280] = bhEne05_MV01_0x1adfb0; // 0x1ae1a8 - g_ps2RecompiledFunctionTable[178291] = bhEne05_MV01_0x1adfb0; // 0x1ae1d4 - g_ps2RecompiledFunctionTable[178301] = bhEne05_MV01_0x1adfb0; // 0x1ae1fc - g_ps2RecompiledFunctionTable[178308] = bhEne05_MV01_0x1adfb0; // 0x1ae218 - g_ps2RecompiledFunctionTable[178310] = bhEne05_MV01_0x1adfb0; // 0x1ae220 - g_ps2RecompiledFunctionTable[178312] = bhEne05_MV01_0x1adfb0; // 0x1ae228 - g_ps2RecompiledFunctionTable[178316] = bhEne05_MV01_0x1adfb0; // 0x1ae238 - g_ps2RecompiledFunctionTable[178320] = bhEne05_MV01_0x1adfb0; // 0x1ae248 - g_ps2RecompiledFunctionTable[178322] = bhEne05_MV01_0x1adfb0; // 0x1ae250 - g_ps2RecompiledFunctionTable[178327] = bhEne05_MV01_0x1adfb0; // 0x1ae264 - g_ps2RecompiledFunctionTable[178345] = bhEne05_MV01_0x1adfb0; // 0x1ae2ac - g_ps2RecompiledFunctionTable[178362] = bhEne05_MV01_0x1adfb0; // 0x1ae2f0 - g_ps2RecompiledFunctionTable[178371] = bhEne05_MV01_0x1adfb0; // 0x1ae314 - g_ps2RecompiledFunctionTable[178387] = bhEne05_MV01_0x1adfb0; // 0x1ae354 - g_ps2RecompiledFunctionTable[178396] = bhEne05_MV01_0x1adfb0; // 0x1ae378 - g_ps2RecompiledFunctionTable[178413] = bhEne05_MV01_0x1adfb0; // 0x1ae3bc - g_ps2RecompiledFunctionTable[178444] = bhEne05_MV01_0x1adfb0; // 0x1ae438 - g_ps2RecompiledFunctionTable[178449] = bhEne05_MV01_0x1adfb0; // 0x1ae44c - g_ps2RecompiledFunctionTable[178459] = bhEne05_MV01_0x1adfb0; // 0x1ae474 - g_ps2RecompiledFunctionTable[178471] = bhEne05_MV01_0x1adfb0; // 0x1ae4a4 - g_ps2RecompiledFunctionTable[178515] = bhEne05_MV01_0x1adfb0; // 0x1ae554 - g_ps2RecompiledFunctionTable[178546] = bhEne05_MV02_0x1ae5d0; // 0x1ae5d0 - g_ps2RecompiledFunctionTable[178608] = bhEne05_MV02_0x1ae5d0; // 0x1ae6c8 - g_ps2RecompiledFunctionTable[178614] = bhEne05_MV02_0x1ae5d0; // 0x1ae6e0 - g_ps2RecompiledFunctionTable[178642] = bhEne05_MV02_0x1ae5d0; // 0x1ae750 - g_ps2RecompiledFunctionTable[178647] = bhEne05_MV02_0x1ae5d0; // 0x1ae764 - g_ps2RecompiledFunctionTable[178655] = bhEne05_MV02_0x1ae5d0; // 0x1ae784 - g_ps2RecompiledFunctionTable[178673] = bhEne05_MV02_0x1ae5d0; // 0x1ae7cc - g_ps2RecompiledFunctionTable[178698] = bhEne05_MV03_0x1ae830; // 0x1ae830 - g_ps2RecompiledFunctionTable[178797] = bhEne05_MV03_0x1ae830; // 0x1ae9bc - g_ps2RecompiledFunctionTable[178804] = bhEne05_MV03_0x1ae830; // 0x1ae9d8 - g_ps2RecompiledFunctionTable[178812] = bhEne05_MV03_0x1ae830; // 0x1ae9f8 - g_ps2RecompiledFunctionTable[178827] = bhEne05_MV03_0x1ae830; // 0x1aea34 - g_ps2RecompiledFunctionTable[178834] = bhEne05_MV03_0x1ae830; // 0x1aea50 - g_ps2RecompiledFunctionTable[178846] = bhEne05_MV03_0x1ae830; // 0x1aea80 - g_ps2RecompiledFunctionTable[178878] = bhEne05_MV03_0x1ae830; // 0x1aeb00 - g_ps2RecompiledFunctionTable[178884] = bhEne05_MV03_0x1ae830; // 0x1aeb18 - g_ps2RecompiledFunctionTable[178893] = bhEne05_MV03_0x1ae830; // 0x1aeb3c - g_ps2RecompiledFunctionTable[178904] = bhEne05_MV03_0x1ae830; // 0x1aeb68 - g_ps2RecompiledFunctionTable[178953] = bhEne05_MV03_0x1ae830; // 0x1aec2c - g_ps2RecompiledFunctionTable[179014] = bhEne05_MV04_0x1aed20; // 0x1aed20 - g_ps2RecompiledFunctionTable[179018] = bhEne05_MV05_0x1aed30; // 0x1aed30 - g_ps2RecompiledFunctionTable[179080] = bhEne05_MV05_0x1aed30; // 0x1aee28 - g_ps2RecompiledFunctionTable[179136] = bhEne05_MV05_0x1aed30; // 0x1aef08 - g_ps2RecompiledFunctionTable[179139] = bhEne05_MV05_0x1aed30; // 0x1aef14 - g_ps2RecompiledFunctionTable[179153] = bhEne05_MV05_0x1aed30; // 0x1aef4c - g_ps2RecompiledFunctionTable[179192] = bhEne05_MV05_0x1aed30; // 0x1aefe8 - g_ps2RecompiledFunctionTable[179259] = bhEne05_MV05_0x1aed30; // 0x1af0f4 - g_ps2RecompiledFunctionTable[179265] = bhEne05_MV05_0x1aed30; // 0x1af10c - g_ps2RecompiledFunctionTable[179274] = bhEne05_MV05_0x1aed30; // 0x1af130 - g_ps2RecompiledFunctionTable[179297] = bhEne05_MV05_0x1aed30; // 0x1af18c - g_ps2RecompiledFunctionTable[179361] = bhEne05_MV05_0x1aed30; // 0x1af28c - g_ps2RecompiledFunctionTable[179404] = bhEne05_MV05_0x1aed30; // 0x1af338 - g_ps2RecompiledFunctionTable[179419] = bhEne05_MV05_0x1aed30; // 0x1af374 - g_ps2RecompiledFunctionTable[179442] = bhEne05_MV06_0x1af3d0; // 0x1af3d0 - g_ps2RecompiledFunctionTable[179482] = bhEne05_MV06_0x1af3d0; // 0x1af470 - g_ps2RecompiledFunctionTable[179489] = bhEne05_MV06_0x1af3d0; // 0x1af48c - g_ps2RecompiledFunctionTable[179566] = bhEne05_MV06_0x1af3d0; // 0x1af5c0 - g_ps2RecompiledFunctionTable[179578] = bhEne05_MV06_0x1af3d0; // 0x1af5f0 - g_ps2RecompiledFunctionTable[179589] = bhEne05_MV06_0x1af3d0; // 0x1af61c - g_ps2RecompiledFunctionTable[179624] = bhEne05_MV06_0x1af3d0; // 0x1af6a8 - g_ps2RecompiledFunctionTable[179630] = bhEne05_MV06_0x1af3d0; // 0x1af6c0 - g_ps2RecompiledFunctionTable[179637] = bhEne05_MV06_0x1af3d0; // 0x1af6dc - g_ps2RecompiledFunctionTable[179644] = bhEne05_MV06_0x1af3d0; // 0x1af6f8 - g_ps2RecompiledFunctionTable[179672] = bhEne05_MV06_0x1af3d0; // 0x1af768 - g_ps2RecompiledFunctionTable[179758] = bhEne05_MV07_0x1af8c0; // 0x1af8c0 - g_ps2RecompiledFunctionTable[179858] = bhEne05_MV07_0x1af8c0; // 0x1afa50 - g_ps2RecompiledFunctionTable[179939] = bhEne05_MV07_0x1af8c0; // 0x1afb94 - g_ps2RecompiledFunctionTable[179949] = bhEne05_MV07_0x1af8c0; // 0x1afbbc - g_ps2RecompiledFunctionTable[179959] = bhEne05_MV07_0x1af8c0; // 0x1afbe4 - g_ps2RecompiledFunctionTable[179978] = bhEne05_MV07_0x1af8c0; // 0x1afc30 - g_ps2RecompiledFunctionTable[179981] = bhEne05_MV07_0x1af8c0; // 0x1afc3c - g_ps2RecompiledFunctionTable[179989] = bhEne05_MV07_0x1af8c0; // 0x1afc5c - g_ps2RecompiledFunctionTable[180064] = bhEne05_MV07_0x1af8c0; // 0x1afd88 - g_ps2RecompiledFunctionTable[180072] = bhEne05_MV07_0x1af8c0; // 0x1afda8 - g_ps2RecompiledFunctionTable[180182] = bhEne05_MV08_0x1aff60; // 0x1aff60 - g_ps2RecompiledFunctionTable[180291] = bhEne05_MV08_0x1aff60; // 0x1b0114 - g_ps2RecompiledFunctionTable[180342] = bhEne05_MV09_0x1b01e0; // 0x1b01e0 - g_ps2RecompiledFunctionTable[180404] = bhEne05_MV09_0x1b01e0; // 0x1b02d8 - g_ps2RecompiledFunctionTable[180457] = bhEne05_MV09_0x1b01e0; // 0x1b03ac - g_ps2RecompiledFunctionTable[180460] = bhEne05_MV09_0x1b01e0; // 0x1b03b8 - g_ps2RecompiledFunctionTable[180474] = bhEne05_MV09_0x1b01e0; // 0x1b03f0 - g_ps2RecompiledFunctionTable[180513] = bhEne05_MV09_0x1b01e0; // 0x1b048c - g_ps2RecompiledFunctionTable[180581] = bhEne05_MV09_0x1b01e0; // 0x1b059c - g_ps2RecompiledFunctionTable[180596] = bhEne05_MV09_0x1b01e0; // 0x1b05d8 - g_ps2RecompiledFunctionTable[180614] = bhEne05_MV10_0x1b0620; // 0x1b0620 - g_ps2RecompiledFunctionTable[180689] = bhEne05_MV10_0x1b0620; // 0x1b074c - g_ps2RecompiledFunctionTable[180734] = bhEne05_MV11_0x1b0800; // 0x1b0800 - g_ps2RecompiledFunctionTable[180774] = bhEne05_MV12_0x1b08a0; // 0x1b08a0 - g_ps2RecompiledFunctionTable[180940] = bhEne05_MV12_0x1b08a0; // 0x1b0b38 - g_ps2RecompiledFunctionTable[180980] = bhEne05_MV12_0x1b08a0; // 0x1b0bd8 - g_ps2RecompiledFunctionTable[180983] = bhEne05_MV12_0x1b08a0; // 0x1b0be4 - g_ps2RecompiledFunctionTable[180987] = bhEne05_MV12_0x1b08a0; // 0x1b0bf4 - g_ps2RecompiledFunctionTable[181055] = bhEne05_MV12_0x1b08a0; // 0x1b0d04 - g_ps2RecompiledFunctionTable[181063] = bhEne05_MV12_0x1b08a0; // 0x1b0d24 - g_ps2RecompiledFunctionTable[181070] = bhEne05_MV13_0x1b0d40; // 0x1b0d40 - g_ps2RecompiledFunctionTable[181222] = bhEne05_MV13_0x1b0d40; // 0x1b0fa0 - g_ps2RecompiledFunctionTable[181266] = bhEne05_MV13_0x1b0d40; // 0x1b1050 - g_ps2RecompiledFunctionTable[181269] = bhEne05_MV13_0x1b0d40; // 0x1b105c - g_ps2RecompiledFunctionTable[181273] = bhEne05_MV13_0x1b0d40; // 0x1b106c - g_ps2RecompiledFunctionTable[181341] = bhEne05_MV13_0x1b0d40; // 0x1b117c - g_ps2RecompiledFunctionTable[181349] = bhEne05_MV13_0x1b0d40; // 0x1b119c - g_ps2RecompiledFunctionTable[181358] = bhEne05_MV14_0x1b11c0; // 0x1b11c0 - g_ps2RecompiledFunctionTable[181385] = bhEne05_MV14_0x1b11c0; // 0x1b122c - g_ps2RecompiledFunctionTable[181388] = bhEne05_MV14_0x1b11c0; // 0x1b1238 - g_ps2RecompiledFunctionTable[181398] = bhEne05_MV15_0x1b1260; // 0x1b1260 - g_ps2RecompiledFunctionTable[181448] = bhEne05_MV15_0x1b1260; // 0x1b1328 - g_ps2RecompiledFunctionTable[181483] = bhEne05_MV15_0x1b1260; // 0x1b13b4 - g_ps2RecompiledFunctionTable[181489] = bhEne05_MV15_0x1b1260; // 0x1b13cc - g_ps2RecompiledFunctionTable[181498] = bhEne05_MV15_0x1b1260; // 0x1b13f0 - g_ps2RecompiledFunctionTable[181509] = bhEne05_MV15_0x1b1260; // 0x1b141c - g_ps2RecompiledFunctionTable[181558] = bhEne05_MV15_0x1b1260; // 0x1b14e0 - g_ps2RecompiledFunctionTable[181588] = bhEne05_MV15_0x1b1260; // 0x1b1558 - g_ps2RecompiledFunctionTable[181646] = bhEne05_MV16_0x1b1640; // 0x1b1640 - g_ps2RecompiledFunctionTable[181681] = bhEne05_MV16_0x1b1640; // 0x1b16cc - g_ps2RecompiledFunctionTable[181694] = bhEne05_MV16_0x1b1640; // 0x1b1700 - g_ps2RecompiledFunctionTable[181710] = bhEne05_MV17_0x1b1740; // 0x1b1740 - g_ps2RecompiledFunctionTable[181776] = bhEne05_MV17_0x1b1740; // 0x1b1848 - g_ps2RecompiledFunctionTable[181782] = bhEne05_MV17_0x1b1740; // 0x1b1860 - g_ps2RecompiledFunctionTable[181791] = bhEne05_MV17_0x1b1740; // 0x1b1884 - g_ps2RecompiledFunctionTable[181802] = bhEne05_MV17_0x1b1740; // 0x1b18b0 - g_ps2RecompiledFunctionTable[181851] = bhEne05_MV17_0x1b1740; // 0x1b1974 - g_ps2RecompiledFunctionTable[181884] = bhEne05_MV17_0x1b1740; // 0x1b19f8 - g_ps2RecompiledFunctionTable[181930] = bhEne05_Nage_0x1b1ab0; // 0x1b1ab0 - g_ps2RecompiledFunctionTable[181934] = bhEne05_Damage_0x1b1ac0; // 0x1b1ac0 - g_ps2RecompiledFunctionTable[181935] = bhEne05_Damage_0x1b1ac0; // 0x1b1ac4 - g_ps2RecompiledFunctionTable[181936] = bhEne05_Damage_0x1b1ac0; // 0x1b1ac8 - g_ps2RecompiledFunctionTable[181937] = bhEne05_Damage_0x1b1ac0; // 0x1b1acc - g_ps2RecompiledFunctionTable[181938] = bhEne05_Damage_0x1b1ac0; // 0x1b1ad0 - g_ps2RecompiledFunctionTable[181939] = bhEne05_Damage_0x1b1ac0; // 0x1b1ad4 - g_ps2RecompiledFunctionTable[181940] = bhEne05_Damage_0x1b1ac0; // 0x1b1ad8 - g_ps2RecompiledFunctionTable[181941] = bhEne05_Damage_0x1b1ac0; // 0x1b1adc - g_ps2RecompiledFunctionTable[181942] = bhEne05_Damage_0x1b1ac0; // 0x1b1ae0 - g_ps2RecompiledFunctionTable[181943] = bhEne05_Damage_0x1b1ac0; // 0x1b1ae4 - g_ps2RecompiledFunctionTable[181944] = bhEne05_Damage_0x1b1ac0; // 0x1b1ae8 - g_ps2RecompiledFunctionTable[181945] = bhEne05_Damage_0x1b1ac0; // 0x1b1aec - g_ps2RecompiledFunctionTable[181946] = bhEne05_Damage_0x1b1ac0; // 0x1b1af0 - g_ps2RecompiledFunctionTable[181947] = bhEne05_Damage_0x1b1ac0; // 0x1b1af4 - g_ps2RecompiledFunctionTable[181948] = bhEne05_Damage_0x1b1ac0; // 0x1b1af8 - g_ps2RecompiledFunctionTable[181949] = bhEne05_Damage_0x1b1ac0; // 0x1b1afc - g_ps2RecompiledFunctionTable[181950] = bhEne05_Damage_0x1b1ac0; // 0x1b1b00 - g_ps2RecompiledFunctionTable[181951] = bhEne05_Damage_0x1b1ac0; // 0x1b1b04 - g_ps2RecompiledFunctionTable[181952] = bhEne05_Damage_0x1b1ac0; // 0x1b1b08 - g_ps2RecompiledFunctionTable[181953] = bhEne05_Damage_0x1b1ac0; // 0x1b1b0c - g_ps2RecompiledFunctionTable[181954] = bhEne05_Damage_0x1b1ac0; // 0x1b1b10 - g_ps2RecompiledFunctionTable[181955] = bhEne05_Damage_0x1b1ac0; // 0x1b1b14 - g_ps2RecompiledFunctionTable[181956] = bhEne05_Damage_0x1b1ac0; // 0x1b1b18 - g_ps2RecompiledFunctionTable[181957] = bhEne05_Damage_0x1b1ac0; // 0x1b1b1c - g_ps2RecompiledFunctionTable[181958] = bhEne05_Damage_0x1b1ac0; // 0x1b1b20 - g_ps2RecompiledFunctionTable[181959] = bhEne05_Damage_0x1b1ac0; // 0x1b1b24 - g_ps2RecompiledFunctionTable[181960] = bhEne05_Damage_0x1b1ac0; // 0x1b1b28 - g_ps2RecompiledFunctionTable[181961] = bhEne05_Damage_0x1b1ac0; // 0x1b1b2c - g_ps2RecompiledFunctionTable[181962] = bhEne05_Damage_0x1b1ac0; // 0x1b1b30 - g_ps2RecompiledFunctionTable[181963] = bhEne05_Damage_0x1b1ac0; // 0x1b1b34 - g_ps2RecompiledFunctionTable[181964] = bhEne05_Damage_0x1b1ac0; // 0x1b1b38 - g_ps2RecompiledFunctionTable[181965] = bhEne05_Damage_0x1b1ac0; // 0x1b1b3c - g_ps2RecompiledFunctionTable[181966] = bhEne05_Damage_0x1b1ac0; // 0x1b1b40 - g_ps2RecompiledFunctionTable[181967] = bhEne05_Damage_0x1b1ac0; // 0x1b1b44 - g_ps2RecompiledFunctionTable[181968] = bhEne05_Damage_0x1b1ac0; // 0x1b1b48 - g_ps2RecompiledFunctionTable[181969] = bhEne05_Damage_0x1b1ac0; // 0x1b1b4c - g_ps2RecompiledFunctionTable[181970] = bhEne05_Damage_0x1b1ac0; // 0x1b1b50 - g_ps2RecompiledFunctionTable[181971] = bhEne05_Damage_0x1b1ac0; // 0x1b1b54 - g_ps2RecompiledFunctionTable[181972] = bhEne05_Damage_0x1b1ac0; // 0x1b1b58 - g_ps2RecompiledFunctionTable[181973] = bhEne05_Damage_0x1b1ac0; // 0x1b1b5c - g_ps2RecompiledFunctionTable[181974] = bhEne05_Damage_0x1b1ac0; // 0x1b1b60 - g_ps2RecompiledFunctionTable[181975] = bhEne05_Damage_0x1b1ac0; // 0x1b1b64 - g_ps2RecompiledFunctionTable[181976] = bhEne05_Damage_0x1b1ac0; // 0x1b1b68 - g_ps2RecompiledFunctionTable[181977] = bhEne05_Damage_0x1b1ac0; // 0x1b1b6c - g_ps2RecompiledFunctionTable[181978] = bhEne05_Damage_0x1b1ac0; // 0x1b1b70 - g_ps2RecompiledFunctionTable[181979] = bhEne05_Damage_0x1b1ac0; // 0x1b1b74 - g_ps2RecompiledFunctionTable[181980] = bhEne05_Damage_0x1b1ac0; // 0x1b1b78 - g_ps2RecompiledFunctionTable[181981] = bhEne05_Damage_0x1b1ac0; // 0x1b1b7c - g_ps2RecompiledFunctionTable[181982] = bhEne05_Damage_0x1b1ac0; // 0x1b1b80 - g_ps2RecompiledFunctionTable[181983] = bhEne05_Damage_0x1b1ac0; // 0x1b1b84 - g_ps2RecompiledFunctionTable[181984] = bhEne05_Damage_0x1b1ac0; // 0x1b1b88 - g_ps2RecompiledFunctionTable[181985] = bhEne05_Damage_0x1b1ac0; // 0x1b1b8c - g_ps2RecompiledFunctionTable[181986] = bhEne05_Damage_0x1b1ac0; // 0x1b1b90 - g_ps2RecompiledFunctionTable[181987] = bhEne05_Damage_0x1b1ac0; // 0x1b1b94 - g_ps2RecompiledFunctionTable[181988] = bhEne05_Damage_0x1b1ac0; // 0x1b1b98 - g_ps2RecompiledFunctionTable[181989] = bhEne05_Damage_0x1b1ac0; // 0x1b1b9c - g_ps2RecompiledFunctionTable[181990] = bhEne05_Damage_0x1b1ac0; // 0x1b1ba0 - g_ps2RecompiledFunctionTable[181991] = bhEne05_Damage_0x1b1ac0; // 0x1b1ba4 - g_ps2RecompiledFunctionTable[181992] = bhEne05_Damage_0x1b1ac0; // 0x1b1ba8 - g_ps2RecompiledFunctionTable[181993] = bhEne05_Damage_0x1b1ac0; // 0x1b1bac - g_ps2RecompiledFunctionTable[181994] = bhEne05_Damage_0x1b1ac0; // 0x1b1bb0 - g_ps2RecompiledFunctionTable[181995] = bhEne05_Damage_0x1b1ac0; // 0x1b1bb4 - g_ps2RecompiledFunctionTable[181996] = bhEne05_Damage_0x1b1ac0; // 0x1b1bb8 - g_ps2RecompiledFunctionTable[181997] = bhEne05_Damage_0x1b1ac0; // 0x1b1bbc - g_ps2RecompiledFunctionTable[181998] = bhEne05_Damage_0x1b1ac0; // 0x1b1bc0 - g_ps2RecompiledFunctionTable[181999] = bhEne05_Damage_0x1b1ac0; // 0x1b1bc4 - g_ps2RecompiledFunctionTable[182000] = bhEne05_Damage_0x1b1ac0; // 0x1b1bc8 - g_ps2RecompiledFunctionTable[182001] = bhEne05_Damage_0x1b1ac0; // 0x1b1bcc - g_ps2RecompiledFunctionTable[182002] = bhEne05_Damage_0x1b1ac0; // 0x1b1bd0 - g_ps2RecompiledFunctionTable[182003] = bhEne05_Damage_0x1b1ac0; // 0x1b1bd4 - g_ps2RecompiledFunctionTable[182004] = bhEne05_Damage_0x1b1ac0; // 0x1b1bd8 - g_ps2RecompiledFunctionTable[182005] = bhEne05_Damage_0x1b1ac0; // 0x1b1bdc - g_ps2RecompiledFunctionTable[182006] = bhEne05_Damage_0x1b1ac0; // 0x1b1be0 - g_ps2RecompiledFunctionTable[182007] = bhEne05_Damage_0x1b1ac0; // 0x1b1be4 - g_ps2RecompiledFunctionTable[182008] = bhEne05_Damage_0x1b1ac0; // 0x1b1be8 - g_ps2RecompiledFunctionTable[182009] = bhEne05_Damage_0x1b1ac0; // 0x1b1bec - g_ps2RecompiledFunctionTable[182010] = bhEne05_Damage_0x1b1ac0; // 0x1b1bf0 - g_ps2RecompiledFunctionTable[182011] = bhEne05_Damage_0x1b1ac0; // 0x1b1bf4 - g_ps2RecompiledFunctionTable[182012] = bhEne05_Damage_0x1b1ac0; // 0x1b1bf8 - g_ps2RecompiledFunctionTable[182013] = bhEne05_Damage_0x1b1ac0; // 0x1b1bfc - g_ps2RecompiledFunctionTable[182014] = bhEne05_Damage_0x1b1ac0; // 0x1b1c00 - g_ps2RecompiledFunctionTable[182015] = bhEne05_Damage_0x1b1ac0; // 0x1b1c04 - g_ps2RecompiledFunctionTable[182016] = bhEne05_Damage_0x1b1ac0; // 0x1b1c08 - g_ps2RecompiledFunctionTable[182017] = bhEne05_Damage_0x1b1ac0; // 0x1b1c0c - g_ps2RecompiledFunctionTable[182018] = bhEne05_Damage_0x1b1ac0; // 0x1b1c10 - g_ps2RecompiledFunctionTable[182019] = bhEne05_Damage_0x1b1ac0; // 0x1b1c14 - g_ps2RecompiledFunctionTable[182020] = bhEne05_Damage_0x1b1ac0; // 0x1b1c18 - g_ps2RecompiledFunctionTable[182021] = bhEne05_Damage_0x1b1ac0; // 0x1b1c1c - g_ps2RecompiledFunctionTable[182022] = bhEne05_Damage_0x1b1ac0; // 0x1b1c20 - g_ps2RecompiledFunctionTable[182023] = bhEne05_Damage_0x1b1ac0; // 0x1b1c24 - g_ps2RecompiledFunctionTable[182024] = bhEne05_Damage_0x1b1ac0; // 0x1b1c28 - g_ps2RecompiledFunctionTable[182025] = bhEne05_Damage_0x1b1ac0; // 0x1b1c2c - g_ps2RecompiledFunctionTable[182026] = bhEne05_Damage_0x1b1ac0; // 0x1b1c30 - g_ps2RecompiledFunctionTable[182027] = bhEne05_Damage_0x1b1ac0; // 0x1b1c34 - g_ps2RecompiledFunctionTable[182028] = bhEne05_Damage_0x1b1ac0; // 0x1b1c38 - g_ps2RecompiledFunctionTable[182029] = bhEne05_Damage_0x1b1ac0; // 0x1b1c3c - g_ps2RecompiledFunctionTable[182030] = bhEne05_Damage_0x1b1ac0; // 0x1b1c40 - g_ps2RecompiledFunctionTable[182031] = bhEne05_Damage_0x1b1ac0; // 0x1b1c44 - g_ps2RecompiledFunctionTable[182032] = bhEne05_Damage_0x1b1ac0; // 0x1b1c48 - g_ps2RecompiledFunctionTable[182033] = bhEne05_Damage_0x1b1ac0; // 0x1b1c4c - g_ps2RecompiledFunctionTable[182034] = bhEne05_Damage_0x1b1ac0; // 0x1b1c50 - g_ps2RecompiledFunctionTable[182035] = bhEne05_Damage_0x1b1ac0; // 0x1b1c54 - g_ps2RecompiledFunctionTable[182036] = bhEne05_Damage_0x1b1ac0; // 0x1b1c58 - g_ps2RecompiledFunctionTable[182037] = bhEne05_Damage_0x1b1ac0; // 0x1b1c5c - g_ps2RecompiledFunctionTable[182038] = bhEne05_Damage_0x1b1ac0; // 0x1b1c60 - g_ps2RecompiledFunctionTable[182039] = bhEne05_Damage_0x1b1ac0; // 0x1b1c64 - g_ps2RecompiledFunctionTable[182040] = bhEne05_Damage_0x1b1ac0; // 0x1b1c68 - g_ps2RecompiledFunctionTable[182041] = bhEne05_Damage_0x1b1ac0; // 0x1b1c6c - g_ps2RecompiledFunctionTable[182042] = bhEne05_Damage_0x1b1ac0; // 0x1b1c70 - g_ps2RecompiledFunctionTable[182043] = bhEne05_Damage_0x1b1ac0; // 0x1b1c74 - g_ps2RecompiledFunctionTable[182044] = bhEne05_Damage_0x1b1ac0; // 0x1b1c78 - g_ps2RecompiledFunctionTable[182045] = bhEne05_Damage_0x1b1ac0; // 0x1b1c7c - g_ps2RecompiledFunctionTable[182046] = bhEne05_Damage_0x1b1ac0; // 0x1b1c80 - g_ps2RecompiledFunctionTable[182047] = bhEne05_Damage_0x1b1ac0; // 0x1b1c84 - g_ps2RecompiledFunctionTable[182048] = bhEne05_Damage_0x1b1ac0; // 0x1b1c88 - g_ps2RecompiledFunctionTable[182049] = bhEne05_Damage_0x1b1ac0; // 0x1b1c8c - g_ps2RecompiledFunctionTable[182050] = bhEne05_Damage_0x1b1ac0; // 0x1b1c90 - g_ps2RecompiledFunctionTable[182051] = bhEne05_Damage_0x1b1ac0; // 0x1b1c94 - g_ps2RecompiledFunctionTable[182052] = bhEne05_Damage_0x1b1ac0; // 0x1b1c98 - g_ps2RecompiledFunctionTable[182053] = bhEne05_Damage_0x1b1ac0; // 0x1b1c9c - g_ps2RecompiledFunctionTable[182054] = bhEne05_Damage_0x1b1ac0; // 0x1b1ca0 - g_ps2RecompiledFunctionTable[182055] = bhEne05_Damage_0x1b1ac0; // 0x1b1ca4 - g_ps2RecompiledFunctionTable[182056] = bhEne05_Damage_0x1b1ac0; // 0x1b1ca8 - g_ps2RecompiledFunctionTable[182057] = bhEne05_Damage_0x1b1ac0; // 0x1b1cac - g_ps2RecompiledFunctionTable[182058] = bhEne05_Damage_0x1b1ac0; // 0x1b1cb0 - g_ps2RecompiledFunctionTable[182059] = bhEne05_Damage_0x1b1ac0; // 0x1b1cb4 - g_ps2RecompiledFunctionTable[182060] = bhEne05_Damage_0x1b1ac0; // 0x1b1cb8 - g_ps2RecompiledFunctionTable[182061] = bhEne05_Damage_0x1b1ac0; // 0x1b1cbc - g_ps2RecompiledFunctionTable[182062] = bhEne05_Damage_0x1b1ac0; // 0x1b1cc0 - g_ps2RecompiledFunctionTable[182063] = bhEne05_Damage_0x1b1ac0; // 0x1b1cc4 - g_ps2RecompiledFunctionTable[182064] = bhEne05_Damage_0x1b1ac0; // 0x1b1cc8 - g_ps2RecompiledFunctionTable[182065] = bhEne05_Damage_0x1b1ac0; // 0x1b1ccc - g_ps2RecompiledFunctionTable[182066] = bhEne05_Damage_0x1b1ac0; // 0x1b1cd0 - g_ps2RecompiledFunctionTable[182067] = bhEne05_Damage_0x1b1ac0; // 0x1b1cd4 - g_ps2RecompiledFunctionTable[182068] = bhEne05_Damage_0x1b1ac0; // 0x1b1cd8 - g_ps2RecompiledFunctionTable[182069] = bhEne05_Damage_0x1b1ac0; // 0x1b1cdc - g_ps2RecompiledFunctionTable[182070] = bhEne05_Damage_0x1b1ac0; // 0x1b1ce0 - g_ps2RecompiledFunctionTable[182071] = bhEne05_Damage_0x1b1ac0; // 0x1b1ce4 - g_ps2RecompiledFunctionTable[182072] = bhEne05_Damage_0x1b1ac0; // 0x1b1ce8 - g_ps2RecompiledFunctionTable[182073] = bhEne05_Damage_0x1b1ac0; // 0x1b1cec - g_ps2RecompiledFunctionTable[182074] = bhEne05_Damage_0x1b1ac0; // 0x1b1cf0 - g_ps2RecompiledFunctionTable[182075] = bhEne05_Damage_0x1b1ac0; // 0x1b1cf4 - g_ps2RecompiledFunctionTable[182076] = bhEne05_Damage_0x1b1ac0; // 0x1b1cf8 - g_ps2RecompiledFunctionTable[182077] = bhEne05_Damage_0x1b1ac0; // 0x1b1cfc - g_ps2RecompiledFunctionTable[182078] = bhEne05_Damage_0x1b1ac0; // 0x1b1d00 - g_ps2RecompiledFunctionTable[182079] = bhEne05_Damage_0x1b1ac0; // 0x1b1d04 - g_ps2RecompiledFunctionTable[182080] = bhEne05_Damage_0x1b1ac0; // 0x1b1d08 - g_ps2RecompiledFunctionTable[182081] = bhEne05_Damage_0x1b1ac0; // 0x1b1d0c - g_ps2RecompiledFunctionTable[182082] = bhEne05_Damage_0x1b1ac0; // 0x1b1d10 - g_ps2RecompiledFunctionTable[182083] = bhEne05_Damage_0x1b1ac0; // 0x1b1d14 - g_ps2RecompiledFunctionTable[182084] = bhEne05_Damage_0x1b1ac0; // 0x1b1d18 - g_ps2RecompiledFunctionTable[182085] = bhEne05_Damage_0x1b1ac0; // 0x1b1d1c - g_ps2RecompiledFunctionTable[182086] = bhEne05_Damage_0x1b1ac0; // 0x1b1d20 - g_ps2RecompiledFunctionTable[182087] = bhEne05_Damage_0x1b1ac0; // 0x1b1d24 - g_ps2RecompiledFunctionTable[182088] = bhEne05_Damage_0x1b1ac0; // 0x1b1d28 - g_ps2RecompiledFunctionTable[182089] = bhEne05_Damage_0x1b1ac0; // 0x1b1d2c - g_ps2RecompiledFunctionTable[182090] = bhEne05_Damage_0x1b1ac0; // 0x1b1d30 - g_ps2RecompiledFunctionTable[182091] = bhEne05_Damage_0x1b1ac0; // 0x1b1d34 - g_ps2RecompiledFunctionTable[182092] = bhEne05_Damage_0x1b1ac0; // 0x1b1d38 - g_ps2RecompiledFunctionTable[182093] = bhEne05_Damage_0x1b1ac0; // 0x1b1d3c - g_ps2RecompiledFunctionTable[182094] = bhEne05_Damage_0x1b1ac0; // 0x1b1d40 - g_ps2RecompiledFunctionTable[182095] = bhEne05_Damage_0x1b1ac0; // 0x1b1d44 - g_ps2RecompiledFunctionTable[182096] = bhEne05_Damage_0x1b1ac0; // 0x1b1d48 - g_ps2RecompiledFunctionTable[182097] = bhEne05_Damage_0x1b1ac0; // 0x1b1d4c - g_ps2RecompiledFunctionTable[182098] = bhEne05_Damage_0x1b1ac0; // 0x1b1d50 - g_ps2RecompiledFunctionTable[182099] = bhEne05_Damage_0x1b1ac0; // 0x1b1d54 - g_ps2RecompiledFunctionTable[182100] = bhEne05_Damage_0x1b1ac0; // 0x1b1d58 - g_ps2RecompiledFunctionTable[182101] = bhEne05_Damage_0x1b1ac0; // 0x1b1d5c - g_ps2RecompiledFunctionTable[182102] = bhEne05_Damage_0x1b1ac0; // 0x1b1d60 - g_ps2RecompiledFunctionTable[182103] = bhEne05_Damage_0x1b1ac0; // 0x1b1d64 - g_ps2RecompiledFunctionTable[182104] = bhEne05_Damage_0x1b1ac0; // 0x1b1d68 - g_ps2RecompiledFunctionTable[182105] = bhEne05_Damage_0x1b1ac0; // 0x1b1d6c - g_ps2RecompiledFunctionTable[182106] = bhEne05_Damage_0x1b1ac0; // 0x1b1d70 - g_ps2RecompiledFunctionTable[182107] = bhEne05_Damage_0x1b1ac0; // 0x1b1d74 - g_ps2RecompiledFunctionTable[182108] = bhEne05_Damage_0x1b1ac0; // 0x1b1d78 - g_ps2RecompiledFunctionTable[182109] = bhEne05_Damage_0x1b1ac0; // 0x1b1d7c - g_ps2RecompiledFunctionTable[182110] = bhEne05_Damage_0x1b1ac0; // 0x1b1d80 - g_ps2RecompiledFunctionTable[182111] = bhEne05_Damage_0x1b1ac0; // 0x1b1d84 - g_ps2RecompiledFunctionTable[182112] = bhEne05_Damage_0x1b1ac0; // 0x1b1d88 - g_ps2RecompiledFunctionTable[182113] = bhEne05_Damage_0x1b1ac0; // 0x1b1d8c - g_ps2RecompiledFunctionTable[182114] = bhEne05_Damage_0x1b1ac0; // 0x1b1d90 - g_ps2RecompiledFunctionTable[182115] = bhEne05_Damage_0x1b1ac0; // 0x1b1d94 - g_ps2RecompiledFunctionTable[182116] = bhEne05_Damage_0x1b1ac0; // 0x1b1d98 - g_ps2RecompiledFunctionTable[182117] = bhEne05_Damage_0x1b1ac0; // 0x1b1d9c - g_ps2RecompiledFunctionTable[182118] = bhEne05_Damage_0x1b1ac0; // 0x1b1da0 - g_ps2RecompiledFunctionTable[182119] = bhEne05_Damage_0x1b1ac0; // 0x1b1da4 - g_ps2RecompiledFunctionTable[182120] = bhEne05_Damage_0x1b1ac0; // 0x1b1da8 - g_ps2RecompiledFunctionTable[182121] = bhEne05_Damage_0x1b1ac0; // 0x1b1dac - g_ps2RecompiledFunctionTable[182122] = bhEne05_Damage_0x1b1ac0; // 0x1b1db0 - g_ps2RecompiledFunctionTable[182123] = bhEne05_Damage_0x1b1ac0; // 0x1b1db4 - g_ps2RecompiledFunctionTable[182124] = bhEne05_Damage_0x1b1ac0; // 0x1b1db8 - g_ps2RecompiledFunctionTable[182125] = bhEne05_Damage_0x1b1ac0; // 0x1b1dbc - g_ps2RecompiledFunctionTable[182126] = bhEne05_Damage_0x1b1ac0; // 0x1b1dc0 - g_ps2RecompiledFunctionTable[182127] = bhEne05_Damage_0x1b1ac0; // 0x1b1dc4 - g_ps2RecompiledFunctionTable[182128] = bhEne05_Damage_0x1b1ac0; // 0x1b1dc8 - g_ps2RecompiledFunctionTable[182129] = bhEne05_Damage_0x1b1ac0; // 0x1b1dcc - g_ps2RecompiledFunctionTable[182130] = bhEne05_Damage_0x1b1ac0; // 0x1b1dd0 - g_ps2RecompiledFunctionTable[182131] = bhEne05_Damage_0x1b1ac0; // 0x1b1dd4 - g_ps2RecompiledFunctionTable[182132] = bhEne05_Damage_0x1b1ac0; // 0x1b1dd8 - g_ps2RecompiledFunctionTable[182133] = bhEne05_Damage_0x1b1ac0; // 0x1b1ddc - g_ps2RecompiledFunctionTable[182134] = bhEne05_Damage_0x1b1ac0; // 0x1b1de0 - g_ps2RecompiledFunctionTable[182135] = bhEne05_Damage_0x1b1ac0; // 0x1b1de4 - g_ps2RecompiledFunctionTable[182136] = bhEne05_Damage_0x1b1ac0; // 0x1b1de8 - g_ps2RecompiledFunctionTable[182137] = bhEne05_Damage_0x1b1ac0; // 0x1b1dec - g_ps2RecompiledFunctionTable[182138] = bhEne05_Damage_0x1b1ac0; // 0x1b1df0 - g_ps2RecompiledFunctionTable[182139] = bhEne05_Damage_0x1b1ac0; // 0x1b1df4 - g_ps2RecompiledFunctionTable[182140] = bhEne05_Damage_0x1b1ac0; // 0x1b1df8 - g_ps2RecompiledFunctionTable[182141] = bhEne05_Damage_0x1b1ac0; // 0x1b1dfc - g_ps2RecompiledFunctionTable[182142] = bhEne05_Damage_0x1b1ac0; // 0x1b1e00 - g_ps2RecompiledFunctionTable[182143] = bhEne05_Damage_0x1b1ac0; // 0x1b1e04 - g_ps2RecompiledFunctionTable[182144] = bhEne05_Damage_0x1b1ac0; // 0x1b1e08 - g_ps2RecompiledFunctionTable[182145] = bhEne05_Damage_0x1b1ac0; // 0x1b1e0c - g_ps2RecompiledFunctionTable[182146] = bhEne05_Damage_0x1b1ac0; // 0x1b1e10 - g_ps2RecompiledFunctionTable[182147] = bhEne05_Damage_0x1b1ac0; // 0x1b1e14 - g_ps2RecompiledFunctionTable[182148] = bhEne05_Damage_0x1b1ac0; // 0x1b1e18 - g_ps2RecompiledFunctionTable[182149] = bhEne05_Damage_0x1b1ac0; // 0x1b1e1c - g_ps2RecompiledFunctionTable[182150] = bhEne05_Damage_0x1b1ac0; // 0x1b1e20 - g_ps2RecompiledFunctionTable[182151] = bhEne05_Damage_0x1b1ac0; // 0x1b1e24 - g_ps2RecompiledFunctionTable[182152] = bhEne05_Damage_0x1b1ac0; // 0x1b1e28 - g_ps2RecompiledFunctionTable[182153] = bhEne05_Damage_0x1b1ac0; // 0x1b1e2c - g_ps2RecompiledFunctionTable[182154] = bhEne05_Damage_0x1b1ac0; // 0x1b1e30 - g_ps2RecompiledFunctionTable[182155] = bhEne05_Damage_0x1b1ac0; // 0x1b1e34 - g_ps2RecompiledFunctionTable[182156] = bhEne05_Damage_0x1b1ac0; // 0x1b1e38 - g_ps2RecompiledFunctionTable[182157] = bhEne05_Damage_0x1b1ac0; // 0x1b1e3c - g_ps2RecompiledFunctionTable[182158] = bhEne05_Damage_0x1b1ac0; // 0x1b1e40 - g_ps2RecompiledFunctionTable[182159] = bhEne05_Damage_0x1b1ac0; // 0x1b1e44 - g_ps2RecompiledFunctionTable[182160] = bhEne05_Damage_0x1b1ac0; // 0x1b1e48 - g_ps2RecompiledFunctionTable[182161] = bhEne05_Damage_0x1b1ac0; // 0x1b1e4c - g_ps2RecompiledFunctionTable[182162] = bhEne05_Damage_0x1b1ac0; // 0x1b1e50 - g_ps2RecompiledFunctionTable[182163] = bhEne05_Damage_0x1b1ac0; // 0x1b1e54 - g_ps2RecompiledFunctionTable[182164] = bhEne05_Damage_0x1b1ac0; // 0x1b1e58 - g_ps2RecompiledFunctionTable[182165] = bhEne05_Damage_0x1b1ac0; // 0x1b1e5c - g_ps2RecompiledFunctionTable[182166] = bhEne05_Damage_0x1b1ac0; // 0x1b1e60 - g_ps2RecompiledFunctionTable[182167] = bhEne05_Damage_0x1b1ac0; // 0x1b1e64 - g_ps2RecompiledFunctionTable[182168] = bhEne05_Damage_0x1b1ac0; // 0x1b1e68 - g_ps2RecompiledFunctionTable[182169] = bhEne05_Damage_0x1b1ac0; // 0x1b1e6c - g_ps2RecompiledFunctionTable[182170] = bhEne05_Damage_0x1b1ac0; // 0x1b1e70 - g_ps2RecompiledFunctionTable[182171] = bhEne05_Damage_0x1b1ac0; // 0x1b1e74 - g_ps2RecompiledFunctionTable[182172] = bhEne05_Damage_0x1b1ac0; // 0x1b1e78 - g_ps2RecompiledFunctionTable[182173] = bhEne05_Damage_0x1b1ac0; // 0x1b1e7c - g_ps2RecompiledFunctionTable[182174] = bhEne05_Damage_0x1b1ac0; // 0x1b1e80 - g_ps2RecompiledFunctionTable[182175] = bhEne05_Damage_0x1b1ac0; // 0x1b1e84 - g_ps2RecompiledFunctionTable[182176] = bhEne05_Damage_0x1b1ac0; // 0x1b1e88 - g_ps2RecompiledFunctionTable[182177] = bhEne05_Damage_0x1b1ac0; // 0x1b1e8c - g_ps2RecompiledFunctionTable[182178] = bhEne05_Damage_0x1b1ac0; // 0x1b1e90 - g_ps2RecompiledFunctionTable[182179] = bhEne05_Damage_0x1b1ac0; // 0x1b1e94 - g_ps2RecompiledFunctionTable[182180] = bhEne05_Damage_0x1b1ac0; // 0x1b1e98 - g_ps2RecompiledFunctionTable[182181] = bhEne05_Damage_0x1b1ac0; // 0x1b1e9c - g_ps2RecompiledFunctionTable[182182] = bhEne05_Damage_0x1b1ac0; // 0x1b1ea0 - g_ps2RecompiledFunctionTable[182183] = bhEne05_Damage_0x1b1ac0; // 0x1b1ea4 - g_ps2RecompiledFunctionTable[182184] = bhEne05_Damage_0x1b1ac0; // 0x1b1ea8 - g_ps2RecompiledFunctionTable[182185] = bhEne05_Damage_0x1b1ac0; // 0x1b1eac - g_ps2RecompiledFunctionTable[182186] = bhEne05_Damage_0x1b1ac0; // 0x1b1eb0 - g_ps2RecompiledFunctionTable[182187] = bhEne05_Damage_0x1b1ac0; // 0x1b1eb4 - g_ps2RecompiledFunctionTable[182188] = bhEne05_Damage_0x1b1ac0; // 0x1b1eb8 - g_ps2RecompiledFunctionTable[182189] = bhEne05_Damage_0x1b1ac0; // 0x1b1ebc - g_ps2RecompiledFunctionTable[182190] = bhEne05_Damage_0x1b1ac0; // 0x1b1ec0 - g_ps2RecompiledFunctionTable[182191] = bhEne05_Damage_0x1b1ac0; // 0x1b1ec4 - g_ps2RecompiledFunctionTable[182192] = bhEne05_Damage_0x1b1ac0; // 0x1b1ec8 - g_ps2RecompiledFunctionTable[182193] = bhEne05_Damage_0x1b1ac0; // 0x1b1ecc - g_ps2RecompiledFunctionTable[182194] = bhEne05_Damage_0x1b1ac0; // 0x1b1ed0 - g_ps2RecompiledFunctionTable[182195] = bhEne05_Damage_0x1b1ac0; // 0x1b1ed4 - g_ps2RecompiledFunctionTable[182196] = bhEne05_Damage_0x1b1ac0; // 0x1b1ed8 - g_ps2RecompiledFunctionTable[182197] = bhEne05_Damage_0x1b1ac0; // 0x1b1edc - g_ps2RecompiledFunctionTable[182198] = bhEne05_Damage_0x1b1ac0; // 0x1b1ee0 - g_ps2RecompiledFunctionTable[182199] = bhEne05_Damage_0x1b1ac0; // 0x1b1ee4 - g_ps2RecompiledFunctionTable[182200] = bhEne05_Damage_0x1b1ac0; // 0x1b1ee8 - g_ps2RecompiledFunctionTable[182201] = bhEne05_Damage_0x1b1ac0; // 0x1b1eec - g_ps2RecompiledFunctionTable[182202] = bhEne05_Damage_0x1b1ac0; // 0x1b1ef0 - g_ps2RecompiledFunctionTable[182203] = bhEne05_Damage_0x1b1ac0; // 0x1b1ef4 - g_ps2RecompiledFunctionTable[182204] = bhEne05_Damage_0x1b1ac0; // 0x1b1ef8 - g_ps2RecompiledFunctionTable[182205] = bhEne05_Damage_0x1b1ac0; // 0x1b1efc - g_ps2RecompiledFunctionTable[182206] = bhEne05_Damage_0x1b1ac0; // 0x1b1f00 - g_ps2RecompiledFunctionTable[182207] = bhEne05_Damage_0x1b1ac0; // 0x1b1f04 - g_ps2RecompiledFunctionTable[182208] = bhEne05_Damage_0x1b1ac0; // 0x1b1f08 - g_ps2RecompiledFunctionTable[182209] = bhEne05_Damage_0x1b1ac0; // 0x1b1f0c - g_ps2RecompiledFunctionTable[182210] = bhEne05_Damage_0x1b1ac0; // 0x1b1f10 - g_ps2RecompiledFunctionTable[182211] = bhEne05_Damage_0x1b1ac0; // 0x1b1f14 - g_ps2RecompiledFunctionTable[182212] = bhEne05_Damage_0x1b1ac0; // 0x1b1f18 - g_ps2RecompiledFunctionTable[182213] = bhEne05_Damage_0x1b1ac0; // 0x1b1f1c - g_ps2RecompiledFunctionTable[182214] = bhEne05_Damage_0x1b1ac0; // 0x1b1f20 - g_ps2RecompiledFunctionTable[182215] = bhEne05_Damage_0x1b1ac0; // 0x1b1f24 - g_ps2RecompiledFunctionTable[182216] = bhEne05_Damage_0x1b1ac0; // 0x1b1f28 - g_ps2RecompiledFunctionTable[182217] = bhEne05_Damage_0x1b1ac0; // 0x1b1f2c - g_ps2RecompiledFunctionTable[182218] = bhEne05_Damage_0x1b1ac0; // 0x1b1f30 - g_ps2RecompiledFunctionTable[182219] = bhEne05_Damage_0x1b1ac0; // 0x1b1f34 - g_ps2RecompiledFunctionTable[182220] = bhEne05_Damage_0x1b1ac0; // 0x1b1f38 - g_ps2RecompiledFunctionTable[182221] = bhEne05_Damage_0x1b1ac0; // 0x1b1f3c - g_ps2RecompiledFunctionTable[182222] = bhEne05_Damage_0x1b1ac0; // 0x1b1f40 - g_ps2RecompiledFunctionTable[182223] = bhEne05_Damage_0x1b1ac0; // 0x1b1f44 - g_ps2RecompiledFunctionTable[182224] = bhEne05_Damage_0x1b1ac0; // 0x1b1f48 - g_ps2RecompiledFunctionTable[182225] = bhEne05_Damage_0x1b1ac0; // 0x1b1f4c - g_ps2RecompiledFunctionTable[182226] = bhEne05_Damage_0x1b1ac0; // 0x1b1f50 - g_ps2RecompiledFunctionTable[182227] = bhEne05_Damage_0x1b1ac0; // 0x1b1f54 - g_ps2RecompiledFunctionTable[182228] = bhEne05_Damage_0x1b1ac0; // 0x1b1f58 - g_ps2RecompiledFunctionTable[182229] = bhEne05_Damage_0x1b1ac0; // 0x1b1f5c - g_ps2RecompiledFunctionTable[182230] = bhEne05_Damage_0x1b1ac0; // 0x1b1f60 - g_ps2RecompiledFunctionTable[182231] = bhEne05_Damage_0x1b1ac0; // 0x1b1f64 - g_ps2RecompiledFunctionTable[182232] = bhEne05_Damage_0x1b1ac0; // 0x1b1f68 - g_ps2RecompiledFunctionTable[182233] = bhEne05_Damage_0x1b1ac0; // 0x1b1f6c - g_ps2RecompiledFunctionTable[182234] = bhEne05_Damage_0x1b1ac0; // 0x1b1f70 - g_ps2RecompiledFunctionTable[182235] = bhEne05_Damage_0x1b1ac0; // 0x1b1f74 - g_ps2RecompiledFunctionTable[182236] = bhEne05_Damage_0x1b1ac0; // 0x1b1f78 - g_ps2RecompiledFunctionTable[182237] = bhEne05_Damage_0x1b1ac0; // 0x1b1f7c - g_ps2RecompiledFunctionTable[182238] = bhEne05_Damage_0x1b1ac0; // 0x1b1f80 - g_ps2RecompiledFunctionTable[182239] = bhEne05_Damage_0x1b1ac0; // 0x1b1f84 - g_ps2RecompiledFunctionTable[182240] = bhEne05_Damage_0x1b1ac0; // 0x1b1f88 - g_ps2RecompiledFunctionTable[182241] = bhEne05_Damage_0x1b1ac0; // 0x1b1f8c - g_ps2RecompiledFunctionTable[182242] = bhEne05_Damage_0x1b1ac0; // 0x1b1f90 - g_ps2RecompiledFunctionTable[182243] = bhEne05_Damage_0x1b1ac0; // 0x1b1f94 - g_ps2RecompiledFunctionTable[182244] = bhEne05_Damage_0x1b1ac0; // 0x1b1f98 - g_ps2RecompiledFunctionTable[182245] = bhEne05_Damage_0x1b1ac0; // 0x1b1f9c - g_ps2RecompiledFunctionTable[182246] = bhEne05_Damage_0x1b1ac0; // 0x1b1fa0 - g_ps2RecompiledFunctionTable[182247] = bhEne05_Damage_0x1b1ac0; // 0x1b1fa4 - g_ps2RecompiledFunctionTable[182248] = bhEne05_Damage_0x1b1ac0; // 0x1b1fa8 - g_ps2RecompiledFunctionTable[182249] = bhEne05_Damage_0x1b1ac0; // 0x1b1fac - g_ps2RecompiledFunctionTable[182250] = bhEne05_Damage_0x1b1ac0; // 0x1b1fb0 - g_ps2RecompiledFunctionTable[182251] = bhEne05_Damage_0x1b1ac0; // 0x1b1fb4 - g_ps2RecompiledFunctionTable[182252] = bhEne05_Damage_0x1b1ac0; // 0x1b1fb8 - g_ps2RecompiledFunctionTable[182253] = bhEne05_Damage_0x1b1ac0; // 0x1b1fbc - g_ps2RecompiledFunctionTable[182254] = bhEne05_Damage_0x1b1ac0; // 0x1b1fc0 - g_ps2RecompiledFunctionTable[182255] = bhEne05_Damage_0x1b1ac0; // 0x1b1fc4 - g_ps2RecompiledFunctionTable[182256] = bhEne05_Damage_0x1b1ac0; // 0x1b1fc8 - g_ps2RecompiledFunctionTable[182257] = bhEne05_Damage_0x1b1ac0; // 0x1b1fcc - g_ps2RecompiledFunctionTable[182258] = bhEne05_Damage_0x1b1ac0; // 0x1b1fd0 - g_ps2RecompiledFunctionTable[182259] = bhEne05_Damage_0x1b1ac0; // 0x1b1fd4 - g_ps2RecompiledFunctionTable[182260] = bhEne05_Damage_0x1b1ac0; // 0x1b1fd8 - g_ps2RecompiledFunctionTable[182261] = bhEne05_Damage_0x1b1ac0; // 0x1b1fdc - g_ps2RecompiledFunctionTable[182262] = bhEne05_Damage_0x1b1ac0; // 0x1b1fe0 - g_ps2RecompiledFunctionTable[182263] = bhEne05_Damage_0x1b1ac0; // 0x1b1fe4 - g_ps2RecompiledFunctionTable[182264] = bhEne05_Damage_0x1b1ac0; // 0x1b1fe8 - g_ps2RecompiledFunctionTable[182265] = bhEne05_Damage_0x1b1ac0; // 0x1b1fec - g_ps2RecompiledFunctionTable[182266] = bhEne05_Damage_0x1b1ac0; // 0x1b1ff0 - g_ps2RecompiledFunctionTable[182267] = bhEne05_Damage_0x1b1ac0; // 0x1b1ff4 - g_ps2RecompiledFunctionTable[182268] = bhEne05_Damage_0x1b1ac0; // 0x1b1ff8 - g_ps2RecompiledFunctionTable[182269] = bhEne05_Damage_0x1b1ac0; // 0x1b1ffc - g_ps2RecompiledFunctionTable[182270] = bhEne05_Damage_0x1b1ac0; // 0x1b2000 - g_ps2RecompiledFunctionTable[182271] = bhEne05_Damage_0x1b1ac0; // 0x1b2004 - g_ps2RecompiledFunctionTable[182272] = bhEne05_Damage_0x1b1ac0; // 0x1b2008 - g_ps2RecompiledFunctionTable[182273] = bhEne05_Damage_0x1b1ac0; // 0x1b200c - g_ps2RecompiledFunctionTable[182274] = bhEne05_Damage_0x1b1ac0; // 0x1b2010 - g_ps2RecompiledFunctionTable[182275] = bhEne05_Damage_0x1b1ac0; // 0x1b2014 - g_ps2RecompiledFunctionTable[182276] = bhEne05_Damage_0x1b1ac0; // 0x1b2018 - g_ps2RecompiledFunctionTable[182277] = bhEne05_Damage_0x1b1ac0; // 0x1b201c - g_ps2RecompiledFunctionTable[182278] = bhEne05_Damage_0x1b1ac0; // 0x1b2020 - g_ps2RecompiledFunctionTable[182279] = bhEne05_Damage_0x1b1ac0; // 0x1b2024 - g_ps2RecompiledFunctionTable[182280] = bhEne05_Damage_0x1b1ac0; // 0x1b2028 - g_ps2RecompiledFunctionTable[182281] = bhEne05_Damage_0x1b1ac0; // 0x1b202c - g_ps2RecompiledFunctionTable[182282] = bhEne05_Damage_0x1b1ac0; // 0x1b2030 - g_ps2RecompiledFunctionTable[182283] = bhEne05_Damage_0x1b1ac0; // 0x1b2034 - g_ps2RecompiledFunctionTable[182284] = bhEne05_Damage_0x1b1ac0; // 0x1b2038 - g_ps2RecompiledFunctionTable[182285] = bhEne05_Damage_0x1b1ac0; // 0x1b203c - g_ps2RecompiledFunctionTable[182286] = bhEne05_Damage_0x1b1ac0; // 0x1b2040 - g_ps2RecompiledFunctionTable[182287] = bhEne05_Damage_0x1b1ac0; // 0x1b2044 - g_ps2RecompiledFunctionTable[182288] = bhEne05_Damage_0x1b1ac0; // 0x1b2048 - g_ps2RecompiledFunctionTable[182289] = bhEne05_Damage_0x1b1ac0; // 0x1b204c - g_ps2RecompiledFunctionTable[182290] = bhEne05_Damage_0x1b1ac0; // 0x1b2050 - g_ps2RecompiledFunctionTable[182291] = bhEne05_Damage_0x1b1ac0; // 0x1b2054 - g_ps2RecompiledFunctionTable[182292] = bhEne05_Damage_0x1b1ac0; // 0x1b2058 - g_ps2RecompiledFunctionTable[182293] = bhEne05_Damage_0x1b1ac0; // 0x1b205c - g_ps2RecompiledFunctionTable[182294] = bhEne05_Damage_0x1b1ac0; // 0x1b2060 - g_ps2RecompiledFunctionTable[182295] = bhEne05_Damage_0x1b1ac0; // 0x1b2064 - g_ps2RecompiledFunctionTable[182296] = bhEne05_Damage_0x1b1ac0; // 0x1b2068 - g_ps2RecompiledFunctionTable[182297] = bhEne05_Damage_0x1b1ac0; // 0x1b206c - g_ps2RecompiledFunctionTable[182298] = bhEne05_Damage_0x1b1ac0; // 0x1b2070 - g_ps2RecompiledFunctionTable[182299] = bhEne05_Damage_0x1b1ac0; // 0x1b2074 - g_ps2RecompiledFunctionTable[182300] = bhEne05_Damage_0x1b1ac0; // 0x1b2078 - g_ps2RecompiledFunctionTable[182301] = bhEne05_Damage_0x1b1ac0; // 0x1b207c - g_ps2RecompiledFunctionTable[182302] = bhEne05_Damage_0x1b1ac0; // 0x1b2080 - g_ps2RecompiledFunctionTable[182303] = bhEne05_Damage_0x1b1ac0; // 0x1b2084 - g_ps2RecompiledFunctionTable[182304] = bhEne05_Damage_0x1b1ac0; // 0x1b2088 - g_ps2RecompiledFunctionTable[182305] = bhEne05_Damage_0x1b1ac0; // 0x1b208c - g_ps2RecompiledFunctionTable[182306] = bhEne05_Damage_0x1b1ac0; // 0x1b2090 - g_ps2RecompiledFunctionTable[182307] = bhEne05_Damage_0x1b1ac0; // 0x1b2094 - g_ps2RecompiledFunctionTable[182308] = bhEne05_Damage_0x1b1ac0; // 0x1b2098 - g_ps2RecompiledFunctionTable[182309] = bhEne05_Damage_0x1b1ac0; // 0x1b209c - g_ps2RecompiledFunctionTable[182310] = bhEne05_Damage_0x1b1ac0; // 0x1b20a0 - g_ps2RecompiledFunctionTable[182311] = bhEne05_Damage_0x1b1ac0; // 0x1b20a4 - g_ps2RecompiledFunctionTable[182312] = bhEne05_Damage_0x1b1ac0; // 0x1b20a8 - g_ps2RecompiledFunctionTable[182313] = bhEne05_Damage_0x1b1ac0; // 0x1b20ac - g_ps2RecompiledFunctionTable[182314] = bhEne05_Damage_0x1b1ac0; // 0x1b20b0 - g_ps2RecompiledFunctionTable[182315] = bhEne05_Damage_0x1b1ac0; // 0x1b20b4 - g_ps2RecompiledFunctionTable[182316] = bhEne05_Damage_0x1b1ac0; // 0x1b20b8 - g_ps2RecompiledFunctionTable[182317] = bhEne05_Damage_0x1b1ac0; // 0x1b20bc - g_ps2RecompiledFunctionTable[182318] = bhEne05_Damage_0x1b1ac0; // 0x1b20c0 - g_ps2RecompiledFunctionTable[182319] = bhEne05_Damage_0x1b1ac0; // 0x1b20c4 - g_ps2RecompiledFunctionTable[182320] = bhEne05_Damage_0x1b1ac0; // 0x1b20c8 - g_ps2RecompiledFunctionTable[182321] = bhEne05_Damage_0x1b1ac0; // 0x1b20cc - g_ps2RecompiledFunctionTable[182322] = bhEne05_Damage_0x1b1ac0; // 0x1b20d0 - g_ps2RecompiledFunctionTable[182323] = bhEne05_Damage_0x1b1ac0; // 0x1b20d4 - g_ps2RecompiledFunctionTable[182324] = bhEne05_Damage_0x1b1ac0; // 0x1b20d8 - g_ps2RecompiledFunctionTable[182325] = bhEne05_Damage_0x1b1ac0; // 0x1b20dc - g_ps2RecompiledFunctionTable[182326] = bhEne05_Damage_0x1b1ac0; // 0x1b20e0 - g_ps2RecompiledFunctionTable[182327] = bhEne05_Damage_0x1b1ac0; // 0x1b20e4 - g_ps2RecompiledFunctionTable[182328] = bhEne05_Damage_0x1b1ac0; // 0x1b20e8 - g_ps2RecompiledFunctionTable[182330] = bhEne05_DG00_0x1b20f0; // 0x1b20f0 - g_ps2RecompiledFunctionTable[182381] = bhEne05_DG00_0x1b20f0; // 0x1b21bc - g_ps2RecompiledFunctionTable[182408] = bhEne05_DG00_0x1b20f0; // 0x1b2228 - g_ps2RecompiledFunctionTable[182413] = bhEne05_DG00_0x1b20f0; // 0x1b223c - g_ps2RecompiledFunctionTable[182438] = bhEne05_DG01_0x1b22a0; // 0x1b22a0 - g_ps2RecompiledFunctionTable[182442] = bhEne05_DG02_0x1b22b0; // 0x1b22b0 - g_ps2RecompiledFunctionTable[182494] = bhEne05_DG03_0x1b2380; // 0x1b2380 - g_ps2RecompiledFunctionTable[182546] = bhEne05_DG04_0x1b2450; // 0x1b2450 - g_ps2RecompiledFunctionTable[182606] = bhEne05_DG05_0x1b2540; // 0x1b2540 - g_ps2RecompiledFunctionTable[182666] = bhEne05_DG05_0x1b2540; // 0x1b2630 - g_ps2RecompiledFunctionTable[182684] = bhEne05_DG05_0x1b2540; // 0x1b2678 - g_ps2RecompiledFunctionTable[182693] = bhEne05_DG05_0x1b2540; // 0x1b269c - g_ps2RecompiledFunctionTable[182706] = bhEne05_DG05_0x1b2540; // 0x1b26d0 - g_ps2RecompiledFunctionTable[182712] = bhEne05_DG05_0x1b2540; // 0x1b26e8 - g_ps2RecompiledFunctionTable[182724] = bhEne05_DG05_0x1b2540; // 0x1b2718 - g_ps2RecompiledFunctionTable[182737] = bhEne05_DG05_0x1b2540; // 0x1b274c - g_ps2RecompiledFunctionTable[182741] = bhEne05_DG05_0x1b2540; // 0x1b275c - g_ps2RecompiledFunctionTable[182758] = bhEne05_DG05_0x1b2540; // 0x1b27a0 - g_ps2RecompiledFunctionTable[182769] = bhEne05_DG05_0x1b2540; // 0x1b27cc - g_ps2RecompiledFunctionTable[182782] = bhEne05_DG05_0x1b2540; // 0x1b2800 - g_ps2RecompiledFunctionTable[182806] = bhEne05_DG06_0x1b2860; // 0x1b2860 - g_ps2RecompiledFunctionTable[182857] = bhEne05_DG06_0x1b2860; // 0x1b292c - g_ps2RecompiledFunctionTable[182869] = bhEne05_DG06_0x1b2860; // 0x1b295c - g_ps2RecompiledFunctionTable[182883] = bhEne05_DG06_0x1b2860; // 0x1b2994 - g_ps2RecompiledFunctionTable[182894] = bhEne05_DG06_0x1b2860; // 0x1b29c0 - g_ps2RecompiledFunctionTable[182923] = bhEne05_DG06_0x1b2860; // 0x1b2a34 - g_ps2RecompiledFunctionTable[182946] = bhEne05_DG07_0x1b2a90; // 0x1b2a90 - g_ps2RecompiledFunctionTable[183000] = bhEne05_DG07_0x1b2a90; // 0x1b2b68 - g_ps2RecompiledFunctionTable[183030] = bhEne05_DG07_0x1b2a90; // 0x1b2be0 - g_ps2RecompiledFunctionTable[183044] = bhEne05_DG07_0x1b2a90; // 0x1b2c18 - g_ps2RecompiledFunctionTable[183055] = bhEne05_DG07_0x1b2a90; // 0x1b2c44 - g_ps2RecompiledFunctionTable[183084] = bhEne05_DG07_0x1b2a90; // 0x1b2cb8 - g_ps2RecompiledFunctionTable[183106] = bhEne05_DG08_0x1b2d10; // 0x1b2d10 - g_ps2RecompiledFunctionTable[183177] = bhEne05_DG08_0x1b2d10; // 0x1b2e2c - g_ps2RecompiledFunctionTable[183205] = bhEne05_DG08_0x1b2d10; // 0x1b2e9c - g_ps2RecompiledFunctionTable[183220] = bhEne05_DG08_0x1b2d10; // 0x1b2ed8 - g_ps2RecompiledFunctionTable[183234] = bhEne05_DG08_0x1b2d10; // 0x1b2f10 - g_ps2RecompiledFunctionTable[183298] = bhEne05_DG09_0x1b3010; // 0x1b3010 - g_ps2RecompiledFunctionTable[183369] = bhEne05_DG09_0x1b3010; // 0x1b312c - g_ps2RecompiledFunctionTable[183399] = bhEne05_DG09_0x1b3010; // 0x1b31a4 - g_ps2RecompiledFunctionTable[183408] = bhEne05_DG09_0x1b3010; // 0x1b31c8 - g_ps2RecompiledFunctionTable[183423] = bhEne05_DG09_0x1b3010; // 0x1b3204 - g_ps2RecompiledFunctionTable[183437] = bhEne05_DG09_0x1b3010; // 0x1b323c - g_ps2RecompiledFunctionTable[183502] = bhEne05_DG10_0x1b3340; // 0x1b3340 - g_ps2RecompiledFunctionTable[183533] = bhEne05_DG10_0x1b3340; // 0x1b33bc - g_ps2RecompiledFunctionTable[183541] = bhEne05_DG10_0x1b3340; // 0x1b33dc - g_ps2RecompiledFunctionTable[183555] = bhEne05_DG10_0x1b3340; // 0x1b3414 - g_ps2RecompiledFunctionTable[183586] = bhEne05_DG10_0x1b3340; // 0x1b3490 - g_ps2RecompiledFunctionTable[183589] = bhEne05_DG10_0x1b3340; // 0x1b349c - g_ps2RecompiledFunctionTable[183593] = bhEne05_DG10_0x1b3340; // 0x1b34ac - g_ps2RecompiledFunctionTable[183667] = bhEne05_DG10_0x1b3340; // 0x1b35d4 - g_ps2RecompiledFunctionTable[183674] = bhEne05_DG10_0x1b3340; // 0x1b35f0 - g_ps2RecompiledFunctionTable[183704] = bhEne05_DG10_0x1b3340; // 0x1b3668 - g_ps2RecompiledFunctionTable[183719] = bhEne05_DG10_0x1b3340; // 0x1b36a4 - g_ps2RecompiledFunctionTable[183749] = bhEne05_DG10_0x1b3340; // 0x1b371c - g_ps2RecompiledFunctionTable[183763] = bhEne05_DG10_0x1b3340; // 0x1b3754 - g_ps2RecompiledFunctionTable[183781] = bhEne05_DG10_0x1b3340; // 0x1b379c - g_ps2RecompiledFunctionTable[183815] = bhEne05_DG10_0x1b3340; // 0x1b3824 - g_ps2RecompiledFunctionTable[183838] = bhEne05_DG11_0x1b3880; // 0x1b3880 - g_ps2RecompiledFunctionTable[183886] = bhEne05_DG11_0x1b3880; // 0x1b3940 - g_ps2RecompiledFunctionTable[183894] = bhEne05_DG11_0x1b3880; // 0x1b3960 - g_ps2RecompiledFunctionTable[183908] = bhEne05_DG11_0x1b3880; // 0x1b3998 - g_ps2RecompiledFunctionTable[183955] = bhEne05_DG11_0x1b3880; // 0x1b3a54 - g_ps2RecompiledFunctionTable[183970] = bhEne05_DG11_0x1b3880; // 0x1b3a90 - g_ps2RecompiledFunctionTable[183982] = bhEne05_DG11_0x1b3880; // 0x1b3ac0 - g_ps2RecompiledFunctionTable[183996] = bhEne05_DG11_0x1b3880; // 0x1b3af8 - g_ps2RecompiledFunctionTable[184028] = bhEne05_DG11_0x1b3880; // 0x1b3b78 - g_ps2RecompiledFunctionTable[184050] = bhEne05_DG12_0x1b3bd0; // 0x1b3bd0 - g_ps2RecompiledFunctionTable[184078] = bhEne05_DG12_0x1b3bd0; // 0x1b3c40 - g_ps2RecompiledFunctionTable[184087] = bhEne05_DG12_0x1b3bd0; // 0x1b3c64 - g_ps2RecompiledFunctionTable[184178] = bhEne05_DG12_0x1b3bd0; // 0x1b3dd0 - g_ps2RecompiledFunctionTable[184184] = bhEne05_DG12_0x1b3bd0; // 0x1b3de8 - g_ps2RecompiledFunctionTable[184213] = bhEne05_DG12_0x1b3bd0; // 0x1b3e5c - g_ps2RecompiledFunctionTable[184228] = bhEne05_DG12_0x1b3bd0; // 0x1b3e98 - g_ps2RecompiledFunctionTable[184258] = bhEne05_DG12_0x1b3bd0; // 0x1b3f10 - g_ps2RecompiledFunctionTable[184272] = bhEne05_DG12_0x1b3bd0; // 0x1b3f48 - g_ps2RecompiledFunctionTable[184286] = bhEne05_DG12_0x1b3bd0; // 0x1b3f80 - g_ps2RecompiledFunctionTable[184320] = bhEne05_DG12_0x1b3bd0; // 0x1b4008 - g_ps2RecompiledFunctionTable[184346] = bhEne05_DG13_0x1b4070; // 0x1b4070 - g_ps2RecompiledFunctionTable[184384] = bhEne05_DG13_0x1b4070; // 0x1b4108 - g_ps2RecompiledFunctionTable[184392] = bhEne05_DG13_0x1b4070; // 0x1b4128 - g_ps2RecompiledFunctionTable[184435] = bhEne05_DG13_0x1b4070; // 0x1b41d4 - g_ps2RecompiledFunctionTable[184464] = bhEne05_DG13_0x1b4070; // 0x1b4248 - g_ps2RecompiledFunctionTable[184479] = bhEne05_DG13_0x1b4070; // 0x1b4284 - g_ps2RecompiledFunctionTable[184506] = bhEne05_DG13_0x1b4070; // 0x1b42f0 - g_ps2RecompiledFunctionTable[184530] = bhEne05_ChainDamage_0x1b4350; // 0x1b4350 - g_ps2RecompiledFunctionTable[184543] = bhEne05_ChainDamage_0x1b4350; // 0x1b4384 - g_ps2RecompiledFunctionTable[184556] = bhEne05_ChainDamage_0x1b4350; // 0x1b43b8 - g_ps2RecompiledFunctionTable[184565] = bhEne05_ChainDamage_0x1b4350; // 0x1b43dc - g_ps2RecompiledFunctionTable[184572] = bhEne05_ChainDamage_0x1b4350; // 0x1b43f8 - g_ps2RecompiledFunctionTable[184593] = bhEne05_ChainDamage_0x1b4350; // 0x1b444c - g_ps2RecompiledFunctionTable[184610] = bhEne05_Die_0x1b4490; // 0x1b4490 - g_ps2RecompiledFunctionTable[184611] = bhEne05_Die_0x1b4490; // 0x1b4494 - g_ps2RecompiledFunctionTable[184612] = bhEne05_Die_0x1b4490; // 0x1b4498 - g_ps2RecompiledFunctionTable[184613] = bhEne05_Die_0x1b4490; // 0x1b449c - g_ps2RecompiledFunctionTable[184614] = bhEne05_Die_0x1b4490; // 0x1b44a0 - g_ps2RecompiledFunctionTable[184615] = bhEne05_Die_0x1b4490; // 0x1b44a4 - g_ps2RecompiledFunctionTable[184616] = bhEne05_Die_0x1b4490; // 0x1b44a8 - g_ps2RecompiledFunctionTable[184617] = bhEne05_Die_0x1b4490; // 0x1b44ac - g_ps2RecompiledFunctionTable[184618] = bhEne05_DD00_0x1b44b0; // 0x1b44b0 - g_ps2RecompiledFunctionTable[184676] = bhEne05_DD00_0x1b44b0; // 0x1b4598 - g_ps2RecompiledFunctionTable[184708] = bhEne05_DD00_0x1b44b0; // 0x1b4618 - g_ps2RecompiledFunctionTable[184715] = bhEne05_DD00_0x1b44b0; // 0x1b4634 - g_ps2RecompiledFunctionTable[184746] = bhEne05_DD00_0x1b44b0; // 0x1b46b0 - g_ps2RecompiledFunctionTable[184759] = bhEne05_DD00_0x1b44b0; // 0x1b46e4 - g_ps2RecompiledFunctionTable[184774] = bhEne05_DD01_0x1b4720; // 0x1b4720 - g_ps2RecompiledFunctionTable[184835] = bhEne05_DD01_0x1b4720; // 0x1b4814 - g_ps2RecompiledFunctionTable[184885] = bhEne05_DD01_0x1b4720; // 0x1b48dc - g_ps2RecompiledFunctionTable[184892] = bhEne05_DD01_0x1b4720; // 0x1b48f8 - g_ps2RecompiledFunctionTable[184920] = bhEne05_DD01_0x1b4720; // 0x1b4968 - g_ps2RecompiledFunctionTable[184933] = bhEne05_DD01_0x1b4720; // 0x1b499c - g_ps2RecompiledFunctionTable[184946] = bhEne05_DD02_0x1b49d0; // 0x1b49d0 - g_ps2RecompiledFunctionTable[185013] = bhEne05_DD02_0x1b49d0; // 0x1b4adc - g_ps2RecompiledFunctionTable[185041] = bhEne05_DD02_0x1b49d0; // 0x1b4b4c - g_ps2RecompiledFunctionTable[185064] = bhEne05_DD02_0x1b49d0; // 0x1b4ba8 - g_ps2RecompiledFunctionTable[185074] = bhEne05_DD03_0x1b4bd0; // 0x1b4bd0 - g_ps2RecompiledFunctionTable[185141] = bhEne05_DD03_0x1b4bd0; // 0x1b4cdc - g_ps2RecompiledFunctionTable[185171] = bhEne05_DD03_0x1b4bd0; // 0x1b4d54 - g_ps2RecompiledFunctionTable[185180] = bhEne05_DD03_0x1b4bd0; // 0x1b4d78 - g_ps2RecompiledFunctionTable[185203] = bhEne05_DD03_0x1b4bd0; // 0x1b4dd4 - g_ps2RecompiledFunctionTable[185210] = bhEne05_DD04_0x1b4df0; // 0x1b4df0 - g_ps2RecompiledFunctionTable[185244] = bhEne05_DD04_0x1b4df0; // 0x1b4e78 - g_ps2RecompiledFunctionTable[185252] = bhEne05_DD04_0x1b4df0; // 0x1b4e98 - g_ps2RecompiledFunctionTable[185266] = bhEne05_DD04_0x1b4df0; // 0x1b4ed0 - g_ps2RecompiledFunctionTable[185297] = bhEne05_DD04_0x1b4df0; // 0x1b4f4c - g_ps2RecompiledFunctionTable[185300] = bhEne05_DD04_0x1b4df0; // 0x1b4f58 - g_ps2RecompiledFunctionTable[185304] = bhEne05_DD04_0x1b4df0; // 0x1b4f68 - g_ps2RecompiledFunctionTable[185396] = bhEne05_DD04_0x1b4df0; // 0x1b50d8 - g_ps2RecompiledFunctionTable[185402] = bhEne05_DD04_0x1b4df0; // 0x1b50f0 - g_ps2RecompiledFunctionTable[185431] = bhEne05_DD04_0x1b4df0; // 0x1b5164 - g_ps2RecompiledFunctionTable[185446] = bhEne05_DD04_0x1b4df0; // 0x1b51a0 - g_ps2RecompiledFunctionTable[185479] = bhEne05_DD04_0x1b4df0; // 0x1b5224 - g_ps2RecompiledFunctionTable[185491] = bhEne05_DD04_0x1b4df0; // 0x1b5254 - g_ps2RecompiledFunctionTable[185525] = bhEne05_DD04_0x1b4df0; // 0x1b52dc - g_ps2RecompiledFunctionTable[185538] = bhEne05_DD04_0x1b4df0; // 0x1b5310 - g_ps2RecompiledFunctionTable[185554] = bhEne05_DD05_0x1b5350; // 0x1b5350 - g_ps2RecompiledFunctionTable[185599] = bhEne05_DD05_0x1b5350; // 0x1b5404 - g_ps2RecompiledFunctionTable[185607] = bhEne05_DD05_0x1b5350; // 0x1b5424 - g_ps2RecompiledFunctionTable[185625] = bhEne05_DD05_0x1b5350; // 0x1b546c - g_ps2RecompiledFunctionTable[185672] = bhEne05_DD05_0x1b5350; // 0x1b5528 - g_ps2RecompiledFunctionTable[185687] = bhEne05_DD05_0x1b5350; // 0x1b5564 - g_ps2RecompiledFunctionTable[185701] = bhEne05_DD05_0x1b5350; // 0x1b559c - g_ps2RecompiledFunctionTable[185729] = bhEne05_DD05_0x1b5350; // 0x1b560c - g_ps2RecompiledFunctionTable[185742] = bhEne05_DD05_0x1b5350; // 0x1b5640 - g_ps2RecompiledFunctionTable[185758] = bhEne05_DD06_0x1b5680; // 0x1b5680 - g_ps2RecompiledFunctionTable[185807] = bhEne05_DD06_0x1b5680; // 0x1b5744 - g_ps2RecompiledFunctionTable[185814] = bhEne05_DD06_0x1b5680; // 0x1b5760 - g_ps2RecompiledFunctionTable[185828] = bhEne05_DD06_0x1b5680; // 0x1b5798 - g_ps2RecompiledFunctionTable[185856] = bhEne05_DD06_0x1b5680; // 0x1b5808 - g_ps2RecompiledFunctionTable[185869] = bhEne05_DD06_0x1b5680; // 0x1b583c - g_ps2RecompiledFunctionTable[185878] = bhEne05_DD07_0x1b5860; // 0x1b5860 - g_ps2RecompiledFunctionTable[185903] = bhEne05_DD07_0x1b5860; // 0x1b58c4 - g_ps2RecompiledFunctionTable[185912] = bhEne05_DD07_0x1b5860; // 0x1b58e8 - g_ps2RecompiledFunctionTable[186002] = bhEne05_DD07_0x1b5860; // 0x1b5a50 - g_ps2RecompiledFunctionTable[186005] = bhEne05_DD07_0x1b5860; // 0x1b5a5c - g_ps2RecompiledFunctionTable[186016] = bhEne05_DD07_0x1b5860; // 0x1b5a88 - g_ps2RecompiledFunctionTable[186045] = bhEne05_DD07_0x1b5860; // 0x1b5afc - g_ps2RecompiledFunctionTable[186060] = bhEne05_DD07_0x1b5860; // 0x1b5b38 - g_ps2RecompiledFunctionTable[186115] = bhEne05_DD07_0x1b5860; // 0x1b5c14 - g_ps2RecompiledFunctionTable[186149] = bhEne05_DD07_0x1b5860; // 0x1b5c9c - g_ps2RecompiledFunctionTable[186162] = bhEne05_DD07_0x1b5860; // 0x1b5cd0 - g_ps2RecompiledFunctionTable[186170] = bhEne05_DD08_0x1b5cf0; // 0x1b5cf0 - g_ps2RecompiledFunctionTable[186219] = bhEne05_DD08_0x1b5cf0; // 0x1b5db4 - g_ps2RecompiledFunctionTable[186227] = bhEne05_DD08_0x1b5cf0; // 0x1b5dd4 - g_ps2RecompiledFunctionTable[186245] = bhEne05_DD08_0x1b5cf0; // 0x1b5e1c - g_ps2RecompiledFunctionTable[186292] = bhEne05_DD08_0x1b5cf0; // 0x1b5ed8 - g_ps2RecompiledFunctionTable[186307] = bhEne05_DD08_0x1b5cf0; // 0x1b5f14 - g_ps2RecompiledFunctionTable[186321] = bhEne05_DD08_0x1b5cf0; // 0x1b5f4c - g_ps2RecompiledFunctionTable[186349] = bhEne05_DD08_0x1b5cf0; // 0x1b5fbc - g_ps2RecompiledFunctionTable[186362] = bhEne05_DD08_0x1b5cf0; // 0x1b5ff0 - g_ps2RecompiledFunctionTable[186378] = bhEne05_SearchPlayer_0x1b6030; // 0x1b6030 - g_ps2RecompiledFunctionTable[186394] = bhEne05_SearchPlayer_0x1b6030; // 0x1b6070 - g_ps2RecompiledFunctionTable[186402] = bhEne05_SearchPlayer_0x1b6030; // 0x1b6090 - g_ps2RecompiledFunctionTable[186412] = bhEne05_SearchPlayer_0x1b6030; // 0x1b60b8 - g_ps2RecompiledFunctionTable[186438] = bhEne05_SearchPlayer_0x1b6030; // 0x1b6120 - g_ps2RecompiledFunctionTable[186482] = bhEne05_MotionPause_0x1b61d0; // 0x1b61d0 - g_ps2RecompiledFunctionTable[186487] = bhEne05_MotionPause_0x1b61d0; // 0x1b61e4 - g_ps2RecompiledFunctionTable[186502] = bhEne05_SetMotionFlg_0x1b6220; // 0x1b6220 - g_ps2RecompiledFunctionTable[186510] = bhEne05_SetMotionFlg_0x1b6220; // 0x1b6240 - g_ps2RecompiledFunctionTable[186538] = bhEne05_FixedLegPos_0x1b62b0; // 0x1b62b0 - g_ps2RecompiledFunctionTable[186747] = bhEne05_FixedLegPos_0x1b62b0; // 0x1b65f4 - g_ps2RecompiledFunctionTable[186762] = bhEne05_CheckWall_0x1b6630; // 0x1b6630 - g_ps2RecompiledFunctionTable[186796] = bhEne05_CheckWall_0x1b6630; // 0x1b66b8 - g_ps2RecompiledFunctionTable[186816] = bhEne05_CheckWall_0x1b6630; // 0x1b6708 - g_ps2RecompiledFunctionTable[186834] = bhEne05_CheckWall_0x1b6630; // 0x1b6750 - g_ps2RecompiledFunctionTable[186854] = bhEne05_CheckWall_0x1b6630; // 0x1b67a0 - g_ps2RecompiledFunctionTable[186867] = bhEne05_CheckWall_0x1b6630; // 0x1b67d4 - g_ps2RecompiledFunctionTable[186889] = bhEne05_CheckWall_0x1b6630; // 0x1b682c - g_ps2RecompiledFunctionTable[186902] = bhEne05_CheckWall_0x1b6630; // 0x1b6860 - g_ps2RecompiledFunctionTable[186921] = bhEne05_CheckWall_0x1b6630; // 0x1b68ac - g_ps2RecompiledFunctionTable[186939] = bhEne05_CheckWall_0x1b6630; // 0x1b68f4 - g_ps2RecompiledFunctionTable[186958] = bhEne05_CheckWall_0x1b6630; // 0x1b6940 - g_ps2RecompiledFunctionTable[186976] = bhEne05_CheckWall_0x1b6630; // 0x1b6988 - g_ps2RecompiledFunctionTable[186981] = bhEne05_CheckWall_0x1b6630; // 0x1b699c - g_ps2RecompiledFunctionTable[187009] = bhEne05_CheckWall_0x1b6630; // 0x1b6a0c - g_ps2RecompiledFunctionTable[187037] = bhEne05_CheckWall_0x1b6630; // 0x1b6a7c - g_ps2RecompiledFunctionTable[187040] = bhEne05_CheckWall_0x1b6630; // 0x1b6a88 - g_ps2RecompiledFunctionTable[187044] = bhEne05_CheckWall_0x1b6630; // 0x1b6a98 - g_ps2RecompiledFunctionTable[187054] = bhEne05_CheckWall_0x1b6630; // 0x1b6ac0 - g_ps2RecompiledFunctionTable[187070] = bhEne05_CheckLeaningWall_0x1b6b00; // 0x1b6b00 - g_ps2RecompiledFunctionTable[187094] = bhEne05_CheckLeaningWall_0x1b6b00; // 0x1b6b60 - g_ps2RecompiledFunctionTable[187097] = bhEne05_CheckLeaningWall_0x1b6b00; // 0x1b6b6c - g_ps2RecompiledFunctionTable[187101] = bhEne05_CheckLeaningWall_0x1b6b00; // 0x1b6b7c - g_ps2RecompiledFunctionTable[187128] = bhEne05_CheckLeaningWall_0x1b6b00; // 0x1b6be8 - g_ps2RecompiledFunctionTable[187136] = bhEne05_CheckLeaningWall_0x1b6b00; // 0x1b6c08 - g_ps2RecompiledFunctionTable[187138] = bhEne05_CheckLeaningWall_0x1b6b00; // 0x1b6c10 - g_ps2RecompiledFunctionTable[187140] = bhEne05_CheckLeaningWall_0x1b6b00; // 0x1b6c18 - g_ps2RecompiledFunctionTable[187162] = bhEne05_CheckLeaningWall_0x1b6b00; // 0x1b6c70 - g_ps2RecompiledFunctionTable[187165] = bhEne05_CheckLeaningWall_0x1b6b00; // 0x1b6c7c - g_ps2RecompiledFunctionTable[187174] = bhEne05_CheckLeaningWall_0x1b6b00; // 0x1b6ca0 - g_ps2RecompiledFunctionTable[187181] = bhEne05_CheckLeaningWall_0x1b6b00; // 0x1b6cbc - g_ps2RecompiledFunctionTable[187194] = bhEne05_FloorCollision_0x1b6cf0; // 0x1b6cf0 - g_ps2RecompiledFunctionTable[187226] = bhEne05_FloorCollision_0x1b6cf0; // 0x1b6d70 - g_ps2RecompiledFunctionTable[187239] = bhEne05_FloorCollision_0x1b6cf0; // 0x1b6da4 - g_ps2RecompiledFunctionTable[187251] = bhEne05_FloorCollision_0x1b6cf0; // 0x1b6dd4 - g_ps2RecompiledFunctionTable[187253] = bhEne05_FloorCollision_0x1b6cf0; // 0x1b6ddc - g_ps2RecompiledFunctionTable[187298] = bhEne05_SetWeponAtr_0x1b6e90; // 0x1b6e90 - g_ps2RecompiledFunctionTable[187330] = bhEne05_InitDamage_0x1b6f10; // 0x1b6f10 - g_ps2RecompiledFunctionTable[187371] = bhEne05_InitDamage_0x1b6f10; // 0x1b6fb4 - g_ps2RecompiledFunctionTable[187397] = bhEne05_InitDamage_0x1b6f10; // 0x1b701c - g_ps2RecompiledFunctionTable[187406] = bhEne05_InitDamage_0x1b6f10; // 0x1b7040 - g_ps2RecompiledFunctionTable[187414] = bhEne05_InitDamage_0x1b6f10; // 0x1b7060 - g_ps2RecompiledFunctionTable[187430] = bhEne05_InitDamage_0x1b6f10; // 0x1b70a0 - g_ps2RecompiledFunctionTable[187474] = bhEne05_InitDamage_0x1b6f10; // 0x1b7150 - g_ps2RecompiledFunctionTable[187505] = bhEne05_InitDamage_0x1b6f10; // 0x1b71cc - g_ps2RecompiledFunctionTable[187534] = bhEne05_InitDamage_0x1b6f10; // 0x1b7240 - g_ps2RecompiledFunctionTable[187541] = bhEne05_InitDamage_0x1b6f10; // 0x1b725c - g_ps2RecompiledFunctionTable[187552] = bhEne05_InitDamage_0x1b6f10; // 0x1b7288 - g_ps2RecompiledFunctionTable[187599] = bhEne05_InitDamage_0x1b6f10; // 0x1b7344 - g_ps2RecompiledFunctionTable[187660] = bhEne05_InitDamage_0x1b6f10; // 0x1b7438 - g_ps2RecompiledFunctionTable[187672] = bhEne05_InitDamage_0x1b6f10; // 0x1b7468 - g_ps2RecompiledFunctionTable[187679] = bhEne05_InitDamage_0x1b6f10; // 0x1b7484 - g_ps2RecompiledFunctionTable[187690] = bhEne05_InitDamage_0x1b6f10; // 0x1b74b0 - g_ps2RecompiledFunctionTable[187722] = bhEne05_WaterEffect_0x1b7530; // 0x1b7530 - g_ps2RecompiledFunctionTable[187740] = bhEne05_WaterEffect_0x1b7530; // 0x1b7578 - g_ps2RecompiledFunctionTable[187746] = bhEne05_WaterEffect_0x1b7530; // 0x1b7590 - g_ps2RecompiledFunctionTable[187756] = bhEne05_WaterEffect_0x1b7530; // 0x1b75b8 - g_ps2RecompiledFunctionTable[187759] = bhEne05_WaterEffect_0x1b7530; // 0x1b75c4 - g_ps2RecompiledFunctionTable[187763] = bhEne05_WaterEffect_0x1b7530; // 0x1b75d4 - g_ps2RecompiledFunctionTable[187792] = bhEne05_WaterEffect_0x1b7530; // 0x1b7648 - g_ps2RecompiledFunctionTable[187802] = bhEne05_WaterEffect_0x1b7530; // 0x1b7670 - g_ps2RecompiledFunctionTable[187813] = bhEne05_WaterEffect_0x1b7530; // 0x1b769c - g_ps2RecompiledFunctionTable[187872] = bhEne05_WaterEffect_0x1b7530; // 0x1b7788 - g_ps2RecompiledFunctionTable[187894] = bhEne05_PlayerControl_0x1b77e0; // 0x1b77e0 - g_ps2RecompiledFunctionTable[187907] = bhEne05_PlayerControl_0x1b77e0; // 0x1b7814 - g_ps2RecompiledFunctionTable[187920] = bhEne05_PlayerControl_0x1b77e0; // 0x1b7848 - g_ps2RecompiledFunctionTable[187934] = bhEne05_PlayerControl_0x1b77e0; // 0x1b7880 - g_ps2RecompiledFunctionTable[187950] = bhEne05_PlayerControl_0x1b77e0; // 0x1b78c0 - g_ps2RecompiledFunctionTable[187957] = bhEne05_PlayerControl_0x1b77e0; // 0x1b78dc - g_ps2RecompiledFunctionTable[187970] = bhEne05_PlayerControl_0x1b77e0; // 0x1b7910 - g_ps2RecompiledFunctionTable[187986] = bhEne05_PlayerControl_0x1b77e0; // 0x1b7950 - g_ps2RecompiledFunctionTable[187993] = bhEne05_PlayerControl_0x1b77e0; // 0x1b796c - g_ps2RecompiledFunctionTable[188055] = bhEne05_PlayerControl_0x1b77e0; // 0x1b7a64 - g_ps2RecompiledFunctionTable[188090] = bhEne05_CheckJump_0x1b7af0; // 0x1b7af0 - g_ps2RecompiledFunctionTable[188106] = bhEne05_CheckJump_0x1b7af0; // 0x1b7b30 - g_ps2RecompiledFunctionTable[188119] = bhEne05_CheckJump_0x1b7af0; // 0x1b7b64 - g_ps2RecompiledFunctionTable[188196] = bhEne05_CheckJump_0x1b7af0; // 0x1b7c98 - g_ps2RecompiledFunctionTable[188207] = bhEne05_CheckJump_0x1b7af0; // 0x1b7cc4 - g_ps2RecompiledFunctionTable[188223] = bhEne05_CheckJump_0x1b7af0; // 0x1b7d04 - g_ps2RecompiledFunctionTable[188248] = bhEne05_CheckJump_0x1b7af0; // 0x1b7d68 - g_ps2RecompiledFunctionTable[188251] = bhEne05_CheckJump_0x1b7af0; // 0x1b7d74 - g_ps2RecompiledFunctionTable[188263] = bhEne05_CheckJump_0x1b7af0; // 0x1b7da4 - g_ps2RecompiledFunctionTable[188278] = bhEne05_CheckJump_0x1b7af0; // 0x1b7de0 - g_ps2RecompiledFunctionTable[188295] = bhEne05_CheckJump_0x1b7af0; // 0x1b7e24 - g_ps2RecompiledFunctionTable[188328] = bhEne05_CheckJump_0x1b7af0; // 0x1b7ea8 - g_ps2RecompiledFunctionTable[188334] = bhEne05_CheckJump_0x1b7af0; // 0x1b7ec0 - g_ps2RecompiledFunctionTable[188342] = bhEne05_CheckJump_0x1b7af0; // 0x1b7ee0 - g_ps2RecompiledFunctionTable[188363] = bhEne05_CheckJump_0x1b7af0; // 0x1b7f34 - g_ps2RecompiledFunctionTable[188385] = bhEne05_CheckJump_0x1b7af0; // 0x1b7f8c - g_ps2RecompiledFunctionTable[188402] = bhEne05_CheckBackAttack_0x1b7fd0; // 0x1b7fd0 - g_ps2RecompiledFunctionTable[188417] = bhEne05_CheckBackAttack_0x1b7fd0; // 0x1b800c - g_ps2RecompiledFunctionTable[188430] = bhEne05_CheckBackAttack_0x1b7fd0; // 0x1b8040 - g_ps2RecompiledFunctionTable[188440] = bhEne05_CheckBackAttack_0x1b7fd0; // 0x1b8068 - g_ps2RecompiledFunctionTable[188454] = bhEne05_CheckBackAttack_0x1b7fd0; // 0x1b80a0 - g_ps2RecompiledFunctionTable[188460] = bhEne05_CheckBackAttack_0x1b7fd0; // 0x1b80b8 - g_ps2RecompiledFunctionTable[188476] = bhEne05_CheckBackAttack_0x1b7fd0; // 0x1b80f8 - g_ps2RecompiledFunctionTable[188489] = bhEne05_CheckBackAttack_0x1b7fd0; // 0x1b812c - g_ps2RecompiledFunctionTable[188523] = bhEne05_CheckBackAttack_0x1b7fd0; // 0x1b81b4 - g_ps2RecompiledFunctionTable[188529] = bhEne05_CheckBackAttack_0x1b7fd0; // 0x1b81cc - g_ps2RecompiledFunctionTable[188537] = bhEne05_CheckBackAttack_0x1b7fd0; // 0x1b81ec - g_ps2RecompiledFunctionTable[188558] = bhEne05_CheckBackAttack_0x1b7fd0; // 0x1b8240 - g_ps2RecompiledFunctionTable[188581] = bhEne05_CheckBackAttack_0x1b7fd0; // 0x1b829c - g_ps2RecompiledFunctionTable[188594] = bhEne05_CheckHikkaki_0x1b82d0; // 0x1b82d0 - g_ps2RecompiledFunctionTable[188620] = bhEne05_CheckHikkaki_0x1b82d0; // 0x1b8338 - g_ps2RecompiledFunctionTable[188630] = bhEne05_CheckPlyRoute_0x1b8360; // 0x1b8360 - g_ps2RecompiledFunctionTable[188652] = bhEne05_CheckPlyRoute_0x1b8360; // 0x1b83b8 - g_ps2RecompiledFunctionTable[188684] = bhEne05_CheckPlyRoute_0x1b8360; // 0x1b8438 - g_ps2RecompiledFunctionTable[188690] = bhEne05_CheckPlyRoute_0x1b8360; // 0x1b8450 - g_ps2RecompiledFunctionTable[188697] = bhEne05_CheckPlyRoute_0x1b8360; // 0x1b846c - g_ps2RecompiledFunctionTable[188710] = bhEne05_HitMark_0x1b84a0; // 0x1b84a0 - g_ps2RecompiledFunctionTable[188770] = bhEne05_HitMark_0x1b84a0; // 0x1b8590 - g_ps2RecompiledFunctionTable[188786] = bhEne05_HitMark_0x1b84a0; // 0x1b85d0 - g_ps2RecompiledFunctionTable[188802] = bhEne05_HitMark_0x1b84a0; // 0x1b8610 - g_ps2RecompiledFunctionTable[188840] = bhEne05_HitMark_0x1b84a0; // 0x1b86a8 - g_ps2RecompiledFunctionTable[188854] = bhEne05_HitMark_0x1b84a0; // 0x1b86e0 - g_ps2RecompiledFunctionTable[188868] = bhEne05_HitMark_0x1b84a0; // 0x1b8718 - g_ps2RecompiledFunctionTable[188878] = bhEne05_HitMark_0x1b84a0; // 0x1b8740 - g_ps2RecompiledFunctionTable[188894] = bhEne05_HitMark_0x1b84a0; // 0x1b8780 - g_ps2RecompiledFunctionTable[188910] = bhEne05_HitMark_0x1b84a0; // 0x1b87c0 - g_ps2RecompiledFunctionTable[188925] = bhEne05_HitMark_0x1b84a0; // 0x1b87fc - g_ps2RecompiledFunctionTable[188938] = bhEne05_HitMark_0x1b84a0; // 0x1b8830 - g_ps2RecompiledFunctionTable[188951] = bhEne05_HitMark_0x1b84a0; // 0x1b8864 - g_ps2RecompiledFunctionTable[188957] = bhEne05_HitMark_0x1b84a0; // 0x1b887c - g_ps2RecompiledFunctionTable[188982] = bhEne05_HitMark_0x1b84a0; // 0x1b88e0 - g_ps2RecompiledFunctionTable[188998] = bhEne05_HitMark_0x1b84a0; // 0x1b8920 - g_ps2RecompiledFunctionTable[189014] = bhEne05_HitMark_0x1b84a0; // 0x1b8960 - g_ps2RecompiledFunctionTable[189032] = bhEne05_HitMark_0x1b84a0; // 0x1b89a8 - g_ps2RecompiledFunctionTable[189048] = bhEne05_HitMark_0x1b84a0; // 0x1b89e8 - g_ps2RecompiledFunctionTable[189062] = bhEne05_DustEffect_0x1b8a20; // 0x1b8a20 - g_ps2RecompiledFunctionTable[189066] = bhEne05_CallSE_0x1b8a30; // 0x1b8a30 - g_ps2RecompiledFunctionTable[189152] = bhEne05_CallSE_0x1b8a30; // 0x1b8b88 - g_ps2RecompiledFunctionTable[189158] = bhEne05_CallSE_0x1b8a30; // 0x1b8ba0 - g_ps2RecompiledFunctionTable[189176] = bhEne05_CallSE_0x1b8a30; // 0x1b8be8 - g_ps2RecompiledFunctionTable[189182] = bhEne05_CallSE_0x1b8a30; // 0x1b8c00 - g_ps2RecompiledFunctionTable[189190] = bhEne05_CallSE_0x1b8a30; // 0x1b8c20 - g_ps2RecompiledFunctionTable[189204] = bhEne05_CallSE_0x1b8a30; // 0x1b8c58 - g_ps2RecompiledFunctionTable[189210] = bhEne05_CallSE_0x1b8a30; // 0x1b8c70 - g_ps2RecompiledFunctionTable[189224] = bhEne05_CallSE_0x1b8a30; // 0x1b8ca8 - g_ps2RecompiledFunctionTable[189230] = bhEne05_CallSE_0x1b8a30; // 0x1b8cc0 - g_ps2RecompiledFunctionTable[189239] = bhEne05_CallSE_0x1b8a30; // 0x1b8ce4 - g_ps2RecompiledFunctionTable[189249] = bhEne05_CallSE_0x1b8a30; // 0x1b8d0c - g_ps2RecompiledFunctionTable[189262] = bhEne05_CallSE_0x1b8a30; // 0x1b8d40 - g_ps2RecompiledFunctionTable[189267] = bhEne05_CallSE_0x1b8a30; // 0x1b8d54 - g_ps2RecompiledFunctionTable[189280] = bhEne05_CallSE_0x1b8a30; // 0x1b8d88 - g_ps2RecompiledFunctionTable[189285] = bhEne05_CallSE_0x1b8a30; // 0x1b8d9c - g_ps2RecompiledFunctionTable[189298] = bhEne05_CallSE_0x1b8a30; // 0x1b8dd0 - g_ps2RecompiledFunctionTable[189303] = bhEne05_CallSE_0x1b8a30; // 0x1b8de4 - g_ps2RecompiledFunctionTable[189316] = bhEne05_CallSE_0x1b8a30; // 0x1b8e18 - g_ps2RecompiledFunctionTable[189321] = bhEne05_CallSE_0x1b8a30; // 0x1b8e2c - g_ps2RecompiledFunctionTable[189329] = bhEne05_CallSE_0x1b8a30; // 0x1b8e4c - g_ps2RecompiledFunctionTable[189341] = bhEne05_CallSE_0x1b8a30; // 0x1b8e7c - g_ps2RecompiledFunctionTable[189347] = bhEne05_CallSE_0x1b8a30; // 0x1b8e94 - g_ps2RecompiledFunctionTable[189365] = bhEne05_CallSE_0x1b8a30; // 0x1b8edc - g_ps2RecompiledFunctionTable[189370] = bhEne05_CallSE_0x1b8a30; // 0x1b8ef0 - g_ps2RecompiledFunctionTable[189383] = bhEne05_CallSE_0x1b8a30; // 0x1b8f24 - g_ps2RecompiledFunctionTable[189388] = bhEne05_CallSE_0x1b8a30; // 0x1b8f38 - g_ps2RecompiledFunctionTable[189401] = bhEne05_CallSE_0x1b8a30; // 0x1b8f6c - g_ps2RecompiledFunctionTable[189406] = bhEne05_CallSE_0x1b8a30; // 0x1b8f80 - g_ps2RecompiledFunctionTable[189414] = bhEne05s_0x1b8fa0; // 0x1b8fa0 - g_ps2RecompiledFunctionTable[189415] = bhEne05s_0x1b8fa0; // 0x1b8fa4 - g_ps2RecompiledFunctionTable[189416] = bhEne05s_0x1b8fa0; // 0x1b8fa8 - g_ps2RecompiledFunctionTable[189417] = bhEne05s_0x1b8fa0; // 0x1b8fac - g_ps2RecompiledFunctionTable[189418] = bhEne05s_0x1b8fa0; // 0x1b8fb0 - g_ps2RecompiledFunctionTable[189419] = bhEne05s_0x1b8fa0; // 0x1b8fb4 - g_ps2RecompiledFunctionTable[189420] = bhEne05s_0x1b8fa0; // 0x1b8fb8 - g_ps2RecompiledFunctionTable[189421] = bhEne05s_0x1b8fa0; // 0x1b8fbc - g_ps2RecompiledFunctionTable[189422] = bhEne05s_0x1b8fa0; // 0x1b8fc0 - g_ps2RecompiledFunctionTable[189423] = bhEne05s_0x1b8fa0; // 0x1b8fc4 - g_ps2RecompiledFunctionTable[189424] = bhEne05s_0x1b8fa0; // 0x1b8fc8 - g_ps2RecompiledFunctionTable[189425] = bhEne05s_0x1b8fa0; // 0x1b8fcc - g_ps2RecompiledFunctionTable[189426] = bhEne05s_0x1b8fa0; // 0x1b8fd0 - g_ps2RecompiledFunctionTable[189427] = bhEne05s_0x1b8fa0; // 0x1b8fd4 - g_ps2RecompiledFunctionTable[189428] = bhEne05s_0x1b8fa0; // 0x1b8fd8 - g_ps2RecompiledFunctionTable[189429] = bhEne05s_0x1b8fa0; // 0x1b8fdc - g_ps2RecompiledFunctionTable[189430] = bhEne05s_0x1b8fa0; // 0x1b8fe0 - g_ps2RecompiledFunctionTable[189431] = bhEne05s_0x1b8fa0; // 0x1b8fe4 - g_ps2RecompiledFunctionTable[189432] = bhEne05s_0x1b8fa0; // 0x1b8fe8 - g_ps2RecompiledFunctionTable[189433] = bhEne05s_0x1b8fa0; // 0x1b8fec - g_ps2RecompiledFunctionTable[189434] = bhEne05s_0x1b8fa0; // 0x1b8ff0 - g_ps2RecompiledFunctionTable[189435] = bhEne05s_0x1b8fa0; // 0x1b8ff4 - g_ps2RecompiledFunctionTable[189436] = bhEne05s_0x1b8fa0; // 0x1b8ff8 - g_ps2RecompiledFunctionTable[189437] = bhEne05s_0x1b8fa0; // 0x1b8ffc - g_ps2RecompiledFunctionTable[189438] = bhEne05s_0x1b8fa0; // 0x1b9000 - g_ps2RecompiledFunctionTable[189439] = bhEne05s_0x1b8fa0; // 0x1b9004 - g_ps2RecompiledFunctionTable[189440] = bhEne05s_0x1b8fa0; // 0x1b9008 - g_ps2RecompiledFunctionTable[189441] = bhEne05s_0x1b8fa0; // 0x1b900c - g_ps2RecompiledFunctionTable[189442] = bhEne05s_0x1b8fa0; // 0x1b9010 - g_ps2RecompiledFunctionTable[189443] = bhEne05s_0x1b8fa0; // 0x1b9014 - g_ps2RecompiledFunctionTable[189444] = bhEne05s_0x1b8fa0; // 0x1b9018 - g_ps2RecompiledFunctionTable[189445] = bhEne05s_0x1b8fa0; // 0x1b901c - g_ps2RecompiledFunctionTable[189446] = bhEne05s_0x1b8fa0; // 0x1b9020 - g_ps2RecompiledFunctionTable[189447] = bhEne05s_0x1b8fa0; // 0x1b9024 - g_ps2RecompiledFunctionTable[189448] = bhEne05s_0x1b8fa0; // 0x1b9028 - g_ps2RecompiledFunctionTable[189449] = bhEne05s_0x1b8fa0; // 0x1b902c - g_ps2RecompiledFunctionTable[189450] = bhEne05s_0x1b8fa0; // 0x1b9030 - g_ps2RecompiledFunctionTable[189451] = bhEne05s_0x1b8fa0; // 0x1b9034 - g_ps2RecompiledFunctionTable[189452] = bhEne05s_0x1b8fa0; // 0x1b9038 - g_ps2RecompiledFunctionTable[189453] = bhEne05s_0x1b8fa0; // 0x1b903c - g_ps2RecompiledFunctionTable[189454] = bhEne05s_0x1b8fa0; // 0x1b9040 - g_ps2RecompiledFunctionTable[189455] = bhEne05s_0x1b8fa0; // 0x1b9044 - g_ps2RecompiledFunctionTable[189456] = bhEne05s_0x1b8fa0; // 0x1b9048 - g_ps2RecompiledFunctionTable[189457] = bhEne05s_0x1b8fa0; // 0x1b904c - g_ps2RecompiledFunctionTable[189458] = bhEne05s_0x1b8fa0; // 0x1b9050 - g_ps2RecompiledFunctionTable[189459] = bhEne05s_0x1b8fa0; // 0x1b9054 - g_ps2RecompiledFunctionTable[189460] = bhEne05s_0x1b8fa0; // 0x1b9058 - g_ps2RecompiledFunctionTable[189461] = bhEne05s_0x1b8fa0; // 0x1b905c - g_ps2RecompiledFunctionTable[189462] = bhEne05s_0x1b8fa0; // 0x1b9060 - g_ps2RecompiledFunctionTable[189463] = bhEne05s_0x1b8fa0; // 0x1b9064 - g_ps2RecompiledFunctionTable[189464] = bhEne05s_0x1b8fa0; // 0x1b9068 - g_ps2RecompiledFunctionTable[189465] = bhEne05s_0x1b8fa0; // 0x1b906c - g_ps2RecompiledFunctionTable[189466] = bhEne05s_0x1b8fa0; // 0x1b9070 - g_ps2RecompiledFunctionTable[189467] = bhEne05s_0x1b8fa0; // 0x1b9074 - g_ps2RecompiledFunctionTable[189468] = bhEne05s_0x1b8fa0; // 0x1b9078 - g_ps2RecompiledFunctionTable[189469] = bhEne05s_0x1b8fa0; // 0x1b907c - g_ps2RecompiledFunctionTable[189470] = bhEne05s_0x1b8fa0; // 0x1b9080 - g_ps2RecompiledFunctionTable[189471] = bhEne05s_0x1b8fa0; // 0x1b9084 - g_ps2RecompiledFunctionTable[189474] = bhEne05s_Init_0x1b9090; // 0x1b9090 - g_ps2RecompiledFunctionTable[189491] = bhEne05s_Init_0x1b9090; // 0x1b90d4 - g_ps2RecompiledFunctionTable[189498] = bhEne05s_Move_0x1b90f0; // 0x1b90f0 - g_ps2RecompiledFunctionTable[189499] = bhEne05s_Move_0x1b90f0; // 0x1b90f4 - g_ps2RecompiledFunctionTable[189500] = bhEne05s_Move_0x1b90f0; // 0x1b90f8 - g_ps2RecompiledFunctionTable[189501] = bhEne05s_Move_0x1b90f0; // 0x1b90fc - g_ps2RecompiledFunctionTable[189502] = bhEne05s_Move_0x1b90f0; // 0x1b9100 - g_ps2RecompiledFunctionTable[189503] = bhEne05s_Move_0x1b90f0; // 0x1b9104 - g_ps2RecompiledFunctionTable[189504] = bhEne05s_Move_0x1b90f0; // 0x1b9108 - g_ps2RecompiledFunctionTable[189505] = bhEne05s_Move_0x1b90f0; // 0x1b910c - g_ps2RecompiledFunctionTable[189506] = bhEne05s_MV00_0x1b9110; // 0x1b9110 - g_ps2RecompiledFunctionTable[189510] = bhEne05s_MV01_0x1b9120; // 0x1b9120 - g_ps2RecompiledFunctionTable[189540] = bhEne05s_MV01_0x1b9120; // 0x1b9198 - g_ps2RecompiledFunctionTable[189558] = bhEne05s_MV01_0x1b9120; // 0x1b91e0 - g_ps2RecompiledFunctionTable[189561] = bhEne05s_MV01_0x1b9120; // 0x1b91ec - g_ps2RecompiledFunctionTable[189569] = bhEne05s_MV01_0x1b9120; // 0x1b920c - g_ps2RecompiledFunctionTable[189618] = bhEne05s_MV01_0x1b9120; // 0x1b92d0 - g_ps2RecompiledFunctionTable[189621] = bhEne05s_MV01_0x1b9120; // 0x1b92dc - g_ps2RecompiledFunctionTable[189669] = bhEne05s_MV01_0x1b9120; // 0x1b939c - g_ps2RecompiledFunctionTable[189682] = bhEne05s_MV01_0x1b9120; // 0x1b93d0 - g_ps2RecompiledFunctionTable[189686] = bhEne05s_MV01_0x1b9120; // 0x1b93e0 - g_ps2RecompiledFunctionTable[189699] = bhEne05s_MV01_0x1b9120; // 0x1b9414 - g_ps2RecompiledFunctionTable[189718] = bhEne05s_MV01_0x1b9120; // 0x1b9460 - g_ps2RecompiledFunctionTable[189726] = bhEne05s_MV02_0x1b9480; // 0x1b9480 - g_ps2RecompiledFunctionTable[189750] = bhEne05s_MV02_0x1b9480; // 0x1b94e0 - g_ps2RecompiledFunctionTable[189753] = bhEne05s_MV02_0x1b9480; // 0x1b94ec - g_ps2RecompiledFunctionTable[189755] = bhEne05s_MV02_0x1b9480; // 0x1b94f4 - g_ps2RecompiledFunctionTable[189768] = bhEne05s_MV02_0x1b9480; // 0x1b9528 - g_ps2RecompiledFunctionTable[189771] = bhEne05s_MV02_0x1b9480; // 0x1b9534 - g_ps2RecompiledFunctionTable[189784] = bhEne05s_MV02_0x1b9480; // 0x1b9568 - g_ps2RecompiledFunctionTable[189792] = bhEne05s_MV02_0x1b9480; // 0x1b9588 - g_ps2RecompiledFunctionTable[189795] = bhEne05s_MV02_0x1b9480; // 0x1b9594 - g_ps2RecompiledFunctionTable[189797] = bhEne05s_MV02_0x1b9480; // 0x1b959c - g_ps2RecompiledFunctionTable[189809] = bhEne05s_MV02_0x1b9480; // 0x1b95cc - g_ps2RecompiledFunctionTable[189824] = bhEne05s_MV02_0x1b9480; // 0x1b9608 - g_ps2RecompiledFunctionTable[189837] = bhEne05s_MV02_0x1b9480; // 0x1b963c - g_ps2RecompiledFunctionTable[189854] = bhEne05s_MV02_0x1b9480; // 0x1b9680 - g_ps2RecompiledFunctionTable[189862] = bhEne05s_FloorCollision_0x1b96a0; // 0x1b96a0 - g_ps2RecompiledFunctionTable[189873] = bhEne05s_FloorCollision_0x1b96a0; // 0x1b96cc - g_ps2RecompiledFunctionTable[189878] = bhEne05s_FloorCollision_0x1b96a0; // 0x1b96e0 - g_ps2RecompiledFunctionTable[189881] = bhEne05s_FloorCollision_0x1b96a0; // 0x1b96ec - g_ps2RecompiledFunctionTable[189918] = bhEne05s_FloorCollision_0x1b96a0; // 0x1b9780 - g_ps2RecompiledFunctionTable[189928] = bhEne05s_FloorCollision_0x1b96a0; // 0x1b97a8 - g_ps2RecompiledFunctionTable[189945] = bhEne05s_FloorCollision_0x1b96a0; // 0x1b97ec - g_ps2RecompiledFunctionTable[189966] = bhEne06_0x1b9840; // 0x1b9840 - g_ps2RecompiledFunctionTable[189967] = bhEne06_0x1b9840; // 0x1b9844 - g_ps2RecompiledFunctionTable[189968] = bhEne06_0x1b9840; // 0x1b9848 - g_ps2RecompiledFunctionTable[189969] = bhEne06_0x1b9840; // 0x1b984c - g_ps2RecompiledFunctionTable[189970] = bhEne06_0x1b9840; // 0x1b9850 - g_ps2RecompiledFunctionTable[189971] = bhEne06_0x1b9840; // 0x1b9854 - g_ps2RecompiledFunctionTable[189972] = bhEne06_0x1b9840; // 0x1b9858 - g_ps2RecompiledFunctionTable[189973] = bhEne06_0x1b9840; // 0x1b985c - g_ps2RecompiledFunctionTable[189974] = bhEne06_0x1b9840; // 0x1b9860 - g_ps2RecompiledFunctionTable[189975] = bhEne06_0x1b9840; // 0x1b9864 - g_ps2RecompiledFunctionTable[189976] = bhEne06_0x1b9840; // 0x1b9868 - g_ps2RecompiledFunctionTable[189977] = bhEne06_0x1b9840; // 0x1b986c - g_ps2RecompiledFunctionTable[189978] = bhEne06_0x1b9840; // 0x1b9870 - g_ps2RecompiledFunctionTable[189979] = bhEne06_0x1b9840; // 0x1b9874 - g_ps2RecompiledFunctionTable[189980] = bhEne06_0x1b9840; // 0x1b9878 - g_ps2RecompiledFunctionTable[189981] = bhEne06_0x1b9840; // 0x1b987c - g_ps2RecompiledFunctionTable[189982] = bhEne06_0x1b9840; // 0x1b9880 - g_ps2RecompiledFunctionTable[189983] = bhEne06_0x1b9840; // 0x1b9884 - g_ps2RecompiledFunctionTable[189984] = bhEne06_0x1b9840; // 0x1b9888 - g_ps2RecompiledFunctionTable[189985] = bhEne06_0x1b9840; // 0x1b988c - g_ps2RecompiledFunctionTable[189986] = bhEne06_0x1b9840; // 0x1b9890 - g_ps2RecompiledFunctionTable[189987] = bhEne06_0x1b9840; // 0x1b9894 - g_ps2RecompiledFunctionTable[189988] = bhEne06_0x1b9840; // 0x1b9898 - g_ps2RecompiledFunctionTable[189989] = bhEne06_0x1b9840; // 0x1b989c - g_ps2RecompiledFunctionTable[189990] = bhEne06_0x1b9840; // 0x1b98a0 - g_ps2RecompiledFunctionTable[189991] = bhEne06_0x1b9840; // 0x1b98a4 - g_ps2RecompiledFunctionTable[189992] = bhEne06_0x1b9840; // 0x1b98a8 - g_ps2RecompiledFunctionTable[189993] = bhEne06_0x1b9840; // 0x1b98ac - g_ps2RecompiledFunctionTable[189994] = bhEne06_0x1b9840; // 0x1b98b0 - g_ps2RecompiledFunctionTable[189995] = bhEne06_0x1b9840; // 0x1b98b4 - g_ps2RecompiledFunctionTable[189996] = bhEne06_0x1b9840; // 0x1b98b8 - g_ps2RecompiledFunctionTable[189997] = bhEne06_0x1b9840; // 0x1b98bc - g_ps2RecompiledFunctionTable[189998] = bhEne06_0x1b9840; // 0x1b98c0 - g_ps2RecompiledFunctionTable[189999] = bhEne06_0x1b9840; // 0x1b98c4 - g_ps2RecompiledFunctionTable[190000] = bhEne06_0x1b9840; // 0x1b98c8 - g_ps2RecompiledFunctionTable[190001] = bhEne06_0x1b9840; // 0x1b98cc - g_ps2RecompiledFunctionTable[190002] = bhEne06_0x1b9840; // 0x1b98d0 - g_ps2RecompiledFunctionTable[190003] = bhEne06_0x1b9840; // 0x1b98d4 - g_ps2RecompiledFunctionTable[190004] = bhEne06_0x1b9840; // 0x1b98d8 - g_ps2RecompiledFunctionTable[190005] = bhEne06_0x1b9840; // 0x1b98dc - g_ps2RecompiledFunctionTable[190006] = bhEne06_0x1b9840; // 0x1b98e0 - g_ps2RecompiledFunctionTable[190007] = bhEne06_0x1b9840; // 0x1b98e4 - g_ps2RecompiledFunctionTable[190008] = bhEne06_0x1b9840; // 0x1b98e8 - g_ps2RecompiledFunctionTable[190009] = bhEne06_0x1b9840; // 0x1b98ec - g_ps2RecompiledFunctionTable[190010] = bhEne06_0x1b9840; // 0x1b98f0 - g_ps2RecompiledFunctionTable[190011] = bhEne06_0x1b9840; // 0x1b98f4 - g_ps2RecompiledFunctionTable[190012] = bhEne06_0x1b9840; // 0x1b98f8 - g_ps2RecompiledFunctionTable[190013] = bhEne06_0x1b9840; // 0x1b98fc - g_ps2RecompiledFunctionTable[190014] = bhEne06_0x1b9840; // 0x1b9900 - g_ps2RecompiledFunctionTable[190015] = bhEne06_0x1b9840; // 0x1b9904 - g_ps2RecompiledFunctionTable[190016] = bhEne06_0x1b9840; // 0x1b9908 - g_ps2RecompiledFunctionTable[190017] = bhEne06_0x1b9840; // 0x1b990c - g_ps2RecompiledFunctionTable[190018] = bhEne06_0x1b9840; // 0x1b9910 - g_ps2RecompiledFunctionTable[190019] = bhEne06_0x1b9840; // 0x1b9914 - g_ps2RecompiledFunctionTable[190020] = bhEne06_0x1b9840; // 0x1b9918 - g_ps2RecompiledFunctionTable[190021] = bhEne06_0x1b9840; // 0x1b991c - g_ps2RecompiledFunctionTable[190022] = bhEne06_0x1b9840; // 0x1b9920 - g_ps2RecompiledFunctionTable[190023] = bhEne06_0x1b9840; // 0x1b9924 - g_ps2RecompiledFunctionTable[190024] = bhEne06_0x1b9840; // 0x1b9928 - g_ps2RecompiledFunctionTable[190025] = bhEne06_0x1b9840; // 0x1b992c - g_ps2RecompiledFunctionTable[190026] = bhEne06_0x1b9840; // 0x1b9930 - g_ps2RecompiledFunctionTable[190027] = bhEne06_0x1b9840; // 0x1b9934 - g_ps2RecompiledFunctionTable[190028] = bhEne06_0x1b9840; // 0x1b9938 - g_ps2RecompiledFunctionTable[190029] = bhEne06_0x1b9840; // 0x1b993c - g_ps2RecompiledFunctionTable[190030] = bhEne06_0x1b9840; // 0x1b9940 - g_ps2RecompiledFunctionTable[190031] = bhEne06_0x1b9840; // 0x1b9944 - g_ps2RecompiledFunctionTable[190032] = bhEne06_0x1b9840; // 0x1b9948 - g_ps2RecompiledFunctionTable[190033] = bhEne06_0x1b9840; // 0x1b994c - g_ps2RecompiledFunctionTable[190034] = bhEne06_0x1b9840; // 0x1b9950 - g_ps2RecompiledFunctionTable[190035] = bhEne06_0x1b9840; // 0x1b9954 - g_ps2RecompiledFunctionTable[190036] = bhEne06_0x1b9840; // 0x1b9958 - g_ps2RecompiledFunctionTable[190037] = bhEne06_0x1b9840; // 0x1b995c - g_ps2RecompiledFunctionTable[190038] = bhEne06_0x1b9840; // 0x1b9960 - g_ps2RecompiledFunctionTable[190039] = bhEne06_0x1b9840; // 0x1b9964 - g_ps2RecompiledFunctionTable[190040] = bhEne06_0x1b9840; // 0x1b9968 - g_ps2RecompiledFunctionTable[190042] = bhEne06_Init_0x1b9970; // 0x1b9970 - g_ps2RecompiledFunctionTable[190070] = bhEne06_Init_0x1b9970; // 0x1b99e0 - g_ps2RecompiledFunctionTable[190083] = bhEne06_Init_0x1b9970; // 0x1b9a14 - g_ps2RecompiledFunctionTable[190107] = bhEne06_Init_0x1b9970; // 0x1b9a74 - g_ps2RecompiledFunctionTable[190123] = bhEne06_Init_0x1b9970; // 0x1b9ab4 - g_ps2RecompiledFunctionTable[190134] = bhEne06_Init_0x1b9970; // 0x1b9ae0 - g_ps2RecompiledFunctionTable[190149] = bhEne06_Init_0x1b9970; // 0x1b9b1c - g_ps2RecompiledFunctionTable[190161] = bhEne06_Init_0x1b9970; // 0x1b9b4c - g_ps2RecompiledFunctionTable[190181] = bhEne06_Init_0x1b9970; // 0x1b9b9c - g_ps2RecompiledFunctionTable[190187] = bhEne06_Init_0x1b9970; // 0x1b9bb4 - g_ps2RecompiledFunctionTable[190221] = bhEne06_Init_0x1b9970; // 0x1b9c3c - g_ps2RecompiledFunctionTable[190228] = bhEne06_Init_0x1b9970; // 0x1b9c58 - g_ps2RecompiledFunctionTable[190241] = bhEne06_Init_0x1b9970; // 0x1b9c8c - g_ps2RecompiledFunctionTable[190258] = bhEne06_Init_0x1b9970; // 0x1b9cd0 - g_ps2RecompiledFunctionTable[190318] = bhEne06_Brain_0x1b9dc0; // 0x1b9dc0 - g_ps2RecompiledFunctionTable[190319] = bhEne06_Brain_0x1b9dc0; // 0x1b9dc4 - g_ps2RecompiledFunctionTable[190320] = bhEne06_Brain_0x1b9dc0; // 0x1b9dc8 - g_ps2RecompiledFunctionTable[190321] = bhEne06_Brain_0x1b9dc0; // 0x1b9dcc - g_ps2RecompiledFunctionTable[190322] = bhEne06_Brain_0x1b9dc0; // 0x1b9dd0 - g_ps2RecompiledFunctionTable[190323] = bhEne06_Brain_0x1b9dc0; // 0x1b9dd4 - g_ps2RecompiledFunctionTable[190324] = bhEne06_Brain_0x1b9dc0; // 0x1b9dd8 - g_ps2RecompiledFunctionTable[190325] = bhEne06_Brain_0x1b9dc0; // 0x1b9ddc - g_ps2RecompiledFunctionTable[190326] = bhEne06_BR00_0x1b9de0; // 0x1b9de0 - g_ps2RecompiledFunctionTable[190331] = bhEne06_BR00_0x1b9de0; // 0x1b9df4 - g_ps2RecompiledFunctionTable[190387] = bhEne06_BR00_0x1b9de0; // 0x1b9ed4 - g_ps2RecompiledFunctionTable[190401] = bhEne06_BR00_0x1b9de0; // 0x1b9f0c - g_ps2RecompiledFunctionTable[190410] = bhEne06_BR00_0x1b9de0; // 0x1b9f30 - g_ps2RecompiledFunctionTable[190412] = bhEne06_BR00_0x1b9de0; // 0x1b9f38 - g_ps2RecompiledFunctionTable[190438] = bhEne06_Move_0x1b9fa0; // 0x1b9fa0 - g_ps2RecompiledFunctionTable[190439] = bhEne06_Move_0x1b9fa0; // 0x1b9fa4 - g_ps2RecompiledFunctionTable[190440] = bhEne06_Move_0x1b9fa0; // 0x1b9fa8 - g_ps2RecompiledFunctionTable[190441] = bhEne06_Move_0x1b9fa0; // 0x1b9fac - g_ps2RecompiledFunctionTable[190442] = bhEne06_Move_0x1b9fa0; // 0x1b9fb0 - g_ps2RecompiledFunctionTable[190443] = bhEne06_Move_0x1b9fa0; // 0x1b9fb4 - g_ps2RecompiledFunctionTable[190444] = bhEne06_Move_0x1b9fa0; // 0x1b9fb8 - g_ps2RecompiledFunctionTable[190445] = bhEne06_Move_0x1b9fa0; // 0x1b9fbc - g_ps2RecompiledFunctionTable[190446] = bhEne06_Move_0x1b9fa0; // 0x1b9fc0 - g_ps2RecompiledFunctionTable[190447] = bhEne06_Move_0x1b9fa0; // 0x1b9fc4 - g_ps2RecompiledFunctionTable[190448] = bhEne06_Move_0x1b9fa0; // 0x1b9fc8 - g_ps2RecompiledFunctionTable[190449] = bhEne06_Move_0x1b9fa0; // 0x1b9fcc - g_ps2RecompiledFunctionTable[190450] = bhEne06_Move_0x1b9fa0; // 0x1b9fd0 - g_ps2RecompiledFunctionTable[190451] = bhEne06_Move_0x1b9fa0; // 0x1b9fd4 - g_ps2RecompiledFunctionTable[190452] = bhEne06_Move_0x1b9fa0; // 0x1b9fd8 - g_ps2RecompiledFunctionTable[190453] = bhEne06_Move_0x1b9fa0; // 0x1b9fdc - g_ps2RecompiledFunctionTable[190454] = bhEne06_Move_0x1b9fa0; // 0x1b9fe0 - g_ps2RecompiledFunctionTable[190455] = bhEne06_Move_0x1b9fa0; // 0x1b9fe4 - g_ps2RecompiledFunctionTable[190456] = bhEne06_Move_0x1b9fa0; // 0x1b9fe8 - g_ps2RecompiledFunctionTable[190457] = bhEne06_Move_0x1b9fa0; // 0x1b9fec - g_ps2RecompiledFunctionTable[190458] = bhEne06_Move_0x1b9fa0; // 0x1b9ff0 - g_ps2RecompiledFunctionTable[190459] = bhEne06_Move_0x1b9fa0; // 0x1b9ff4 - g_ps2RecompiledFunctionTable[190460] = bhEne06_Move_0x1b9fa0; // 0x1b9ff8 - g_ps2RecompiledFunctionTable[190461] = bhEne06_Move_0x1b9fa0; // 0x1b9ffc - g_ps2RecompiledFunctionTable[190462] = bhEne06_Move_0x1b9fa0; // 0x1ba000 - g_ps2RecompiledFunctionTable[190463] = bhEne06_Move_0x1b9fa0; // 0x1ba004 - g_ps2RecompiledFunctionTable[190464] = bhEne06_Move_0x1b9fa0; // 0x1ba008 - g_ps2RecompiledFunctionTable[190465] = bhEne06_Move_0x1b9fa0; // 0x1ba00c - g_ps2RecompiledFunctionTable[190466] = bhEne06_Move_0x1b9fa0; // 0x1ba010 - g_ps2RecompiledFunctionTable[190467] = bhEne06_Move_0x1b9fa0; // 0x1ba014 - g_ps2RecompiledFunctionTable[190468] = bhEne06_Move_0x1b9fa0; // 0x1ba018 - g_ps2RecompiledFunctionTable[190469] = bhEne06_Move_0x1b9fa0; // 0x1ba01c - g_ps2RecompiledFunctionTable[190470] = bhEne06_Move_0x1b9fa0; // 0x1ba020 - g_ps2RecompiledFunctionTable[190471] = bhEne06_Move_0x1b9fa0; // 0x1ba024 - g_ps2RecompiledFunctionTable[190472] = bhEne06_Move_0x1b9fa0; // 0x1ba028 - g_ps2RecompiledFunctionTable[190473] = bhEne06_Move_0x1b9fa0; // 0x1ba02c - g_ps2RecompiledFunctionTable[190474] = bhEne06_Move_0x1b9fa0; // 0x1ba030 - g_ps2RecompiledFunctionTable[190475] = bhEne06_Move_0x1b9fa0; // 0x1ba034 - g_ps2RecompiledFunctionTable[190476] = bhEne06_Move_0x1b9fa0; // 0x1ba038 - g_ps2RecompiledFunctionTable[190477] = bhEne06_Move_0x1b9fa0; // 0x1ba03c - g_ps2RecompiledFunctionTable[190478] = bhEne06_Move_0x1b9fa0; // 0x1ba040 - g_ps2RecompiledFunctionTable[190479] = bhEne06_Move_0x1b9fa0; // 0x1ba044 - g_ps2RecompiledFunctionTable[190482] = bhEne06_MV00_0x1ba050; // 0x1ba050 - g_ps2RecompiledFunctionTable[190518] = bhEne06_MV00_0x1ba050; // 0x1ba0e0 - g_ps2RecompiledFunctionTable[190531] = bhEne06_MV00_0x1ba050; // 0x1ba114 - g_ps2RecompiledFunctionTable[190543] = bhEne06_MV00_0x1ba050; // 0x1ba144 - g_ps2RecompiledFunctionTable[190561] = bhEne06_MV00_0x1ba050; // 0x1ba18c - g_ps2RecompiledFunctionTable[190574] = bhEne06_MV00_0x1ba050; // 0x1ba1c0 - g_ps2RecompiledFunctionTable[190579] = bhEne06_MV00_0x1ba050; // 0x1ba1d4 - g_ps2RecompiledFunctionTable[190592] = bhEne06_MV00_0x1ba050; // 0x1ba208 - g_ps2RecompiledFunctionTable[190618] = bhEne06_MV01_0x1ba270; // 0x1ba270 - g_ps2RecompiledFunctionTable[190632] = bhEne06_MV01_0x1ba270; // 0x1ba2a8 - g_ps2RecompiledFunctionTable[190703] = bhEne06_MV01_0x1ba270; // 0x1ba3c4 - g_ps2RecompiledFunctionTable[190710] = bhEne06_MV01_0x1ba270; // 0x1ba3e0 - g_ps2RecompiledFunctionTable[190733] = bhEne06_MV01_0x1ba270; // 0x1ba43c - g_ps2RecompiledFunctionTable[190746] = bhEne06_MV01_0x1ba270; // 0x1ba470 - g_ps2RecompiledFunctionTable[190762] = bhEne06_MV01_0x1ba270; // 0x1ba4b0 - g_ps2RecompiledFunctionTable[190769] = bhEne06_MV01_0x1ba270; // 0x1ba4cc - g_ps2RecompiledFunctionTable[190782] = bhEne06_MV01_0x1ba270; // 0x1ba500 - g_ps2RecompiledFunctionTable[190806] = bhEne06_MV02_0x1ba560; // 0x1ba560 - g_ps2RecompiledFunctionTable[190839] = bhEne06_MV02_0x1ba560; // 0x1ba5e4 - g_ps2RecompiledFunctionTable[190852] = bhEne06_MV02_0x1ba560; // 0x1ba618 - g_ps2RecompiledFunctionTable[190855] = bhEne06_MV02_0x1ba560; // 0x1ba624 - g_ps2RecompiledFunctionTable[190877] = bhEne06_MV02_0x1ba560; // 0x1ba67c - g_ps2RecompiledFunctionTable[190890] = bhEne06_MV02_0x1ba560; // 0x1ba6b0 - g_ps2RecompiledFunctionTable[190893] = bhEne06_MV02_0x1ba560; // 0x1ba6bc - g_ps2RecompiledFunctionTable[190913] = bhEne06_MV02_0x1ba560; // 0x1ba70c - g_ps2RecompiledFunctionTable[190933] = bhEne06_MV02_0x1ba560; // 0x1ba75c - g_ps2RecompiledFunctionTable[191003] = bhEne06_MV02_0x1ba560; // 0x1ba874 - g_ps2RecompiledFunctionTable[191011] = bhEne06_MV02_0x1ba560; // 0x1ba894 - g_ps2RecompiledFunctionTable[191035] = bhEne06_MV02_0x1ba560; // 0x1ba8f4 - g_ps2RecompiledFunctionTable[191046] = bhEne06_MV02_0x1ba560; // 0x1ba920 - g_ps2RecompiledFunctionTable[191072] = bhEne06_MV02_0x1ba560; // 0x1ba988 - g_ps2RecompiledFunctionTable[191092] = bhEne06_MV02_0x1ba560; // 0x1ba9d8 - g_ps2RecompiledFunctionTable[191112] = bhEne06_MV02_0x1ba560; // 0x1baa28 - g_ps2RecompiledFunctionTable[191114] = bhEne06_MV02_0x1ba560; // 0x1baa30 - g_ps2RecompiledFunctionTable[191127] = bhEne06_MV02_0x1ba560; // 0x1baa64 - g_ps2RecompiledFunctionTable[191143] = bhEne06_MV02_0x1ba560; // 0x1baaa4 - g_ps2RecompiledFunctionTable[191145] = bhEne06_MV02_0x1ba560; // 0x1baaac - g_ps2RecompiledFunctionTable[191158] = bhEne06_MV02_0x1ba560; // 0x1baae0 - g_ps2RecompiledFunctionTable[191168] = bhEne06_MV02_0x1ba560; // 0x1bab08 - g_ps2RecompiledFunctionTable[191181] = bhEne06_MV02_0x1ba560; // 0x1bab3c - g_ps2RecompiledFunctionTable[191197] = bhEne06_MV02_0x1ba560; // 0x1bab7c - g_ps2RecompiledFunctionTable[191204] = bhEne06_MV02_0x1ba560; // 0x1bab98 - g_ps2RecompiledFunctionTable[191217] = bhEne06_MV02_0x1ba560; // 0x1babcc - g_ps2RecompiledFunctionTable[191226] = bhEne06_MV03_0x1babf0; // 0x1babf0 - g_ps2RecompiledFunctionTable[191260] = bhEne06_MV03_0x1babf0; // 0x1bac78 - g_ps2RecompiledFunctionTable[191273] = bhEne06_MV03_0x1babf0; // 0x1bacac - g_ps2RecompiledFunctionTable[191276] = bhEne06_MV03_0x1babf0; // 0x1bacb8 - g_ps2RecompiledFunctionTable[191298] = bhEne06_MV03_0x1babf0; // 0x1bad10 - g_ps2RecompiledFunctionTable[191311] = bhEne06_MV03_0x1babf0; // 0x1bad44 - g_ps2RecompiledFunctionTable[191314] = bhEne06_MV03_0x1babf0; // 0x1bad50 - g_ps2RecompiledFunctionTable[191342] = bhEne06_MV03_0x1babf0; // 0x1badc0 - g_ps2RecompiledFunctionTable[191411] = bhEne06_MV03_0x1babf0; // 0x1baed4 - g_ps2RecompiledFunctionTable[191414] = bhEne06_MV03_0x1babf0; // 0x1baee0 - g_ps2RecompiledFunctionTable[191440] = bhEne06_MV03_0x1babf0; // 0x1baf48 - g_ps2RecompiledFunctionTable[191464] = bhEne06_MV03_0x1babf0; // 0x1bafa8 - g_ps2RecompiledFunctionTable[191467] = bhEne06_MV03_0x1babf0; // 0x1bafb4 - g_ps2RecompiledFunctionTable[191485] = bhEne06_MV03_0x1babf0; // 0x1baffc - g_ps2RecompiledFunctionTable[191487] = bhEne06_MV03_0x1babf0; // 0x1bb004 - g_ps2RecompiledFunctionTable[191500] = bhEne06_MV03_0x1babf0; // 0x1bb038 - g_ps2RecompiledFunctionTable[191511] = bhEne06_MV03_0x1babf0; // 0x1bb064 - g_ps2RecompiledFunctionTable[191530] = bhEne06_MV03_0x1babf0; // 0x1bb0b0 - g_ps2RecompiledFunctionTable[191543] = bhEne06_MV03_0x1babf0; // 0x1bb0e4 - g_ps2RecompiledFunctionTable[191559] = bhEne06_MV03_0x1babf0; // 0x1bb124 - g_ps2RecompiledFunctionTable[191566] = bhEne06_MV03_0x1babf0; // 0x1bb140 - g_ps2RecompiledFunctionTable[191579] = bhEne06_MV03_0x1babf0; // 0x1bb174 - g_ps2RecompiledFunctionTable[191590] = bhEne06_MV04_0x1bb1a0; // 0x1bb1a0 - g_ps2RecompiledFunctionTable[191594] = bhEne06_MV05_0x1bb1b0; // 0x1bb1b0 - g_ps2RecompiledFunctionTable[191616] = bhEne06_MV05_0x1bb1b0; // 0x1bb208 - g_ps2RecompiledFunctionTable[191629] = bhEne06_MV05_0x1bb1b0; // 0x1bb23c - g_ps2RecompiledFunctionTable[191651] = bhEne06_MV05_0x1bb1b0; // 0x1bb294 - g_ps2RecompiledFunctionTable[191749] = bhEne06_MV05_0x1bb1b0; // 0x1bb41c - g_ps2RecompiledFunctionTable[191756] = bhEne06_MV05_0x1bb1b0; // 0x1bb438 - g_ps2RecompiledFunctionTable[191778] = bhEne06_MV06_0x1bb490; // 0x1bb490 - g_ps2RecompiledFunctionTable[191782] = bhEne06_MV07_0x1bb4a0; // 0x1bb4a0 - g_ps2RecompiledFunctionTable[191786] = bhEne06_MV08_0x1bb4b0; // 0x1bb4b0 - g_ps2RecompiledFunctionTable[191895] = bhEne06_MV08_0x1bb4b0; // 0x1bb664 - g_ps2RecompiledFunctionTable[191914] = bhEne06_MV09_0x1bb6b0; // 0x1bb6b0 - g_ps2RecompiledFunctionTable[191956] = bhEne06_MV09_0x1bb6b0; // 0x1bb758 - g_ps2RecompiledFunctionTable[191969] = bhEne06_MV09_0x1bb6b0; // 0x1bb78c - g_ps2RecompiledFunctionTable[191982] = bhEne06_MV09_0x1bb6b0; // 0x1bb7c0 - g_ps2RecompiledFunctionTable[191996] = bhEne06_MV09_0x1bb6b0; // 0x1bb7f8 - g_ps2RecompiledFunctionTable[192003] = bhEne06_MV09_0x1bb6b0; // 0x1bb814 - g_ps2RecompiledFunctionTable[192019] = bhEne06_MV09_0x1bb6b0; // 0x1bb854 - g_ps2RecompiledFunctionTable[192021] = bhEne06_MV09_0x1bb6b0; // 0x1bb85c - g_ps2RecompiledFunctionTable[192046] = bhEne06_MV09_0x1bb6b0; // 0x1bb8c0 - g_ps2RecompiledFunctionTable[192052] = bhEne06_MV09_0x1bb6b0; // 0x1bb8d8 - g_ps2RecompiledFunctionTable[192056] = bhEne06_MV09_0x1bb6b0; // 0x1bb8e8 - g_ps2RecompiledFunctionTable[192105] = bhEne06_MV09_0x1bb6b0; // 0x1bb9ac - g_ps2RecompiledFunctionTable[192107] = bhEne06_MV09_0x1bb6b0; // 0x1bb9b4 - g_ps2RecompiledFunctionTable[192120] = bhEne06_MV09_0x1bb6b0; // 0x1bb9e8 - g_ps2RecompiledFunctionTable[192126] = bhEne06_MV10_0x1bba00; // 0x1bba00 - g_ps2RecompiledFunctionTable[192168] = bhEne06_MV10_0x1bba00; // 0x1bbaa8 - g_ps2RecompiledFunctionTable[192181] = bhEne06_MV10_0x1bba00; // 0x1bbadc - g_ps2RecompiledFunctionTable[192194] = bhEne06_MV10_0x1bba00; // 0x1bbb10 - g_ps2RecompiledFunctionTable[192208] = bhEne06_MV10_0x1bba00; // 0x1bbb48 - g_ps2RecompiledFunctionTable[192215] = bhEne06_MV10_0x1bba00; // 0x1bbb64 - g_ps2RecompiledFunctionTable[192231] = bhEne06_MV10_0x1bba00; // 0x1bbba4 - g_ps2RecompiledFunctionTable[192233] = bhEne06_MV10_0x1bba00; // 0x1bbbac - g_ps2RecompiledFunctionTable[192258] = bhEne06_MV10_0x1bba00; // 0x1bbc10 - g_ps2RecompiledFunctionTable[192264] = bhEne06_MV10_0x1bba00; // 0x1bbc28 - g_ps2RecompiledFunctionTable[192268] = bhEne06_MV10_0x1bba00; // 0x1bbc38 - g_ps2RecompiledFunctionTable[192317] = bhEne06_MV10_0x1bba00; // 0x1bbcfc - g_ps2RecompiledFunctionTable[192319] = bhEne06_MV10_0x1bba00; // 0x1bbd04 - g_ps2RecompiledFunctionTable[192332] = bhEne06_MV10_0x1bba00; // 0x1bbd38 - g_ps2RecompiledFunctionTable[192338] = bhEne06_Nage_0x1bbd50; // 0x1bbd50 - g_ps2RecompiledFunctionTable[192339] = bhEne06_Nage_0x1bbd50; // 0x1bbd54 - g_ps2RecompiledFunctionTable[192340] = bhEne06_Nage_0x1bbd50; // 0x1bbd58 - g_ps2RecompiledFunctionTable[192341] = bhEne06_Nage_0x1bbd50; // 0x1bbd5c - g_ps2RecompiledFunctionTable[192342] = bhEne06_Nage_0x1bbd50; // 0x1bbd60 - g_ps2RecompiledFunctionTable[192343] = bhEne06_Nage_0x1bbd50; // 0x1bbd64 - g_ps2RecompiledFunctionTable[192344] = bhEne06_Nage_0x1bbd50; // 0x1bbd68 - g_ps2RecompiledFunctionTable[192345] = bhEne06_Nage_0x1bbd50; // 0x1bbd6c - g_ps2RecompiledFunctionTable[192346] = bhEne06_NG00_0x1bbd70; // 0x1bbd70 - g_ps2RecompiledFunctionTable[192390] = bhEne06_NG00_0x1bbd70; // 0x1bbe20 - g_ps2RecompiledFunctionTable[192417] = bhEne06_NG00_0x1bbd70; // 0x1bbe8c - g_ps2RecompiledFunctionTable[192427] = bhEne06_NG00_0x1bbd70; // 0x1bbeb4 - g_ps2RecompiledFunctionTable[192453] = bhEne06_NG00_0x1bbd70; // 0x1bbf1c - g_ps2RecompiledFunctionTable[192485] = bhEne06_NG00_0x1bbd70; // 0x1bbf9c - g_ps2RecompiledFunctionTable[192491] = bhEne06_NG00_0x1bbd70; // 0x1bbfb4 - g_ps2RecompiledFunctionTable[192497] = bhEne06_NG00_0x1bbd70; // 0x1bbfcc - g_ps2RecompiledFunctionTable[192500] = bhEne06_NG00_0x1bbd70; // 0x1bbfd8 - g_ps2RecompiledFunctionTable[192543] = bhEne06_NG00_0x1bbd70; // 0x1bc084 - g_ps2RecompiledFunctionTable[192556] = bhEne06_NG00_0x1bbd70; // 0x1bc0b8 - g_ps2RecompiledFunctionTable[192562] = bhEne06_NG00_0x1bbd70; // 0x1bc0d0 - g_ps2RecompiledFunctionTable[192568] = bhEne06_NG00_0x1bbd70; // 0x1bc0e8 - g_ps2RecompiledFunctionTable[192571] = bhEne06_NG00_0x1bbd70; // 0x1bc0f4 - g_ps2RecompiledFunctionTable[192610] = bhEne06_NG00_0x1bbd70; // 0x1bc190 - g_ps2RecompiledFunctionTable[192612] = bhEne06_NG00_0x1bbd70; // 0x1bc198 - g_ps2RecompiledFunctionTable[192625] = bhEne06_NG00_0x1bbd70; // 0x1bc1cc - g_ps2RecompiledFunctionTable[192630] = bhEne06_NG00_0x1bbd70; // 0x1bc1e0 - g_ps2RecompiledFunctionTable[192654] = bhEne06_NG00_0x1bbd70; // 0x1bc240 - g_ps2RecompiledFunctionTable[192662] = bhEne06_Damage_0x1bc260; // 0x1bc260 - g_ps2RecompiledFunctionTable[192663] = bhEne06_Damage_0x1bc260; // 0x1bc264 - g_ps2RecompiledFunctionTable[192664] = bhEne06_Damage_0x1bc260; // 0x1bc268 - g_ps2RecompiledFunctionTable[192665] = bhEne06_Damage_0x1bc260; // 0x1bc26c - g_ps2RecompiledFunctionTable[192666] = bhEne06_Damage_0x1bc260; // 0x1bc270 - g_ps2RecompiledFunctionTable[192667] = bhEne06_Damage_0x1bc260; // 0x1bc274 - g_ps2RecompiledFunctionTable[192668] = bhEne06_Damage_0x1bc260; // 0x1bc278 - g_ps2RecompiledFunctionTable[192669] = bhEne06_Damage_0x1bc260; // 0x1bc27c - g_ps2RecompiledFunctionTable[192670] = bhEne06_Damage_0x1bc260; // 0x1bc280 - g_ps2RecompiledFunctionTable[192671] = bhEne06_Damage_0x1bc260; // 0x1bc284 - g_ps2RecompiledFunctionTable[192672] = bhEne06_Damage_0x1bc260; // 0x1bc288 - g_ps2RecompiledFunctionTable[192673] = bhEne06_Damage_0x1bc260; // 0x1bc28c - g_ps2RecompiledFunctionTable[192674] = bhEne06_Damage_0x1bc260; // 0x1bc290 - g_ps2RecompiledFunctionTable[192675] = bhEne06_Damage_0x1bc260; // 0x1bc294 - g_ps2RecompiledFunctionTable[192676] = bhEne06_Damage_0x1bc260; // 0x1bc298 - g_ps2RecompiledFunctionTable[192677] = bhEne06_Damage_0x1bc260; // 0x1bc29c - g_ps2RecompiledFunctionTable[192678] = bhEne06_Damage_0x1bc260; // 0x1bc2a0 - g_ps2RecompiledFunctionTable[192679] = bhEne06_Damage_0x1bc260; // 0x1bc2a4 - g_ps2RecompiledFunctionTable[192680] = bhEne06_Damage_0x1bc260; // 0x1bc2a8 - g_ps2RecompiledFunctionTable[192681] = bhEne06_Damage_0x1bc260; // 0x1bc2ac - g_ps2RecompiledFunctionTable[192682] = bhEne06_Damage_0x1bc260; // 0x1bc2b0 - g_ps2RecompiledFunctionTable[192683] = bhEne06_Damage_0x1bc260; // 0x1bc2b4 - g_ps2RecompiledFunctionTable[192684] = bhEne06_Damage_0x1bc260; // 0x1bc2b8 - g_ps2RecompiledFunctionTable[192685] = bhEne06_Damage_0x1bc260; // 0x1bc2bc - g_ps2RecompiledFunctionTable[192686] = bhEne06_Damage_0x1bc260; // 0x1bc2c0 - g_ps2RecompiledFunctionTable[192687] = bhEne06_Damage_0x1bc260; // 0x1bc2c4 - g_ps2RecompiledFunctionTable[192688] = bhEne06_Damage_0x1bc260; // 0x1bc2c8 - g_ps2RecompiledFunctionTable[192689] = bhEne06_Damage_0x1bc260; // 0x1bc2cc - g_ps2RecompiledFunctionTable[192690] = bhEne06_Damage_0x1bc260; // 0x1bc2d0 - g_ps2RecompiledFunctionTable[192691] = bhEne06_Damage_0x1bc260; // 0x1bc2d4 - g_ps2RecompiledFunctionTable[192692] = bhEne06_Damage_0x1bc260; // 0x1bc2d8 - g_ps2RecompiledFunctionTable[192693] = bhEne06_Damage_0x1bc260; // 0x1bc2dc - g_ps2RecompiledFunctionTable[192694] = bhEne06_Damage_0x1bc260; // 0x1bc2e0 - g_ps2RecompiledFunctionTable[192695] = bhEne06_Damage_0x1bc260; // 0x1bc2e4 - g_ps2RecompiledFunctionTable[192696] = bhEne06_Damage_0x1bc260; // 0x1bc2e8 - g_ps2RecompiledFunctionTable[192697] = bhEne06_Damage_0x1bc260; // 0x1bc2ec - g_ps2RecompiledFunctionTable[192698] = bhEne06_Damage_0x1bc260; // 0x1bc2f0 - g_ps2RecompiledFunctionTable[192699] = bhEne06_Damage_0x1bc260; // 0x1bc2f4 - g_ps2RecompiledFunctionTable[192700] = bhEne06_Damage_0x1bc260; // 0x1bc2f8 - g_ps2RecompiledFunctionTable[192701] = bhEne06_Damage_0x1bc260; // 0x1bc2fc - g_ps2RecompiledFunctionTable[192702] = bhEne06_Damage_0x1bc260; // 0x1bc300 - g_ps2RecompiledFunctionTable[192703] = bhEne06_Damage_0x1bc260; // 0x1bc304 - g_ps2RecompiledFunctionTable[192704] = bhEne06_Damage_0x1bc260; // 0x1bc308 - g_ps2RecompiledFunctionTable[192705] = bhEne06_Damage_0x1bc260; // 0x1bc30c - g_ps2RecompiledFunctionTable[192706] = bhEne06_Damage_0x1bc260; // 0x1bc310 - g_ps2RecompiledFunctionTable[192707] = bhEne06_Damage_0x1bc260; // 0x1bc314 - g_ps2RecompiledFunctionTable[192708] = bhEne06_Damage_0x1bc260; // 0x1bc318 - g_ps2RecompiledFunctionTable[192709] = bhEne06_Damage_0x1bc260; // 0x1bc31c - g_ps2RecompiledFunctionTable[192710] = bhEne06_Damage_0x1bc260; // 0x1bc320 - g_ps2RecompiledFunctionTable[192711] = bhEne06_Damage_0x1bc260; // 0x1bc324 - g_ps2RecompiledFunctionTable[192712] = bhEne06_Damage_0x1bc260; // 0x1bc328 - g_ps2RecompiledFunctionTable[192713] = bhEne06_Damage_0x1bc260; // 0x1bc32c - g_ps2RecompiledFunctionTable[192714] = bhEne06_Damage_0x1bc260; // 0x1bc330 - g_ps2RecompiledFunctionTable[192715] = bhEne06_Damage_0x1bc260; // 0x1bc334 - g_ps2RecompiledFunctionTable[192716] = bhEne06_Damage_0x1bc260; // 0x1bc338 - g_ps2RecompiledFunctionTable[192717] = bhEne06_Damage_0x1bc260; // 0x1bc33c - g_ps2RecompiledFunctionTable[192718] = bhEne06_Damage_0x1bc260; // 0x1bc340 - g_ps2RecompiledFunctionTable[192719] = bhEne06_Damage_0x1bc260; // 0x1bc344 - g_ps2RecompiledFunctionTable[192720] = bhEne06_Damage_0x1bc260; // 0x1bc348 - g_ps2RecompiledFunctionTable[192721] = bhEne06_Damage_0x1bc260; // 0x1bc34c - g_ps2RecompiledFunctionTable[192722] = bhEne06_Damage_0x1bc260; // 0x1bc350 - g_ps2RecompiledFunctionTable[192723] = bhEne06_Damage_0x1bc260; // 0x1bc354 - g_ps2RecompiledFunctionTable[192724] = bhEne06_Damage_0x1bc260; // 0x1bc358 - g_ps2RecompiledFunctionTable[192725] = bhEne06_Damage_0x1bc260; // 0x1bc35c - g_ps2RecompiledFunctionTable[192726] = bhEne06_Damage_0x1bc260; // 0x1bc360 - g_ps2RecompiledFunctionTable[192727] = bhEne06_Damage_0x1bc260; // 0x1bc364 - g_ps2RecompiledFunctionTable[192728] = bhEne06_Damage_0x1bc260; // 0x1bc368 - g_ps2RecompiledFunctionTable[192729] = bhEne06_Damage_0x1bc260; // 0x1bc36c - g_ps2RecompiledFunctionTable[192730] = bhEne06_Damage_0x1bc260; // 0x1bc370 - g_ps2RecompiledFunctionTable[192731] = bhEne06_Damage_0x1bc260; // 0x1bc374 - g_ps2RecompiledFunctionTable[192732] = bhEne06_Damage_0x1bc260; // 0x1bc378 - g_ps2RecompiledFunctionTable[192733] = bhEne06_Damage_0x1bc260; // 0x1bc37c - g_ps2RecompiledFunctionTable[192734] = bhEne06_Damage_0x1bc260; // 0x1bc380 - g_ps2RecompiledFunctionTable[192735] = bhEne06_Damage_0x1bc260; // 0x1bc384 - g_ps2RecompiledFunctionTable[192736] = bhEne06_Damage_0x1bc260; // 0x1bc388 - g_ps2RecompiledFunctionTable[192737] = bhEne06_Damage_0x1bc260; // 0x1bc38c - g_ps2RecompiledFunctionTable[192738] = bhEne06_Damage_0x1bc260; // 0x1bc390 - g_ps2RecompiledFunctionTable[192739] = bhEne06_Damage_0x1bc260; // 0x1bc394 - g_ps2RecompiledFunctionTable[192740] = bhEne06_Damage_0x1bc260; // 0x1bc398 - g_ps2RecompiledFunctionTable[192741] = bhEne06_Damage_0x1bc260; // 0x1bc39c - g_ps2RecompiledFunctionTable[192742] = bhEne06_Damage_0x1bc260; // 0x1bc3a0 - g_ps2RecompiledFunctionTable[192743] = bhEne06_Damage_0x1bc260; // 0x1bc3a4 - g_ps2RecompiledFunctionTable[192744] = bhEne06_Damage_0x1bc260; // 0x1bc3a8 - g_ps2RecompiledFunctionTable[192745] = bhEne06_Damage_0x1bc260; // 0x1bc3ac - g_ps2RecompiledFunctionTable[192746] = bhEne06_Damage_0x1bc260; // 0x1bc3b0 - g_ps2RecompiledFunctionTable[192747] = bhEne06_Damage_0x1bc260; // 0x1bc3b4 - g_ps2RecompiledFunctionTable[192748] = bhEne06_Damage_0x1bc260; // 0x1bc3b8 - g_ps2RecompiledFunctionTable[192749] = bhEne06_Damage_0x1bc260; // 0x1bc3bc - g_ps2RecompiledFunctionTable[192750] = bhEne06_Damage_0x1bc260; // 0x1bc3c0 - g_ps2RecompiledFunctionTable[192751] = bhEne06_Damage_0x1bc260; // 0x1bc3c4 - g_ps2RecompiledFunctionTable[192752] = bhEne06_Damage_0x1bc260; // 0x1bc3c8 - g_ps2RecompiledFunctionTable[192753] = bhEne06_Damage_0x1bc260; // 0x1bc3cc - g_ps2RecompiledFunctionTable[192754] = bhEne06_Damage_0x1bc260; // 0x1bc3d0 - g_ps2RecompiledFunctionTable[192755] = bhEne06_Damage_0x1bc260; // 0x1bc3d4 - g_ps2RecompiledFunctionTable[192756] = bhEne06_Damage_0x1bc260; // 0x1bc3d8 - g_ps2RecompiledFunctionTable[192757] = bhEne06_Damage_0x1bc260; // 0x1bc3dc - g_ps2RecompiledFunctionTable[192758] = bhEne06_Damage_0x1bc260; // 0x1bc3e0 - g_ps2RecompiledFunctionTable[192759] = bhEne06_Damage_0x1bc260; // 0x1bc3e4 - g_ps2RecompiledFunctionTable[192760] = bhEne06_Damage_0x1bc260; // 0x1bc3e8 - g_ps2RecompiledFunctionTable[192761] = bhEne06_Damage_0x1bc260; // 0x1bc3ec - g_ps2RecompiledFunctionTable[192762] = bhEne06_Damage_0x1bc260; // 0x1bc3f0 - g_ps2RecompiledFunctionTable[192763] = bhEne06_Damage_0x1bc260; // 0x1bc3f4 - g_ps2RecompiledFunctionTable[192764] = bhEne06_Damage_0x1bc260; // 0x1bc3f8 - g_ps2RecompiledFunctionTable[192765] = bhEne06_Damage_0x1bc260; // 0x1bc3fc - g_ps2RecompiledFunctionTable[192766] = bhEne06_Damage_0x1bc260; // 0x1bc400 - g_ps2RecompiledFunctionTable[192767] = bhEne06_Damage_0x1bc260; // 0x1bc404 - g_ps2RecompiledFunctionTable[192768] = bhEne06_Damage_0x1bc260; // 0x1bc408 - g_ps2RecompiledFunctionTable[192769] = bhEne06_Damage_0x1bc260; // 0x1bc40c - g_ps2RecompiledFunctionTable[192770] = bhEne06_Damage_0x1bc260; // 0x1bc410 - g_ps2RecompiledFunctionTable[192771] = bhEne06_Damage_0x1bc260; // 0x1bc414 - g_ps2RecompiledFunctionTable[192772] = bhEne06_Damage_0x1bc260; // 0x1bc418 - g_ps2RecompiledFunctionTable[192773] = bhEne06_Damage_0x1bc260; // 0x1bc41c - g_ps2RecompiledFunctionTable[192774] = bhEne06_Damage_0x1bc260; // 0x1bc420 - g_ps2RecompiledFunctionTable[192775] = bhEne06_Damage_0x1bc260; // 0x1bc424 - g_ps2RecompiledFunctionTable[192776] = bhEne06_Damage_0x1bc260; // 0x1bc428 - g_ps2RecompiledFunctionTable[192777] = bhEne06_Damage_0x1bc260; // 0x1bc42c - g_ps2RecompiledFunctionTable[192778] = bhEne06_Damage_0x1bc260; // 0x1bc430 - g_ps2RecompiledFunctionTable[192779] = bhEne06_Damage_0x1bc260; // 0x1bc434 - g_ps2RecompiledFunctionTable[192780] = bhEne06_Damage_0x1bc260; // 0x1bc438 - g_ps2RecompiledFunctionTable[192781] = bhEne06_Damage_0x1bc260; // 0x1bc43c - g_ps2RecompiledFunctionTable[192782] = bhEne06_Damage_0x1bc260; // 0x1bc440 - g_ps2RecompiledFunctionTable[192783] = bhEne06_Damage_0x1bc260; // 0x1bc444 - g_ps2RecompiledFunctionTable[192784] = bhEne06_Damage_0x1bc260; // 0x1bc448 - g_ps2RecompiledFunctionTable[192785] = bhEne06_Damage_0x1bc260; // 0x1bc44c - g_ps2RecompiledFunctionTable[192786] = bhEne06_Damage_0x1bc260; // 0x1bc450 - g_ps2RecompiledFunctionTable[192787] = bhEne06_Damage_0x1bc260; // 0x1bc454 - g_ps2RecompiledFunctionTable[192788] = bhEne06_Damage_0x1bc260; // 0x1bc458 - g_ps2RecompiledFunctionTable[192789] = bhEne06_Damage_0x1bc260; // 0x1bc45c - g_ps2RecompiledFunctionTable[192790] = bhEne06_Damage_0x1bc260; // 0x1bc460 - g_ps2RecompiledFunctionTable[192791] = bhEne06_Damage_0x1bc260; // 0x1bc464 - g_ps2RecompiledFunctionTable[192792] = bhEne06_Damage_0x1bc260; // 0x1bc468 - g_ps2RecompiledFunctionTable[192793] = bhEne06_Damage_0x1bc260; // 0x1bc46c - g_ps2RecompiledFunctionTable[192794] = bhEne06_Damage_0x1bc260; // 0x1bc470 - g_ps2RecompiledFunctionTable[192795] = bhEne06_Damage_0x1bc260; // 0x1bc474 - g_ps2RecompiledFunctionTable[192796] = bhEne06_Damage_0x1bc260; // 0x1bc478 - g_ps2RecompiledFunctionTable[192798] = bhEne06_DG00_0x1bc480; // 0x1bc480 - g_ps2RecompiledFunctionTable[192851] = bhEne06_DG00_0x1bc480; // 0x1bc554 - g_ps2RecompiledFunctionTable[192860] = bhEne06_DG00_0x1bc480; // 0x1bc578 - g_ps2RecompiledFunctionTable[192873] = bhEne06_DG00_0x1bc480; // 0x1bc5ac - g_ps2RecompiledFunctionTable[192899] = bhEne06_DG00_0x1bc480; // 0x1bc614 - g_ps2RecompiledFunctionTable[192919] = bhEne06_DG00_0x1bc480; // 0x1bc664 - g_ps2RecompiledFunctionTable[192957] = bhEne06_DG00_0x1bc480; // 0x1bc6fc - g_ps2RecompiledFunctionTable[192960] = bhEne06_DG00_0x1bc480; // 0x1bc708 - g_ps2RecompiledFunctionTable[192964] = bhEne06_DG00_0x1bc480; // 0x1bc718 - g_ps2RecompiledFunctionTable[193054] = bhEne06_DG01_0x1bc880; // 0x1bc880 - g_ps2RecompiledFunctionTable[193107] = bhEne06_DG01_0x1bc880; // 0x1bc954 - g_ps2RecompiledFunctionTable[193119] = bhEne06_DG01_0x1bc880; // 0x1bc984 - g_ps2RecompiledFunctionTable[193132] = bhEne06_DG01_0x1bc880; // 0x1bc9b8 - g_ps2RecompiledFunctionTable[193155] = bhEne06_DG01_0x1bc880; // 0x1bca14 - g_ps2RecompiledFunctionTable[193175] = bhEne06_DG01_0x1bc880; // 0x1bca64 - g_ps2RecompiledFunctionTable[193213] = bhEne06_DG01_0x1bc880; // 0x1bcafc - g_ps2RecompiledFunctionTable[193216] = bhEne06_DG01_0x1bc880; // 0x1bcb08 - g_ps2RecompiledFunctionTable[193220] = bhEne06_DG01_0x1bc880; // 0x1bcb18 - g_ps2RecompiledFunctionTable[193318] = bhEne06_Die_0x1bcca0; // 0x1bcca0 - g_ps2RecompiledFunctionTable[193319] = bhEne06_Die_0x1bcca0; // 0x1bcca4 - g_ps2RecompiledFunctionTable[193320] = bhEne06_Die_0x1bcca0; // 0x1bcca8 - g_ps2RecompiledFunctionTable[193321] = bhEne06_Die_0x1bcca0; // 0x1bccac - g_ps2RecompiledFunctionTable[193322] = bhEne06_Die_0x1bcca0; // 0x1bccb0 - g_ps2RecompiledFunctionTable[193323] = bhEne06_Die_0x1bcca0; // 0x1bccb4 - g_ps2RecompiledFunctionTable[193324] = bhEne06_Die_0x1bcca0; // 0x1bccb8 - g_ps2RecompiledFunctionTable[193325] = bhEne06_Die_0x1bcca0; // 0x1bccbc - g_ps2RecompiledFunctionTable[193326] = bhEne06_DD00_0x1bccc0; // 0x1bccc0 - g_ps2RecompiledFunctionTable[193373] = bhEne06_DD00_0x1bccc0; // 0x1bcd7c - g_ps2RecompiledFunctionTable[193395] = bhEne06_DD00_0x1bccc0; // 0x1bcdd4 - g_ps2RecompiledFunctionTable[193407] = bhEne06_DD00_0x1bccc0; // 0x1bce04 - g_ps2RecompiledFunctionTable[193445] = bhEne06_DD00_0x1bccc0; // 0x1bce9c - g_ps2RecompiledFunctionTable[193448] = bhEne06_DD00_0x1bccc0; // 0x1bcea8 - g_ps2RecompiledFunctionTable[193452] = bhEne06_DD00_0x1bccc0; // 0x1bceb8 - g_ps2RecompiledFunctionTable[193532] = bhEne06_DD00_0x1bccc0; // 0x1bcff8 - g_ps2RecompiledFunctionTable[193546] = bhEne06_DD01_0x1bd030; // 0x1bd030 - g_ps2RecompiledFunctionTable[193593] = bhEne06_DD01_0x1bd030; // 0x1bd0ec - g_ps2RecompiledFunctionTable[193611] = bhEne06_DD01_0x1bd030; // 0x1bd134 - g_ps2RecompiledFunctionTable[193623] = bhEne06_DD01_0x1bd030; // 0x1bd164 - g_ps2RecompiledFunctionTable[193661] = bhEne06_DD01_0x1bd030; // 0x1bd1fc - g_ps2RecompiledFunctionTable[193664] = bhEne06_DD01_0x1bd030; // 0x1bd208 - g_ps2RecompiledFunctionTable[193668] = bhEne06_DD01_0x1bd030; // 0x1bd218 - g_ps2RecompiledFunctionTable[193748] = bhEne06_DD01_0x1bd030; // 0x1bd358 - g_ps2RecompiledFunctionTable[193762] = bhEne06_DD02_0x1bd390; // 0x1bd390 - g_ps2RecompiledFunctionTable[193809] = bhEne06_DD02_0x1bd390; // 0x1bd44c - g_ps2RecompiledFunctionTable[193827] = bhEne06_DD02_0x1bd390; // 0x1bd494 - g_ps2RecompiledFunctionTable[193839] = bhEne06_DD02_0x1bd390; // 0x1bd4c4 - g_ps2RecompiledFunctionTable[193877] = bhEne06_DD02_0x1bd390; // 0x1bd55c - g_ps2RecompiledFunctionTable[193880] = bhEne06_DD02_0x1bd390; // 0x1bd568 - g_ps2RecompiledFunctionTable[193884] = bhEne06_DD02_0x1bd390; // 0x1bd578 - g_ps2RecompiledFunctionTable[193964] = bhEne06_DD02_0x1bd390; // 0x1bd6b8 - g_ps2RecompiledFunctionTable[193978] = bhEne06_DD03_0x1bd6f0; // 0x1bd6f0 - g_ps2RecompiledFunctionTable[193994] = bhEne06_DD03_0x1bd6f0; // 0x1bd730 - g_ps2RecompiledFunctionTable[194041] = bhEne06_DD03_0x1bd6f0; // 0x1bd7ec - g_ps2RecompiledFunctionTable[194050] = bhEne06_DD04_0x1bd810; // 0x1bd810 - g_ps2RecompiledFunctionTable[194076] = bhEne06_DD04_0x1bd810; // 0x1bd878 - g_ps2RecompiledFunctionTable[194086] = bhEne06_SearchPlayer_0x1bd8a0; // 0x1bd8a0 - g_ps2RecompiledFunctionTable[194103] = bhEne06_SearchPlayer_0x1bd8a0; // 0x1bd8e4 - g_ps2RecompiledFunctionTable[194114] = bhEne06_CollisionWalls_0x1bd910; // 0x1bd910 - g_ps2RecompiledFunctionTable[194164] = bhEne06_CollisionWalls_0x1bd910; // 0x1bd9d8 - g_ps2RecompiledFunctionTable[194167] = bhEne06_CollisionWalls_0x1bd910; // 0x1bd9e4 - g_ps2RecompiledFunctionTable[194172] = bhEne06_CollisionWalls_0x1bd910; // 0x1bd9f8 - g_ps2RecompiledFunctionTable[194176] = bhEne06_CollisionWalls_0x1bd910; // 0x1bda08 - g_ps2RecompiledFunctionTable[194195] = bhEne06_CollisionWalls_0x1bd910; // 0x1bda54 - g_ps2RecompiledFunctionTable[194198] = bhEne06_CollisionWalls_0x1bd910; // 0x1bda60 - g_ps2RecompiledFunctionTable[194202] = bhEne06_CollisionWalls_0x1bd910; // 0x1bda70 - g_ps2RecompiledFunctionTable[194230] = bhEne06_CollisionWalls_0x1bd910; // 0x1bdae0 - g_ps2RecompiledFunctionTable[194266] = bhEne06_FloorCollision_0x1bdb70; // 0x1bdb70 - g_ps2RecompiledFunctionTable[194274] = bhEne06_FloorCollision_0x1bdb70; // 0x1bdb90 - g_ps2RecompiledFunctionTable[194280] = bhEne06_FloorCollision_0x1bdb70; // 0x1bdba8 - g_ps2RecompiledFunctionTable[194283] = bhEne06_FloorCollision_0x1bdb70; // 0x1bdbb4 - g_ps2RecompiledFunctionTable[194345] = bhEne06_FloorCollision_0x1bdb70; // 0x1bdcac - g_ps2RecompiledFunctionTable[194362] = bhEne06_CheckLeaningWall_0x1bdcf0; // 0x1bdcf0 - g_ps2RecompiledFunctionTable[194378] = bhEne06_CheckLeaningWall_0x1bdcf0; // 0x1bdd30 - g_ps2RecompiledFunctionTable[194381] = bhEne06_CheckLeaningWall_0x1bdcf0; // 0x1bdd3c - g_ps2RecompiledFunctionTable[194385] = bhEne06_CheckLeaningWall_0x1bdcf0; // 0x1bdd4c - g_ps2RecompiledFunctionTable[194401] = bhEne06_CheckLeaningWall_0x1bdcf0; // 0x1bdd8c - g_ps2RecompiledFunctionTable[194414] = bhEne06_CheckLeaningWall_0x1bdcf0; // 0x1bddc0 - g_ps2RecompiledFunctionTable[194437] = bhEne06_CheckLeaningWall_0x1bdcf0; // 0x1bde1c - g_ps2RecompiledFunctionTable[194445] = bhEne06_CheckLeaningWall_0x1bdcf0; // 0x1bde3c - g_ps2RecompiledFunctionTable[194447] = bhEne06_CheckLeaningWall_0x1bdcf0; // 0x1bde44 - g_ps2RecompiledFunctionTable[194451] = bhEne06_CheckLeaningWall_0x1bdcf0; // 0x1bde54 - g_ps2RecompiledFunctionTable[194482] = bhEne06_AvoidWall_0x1bded0; // 0x1bded0 - g_ps2RecompiledFunctionTable[194502] = bhEne06_AvoidWall_0x1bded0; // 0x1bdf20 - g_ps2RecompiledFunctionTable[194528] = bhEne06_AvoidWall_0x1bded0; // 0x1bdf88 - g_ps2RecompiledFunctionTable[194552] = bhEne06_AvoidWall_0x1bded0; // 0x1bdfe8 - g_ps2RecompiledFunctionTable[194612] = bhEne06_AvoidWall_0x1bded0; // 0x1be0d8 - g_ps2RecompiledFunctionTable[194615] = bhEne06_AvoidWall_0x1bded0; // 0x1be0e4 - g_ps2RecompiledFunctionTable[194620] = bhEne06_AvoidWall_0x1bded0; // 0x1be0f8 - g_ps2RecompiledFunctionTable[194624] = bhEne06_AvoidWall_0x1bded0; // 0x1be108 - g_ps2RecompiledFunctionTable[194643] = bhEne06_AvoidWall_0x1bded0; // 0x1be154 - g_ps2RecompiledFunctionTable[194646] = bhEne06_AvoidWall_0x1bded0; // 0x1be160 - g_ps2RecompiledFunctionTable[194650] = bhEne06_AvoidWall_0x1bded0; // 0x1be170 - g_ps2RecompiledFunctionTable[194687] = bhEne06_AvoidWall_0x1bded0; // 0x1be204 - g_ps2RecompiledFunctionTable[194715] = bhEne06_AvoidWall_0x1bded0; // 0x1be274 - g_ps2RecompiledFunctionTable[194730] = bhEne06_AvoidWall_0x1bded0; // 0x1be2b0 - g_ps2RecompiledFunctionTable[194739] = bhEne06_AvoidWall_0x1bded0; // 0x1be2d4 - g_ps2RecompiledFunctionTable[194773] = bhEne06_AvoidWall_0x1bded0; // 0x1be35c - g_ps2RecompiledFunctionTable[194800] = bhEne06_AvoidWall_0x1bded0; // 0x1be3c8 - g_ps2RecompiledFunctionTable[194815] = bhEne06_AvoidWall_0x1bded0; // 0x1be404 - g_ps2RecompiledFunctionTable[194824] = bhEne06_AvoidWall_0x1bded0; // 0x1be428 - g_ps2RecompiledFunctionTable[194900] = bhEne06_AvoidWall_0x1bded0; // 0x1be558 - g_ps2RecompiledFunctionTable[194918] = bhEne06_AvoidWall_0x1bded0; // 0x1be5a0 - g_ps2RecompiledFunctionTable[194931] = bhEne06_AvoidWall_0x1bded0; // 0x1be5d4 - g_ps2RecompiledFunctionTable[194958] = bhEne06_PlayerControl_0x1be640; // 0x1be640 - g_ps2RecompiledFunctionTable[195099] = bhEne06_PlayerControl_0x1be640; // 0x1be874 - g_ps2RecompiledFunctionTable[195114] = bhEne06_SetRinpunEffect_0x1be8b0; // 0x1be8b0 - g_ps2RecompiledFunctionTable[195120] = bhEne06_SetRinpunEffect_0x1be8b0; // 0x1be8c8 - g_ps2RecompiledFunctionTable[195138] = bhEne06_SetRinpunEffect_0x1be8b0; // 0x1be910 - g_ps2RecompiledFunctionTable[195171] = bhEne06_SetRinpunEffect_0x1be8b0; // 0x1be994 - g_ps2RecompiledFunctionTable[195189] = bhEne06_SetRinpunEffect_0x1be8b0; // 0x1be9dc - g_ps2RecompiledFunctionTable[195195] = bhEne06_SetRinpunEffect_0x1be8b0; // 0x1be9f4 - g_ps2RecompiledFunctionTable[195211] = bhEne06_SetRinpunEffect_0x1be8b0; // 0x1bea34 - g_ps2RecompiledFunctionTable[195225] = bhEne06_SetRinpunEffect_0x1be8b0; // 0x1bea6c - g_ps2RecompiledFunctionTable[195234] = bhEne06_SetRinpunEffect_0x1be8b0; // 0x1bea90 - g_ps2RecompiledFunctionTable[195263] = bhEne06_SetRinpunEffect_0x1be8b0; // 0x1beb04 - g_ps2RecompiledFunctionTable[195298] = bhEne06_HitMark_0x1beb90; // 0x1beb90 - g_ps2RecompiledFunctionTable[195345] = bhEne06_HitMark_0x1beb90; // 0x1bec4c - g_ps2RecompiledFunctionTable[195361] = bhEne06_HitMark_0x1beb90; // 0x1bec8c - g_ps2RecompiledFunctionTable[195377] = bhEne06_HitMark_0x1beb90; // 0x1beccc - g_ps2RecompiledFunctionTable[195404] = bhEne06_HitMark_0x1beb90; // 0x1bed38 - g_ps2RecompiledFunctionTable[195419] = bhEne06_HitMark_0x1beb90; // 0x1bed74 - g_ps2RecompiledFunctionTable[195433] = bhEne06_HitMark_0x1beb90; // 0x1bedac - g_ps2RecompiledFunctionTable[195443] = bhEne06_HitMark_0x1beb90; // 0x1bedd4 - g_ps2RecompiledFunctionTable[195459] = bhEne06_HitMark_0x1beb90; // 0x1bee14 - g_ps2RecompiledFunctionTable[195475] = bhEne06_HitMark_0x1beb90; // 0x1bee54 - g_ps2RecompiledFunctionTable[195490] = bhEne06_HitMark_0x1beb90; // 0x1bee90 - g_ps2RecompiledFunctionTable[195503] = bhEne06_HitMark_0x1beb90; // 0x1beec4 - g_ps2RecompiledFunctionTable[195516] = bhEne06_HitMark_0x1beb90; // 0x1beef8 - g_ps2RecompiledFunctionTable[195522] = bhEne06_HitMark_0x1beb90; // 0x1bef10 - g_ps2RecompiledFunctionTable[195546] = bhEne06_HitMark_0x1beb90; // 0x1bef70 - g_ps2RecompiledFunctionTable[195562] = bhEne06_HitMark_0x1beb90; // 0x1befb0 - g_ps2RecompiledFunctionTable[195578] = bhEne06_HitMark_0x1beb90; // 0x1beff0 - g_ps2RecompiledFunctionTable[195596] = bhEne06_HitMark_0x1beb90; // 0x1bf038 - g_ps2RecompiledFunctionTable[195612] = bhEne06_HitMark_0x1beb90; // 0x1bf078 - g_ps2RecompiledFunctionTable[195626] = bhEne06_DeadCheck_0x1bf0b0; // 0x1bf0b0 - g_ps2RecompiledFunctionTable[195646] = bhEne06_DeadCheck_0x1bf0b0; // 0x1bf100 - g_ps2RecompiledFunctionTable[195683] = bhEne06_DeadCheck_0x1bf0b0; // 0x1bf194 - g_ps2RecompiledFunctionTable[195687] = bhEne06_DeadCheck_0x1bf0b0; // 0x1bf1a4 - g_ps2RecompiledFunctionTable[195723] = bhEne06_DeadCheck_0x1bf0b0; // 0x1bf234 - g_ps2RecompiledFunctionTable[195754] = bhEne06s_0x1bf2b0; // 0x1bf2b0 - g_ps2RecompiledFunctionTable[195755] = bhEne06s_0x1bf2b0; // 0x1bf2b4 - g_ps2RecompiledFunctionTable[195756] = bhEne06s_0x1bf2b0; // 0x1bf2b8 - g_ps2RecompiledFunctionTable[195757] = bhEne06s_0x1bf2b0; // 0x1bf2bc - g_ps2RecompiledFunctionTable[195758] = bhEne06s_0x1bf2b0; // 0x1bf2c0 - g_ps2RecompiledFunctionTable[195759] = bhEne06s_0x1bf2b0; // 0x1bf2c4 - g_ps2RecompiledFunctionTable[195760] = bhEne06s_0x1bf2b0; // 0x1bf2c8 - g_ps2RecompiledFunctionTable[195761] = bhEne06s_0x1bf2b0; // 0x1bf2cc - g_ps2RecompiledFunctionTable[195762] = bhEne06s_0x1bf2b0; // 0x1bf2d0 - g_ps2RecompiledFunctionTable[195763] = bhEne06s_0x1bf2b0; // 0x1bf2d4 - g_ps2RecompiledFunctionTable[195764] = bhEne06s_0x1bf2b0; // 0x1bf2d8 - g_ps2RecompiledFunctionTable[195765] = bhEne06s_0x1bf2b0; // 0x1bf2dc - g_ps2RecompiledFunctionTable[195766] = bhEne06s_0x1bf2b0; // 0x1bf2e0 - g_ps2RecompiledFunctionTable[195767] = bhEne06s_0x1bf2b0; // 0x1bf2e4 - g_ps2RecompiledFunctionTable[195768] = bhEne06s_0x1bf2b0; // 0x1bf2e8 - g_ps2RecompiledFunctionTable[195769] = bhEne06s_0x1bf2b0; // 0x1bf2ec - g_ps2RecompiledFunctionTable[195770] = bhEne06s_0x1bf2b0; // 0x1bf2f0 - g_ps2RecompiledFunctionTable[195771] = bhEne06s_0x1bf2b0; // 0x1bf2f4 - g_ps2RecompiledFunctionTable[195772] = bhEne06s_0x1bf2b0; // 0x1bf2f8 - g_ps2RecompiledFunctionTable[195773] = bhEne06s_0x1bf2b0; // 0x1bf2fc - g_ps2RecompiledFunctionTable[195774] = bhEne06s_0x1bf2b0; // 0x1bf300 - g_ps2RecompiledFunctionTable[195775] = bhEne06s_0x1bf2b0; // 0x1bf304 - g_ps2RecompiledFunctionTable[195776] = bhEne06s_0x1bf2b0; // 0x1bf308 - g_ps2RecompiledFunctionTable[195777] = bhEne06s_0x1bf2b0; // 0x1bf30c - g_ps2RecompiledFunctionTable[195778] = bhEne06s_0x1bf2b0; // 0x1bf310 - g_ps2RecompiledFunctionTable[195779] = bhEne06s_0x1bf2b0; // 0x1bf314 - g_ps2RecompiledFunctionTable[195780] = bhEne06s_0x1bf2b0; // 0x1bf318 - g_ps2RecompiledFunctionTable[195781] = bhEne06s_0x1bf2b0; // 0x1bf31c - g_ps2RecompiledFunctionTable[195782] = bhEne06s_0x1bf2b0; // 0x1bf320 - g_ps2RecompiledFunctionTable[195783] = bhEne06s_0x1bf2b0; // 0x1bf324 - g_ps2RecompiledFunctionTable[195784] = bhEne06s_0x1bf2b0; // 0x1bf328 - g_ps2RecompiledFunctionTable[195785] = bhEne06s_0x1bf2b0; // 0x1bf32c - g_ps2RecompiledFunctionTable[195786] = bhEne06s_0x1bf2b0; // 0x1bf330 - g_ps2RecompiledFunctionTable[195790] = bhEne06s_Init_0x1bf340; // 0x1bf340 - g_ps2RecompiledFunctionTable[195815] = bhEne06s_Init_0x1bf340; // 0x1bf3a4 - g_ps2RecompiledFunctionTable[195822] = bhEne06s_Move_0x1bf3c0; // 0x1bf3c0 - g_ps2RecompiledFunctionTable[195823] = bhEne06s_Move_0x1bf3c0; // 0x1bf3c4 - g_ps2RecompiledFunctionTable[195824] = bhEne06s_Move_0x1bf3c0; // 0x1bf3c8 - g_ps2RecompiledFunctionTable[195825] = bhEne06s_Move_0x1bf3c0; // 0x1bf3cc - g_ps2RecompiledFunctionTable[195826] = bhEne06s_Move_0x1bf3c0; // 0x1bf3d0 - g_ps2RecompiledFunctionTable[195827] = bhEne06s_Move_0x1bf3c0; // 0x1bf3d4 - g_ps2RecompiledFunctionTable[195828] = bhEne06s_Move_0x1bf3c0; // 0x1bf3d8 - g_ps2RecompiledFunctionTable[195829] = bhEne06s_Move_0x1bf3c0; // 0x1bf3dc - g_ps2RecompiledFunctionTable[195830] = bhEne06s_MV00_0x1bf3e0; // 0x1bf3e0 - g_ps2RecompiledFunctionTable[195860] = bhEne06s_MV00_0x1bf3e0; // 0x1bf458 - g_ps2RecompiledFunctionTable[195874] = bhEne06s_MV00_0x1bf3e0; // 0x1bf490 - g_ps2RecompiledFunctionTable[195889] = bhEne06s_MV00_0x1bf3e0; // 0x1bf4cc - g_ps2RecompiledFunctionTable[195970] = bhEne06s_MV00_0x1bf3e0; // 0x1bf610 - g_ps2RecompiledFunctionTable[195993] = bhEne06s_MV00_0x1bf3e0; // 0x1bf66c - g_ps2RecompiledFunctionTable[195996] = bhEne06s_MV00_0x1bf3e0; // 0x1bf678 - g_ps2RecompiledFunctionTable[195998] = bhEne06s_MV00_0x1bf3e0; // 0x1bf680 - g_ps2RecompiledFunctionTable[196000] = bhEne06s_MV00_0x1bf3e0; // 0x1bf688 - g_ps2RecompiledFunctionTable[196005] = bhEne06s_MV00_0x1bf3e0; // 0x1bf69c - g_ps2RecompiledFunctionTable[196014] = bhEne06s_MV00_0x1bf3e0; // 0x1bf6c0 - g_ps2RecompiledFunctionTable[196017] = bhEne06s_MV00_0x1bf3e0; // 0x1bf6cc - g_ps2RecompiledFunctionTable[196019] = bhEne06s_MV00_0x1bf3e0; // 0x1bf6d4 - g_ps2RecompiledFunctionTable[196046] = bhEne06s_MV01_0x1bf740; // 0x1bf740 - g_ps2RecompiledFunctionTable[196076] = bhEne06s_MV01_0x1bf740; // 0x1bf7b8 - g_ps2RecompiledFunctionTable[196090] = bhEne06s_MV01_0x1bf740; // 0x1bf7f0 - g_ps2RecompiledFunctionTable[196105] = bhEne06s_MV01_0x1bf740; // 0x1bf82c - g_ps2RecompiledFunctionTable[196136] = bhEne06s_MV01_0x1bf740; // 0x1bf8a8 - g_ps2RecompiledFunctionTable[196154] = bhEne06s_MV01_0x1bf740; // 0x1bf8f0 - g_ps2RecompiledFunctionTable[196169] = bhEne06s_MV01_0x1bf740; // 0x1bf92c - g_ps2RecompiledFunctionTable[196172] = bhEne06s_MV01_0x1bf740; // 0x1bf938 - g_ps2RecompiledFunctionTable[196175] = bhEne06s_MV01_0x1bf740; // 0x1bf944 - g_ps2RecompiledFunctionTable[196227] = bhEne06s_MV01_0x1bf740; // 0x1bfa14 - g_ps2RecompiledFunctionTable[196231] = bhEne06s_MV01_0x1bf740; // 0x1bfa24 - g_ps2RecompiledFunctionTable[196253] = bhEne06s_MV01_0x1bf740; // 0x1bfa7c - g_ps2RecompiledFunctionTable[196258] = bhEne06s_MV01_0x1bf740; // 0x1bfa90 - g_ps2RecompiledFunctionTable[196261] = bhEne06s_MV01_0x1bf740; // 0x1bfa9c - g_ps2RecompiledFunctionTable[196271] = bhEne06s_MV01_0x1bf740; // 0x1bfac4 - g_ps2RecompiledFunctionTable[196273] = bhEne06s_MV01_0x1bf740; // 0x1bfacc - g_ps2RecompiledFunctionTable[196278] = bhEne06s_MV01_0x1bf740; // 0x1bfae0 - g_ps2RecompiledFunctionTable[196281] = bhEne06s_MV01_0x1bf740; // 0x1bfaec - g_ps2RecompiledFunctionTable[196289] = bhEne06s_MV01_0x1bf740; // 0x1bfb0c - g_ps2RecompiledFunctionTable[196292] = bhEne06s_MV01_0x1bf740; // 0x1bfb18 - g_ps2RecompiledFunctionTable[196294] = bhEne06s_MV01_0x1bf740; // 0x1bfb20 - g_ps2RecompiledFunctionTable[196304] = bhEne06s_MV01_0x1bf740; // 0x1bfb48 - g_ps2RecompiledFunctionTable[196338] = bhEne06s_Dummy_0x1bfbd0; // 0x1bfbd0 - g_ps2RecompiledFunctionTable[196342] = bhEne06s_FloorCollision_0x1bfbe0; // 0x1bfbe0 - g_ps2RecompiledFunctionTable[196353] = bhEne06s_FloorCollision_0x1bfbe0; // 0x1bfc0c - g_ps2RecompiledFunctionTable[196358] = bhEne06s_FloorCollision_0x1bfbe0; // 0x1bfc20 - g_ps2RecompiledFunctionTable[196361] = bhEne06s_FloorCollision_0x1bfbe0; // 0x1bfc2c - g_ps2RecompiledFunctionTable[196402] = bhEne06s_WallCheck_0x1bfcd0; // 0x1bfcd0 - g_ps2RecompiledFunctionTable[196414] = bhEne06s_WallCheck_0x1bfcd0; // 0x1bfd00 - g_ps2RecompiledFunctionTable[196425] = bhEne06s_WallCheck_0x1bfcd0; // 0x1bfd2c - g_ps2RecompiledFunctionTable[196428] = bhEne06s_WallCheck_0x1bfcd0; // 0x1bfd38 - g_ps2RecompiledFunctionTable[196433] = bhEne06s_WallCheck_0x1bfcd0; // 0x1bfd4c - g_ps2RecompiledFunctionTable[196438] = bhEne06s_WallCheck_0x1bfcd0; // 0x1bfd60 - g_ps2RecompiledFunctionTable[196441] = bhEne06s_WallCheck_0x1bfcd0; // 0x1bfd6c - g_ps2RecompiledFunctionTable[196475] = bhEne06s_WallCheck_0x1bfcd0; // 0x1bfdf4 - g_ps2RecompiledFunctionTable[196478] = bhEne06s_WallCheck_0x1bfcd0; // 0x1bfe00 - g_ps2RecompiledFunctionTable[196503] = bhEne06s_WallCheck_0x1bfcd0; // 0x1bfe64 - g_ps2RecompiledFunctionTable[196510] = bhEne07_0x1bfe80; // 0x1bfe80 - g_ps2RecompiledFunctionTable[196511] = bhEne07_0x1bfe80; // 0x1bfe84 - g_ps2RecompiledFunctionTable[196512] = bhEne07_0x1bfe80; // 0x1bfe88 - g_ps2RecompiledFunctionTable[196513] = bhEne07_0x1bfe80; // 0x1bfe8c - g_ps2RecompiledFunctionTable[196514] = bhEne07_0x1bfe80; // 0x1bfe90 - g_ps2RecompiledFunctionTable[196515] = bhEne07_0x1bfe80; // 0x1bfe94 - g_ps2RecompiledFunctionTable[196516] = bhEne07_0x1bfe80; // 0x1bfe98 - g_ps2RecompiledFunctionTable[196517] = bhEne07_0x1bfe80; // 0x1bfe9c - g_ps2RecompiledFunctionTable[196518] = bhEne07_0x1bfe80; // 0x1bfea0 - g_ps2RecompiledFunctionTable[196519] = bhEne07_0x1bfe80; // 0x1bfea4 - g_ps2RecompiledFunctionTable[196520] = bhEne07_0x1bfe80; // 0x1bfea8 - g_ps2RecompiledFunctionTable[196521] = bhEne07_0x1bfe80; // 0x1bfeac - g_ps2RecompiledFunctionTable[196522] = bhEne07_0x1bfe80; // 0x1bfeb0 - g_ps2RecompiledFunctionTable[196523] = bhEne07_0x1bfe80; // 0x1bfeb4 - g_ps2RecompiledFunctionTable[196524] = bhEne07_0x1bfe80; // 0x1bfeb8 - g_ps2RecompiledFunctionTable[196525] = bhEne07_0x1bfe80; // 0x1bfebc - g_ps2RecompiledFunctionTable[196526] = bhEne07_0x1bfe80; // 0x1bfec0 - g_ps2RecompiledFunctionTable[196527] = bhEne07_0x1bfe80; // 0x1bfec4 - g_ps2RecompiledFunctionTable[196528] = bhEne07_0x1bfe80; // 0x1bfec8 - g_ps2RecompiledFunctionTable[196529] = bhEne07_0x1bfe80; // 0x1bfecc - g_ps2RecompiledFunctionTable[196530] = bhEne07_0x1bfe80; // 0x1bfed0 - g_ps2RecompiledFunctionTable[196531] = bhEne07_0x1bfe80; // 0x1bfed4 - g_ps2RecompiledFunctionTable[196532] = bhEne07_0x1bfe80; // 0x1bfed8 - g_ps2RecompiledFunctionTable[196533] = bhEne07_0x1bfe80; // 0x1bfedc - g_ps2RecompiledFunctionTable[196534] = bhEne07_0x1bfe80; // 0x1bfee0 - g_ps2RecompiledFunctionTable[196535] = bhEne07_0x1bfe80; // 0x1bfee4 - g_ps2RecompiledFunctionTable[196536] = bhEne07_0x1bfe80; // 0x1bfee8 - g_ps2RecompiledFunctionTable[196537] = bhEne07_0x1bfe80; // 0x1bfeec - g_ps2RecompiledFunctionTable[196538] = bhEne07_0x1bfe80; // 0x1bfef0 - g_ps2RecompiledFunctionTable[196539] = bhEne07_0x1bfe80; // 0x1bfef4 - g_ps2RecompiledFunctionTable[196540] = bhEne07_0x1bfe80; // 0x1bfef8 - g_ps2RecompiledFunctionTable[196541] = bhEne07_0x1bfe80; // 0x1bfefc - g_ps2RecompiledFunctionTable[196542] = bhEne07_0x1bfe80; // 0x1bff00 - g_ps2RecompiledFunctionTable[196543] = bhEne07_0x1bfe80; // 0x1bff04 - g_ps2RecompiledFunctionTable[196544] = bhEne07_0x1bfe80; // 0x1bff08 - g_ps2RecompiledFunctionTable[196545] = bhEne07_0x1bfe80; // 0x1bff0c - g_ps2RecompiledFunctionTable[196546] = bhEne07_0x1bfe80; // 0x1bff10 - g_ps2RecompiledFunctionTable[196547] = bhEne07_0x1bfe80; // 0x1bff14 - g_ps2RecompiledFunctionTable[196548] = bhEne07_0x1bfe80; // 0x1bff18 - g_ps2RecompiledFunctionTable[196549] = bhEne07_0x1bfe80; // 0x1bff1c - g_ps2RecompiledFunctionTable[196550] = bhEne07_0x1bfe80; // 0x1bff20 - g_ps2RecompiledFunctionTable[196551] = bhEne07_0x1bfe80; // 0x1bff24 - g_ps2RecompiledFunctionTable[196552] = bhEne07_0x1bfe80; // 0x1bff28 - g_ps2RecompiledFunctionTable[196553] = bhEne07_0x1bfe80; // 0x1bff2c - g_ps2RecompiledFunctionTable[196554] = bhEne07_0x1bfe80; // 0x1bff30 - g_ps2RecompiledFunctionTable[196555] = bhEne07_0x1bfe80; // 0x1bff34 - g_ps2RecompiledFunctionTable[196556] = bhEne07_0x1bfe80; // 0x1bff38 - g_ps2RecompiledFunctionTable[196557] = bhEne07_0x1bfe80; // 0x1bff3c - g_ps2RecompiledFunctionTable[196558] = bhEne07_0x1bfe80; // 0x1bff40 - g_ps2RecompiledFunctionTable[196559] = bhEne07_0x1bfe80; // 0x1bff44 - g_ps2RecompiledFunctionTable[196560] = bhEne07_0x1bfe80; // 0x1bff48 - g_ps2RecompiledFunctionTable[196561] = bhEne07_0x1bfe80; // 0x1bff4c - g_ps2RecompiledFunctionTable[196562] = bhEne07_0x1bfe80; // 0x1bff50 - g_ps2RecompiledFunctionTable[196563] = bhEne07_0x1bfe80; // 0x1bff54 - g_ps2RecompiledFunctionTable[196564] = bhEne07_0x1bfe80; // 0x1bff58 - g_ps2RecompiledFunctionTable[196565] = bhEne07_0x1bfe80; // 0x1bff5c - g_ps2RecompiledFunctionTable[196566] = bhEne07_0x1bfe80; // 0x1bff60 - g_ps2RecompiledFunctionTable[196567] = bhEne07_0x1bfe80; // 0x1bff64 - g_ps2RecompiledFunctionTable[196568] = bhEne07_0x1bfe80; // 0x1bff68 - g_ps2RecompiledFunctionTable[196569] = bhEne07_0x1bfe80; // 0x1bff6c - g_ps2RecompiledFunctionTable[196570] = bhEne07_0x1bfe80; // 0x1bff70 - g_ps2RecompiledFunctionTable[196571] = bhEne07_0x1bfe80; // 0x1bff74 - g_ps2RecompiledFunctionTable[196572] = bhEne07_0x1bfe80; // 0x1bff78 - g_ps2RecompiledFunctionTable[196573] = bhEne07_0x1bfe80; // 0x1bff7c - g_ps2RecompiledFunctionTable[196574] = bhEne07_0x1bfe80; // 0x1bff80 - g_ps2RecompiledFunctionTable[196575] = bhEne07_0x1bfe80; // 0x1bff84 - g_ps2RecompiledFunctionTable[196576] = bhEne07_0x1bfe80; // 0x1bff88 - g_ps2RecompiledFunctionTable[196577] = bhEne07_0x1bfe80; // 0x1bff8c - g_ps2RecompiledFunctionTable[196578] = bhEne07_0x1bfe80; // 0x1bff90 - g_ps2RecompiledFunctionTable[196579] = bhEne07_0x1bfe80; // 0x1bff94 - g_ps2RecompiledFunctionTable[196580] = bhEne07_0x1bfe80; // 0x1bff98 - g_ps2RecompiledFunctionTable[196581] = bhEne07_0x1bfe80; // 0x1bff9c - g_ps2RecompiledFunctionTable[196582] = bhEne07_0x1bfe80; // 0x1bffa0 - g_ps2RecompiledFunctionTable[196583] = bhEne07_0x1bfe80; // 0x1bffa4 - g_ps2RecompiledFunctionTable[196584] = bhEne07_0x1bfe80; // 0x1bffa8 - g_ps2RecompiledFunctionTable[196585] = bhEne07_0x1bfe80; // 0x1bffac - g_ps2RecompiledFunctionTable[196586] = bhEne07_0x1bfe80; // 0x1bffb0 - g_ps2RecompiledFunctionTable[196587] = bhEne07_0x1bfe80; // 0x1bffb4 - g_ps2RecompiledFunctionTable[196588] = bhEne07_0x1bfe80; // 0x1bffb8 - g_ps2RecompiledFunctionTable[196589] = bhEne07_0x1bfe80; // 0x1bffbc - g_ps2RecompiledFunctionTable[196590] = bhEne07_0x1bfe80; // 0x1bffc0 - g_ps2RecompiledFunctionTable[196594] = bhEne07_Init_0x1bffd0; // 0x1bffd0 - g_ps2RecompiledFunctionTable[196620] = bhEne07_Init_0x1bffd0; // 0x1c0038 - g_ps2RecompiledFunctionTable[196633] = bhEne07_Init_0x1bffd0; // 0x1c006c - g_ps2RecompiledFunctionTable[196680] = bhEne07_Init_0x1bffd0; // 0x1c0128 - g_ps2RecompiledFunctionTable[196691] = bhEne07_Init_0x1bffd0; // 0x1c0154 - g_ps2RecompiledFunctionTable[196706] = bhEne07_Init_0x1bffd0; // 0x1c0190 - g_ps2RecompiledFunctionTable[196721] = bhEne07_Init_0x1bffd0; // 0x1c01cc - g_ps2RecompiledFunctionTable[196743] = bhEne07_Init_0x1bffd0; // 0x1c0224 - g_ps2RecompiledFunctionTable[196779] = bhEne07_Init_0x1bffd0; // 0x1c02b4 - g_ps2RecompiledFunctionTable[196792] = bhEne07_Init_0x1bffd0; // 0x1c02e8 - g_ps2RecompiledFunctionTable[196832] = bhEne07_Init_0x1bffd0; // 0x1c0388 - g_ps2RecompiledFunctionTable[196866] = bhEne07_Brain_0x1c0410; // 0x1c0410 - g_ps2RecompiledFunctionTable[196867] = bhEne07_Brain_0x1c0410; // 0x1c0414 - g_ps2RecompiledFunctionTable[196868] = bhEne07_Brain_0x1c0410; // 0x1c0418 - g_ps2RecompiledFunctionTable[196869] = bhEne07_Brain_0x1c0410; // 0x1c041c - g_ps2RecompiledFunctionTable[196870] = bhEne07_Brain_0x1c0410; // 0x1c0420 - g_ps2RecompiledFunctionTable[196871] = bhEne07_Brain_0x1c0410; // 0x1c0424 - g_ps2RecompiledFunctionTable[196872] = bhEne07_Brain_0x1c0410; // 0x1c0428 - g_ps2RecompiledFunctionTable[196873] = bhEne07_Brain_0x1c0410; // 0x1c042c - g_ps2RecompiledFunctionTable[196874] = bhEne07_BR00_0x1c0430; // 0x1c0430 - g_ps2RecompiledFunctionTable[196879] = bhEne07_BR00_0x1c0430; // 0x1c0444 - g_ps2RecompiledFunctionTable[196908] = bhEne07_BR00_0x1c0430; // 0x1c04b8 - g_ps2RecompiledFunctionTable[196921] = bhEne07_BR00_0x1c0430; // 0x1c04ec - g_ps2RecompiledFunctionTable[196964] = bhEne07_BR00_0x1c0430; // 0x1c0598 - g_ps2RecompiledFunctionTable[196977] = bhEne07_BR00_0x1c0430; // 0x1c05cc - g_ps2RecompiledFunctionTable[196998] = bhEne07_BR00_0x1c0430; // 0x1c0620 - g_ps2RecompiledFunctionTable[197011] = bhEne07_BR00_0x1c0430; // 0x1c0654 - g_ps2RecompiledFunctionTable[197066] = bhEne07_BR00_0x1c0430; // 0x1c0730 - g_ps2RecompiledFunctionTable[197068] = bhEne07_BR00_0x1c0430; // 0x1c0738 - g_ps2RecompiledFunctionTable[197078] = bhEne07_BR00_0x1c0430; // 0x1c0760 - g_ps2RecompiledFunctionTable[197087] = bhEne07_BR00_0x1c0430; // 0x1c0784 - g_ps2RecompiledFunctionTable[197178] = bhEne07_BR01_0x1c08f0; // 0x1c08f0 - g_ps2RecompiledFunctionTable[197205] = bhEne07_BR01_0x1c08f0; // 0x1c095c - g_ps2RecompiledFunctionTable[197218] = bhEne07_BR01_0x1c08f0; // 0x1c0990 - g_ps2RecompiledFunctionTable[197226] = bhEne07_Move_0x1c09b0; // 0x1c09b0 - g_ps2RecompiledFunctionTable[197227] = bhEne07_Move_0x1c09b0; // 0x1c09b4 - g_ps2RecompiledFunctionTable[197228] = bhEne07_Move_0x1c09b0; // 0x1c09b8 - g_ps2RecompiledFunctionTable[197229] = bhEne07_Move_0x1c09b0; // 0x1c09bc - g_ps2RecompiledFunctionTable[197230] = bhEne07_Move_0x1c09b0; // 0x1c09c0 - g_ps2RecompiledFunctionTable[197231] = bhEne07_Move_0x1c09b0; // 0x1c09c4 - g_ps2RecompiledFunctionTable[197232] = bhEne07_Move_0x1c09b0; // 0x1c09c8 - g_ps2RecompiledFunctionTable[197233] = bhEne07_Move_0x1c09b0; // 0x1c09cc - g_ps2RecompiledFunctionTable[197234] = bhEne07_Move_0x1c09b0; // 0x1c09d0 - g_ps2RecompiledFunctionTable[197235] = bhEne07_Move_0x1c09b0; // 0x1c09d4 - g_ps2RecompiledFunctionTable[197236] = bhEne07_Move_0x1c09b0; // 0x1c09d8 - g_ps2RecompiledFunctionTable[197237] = bhEne07_Move_0x1c09b0; // 0x1c09dc - g_ps2RecompiledFunctionTable[197238] = bhEne07_Move_0x1c09b0; // 0x1c09e0 - g_ps2RecompiledFunctionTable[197239] = bhEne07_Move_0x1c09b0; // 0x1c09e4 - g_ps2RecompiledFunctionTable[197240] = bhEne07_Move_0x1c09b0; // 0x1c09e8 - g_ps2RecompiledFunctionTable[197241] = bhEne07_Move_0x1c09b0; // 0x1c09ec - g_ps2RecompiledFunctionTable[197242] = bhEne07_Move_0x1c09b0; // 0x1c09f0 - g_ps2RecompiledFunctionTable[197243] = bhEne07_Move_0x1c09b0; // 0x1c09f4 - g_ps2RecompiledFunctionTable[197244] = bhEne07_Move_0x1c09b0; // 0x1c09f8 - g_ps2RecompiledFunctionTable[197245] = bhEne07_Move_0x1c09b0; // 0x1c09fc - g_ps2RecompiledFunctionTable[197246] = bhEne07_Move_0x1c09b0; // 0x1c0a00 - g_ps2RecompiledFunctionTable[197247] = bhEne07_Move_0x1c09b0; // 0x1c0a04 - g_ps2RecompiledFunctionTable[197248] = bhEne07_Move_0x1c09b0; // 0x1c0a08 - g_ps2RecompiledFunctionTable[197249] = bhEne07_Move_0x1c09b0; // 0x1c0a0c - g_ps2RecompiledFunctionTable[197250] = bhEne07_Move_0x1c09b0; // 0x1c0a10 - g_ps2RecompiledFunctionTable[197251] = bhEne07_Move_0x1c09b0; // 0x1c0a14 - g_ps2RecompiledFunctionTable[197252] = bhEne07_Move_0x1c09b0; // 0x1c0a18 - g_ps2RecompiledFunctionTable[197253] = bhEne07_Move_0x1c09b0; // 0x1c0a1c - g_ps2RecompiledFunctionTable[197254] = bhEne07_Move_0x1c09b0; // 0x1c0a20 - g_ps2RecompiledFunctionTable[197255] = bhEne07_Move_0x1c09b0; // 0x1c0a24 - g_ps2RecompiledFunctionTable[197256] = bhEne07_Move_0x1c09b0; // 0x1c0a28 - g_ps2RecompiledFunctionTable[197257] = bhEne07_Move_0x1c09b0; // 0x1c0a2c - g_ps2RecompiledFunctionTable[197258] = bhEne07_Move_0x1c09b0; // 0x1c0a30 - g_ps2RecompiledFunctionTable[197259] = bhEne07_Move_0x1c09b0; // 0x1c0a34 - g_ps2RecompiledFunctionTable[197260] = bhEne07_Move_0x1c09b0; // 0x1c0a38 - g_ps2RecompiledFunctionTable[197261] = bhEne07_Move_0x1c09b0; // 0x1c0a3c - g_ps2RecompiledFunctionTable[197262] = bhEne07_MV00_0x1c0a40; // 0x1c0a40 - g_ps2RecompiledFunctionTable[197301] = bhEne07_MV00_0x1c0a40; // 0x1c0adc - g_ps2RecompiledFunctionTable[197314] = bhEne07_MV00_0x1c0a40; // 0x1c0b10 - g_ps2RecompiledFunctionTable[197321] = bhEne07_MV00_0x1c0a40; // 0x1c0b2c - g_ps2RecompiledFunctionTable[197334] = bhEne07_MV00_0x1c0a40; // 0x1c0b60 - g_ps2RecompiledFunctionTable[197345] = bhEne07_MV00_0x1c0a40; // 0x1c0b8c - g_ps2RecompiledFunctionTable[197358] = bhEne07_MV00_0x1c0a40; // 0x1c0bc0 - g_ps2RecompiledFunctionTable[197384] = bhEne07_MV00_0x1c0a40; // 0x1c0c28 - g_ps2RecompiledFunctionTable[197390] = bhEne07_MV00_0x1c0a40; // 0x1c0c40 - g_ps2RecompiledFunctionTable[197402] = bhEne07_MV01_0x1c0c70; // 0x1c0c70 - g_ps2RecompiledFunctionTable[197418] = bhEne07_MV01_0x1c0c70; // 0x1c0cb0 - g_ps2RecompiledFunctionTable[197431] = bhEne07_MV01_0x1c0c70; // 0x1c0ce4 - g_ps2RecompiledFunctionTable[197472] = bhEne07_MV01_0x1c0c70; // 0x1c0d88 - g_ps2RecompiledFunctionTable[197482] = bhEne07_MV01_0x1c0c70; // 0x1c0db0 - g_ps2RecompiledFunctionTable[197507] = bhEne07_MV01_0x1c0c70; // 0x1c0e14 - g_ps2RecompiledFunctionTable[197520] = bhEne07_MV01_0x1c0c70; // 0x1c0e48 - g_ps2RecompiledFunctionTable[197530] = bhEne07_MV02_0x1c0e70; // 0x1c0e70 - g_ps2RecompiledFunctionTable[197566] = bhEne07_MV02_0x1c0e70; // 0x1c0f00 - g_ps2RecompiledFunctionTable[197579] = bhEne07_MV02_0x1c0e70; // 0x1c0f34 - g_ps2RecompiledFunctionTable[197586] = bhEne07_MV02_0x1c0e70; // 0x1c0f50 - g_ps2RecompiledFunctionTable[197598] = bhEne07_MV02_0x1c0e70; // 0x1c0f80 - g_ps2RecompiledFunctionTable[197602] = bhEne07_MV02_0x1c0e70; // 0x1c0f90 - g_ps2RecompiledFunctionTable[197609] = bhEne07_MV02_0x1c0e70; // 0x1c0fac - g_ps2RecompiledFunctionTable[197622] = bhEne07_MV02_0x1c0e70; // 0x1c0fe0 - g_ps2RecompiledFunctionTable[197626] = bhEne07_MV02_0x1c0e70; // 0x1c0ff0 - g_ps2RecompiledFunctionTable[197648] = bhEne07_MV02_0x1c0e70; // 0x1c1048 - g_ps2RecompiledFunctionTable[197650] = bhEne07_MV02_0x1c0e70; // 0x1c1050 - g_ps2RecompiledFunctionTable[197658] = bhEne07_MV02_0x1c0e70; // 0x1c1070 - g_ps2RecompiledFunctionTable[197694] = bhEne07_MV02_0x1c0e70; // 0x1c1100 - g_ps2RecompiledFunctionTable[197697] = bhEne07_MV02_0x1c0e70; // 0x1c110c - g_ps2RecompiledFunctionTable[197718] = bhEne07_MV02_0x1c0e70; // 0x1c1160 - g_ps2RecompiledFunctionTable[197770] = bhEne07_MV02_0x1c0e70; // 0x1c1230 - g_ps2RecompiledFunctionTable[197772] = bhEne07_MV02_0x1c0e70; // 0x1c1238 - g_ps2RecompiledFunctionTable[197785] = bhEne07_MV02_0x1c0e70; // 0x1c126c - g_ps2RecompiledFunctionTable[197794] = bhEne07_MV03_0x1c1290; // 0x1c1290 - g_ps2RecompiledFunctionTable[197821] = bhEne07_MV03_0x1c1290; // 0x1c12fc - g_ps2RecompiledFunctionTable[197834] = bhEne07_MV03_0x1c1290; // 0x1c1330 - g_ps2RecompiledFunctionTable[197846] = bhEne07_MV03_0x1c1290; // 0x1c1360 - g_ps2RecompiledFunctionTable[197862] = bhEne07_MV04_0x1c13a0; // 0x1c13a0 - g_ps2RecompiledFunctionTable[197892] = bhEne07_MV04_0x1c13a0; // 0x1c1418 - g_ps2RecompiledFunctionTable[197905] = bhEne07_MV04_0x1c13a0; // 0x1c144c - g_ps2RecompiledFunctionTable[197908] = bhEne07_MV04_0x1c13a0; // 0x1c1458 - g_ps2RecompiledFunctionTable[197921] = bhEne07_MV04_0x1c13a0; // 0x1c148c - g_ps2RecompiledFunctionTable[197933] = bhEne07_MV04_0x1c13a0; // 0x1c14bc - g_ps2RecompiledFunctionTable[197939] = bhEne07_MV04_0x1c13a0; // 0x1c14d4 - g_ps2RecompiledFunctionTable[197949] = bhEne07_MV04_0x1c13a0; // 0x1c14fc - g_ps2RecompiledFunctionTable[197953] = bhEne07_MV04_0x1c13a0; // 0x1c150c - g_ps2RecompiledFunctionTable[197972] = bhEne07_MV04_0x1c13a0; // 0x1c1558 - g_ps2RecompiledFunctionTable[197974] = bhEne07_MV04_0x1c13a0; // 0x1c1560 - g_ps2RecompiledFunctionTable[197982] = bhEne07_MV04_0x1c13a0; // 0x1c1580 - g_ps2RecompiledFunctionTable[198018] = bhEne07_MV04_0x1c13a0; // 0x1c1610 - g_ps2RecompiledFunctionTable[198031] = bhEne07_MV04_0x1c13a0; // 0x1c1644 - g_ps2RecompiledFunctionTable[198059] = bhEne07_MV04_0x1c13a0; // 0x1c16b4 - g_ps2RecompiledFunctionTable[198066] = bhEne07_MV04_0x1c13a0; // 0x1c16d0 - g_ps2RecompiledFunctionTable[198106] = bhEne07_MV04_0x1c13a0; // 0x1c1770 - g_ps2RecompiledFunctionTable[198108] = bhEne07_MV04_0x1c13a0; // 0x1c1778 - g_ps2RecompiledFunctionTable[198121] = bhEne07_MV04_0x1c13a0; // 0x1c17ac - g_ps2RecompiledFunctionTable[198135] = bhEne07_MV04_0x1c13a0; // 0x1c17e4 - g_ps2RecompiledFunctionTable[198146] = bhEne07_MV05_0x1c1810; // 0x1c1810 - g_ps2RecompiledFunctionTable[198170] = bhEne07_MV05_0x1c1810; // 0x1c1870 - g_ps2RecompiledFunctionTable[198183] = bhEne07_MV05_0x1c1810; // 0x1c18a4 - g_ps2RecompiledFunctionTable[198187] = bhEne07_MV05_0x1c1810; // 0x1c18b4 - g_ps2RecompiledFunctionTable[198191] = bhEne07_MV05_0x1c1810; // 0x1c18c4 - g_ps2RecompiledFunctionTable[198204] = bhEne07_MV05_0x1c1810; // 0x1c18f8 - g_ps2RecompiledFunctionTable[198222] = bhEne07_MV05_0x1c1810; // 0x1c1940 - g_ps2RecompiledFunctionTable[198225] = bhEne07_MV05_0x1c1810; // 0x1c194c - g_ps2RecompiledFunctionTable[198233] = bhEne07_MV05_0x1c1810; // 0x1c196c - g_ps2RecompiledFunctionTable[198264] = bhEne07_MV05_0x1c1810; // 0x1c19e8 - g_ps2RecompiledFunctionTable[198274] = bhEne07_MV05_0x1c1810; // 0x1c1a10 - g_ps2RecompiledFunctionTable[198286] = bhEne07_MV05_0x1c1810; // 0x1c1a40 - g_ps2RecompiledFunctionTable[198288] = bhEne07_MV05_0x1c1810; // 0x1c1a48 - g_ps2RecompiledFunctionTable[198296] = bhEne07_MV05_0x1c1810; // 0x1c1a68 - g_ps2RecompiledFunctionTable[198346] = bhEne07_MV06_0x1c1b30; // 0x1c1b30 - g_ps2RecompiledFunctionTable[198350] = bhEne07_MV07_0x1c1b40; // 0x1c1b40 - g_ps2RecompiledFunctionTable[198354] = bhEne07_MV08_0x1c1b50; // 0x1c1b50 - g_ps2RecompiledFunctionTable[198404] = bhEne07_MV08_0x1c1b50; // 0x1c1c18 - g_ps2RecompiledFunctionTable[198458] = bhEne07_Nage_0x1c1cf0; // 0x1c1cf0 - g_ps2RecompiledFunctionTable[198459] = bhEne07_Nage_0x1c1cf0; // 0x1c1cf4 - g_ps2RecompiledFunctionTable[198460] = bhEne07_Nage_0x1c1cf0; // 0x1c1cf8 - g_ps2RecompiledFunctionTable[198461] = bhEne07_Nage_0x1c1cf0; // 0x1c1cfc - g_ps2RecompiledFunctionTable[198462] = bhEne07_Nage_0x1c1cf0; // 0x1c1d00 - g_ps2RecompiledFunctionTable[198463] = bhEne07_Nage_0x1c1cf0; // 0x1c1d04 - g_ps2RecompiledFunctionTable[198464] = bhEne07_Nage_0x1c1cf0; // 0x1c1d08 - g_ps2RecompiledFunctionTable[198465] = bhEne07_Nage_0x1c1cf0; // 0x1c1d0c - g_ps2RecompiledFunctionTable[198466] = bhEne07_NG00_0x1c1d10; // 0x1c1d10 - g_ps2RecompiledFunctionTable[198515] = bhEne07_NG00_0x1c1d10; // 0x1c1dd4 - g_ps2RecompiledFunctionTable[198540] = bhEne07_NG00_0x1c1d10; // 0x1c1e38 - g_ps2RecompiledFunctionTable[198581] = bhEne07_NG00_0x1c1d10; // 0x1c1edc - g_ps2RecompiledFunctionTable[198590] = bhEne07_NG00_0x1c1d10; // 0x1c1f00 - g_ps2RecompiledFunctionTable[198602] = bhEne07_NG00_0x1c1d10; // 0x1c1f30 - g_ps2RecompiledFunctionTable[198629] = bhEne07_NG00_0x1c1d10; // 0x1c1f9c - g_ps2RecompiledFunctionTable[198698] = bhEne07_NG00_0x1c1d10; // 0x1c20b0 - g_ps2RecompiledFunctionTable[198703] = bhEne07_NG00_0x1c1d10; // 0x1c20c4 - g_ps2RecompiledFunctionTable[198706] = bhEne07_NG00_0x1c1d10; // 0x1c20d0 - g_ps2RecompiledFunctionTable[198726] = bhEne07_NG01_0x1c2120; // 0x1c2120 - g_ps2RecompiledFunctionTable[198787] = bhEne07_NG01_0x1c2120; // 0x1c2214 - g_ps2RecompiledFunctionTable[198789] = bhEne07_NG01_0x1c2120; // 0x1c221c - g_ps2RecompiledFunctionTable[198792] = bhEne07_NG01_0x1c2120; // 0x1c2228 - g_ps2RecompiledFunctionTable[198814] = bhEne07_NG01_0x1c2120; // 0x1c2280 - g_ps2RecompiledFunctionTable[198845] = bhEne07_NG01_0x1c2120; // 0x1c22fc - g_ps2RecompiledFunctionTable[198848] = bhEne07_NG01_0x1c2120; // 0x1c2308 - g_ps2RecompiledFunctionTable[198852] = bhEne07_NG01_0x1c2120; // 0x1c2318 - g_ps2RecompiledFunctionTable[198858] = bhEne07_NG01_0x1c2120; // 0x1c2330 - g_ps2RecompiledFunctionTable[198864] = bhEne07_NG01_0x1c2120; // 0x1c2348 - g_ps2RecompiledFunctionTable[198867] = bhEne07_NG01_0x1c2120; // 0x1c2354 - g_ps2RecompiledFunctionTable[198910] = bhEne07_NG01_0x1c2120; // 0x1c2400 - g_ps2RecompiledFunctionTable[198913] = bhEne07_NG01_0x1c2120; // 0x1c240c - g_ps2RecompiledFunctionTable[198926] = bhEne07_NG01_0x1c2120; // 0x1c2440 - g_ps2RecompiledFunctionTable[198932] = bhEne07_NG01_0x1c2120; // 0x1c2458 - g_ps2RecompiledFunctionTable[198938] = bhEne07_NG01_0x1c2120; // 0x1c2470 - g_ps2RecompiledFunctionTable[198941] = bhEne07_NG01_0x1c2120; // 0x1c247c - g_ps2RecompiledFunctionTable[198944] = bhEne07_NG01_0x1c2120; // 0x1c2488 - g_ps2RecompiledFunctionTable[198992] = bhEne07_NG01_0x1c2120; // 0x1c2548 - g_ps2RecompiledFunctionTable[198997] = bhEne07_NG01_0x1c2120; // 0x1c255c - g_ps2RecompiledFunctionTable[199018] = bhEne07_Damage_0x1c25b0; // 0x1c25b0 - g_ps2RecompiledFunctionTable[199029] = bhEne07_Damage_0x1c25b0; // 0x1c25dc - g_ps2RecompiledFunctionTable[199062] = bhEne07_Damage_0x1c25b0; // 0x1c2660 - g_ps2RecompiledFunctionTable[199066] = bhEne07_Damage_0x1c25b0; // 0x1c2670 - g_ps2RecompiledFunctionTable[199072] = bhEne07_Damage_0x1c25b0; // 0x1c2688 - g_ps2RecompiledFunctionTable[199077] = bhEne07_Damage_0x1c25b0; // 0x1c269c - g_ps2RecompiledFunctionTable[199089] = bhEne07_Damage_0x1c25b0; // 0x1c26cc - g_ps2RecompiledFunctionTable[199108] = bhEne07_Damage_0x1c25b0; // 0x1c2718 - g_ps2RecompiledFunctionTable[199121] = bhEne07_Damage_0x1c25b0; // 0x1c274c - g_ps2RecompiledFunctionTable[199131] = bhEne07_Damage_0x1c25b0; // 0x1c2774 - g_ps2RecompiledFunctionTable[199144] = bhEne07_Damage_0x1c25b0; // 0x1c27a8 - g_ps2RecompiledFunctionTable[199159] = bhEne07_Damage_0x1c25b0; // 0x1c27e4 - g_ps2RecompiledFunctionTable[199172] = bhEne07_Damage_0x1c25b0; // 0x1c2818 - g_ps2RecompiledFunctionTable[199178] = bhEne07_Damage_0x1c25b0; // 0x1c2830 - g_ps2RecompiledFunctionTable[199180] = bhEne07_Damage_0x1c25b0; // 0x1c2838 - g_ps2RecompiledFunctionTable[199193] = bhEne07_Damage_0x1c25b0; // 0x1c286c - g_ps2RecompiledFunctionTable[199205] = bhEne07_Damage_0x1c25b0; // 0x1c289c - g_ps2RecompiledFunctionTable[199218] = bhEne07_Damage_0x1c25b0; // 0x1c28d0 - g_ps2RecompiledFunctionTable[199224] = bhEne07_Damage_0x1c25b0; // 0x1c28e8 - g_ps2RecompiledFunctionTable[199226] = bhEne07_Damage_0x1c25b0; // 0x1c28f0 - g_ps2RecompiledFunctionTable[199239] = bhEne07_Damage_0x1c25b0; // 0x1c2924 - g_ps2RecompiledFunctionTable[199251] = bhEne07_Damage_0x1c25b0; // 0x1c2954 - g_ps2RecompiledFunctionTable[199264] = bhEne07_Damage_0x1c25b0; // 0x1c2988 - g_ps2RecompiledFunctionTable[199272] = bhEne07_Damage_0x1c25b0; // 0x1c29a8 - g_ps2RecompiledFunctionTable[199278] = bhEne07_Damage_0x1c25b0; // 0x1c29c0 - g_ps2RecompiledFunctionTable[199291] = bhEne07_Damage_0x1c25b0; // 0x1c29f4 - g_ps2RecompiledFunctionTable[199306] = bhEne07_Damage_0x1c25b0; // 0x1c2a30 - g_ps2RecompiledFunctionTable[199330] = bhEne07_Die_0x1c2a90; // 0x1c2a90 - g_ps2RecompiledFunctionTable[199331] = bhEne07_Die_0x1c2a90; // 0x1c2a94 - g_ps2RecompiledFunctionTable[199332] = bhEne07_Die_0x1c2a90; // 0x1c2a98 - g_ps2RecompiledFunctionTable[199333] = bhEne07_Die_0x1c2a90; // 0x1c2a9c - g_ps2RecompiledFunctionTable[199334] = bhEne07_Die_0x1c2a90; // 0x1c2aa0 - g_ps2RecompiledFunctionTable[199335] = bhEne07_Die_0x1c2a90; // 0x1c2aa4 - g_ps2RecompiledFunctionTable[199336] = bhEne07_Die_0x1c2a90; // 0x1c2aa8 - g_ps2RecompiledFunctionTable[199337] = bhEne07_Die_0x1c2a90; // 0x1c2aac - g_ps2RecompiledFunctionTable[199338] = bhEne07_DD00_0x1c2ab0; // 0x1c2ab0 - g_ps2RecompiledFunctionTable[199388] = bhEne07_DD00_0x1c2ab0; // 0x1c2b78 - g_ps2RecompiledFunctionTable[199426] = bhEne07_DD00_0x1c2ab0; // 0x1c2c10 - g_ps2RecompiledFunctionTable[199429] = bhEne07_DD00_0x1c2ab0; // 0x1c2c1c - g_ps2RecompiledFunctionTable[199433] = bhEne07_DD00_0x1c2ab0; // 0x1c2c2c - g_ps2RecompiledFunctionTable[199449] = bhEne07_DD00_0x1c2ab0; // 0x1c2c6c - g_ps2RecompiledFunctionTable[199461] = bhEne07_DD00_0x1c2ab0; // 0x1c2c9c - g_ps2RecompiledFunctionTable[199474] = bhEne07_DD00_0x1c2ab0; // 0x1c2cd0 - g_ps2RecompiledFunctionTable[199501] = bhEne07_DD00_0x1c2ab0; // 0x1c2d3c - g_ps2RecompiledFunctionTable[199539] = bhEne07_DD00_0x1c2ab0; // 0x1c2dd4 - g_ps2RecompiledFunctionTable[199608] = bhEne07_DD00_0x1c2ab0; // 0x1c2ee8 - g_ps2RecompiledFunctionTable[199642] = bhEne07_DD01_0x1c2f70; // 0x1c2f70 - g_ps2RecompiledFunctionTable[199692] = bhEne07_DD01_0x1c2f70; // 0x1c3038 - g_ps2RecompiledFunctionTable[199730] = bhEne07_DD01_0x1c2f70; // 0x1c30d0 - g_ps2RecompiledFunctionTable[199733] = bhEne07_DD01_0x1c2f70; // 0x1c30dc - g_ps2RecompiledFunctionTable[199737] = bhEne07_DD01_0x1c2f70; // 0x1c30ec - g_ps2RecompiledFunctionTable[199753] = bhEne07_DD01_0x1c2f70; // 0x1c312c - g_ps2RecompiledFunctionTable[199765] = bhEne07_DD01_0x1c2f70; // 0x1c315c - g_ps2RecompiledFunctionTable[199778] = bhEne07_DD01_0x1c2f70; // 0x1c3190 - g_ps2RecompiledFunctionTable[199805] = bhEne07_DD01_0x1c2f70; // 0x1c31fc - g_ps2RecompiledFunctionTable[199843] = bhEne07_DD01_0x1c2f70; // 0x1c3294 - g_ps2RecompiledFunctionTable[199912] = bhEne07_DD01_0x1c2f70; // 0x1c33a8 - g_ps2RecompiledFunctionTable[199946] = bhEne07_DD02_0x1c3430; // 0x1c3430 - g_ps2RecompiledFunctionTable[199990] = bhEne07_DD02_0x1c3430; // 0x1c34e0 - g_ps2RecompiledFunctionTable[200016] = bhEne07_DD02_0x1c3430; // 0x1c3548 - g_ps2RecompiledFunctionTable[200030] = bhEne07_DD02_0x1c3430; // 0x1c3580 - g_ps2RecompiledFunctionTable[200063] = bhEne07_DD02_0x1c3430; // 0x1c3604 - g_ps2RecompiledFunctionTable[200066] = bhEne07_DD02_0x1c3430; // 0x1c3610 - g_ps2RecompiledFunctionTable[200070] = bhEne07_DD02_0x1c3430; // 0x1c3620 - g_ps2RecompiledFunctionTable[200142] = bhEne07_DD02_0x1c3430; // 0x1c3740 - g_ps2RecompiledFunctionTable[200151] = bhEne07_DD02_0x1c3430; // 0x1c3764 - g_ps2RecompiledFunctionTable[200164] = bhEne07_DD02_0x1c3430; // 0x1c3798 - g_ps2RecompiledFunctionTable[200178] = bhEne07_DD02_0x1c3430; // 0x1c37d0 - g_ps2RecompiledFunctionTable[200227] = bhEne07_DD02_0x1c3430; // 0x1c3894 - g_ps2RecompiledFunctionTable[200296] = bhEne07_DD02_0x1c3430; // 0x1c39a8 - g_ps2RecompiledFunctionTable[200330] = bhEne07_DD03_0x1c3a30; // 0x1c3a30 - g_ps2RecompiledFunctionTable[200374] = bhEne07_DD03_0x1c3a30; // 0x1c3ae0 - g_ps2RecompiledFunctionTable[200400] = bhEne07_DD03_0x1c3a30; // 0x1c3b48 - g_ps2RecompiledFunctionTable[200414] = bhEne07_DD03_0x1c3a30; // 0x1c3b80 - g_ps2RecompiledFunctionTable[200447] = bhEne07_DD03_0x1c3a30; // 0x1c3c04 - g_ps2RecompiledFunctionTable[200450] = bhEne07_DD03_0x1c3a30; // 0x1c3c10 - g_ps2RecompiledFunctionTable[200454] = bhEne07_DD03_0x1c3a30; // 0x1c3c20 - g_ps2RecompiledFunctionTable[200526] = bhEne07_DD03_0x1c3a30; // 0x1c3d40 - g_ps2RecompiledFunctionTable[200535] = bhEne07_DD03_0x1c3a30; // 0x1c3d64 - g_ps2RecompiledFunctionTable[200548] = bhEne07_DD03_0x1c3a30; // 0x1c3d98 - g_ps2RecompiledFunctionTable[200562] = bhEne07_DD03_0x1c3a30; // 0x1c3dd0 - g_ps2RecompiledFunctionTable[200611] = bhEne07_DD03_0x1c3a30; // 0x1c3e94 - g_ps2RecompiledFunctionTable[200680] = bhEne07_DD03_0x1c3a30; // 0x1c3fa8 - g_ps2RecompiledFunctionTable[200714] = bhEne07_DD04_0x1c4030; // 0x1c4030 - g_ps2RecompiledFunctionTable[200769] = bhEne07_DD04_0x1c4030; // 0x1c410c - g_ps2RecompiledFunctionTable[200805] = bhEne07_DD04_0x1c4030; // 0x1c419c - g_ps2RecompiledFunctionTable[200838] = bhEne07_DD04_0x1c4030; // 0x1c4220 - g_ps2RecompiledFunctionTable[200841] = bhEne07_DD04_0x1c4030; // 0x1c422c - g_ps2RecompiledFunctionTable[200845] = bhEne07_DD04_0x1c4030; // 0x1c423c - g_ps2RecompiledFunctionTable[200890] = bhEne07_DD04_0x1c4030; // 0x1c42f0 - g_ps2RecompiledFunctionTable[200940] = bhEne07_DD04_0x1c4030; // 0x1c43b8 - g_ps2RecompiledFunctionTable[200946] = bhEne07_DD05_0x1c43d0; // 0x1c43d0 - g_ps2RecompiledFunctionTable[201001] = bhEne07_DD05_0x1c43d0; // 0x1c44ac - g_ps2RecompiledFunctionTable[201037] = bhEne07_DD05_0x1c43d0; // 0x1c453c - g_ps2RecompiledFunctionTable[201070] = bhEne07_DD05_0x1c43d0; // 0x1c45c0 - g_ps2RecompiledFunctionTable[201073] = bhEne07_DD05_0x1c43d0; // 0x1c45cc - g_ps2RecompiledFunctionTable[201077] = bhEne07_DD05_0x1c43d0; // 0x1c45dc - g_ps2RecompiledFunctionTable[201122] = bhEne07_DD05_0x1c43d0; // 0x1c4690 - g_ps2RecompiledFunctionTable[201172] = bhEne07_DD05_0x1c43d0; // 0x1c4758 - g_ps2RecompiledFunctionTable[201178] = bhEne07_DD06_0x1c4770; // 0x1c4770 - g_ps2RecompiledFunctionTable[201197] = bhEne07_DD06_0x1c4770; // 0x1c47bc - g_ps2RecompiledFunctionTable[201210] = bhEne07_SearchPlayer_0x1c47f0; // 0x1c47f0 - g_ps2RecompiledFunctionTable[201228] = bhEne07_SearchPlayer_0x1c47f0; // 0x1c4838 - g_ps2RecompiledFunctionTable[201243] = bhEne07_SearchPlayer_0x1c47f0; // 0x1c4874 - g_ps2RecompiledFunctionTable[201250] = bhEne07_CollisionWalls_0x1c4890; // 0x1c4890 - g_ps2RecompiledFunctionTable[201258] = bhEne07_CollisionWalls_0x1c4890; // 0x1c48b0 - g_ps2RecompiledFunctionTable[201274] = bhEne07_CollisionWalls_0x1c4890; // 0x1c48f0 - g_ps2RecompiledFunctionTable[201294] = bhEne07_FloorCollision_0x1c4940; // 0x1c4940 - g_ps2RecompiledFunctionTable[201304] = bhEne07_FloorCollision_0x1c4940; // 0x1c4968 - g_ps2RecompiledFunctionTable[201309] = bhEne07_FloorCollision_0x1c4940; // 0x1c497c - g_ps2RecompiledFunctionTable[201358] = bhEne07_CheckLeaningWall_0x1c4a40; // 0x1c4a40 - g_ps2RecompiledFunctionTable[201362] = bhEne07_CheckHangingWall_0x1c4a50; // 0x1c4a50 - g_ps2RecompiledFunctionTable[201381] = bhEne07_CheckHangingWall_0x1c4a50; // 0x1c4a9c - g_ps2RecompiledFunctionTable[201384] = bhEne07_CheckHangingWall_0x1c4a50; // 0x1c4aa8 - g_ps2RecompiledFunctionTable[201388] = bhEne07_CheckHangingWall_0x1c4a50; // 0x1c4ab8 - g_ps2RecompiledFunctionTable[201406] = bhEne07_CheckHangingWall_0x1c4a50; // 0x1c4b00 - g_ps2RecompiledFunctionTable[201419] = bhEne07_CheckHangingWall_0x1c4a50; // 0x1c4b34 - g_ps2RecompiledFunctionTable[201441] = bhEne07_CheckHangingWall_0x1c4a50; // 0x1c4b8c - g_ps2RecompiledFunctionTable[201454] = bhEne07_CheckHangingWall_0x1c4a50; // 0x1c4bc0 - g_ps2RecompiledFunctionTable[201456] = bhEne07_CheckHangingWall_0x1c4a50; // 0x1c4bc8 - g_ps2RecompiledFunctionTable[201481] = bhEne07_CheckHangingWall_0x1c4a50; // 0x1c4c2c - g_ps2RecompiledFunctionTable[201500] = bhEne07_CheckHangingWall_0x1c4a50; // 0x1c4c78 - g_ps2RecompiledFunctionTable[201503] = bhEne07_CheckHangingWall_0x1c4a50; // 0x1c4c84 - g_ps2RecompiledFunctionTable[201507] = bhEne07_CheckHangingWall_0x1c4a50; // 0x1c4c94 - g_ps2RecompiledFunctionTable[201542] = bhEne07_AvoidWall_0x1c4d20; // 0x1c4d20 - g_ps2RecompiledFunctionTable[201561] = bhEne07_AvoidWall_0x1c4d20; // 0x1c4d6c - g_ps2RecompiledFunctionTable[201577] = bhEne07_AvoidWall_0x1c4d20; // 0x1c4dac - g_ps2RecompiledFunctionTable[201609] = bhEne07_AvoidWall_0x1c4d20; // 0x1c4e2c - g_ps2RecompiledFunctionTable[201657] = bhEne07_AvoidWall_0x1c4d20; // 0x1c4eec - g_ps2RecompiledFunctionTable[201668] = bhEne07_AvoidWall_0x1c4d20; // 0x1c4f18 - g_ps2RecompiledFunctionTable[201680] = bhEne07_AvoidWall_0x1c4d20; // 0x1c4f48 - g_ps2RecompiledFunctionTable[201711] = bhEne07_AvoidWall_0x1c4d20; // 0x1c4fc4 - g_ps2RecompiledFunctionTable[201714] = bhEne07_AvoidWall_0x1c4d20; // 0x1c4fd0 - g_ps2RecompiledFunctionTable[201738] = bhEne07_AvoidWall_0x1c4d20; // 0x1c5030 - g_ps2RecompiledFunctionTable[201742] = bhEne07_AvoidWall_0x1c4d20; // 0x1c5040 - g_ps2RecompiledFunctionTable[201761] = bhEne07_AvoidWall_0x1c4d20; // 0x1c508c - g_ps2RecompiledFunctionTable[201764] = bhEne07_AvoidWall_0x1c4d20; // 0x1c5098 - g_ps2RecompiledFunctionTable[201768] = bhEne07_AvoidWall_0x1c4d20; // 0x1c50a8 - g_ps2RecompiledFunctionTable[201805] = bhEne07_AvoidWall_0x1c4d20; // 0x1c513c - g_ps2RecompiledFunctionTable[201833] = bhEne07_AvoidWall_0x1c4d20; // 0x1c51ac - g_ps2RecompiledFunctionTable[201847] = bhEne07_AvoidWall_0x1c4d20; // 0x1c51e4 - g_ps2RecompiledFunctionTable[201856] = bhEne07_AvoidWall_0x1c4d20; // 0x1c5208 - g_ps2RecompiledFunctionTable[201889] = bhEne07_AvoidWall_0x1c4d20; // 0x1c528c - g_ps2RecompiledFunctionTable[201916] = bhEne07_AvoidWall_0x1c4d20; // 0x1c52f8 - g_ps2RecompiledFunctionTable[201930] = bhEne07_AvoidWall_0x1c4d20; // 0x1c5330 - g_ps2RecompiledFunctionTable[201939] = bhEne07_AvoidWall_0x1c4d20; // 0x1c5354 - g_ps2RecompiledFunctionTable[202013] = bhEne07_AvoidWall_0x1c4d20; // 0x1c547c - g_ps2RecompiledFunctionTable[202027] = bhEne07_AvoidWall_0x1c4d20; // 0x1c54b4 - g_ps2RecompiledFunctionTable[202038] = bhEne07_AvoidWall_0x1c4d20; // 0x1c54e0 - g_ps2RecompiledFunctionTable[202066] = bhEne07_PlayerBloodEffect_0x1c5550; // 0x1c5550 - g_ps2RecompiledFunctionTable[202095] = bhEne07_PlayerBloodEffect_0x1c5550; // 0x1c55c4 - g_ps2RecompiledFunctionTable[202111] = bhEne07_PlayerBloodEffect_0x1c5550; // 0x1c5604 - g_ps2RecompiledFunctionTable[202118] = bhEne07_PlayerControl_0x1c5620; // 0x1c5620 - g_ps2RecompiledFunctionTable[202434] = bhEne07_ObjEdge_0x1c5b10; // 0x1c5b10 - g_ps2RecompiledFunctionTable[202618] = bhEne07_ObjEdge_0x1c5b10; // 0x1c5df0 - g_ps2RecompiledFunctionTable[202638] = bhEne07_CalcAtariOffset_0x1c5e40; // 0x1c5e40 - g_ps2RecompiledFunctionTable[202650] = bhEne07_CalcAtariOffset_0x1c5e40; // 0x1c5e70 - g_ps2RecompiledFunctionTable[202653] = bhEne07_CalcAtariOffset_0x1c5e40; // 0x1c5e7c - g_ps2RecompiledFunctionTable[202677] = bhEne07_CalcAtariOffset_0x1c5e40; // 0x1c5edc - g_ps2RecompiledFunctionTable[202681] = bhEne07_CalcAtariOffset_0x1c5e40; // 0x1c5eec - g_ps2RecompiledFunctionTable[202699] = bhEne07_CalcAtariOffset_0x1c5e40; // 0x1c5f34 - g_ps2RecompiledFunctionTable[202702] = bhEne07_CalcAtariOffset_0x1c5e40; // 0x1c5f40 - g_ps2RecompiledFunctionTable[202706] = bhEne07_CalcAtariOffset_0x1c5e40; // 0x1c5f50 - g_ps2RecompiledFunctionTable[202709] = bhEne07_CalcAtariOffset_0x1c5e40; // 0x1c5f5c - g_ps2RecompiledFunctionTable[202714] = bhEne08_0x1c5f70; // 0x1c5f70 - g_ps2RecompiledFunctionTable[202715] = bhEne08_0x1c5f70; // 0x1c5f74 - g_ps2RecompiledFunctionTable[202716] = bhEne08_0x1c5f70; // 0x1c5f78 - g_ps2RecompiledFunctionTable[202717] = bhEne08_0x1c5f70; // 0x1c5f7c - g_ps2RecompiledFunctionTable[202718] = bhEne08_0x1c5f70; // 0x1c5f80 - g_ps2RecompiledFunctionTable[202719] = bhEne08_0x1c5f70; // 0x1c5f84 - g_ps2RecompiledFunctionTable[202720] = bhEne08_0x1c5f70; // 0x1c5f88 - g_ps2RecompiledFunctionTable[202721] = bhEne08_0x1c5f70; // 0x1c5f8c - g_ps2RecompiledFunctionTable[202722] = bhEne08_0x1c5f70; // 0x1c5f90 - g_ps2RecompiledFunctionTable[202723] = bhEne08_0x1c5f70; // 0x1c5f94 - g_ps2RecompiledFunctionTable[202724] = bhEne08_0x1c5f70; // 0x1c5f98 - g_ps2RecompiledFunctionTable[202725] = bhEne08_0x1c5f70; // 0x1c5f9c - g_ps2RecompiledFunctionTable[202726] = bhEne08_0x1c5f70; // 0x1c5fa0 - g_ps2RecompiledFunctionTable[202727] = bhEne08_0x1c5f70; // 0x1c5fa4 - g_ps2RecompiledFunctionTable[202728] = bhEne08_0x1c5f70; // 0x1c5fa8 - g_ps2RecompiledFunctionTable[202729] = bhEne08_0x1c5f70; // 0x1c5fac - g_ps2RecompiledFunctionTable[202730] = bhEne08_0x1c5f70; // 0x1c5fb0 - g_ps2RecompiledFunctionTable[202731] = bhEne08_0x1c5f70; // 0x1c5fb4 - g_ps2RecompiledFunctionTable[202732] = bhEne08_0x1c5f70; // 0x1c5fb8 - g_ps2RecompiledFunctionTable[202733] = bhEne08_0x1c5f70; // 0x1c5fbc - g_ps2RecompiledFunctionTable[202734] = bhEne08_0x1c5f70; // 0x1c5fc0 - g_ps2RecompiledFunctionTable[202735] = bhEne08_0x1c5f70; // 0x1c5fc4 - g_ps2RecompiledFunctionTable[202736] = bhEne08_0x1c5f70; // 0x1c5fc8 - g_ps2RecompiledFunctionTable[202737] = bhEne08_0x1c5f70; // 0x1c5fcc - g_ps2RecompiledFunctionTable[202738] = bhEne08_0x1c5f70; // 0x1c5fd0 - g_ps2RecompiledFunctionTable[202739] = bhEne08_0x1c5f70; // 0x1c5fd4 - g_ps2RecompiledFunctionTable[202740] = bhEne08_0x1c5f70; // 0x1c5fd8 - g_ps2RecompiledFunctionTable[202741] = bhEne08_0x1c5f70; // 0x1c5fdc - g_ps2RecompiledFunctionTable[202742] = bhEne08_0x1c5f70; // 0x1c5fe0 - g_ps2RecompiledFunctionTable[202746] = bhEne08_Init_0x1c5ff0; // 0x1c5ff0 - g_ps2RecompiledFunctionTable[202783] = bhEne08_Init_0x1c5ff0; // 0x1c6084 - g_ps2RecompiledFunctionTable[202806] = bhEne08_Move_0x1c60e0; // 0x1c60e0 - g_ps2RecompiledFunctionTable[202807] = bhEne08_Move_0x1c60e0; // 0x1c60e4 - g_ps2RecompiledFunctionTable[202808] = bhEne08_Move_0x1c60e0; // 0x1c60e8 - g_ps2RecompiledFunctionTable[202809] = bhEne08_Move_0x1c60e0; // 0x1c60ec - g_ps2RecompiledFunctionTable[202810] = bhEne08_Move_0x1c60e0; // 0x1c60f0 - g_ps2RecompiledFunctionTable[202811] = bhEne08_Move_0x1c60e0; // 0x1c60f4 - g_ps2RecompiledFunctionTable[202812] = bhEne08_Move_0x1c60e0; // 0x1c60f8 - g_ps2RecompiledFunctionTable[202813] = bhEne08_Move_0x1c60e0; // 0x1c60fc - g_ps2RecompiledFunctionTable[202814] = bhEne08_MV00_0x1c6100; // 0x1c6100 - g_ps2RecompiledFunctionTable[202834] = bhEne08_MV00_0x1c6100; // 0x1c6150 - g_ps2RecompiledFunctionTable[202847] = bhEne08_MV00_0x1c6100; // 0x1c6184 - g_ps2RecompiledFunctionTable[202850] = bhEne08_MV00_0x1c6100; // 0x1c6190 - g_ps2RecompiledFunctionTable[202873] = bhEne08_MV00_0x1c6100; // 0x1c61ec - g_ps2RecompiledFunctionTable[202892] = bhEne08_MV00_0x1c6100; // 0x1c6238 - g_ps2RecompiledFunctionTable[202894] = bhEne08_MV00_0x1c6100; // 0x1c6240 - g_ps2RecompiledFunctionTable[202916] = bhEne08_MV00_0x1c6100; // 0x1c6298 - g_ps2RecompiledFunctionTable[202950] = bhEne08_MV00_0x1c6100; // 0x1c6320 - g_ps2RecompiledFunctionTable[202955] = bhEne08_MV00_0x1c6100; // 0x1c6334 - g_ps2RecompiledFunctionTable[202966] = bhEne08_MV00_0x1c6100; // 0x1c6360 - g_ps2RecompiledFunctionTable[202977] = bhEne08_MV00_0x1c6100; // 0x1c638c - g_ps2RecompiledFunctionTable[202991] = bhEne08_MV00_0x1c6100; // 0x1c63c4 - g_ps2RecompiledFunctionTable[203001] = bhEne08_MV00_0x1c6100; // 0x1c63ec - g_ps2RecompiledFunctionTable[203011] = bhEne08_MV00_0x1c6100; // 0x1c6414 - g_ps2RecompiledFunctionTable[203020] = bhEne08_MV00_0x1c6100; // 0x1c6438 - g_ps2RecompiledFunctionTable[203024] = bhEne08_MV00_0x1c6100; // 0x1c6448 - g_ps2RecompiledFunctionTable[203026] = bhEne08_MV00_0x1c6100; // 0x1c6450 - g_ps2RecompiledFunctionTable[203028] = bhEne08_MV00_0x1c6100; // 0x1c6458 - g_ps2RecompiledFunctionTable[203032] = bhEne08_MV00_0x1c6100; // 0x1c6468 - g_ps2RecompiledFunctionTable[203036] = bhEne08_MV00_0x1c6100; // 0x1c6478 - g_ps2RecompiledFunctionTable[203050] = bhEne08_MV00_0x1c6100; // 0x1c64b0 - g_ps2RecompiledFunctionTable[203055] = bhEne08_MV00_0x1c6100; // 0x1c64c4 - g_ps2RecompiledFunctionTable[203066] = bhEne08_MV01_0x1c64f0; // 0x1c64f0 - g_ps2RecompiledFunctionTable[203086] = bhEne08_MV01_0x1c64f0; // 0x1c6540 - g_ps2RecompiledFunctionTable[203099] = bhEne08_MV01_0x1c64f0; // 0x1c6574 - g_ps2RecompiledFunctionTable[203102] = bhEne08_MV01_0x1c64f0; // 0x1c6580 - g_ps2RecompiledFunctionTable[203116] = bhEne08_MV01_0x1c64f0; // 0x1c65b8 - g_ps2RecompiledFunctionTable[203135] = bhEne08_MV01_0x1c64f0; // 0x1c6604 - g_ps2RecompiledFunctionTable[203137] = bhEne08_MV01_0x1c64f0; // 0x1c660c - g_ps2RecompiledFunctionTable[203175] = bhEne08_MV01_0x1c64f0; // 0x1c66a4 - g_ps2RecompiledFunctionTable[203210] = bhEne08_MV01_0x1c64f0; // 0x1c6730 - g_ps2RecompiledFunctionTable[203215] = bhEne08_MV01_0x1c64f0; // 0x1c6744 - g_ps2RecompiledFunctionTable[203226] = bhEne08_MV01_0x1c64f0; // 0x1c6770 - g_ps2RecompiledFunctionTable[203237] = bhEne08_MV01_0x1c64f0; // 0x1c679c - g_ps2RecompiledFunctionTable[203251] = bhEne08_MV01_0x1c64f0; // 0x1c67d4 - g_ps2RecompiledFunctionTable[203261] = bhEne08_MV01_0x1c64f0; // 0x1c67fc - g_ps2RecompiledFunctionTable[203271] = bhEne08_MV01_0x1c64f0; // 0x1c6824 - g_ps2RecompiledFunctionTable[203280] = bhEne08_MV01_0x1c64f0; // 0x1c6848 - g_ps2RecompiledFunctionTable[203284] = bhEne08_MV01_0x1c64f0; // 0x1c6858 - g_ps2RecompiledFunctionTable[203286] = bhEne08_MV01_0x1c64f0; // 0x1c6860 - g_ps2RecompiledFunctionTable[203288] = bhEne08_MV01_0x1c64f0; // 0x1c6868 - g_ps2RecompiledFunctionTable[203292] = bhEne08_MV01_0x1c64f0; // 0x1c6878 - g_ps2RecompiledFunctionTable[203296] = bhEne08_MV01_0x1c64f0; // 0x1c6888 - g_ps2RecompiledFunctionTable[203310] = bhEne08_MV01_0x1c64f0; // 0x1c68c0 - g_ps2RecompiledFunctionTable[203315] = bhEne08_MV01_0x1c64f0; // 0x1c68d4 - g_ps2RecompiledFunctionTable[203326] = bhEne08_MV02_0x1c6900; // 0x1c6900 - g_ps2RecompiledFunctionTable[203340] = bhEne08_MV02_0x1c6900; // 0x1c6938 - g_ps2RecompiledFunctionTable[203361] = bhEne08_MV02_0x1c6900; // 0x1c698c - g_ps2RecompiledFunctionTable[203386] = bhEne08_MV02_0x1c6900; // 0x1c69f0 - g_ps2RecompiledFunctionTable[203434] = bhEne08_Nage_0x1c6ab0; // 0x1c6ab0 - g_ps2RecompiledFunctionTable[203438] = bhEne08_Damage_0x1c6ac0; // 0x1c6ac0 - g_ps2RecompiledFunctionTable[203442] = bhEne08_Die_0x1c6ad0; // 0x1c6ad0 - g_ps2RecompiledFunctionTable[203446] = bhEne09_DmmyBrain_0x1c6ae0; // 0x1c6ae0 - g_ps2RecompiledFunctionTable[203450] = bhEne09_0x1c6af0; // 0x1c6af0 - g_ps2RecompiledFunctionTable[203457] = bhEne09_0x1c6af0; // 0x1c6b0c - g_ps2RecompiledFunctionTable[203459] = bhEne09_0x1c6af0; // 0x1c6b14 - g_ps2RecompiledFunctionTable[203465] = bhEne09_0x1c6af0; // 0x1c6b2c - g_ps2RecompiledFunctionTable[203487] = bhEne09_0x1c6af0; // 0x1c6b84 - g_ps2RecompiledFunctionTable[203489] = bhEne09_0x1c6af0; // 0x1c6b8c - g_ps2RecompiledFunctionTable[203493] = bhEne09_0x1c6af0; // 0x1c6b9c - g_ps2RecompiledFunctionTable[203511] = bhEne09_0x1c6af0; // 0x1c6be4 - g_ps2RecompiledFunctionTable[203515] = bhEne09_0x1c6af0; // 0x1c6bf4 - g_ps2RecompiledFunctionTable[203537] = bhEne09_0x1c6af0; // 0x1c6c4c - g_ps2RecompiledFunctionTable[203570] = bhEne09_MainLoop_0x1c6cd0; // 0x1c6cd0 - g_ps2RecompiledFunctionTable[203571] = bhEne09_MainLoop_0x1c6cd0; // 0x1c6cd4 - g_ps2RecompiledFunctionTable[203572] = bhEne09_MainLoop_0x1c6cd0; // 0x1c6cd8 - g_ps2RecompiledFunctionTable[203573] = bhEne09_MainLoop_0x1c6cd0; // 0x1c6cdc - g_ps2RecompiledFunctionTable[203574] = bhEne09_MainLoop_0x1c6cd0; // 0x1c6ce0 - g_ps2RecompiledFunctionTable[203575] = bhEne09_MainLoop_0x1c6cd0; // 0x1c6ce4 - g_ps2RecompiledFunctionTable[203576] = bhEne09_MainLoop_0x1c6cd0; // 0x1c6ce8 - g_ps2RecompiledFunctionTable[203577] = bhEne09_MainLoop_0x1c6cd0; // 0x1c6cec - g_ps2RecompiledFunctionTable[203578] = bhEne09_MainLoop_0x1c6cd0; // 0x1c6cf0 - g_ps2RecompiledFunctionTable[203579] = bhEne09_MainLoop_0x1c6cd0; // 0x1c6cf4 - g_ps2RecompiledFunctionTable[203580] = bhEne09_MainLoop_0x1c6cd0; // 0x1c6cf8 - g_ps2RecompiledFunctionTable[203581] = bhEne09_MainLoop_0x1c6cd0; // 0x1c6cfc - g_ps2RecompiledFunctionTable[203582] = bhEne09_MainLoop_0x1c6cd0; // 0x1c6d00 - g_ps2RecompiledFunctionTable[203583] = bhEne09_MainLoop_0x1c6cd0; // 0x1c6d04 - g_ps2RecompiledFunctionTable[203584] = bhEne09_MainLoop_0x1c6cd0; // 0x1c6d08 - g_ps2RecompiledFunctionTable[203585] = bhEne09_MainLoop_0x1c6cd0; // 0x1c6d0c - g_ps2RecompiledFunctionTable[203586] = bhEne09_MainLoop_0x1c6cd0; // 0x1c6d10 - g_ps2RecompiledFunctionTable[203587] = bhEne09_MainLoop_0x1c6cd0; // 0x1c6d14 - g_ps2RecompiledFunctionTable[203588] = bhEne09_MainLoop_0x1c6cd0; // 0x1c6d18 - g_ps2RecompiledFunctionTable[203589] = bhEne09_MainLoop_0x1c6cd0; // 0x1c6d1c - g_ps2RecompiledFunctionTable[203590] = bhEne09_MainLoop_0x1c6cd0; // 0x1c6d20 - g_ps2RecompiledFunctionTable[203591] = bhEne09_MainLoop_0x1c6cd0; // 0x1c6d24 - g_ps2RecompiledFunctionTable[203592] = bhEne09_MainLoop_0x1c6cd0; // 0x1c6d28 - g_ps2RecompiledFunctionTable[203593] = bhEne09_MainLoop_0x1c6cd0; // 0x1c6d2c - g_ps2RecompiledFunctionTable[203594] = bhEne09_MainLoop_0x1c6cd0; // 0x1c6d30 - g_ps2RecompiledFunctionTable[203595] = bhEne09_MainLoop_0x1c6cd0; // 0x1c6d34 - g_ps2RecompiledFunctionTable[203596] = bhEne09_MainLoop_0x1c6cd0; // 0x1c6d38 - g_ps2RecompiledFunctionTable[203598] = bhEne09_PlayerControl_0x1c6d40; // 0x1c6d40 - g_ps2RecompiledFunctionTable[203619] = bhEne09_PlayerControl_0x1c6d40; // 0x1c6d94 - g_ps2RecompiledFunctionTable[203624] = bhEne09_PlayerControl_0x1c6d40; // 0x1c6da8 - g_ps2RecompiledFunctionTable[203630] = bhEne09_CalcEnemy_0x1c6dc0; // 0x1c6dc0 - g_ps2RecompiledFunctionTable[203635] = bhEne09_CalcEnemy_0x1c6dc0; // 0x1c6dd4 - g_ps2RecompiledFunctionTable[203652] = bhEne09_CalcEnemy_0x1c6dc0; // 0x1c6e18 - g_ps2RecompiledFunctionTable[203702] = bhEne09_CollCheck_0x1c6ee0; // 0x1c6ee0 - g_ps2RecompiledFunctionTable[203716] = bhEne09_CollCheck_0x1c6ee0; // 0x1c6f18 - g_ps2RecompiledFunctionTable[203723] = bhEne09_CollCheck_0x1c6ee0; // 0x1c6f34 - g_ps2RecompiledFunctionTable[203726] = bhEne09_CollCheck_0x1c6ee0; // 0x1c6f40 - g_ps2RecompiledFunctionTable[203730] = bhEne09_CollCheckWall_0x1c6f50; // 0x1c6f50 - g_ps2RecompiledFunctionTable[203771] = bhEne09_CollCheckWall_0x1c6f50; // 0x1c6ff4 - g_ps2RecompiledFunctionTable[203810] = bhEne09_CollCheckWall_0x1c6f50; // 0x1c7090 - g_ps2RecompiledFunctionTable[203824] = bhEne09_CollCheckWall_0x1c6f50; // 0x1c70c8 - g_ps2RecompiledFunctionTable[203862] = bhEne09_CollCheckWall_0x1c6f50; // 0x1c7160 - g_ps2RecompiledFunctionTable[203885] = bhEne09_CollCheckWall_0x1c6f50; // 0x1c71bc - g_ps2RecompiledFunctionTable[203894] = bhEne09_CollCheckWall_0x1c6f50; // 0x1c71e0 - g_ps2RecompiledFunctionTable[203943] = bhEne09_CollCheckWall_0x1c6f50; // 0x1c72a4 - g_ps2RecompiledFunctionTable[203957] = bhEne09_CollCheckWall_0x1c6f50; // 0x1c72dc - g_ps2RecompiledFunctionTable[203995] = bhEne09_CollCheckWall_0x1c6f50; // 0x1c7374 - g_ps2RecompiledFunctionTable[204018] = bhEne09_CollCheckWall_0x1c6f50; // 0x1c73d0 - g_ps2RecompiledFunctionTable[204036] = bhEne09_CollCheckWall_0x1c6f50; // 0x1c7418 - g_ps2RecompiledFunctionTable[204050] = bhEne09_CollCheckWall_0x1c6f50; // 0x1c7450 - g_ps2RecompiledFunctionTable[204062] = bhEne09_CollCheckWall_0x1c6f50; // 0x1c7480 - g_ps2RecompiledFunctionTable[204104] = bhEne09_CollCheckWall_0x1c6f50; // 0x1c7528 - g_ps2RecompiledFunctionTable[204118] = bhEne09_CollCheckWall_0x1c6f50; // 0x1c7560 - g_ps2RecompiledFunctionTable[204130] = bhEne09_CollCheckArm_0x1c7590; // 0x1c7590 - g_ps2RecompiledFunctionTable[204134] = bhEne09_Init_0x1c75a0; // 0x1c75a0 - g_ps2RecompiledFunctionTable[204158] = bhEne09_Init_0x1c75a0; // 0x1c7600 - g_ps2RecompiledFunctionTable[204172] = bhEne09_Init_0x1c75a0; // 0x1c7638 - g_ps2RecompiledFunctionTable[204185] = bhEne09_Init_0x1c75a0; // 0x1c766c - g_ps2RecompiledFunctionTable[204207] = bhEne09_Init_0x1c75a0; // 0x1c76c4 - g_ps2RecompiledFunctionTable[204244] = bhEne09_Init_0x1c75a0; // 0x1c7758 - g_ps2RecompiledFunctionTable[204258] = bhEne09_Init_0x1c75a0; // 0x1c7790 - g_ps2RecompiledFunctionTable[204268] = bhEne09_Init_0x1c75a0; // 0x1c77b8 - g_ps2RecompiledFunctionTable[204332] = bhEne09_Init_0x1c75a0; // 0x1c78b8 - g_ps2RecompiledFunctionTable[204345] = bhEne09_Init_0x1c75a0; // 0x1c78ec - g_ps2RecompiledFunctionTable[204372] = bhEne09_Init_0x1c75a0; // 0x1c7958 - g_ps2RecompiledFunctionTable[204374] = bhEne09_Init_0x1c75a0; // 0x1c7960 - g_ps2RecompiledFunctionTable[204378] = bhEne09_Move_0x1c7970; // 0x1c7970 - g_ps2RecompiledFunctionTable[204379] = bhEne09_Move_0x1c7970; // 0x1c7974 - g_ps2RecompiledFunctionTable[204380] = bhEne09_Move_0x1c7970; // 0x1c7978 - g_ps2RecompiledFunctionTable[204381] = bhEne09_Move_0x1c7970; // 0x1c797c - g_ps2RecompiledFunctionTable[204382] = bhEne09_Move_0x1c7970; // 0x1c7980 - g_ps2RecompiledFunctionTable[204383] = bhEne09_Move_0x1c7970; // 0x1c7984 - g_ps2RecompiledFunctionTable[204384] = bhEne09_Move_0x1c7970; // 0x1c7988 - g_ps2RecompiledFunctionTable[204385] = bhEne09_Move_0x1c7970; // 0x1c798c - g_ps2RecompiledFunctionTable[204386] = bhEne09_Damage_0x1c7990; // 0x1c7990 - g_ps2RecompiledFunctionTable[204387] = bhEne09_Damage_0x1c7990; // 0x1c7994 - g_ps2RecompiledFunctionTable[204388] = bhEne09_Damage_0x1c7990; // 0x1c7998 - g_ps2RecompiledFunctionTable[204389] = bhEne09_Damage_0x1c7990; // 0x1c799c - g_ps2RecompiledFunctionTable[204390] = bhEne09_Nage_0x1c79a0; // 0x1c79a0 - g_ps2RecompiledFunctionTable[204391] = bhEne09_Nage_0x1c79a0; // 0x1c79a4 - g_ps2RecompiledFunctionTable[204392] = bhEne09_Nage_0x1c79a0; // 0x1c79a8 - g_ps2RecompiledFunctionTable[204393] = bhEne09_Nage_0x1c79a0; // 0x1c79ac - g_ps2RecompiledFunctionTable[204394] = bhEne09_Die_0x1c79b0; // 0x1c79b0 - g_ps2RecompiledFunctionTable[204395] = bhEne09_Die_0x1c79b0; // 0x1c79b4 - g_ps2RecompiledFunctionTable[204396] = bhEne09_Die_0x1c79b0; // 0x1c79b8 - g_ps2RecompiledFunctionTable[204397] = bhEne09_Die_0x1c79b0; // 0x1c79bc - g_ps2RecompiledFunctionTable[204398] = bhEne09_DmgCheck_0x1c79c0; // 0x1c79c0 - g_ps2RecompiledFunctionTable[204416] = bhEne09_DmgCheck_0x1c79c0; // 0x1c7a08 - g_ps2RecompiledFunctionTable[204457] = bhEne09_DmgCheck_0x1c79c0; // 0x1c7aac - g_ps2RecompiledFunctionTable[204465] = bhEne09_DmgCheck_0x1c79c0; // 0x1c7acc - g_ps2RecompiledFunctionTable[204497] = bhEne09_DmgCheck_0x1c79c0; // 0x1c7b4c - g_ps2RecompiledFunctionTable[204571] = bhEne09_DmgCheck_0x1c79c0; // 0x1c7c74 - g_ps2RecompiledFunctionTable[204602] = bhEne09_ChgDmgMode_0x1c7cf0; // 0x1c7cf0 - g_ps2RecompiledFunctionTable[204648] = bhEne09_ChgDmgMode_0x1c7cf0; // 0x1c7da8 - g_ps2RecompiledFunctionTable[204664] = bhEne09_ChgDmgMode_0x1c7cf0; // 0x1c7de8 - g_ps2RecompiledFunctionTable[204702] = bhEne09_ChgDmgMode_0x1c7cf0; // 0x1c7e80 - g_ps2RecompiledFunctionTable[204708] = bhEne09_ChgDmgMode_0x1c7cf0; // 0x1c7e98 - g_ps2RecompiledFunctionTable[204714] = bhEne09_ChgDmgMode_0x1c7cf0; // 0x1c7eb0 - g_ps2RecompiledFunctionTable[204771] = bhEne09_ChgDmgMode_0x1c7cf0; // 0x1c7f94 - g_ps2RecompiledFunctionTable[204794] = bhEne09_ExDmgCheck_0x1c7ff0; // 0x1c7ff0 - g_ps2RecompiledFunctionTable[204806] = bhEne09_ExDmgCheck_0x1c7ff0; // 0x1c8020 - g_ps2RecompiledFunctionTable[204852] = bhEne09_ExDmgCheck_0x1c7ff0; // 0x1c80d8 - g_ps2RecompiledFunctionTable[204862] = bhEne09_ExDmgCheck_0x1c7ff0; // 0x1c8100 - g_ps2RecompiledFunctionTable[204930] = bhEne09_DamageAdd_0x1c8210; // 0x1c8210 - g_ps2RecompiledFunctionTable[204960] = bhEne09_DamageAdd_0x1c8210; // 0x1c8288 - g_ps2RecompiledFunctionTable[205002] = bhEne09_DamageAdd_0x1c8210; // 0x1c8330 - g_ps2RecompiledFunctionTable[205008] = bhEne09_DamageAdd_0x1c8210; // 0x1c8348 - g_ps2RecompiledFunctionTable[205015] = bhEne09_DamageAdd_0x1c8210; // 0x1c8364 - g_ps2RecompiledFunctionTable[205021] = bhEne09_DamageAdd_0x1c8210; // 0x1c837c - g_ps2RecompiledFunctionTable[205033] = bhEne09_DamageAdd_0x1c8210; // 0x1c83ac - g_ps2RecompiledFunctionTable[205053] = bhEne09_DamageAdd_0x1c8210; // 0x1c83fc - g_ps2RecompiledFunctionTable[205060] = bhEne09_DamageAdd_0x1c8210; // 0x1c8418 - g_ps2RecompiledFunctionTable[205070] = bhEne09_DamageAdd_0x1c8210; // 0x1c8440 - g_ps2RecompiledFunctionTable[205077] = bhEne09_DamageAdd_0x1c8210; // 0x1c845c - g_ps2RecompiledFunctionTable[205110] = bhEne09_DamageAdd_0x1c8210; // 0x1c84e0 - g_ps2RecompiledFunctionTable[205121] = bhEne09_DamageAdd_0x1c8210; // 0x1c850c - g_ps2RecompiledFunctionTable[205129] = bhEne09_DamageAdd_0x1c8210; // 0x1c852c - g_ps2RecompiledFunctionTable[205145] = bhEne09_DamageAdd_0x1c8210; // 0x1c856c - g_ps2RecompiledFunctionTable[205154] = bhEne09_PlayerLink_0x1c8590; // 0x1c8590 - g_ps2RecompiledFunctionTable[205177] = bhEne09_PlayerLink_0x1c8590; // 0x1c85ec - g_ps2RecompiledFunctionTable[205182] = bhEne09_PlayerLink_0x1c8590; // 0x1c8600 - g_ps2RecompiledFunctionTable[205187] = bhEne09_PlayerLink_0x1c8590; // 0x1c8614 - g_ps2RecompiledFunctionTable[205192] = bhEne09_PlayerLink_0x1c8590; // 0x1c8628 - g_ps2RecompiledFunctionTable[205212] = bhEne09_PlayerLink_0x1c8590; // 0x1c8678 - g_ps2RecompiledFunctionTable[205217] = bhEne09_PlayerLink_0x1c8590; // 0x1c868c - g_ps2RecompiledFunctionTable[205225] = bhEne09_PlayerLink_0x1c8590; // 0x1c86ac - g_ps2RecompiledFunctionTable[205254] = bhEne09_MVType00_0x1c8720; // 0x1c8720 - g_ps2RecompiledFunctionTable[205255] = bhEne09_MVType00_0x1c8720; // 0x1c8724 - g_ps2RecompiledFunctionTable[205256] = bhEne09_MVType00_0x1c8720; // 0x1c8728 - g_ps2RecompiledFunctionTable[205257] = bhEne09_MVType00_0x1c8720; // 0x1c872c - g_ps2RecompiledFunctionTable[205258] = bhEne09_MVType00_0x1c8720; // 0x1c8730 - g_ps2RecompiledFunctionTable[205259] = bhEne09_MVType00_0x1c8720; // 0x1c8734 - g_ps2RecompiledFunctionTable[205260] = bhEne09_MVType00_0x1c8720; // 0x1c8738 - g_ps2RecompiledFunctionTable[205261] = bhEne09_MVType00_0x1c8720; // 0x1c873c - g_ps2RecompiledFunctionTable[205262] = bhEne09_MVType00_0x1c8720; // 0x1c8740 - g_ps2RecompiledFunctionTable[205263] = bhEne09_MVType00_0x1c8720; // 0x1c8744 - g_ps2RecompiledFunctionTable[205264] = bhEne09_MVType00_0x1c8720; // 0x1c8748 - g_ps2RecompiledFunctionTable[205265] = bhEne09_MVType00_0x1c8720; // 0x1c874c - g_ps2RecompiledFunctionTable[205266] = bhEne09_MVType00_0x1c8720; // 0x1c8750 - g_ps2RecompiledFunctionTable[205267] = bhEne09_MVType00_0x1c8720; // 0x1c8754 - g_ps2RecompiledFunctionTable[205268] = bhEne09_MVType00_0x1c8720; // 0x1c8758 - g_ps2RecompiledFunctionTable[205269] = bhEne09_MVType00_0x1c8720; // 0x1c875c - g_ps2RecompiledFunctionTable[205270] = bhEne09_MVType00_0x1c8720; // 0x1c8760 - g_ps2RecompiledFunctionTable[205271] = bhEne09_MVType00_0x1c8720; // 0x1c8764 - g_ps2RecompiledFunctionTable[205272] = bhEne09_MVType00_0x1c8720; // 0x1c8768 - g_ps2RecompiledFunctionTable[205273] = bhEne09_MVType00_0x1c8720; // 0x1c876c - g_ps2RecompiledFunctionTable[205274] = bhEne09_MVType00_0x1c8720; // 0x1c8770 - g_ps2RecompiledFunctionTable[205275] = bhEne09_MVType00_0x1c8720; // 0x1c8774 - g_ps2RecompiledFunctionTable[205276] = bhEne09_MVType00_0x1c8720; // 0x1c8778 - g_ps2RecompiledFunctionTable[205277] = bhEne09_MVType00_0x1c8720; // 0x1c877c - g_ps2RecompiledFunctionTable[205278] = bhEne09_MVType00_0x1c8720; // 0x1c8780 - g_ps2RecompiledFunctionTable[205279] = bhEne09_MVType00_0x1c8720; // 0x1c8784 - g_ps2RecompiledFunctionTable[205280] = bhEne09_MVType00_0x1c8720; // 0x1c8788 - g_ps2RecompiledFunctionTable[205281] = bhEne09_MVType00_0x1c8720; // 0x1c878c - g_ps2RecompiledFunctionTable[205282] = bhEne09_MVType00_0x1c8720; // 0x1c8790 - g_ps2RecompiledFunctionTable[205283] = bhEne09_MVType00_0x1c8720; // 0x1c8794 - g_ps2RecompiledFunctionTable[205284] = bhEne09_MVType00_0x1c8720; // 0x1c8798 - g_ps2RecompiledFunctionTable[205285] = bhEne09_MVType00_0x1c8720; // 0x1c879c - g_ps2RecompiledFunctionTable[205286] = bhEne09_MVType00_0x1c8720; // 0x1c87a0 - g_ps2RecompiledFunctionTable[205290] = bhEne09_MVType09_0x1c87b0; // 0x1c87b0 - g_ps2RecompiledFunctionTable[205299] = bhEne09_MVType09_0x1c87b0; // 0x1c87d4 - g_ps2RecompiledFunctionTable[205313] = bhEne09_MVType09_0x1c87b0; // 0x1c880c - g_ps2RecompiledFunctionTable[205318] = bhEne09_MVType10_0x1c8820; // 0x1c8820 - g_ps2RecompiledFunctionTable[205327] = bhEne09_MVType10_0x1c8820; // 0x1c8844 - g_ps2RecompiledFunctionTable[205335] = bhEne09_MVType10_0x1c8820; // 0x1c8864 - g_ps2RecompiledFunctionTable[205340] = bhEne09_MVType10_0x1c8820; // 0x1c8878 - g_ps2RecompiledFunctionTable[205346] = bhEne09_EneSearch_0x1c8890; // 0x1c8890 - g_ps2RecompiledFunctionTable[205357] = bhEne09_EneSearch_0x1c8890; // 0x1c88bc - g_ps2RecompiledFunctionTable[205430] = bhEne09_Brain_0x1c89e0; // 0x1c89e0 - g_ps2RecompiledFunctionTable[205431] = bhEne09_Brain_0x1c89e0; // 0x1c89e4 - g_ps2RecompiledFunctionTable[205432] = bhEne09_Brain_0x1c89e0; // 0x1c89e8 - g_ps2RecompiledFunctionTable[205433] = bhEne09_Brain_0x1c89e0; // 0x1c89ec - g_ps2RecompiledFunctionTable[205434] = bhEne09_Brain_0x1c89e0; // 0x1c89f0 - g_ps2RecompiledFunctionTable[205435] = bhEne09_Brain_0x1c89e0; // 0x1c89f4 - g_ps2RecompiledFunctionTable[205436] = bhEne09_Brain_0x1c89e0; // 0x1c89f8 - g_ps2RecompiledFunctionTable[205437] = bhEne09_Brain_0x1c89e0; // 0x1c89fc - g_ps2RecompiledFunctionTable[205438] = bhEne09_Brain_0x1c89e0; // 0x1c8a00 - g_ps2RecompiledFunctionTable[205439] = bhEne09_Brain_0x1c89e0; // 0x1c8a04 - g_ps2RecompiledFunctionTable[205440] = bhEne09_Brain_0x1c89e0; // 0x1c8a08 - g_ps2RecompiledFunctionTable[205441] = bhEne09_Brain_0x1c89e0; // 0x1c8a0c - g_ps2RecompiledFunctionTable[205442] = bhEne09_Brain_0x1c89e0; // 0x1c8a10 - g_ps2RecompiledFunctionTable[205443] = bhEne09_Brain_0x1c89e0; // 0x1c8a14 - g_ps2RecompiledFunctionTable[205444] = bhEne09_Brain_0x1c89e0; // 0x1c8a18 - g_ps2RecompiledFunctionTable[205445] = bhEne09_Brain_0x1c89e0; // 0x1c8a1c - g_ps2RecompiledFunctionTable[205446] = bhEne09_Brain_0x1c89e0; // 0x1c8a20 - g_ps2RecompiledFunctionTable[205447] = bhEne09_Brain_0x1c89e0; // 0x1c8a24 - g_ps2RecompiledFunctionTable[205448] = bhEne09_Brain_0x1c89e0; // 0x1c8a28 - g_ps2RecompiledFunctionTable[205449] = bhEne09_Brain_0x1c89e0; // 0x1c8a2c - g_ps2RecompiledFunctionTable[205450] = bhEne09_Brain_0x1c89e0; // 0x1c8a30 - g_ps2RecompiledFunctionTable[205451] = bhEne09_Brain_0x1c89e0; // 0x1c8a34 - g_ps2RecompiledFunctionTable[205452] = bhEne09_Brain_0x1c89e0; // 0x1c8a38 - g_ps2RecompiledFunctionTable[205453] = bhEne09_Brain_0x1c89e0; // 0x1c8a3c - g_ps2RecompiledFunctionTable[205454] = bhEne09_Brain_0x1c89e0; // 0x1c8a40 - g_ps2RecompiledFunctionTable[205455] = bhEne09_Brain_0x1c89e0; // 0x1c8a44 - g_ps2RecompiledFunctionTable[205456] = bhEne09_Brain_0x1c89e0; // 0x1c8a48 - g_ps2RecompiledFunctionTable[205457] = bhEne09_Brain_0x1c89e0; // 0x1c8a4c - g_ps2RecompiledFunctionTable[205458] = bhEne09_Brain_0x1c89e0; // 0x1c8a50 - g_ps2RecompiledFunctionTable[205459] = bhEne09_Brain_0x1c89e0; // 0x1c8a54 - g_ps2RecompiledFunctionTable[205460] = bhEne09_Brain_0x1c89e0; // 0x1c8a58 - g_ps2RecompiledFunctionTable[205461] = bhEne09_Brain_0x1c89e0; // 0x1c8a5c - g_ps2RecompiledFunctionTable[205462] = bhEne09_Brain_0x1c89e0; // 0x1c8a60 - g_ps2RecompiledFunctionTable[205463] = bhEne09_Brain_0x1c89e0; // 0x1c8a64 - g_ps2RecompiledFunctionTable[205464] = bhEne09_Brain_0x1c89e0; // 0x1c8a68 - g_ps2RecompiledFunctionTable[205465] = bhEne09_Brain_0x1c89e0; // 0x1c8a6c - g_ps2RecompiledFunctionTable[205466] = bhEne09_Brain_0x1c89e0; // 0x1c8a70 - g_ps2RecompiledFunctionTable[205467] = bhEne09_Brain_0x1c89e0; // 0x1c8a74 - g_ps2RecompiledFunctionTable[205468] = bhEne09_Brain_0x1c89e0; // 0x1c8a78 - g_ps2RecompiledFunctionTable[205469] = bhEne09_Brain_0x1c89e0; // 0x1c8a7c - g_ps2RecompiledFunctionTable[205470] = bhEne09_Brain_0x1c89e0; // 0x1c8a80 - g_ps2RecompiledFunctionTable[205471] = bhEne09_Brain_0x1c89e0; // 0x1c8a84 - g_ps2RecompiledFunctionTable[205472] = bhEne09_Brain_0x1c89e0; // 0x1c8a88 - g_ps2RecompiledFunctionTable[205473] = bhEne09_Brain_0x1c89e0; // 0x1c8a8c - g_ps2RecompiledFunctionTable[205474] = bhEne09_Brain_0x1c89e0; // 0x1c8a90 - g_ps2RecompiledFunctionTable[205475] = bhEne09_Brain_0x1c89e0; // 0x1c8a94 - g_ps2RecompiledFunctionTable[205476] = bhEne09_Brain_0x1c89e0; // 0x1c8a98 - g_ps2RecompiledFunctionTable[205477] = bhEne09_Brain_0x1c89e0; // 0x1c8a9c - g_ps2RecompiledFunctionTable[205478] = bhEne09_Brain_0x1c89e0; // 0x1c8aa0 - g_ps2RecompiledFunctionTable[205479] = bhEne09_Brain_0x1c89e0; // 0x1c8aa4 - g_ps2RecompiledFunctionTable[205480] = bhEne09_Brain_0x1c89e0; // 0x1c8aa8 - g_ps2RecompiledFunctionTable[205481] = bhEne09_Brain_0x1c89e0; // 0x1c8aac - g_ps2RecompiledFunctionTable[205482] = bhEne09_Brain_0x1c89e0; // 0x1c8ab0 - g_ps2RecompiledFunctionTable[205483] = bhEne09_Brain_0x1c89e0; // 0x1c8ab4 - g_ps2RecompiledFunctionTable[205484] = bhEne09_Brain_0x1c89e0; // 0x1c8ab8 - g_ps2RecompiledFunctionTable[205485] = bhEne09_Brain_0x1c89e0; // 0x1c8abc - g_ps2RecompiledFunctionTable[205486] = bhEne09_Brain_0x1c89e0; // 0x1c8ac0 - g_ps2RecompiledFunctionTable[205487] = bhEne09_Brain_0x1c89e0; // 0x1c8ac4 - g_ps2RecompiledFunctionTable[205488] = bhEne09_Brain_0x1c89e0; // 0x1c8ac8 - g_ps2RecompiledFunctionTable[205489] = bhEne09_Brain_0x1c89e0; // 0x1c8acc - g_ps2RecompiledFunctionTable[205490] = bhEne09_Brain_0x1c89e0; // 0x1c8ad0 - g_ps2RecompiledFunctionTable[205491] = bhEne09_Brain_0x1c89e0; // 0x1c8ad4 - g_ps2RecompiledFunctionTable[205492] = bhEne09_Brain_0x1c89e0; // 0x1c8ad8 - g_ps2RecompiledFunctionTable[205493] = bhEne09_Brain_0x1c89e0; // 0x1c8adc - g_ps2RecompiledFunctionTable[205494] = bhEne09_Brain_0x1c89e0; // 0x1c8ae0 - g_ps2RecompiledFunctionTable[205495] = bhEne09_Brain_0x1c89e0; // 0x1c8ae4 - g_ps2RecompiledFunctionTable[205496] = bhEne09_Brain_0x1c89e0; // 0x1c8ae8 - g_ps2RecompiledFunctionTable[205497] = bhEne09_Brain_0x1c89e0; // 0x1c8aec - g_ps2RecompiledFunctionTable[205498] = bhEne09_Brain_0x1c89e0; // 0x1c8af0 - g_ps2RecompiledFunctionTable[205499] = bhEne09_Brain_0x1c89e0; // 0x1c8af4 - g_ps2RecompiledFunctionTable[205500] = bhEne09_Brain_0x1c89e0; // 0x1c8af8 - g_ps2RecompiledFunctionTable[205501] = bhEne09_Brain_0x1c89e0; // 0x1c8afc - g_ps2RecompiledFunctionTable[205502] = bhEne09_Brain_0x1c89e0; // 0x1c8b00 - g_ps2RecompiledFunctionTable[205503] = bhEne09_Brain_0x1c89e0; // 0x1c8b04 - g_ps2RecompiledFunctionTable[205504] = bhEne09_Brain_0x1c89e0; // 0x1c8b08 - g_ps2RecompiledFunctionTable[205505] = bhEne09_Brain_0x1c89e0; // 0x1c8b0c - g_ps2RecompiledFunctionTable[205506] = bhEne09_Brain_0x1c89e0; // 0x1c8b10 - g_ps2RecompiledFunctionTable[205507] = bhEne09_Brain_0x1c89e0; // 0x1c8b14 - g_ps2RecompiledFunctionTable[205508] = bhEne09_Brain_0x1c89e0; // 0x1c8b18 - g_ps2RecompiledFunctionTable[205509] = bhEne09_Brain_0x1c89e0; // 0x1c8b1c - g_ps2RecompiledFunctionTable[205510] = bhEne09_Brain_0x1c89e0; // 0x1c8b20 - g_ps2RecompiledFunctionTable[205511] = bhEne09_Brain_0x1c89e0; // 0x1c8b24 - g_ps2RecompiledFunctionTable[205512] = bhEne09_Brain_0x1c89e0; // 0x1c8b28 - g_ps2RecompiledFunctionTable[205513] = bhEne09_Brain_0x1c89e0; // 0x1c8b2c - g_ps2RecompiledFunctionTable[205514] = bhEne09_Brain_0x1c89e0; // 0x1c8b30 - g_ps2RecompiledFunctionTable[205515] = bhEne09_Brain_0x1c89e0; // 0x1c8b34 - g_ps2RecompiledFunctionTable[205516] = bhEne09_Brain_0x1c89e0; // 0x1c8b38 - g_ps2RecompiledFunctionTable[205517] = bhEne09_Brain_0x1c89e0; // 0x1c8b3c - g_ps2RecompiledFunctionTable[205518] = bhEne09_Brain_0x1c89e0; // 0x1c8b40 - g_ps2RecompiledFunctionTable[205519] = bhEne09_Brain_0x1c89e0; // 0x1c8b44 - g_ps2RecompiledFunctionTable[205520] = bhEne09_Brain_0x1c89e0; // 0x1c8b48 - g_ps2RecompiledFunctionTable[205521] = bhEne09_Brain_0x1c89e0; // 0x1c8b4c - g_ps2RecompiledFunctionTable[205522] = bhEne09_Brain_0x1c89e0; // 0x1c8b50 - g_ps2RecompiledFunctionTable[205523] = bhEne09_Brain_0x1c89e0; // 0x1c8b54 - g_ps2RecompiledFunctionTable[205524] = bhEne09_Brain_0x1c89e0; // 0x1c8b58 - g_ps2RecompiledFunctionTable[205525] = bhEne09_Brain_0x1c89e0; // 0x1c8b5c - g_ps2RecompiledFunctionTable[205526] = bhEne09_Brain_0x1c89e0; // 0x1c8b60 - g_ps2RecompiledFunctionTable[205527] = bhEne09_Brain_0x1c89e0; // 0x1c8b64 - g_ps2RecompiledFunctionTable[205528] = bhEne09_Brain_0x1c89e0; // 0x1c8b68 - g_ps2RecompiledFunctionTable[205529] = bhEne09_Brain_0x1c89e0; // 0x1c8b6c - g_ps2RecompiledFunctionTable[205530] = bhEne09_Brain_0x1c89e0; // 0x1c8b70 - g_ps2RecompiledFunctionTable[205531] = bhEne09_Brain_0x1c89e0; // 0x1c8b74 - g_ps2RecompiledFunctionTable[205532] = bhEne09_Brain_0x1c89e0; // 0x1c8b78 - g_ps2RecompiledFunctionTable[205533] = bhEne09_Brain_0x1c89e0; // 0x1c8b7c - g_ps2RecompiledFunctionTable[205534] = bhEne09_Brain_0x1c89e0; // 0x1c8b80 - g_ps2RecompiledFunctionTable[205535] = bhEne09_Brain_0x1c89e0; // 0x1c8b84 - g_ps2RecompiledFunctionTable[205536] = bhEne09_Brain_0x1c89e0; // 0x1c8b88 - g_ps2RecompiledFunctionTable[205537] = bhEne09_Brain_0x1c89e0; // 0x1c8b8c - g_ps2RecompiledFunctionTable[205538] = bhEne09_Brain_0x1c89e0; // 0x1c8b90 - g_ps2RecompiledFunctionTable[205539] = bhEne09_Brain_0x1c89e0; // 0x1c8b94 - g_ps2RecompiledFunctionTable[205540] = bhEne09_Brain_0x1c89e0; // 0x1c8b98 - g_ps2RecompiledFunctionTable[205541] = bhEne09_Brain_0x1c89e0; // 0x1c8b9c - g_ps2RecompiledFunctionTable[205542] = bhEne09_Brain_0x1c89e0; // 0x1c8ba0 - g_ps2RecompiledFunctionTable[205543] = bhEne09_Brain_0x1c89e0; // 0x1c8ba4 - g_ps2RecompiledFunctionTable[205544] = bhEne09_Brain_0x1c89e0; // 0x1c8ba8 - g_ps2RecompiledFunctionTable[205545] = bhEne09_Brain_0x1c89e0; // 0x1c8bac - g_ps2RecompiledFunctionTable[205546] = bhEne09_Brain_0x1c89e0; // 0x1c8bb0 - g_ps2RecompiledFunctionTable[205547] = bhEne09_Brain_0x1c89e0; // 0x1c8bb4 - g_ps2RecompiledFunctionTable[205548] = bhEne09_Brain_0x1c89e0; // 0x1c8bb8 - g_ps2RecompiledFunctionTable[205549] = bhEne09_Brain_0x1c89e0; // 0x1c8bbc - g_ps2RecompiledFunctionTable[205550] = bhEne09_Brain_0x1c89e0; // 0x1c8bc0 - g_ps2RecompiledFunctionTable[205551] = bhEne09_Brain_0x1c89e0; // 0x1c8bc4 - g_ps2RecompiledFunctionTable[205552] = bhEne09_Brain_0x1c89e0; // 0x1c8bc8 - g_ps2RecompiledFunctionTable[205553] = bhEne09_Brain_0x1c89e0; // 0x1c8bcc - g_ps2RecompiledFunctionTable[205554] = bhEne09_Brain_0x1c89e0; // 0x1c8bd0 - g_ps2RecompiledFunctionTable[205555] = bhEne09_Brain_0x1c89e0; // 0x1c8bd4 - g_ps2RecompiledFunctionTable[205556] = bhEne09_Brain_0x1c89e0; // 0x1c8bd8 - g_ps2RecompiledFunctionTable[205557] = bhEne09_Brain_0x1c89e0; // 0x1c8bdc - g_ps2RecompiledFunctionTable[205558] = bhEne09_Brain_0x1c89e0; // 0x1c8be0 - g_ps2RecompiledFunctionTable[205559] = bhEne09_Brain_0x1c89e0; // 0x1c8be4 - g_ps2RecompiledFunctionTable[205560] = bhEne09_Brain_0x1c89e0; // 0x1c8be8 - g_ps2RecompiledFunctionTable[205561] = bhEne09_Brain_0x1c89e0; // 0x1c8bec - g_ps2RecompiledFunctionTable[205562] = bhEne09_Brain_0x1c89e0; // 0x1c8bf0 - g_ps2RecompiledFunctionTable[205563] = bhEne09_Brain_0x1c89e0; // 0x1c8bf4 - g_ps2RecompiledFunctionTable[205564] = bhEne09_Brain_0x1c89e0; // 0x1c8bf8 - g_ps2RecompiledFunctionTable[205565] = bhEne09_Brain_0x1c89e0; // 0x1c8bfc - g_ps2RecompiledFunctionTable[205566] = bhEne09_Brain_0x1c89e0; // 0x1c8c00 - g_ps2RecompiledFunctionTable[205567] = bhEne09_Brain_0x1c89e0; // 0x1c8c04 - g_ps2RecompiledFunctionTable[205568] = bhEne09_Brain_0x1c89e0; // 0x1c8c08 - g_ps2RecompiledFunctionTable[205569] = bhEne09_Brain_0x1c89e0; // 0x1c8c0c - g_ps2RecompiledFunctionTable[205570] = bhEne09_Brain_0x1c89e0; // 0x1c8c10 - g_ps2RecompiledFunctionTable[205571] = bhEne09_Brain_0x1c89e0; // 0x1c8c14 - g_ps2RecompiledFunctionTable[205572] = bhEne09_Brain_0x1c89e0; // 0x1c8c18 - g_ps2RecompiledFunctionTable[205573] = bhEne09_Brain_0x1c89e0; // 0x1c8c1c - g_ps2RecompiledFunctionTable[205574] = bhEne09_Brain_0x1c89e0; // 0x1c8c20 - g_ps2RecompiledFunctionTable[205575] = bhEne09_Brain_0x1c89e0; // 0x1c8c24 - g_ps2RecompiledFunctionTable[205576] = bhEne09_Brain_0x1c89e0; // 0x1c8c28 - g_ps2RecompiledFunctionTable[205577] = bhEne09_Brain_0x1c89e0; // 0x1c8c2c - g_ps2RecompiledFunctionTable[205578] = bhEne09_Brain_0x1c89e0; // 0x1c8c30 - g_ps2RecompiledFunctionTable[205579] = bhEne09_Brain_0x1c89e0; // 0x1c8c34 - g_ps2RecompiledFunctionTable[205580] = bhEne09_Brain_0x1c89e0; // 0x1c8c38 - g_ps2RecompiledFunctionTable[205581] = bhEne09_Brain_0x1c89e0; // 0x1c8c3c - g_ps2RecompiledFunctionTable[205582] = bhEne09_Brain_0x1c89e0; // 0x1c8c40 - g_ps2RecompiledFunctionTable[205583] = bhEne09_Brain_0x1c89e0; // 0x1c8c44 - g_ps2RecompiledFunctionTable[205584] = bhEne09_Brain_0x1c89e0; // 0x1c8c48 - g_ps2RecompiledFunctionTable[205585] = bhEne09_Brain_0x1c89e0; // 0x1c8c4c - g_ps2RecompiledFunctionTable[205586] = bhEne09_Brain_0x1c89e0; // 0x1c8c50 - g_ps2RecompiledFunctionTable[205587] = bhEne09_Brain_0x1c89e0; // 0x1c8c54 - g_ps2RecompiledFunctionTable[205588] = bhEne09_Brain_0x1c89e0; // 0x1c8c58 - g_ps2RecompiledFunctionTable[205589] = bhEne09_Brain_0x1c89e0; // 0x1c8c5c - g_ps2RecompiledFunctionTable[205590] = bhEne09_Brain_0x1c89e0; // 0x1c8c60 - g_ps2RecompiledFunctionTable[205591] = bhEne09_Brain_0x1c89e0; // 0x1c8c64 - g_ps2RecompiledFunctionTable[205592] = bhEne09_Brain_0x1c89e0; // 0x1c8c68 - g_ps2RecompiledFunctionTable[205593] = bhEne09_Brain_0x1c89e0; // 0x1c8c6c - g_ps2RecompiledFunctionTable[205594] = bhEne09_Brain_0x1c89e0; // 0x1c8c70 - g_ps2RecompiledFunctionTable[205595] = bhEne09_Brain_0x1c89e0; // 0x1c8c74 - g_ps2RecompiledFunctionTable[205596] = bhEne09_Brain_0x1c89e0; // 0x1c8c78 - g_ps2RecompiledFunctionTable[205597] = bhEne09_Brain_0x1c89e0; // 0x1c8c7c - g_ps2RecompiledFunctionTable[205598] = bhEne09_Brain_0x1c89e0; // 0x1c8c80 - g_ps2RecompiledFunctionTable[205599] = bhEne09_Brain_0x1c89e0; // 0x1c8c84 - g_ps2RecompiledFunctionTable[205600] = bhEne09_Brain_0x1c89e0; // 0x1c8c88 - g_ps2RecompiledFunctionTable[205601] = bhEne09_Brain_0x1c89e0; // 0x1c8c8c - g_ps2RecompiledFunctionTable[205602] = bhEne09_Brain_0x1c89e0; // 0x1c8c90 - g_ps2RecompiledFunctionTable[205603] = bhEne09_Brain_0x1c89e0; // 0x1c8c94 - g_ps2RecompiledFunctionTable[205604] = bhEne09_Brain_0x1c89e0; // 0x1c8c98 - g_ps2RecompiledFunctionTable[205605] = bhEne09_Brain_0x1c89e0; // 0x1c8c9c - g_ps2RecompiledFunctionTable[205606] = bhEne09_Brain_0x1c89e0; // 0x1c8ca0 - g_ps2RecompiledFunctionTable[205607] = bhEne09_Brain_0x1c89e0; // 0x1c8ca4 - g_ps2RecompiledFunctionTable[205608] = bhEne09_Brain_0x1c89e0; // 0x1c8ca8 - g_ps2RecompiledFunctionTable[205609] = bhEne09_Brain_0x1c89e0; // 0x1c8cac - g_ps2RecompiledFunctionTable[205610] = bhEne09_Brain_0x1c89e0; // 0x1c8cb0 - g_ps2RecompiledFunctionTable[205611] = bhEne09_Brain_0x1c89e0; // 0x1c8cb4 - g_ps2RecompiledFunctionTable[205612] = bhEne09_Brain_0x1c89e0; // 0x1c8cb8 - g_ps2RecompiledFunctionTable[205613] = bhEne09_Brain_0x1c89e0; // 0x1c8cbc - g_ps2RecompiledFunctionTable[205614] = bhEne09_Brain_0x1c89e0; // 0x1c8cc0 - g_ps2RecompiledFunctionTable[205615] = bhEne09_Brain_0x1c89e0; // 0x1c8cc4 - g_ps2RecompiledFunctionTable[205616] = bhEne09_Brain_0x1c89e0; // 0x1c8cc8 - g_ps2RecompiledFunctionTable[205617] = bhEne09_Brain_0x1c89e0; // 0x1c8ccc - g_ps2RecompiledFunctionTable[205618] = bhEne09_Brain_0x1c89e0; // 0x1c8cd0 - g_ps2RecompiledFunctionTable[205619] = bhEne09_Brain_0x1c89e0; // 0x1c8cd4 - g_ps2RecompiledFunctionTable[205620] = bhEne09_Brain_0x1c89e0; // 0x1c8cd8 - g_ps2RecompiledFunctionTable[205621] = bhEne09_Brain_0x1c89e0; // 0x1c8cdc - g_ps2RecompiledFunctionTable[205622] = bhEne09_Brain_0x1c89e0; // 0x1c8ce0 - g_ps2RecompiledFunctionTable[205623] = bhEne09_Brain_0x1c89e0; // 0x1c8ce4 - g_ps2RecompiledFunctionTable[205624] = bhEne09_Brain_0x1c89e0; // 0x1c8ce8 - g_ps2RecompiledFunctionTable[205625] = bhEne09_Brain_0x1c89e0; // 0x1c8cec - g_ps2RecompiledFunctionTable[205626] = bhEne09_Brain_0x1c89e0; // 0x1c8cf0 - g_ps2RecompiledFunctionTable[205627] = bhEne09_Brain_0x1c89e0; // 0x1c8cf4 - g_ps2RecompiledFunctionTable[205628] = bhEne09_Brain_0x1c89e0; // 0x1c8cf8 - g_ps2RecompiledFunctionTable[205629] = bhEne09_Brain_0x1c89e0; // 0x1c8cfc - g_ps2RecompiledFunctionTable[205630] = bhEne09_Brain_0x1c89e0; // 0x1c8d00 - g_ps2RecompiledFunctionTable[205631] = bhEne09_Brain_0x1c89e0; // 0x1c8d04 - g_ps2RecompiledFunctionTable[205632] = bhEne09_Brain_0x1c89e0; // 0x1c8d08 - g_ps2RecompiledFunctionTable[205633] = bhEne09_Brain_0x1c89e0; // 0x1c8d0c - g_ps2RecompiledFunctionTable[205634] = bhEne09_Brain_0x1c89e0; // 0x1c8d10 - g_ps2RecompiledFunctionTable[205635] = bhEne09_Brain_0x1c89e0; // 0x1c8d14 - g_ps2RecompiledFunctionTable[205636] = bhEne09_Brain_0x1c89e0; // 0x1c8d18 - g_ps2RecompiledFunctionTable[205637] = bhEne09_Brain_0x1c89e0; // 0x1c8d1c - g_ps2RecompiledFunctionTable[205638] = bhEne09_Brain_0x1c89e0; // 0x1c8d20 - g_ps2RecompiledFunctionTable[205639] = bhEne09_Brain_0x1c89e0; // 0x1c8d24 - g_ps2RecompiledFunctionTable[205640] = bhEne09_Brain_0x1c89e0; // 0x1c8d28 - g_ps2RecompiledFunctionTable[205641] = bhEne09_Brain_0x1c89e0; // 0x1c8d2c - g_ps2RecompiledFunctionTable[205642] = bhEne09_Brain_0x1c89e0; // 0x1c8d30 - g_ps2RecompiledFunctionTable[205643] = bhEne09_Brain_0x1c89e0; // 0x1c8d34 - g_ps2RecompiledFunctionTable[205644] = bhEne09_Brain_0x1c89e0; // 0x1c8d38 - g_ps2RecompiledFunctionTable[205645] = bhEne09_Brain_0x1c89e0; // 0x1c8d3c - g_ps2RecompiledFunctionTable[205646] = bhEne09_Brain_0x1c89e0; // 0x1c8d40 - g_ps2RecompiledFunctionTable[205647] = bhEne09_Brain_0x1c89e0; // 0x1c8d44 - g_ps2RecompiledFunctionTable[205648] = bhEne09_Brain_0x1c89e0; // 0x1c8d48 - g_ps2RecompiledFunctionTable[205649] = bhEne09_Brain_0x1c89e0; // 0x1c8d4c - g_ps2RecompiledFunctionTable[205650] = bhEne09_Brain_0x1c89e0; // 0x1c8d50 - g_ps2RecompiledFunctionTable[205651] = bhEne09_Brain_0x1c89e0; // 0x1c8d54 - g_ps2RecompiledFunctionTable[205652] = bhEne09_Brain_0x1c89e0; // 0x1c8d58 - g_ps2RecompiledFunctionTable[205653] = bhEne09_Brain_0x1c89e0; // 0x1c8d5c - g_ps2RecompiledFunctionTable[205654] = bhEne09_Brain_0x1c89e0; // 0x1c8d60 - g_ps2RecompiledFunctionTable[205655] = bhEne09_Brain_0x1c89e0; // 0x1c8d64 - g_ps2RecompiledFunctionTable[205656] = bhEne09_Brain_0x1c89e0; // 0x1c8d68 - g_ps2RecompiledFunctionTable[205657] = bhEne09_Brain_0x1c89e0; // 0x1c8d6c - g_ps2RecompiledFunctionTable[205658] = bhEne09_Brain_0x1c89e0; // 0x1c8d70 - g_ps2RecompiledFunctionTable[205659] = bhEne09_Brain_0x1c89e0; // 0x1c8d74 - g_ps2RecompiledFunctionTable[205660] = bhEne09_Brain_0x1c89e0; // 0x1c8d78 - g_ps2RecompiledFunctionTable[205661] = bhEne09_Brain_0x1c89e0; // 0x1c8d7c - g_ps2RecompiledFunctionTable[205662] = bhEne09_Brain_0x1c89e0; // 0x1c8d80 - g_ps2RecompiledFunctionTable[205663] = bhEne09_Brain_0x1c89e0; // 0x1c8d84 - g_ps2RecompiledFunctionTable[205664] = bhEne09_Brain_0x1c89e0; // 0x1c8d88 - g_ps2RecompiledFunctionTable[205665] = bhEne09_Brain_0x1c89e0; // 0x1c8d8c - g_ps2RecompiledFunctionTable[205666] = bhEne09_Brain_0x1c89e0; // 0x1c8d90 - g_ps2RecompiledFunctionTable[205667] = bhEne09_Brain_0x1c89e0; // 0x1c8d94 - g_ps2RecompiledFunctionTable[205668] = bhEne09_Brain_0x1c89e0; // 0x1c8d98 - g_ps2RecompiledFunctionTable[205669] = bhEne09_Brain_0x1c89e0; // 0x1c8d9c - g_ps2RecompiledFunctionTable[205670] = bhEne09_Brain_0x1c89e0; // 0x1c8da0 - g_ps2RecompiledFunctionTable[205671] = bhEne09_Brain_0x1c89e0; // 0x1c8da4 - g_ps2RecompiledFunctionTable[205672] = bhEne09_Brain_0x1c89e0; // 0x1c8da8 - g_ps2RecompiledFunctionTable[205673] = bhEne09_Brain_0x1c89e0; // 0x1c8dac - g_ps2RecompiledFunctionTable[205674] = bhEne09_Brain_0x1c89e0; // 0x1c8db0 - g_ps2RecompiledFunctionTable[205675] = bhEne09_Brain_0x1c89e0; // 0x1c8db4 - g_ps2RecompiledFunctionTable[205676] = bhEne09_Brain_0x1c89e0; // 0x1c8db8 - g_ps2RecompiledFunctionTable[205677] = bhEne09_Brain_0x1c89e0; // 0x1c8dbc - g_ps2RecompiledFunctionTable[205678] = bhEne09_Brain_0x1c89e0; // 0x1c8dc0 - g_ps2RecompiledFunctionTable[205679] = bhEne09_Brain_0x1c89e0; // 0x1c8dc4 - g_ps2RecompiledFunctionTable[205680] = bhEne09_Brain_0x1c89e0; // 0x1c8dc8 - g_ps2RecompiledFunctionTable[205681] = bhEne09_Brain_0x1c89e0; // 0x1c8dcc - g_ps2RecompiledFunctionTable[205682] = bhEne09_Brain_0x1c89e0; // 0x1c8dd0 - g_ps2RecompiledFunctionTable[205683] = bhEne09_Brain_0x1c89e0; // 0x1c8dd4 - g_ps2RecompiledFunctionTable[205684] = bhEne09_Brain_0x1c89e0; // 0x1c8dd8 - g_ps2RecompiledFunctionTable[205685] = bhEne09_Brain_0x1c89e0; // 0x1c8ddc - g_ps2RecompiledFunctionTable[205686] = bhEne09_Brain_0x1c89e0; // 0x1c8de0 - g_ps2RecompiledFunctionTable[205687] = bhEne09_Brain_0x1c89e0; // 0x1c8de4 - g_ps2RecompiledFunctionTable[205688] = bhEne09_Brain_0x1c89e0; // 0x1c8de8 - g_ps2RecompiledFunctionTable[205689] = bhEne09_Brain_0x1c89e0; // 0x1c8dec - g_ps2RecompiledFunctionTable[205690] = bhEne09_Brain_0x1c89e0; // 0x1c8df0 - g_ps2RecompiledFunctionTable[205691] = bhEne09_Brain_0x1c89e0; // 0x1c8df4 - g_ps2RecompiledFunctionTable[205692] = bhEne09_Brain_0x1c89e0; // 0x1c8df8 - g_ps2RecompiledFunctionTable[205693] = bhEne09_Brain_0x1c89e0; // 0x1c8dfc - g_ps2RecompiledFunctionTable[205694] = bhEne09_Brain_0x1c89e0; // 0x1c8e00 - g_ps2RecompiledFunctionTable[205695] = bhEne09_Brain_0x1c89e0; // 0x1c8e04 - g_ps2RecompiledFunctionTable[205696] = bhEne09_Brain_0x1c89e0; // 0x1c8e08 - g_ps2RecompiledFunctionTable[205697] = bhEne09_Brain_0x1c89e0; // 0x1c8e0c - g_ps2RecompiledFunctionTable[205698] = bhEne09_Brain_0x1c89e0; // 0x1c8e10 - g_ps2RecompiledFunctionTable[205699] = bhEne09_Brain_0x1c89e0; // 0x1c8e14 - g_ps2RecompiledFunctionTable[205700] = bhEne09_Brain_0x1c89e0; // 0x1c8e18 - g_ps2RecompiledFunctionTable[205701] = bhEne09_Brain_0x1c89e0; // 0x1c8e1c - g_ps2RecompiledFunctionTable[205702] = bhEne09_Brain_0x1c89e0; // 0x1c8e20 - g_ps2RecompiledFunctionTable[205703] = bhEne09_Brain_0x1c89e0; // 0x1c8e24 - g_ps2RecompiledFunctionTable[205704] = bhEne09_Brain_0x1c89e0; // 0x1c8e28 - g_ps2RecompiledFunctionTable[205705] = bhEne09_Brain_0x1c89e0; // 0x1c8e2c - g_ps2RecompiledFunctionTable[205706] = bhEne09_Brain_0x1c89e0; // 0x1c8e30 - g_ps2RecompiledFunctionTable[205707] = bhEne09_Brain_0x1c89e0; // 0x1c8e34 - g_ps2RecompiledFunctionTable[205708] = bhEne09_Brain_0x1c89e0; // 0x1c8e38 - g_ps2RecompiledFunctionTable[205709] = bhEne09_Brain_0x1c89e0; // 0x1c8e3c - g_ps2RecompiledFunctionTable[205710] = bhEne09_Brain_0x1c89e0; // 0x1c8e40 - g_ps2RecompiledFunctionTable[205711] = bhEne09_Brain_0x1c89e0; // 0x1c8e44 - g_ps2RecompiledFunctionTable[205712] = bhEne09_Brain_0x1c89e0; // 0x1c8e48 - g_ps2RecompiledFunctionTable[205713] = bhEne09_Brain_0x1c89e0; // 0x1c8e4c - g_ps2RecompiledFunctionTable[205714] = bhEne09_Brain_0x1c89e0; // 0x1c8e50 - g_ps2RecompiledFunctionTable[205715] = bhEne09_Brain_0x1c89e0; // 0x1c8e54 - g_ps2RecompiledFunctionTable[205716] = bhEne09_Brain_0x1c89e0; // 0x1c8e58 - g_ps2RecompiledFunctionTable[205717] = bhEne09_Brain_0x1c89e0; // 0x1c8e5c - g_ps2RecompiledFunctionTable[205718] = bhEne09_Brain_0x1c89e0; // 0x1c8e60 - g_ps2RecompiledFunctionTable[205719] = bhEne09_Brain_0x1c89e0; // 0x1c8e64 - g_ps2RecompiledFunctionTable[205720] = bhEne09_Brain_0x1c89e0; // 0x1c8e68 - g_ps2RecompiledFunctionTable[205721] = bhEne09_Brain_0x1c89e0; // 0x1c8e6c - g_ps2RecompiledFunctionTable[205722] = bhEne09_Brain_0x1c89e0; // 0x1c8e70 - g_ps2RecompiledFunctionTable[205723] = bhEne09_Brain_0x1c89e0; // 0x1c8e74 - g_ps2RecompiledFunctionTable[205724] = bhEne09_Brain_0x1c89e0; // 0x1c8e78 - g_ps2RecompiledFunctionTable[205725] = bhEne09_Brain_0x1c89e0; // 0x1c8e7c - g_ps2RecompiledFunctionTable[205726] = bhEne09_Brain_0x1c89e0; // 0x1c8e80 - g_ps2RecompiledFunctionTable[205727] = bhEne09_Brain_0x1c89e0; // 0x1c8e84 - g_ps2RecompiledFunctionTable[205728] = bhEne09_Brain_0x1c89e0; // 0x1c8e88 - g_ps2RecompiledFunctionTable[205729] = bhEne09_Brain_0x1c89e0; // 0x1c8e8c - g_ps2RecompiledFunctionTable[205730] = bhEne09_Brain_0x1c89e0; // 0x1c8e90 - g_ps2RecompiledFunctionTable[205731] = bhEne09_Brain_0x1c89e0; // 0x1c8e94 - g_ps2RecompiledFunctionTable[205732] = bhEne09_Brain_0x1c89e0; // 0x1c8e98 - g_ps2RecompiledFunctionTable[205733] = bhEne09_Brain_0x1c89e0; // 0x1c8e9c - g_ps2RecompiledFunctionTable[205734] = bhEne09_Brain_0x1c89e0; // 0x1c8ea0 - g_ps2RecompiledFunctionTable[205735] = bhEne09_Brain_0x1c89e0; // 0x1c8ea4 - g_ps2RecompiledFunctionTable[205736] = bhEne09_Brain_0x1c89e0; // 0x1c8ea8 - g_ps2RecompiledFunctionTable[205737] = bhEne09_Brain_0x1c89e0; // 0x1c8eac - g_ps2RecompiledFunctionTable[205738] = bhEne09_Brain_0x1c89e0; // 0x1c8eb0 - g_ps2RecompiledFunctionTable[205739] = bhEne09_Brain_0x1c89e0; // 0x1c8eb4 - g_ps2RecompiledFunctionTable[205740] = bhEne09_Brain_0x1c89e0; // 0x1c8eb8 - g_ps2RecompiledFunctionTable[205741] = bhEne09_Brain_0x1c89e0; // 0x1c8ebc - g_ps2RecompiledFunctionTable[205742] = bhEne09_Brain_0x1c89e0; // 0x1c8ec0 - g_ps2RecompiledFunctionTable[205743] = bhEne09_Brain_0x1c89e0; // 0x1c8ec4 - g_ps2RecompiledFunctionTable[205744] = bhEne09_Brain_0x1c89e0; // 0x1c8ec8 - g_ps2RecompiledFunctionTable[205745] = bhEne09_Brain_0x1c89e0; // 0x1c8ecc - g_ps2RecompiledFunctionTable[205746] = bhEne09_Brain_0x1c89e0; // 0x1c8ed0 - g_ps2RecompiledFunctionTable[205747] = bhEne09_Brain_0x1c89e0; // 0x1c8ed4 - g_ps2RecompiledFunctionTable[205748] = bhEne09_Brain_0x1c89e0; // 0x1c8ed8 - g_ps2RecompiledFunctionTable[205749] = bhEne09_Brain_0x1c89e0; // 0x1c8edc - g_ps2RecompiledFunctionTable[205750] = bhEne09_Brain_0x1c89e0; // 0x1c8ee0 - g_ps2RecompiledFunctionTable[205751] = bhEne09_Brain_0x1c89e0; // 0x1c8ee4 - g_ps2RecompiledFunctionTable[205752] = bhEne09_Brain_0x1c89e0; // 0x1c8ee8 - g_ps2RecompiledFunctionTable[205753] = bhEne09_Brain_0x1c89e0; // 0x1c8eec - g_ps2RecompiledFunctionTable[205754] = bhEne09_Brain_0x1c89e0; // 0x1c8ef0 - g_ps2RecompiledFunctionTable[205755] = bhEne09_Brain_0x1c89e0; // 0x1c8ef4 - g_ps2RecompiledFunctionTable[205756] = bhEne09_Brain_0x1c89e0; // 0x1c8ef8 - g_ps2RecompiledFunctionTable[205757] = bhEne09_Brain_0x1c89e0; // 0x1c8efc - g_ps2RecompiledFunctionTable[205758] = bhEne09_Brain_0x1c89e0; // 0x1c8f00 - g_ps2RecompiledFunctionTable[205759] = bhEne09_Brain_0x1c89e0; // 0x1c8f04 - g_ps2RecompiledFunctionTable[205760] = bhEne09_Brain_0x1c89e0; // 0x1c8f08 - g_ps2RecompiledFunctionTable[205761] = bhEne09_Brain_0x1c89e0; // 0x1c8f0c - g_ps2RecompiledFunctionTable[205762] = bhEne09_Brain_0x1c89e0; // 0x1c8f10 - g_ps2RecompiledFunctionTable[205763] = bhEne09_Brain_0x1c89e0; // 0x1c8f14 - g_ps2RecompiledFunctionTable[205764] = bhEne09_Brain_0x1c89e0; // 0x1c8f18 - g_ps2RecompiledFunctionTable[205766] = bhEne09_OtherEnemyCheck_0x1c8f20; // 0x1c8f20 - g_ps2RecompiledFunctionTable[205780] = bhEne09_OtherEnemyCheck_0x1c8f20; // 0x1c8f58 - g_ps2RecompiledFunctionTable[205793] = bhEne09_OtherEnemyCheck_0x1c8f20; // 0x1c8f8c - g_ps2RecompiledFunctionTable[205798] = bhEne09_OtherEnemyCheck_0x1c8f20; // 0x1c8fa0 - g_ps2RecompiledFunctionTable[205826] = bhEne09_GetCloseEnemyAtari_0x1c9010; // 0x1c9010 - g_ps2RecompiledFunctionTable[205863] = bhEne09_GetCloseEnemyAtari_0x1c9010; // 0x1c90a4 - g_ps2RecompiledFunctionTable[205924] = bhEne09_GetCloseEnemyAtari_0x1c9010; // 0x1c9198 - g_ps2RecompiledFunctionTable[205978] = bhEne09_JumpCheck_0x1c9270; // 0x1c9270 - g_ps2RecompiledFunctionTable[206005] = bhEne09_JumpCheck_0x1c9270; // 0x1c92dc - g_ps2RecompiledFunctionTable[206112] = bhEne09_JumpCheck_0x1c9270; // 0x1c9488 - g_ps2RecompiledFunctionTable[206159] = bhEne09_JumpCheck_0x1c9270; // 0x1c9544 - g_ps2RecompiledFunctionTable[206201] = bhEne09_JumpCheck_0x1c9270; // 0x1c95ec - g_ps2RecompiledFunctionTable[206218] = bhEne09_Brain00_0x1c9630; // 0x1c9630 - g_ps2RecompiledFunctionTable[206248] = bhEne09_Brain00_0x1c9630; // 0x1c96a8 - g_ps2RecompiledFunctionTable[206276] = bhEne09_Brain00_0x1c9630; // 0x1c9718 - g_ps2RecompiledFunctionTable[206286] = bhEne09_Brain00_0x1c9630; // 0x1c9740 - g_ps2RecompiledFunctionTable[206296] = bhEne09_Brain00_0x1c9630; // 0x1c9768 - g_ps2RecompiledFunctionTable[206306] = bhEne09_Brain00_0x1c9630; // 0x1c9790 - g_ps2RecompiledFunctionTable[206323] = bhEne09_Brain00_0x1c9630; // 0x1c97d4 - g_ps2RecompiledFunctionTable[206346] = bhEne09_AttackCheck_0x1c9830; // 0x1c9830 - g_ps2RecompiledFunctionTable[206379] = bhEne09_AttackCheck_0x1c9830; // 0x1c98b4 - g_ps2RecompiledFunctionTable[206397] = bhEne09_AttackCheck_0x1c9830; // 0x1c98fc - g_ps2RecompiledFunctionTable[206445] = bhEne09_AttackCheck_0x1c9830; // 0x1c99bc - g_ps2RecompiledFunctionTable[206476] = bhEne09_AttackCheck_0x1c9830; // 0x1c9a38 - g_ps2RecompiledFunctionTable[206493] = bhEne09_AttackCheck_0x1c9830; // 0x1c9a7c - g_ps2RecompiledFunctionTable[206518] = bhEne09_AttackCheck_0x1c9830; // 0x1c9ae0 - g_ps2RecompiledFunctionTable[206530] = bhEne09_AttackCheck_0x1c9830; // 0x1c9b10 - g_ps2RecompiledFunctionTable[206540] = bhEne09_AttackCheck_0x1c9830; // 0x1c9b38 - g_ps2RecompiledFunctionTable[206595] = bhEne09_AttackCheck_0x1c9830; // 0x1c9c14 - g_ps2RecompiledFunctionTable[206601] = bhEne09_AttackCheck_0x1c9830; // 0x1c9c2c - g_ps2RecompiledFunctionTable[206618] = bhEne09_AramLineCheck_0x1c9c70; // 0x1c9c70 - g_ps2RecompiledFunctionTable[206653] = bhEne09_AramLineCheck_0x1c9c70; // 0x1c9cfc - g_ps2RecompiledFunctionTable[206659] = bhEne09_AramLineCheck_0x1c9c70; // 0x1c9d14 - g_ps2RecompiledFunctionTable[206668] = bhEne09_AramLineCheck_0x1c9c70; // 0x1c9d38 - g_ps2RecompiledFunctionTable[206680] = bhEne09_AramLineCheck_0x1c9c70; // 0x1c9d68 - g_ps2RecompiledFunctionTable[206710] = bhEne09_MV00_0x1c9de0; // 0x1c9de0 - g_ps2RecompiledFunctionTable[206725] = bhEne09_MV00_0x1c9de0; // 0x1c9e1c - g_ps2RecompiledFunctionTable[206738] = bhEne09_MV00_0x1c9de0; // 0x1c9e50 - g_ps2RecompiledFunctionTable[206745] = bhEne09_MV00_0x1c9de0; // 0x1c9e6c - g_ps2RecompiledFunctionTable[206783] = bhEne09_MV00_0x1c9de0; // 0x1c9f04 - g_ps2RecompiledFunctionTable[206806] = bhEne09_MV01_0x1c9f60; // 0x1c9f60 - g_ps2RecompiledFunctionTable[206824] = bhEne09_MV01_0x1c9f60; // 0x1c9fa8 - g_ps2RecompiledFunctionTable[206845] = bhEne09_MV01_0x1c9f60; // 0x1c9ffc - g_ps2RecompiledFunctionTable[206852] = bhEne09_MV01_0x1c9f60; // 0x1ca018 - g_ps2RecompiledFunctionTable[206859] = bhEne09_MV01_0x1c9f60; // 0x1ca034 - g_ps2RecompiledFunctionTable[206863] = bhEne09_MV01_0x1c9f60; // 0x1ca044 - g_ps2RecompiledFunctionTable[206886] = bhEne09_MV01_0x1c9f60; // 0x1ca0a0 - g_ps2RecompiledFunctionTable[206902] = bhEne09_MV02_0x1ca0e0; // 0x1ca0e0 - g_ps2RecompiledFunctionTable[206906] = bhEne09_MV03_0x1ca0f0; // 0x1ca0f0 - g_ps2RecompiledFunctionTable[206928] = bhEne09_MV03_0x1ca0f0; // 0x1ca148 - g_ps2RecompiledFunctionTable[206938] = bhEne09_MV03_0x1ca0f0; // 0x1ca170 - g_ps2RecompiledFunctionTable[206945] = bhEne09_MV03_0x1ca0f0; // 0x1ca18c - g_ps2RecompiledFunctionTable[206997] = bhEne09_MV03_0x1ca0f0; // 0x1ca25c - g_ps2RecompiledFunctionTable[207008] = bhEne09_MV03_0x1ca0f0; // 0x1ca288 - g_ps2RecompiledFunctionTable[207094] = bhEne09_MV04_0x1ca3e0; // 0x1ca3e0 - g_ps2RecompiledFunctionTable[207113] = bhEne09_MV04_0x1ca3e0; // 0x1ca42c - g_ps2RecompiledFunctionTable[207141] = bhEne09_MV04_0x1ca3e0; // 0x1ca49c - g_ps2RecompiledFunctionTable[207452] = bhEne09_MV04_0x1ca3e0; // 0x1ca978 - g_ps2RecompiledFunctionTable[207510] = bhEne09_MV05_0x1caa60; // 0x1caa60 - g_ps2RecompiledFunctionTable[207534] = bhEne09_MV05_0x1caa60; // 0x1caac0 - g_ps2RecompiledFunctionTable[207576] = bhEne09_MV05_0x1caa60; // 0x1cab68 - g_ps2RecompiledFunctionTable[207595] = bhEne09_MV05_0x1caa60; // 0x1cabb4 - g_ps2RecompiledFunctionTable[207600] = bhEne09_MV05_0x1caa60; // 0x1cabc8 - g_ps2RecompiledFunctionTable[207605] = bhEne09_MV05_0x1caa60; // 0x1cabdc - g_ps2RecompiledFunctionTable[207712] = bhEne09_MV05_0x1caa60; // 0x1cad88 - g_ps2RecompiledFunctionTable[207725] = bhEne09_MV05_0x1caa60; // 0x1cadbc - g_ps2RecompiledFunctionTable[207741] = bhEne09_MV05_0x1caa60; // 0x1cadfc - g_ps2RecompiledFunctionTable[208062] = bhEne09_MV05_0x1caa60; // 0x1cb300 - g_ps2RecompiledFunctionTable[208069] = bhEne09_MV05_0x1caa60; // 0x1cb31c - g_ps2RecompiledFunctionTable[208072] = bhEne09_MV05_0x1caa60; // 0x1cb328 - g_ps2RecompiledFunctionTable[208075] = bhEne09_MV05_0x1caa60; // 0x1cb334 - g_ps2RecompiledFunctionTable[208104] = bhEne09_MV05_0x1caa60; // 0x1cb3a8 - g_ps2RecompiledFunctionTable[208142] = bhEne09_MV06_0x1cb440; // 0x1cb440 - g_ps2RecompiledFunctionTable[208167] = bhEne09_MV06_0x1cb440; // 0x1cb4a4 - g_ps2RecompiledFunctionTable[208209] = bhEne09_MV06_0x1cb440; // 0x1cb54c - g_ps2RecompiledFunctionTable[208216] = bhEne09_MV06_0x1cb440; // 0x1cb568 - g_ps2RecompiledFunctionTable[208343] = bhEne09_MV06_0x1cb440; // 0x1cb764 - g_ps2RecompiledFunctionTable[208349] = bhEne09_MV06_0x1cb440; // 0x1cb77c - g_ps2RecompiledFunctionTable[208417] = bhEne09_MV06_0x1cb440; // 0x1cb88c - g_ps2RecompiledFunctionTable[208477] = bhEne09_MV06_0x1cb440; // 0x1cb97c - g_ps2RecompiledFunctionTable[208502] = bhEne09_MV07_0x1cb9e0; // 0x1cb9e0 - g_ps2RecompiledFunctionTable[208522] = bhEne09_MV07_0x1cb9e0; // 0x1cba30 - g_ps2RecompiledFunctionTable[208538] = bhEne09_MV07_0x1cb9e0; // 0x1cba70 - g_ps2RecompiledFunctionTable[208549] = bhEne09_MV07_0x1cb9e0; // 0x1cba9c - g_ps2RecompiledFunctionTable[208611] = bhEne09_MV07_0x1cb9e0; // 0x1cbb94 - g_ps2RecompiledFunctionTable[208637] = bhEne09_MV07_0x1cb9e0; // 0x1cbbfc - g_ps2RecompiledFunctionTable[208668] = bhEne09_MV07_0x1cb9e0; // 0x1cbc78 - g_ps2RecompiledFunctionTable[208719] = bhEne09_MV07_0x1cb9e0; // 0x1cbd44 - g_ps2RecompiledFunctionTable[208723] = bhEne09_MV07_0x1cb9e0; // 0x1cbd54 - g_ps2RecompiledFunctionTable[208741] = bhEne09_MV07_0x1cb9e0; // 0x1cbd9c - g_ps2RecompiledFunctionTable[208758] = bhEne09_MV08_0x1cbde0; // 0x1cbde0 - g_ps2RecompiledFunctionTable[208773] = bhEne09_MV08_0x1cbde0; // 0x1cbe1c - g_ps2RecompiledFunctionTable[208790] = bhEne09_MV08_0x1cbde0; // 0x1cbe60 - g_ps2RecompiledFunctionTable[208846] = bhEne09_MV09_0x1cbf40; // 0x1cbf40 - g_ps2RecompiledFunctionTable[208860] = bhEne09_MV09_0x1cbf40; // 0x1cbf78 - g_ps2RecompiledFunctionTable[208876] = bhEne09_MV09_0x1cbf40; // 0x1cbfb8 - g_ps2RecompiledFunctionTable[208921] = bhEne09_MV09_0x1cbf40; // 0x1cc06c - g_ps2RecompiledFunctionTable[208938] = bhEne09_MV10_0x1cc0b0; // 0x1cc0b0 - g_ps2RecompiledFunctionTable[208963] = bhEne09_MV10_0x1cc0b0; // 0x1cc114 - g_ps2RecompiledFunctionTable[209022] = bhEne09_MV10_0x1cc0b0; // 0x1cc200 - g_ps2RecompiledFunctionTable[209121] = bhEne09_MV10_0x1cc0b0; // 0x1cc38c - g_ps2RecompiledFunctionTable[209146] = bhEne09_MV11_0x1cc3f0; // 0x1cc3f0 - g_ps2RecompiledFunctionTable[209164] = bhEne09_MV11_0x1cc3f0; // 0x1cc438 - g_ps2RecompiledFunctionTable[209219] = bhEne09_MV11_0x1cc3f0; // 0x1cc514 - g_ps2RecompiledFunctionTable[209328] = bhEne09_MV11_0x1cc3f0; // 0x1cc6c8 - g_ps2RecompiledFunctionTable[209346] = bhEne09_MV12_0x1cc710; // 0x1cc710 - g_ps2RecompiledFunctionTable[209385] = bhEne09_MV12_0x1cc710; // 0x1cc7ac - g_ps2RecompiledFunctionTable[209399] = bhEne09_MV12_0x1cc710; // 0x1cc7e4 - g_ps2RecompiledFunctionTable[209427] = bhEne09_MV12_0x1cc710; // 0x1cc854 - g_ps2RecompiledFunctionTable[209434] = bhEne09_MV12_0x1cc710; // 0x1cc870 - g_ps2RecompiledFunctionTable[209447] = bhEne09_MV12_0x1cc710; // 0x1cc8a4 - g_ps2RecompiledFunctionTable[209489] = bhEne09_MV12_0x1cc710; // 0x1cc94c - g_ps2RecompiledFunctionTable[209507] = bhEne09_MV12_0x1cc710; // 0x1cc994 - g_ps2RecompiledFunctionTable[209550] = bhEne09_MV13_0x1cca40; // 0x1cca40 - g_ps2RecompiledFunctionTable[209573] = bhEne09_MV13_0x1cca40; // 0x1cca9c - g_ps2RecompiledFunctionTable[209583] = bhEne09_MV13_0x1cca40; // 0x1ccac4 - g_ps2RecompiledFunctionTable[209606] = bhEne09_MV13_0x1cca40; // 0x1ccb20 - g_ps2RecompiledFunctionTable[209613] = bhEne09_MV13_0x1cca40; // 0x1ccb3c - g_ps2RecompiledFunctionTable[209626] = bhEne09_MV13_0x1cca40; // 0x1ccb70 - g_ps2RecompiledFunctionTable[209661] = bhEne09_MV13_0x1cca40; // 0x1ccbfc - g_ps2RecompiledFunctionTable[209679] = bhEne09_MV13_0x1cca40; // 0x1ccc44 - g_ps2RecompiledFunctionTable[209718] = bhEne09_MV14_0x1ccce0; // 0x1ccce0 - g_ps2RecompiledFunctionTable[209737] = bhEne09_MV14_0x1ccce0; // 0x1ccd2c - g_ps2RecompiledFunctionTable[209994] = bhEne09_MV14_0x1ccce0; // 0x1cd130 - g_ps2RecompiledFunctionTable[210058] = bhEne09_NGType00_0x1cd230; // 0x1cd230 - g_ps2RecompiledFunctionTable[210059] = bhEne09_NGType00_0x1cd230; // 0x1cd234 - g_ps2RecompiledFunctionTable[210060] = bhEne09_NGType00_0x1cd230; // 0x1cd238 - g_ps2RecompiledFunctionTable[210061] = bhEne09_NGType00_0x1cd230; // 0x1cd23c - g_ps2RecompiledFunctionTable[210062] = bhEne09_NGType00_0x1cd230; // 0x1cd240 - g_ps2RecompiledFunctionTable[210063] = bhEne09_NGType00_0x1cd230; // 0x1cd244 - g_ps2RecompiledFunctionTable[210064] = bhEne09_NGType00_0x1cd230; // 0x1cd248 - g_ps2RecompiledFunctionTable[210065] = bhEne09_NGType00_0x1cd230; // 0x1cd24c - g_ps2RecompiledFunctionTable[210066] = bhEne09_NGType00_0x1cd230; // 0x1cd250 - g_ps2RecompiledFunctionTable[210067] = bhEne09_NGType00_0x1cd230; // 0x1cd254 - g_ps2RecompiledFunctionTable[210068] = bhEne09_NGType00_0x1cd230; // 0x1cd258 - g_ps2RecompiledFunctionTable[210069] = bhEne09_NGType00_0x1cd230; // 0x1cd25c - g_ps2RecompiledFunctionTable[210070] = bhEne09_NGType00_0x1cd230; // 0x1cd260 - g_ps2RecompiledFunctionTable[210071] = bhEne09_NGType00_0x1cd230; // 0x1cd264 - g_ps2RecompiledFunctionTable[210072] = bhEne09_NGType00_0x1cd230; // 0x1cd268 - g_ps2RecompiledFunctionTable[210073] = bhEne09_NGType00_0x1cd230; // 0x1cd26c - g_ps2RecompiledFunctionTable[210074] = bhEne09_NGType00_0x1cd230; // 0x1cd270 - g_ps2RecompiledFunctionTable[210075] = bhEne09_NGType00_0x1cd230; // 0x1cd274 - g_ps2RecompiledFunctionTable[210076] = bhEne09_NGType00_0x1cd230; // 0x1cd278 - g_ps2RecompiledFunctionTable[210077] = bhEne09_NGType00_0x1cd230; // 0x1cd27c - g_ps2RecompiledFunctionTable[210078] = bhEne09_NGType00_0x1cd230; // 0x1cd280 - g_ps2RecompiledFunctionTable[210079] = bhEne09_NGType00_0x1cd230; // 0x1cd284 - g_ps2RecompiledFunctionTable[210080] = bhEne09_NGType00_0x1cd230; // 0x1cd288 - g_ps2RecompiledFunctionTable[210081] = bhEne09_NGType00_0x1cd230; // 0x1cd28c - g_ps2RecompiledFunctionTable[210082] = bhEne09_NGType00_0x1cd230; // 0x1cd290 - g_ps2RecompiledFunctionTable[210083] = bhEne09_NGType00_0x1cd230; // 0x1cd294 - g_ps2RecompiledFunctionTable[210084] = bhEne09_NGType00_0x1cd230; // 0x1cd298 - g_ps2RecompiledFunctionTable[210085] = bhEne09_NGType00_0x1cd230; // 0x1cd29c - g_ps2RecompiledFunctionTable[210086] = bhEne09_NGType00_0x1cd230; // 0x1cd2a0 - g_ps2RecompiledFunctionTable[210087] = bhEne09_NGType00_0x1cd230; // 0x1cd2a4 - g_ps2RecompiledFunctionTable[210088] = bhEne09_NGType00_0x1cd230; // 0x1cd2a8 - g_ps2RecompiledFunctionTable[210089] = bhEne09_NGType00_0x1cd230; // 0x1cd2ac - g_ps2RecompiledFunctionTable[210090] = bhEne09_NGType00_0x1cd230; // 0x1cd2b0 - g_ps2RecompiledFunctionTable[210091] = bhEne09_NGType00_0x1cd230; // 0x1cd2b4 - g_ps2RecompiledFunctionTable[210092] = bhEne09_NGType00_0x1cd230; // 0x1cd2b8 - g_ps2RecompiledFunctionTable[210094] = bhEne09_NG00_0x1cd2c0; // 0x1cd2c0 - g_ps2RecompiledFunctionTable[210150] = bhEne09_NG01_0x1cd3a0; // 0x1cd3a0 - g_ps2RecompiledFunctionTable[210183] = bhEne09_NG01_0x1cd3a0; // 0x1cd424 - g_ps2RecompiledFunctionTable[210201] = bhEne09_NG01_0x1cd3a0; // 0x1cd46c - g_ps2RecompiledFunctionTable[210262] = bhEne09_PlyDG00_0x1cd560; // 0x1cd560 - g_ps2RecompiledFunctionTable[210388] = bhEne09_PlyDG00_0x1cd560; // 0x1cd758 - g_ps2RecompiledFunctionTable[210403] = bhEne09_PlyDG00_0x1cd560; // 0x1cd794 - g_ps2RecompiledFunctionTable[210410] = bhEne09_PlyDG00_0x1cd560; // 0x1cd7b0 - g_ps2RecompiledFunctionTable[210425] = bhEne09_PlyDG00_0x1cd560; // 0x1cd7ec - g_ps2RecompiledFunctionTable[210436] = bhEne09_PlyDG00_0x1cd560; // 0x1cd818 - g_ps2RecompiledFunctionTable[210457] = bhEne09_PlyDG00_0x1cd560; // 0x1cd86c - g_ps2RecompiledFunctionTable[210465] = bhEne09_PlyDG00_0x1cd560; // 0x1cd88c - g_ps2RecompiledFunctionTable[210473] = bhEne09_PlyDG00_0x1cd560; // 0x1cd8ac - g_ps2RecompiledFunctionTable[210546] = bhEne09_PlyDG00_0x1cd560; // 0x1cd9d0 - g_ps2RecompiledFunctionTable[210634] = bhEne09_PlyDG01_0x1cdb30; // 0x1cdb30 - g_ps2RecompiledFunctionTable[210763] = bhEne09_PlyDG01_0x1cdb30; // 0x1cdd34 - g_ps2RecompiledFunctionTable[210778] = bhEne09_PlyDG01_0x1cdb30; // 0x1cdd70 - g_ps2RecompiledFunctionTable[210785] = bhEne09_PlyDG01_0x1cdb30; // 0x1cdd8c - g_ps2RecompiledFunctionTable[210920] = bhEne09_PlyDG01_0x1cdb30; // 0x1cdfa8 - g_ps2RecompiledFunctionTable[210978] = bhEne09_PlyDG01_0x1cdb30; // 0x1ce090 - g_ps2RecompiledFunctionTable[210989] = bhEne09_PlyDG01_0x1cdb30; // 0x1ce0bc - g_ps2RecompiledFunctionTable[211018] = bhEne09_PlyNageCheck_0x1ce130; // 0x1ce130 - g_ps2RecompiledFunctionTable[211062] = bhEne09_PlyNageCheck_0x1ce130; // 0x1ce1e0 - g_ps2RecompiledFunctionTable[211069] = bhEne09_PlyNageCheck_0x1ce130; // 0x1ce1fc - g_ps2RecompiledFunctionTable[211074] = bhEne09_PlyNageCheck_0x1ce130; // 0x1ce210 - g_ps2RecompiledFunctionTable[211088] = bhEne09_PlyNageCheck_0x1ce130; // 0x1ce248 - g_ps2RecompiledFunctionTable[211114] = bhEne09_PlyNageCheck_0x1ce130; // 0x1ce2b0 - g_ps2RecompiledFunctionTable[211142] = bhEne09_PlyNageCheck_0x1ce130; // 0x1ce320 - g_ps2RecompiledFunctionTable[211162] = bhEne09_PlyNageCheck_0x1ce130; // 0x1ce370 - g_ps2RecompiledFunctionTable[211164] = bhEne09_PlyNageCheck_0x1ce130; // 0x1ce378 - g_ps2RecompiledFunctionTable[211174] = bhEne09_DGType00_0x1ce3a0; // 0x1ce3a0 - g_ps2RecompiledFunctionTable[211175] = bhEne09_DGType00_0x1ce3a0; // 0x1ce3a4 - g_ps2RecompiledFunctionTable[211176] = bhEne09_DGType00_0x1ce3a0; // 0x1ce3a8 - g_ps2RecompiledFunctionTable[211177] = bhEne09_DGType00_0x1ce3a0; // 0x1ce3ac - g_ps2RecompiledFunctionTable[211178] = bhEne09_DGType00_0x1ce3a0; // 0x1ce3b0 - g_ps2RecompiledFunctionTable[211179] = bhEne09_DGType00_0x1ce3a0; // 0x1ce3b4 - g_ps2RecompiledFunctionTable[211180] = bhEne09_DGType00_0x1ce3a0; // 0x1ce3b8 - g_ps2RecompiledFunctionTable[211181] = bhEne09_DGType00_0x1ce3a0; // 0x1ce3bc - g_ps2RecompiledFunctionTable[211182] = bhEne09_DG00_0x1ce3c0; // 0x1ce3c0 - g_ps2RecompiledFunctionTable[211240] = bhEne09_DG00_0x1ce3c0; // 0x1ce4a8 - g_ps2RecompiledFunctionTable[211303] = bhEne09_DG00_0x1ce3c0; // 0x1ce5a4 - g_ps2RecompiledFunctionTable[211370] = bhEne09_DG01_0x1ce6b0; // 0x1ce6b0 - g_ps2RecompiledFunctionTable[211428] = bhEne09_DG01_0x1ce6b0; // 0x1ce798 - g_ps2RecompiledFunctionTable[211509] = bhEne09_DG01_0x1ce6b0; // 0x1ce8dc - g_ps2RecompiledFunctionTable[211578] = bhEne09_DG02_0x1ce9f0; // 0x1ce9f0 - g_ps2RecompiledFunctionTable[211636] = bhEne09_DG02_0x1ce9f0; // 0x1cead8 - g_ps2RecompiledFunctionTable[211717] = bhEne09_DG02_0x1ce9f0; // 0x1cec1c - g_ps2RecompiledFunctionTable[211786] = bhEne09_DG03_0x1ced30; // 0x1ced30 - g_ps2RecompiledFunctionTable[211849] = bhEne09_DG03_0x1ced30; // 0x1cee2c - g_ps2RecompiledFunctionTable[211859] = bhEne09_DG03_0x1ced30; // 0x1cee54 - g_ps2RecompiledFunctionTable[211889] = bhEne09_DG03_0x1ced30; // 0x1ceecc - g_ps2RecompiledFunctionTable[211894] = bhEne09_DG03_0x1ced30; // 0x1ceee0 - g_ps2RecompiledFunctionTable[212039] = bhEne09_DG03_0x1ced30; // 0x1cf124 - g_ps2RecompiledFunctionTable[212044] = bhEne09_DG03_0x1ced30; // 0x1cf138 - g_ps2RecompiledFunctionTable[212047] = bhEne09_DG03_0x1ced30; // 0x1cf144 - g_ps2RecompiledFunctionTable[212059] = bhEne09_DG03_0x1ced30; // 0x1cf174 - g_ps2RecompiledFunctionTable[212066] = bhEne09_DG04_0x1cf190; // 0x1cf190 - g_ps2RecompiledFunctionTable[212115] = bhEne09_DG04_0x1cf190; // 0x1cf254 - g_ps2RecompiledFunctionTable[212129] = bhEne09_DG04_0x1cf190; // 0x1cf28c - g_ps2RecompiledFunctionTable[212290] = bhEne09_DG05_0x1cf510; // 0x1cf510 - g_ps2RecompiledFunctionTable[212358] = bhEne09_DG05_0x1cf510; // 0x1cf620 - g_ps2RecompiledFunctionTable[212524] = bhEne09_DG05_0x1cf510; // 0x1cf8b8 - g_ps2RecompiledFunctionTable[212653] = bhEne09_DG05_0x1cf510; // 0x1cfabc - g_ps2RecompiledFunctionTable[212660] = bhEne09_DG05_0x1cf510; // 0x1cfad8 - g_ps2RecompiledFunctionTable[212663] = bhEne09_DG05_0x1cf510; // 0x1cfae4 - g_ps2RecompiledFunctionTable[212666] = bhEne09_DG05_0x1cf510; // 0x1cfaf0 - g_ps2RecompiledFunctionTable[212702] = bhEne09_DG06_0x1cfb80; // 0x1cfb80 - g_ps2RecompiledFunctionTable[212736] = bhEne09_DG06_0x1cfb80; // 0x1cfc08 - g_ps2RecompiledFunctionTable[212784] = bhEne09_DG06_0x1cfb80; // 0x1cfcc8 - g_ps2RecompiledFunctionTable[212787] = bhEne09_DG06_0x1cfb80; // 0x1cfcd4 - g_ps2RecompiledFunctionTable[212818] = bhEne09_DG06_0x1cfb80; // 0x1cfd50 - g_ps2RecompiledFunctionTable[212825] = bhEne09_DG06_0x1cfb80; // 0x1cfd6c - g_ps2RecompiledFunctionTable[212922] = bhEne09_DG07_0x1cfef0; // 0x1cfef0 - g_ps2RecompiledFunctionTable[212954] = bhEne09_DG07_0x1cfef0; // 0x1cff70 - g_ps2RecompiledFunctionTable[213098] = bhEne09_DG08_0x1d01b0; // 0x1d01b0 - g_ps2RecompiledFunctionTable[213146] = bhEne09_DG08_0x1d01b0; // 0x1d0270 - g_ps2RecompiledFunctionTable[213194] = bhEne09_DG08_0x1d01b0; // 0x1d0330 - g_ps2RecompiledFunctionTable[213197] = bhEne09_DG08_0x1d01b0; // 0x1d033c - g_ps2RecompiledFunctionTable[213228] = bhEne09_DG08_0x1d01b0; // 0x1d03b8 - g_ps2RecompiledFunctionTable[213235] = bhEne09_DG08_0x1d01b0; // 0x1d03d4 - g_ps2RecompiledFunctionTable[213346] = bhEne09_DG09_0x1d0590; // 0x1d0590 - g_ps2RecompiledFunctionTable[213388] = bhEne09_DG09_0x1d0590; // 0x1d0638 - g_ps2RecompiledFunctionTable[213406] = bhEne09_DG09_0x1d0590; // 0x1d0680 - g_ps2RecompiledFunctionTable[213408] = bhEne09_DG09_0x1d0590; // 0x1d0688 - g_ps2RecompiledFunctionTable[213442] = bhEne09_DG09_0x1d0590; // 0x1d0710 - g_ps2RecompiledFunctionTable[213445] = bhEne09_DG09_0x1d0590; // 0x1d071c - g_ps2RecompiledFunctionTable[213476] = bhEne09_DG09_0x1d0590; // 0x1d0798 - g_ps2RecompiledFunctionTable[213590] = bhEne09_DG10_0x1d0960; // 0x1d0960 - g_ps2RecompiledFunctionTable[213612] = bhEne09_DG10_0x1d0960; // 0x1d09b8 - g_ps2RecompiledFunctionTable[213625] = bhEne09_DG10_0x1d0960; // 0x1d09ec - g_ps2RecompiledFunctionTable[213638] = bhEne09_DG10_0x1d0960; // 0x1d0a20 - g_ps2RecompiledFunctionTable[213651] = bhEne09_DG10_0x1d0960; // 0x1d0a54 - g_ps2RecompiledFunctionTable[213710] = bhEne09_DDType00_0x1d0b40; // 0x1d0b40 - g_ps2RecompiledFunctionTable[213711] = bhEne09_DDType00_0x1d0b40; // 0x1d0b44 - g_ps2RecompiledFunctionTable[213712] = bhEne09_DDType00_0x1d0b40; // 0x1d0b48 - g_ps2RecompiledFunctionTable[213713] = bhEne09_DDType00_0x1d0b40; // 0x1d0b4c - g_ps2RecompiledFunctionTable[213714] = bhEne09_DDType00_0x1d0b40; // 0x1d0b50 - g_ps2RecompiledFunctionTable[213715] = bhEne09_DDType00_0x1d0b40; // 0x1d0b54 - g_ps2RecompiledFunctionTable[213716] = bhEne09_DDType00_0x1d0b40; // 0x1d0b58 - g_ps2RecompiledFunctionTable[213717] = bhEne09_DDType00_0x1d0b40; // 0x1d0b5c - g_ps2RecompiledFunctionTable[213718] = bhEne09_DD00_0x1d0b60; // 0x1d0b60 - g_ps2RecompiledFunctionTable[213747] = bhEne09_DD00_0x1d0b60; // 0x1d0bd4 - g_ps2RecompiledFunctionTable[213757] = bhEne09_DD00_0x1d0b60; // 0x1d0bfc - g_ps2RecompiledFunctionTable[213773] = bhEne09_DD00_0x1d0b60; // 0x1d0c3c - g_ps2RecompiledFunctionTable[213785] = bhEne09_DD00_0x1d0b60; // 0x1d0c6c - g_ps2RecompiledFunctionTable[213817] = bhEne09_DD00_0x1d0b60; // 0x1d0cec - g_ps2RecompiledFunctionTable[213834] = bhEne09_CollChkArm_0x1d0d30; // 0x1d0d30 - g_ps2RecompiledFunctionTable[213860] = bhEne09_CollChkArm_0x1d0d30; // 0x1d0d98 - g_ps2RecompiledFunctionTable[213880] = bhEne09_CollChkArm_0x1d0d30; // 0x1d0de8 - g_ps2RecompiledFunctionTable[213900] = bhEne09_CollChkArm_0x1d0d30; // 0x1d0e38 - g_ps2RecompiledFunctionTable[213915] = bhEne09_CollChkArm_0x1d0d30; // 0x1d0e74 - g_ps2RecompiledFunctionTable[213920] = bhEne09_CollChkArm_0x1d0d30; // 0x1d0e88 - g_ps2RecompiledFunctionTable[213923] = bhEne09_CollChkArm_0x1d0d30; // 0x1d0e94 - g_ps2RecompiledFunctionTable[213932] = bhEne09_CollChkArm_0x1d0d30; // 0x1d0eb8 - g_ps2RecompiledFunctionTable[213962] = bhEne09_CollChkArm2_0x1d0f30; // 0x1d0f30 - g_ps2RecompiledFunctionTable[213980] = bhEne09_CollChkArm2_0x1d0f30; // 0x1d0f78 - g_ps2RecompiledFunctionTable[214008] = bhEne09_CollChkArm2_0x1d0f30; // 0x1d0fe8 - g_ps2RecompiledFunctionTable[214013] = bhEne09_CollChkArm2_0x1d0f30; // 0x1d0ffc - g_ps2RecompiledFunctionTable[214044] = bhEne09_CollChkArm2_0x1d0f30; // 0x1d1078 - g_ps2RecompiledFunctionTable[214071] = bhEne09_CollChkArm2_0x1d0f30; // 0x1d10e4 - g_ps2RecompiledFunctionTable[214091] = bhEne09_CollChkArm2_0x1d0f30; // 0x1d1134 - g_ps2RecompiledFunctionTable[214093] = bhEne09_CollChkArm2_0x1d0f30; // 0x1d113c - g_ps2RecompiledFunctionTable[214112] = bhEne09_CollChkArm2_0x1d0f30; // 0x1d1188 - g_ps2RecompiledFunctionTable[214124] = bhEne09_CollChkArm2_0x1d0f30; // 0x1d11b8 - g_ps2RecompiledFunctionTable[214144] = bhEne09_CollChkArm2_0x1d0f30; // 0x1d1208 - g_ps2RecompiledFunctionTable[214158] = bhEne09_ChkArmLen2_0x1d1240; // 0x1d1240 - g_ps2RecompiledFunctionTable[214190] = bhEne09_ChkArmLen2_0x1d1240; // 0x1d12c0 - g_ps2RecompiledFunctionTable[214212] = bhEne09_ChkArmLen2_0x1d1240; // 0x1d1318 - g_ps2RecompiledFunctionTable[214221] = bhEne09_ChkArmLen2_0x1d1240; // 0x1d133c - g_ps2RecompiledFunctionTable[214226] = bhEne09_ChkArmLen2_0x1d1240; // 0x1d1350 - g_ps2RecompiledFunctionTable[214235] = bhEne09_ChkArmLen2_0x1d1240; // 0x1d1374 - g_ps2RecompiledFunctionTable[214258] = bhEne09_ChkArmLen2_0x1d1240; // 0x1d13d0 - g_ps2RecompiledFunctionTable[214262] = bhEne09_ChkArmLen2_0x1d1240; // 0x1d13e0 - g_ps2RecompiledFunctionTable[214264] = bhEne09_ChkArmLen2_0x1d1240; // 0x1d13e8 - g_ps2RecompiledFunctionTable[214288] = bhEne09_ChkArmLen2_0x1d1240; // 0x1d1448 - g_ps2RecompiledFunctionTable[214293] = bhEne09_ChkArmLen2_0x1d1240; // 0x1d145c - g_ps2RecompiledFunctionTable[214325] = bhEne09_ChkArmLen2_0x1d1240; // 0x1d14dc - g_ps2RecompiledFunctionTable[214354] = bhEne09_ChkArmLen_0x1d1550; // 0x1d1550 - g_ps2RecompiledFunctionTable[214397] = bhEne09_ChkArmLen_0x1d1550; // 0x1d15fc - g_ps2RecompiledFunctionTable[214420] = bhEne09_ChkArmLen_0x1d1550; // 0x1d1658 - g_ps2RecompiledFunctionTable[214429] = bhEne09_ChkArmLen_0x1d1550; // 0x1d167c - g_ps2RecompiledFunctionTable[214445] = bhEne09_ChkArmLen_0x1d1550; // 0x1d16bc - g_ps2RecompiledFunctionTable[214448] = bhEne09_ChkArmLen_0x1d1550; // 0x1d16c8 - g_ps2RecompiledFunctionTable[214452] = bhEne09_ChkArmLen_0x1d1550; // 0x1d16d8 - g_ps2RecompiledFunctionTable[214482] = bhEne09_ChkArmLen_0x1d1550; // 0x1d1750 - g_ps2RecompiledFunctionTable[214487] = bhEne09_ChkArmLen_0x1d1550; // 0x1d1764 - g_ps2RecompiledFunctionTable[214522] = bhEne09_ChkArmLen_0x1d1550; // 0x1d17f0 - g_ps2RecompiledFunctionTable[214551] = bhEne09_ChkArmLen_0x1d1550; // 0x1d1864 - g_ps2RecompiledFunctionTable[214590] = bhEne09_ChkDiffAngle_0x1d1900; // 0x1d1900 - g_ps2RecompiledFunctionTable[214602] = bhEne09_SetMtn_0x1d1930; // 0x1d1930 - g_ps2RecompiledFunctionTable[214625] = bhEne09_SetMtn_0x1d1930; // 0x1d198c - g_ps2RecompiledFunctionTable[214678] = bhEne09_SetMtn_0x1d1930; // 0x1d1a60 - g_ps2RecompiledFunctionTable[214741] = bhEne09_SetMtn_0x1d1930; // 0x1d1b5c - g_ps2RecompiledFunctionTable[214755] = bhEne09_SetMtn_0x1d1930; // 0x1d1b94 - g_ps2RecompiledFunctionTable[214867] = bhEne09_SetMtn_0x1d1930; // 0x1d1d54 - g_ps2RecompiledFunctionTable[214878] = bhEne09_MtnTblPlay_0x1d1d80; // 0x1d1d80 - g_ps2RecompiledFunctionTable[214916] = bhEne09_MtnTblPlay_0x1d1d80; // 0x1d1e18 - g_ps2RecompiledFunctionTable[214923] = bhEne09_MtnTblPlay_0x1d1d80; // 0x1d1e34 - g_ps2RecompiledFunctionTable[214972] = bhEne09_MtnTblPlay_0x1d1d80; // 0x1d1ef8 - g_ps2RecompiledFunctionTable[214980] = bhEne09_MtnTblPlay_0x1d1d80; // 0x1d1f18 - g_ps2RecompiledFunctionTable[215006] = bhEne09_MtnTblPlay_0x1d1d80; // 0x1d1f80 - g_ps2RecompiledFunctionTable[215014] = bhEne09_MtnTblPlay_0x1d1d80; // 0x1d1fa0 - g_ps2RecompiledFunctionTable[215029] = bhEne09_MtnTblPlay_0x1d1d80; // 0x1d1fdc - g_ps2RecompiledFunctionTable[215054] = bhEne09_MtnTblPlay_0x1d1d80; // 0x1d2040 - g_ps2RecompiledFunctionTable[215060] = bhEne09_MtnTblPlay_0x1d1d80; // 0x1d2058 - g_ps2RecompiledFunctionTable[215069] = bhEne09_MtnTblPlay_0x1d1d80; // 0x1d207c - g_ps2RecompiledFunctionTable[215086] = bhEne09_MtnTblPlay_0x1d1d80; // 0x1d20c0 - g_ps2RecompiledFunctionTable[215092] = bhEne09_MtnTblPlay_0x1d1d80; // 0x1d20d8 - g_ps2RecompiledFunctionTable[215100] = bhEne09_MtnTblPlay_0x1d1d80; // 0x1d20f8 - g_ps2RecompiledFunctionTable[215122] = bhEne09_SePlay_0x1d2150; // 0x1d2150 - g_ps2RecompiledFunctionTable[215137] = bhEne09_SePlay_0x1d2150; // 0x1d218c - g_ps2RecompiledFunctionTable[215142] = bhEne09_SetSmokeEffect_0x1d21a0; // 0x1d21a0 - g_ps2RecompiledFunctionTable[215205] = bhEne09_SetSmokeEffect_0x1d21a0; // 0x1d229c - g_ps2RecompiledFunctionTable[215207] = bhEne09_SetSmokeEffect_0x1d21a0; // 0x1d22a4 - g_ps2RecompiledFunctionTable[215228] = bhEne09_SetSmokeEffect_0x1d21a0; // 0x1d22f8 - g_ps2RecompiledFunctionTable[215257] = bhEne09_SetSmokeEffect_0x1d21a0; // 0x1d236c - g_ps2RecompiledFunctionTable[215277] = bhEne09_SetSmokeEffect_0x1d21a0; // 0x1d23bc - g_ps2RecompiledFunctionTable[215310] = bhEne10_0x1d2440; // 0x1d2440 - g_ps2RecompiledFunctionTable[215311] = bhEne10_0x1d2440; // 0x1d2444 - g_ps2RecompiledFunctionTable[215312] = bhEne10_0x1d2440; // 0x1d2448 - g_ps2RecompiledFunctionTable[215313] = bhEne10_0x1d2440; // 0x1d244c - g_ps2RecompiledFunctionTable[215314] = bhEne10_0x1d2440; // 0x1d2450 - g_ps2RecompiledFunctionTable[215315] = bhEne10_0x1d2440; // 0x1d2454 - g_ps2RecompiledFunctionTable[215316] = bhEne10_0x1d2440; // 0x1d2458 - g_ps2RecompiledFunctionTable[215317] = bhEne10_0x1d2440; // 0x1d245c - g_ps2RecompiledFunctionTable[215318] = bhEne10_0x1d2440; // 0x1d2460 - g_ps2RecompiledFunctionTable[215319] = bhEne10_0x1d2440; // 0x1d2464 - g_ps2RecompiledFunctionTable[215320] = bhEne10_0x1d2440; // 0x1d2468 - g_ps2RecompiledFunctionTable[215321] = bhEne10_0x1d2440; // 0x1d246c - g_ps2RecompiledFunctionTable[215322] = bhEne10_0x1d2440; // 0x1d2470 - g_ps2RecompiledFunctionTable[215323] = bhEne10_0x1d2440; // 0x1d2474 - g_ps2RecompiledFunctionTable[215324] = bhEne10_0x1d2440; // 0x1d2478 - g_ps2RecompiledFunctionTable[215325] = bhEne10_0x1d2440; // 0x1d247c - g_ps2RecompiledFunctionTable[215326] = bhEne10_0x1d2440; // 0x1d2480 - g_ps2RecompiledFunctionTable[215327] = bhEne10_0x1d2440; // 0x1d2484 - g_ps2RecompiledFunctionTable[215328] = bhEne10_0x1d2440; // 0x1d2488 - g_ps2RecompiledFunctionTable[215329] = bhEne10_0x1d2440; // 0x1d248c - g_ps2RecompiledFunctionTable[215330] = bhEne10_0x1d2440; // 0x1d2490 - g_ps2RecompiledFunctionTable[215331] = bhEne10_0x1d2440; // 0x1d2494 - g_ps2RecompiledFunctionTable[215332] = bhEne10_0x1d2440; // 0x1d2498 - g_ps2RecompiledFunctionTable[215333] = bhEne10_0x1d2440; // 0x1d249c - g_ps2RecompiledFunctionTable[215334] = bhEne10_0x1d2440; // 0x1d24a0 - g_ps2RecompiledFunctionTable[215335] = bhEne10_0x1d2440; // 0x1d24a4 - g_ps2RecompiledFunctionTable[215336] = bhEne10_0x1d2440; // 0x1d24a8 - g_ps2RecompiledFunctionTable[215337] = bhEne10_0x1d2440; // 0x1d24ac - g_ps2RecompiledFunctionTable[215338] = bhEne10_0x1d2440; // 0x1d24b0 - g_ps2RecompiledFunctionTable[215339] = bhEne10_0x1d2440; // 0x1d24b4 - g_ps2RecompiledFunctionTable[215340] = bhEne10_0x1d2440; // 0x1d24b8 - g_ps2RecompiledFunctionTable[215341] = bhEne10_0x1d2440; // 0x1d24bc - g_ps2RecompiledFunctionTable[215342] = bhEne10_0x1d2440; // 0x1d24c0 - g_ps2RecompiledFunctionTable[215343] = bhEne10_0x1d2440; // 0x1d24c4 - g_ps2RecompiledFunctionTable[215344] = bhEne10_0x1d2440; // 0x1d24c8 - g_ps2RecompiledFunctionTable[215345] = bhEne10_0x1d2440; // 0x1d24cc - g_ps2RecompiledFunctionTable[215346] = bhEne10_0x1d2440; // 0x1d24d0 - g_ps2RecompiledFunctionTable[215347] = bhEne10_0x1d2440; // 0x1d24d4 - g_ps2RecompiledFunctionTable[215348] = bhEne10_0x1d2440; // 0x1d24d8 - g_ps2RecompiledFunctionTable[215349] = bhEne10_0x1d2440; // 0x1d24dc - g_ps2RecompiledFunctionTable[215350] = bhEne10_0x1d2440; // 0x1d24e0 - g_ps2RecompiledFunctionTable[215351] = bhEne10_0x1d2440; // 0x1d24e4 - g_ps2RecompiledFunctionTable[215352] = bhEne10_0x1d2440; // 0x1d24e8 - g_ps2RecompiledFunctionTable[215353] = bhEne10_0x1d2440; // 0x1d24ec - g_ps2RecompiledFunctionTable[215354] = bhEne10_0x1d2440; // 0x1d24f0 - g_ps2RecompiledFunctionTable[215355] = bhEne10_0x1d2440; // 0x1d24f4 - g_ps2RecompiledFunctionTable[215356] = bhEne10_0x1d2440; // 0x1d24f8 - g_ps2RecompiledFunctionTable[215357] = bhEne10_0x1d2440; // 0x1d24fc - g_ps2RecompiledFunctionTable[215358] = bhEne10_0x1d2440; // 0x1d2500 - g_ps2RecompiledFunctionTable[215359] = bhEne10_0x1d2440; // 0x1d2504 - g_ps2RecompiledFunctionTable[215360] = bhEne10_0x1d2440; // 0x1d2508 - g_ps2RecompiledFunctionTable[215361] = bhEne10_0x1d2440; // 0x1d250c - g_ps2RecompiledFunctionTable[215362] = bhEne10_0x1d2440; // 0x1d2510 - g_ps2RecompiledFunctionTable[215363] = bhEne10_0x1d2440; // 0x1d2514 - g_ps2RecompiledFunctionTable[215364] = bhEne10_0x1d2440; // 0x1d2518 - g_ps2RecompiledFunctionTable[215365] = bhEne10_0x1d2440; // 0x1d251c - g_ps2RecompiledFunctionTable[215366] = bhEne10_0x1d2440; // 0x1d2520 - g_ps2RecompiledFunctionTable[215367] = bhEne10_0x1d2440; // 0x1d2524 - g_ps2RecompiledFunctionTable[215368] = bhEne10_0x1d2440; // 0x1d2528 - g_ps2RecompiledFunctionTable[215369] = bhEne10_0x1d2440; // 0x1d252c - g_ps2RecompiledFunctionTable[215370] = bhEne10_0x1d2440; // 0x1d2530 - g_ps2RecompiledFunctionTable[215371] = bhEne10_0x1d2440; // 0x1d2534 - g_ps2RecompiledFunctionTable[215372] = bhEne10_0x1d2440; // 0x1d2538 - g_ps2RecompiledFunctionTable[215373] = bhEne10_0x1d2440; // 0x1d253c - g_ps2RecompiledFunctionTable[215374] = bhEne10_0x1d2440; // 0x1d2540 - g_ps2RecompiledFunctionTable[215375] = bhEne10_0x1d2440; // 0x1d2544 - g_ps2RecompiledFunctionTable[215376] = bhEne10_0x1d2440; // 0x1d2548 - g_ps2RecompiledFunctionTable[215377] = bhEne10_0x1d2440; // 0x1d254c - g_ps2RecompiledFunctionTable[215378] = bhEne10_0x1d2440; // 0x1d2550 - g_ps2RecompiledFunctionTable[215379] = bhEne10_0x1d2440; // 0x1d2554 - g_ps2RecompiledFunctionTable[215380] = bhEne10_0x1d2440; // 0x1d2558 - g_ps2RecompiledFunctionTable[215381] = bhEne10_0x1d2440; // 0x1d255c - g_ps2RecompiledFunctionTable[215382] = bhEne10_0x1d2440; // 0x1d2560 - g_ps2RecompiledFunctionTable[215383] = bhEne10_0x1d2440; // 0x1d2564 - g_ps2RecompiledFunctionTable[215384] = bhEne10_0x1d2440; // 0x1d2568 - g_ps2RecompiledFunctionTable[215385] = bhEne10_0x1d2440; // 0x1d256c - g_ps2RecompiledFunctionTable[215386] = bhEne10_0x1d2440; // 0x1d2570 - g_ps2RecompiledFunctionTable[215387] = bhEne10_0x1d2440; // 0x1d2574 - g_ps2RecompiledFunctionTable[215388] = bhEne10_0x1d2440; // 0x1d2578 - g_ps2RecompiledFunctionTable[215389] = bhEne10_0x1d2440; // 0x1d257c - g_ps2RecompiledFunctionTable[215390] = bhEne10_0x1d2440; // 0x1d2580 - g_ps2RecompiledFunctionTable[215391] = bhEne10_0x1d2440; // 0x1d2584 - g_ps2RecompiledFunctionTable[215392] = bhEne10_0x1d2440; // 0x1d2588 - g_ps2RecompiledFunctionTable[215393] = bhEne10_0x1d2440; // 0x1d258c - g_ps2RecompiledFunctionTable[215394] = bhEne10_0x1d2440; // 0x1d2590 - g_ps2RecompiledFunctionTable[215395] = bhEne10_0x1d2440; // 0x1d2594 - g_ps2RecompiledFunctionTable[215396] = bhEne10_0x1d2440; // 0x1d2598 - g_ps2RecompiledFunctionTable[215397] = bhEne10_0x1d2440; // 0x1d259c - g_ps2RecompiledFunctionTable[215398] = bhEne10_0x1d2440; // 0x1d25a0 - g_ps2RecompiledFunctionTable[215399] = bhEne10_0x1d2440; // 0x1d25a4 - g_ps2RecompiledFunctionTable[215400] = bhEne10_0x1d2440; // 0x1d25a8 - g_ps2RecompiledFunctionTable[215401] = bhEne10_0x1d2440; // 0x1d25ac - g_ps2RecompiledFunctionTable[215402] = bhEne10_0x1d2440; // 0x1d25b0 - g_ps2RecompiledFunctionTable[215403] = bhEne10_0x1d2440; // 0x1d25b4 - g_ps2RecompiledFunctionTable[215404] = bhEne10_0x1d2440; // 0x1d25b8 - g_ps2RecompiledFunctionTable[215405] = bhEne10_0x1d2440; // 0x1d25bc - g_ps2RecompiledFunctionTable[215406] = bhEne10_0x1d2440; // 0x1d25c0 - g_ps2RecompiledFunctionTable[215407] = bhEne10_0x1d2440; // 0x1d25c4 - g_ps2RecompiledFunctionTable[215408] = bhEne10_0x1d2440; // 0x1d25c8 - g_ps2RecompiledFunctionTable[215409] = bhEne10_0x1d2440; // 0x1d25cc - g_ps2RecompiledFunctionTable[215410] = bhEne10_0x1d2440; // 0x1d25d0 - g_ps2RecompiledFunctionTable[215411] = bhEne10_0x1d2440; // 0x1d25d4 - g_ps2RecompiledFunctionTable[215412] = bhEne10_0x1d2440; // 0x1d25d8 - g_ps2RecompiledFunctionTable[215413] = bhEne10_0x1d2440; // 0x1d25dc - g_ps2RecompiledFunctionTable[215414] = bhEne10_0x1d2440; // 0x1d25e0 - g_ps2RecompiledFunctionTable[215415] = bhEne10_0x1d2440; // 0x1d25e4 - g_ps2RecompiledFunctionTable[215416] = bhEne10_0x1d2440; // 0x1d25e8 - g_ps2RecompiledFunctionTable[215417] = bhEne10_0x1d2440; // 0x1d25ec - g_ps2RecompiledFunctionTable[215418] = bhEne10_0x1d2440; // 0x1d25f0 - g_ps2RecompiledFunctionTable[215419] = bhEne10_0x1d2440; // 0x1d25f4 - g_ps2RecompiledFunctionTable[215420] = bhEne10_0x1d2440; // 0x1d25f8 - g_ps2RecompiledFunctionTable[215421] = bhEne10_0x1d2440; // 0x1d25fc - g_ps2RecompiledFunctionTable[215422] = bhEne10_0x1d2440; // 0x1d2600 - g_ps2RecompiledFunctionTable[215423] = bhEne10_0x1d2440; // 0x1d2604 - g_ps2RecompiledFunctionTable[215424] = bhEne10_0x1d2440; // 0x1d2608 - g_ps2RecompiledFunctionTable[215425] = bhEne10_0x1d2440; // 0x1d260c - g_ps2RecompiledFunctionTable[215426] = bhEne10_0x1d2440; // 0x1d2610 - g_ps2RecompiledFunctionTable[215427] = bhEne10_0x1d2440; // 0x1d2614 - g_ps2RecompiledFunctionTable[215430] = bhEne10_Init_0x1d2620; // 0x1d2620 - g_ps2RecompiledFunctionTable[215440] = bhEne10_Init_0x1d2620; // 0x1d2648 - g_ps2RecompiledFunctionTable[215490] = bhEne10_Init_0x1d2620; // 0x1d2710 - g_ps2RecompiledFunctionTable[215497] = bhEne10_Init_0x1d2620; // 0x1d272c - g_ps2RecompiledFunctionTable[215501] = bhEne10_Init_0x1d2620; // 0x1d273c - g_ps2RecompiledFunctionTable[215508] = bhEne10_Init_0x1d2620; // 0x1d2758 - g_ps2RecompiledFunctionTable[215510] = bhEne10_Init_0x1d2620; // 0x1d2760 - g_ps2RecompiledFunctionTable[215512] = bhEne10_Init_0x1d2620; // 0x1d2768 - g_ps2RecompiledFunctionTable[215538] = bhEne10_CheckPos_0x1d27d0; // 0x1d27d0 - g_ps2RecompiledFunctionTable[215554] = bhEne10_CheckPos_0x1d27d0; // 0x1d2810 - g_ps2RecompiledFunctionTable[215567] = bhEne10_CheckPos_0x1d27d0; // 0x1d2844 - g_ps2RecompiledFunctionTable[215572] = bhEne10_CheckPos_0x1d27d0; // 0x1d2858 - g_ps2RecompiledFunctionTable[215577] = bhEne10_CheckPos_0x1d27d0; // 0x1d286c - g_ps2RecompiledFunctionTable[215590] = bhEne10_Brain_0x1d28a0; // 0x1d28a0 - g_ps2RecompiledFunctionTable[215626] = bhEne10_Brain_0x1d28a0; // 0x1d2930 - g_ps2RecompiledFunctionTable[215636] = bhEne10_Brain_0x1d28a0; // 0x1d2958 - g_ps2RecompiledFunctionTable[215662] = bhEne10_Move_0x1d29c0; // 0x1d29c0 - g_ps2RecompiledFunctionTable[215663] = bhEne10_Move_0x1d29c0; // 0x1d29c4 - g_ps2RecompiledFunctionTable[215664] = bhEne10_Move_0x1d29c0; // 0x1d29c8 - g_ps2RecompiledFunctionTable[215665] = bhEne10_Move_0x1d29c0; // 0x1d29cc - g_ps2RecompiledFunctionTable[215666] = bhEne10_Move_0x1d29c0; // 0x1d29d0 - g_ps2RecompiledFunctionTable[215667] = bhEne10_Move_0x1d29c0; // 0x1d29d4 - g_ps2RecompiledFunctionTable[215668] = bhEne10_Move_0x1d29c0; // 0x1d29d8 - g_ps2RecompiledFunctionTable[215669] = bhEne10_Move_0x1d29c0; // 0x1d29dc - g_ps2RecompiledFunctionTable[215670] = bhEne10_Move_0x1d29c0; // 0x1d29e0 - g_ps2RecompiledFunctionTable[215671] = bhEne10_Move_0x1d29c0; // 0x1d29e4 - g_ps2RecompiledFunctionTable[215672] = bhEne10_Move_0x1d29c0; // 0x1d29e8 - g_ps2RecompiledFunctionTable[215673] = bhEne10_Move_0x1d29c0; // 0x1d29ec - g_ps2RecompiledFunctionTable[215674] = bhEne10_Move_0x1d29c0; // 0x1d29f0 - g_ps2RecompiledFunctionTable[215675] = bhEne10_Move_0x1d29c0; // 0x1d29f4 - g_ps2RecompiledFunctionTable[215676] = bhEne10_Move_0x1d29c0; // 0x1d29f8 - g_ps2RecompiledFunctionTable[215677] = bhEne10_Move_0x1d29c0; // 0x1d29fc - g_ps2RecompiledFunctionTable[215678] = bhEne10_Move_0x1d29c0; // 0x1d2a00 - g_ps2RecompiledFunctionTable[215679] = bhEne10_Move_0x1d29c0; // 0x1d2a04 - g_ps2RecompiledFunctionTable[215680] = bhEne10_Move_0x1d29c0; // 0x1d2a08 - g_ps2RecompiledFunctionTable[215681] = bhEne10_Move_0x1d29c0; // 0x1d2a0c - g_ps2RecompiledFunctionTable[215682] = bhEne10_Move_0x1d29c0; // 0x1d2a10 - g_ps2RecompiledFunctionTable[215683] = bhEne10_Move_0x1d29c0; // 0x1d2a14 - g_ps2RecompiledFunctionTable[215684] = bhEne10_Move_0x1d29c0; // 0x1d2a18 - g_ps2RecompiledFunctionTable[215685] = bhEne10_Move_0x1d29c0; // 0x1d2a1c - g_ps2RecompiledFunctionTable[215686] = bhEne10_Move_0x1d29c0; // 0x1d2a20 - g_ps2RecompiledFunctionTable[215687] = bhEne10_Move_0x1d29c0; // 0x1d2a24 - g_ps2RecompiledFunctionTable[215688] = bhEne10_Move_0x1d29c0; // 0x1d2a28 - g_ps2RecompiledFunctionTable[215689] = bhEne10_Move_0x1d29c0; // 0x1d2a2c - g_ps2RecompiledFunctionTable[215690] = bhEne10_Move_0x1d29c0; // 0x1d2a30 - g_ps2RecompiledFunctionTable[215691] = bhEne10_Move_0x1d29c0; // 0x1d2a34 - g_ps2RecompiledFunctionTable[215692] = bhEne10_Move_0x1d29c0; // 0x1d2a38 - g_ps2RecompiledFunctionTable[215693] = bhEne10_Move_0x1d29c0; // 0x1d2a3c - g_ps2RecompiledFunctionTable[215694] = bhEne10_Move_0x1d29c0; // 0x1d2a40 - g_ps2RecompiledFunctionTable[215695] = bhEne10_Move_0x1d29c0; // 0x1d2a44 - g_ps2RecompiledFunctionTable[215696] = bhEne10_Move_0x1d29c0; // 0x1d2a48 - g_ps2RecompiledFunctionTable[215697] = bhEne10_Move_0x1d29c0; // 0x1d2a4c - g_ps2RecompiledFunctionTable[215698] = bhEne10_Move_0x1d29c0; // 0x1d2a50 - g_ps2RecompiledFunctionTable[215699] = bhEne10_Move_0x1d29c0; // 0x1d2a54 - g_ps2RecompiledFunctionTable[215700] = bhEne10_Move_0x1d29c0; // 0x1d2a58 - g_ps2RecompiledFunctionTable[215701] = bhEne10_Move_0x1d29c0; // 0x1d2a5c - g_ps2RecompiledFunctionTable[215702] = bhEne10_Move_0x1d29c0; // 0x1d2a60 - g_ps2RecompiledFunctionTable[215703] = bhEne10_Move_0x1d29c0; // 0x1d2a64 - g_ps2RecompiledFunctionTable[215704] = bhEne10_Move_0x1d29c0; // 0x1d2a68 - g_ps2RecompiledFunctionTable[215705] = bhEne10_Move_0x1d29c0; // 0x1d2a6c - g_ps2RecompiledFunctionTable[215706] = bhEne10_Move_0x1d29c0; // 0x1d2a70 - g_ps2RecompiledFunctionTable[215707] = bhEne10_Move_0x1d29c0; // 0x1d2a74 - g_ps2RecompiledFunctionTable[215708] = bhEne10_Move_0x1d29c0; // 0x1d2a78 - g_ps2RecompiledFunctionTable[215709] = bhEne10_Move_0x1d29c0; // 0x1d2a7c - g_ps2RecompiledFunctionTable[215710] = bhEne10_Move_0x1d29c0; // 0x1d2a80 - g_ps2RecompiledFunctionTable[215711] = bhEne10_Move_0x1d29c0; // 0x1d2a84 - g_ps2RecompiledFunctionTable[215712] = bhEne10_Move_0x1d29c0; // 0x1d2a88 - g_ps2RecompiledFunctionTable[215713] = bhEne10_Move_0x1d29c0; // 0x1d2a8c - g_ps2RecompiledFunctionTable[215714] = bhEne10_Move_0x1d29c0; // 0x1d2a90 - g_ps2RecompiledFunctionTable[215715] = bhEne10_Move_0x1d29c0; // 0x1d2a94 - g_ps2RecompiledFunctionTable[215716] = bhEne10_Move_0x1d29c0; // 0x1d2a98 - g_ps2RecompiledFunctionTable[215717] = bhEne10_Move_0x1d29c0; // 0x1d2a9c - g_ps2RecompiledFunctionTable[215718] = bhEne10_Move_0x1d29c0; // 0x1d2aa0 - g_ps2RecompiledFunctionTable[215719] = bhEne10_Move_0x1d29c0; // 0x1d2aa4 - g_ps2RecompiledFunctionTable[215720] = bhEne10_Move_0x1d29c0; // 0x1d2aa8 - g_ps2RecompiledFunctionTable[215721] = bhEne10_Move_0x1d29c0; // 0x1d2aac - g_ps2RecompiledFunctionTable[215722] = bhEne10_Move_0x1d29c0; // 0x1d2ab0 - g_ps2RecompiledFunctionTable[215723] = bhEne10_Move_0x1d29c0; // 0x1d2ab4 - g_ps2RecompiledFunctionTable[215724] = bhEne10_Move_0x1d29c0; // 0x1d2ab8 - g_ps2RecompiledFunctionTable[215725] = bhEne10_Move_0x1d29c0; // 0x1d2abc - g_ps2RecompiledFunctionTable[215726] = bhEne10_Move_0x1d29c0; // 0x1d2ac0 - g_ps2RecompiledFunctionTable[215727] = bhEne10_Move_0x1d29c0; // 0x1d2ac4 - g_ps2RecompiledFunctionTable[215728] = bhEne10_Move_0x1d29c0; // 0x1d2ac8 - g_ps2RecompiledFunctionTable[215729] = bhEne10_Move_0x1d29c0; // 0x1d2acc - g_ps2RecompiledFunctionTable[215730] = bhEne10_Move_0x1d29c0; // 0x1d2ad0 - g_ps2RecompiledFunctionTable[215731] = bhEne10_Move_0x1d29c0; // 0x1d2ad4 - g_ps2RecompiledFunctionTable[215732] = bhEne10_Move_0x1d29c0; // 0x1d2ad8 - g_ps2RecompiledFunctionTable[215733] = bhEne10_Move_0x1d29c0; // 0x1d2adc - g_ps2RecompiledFunctionTable[215734] = bhEne10_Move_0x1d29c0; // 0x1d2ae0 - g_ps2RecompiledFunctionTable[215735] = bhEne10_Move_0x1d29c0; // 0x1d2ae4 - g_ps2RecompiledFunctionTable[215736] = bhEne10_Move_0x1d29c0; // 0x1d2ae8 - g_ps2RecompiledFunctionTable[215737] = bhEne10_Move_0x1d29c0; // 0x1d2aec - g_ps2RecompiledFunctionTable[215738] = bhEne10_Move_0x1d29c0; // 0x1d2af0 - g_ps2RecompiledFunctionTable[215739] = bhEne10_Move_0x1d29c0; // 0x1d2af4 - g_ps2RecompiledFunctionTable[215740] = bhEne10_Move_0x1d29c0; // 0x1d2af8 - g_ps2RecompiledFunctionTable[215741] = bhEne10_Move_0x1d29c0; // 0x1d2afc - g_ps2RecompiledFunctionTable[215742] = bhEne10_Move_0x1d29c0; // 0x1d2b00 - g_ps2RecompiledFunctionTable[215743] = bhEne10_Move_0x1d29c0; // 0x1d2b04 - g_ps2RecompiledFunctionTable[215744] = bhEne10_Move_0x1d29c0; // 0x1d2b08 - g_ps2RecompiledFunctionTable[215745] = bhEne10_Move_0x1d29c0; // 0x1d2b0c - g_ps2RecompiledFunctionTable[215746] = bhEne10_Move_0x1d29c0; // 0x1d2b10 - g_ps2RecompiledFunctionTable[215747] = bhEne10_Move_0x1d29c0; // 0x1d2b14 - g_ps2RecompiledFunctionTable[215748] = bhEne10_Move_0x1d29c0; // 0x1d2b18 - g_ps2RecompiledFunctionTable[215749] = bhEne10_Move_0x1d29c0; // 0x1d2b1c - g_ps2RecompiledFunctionTable[215750] = bhEne10_Move_0x1d29c0; // 0x1d2b20 - g_ps2RecompiledFunctionTable[215751] = bhEne10_Move_0x1d29c0; // 0x1d2b24 - g_ps2RecompiledFunctionTable[215752] = bhEne10_Move_0x1d29c0; // 0x1d2b28 - g_ps2RecompiledFunctionTable[215753] = bhEne10_Move_0x1d29c0; // 0x1d2b2c - g_ps2RecompiledFunctionTable[215754] = bhEne10_Move_0x1d29c0; // 0x1d2b30 - g_ps2RecompiledFunctionTable[215755] = bhEne10_Move_0x1d29c0; // 0x1d2b34 - g_ps2RecompiledFunctionTable[215756] = bhEne10_Move_0x1d29c0; // 0x1d2b38 - g_ps2RecompiledFunctionTable[215757] = bhEne10_Move_0x1d29c0; // 0x1d2b3c - g_ps2RecompiledFunctionTable[215758] = bhEne10_Move_0x1d29c0; // 0x1d2b40 - g_ps2RecompiledFunctionTable[215759] = bhEne10_Move_0x1d29c0; // 0x1d2b44 - g_ps2RecompiledFunctionTable[215762] = bhEne10_MV00_0x1d2b50; // 0x1d2b50 - g_ps2RecompiledFunctionTable[215766] = bhEne10_MV01_0x1d2b60; // 0x1d2b60 - g_ps2RecompiledFunctionTable[215781] = bhEne10_MV01_0x1d2b60; // 0x1d2b9c - g_ps2RecompiledFunctionTable[215799] = bhEne10_MV01_0x1d2b60; // 0x1d2be4 - g_ps2RecompiledFunctionTable[215808] = bhEne10_MV01_0x1d2b60; // 0x1d2c08 - g_ps2RecompiledFunctionTable[215814] = bhEne10_MV01_0x1d2b60; // 0x1d2c20 - g_ps2RecompiledFunctionTable[215821] = bhEne10_MV01_0x1d2b60; // 0x1d2c3c - g_ps2RecompiledFunctionTable[215825] = bhEne10_MV01_0x1d2b60; // 0x1d2c4c - g_ps2RecompiledFunctionTable[215832] = bhEne10_MV01_0x1d2b60; // 0x1d2c68 - g_ps2RecompiledFunctionTable[215834] = bhEne10_MV01_0x1d2b60; // 0x1d2c70 - g_ps2RecompiledFunctionTable[215836] = bhEne10_MV01_0x1d2b60; // 0x1d2c78 - g_ps2RecompiledFunctionTable[215858] = bhEne10_MV02_0x1d2cd0; // 0x1d2cd0 - g_ps2RecompiledFunctionTable[215878] = bhEne10_MV02_0x1d2cd0; // 0x1d2d20 - g_ps2RecompiledFunctionTable[215885] = bhEne10_MV02_0x1d2cd0; // 0x1d2d3c - g_ps2RecompiledFunctionTable[215891] = bhEne10_MV02_0x1d2cd0; // 0x1d2d54 - g_ps2RecompiledFunctionTable[215893] = bhEne10_MV02_0x1d2cd0; // 0x1d2d5c - g_ps2RecompiledFunctionTable[215914] = bhEne10_MV02_0x1d2cd0; // 0x1d2db0 - g_ps2RecompiledFunctionTable[215920] = bhEne10_MV02_0x1d2cd0; // 0x1d2dc8 - g_ps2RecompiledFunctionTable[215929] = bhEne10_MV02_0x1d2cd0; // 0x1d2dec - g_ps2RecompiledFunctionTable[215934] = bhEne10_MV02_0x1d2cd0; // 0x1d2e00 - g_ps2RecompiledFunctionTable[215936] = bhEne10_MV02_0x1d2cd0; // 0x1d2e08 - g_ps2RecompiledFunctionTable[215950] = bhEne10_MV02_0x1d2cd0; // 0x1d2e40 - g_ps2RecompiledFunctionTable[215952] = bhEne10_MV02_0x1d2cd0; // 0x1d2e48 - g_ps2RecompiledFunctionTable[215967] = bhEne10_MV02_0x1d2cd0; // 0x1d2e84 - g_ps2RecompiledFunctionTable[215974] = bhEne10_MV02_0x1d2cd0; // 0x1d2ea0 - g_ps2RecompiledFunctionTable[215981] = bhEne10_MV02_0x1d2cd0; // 0x1d2ebc - g_ps2RecompiledFunctionTable[215983] = bhEne10_MV02_0x1d2cd0; // 0x1d2ec4 - g_ps2RecompiledFunctionTable[215985] = bhEne10_MV02_0x1d2cd0; // 0x1d2ecc - g_ps2RecompiledFunctionTable[216010] = bhEne10_Nage_0x1d2f30; // 0x1d2f30 - g_ps2RecompiledFunctionTable[216060] = bhEne10_Nage_0x1d2f30; // 0x1d2ff8 - g_ps2RecompiledFunctionTable[216063] = bhEne10_Nage_0x1d2f30; // 0x1d3004 - g_ps2RecompiledFunctionTable[216142] = bhEne10_Nage_0x1d2f30; // 0x1d3140 - g_ps2RecompiledFunctionTable[216157] = bhEne10_Nage_0x1d2f30; // 0x1d317c - g_ps2RecompiledFunctionTable[216168] = bhEne10_Nage_0x1d2f30; // 0x1d31a8 - g_ps2RecompiledFunctionTable[216170] = bhEne10_Nage_0x1d2f30; // 0x1d31b0 - g_ps2RecompiledFunctionTable[216198] = bhEne10_Damage_0x1d3220; // 0x1d3220 - g_ps2RecompiledFunctionTable[216202] = bhEne10_Die_0x1d3230; // 0x1d3230 - g_ps2RecompiledFunctionTable[216206] = bhEne11_0x1d3240; // 0x1d3240 - g_ps2RecompiledFunctionTable[216207] = bhEne11_0x1d3240; // 0x1d3244 - g_ps2RecompiledFunctionTable[216208] = bhEne11_0x1d3240; // 0x1d3248 - g_ps2RecompiledFunctionTable[216209] = bhEne11_0x1d3240; // 0x1d324c - g_ps2RecompiledFunctionTable[216210] = bhEne11_0x1d3240; // 0x1d3250 - g_ps2RecompiledFunctionTable[216211] = bhEne11_0x1d3240; // 0x1d3254 - g_ps2RecompiledFunctionTable[216212] = bhEne11_0x1d3240; // 0x1d3258 - g_ps2RecompiledFunctionTable[216213] = bhEne11_0x1d3240; // 0x1d325c - g_ps2RecompiledFunctionTable[216214] = bhEne11_0x1d3240; // 0x1d3260 - g_ps2RecompiledFunctionTable[216215] = bhEne11_0x1d3240; // 0x1d3264 - g_ps2RecompiledFunctionTable[216216] = bhEne11_0x1d3240; // 0x1d3268 - g_ps2RecompiledFunctionTable[216217] = bhEne11_0x1d3240; // 0x1d326c - g_ps2RecompiledFunctionTable[216218] = bhEne11_0x1d3240; // 0x1d3270 - g_ps2RecompiledFunctionTable[216219] = bhEne11_0x1d3240; // 0x1d3274 - g_ps2RecompiledFunctionTable[216220] = bhEne11_0x1d3240; // 0x1d3278 - g_ps2RecompiledFunctionTable[216221] = bhEne11_0x1d3240; // 0x1d327c - g_ps2RecompiledFunctionTable[216222] = bhEne11_0x1d3240; // 0x1d3280 - g_ps2RecompiledFunctionTable[216223] = bhEne11_0x1d3240; // 0x1d3284 - g_ps2RecompiledFunctionTable[216224] = bhEne11_0x1d3240; // 0x1d3288 - g_ps2RecompiledFunctionTable[216225] = bhEne11_0x1d3240; // 0x1d328c - g_ps2RecompiledFunctionTable[216226] = bhEne11_0x1d3240; // 0x1d3290 - g_ps2RecompiledFunctionTable[216227] = bhEne11_0x1d3240; // 0x1d3294 - g_ps2RecompiledFunctionTable[216228] = bhEne11_0x1d3240; // 0x1d3298 - g_ps2RecompiledFunctionTable[216229] = bhEne11_0x1d3240; // 0x1d329c - g_ps2RecompiledFunctionTable[216230] = bhEne11_0x1d3240; // 0x1d32a0 - g_ps2RecompiledFunctionTable[216231] = bhEne11_0x1d3240; // 0x1d32a4 - g_ps2RecompiledFunctionTable[216232] = bhEne11_0x1d3240; // 0x1d32a8 - g_ps2RecompiledFunctionTable[216233] = bhEne11_0x1d3240; // 0x1d32ac - g_ps2RecompiledFunctionTable[216234] = bhEne11_0x1d3240; // 0x1d32b0 - g_ps2RecompiledFunctionTable[216235] = bhEne11_0x1d3240; // 0x1d32b4 - g_ps2RecompiledFunctionTable[216236] = bhEne11_0x1d3240; // 0x1d32b8 - g_ps2RecompiledFunctionTable[216237] = bhEne11_0x1d3240; // 0x1d32bc - g_ps2RecompiledFunctionTable[216238] = bhEne11_0x1d3240; // 0x1d32c0 - g_ps2RecompiledFunctionTable[216239] = bhEne11_0x1d3240; // 0x1d32c4 - g_ps2RecompiledFunctionTable[216240] = bhEne11_0x1d3240; // 0x1d32c8 - g_ps2RecompiledFunctionTable[216241] = bhEne11_0x1d3240; // 0x1d32cc - g_ps2RecompiledFunctionTable[216242] = bhEne11_0x1d3240; // 0x1d32d0 - g_ps2RecompiledFunctionTable[216243] = bhEne11_0x1d3240; // 0x1d32d4 - g_ps2RecompiledFunctionTable[216244] = bhEne11_0x1d3240; // 0x1d32d8 - g_ps2RecompiledFunctionTable[216245] = bhEne11_0x1d3240; // 0x1d32dc - g_ps2RecompiledFunctionTable[216246] = bhEne11_0x1d3240; // 0x1d32e0 - g_ps2RecompiledFunctionTable[216247] = bhEne11_0x1d3240; // 0x1d32e4 - g_ps2RecompiledFunctionTable[216248] = bhEne11_0x1d3240; // 0x1d32e8 - g_ps2RecompiledFunctionTable[216249] = bhEne11_0x1d3240; // 0x1d32ec - g_ps2RecompiledFunctionTable[216250] = bhEne11_0x1d3240; // 0x1d32f0 - g_ps2RecompiledFunctionTable[216251] = bhEne11_0x1d3240; // 0x1d32f4 - g_ps2RecompiledFunctionTable[216252] = bhEne11_0x1d3240; // 0x1d32f8 - g_ps2RecompiledFunctionTable[216253] = bhEne11_0x1d3240; // 0x1d32fc - g_ps2RecompiledFunctionTable[216254] = bhEne11_0x1d3240; // 0x1d3300 - g_ps2RecompiledFunctionTable[216255] = bhEne11_0x1d3240; // 0x1d3304 - g_ps2RecompiledFunctionTable[216256] = bhEne11_0x1d3240; // 0x1d3308 - g_ps2RecompiledFunctionTable[216257] = bhEne11_0x1d3240; // 0x1d330c - g_ps2RecompiledFunctionTable[216258] = bhEne11_0x1d3240; // 0x1d3310 - g_ps2RecompiledFunctionTable[216259] = bhEne11_0x1d3240; // 0x1d3314 - g_ps2RecompiledFunctionTable[216260] = bhEne11_0x1d3240; // 0x1d3318 - g_ps2RecompiledFunctionTable[216261] = bhEne11_0x1d3240; // 0x1d331c - g_ps2RecompiledFunctionTable[216262] = bhEne11_0x1d3240; // 0x1d3320 - g_ps2RecompiledFunctionTable[216263] = bhEne11_0x1d3240; // 0x1d3324 - g_ps2RecompiledFunctionTable[216264] = bhEne11_0x1d3240; // 0x1d3328 - g_ps2RecompiledFunctionTable[216265] = bhEne11_0x1d3240; // 0x1d332c - g_ps2RecompiledFunctionTable[216266] = bhEne11_0x1d3240; // 0x1d3330 - g_ps2RecompiledFunctionTable[216267] = bhEne11_0x1d3240; // 0x1d3334 - g_ps2RecompiledFunctionTable[216268] = bhEne11_0x1d3240; // 0x1d3338 - g_ps2RecompiledFunctionTable[216269] = bhEne11_0x1d3240; // 0x1d333c - g_ps2RecompiledFunctionTable[216270] = bhEne11_0x1d3240; // 0x1d3340 - g_ps2RecompiledFunctionTable[216271] = bhEne11_0x1d3240; // 0x1d3344 - g_ps2RecompiledFunctionTable[216272] = bhEne11_0x1d3240; // 0x1d3348 - g_ps2RecompiledFunctionTable[216273] = bhEne11_0x1d3240; // 0x1d334c - g_ps2RecompiledFunctionTable[216274] = bhEne11_0x1d3240; // 0x1d3350 - g_ps2RecompiledFunctionTable[216275] = bhEne11_0x1d3240; // 0x1d3354 - g_ps2RecompiledFunctionTable[216276] = bhEne11_0x1d3240; // 0x1d3358 - g_ps2RecompiledFunctionTable[216277] = bhEne11_0x1d3240; // 0x1d335c - g_ps2RecompiledFunctionTable[216278] = bhEne11_0x1d3240; // 0x1d3360 - g_ps2RecompiledFunctionTable[216279] = bhEne11_0x1d3240; // 0x1d3364 - g_ps2RecompiledFunctionTable[216280] = bhEne11_0x1d3240; // 0x1d3368 - g_ps2RecompiledFunctionTable[216281] = bhEne11_0x1d3240; // 0x1d336c - g_ps2RecompiledFunctionTable[216282] = bhEne11_0x1d3240; // 0x1d3370 - g_ps2RecompiledFunctionTable[216283] = bhEne11_0x1d3240; // 0x1d3374 - g_ps2RecompiledFunctionTable[216284] = bhEne11_0x1d3240; // 0x1d3378 - g_ps2RecompiledFunctionTable[216285] = bhEne11_0x1d3240; // 0x1d337c - g_ps2RecompiledFunctionTable[216286] = bhEne11_0x1d3240; // 0x1d3380 - g_ps2RecompiledFunctionTable[216287] = bhEne11_0x1d3240; // 0x1d3384 - g_ps2RecompiledFunctionTable[216288] = bhEne11_0x1d3240; // 0x1d3388 - g_ps2RecompiledFunctionTable[216289] = bhEne11_0x1d3240; // 0x1d338c - g_ps2RecompiledFunctionTable[216290] = bhEne11_0x1d3240; // 0x1d3390 - g_ps2RecompiledFunctionTable[216291] = bhEne11_0x1d3240; // 0x1d3394 - g_ps2RecompiledFunctionTable[216292] = bhEne11_0x1d3240; // 0x1d3398 - g_ps2RecompiledFunctionTable[216293] = bhEne11_0x1d3240; // 0x1d339c - g_ps2RecompiledFunctionTable[216294] = bhEne11_0x1d3240; // 0x1d33a0 - g_ps2RecompiledFunctionTable[216295] = bhEne11_0x1d3240; // 0x1d33a4 - g_ps2RecompiledFunctionTable[216296] = bhEne11_0x1d3240; // 0x1d33a8 - g_ps2RecompiledFunctionTable[216297] = bhEne11_0x1d3240; // 0x1d33ac - g_ps2RecompiledFunctionTable[216298] = bhEne11_0x1d3240; // 0x1d33b0 - g_ps2RecompiledFunctionTable[216299] = bhEne11_0x1d3240; // 0x1d33b4 - g_ps2RecompiledFunctionTable[216300] = bhEne11_0x1d3240; // 0x1d33b8 - g_ps2RecompiledFunctionTable[216301] = bhEne11_0x1d3240; // 0x1d33bc - g_ps2RecompiledFunctionTable[216302] = bhEne11_0x1d3240; // 0x1d33c0 - g_ps2RecompiledFunctionTable[216303] = bhEne11_0x1d3240; // 0x1d33c4 - g_ps2RecompiledFunctionTable[216304] = bhEne11_0x1d3240; // 0x1d33c8 - g_ps2RecompiledFunctionTable[216305] = bhEne11_0x1d3240; // 0x1d33cc - g_ps2RecompiledFunctionTable[216306] = bhEne11_0x1d3240; // 0x1d33d0 - g_ps2RecompiledFunctionTable[216307] = bhEne11_0x1d3240; // 0x1d33d4 - g_ps2RecompiledFunctionTable[216308] = bhEne11_0x1d3240; // 0x1d33d8 - g_ps2RecompiledFunctionTable[216309] = bhEne11_0x1d3240; // 0x1d33dc - g_ps2RecompiledFunctionTable[216310] = bhEne11_0x1d3240; // 0x1d33e0 - g_ps2RecompiledFunctionTable[216311] = bhEne11_0x1d3240; // 0x1d33e4 - g_ps2RecompiledFunctionTable[216312] = bhEne11_0x1d3240; // 0x1d33e8 - g_ps2RecompiledFunctionTable[216313] = bhEne11_0x1d3240; // 0x1d33ec - g_ps2RecompiledFunctionTable[216314] = bhEne11_0x1d3240; // 0x1d33f0 - g_ps2RecompiledFunctionTable[216315] = bhEne11_0x1d3240; // 0x1d33f4 - g_ps2RecompiledFunctionTable[216316] = bhEne11_0x1d3240; // 0x1d33f8 - g_ps2RecompiledFunctionTable[216317] = bhEne11_0x1d3240; // 0x1d33fc - g_ps2RecompiledFunctionTable[216318] = bhEne11_0x1d3240; // 0x1d3400 - g_ps2RecompiledFunctionTable[216319] = bhEne11_0x1d3240; // 0x1d3404 - g_ps2RecompiledFunctionTable[216320] = bhEne11_0x1d3240; // 0x1d3408 - g_ps2RecompiledFunctionTable[216321] = bhEne11_0x1d3240; // 0x1d340c - g_ps2RecompiledFunctionTable[216322] = bhEne11_0x1d3240; // 0x1d3410 - g_ps2RecompiledFunctionTable[216323] = bhEne11_0x1d3240; // 0x1d3414 - g_ps2RecompiledFunctionTable[216324] = bhEne11_0x1d3240; // 0x1d3418 - g_ps2RecompiledFunctionTable[216325] = bhEne11_0x1d3240; // 0x1d341c - g_ps2RecompiledFunctionTable[216326] = bhEne11_0x1d3240; // 0x1d3420 - g_ps2RecompiledFunctionTable[216327] = bhEne11_0x1d3240; // 0x1d3424 - g_ps2RecompiledFunctionTable[216328] = bhEne11_0x1d3240; // 0x1d3428 - g_ps2RecompiledFunctionTable[216329] = bhEne11_0x1d3240; // 0x1d342c - g_ps2RecompiledFunctionTable[216330] = bhEne11_0x1d3240; // 0x1d3430 - g_ps2RecompiledFunctionTable[216331] = bhEne11_0x1d3240; // 0x1d3434 - g_ps2RecompiledFunctionTable[216332] = bhEne11_0x1d3240; // 0x1d3438 - g_ps2RecompiledFunctionTable[216333] = bhEne11_0x1d3240; // 0x1d343c - g_ps2RecompiledFunctionTable[216334] = bhEne11_0x1d3240; // 0x1d3440 - g_ps2RecompiledFunctionTable[216335] = bhEne11_0x1d3240; // 0x1d3444 - g_ps2RecompiledFunctionTable[216336] = bhEne11_0x1d3240; // 0x1d3448 - g_ps2RecompiledFunctionTable[216337] = bhEne11_0x1d3240; // 0x1d344c - g_ps2RecompiledFunctionTable[216338] = bhEne11_0x1d3240; // 0x1d3450 - g_ps2RecompiledFunctionTable[216339] = bhEne11_0x1d3240; // 0x1d3454 - g_ps2RecompiledFunctionTable[216340] = bhEne11_0x1d3240; // 0x1d3458 - g_ps2RecompiledFunctionTable[216341] = bhEne11_0x1d3240; // 0x1d345c - g_ps2RecompiledFunctionTable[216342] = bhEne11_0x1d3240; // 0x1d3460 - g_ps2RecompiledFunctionTable[216343] = bhEne11_0x1d3240; // 0x1d3464 - g_ps2RecompiledFunctionTable[216344] = bhEne11_0x1d3240; // 0x1d3468 - g_ps2RecompiledFunctionTable[216345] = bhEne11_0x1d3240; // 0x1d346c - g_ps2RecompiledFunctionTable[216346] = bhEne11_0x1d3240; // 0x1d3470 - g_ps2RecompiledFunctionTable[216347] = bhEne11_0x1d3240; // 0x1d3474 - g_ps2RecompiledFunctionTable[216348] = bhEne11_0x1d3240; // 0x1d3478 - g_ps2RecompiledFunctionTable[216349] = bhEne11_0x1d3240; // 0x1d347c - g_ps2RecompiledFunctionTable[216350] = bhEne11_0x1d3240; // 0x1d3480 - g_ps2RecompiledFunctionTable[216351] = bhEne11_0x1d3240; // 0x1d3484 - g_ps2RecompiledFunctionTable[216352] = bhEne11_0x1d3240; // 0x1d3488 - g_ps2RecompiledFunctionTable[216353] = bhEne11_0x1d3240; // 0x1d348c - g_ps2RecompiledFunctionTable[216354] = bhEne11_0x1d3240; // 0x1d3490 - g_ps2RecompiledFunctionTable[216355] = bhEne11_0x1d3240; // 0x1d3494 - g_ps2RecompiledFunctionTable[216356] = bhEne11_0x1d3240; // 0x1d3498 - g_ps2RecompiledFunctionTable[216357] = bhEne11_0x1d3240; // 0x1d349c - g_ps2RecompiledFunctionTable[216358] = bhEne11_0x1d3240; // 0x1d34a0 - g_ps2RecompiledFunctionTable[216359] = bhEne11_0x1d3240; // 0x1d34a4 - g_ps2RecompiledFunctionTable[216360] = bhEne11_0x1d3240; // 0x1d34a8 - g_ps2RecompiledFunctionTable[216361] = bhEne11_0x1d3240; // 0x1d34ac - g_ps2RecompiledFunctionTable[216362] = bhEne11_0x1d3240; // 0x1d34b0 - g_ps2RecompiledFunctionTable[216363] = bhEne11_0x1d3240; // 0x1d34b4 - g_ps2RecompiledFunctionTable[216364] = bhEne11_0x1d3240; // 0x1d34b8 - g_ps2RecompiledFunctionTable[216365] = bhEne11_0x1d3240; // 0x1d34bc - g_ps2RecompiledFunctionTable[216366] = bhEne11_0x1d3240; // 0x1d34c0 - g_ps2RecompiledFunctionTable[216367] = bhEne11_0x1d3240; // 0x1d34c4 - g_ps2RecompiledFunctionTable[216368] = bhEne11_0x1d3240; // 0x1d34c8 - g_ps2RecompiledFunctionTable[216369] = bhEne11_0x1d3240; // 0x1d34cc - g_ps2RecompiledFunctionTable[216370] = bhEne11_0x1d3240; // 0x1d34d0 - g_ps2RecompiledFunctionTable[216371] = bhEne11_0x1d3240; // 0x1d34d4 - g_ps2RecompiledFunctionTable[216372] = bhEne11_0x1d3240; // 0x1d34d8 - g_ps2RecompiledFunctionTable[216373] = bhEne11_0x1d3240; // 0x1d34dc - g_ps2RecompiledFunctionTable[216374] = bhEne11_0x1d3240; // 0x1d34e0 - g_ps2RecompiledFunctionTable[216375] = bhEne11_0x1d3240; // 0x1d34e4 - g_ps2RecompiledFunctionTable[216376] = bhEne11_0x1d3240; // 0x1d34e8 - g_ps2RecompiledFunctionTable[216378] = bhEne11_Init_0x1d34f0; // 0x1d34f0 - g_ps2RecompiledFunctionTable[216415] = bhEne11_Init_0x1d34f0; // 0x1d3584 - g_ps2RecompiledFunctionTable[216418] = bhEne11_Init_0x1d34f0; // 0x1d3590 - g_ps2RecompiledFunctionTable[216424] = bhEne11_Init_0x1d34f0; // 0x1d35a8 - g_ps2RecompiledFunctionTable[216427] = bhEne11_Init_0x1d34f0; // 0x1d35b4 - g_ps2RecompiledFunctionTable[216433] = bhEne11_Init_0x1d34f0; // 0x1d35cc - g_ps2RecompiledFunctionTable[216436] = bhEne11_Init_0x1d34f0; // 0x1d35d8 - g_ps2RecompiledFunctionTable[216439] = bhEne11_Init_0x1d34f0; // 0x1d35e4 - g_ps2RecompiledFunctionTable[216511] = bhEne11_Init_0x1d34f0; // 0x1d3704 - g_ps2RecompiledFunctionTable[216539] = bhEne11_Init_0x1d34f0; // 0x1d3774 - g_ps2RecompiledFunctionTable[216550] = bhEne11_Brain_0x1d37a0; // 0x1d37a0 - g_ps2RecompiledFunctionTable[216551] = bhEne11_Brain_0x1d37a0; // 0x1d37a4 - g_ps2RecompiledFunctionTable[216552] = bhEne11_Brain_0x1d37a0; // 0x1d37a8 - g_ps2RecompiledFunctionTable[216553] = bhEne11_Brain_0x1d37a0; // 0x1d37ac - g_ps2RecompiledFunctionTable[216554] = bhEne11_BR00_0x1d37b0; // 0x1d37b0 - g_ps2RecompiledFunctionTable[216594] = bhEne11_Move_0x1d3850; // 0x1d3850 - g_ps2RecompiledFunctionTable[216595] = bhEne11_Move_0x1d3850; // 0x1d3854 - g_ps2RecompiledFunctionTable[216596] = bhEne11_Move_0x1d3850; // 0x1d3858 - g_ps2RecompiledFunctionTable[216597] = bhEne11_Move_0x1d3850; // 0x1d385c - g_ps2RecompiledFunctionTable[216598] = bhEne11_Move_0x1d3850; // 0x1d3860 - g_ps2RecompiledFunctionTable[216599] = bhEne11_Move_0x1d3850; // 0x1d3864 - g_ps2RecompiledFunctionTable[216600] = bhEne11_Move_0x1d3850; // 0x1d3868 - g_ps2RecompiledFunctionTable[216601] = bhEne11_Move_0x1d3850; // 0x1d386c - g_ps2RecompiledFunctionTable[216602] = bhEne11_Move_0x1d3850; // 0x1d3870 - g_ps2RecompiledFunctionTable[216603] = bhEne11_Move_0x1d3850; // 0x1d3874 - g_ps2RecompiledFunctionTable[216604] = bhEne11_Move_0x1d3850; // 0x1d3878 - g_ps2RecompiledFunctionTable[216605] = bhEne11_Move_0x1d3850; // 0x1d387c - g_ps2RecompiledFunctionTable[216606] = bhEne11_Move_0x1d3850; // 0x1d3880 - g_ps2RecompiledFunctionTable[216607] = bhEne11_Move_0x1d3850; // 0x1d3884 - g_ps2RecompiledFunctionTable[216608] = bhEne11_Move_0x1d3850; // 0x1d3888 - g_ps2RecompiledFunctionTable[216609] = bhEne11_Move_0x1d3850; // 0x1d388c - g_ps2RecompiledFunctionTable[216610] = bhEne11_Move_0x1d3850; // 0x1d3890 - g_ps2RecompiledFunctionTable[216611] = bhEne11_Move_0x1d3850; // 0x1d3894 - g_ps2RecompiledFunctionTable[216612] = bhEne11_Move_0x1d3850; // 0x1d3898 - g_ps2RecompiledFunctionTable[216613] = bhEne11_Move_0x1d3850; // 0x1d389c - g_ps2RecompiledFunctionTable[216614] = bhEne11_Move_0x1d3850; // 0x1d38a0 - g_ps2RecompiledFunctionTable[216618] = bhEne11_MV00_0x1d38b0; // 0x1d38b0 - g_ps2RecompiledFunctionTable[216650] = bhEne11_MV01_0x1d3930; // 0x1d3930 - g_ps2RecompiledFunctionTable[216670] = bhEne11_MV01_0x1d3930; // 0x1d3980 - g_ps2RecompiledFunctionTable[216679] = bhEne11_MV01_0x1d3930; // 0x1d39a4 - g_ps2RecompiledFunctionTable[216690] = bhEne11_MV01_0x1d3930; // 0x1d39d0 - g_ps2RecompiledFunctionTable[216696] = bhEne11_MV01_0x1d3930; // 0x1d39e8 - g_ps2RecompiledFunctionTable[216706] = bhEne11_MV01_0x1d3930; // 0x1d3a10 - g_ps2RecompiledFunctionTable[216715] = bhEne11_MV01_0x1d3930; // 0x1d3a34 - g_ps2RecompiledFunctionTable[216723] = bhEne11_MV01_0x1d3930; // 0x1d3a54 - g_ps2RecompiledFunctionTable[216729] = bhEne11_MV01_0x1d3930; // 0x1d3a6c - g_ps2RecompiledFunctionTable[216738] = bhEne11_MV01_0x1d3930; // 0x1d3a90 - g_ps2RecompiledFunctionTable[216754] = bhEne11_MV01_0x1d3930; // 0x1d3ad0 - g_ps2RecompiledFunctionTable[216761] = bhEne11_MV01_0x1d3930; // 0x1d3aec - g_ps2RecompiledFunctionTable[216768] = bhEne11_MV01_0x1d3930; // 0x1d3b08 - g_ps2RecompiledFunctionTable[216782] = bhEne11_MV02_0x1d3b40; // 0x1d3b40 - g_ps2RecompiledFunctionTable[216805] = bhEne11_MV02_0x1d3b40; // 0x1d3b9c - g_ps2RecompiledFunctionTable[216827] = bhEne11_MV02_0x1d3b40; // 0x1d3bf4 - g_ps2RecompiledFunctionTable[216834] = bhEne11_MV02_0x1d3b40; // 0x1d3c10 - g_ps2RecompiledFunctionTable[216841] = bhEne11_MV02_0x1d3b40; // 0x1d3c2c - g_ps2RecompiledFunctionTable[216846] = bhEne11_MV03_0x1d3c40; // 0x1d3c40 - g_ps2RecompiledFunctionTable[216882] = bhEne11_MV03_0x1d3c40; // 0x1d3cd0 - g_ps2RecompiledFunctionTable[216892] = bhEne11_MV03_0x1d3c40; // 0x1d3cf8 - g_ps2RecompiledFunctionTable[216902] = bhEne11_MV03_0x1d3c40; // 0x1d3d20 - g_ps2RecompiledFunctionTable[216910] = bhEne11_MV03_0x1d3c40; // 0x1d3d40 - g_ps2RecompiledFunctionTable[216963] = bhEne11_MV03_0x1d3c40; // 0x1d3e14 - g_ps2RecompiledFunctionTable[216969] = bhEne11_MV03_0x1d3c40; // 0x1d3e2c - g_ps2RecompiledFunctionTable[216978] = bhEne11_MV04_0x1d3e50; // 0x1d3e50 - g_ps2RecompiledFunctionTable[217003] = bhEne11_MV04_0x1d3e50; // 0x1d3eb4 - g_ps2RecompiledFunctionTable[217013] = bhEne11_MV04_0x1d3e50; // 0x1d3edc - g_ps2RecompiledFunctionTable[217033] = bhEne11_MV04_0x1d3e50; // 0x1d3f2c - g_ps2RecompiledFunctionTable[217042] = bhEne11_MV04_0x1d3e50; // 0x1d3f50 - g_ps2RecompiledFunctionTable[217050] = bhEne11_MV04_0x1d3e50; // 0x1d3f70 - g_ps2RecompiledFunctionTable[217056] = bhEne11_MV04_0x1d3e50; // 0x1d3f88 - g_ps2RecompiledFunctionTable[217065] = bhEne11_MV04_0x1d3e50; // 0x1d3fac - g_ps2RecompiledFunctionTable[217081] = bhEne11_MV04_0x1d3e50; // 0x1d3fec - g_ps2RecompiledFunctionTable[217088] = bhEne11_MV04_0x1d3e50; // 0x1d4008 - g_ps2RecompiledFunctionTable[217095] = bhEne11_MV04_0x1d3e50; // 0x1d4024 - g_ps2RecompiledFunctionTable[217110] = bhEne11_MV05_0x1d4060; // 0x1d4060 - g_ps2RecompiledFunctionTable[217129] = bhEne11_MV05_0x1d4060; // 0x1d40ac - g_ps2RecompiledFunctionTable[217139] = bhEne11_MV05_0x1d4060; // 0x1d40d4 - g_ps2RecompiledFunctionTable[217157] = bhEne11_MV05_0x1d4060; // 0x1d411c - g_ps2RecompiledFunctionTable[217166] = bhEne11_MV05_0x1d4060; // 0x1d4140 - g_ps2RecompiledFunctionTable[217174] = bhEne11_MV05_0x1d4060; // 0x1d4160 - g_ps2RecompiledFunctionTable[217180] = bhEne11_MV05_0x1d4060; // 0x1d4178 - g_ps2RecompiledFunctionTable[217189] = bhEne11_MV05_0x1d4060; // 0x1d419c - g_ps2RecompiledFunctionTable[217205] = bhEne11_MV05_0x1d4060; // 0x1d41dc - g_ps2RecompiledFunctionTable[217212] = bhEne11_MV05_0x1d4060; // 0x1d41f8 - g_ps2RecompiledFunctionTable[217219] = bhEne11_MV05_0x1d4060; // 0x1d4214 - g_ps2RecompiledFunctionTable[217234] = bhEne11_MV06_0x1d4250; // 0x1d4250 - g_ps2RecompiledFunctionTable[217255] = bhEne11_MV06_0x1d4250; // 0x1d42a4 - g_ps2RecompiledFunctionTable[217265] = bhEne11_MV06_0x1d4250; // 0x1d42cc - g_ps2RecompiledFunctionTable[217271] = bhEne11_MV06_0x1d4250; // 0x1d42e4 - g_ps2RecompiledFunctionTable[217290] = bhEne11_MV06_0x1d4250; // 0x1d4330 - g_ps2RecompiledFunctionTable[217296] = bhEne11_MV06_0x1d4250; // 0x1d4348 - g_ps2RecompiledFunctionTable[217305] = bhEne11_MV06_0x1d4250; // 0x1d436c - g_ps2RecompiledFunctionTable[217311] = bhEne11_MV06_0x1d4250; // 0x1d4384 - g_ps2RecompiledFunctionTable[217320] = bhEne11_MV06_0x1d4250; // 0x1d43a8 - g_ps2RecompiledFunctionTable[217326] = bhEne11_MV06_0x1d4250; // 0x1d43c0 - g_ps2RecompiledFunctionTable[217335] = bhEne11_MV06_0x1d4250; // 0x1d43e4 - g_ps2RecompiledFunctionTable[217341] = bhEne11_MV06_0x1d4250; // 0x1d43fc - g_ps2RecompiledFunctionTable[217352] = bhEne11_MV06_0x1d4250; // 0x1d4428 - g_ps2RecompiledFunctionTable[217361] = bhEne11_MV06_0x1d4250; // 0x1d444c - g_ps2RecompiledFunctionTable[217369] = bhEne11_MV06_0x1d4250; // 0x1d446c - g_ps2RecompiledFunctionTable[217375] = bhEne11_MV06_0x1d4250; // 0x1d4484 - g_ps2RecompiledFunctionTable[217384] = bhEne11_MV06_0x1d4250; // 0x1d44a8 - g_ps2RecompiledFunctionTable[217400] = bhEne11_MV06_0x1d4250; // 0x1d44e8 - g_ps2RecompiledFunctionTable[217407] = bhEne11_MV06_0x1d4250; // 0x1d4504 - g_ps2RecompiledFunctionTable[217414] = bhEne11_MV06_0x1d4250; // 0x1d4520 - g_ps2RecompiledFunctionTable[217430] = bhEne11_MV07_0x1d4560; // 0x1d4560 - g_ps2RecompiledFunctionTable[217441] = bhEne11_MV07_0x1d4560; // 0x1d458c - g_ps2RecompiledFunctionTable[217450] = bhEne11_MV08_0x1d45b0; // 0x1d45b0 - g_ps2RecompiledFunctionTable[217461] = bhEne11_MV08_0x1d45b0; // 0x1d45dc - g_ps2RecompiledFunctionTable[217470] = bhEne11_MV09_0x1d4600; // 0x1d4600 - g_ps2RecompiledFunctionTable[217480] = bhEne11_MV09_0x1d4600; // 0x1d4628 - g_ps2RecompiledFunctionTable[217528] = bhEne11_MV09_0x1d4600; // 0x1d46e8 - g_ps2RecompiledFunctionTable[217541] = bhEne11_MV09_0x1d4600; // 0x1d471c - g_ps2RecompiledFunctionTable[217577] = bhEne11_MV09_0x1d4600; // 0x1d47ac - g_ps2RecompiledFunctionTable[217582] = bhEne11_Nage_0x1d47c0; // 0x1d47c0 - g_ps2RecompiledFunctionTable[217586] = bhEne11_Damage_0x1d47d0; // 0x1d47d0 - g_ps2RecompiledFunctionTable[217590] = bhEne11_Die_0x1d47e0; // 0x1d47e0 - g_ps2RecompiledFunctionTable[217594] = bhEne11_GoFoward_0x1d47f0; // 0x1d47f0 - g_ps2RecompiledFunctionTable[217618] = bhEne11_CollisionWalls_0x1d4850; // 0x1d4850 - g_ps2RecompiledFunctionTable[217634] = bhEne11_CollisionWalls_0x1d4850; // 0x1d4890 - g_ps2RecompiledFunctionTable[217650] = bhEne11_CollisionWalls_0x1d4850; // 0x1d48d0 - g_ps2RecompiledFunctionTable[217656] = bhEne11_CollisionWalls_0x1d4850; // 0x1d48e8 - g_ps2RecompiledFunctionTable[217674] = bhEne11_CollisionBoxEdge2_0x1d4930; // 0x1d4930 - g_ps2RecompiledFunctionTable[217697] = bhEne11_CollisionBoxEdge2_0x1d4930; // 0x1d498c - g_ps2RecompiledFunctionTable[217699] = bhEne11_CollisionBoxEdge2_0x1d4930; // 0x1d4994 - g_ps2RecompiledFunctionTable[217912] = bhEne11_CollisionBoxEdge2_0x1d4930; // 0x1d4ce8 - g_ps2RecompiledFunctionTable[217927] = bhEne11_CollisionBoxEdge2_0x1d4930; // 0x1d4d24 - g_ps2RecompiledFunctionTable[217931] = bhEne11_CollisionBoxEdge2_0x1d4930; // 0x1d4d34 - g_ps2RecompiledFunctionTable[217940] = bhEne11_CollisionBoxEdge2_0x1d4930; // 0x1d4d58 - g_ps2RecompiledFunctionTable[217958] = bhEne11_CameraSet_0x1d4da0; // 0x1d4da0 - g_ps2RecompiledFunctionTable[217970] = bhEne11_CameraSet_0x1d4da0; // 0x1d4dd0 - g_ps2RecompiledFunctionTable[217972] = bhEne11_CameraSet_0x1d4da0; // 0x1d4dd8 - g_ps2RecompiledFunctionTable[217976] = bhEne11_CameraSet_0x1d4da0; // 0x1d4de8 - g_ps2RecompiledFunctionTable[217978] = bhEne11_CameraSet_0x1d4da0; // 0x1d4df0 - g_ps2RecompiledFunctionTable[217989] = bhEne11_CameraSet_0x1d4da0; // 0x1d4e1c - g_ps2RecompiledFunctionTable[217992] = bhEne11_CameraSet_0x1d4da0; // 0x1d4e28 - g_ps2RecompiledFunctionTable[217995] = bhEne11_CameraSet_0x1d4da0; // 0x1d4e34 - g_ps2RecompiledFunctionTable[217999] = bhEne11_CameraSet_0x1d4da0; // 0x1d4e44 - g_ps2RecompiledFunctionTable[218003] = bhEne11_CameraSet_0x1d4da0; // 0x1d4e54 - g_ps2RecompiledFunctionTable[218006] = bhEne11_CameraSet_0x1d4da0; // 0x1d4e60 - g_ps2RecompiledFunctionTable[218008] = bhEne11_CameraSet_0x1d4da0; // 0x1d4e68 - g_ps2RecompiledFunctionTable[218013] = bhEne11_CameraSet_0x1d4da0; // 0x1d4e7c - g_ps2RecompiledFunctionTable[218019] = bhEne11_CameraSet_0x1d4da0; // 0x1d4e94 - g_ps2RecompiledFunctionTable[218023] = bhEne11_CameraSet_0x1d4da0; // 0x1d4ea4 - g_ps2RecompiledFunctionTable[218027] = bhEne11_CameraSet_0x1d4da0; // 0x1d4eb4 - g_ps2RecompiledFunctionTable[218033] = bhEne11_CameraSet_0x1d4da0; // 0x1d4ecc - g_ps2RecompiledFunctionTable[218039] = bhEne11_CameraSet_0x1d4da0; // 0x1d4ee4 - g_ps2RecompiledFunctionTable[218042] = bhEne11_CameraSet_0x1d4da0; // 0x1d4ef0 - g_ps2RecompiledFunctionTable[218058] = bhEne11_MoveNearWall_0x1d4f30; // 0x1d4f30 - g_ps2RecompiledFunctionTable[218072] = bhEne11_MoveNearWall_0x1d4f30; // 0x1d4f68 - g_ps2RecompiledFunctionTable[218076] = bhEne11_MoveNearWall_0x1d4f30; // 0x1d4f78 - g_ps2RecompiledFunctionTable[218093] = bhEne11_MoveNearWall_0x1d4f30; // 0x1d4fbc - g_ps2RecompiledFunctionTable[218114] = bhEne11_LightControl_0x1d5010; // 0x1d5010 - g_ps2RecompiledFunctionTable[218158] = bhEne11_SelectDir_0x1d50c0; // 0x1d50c0 - g_ps2RecompiledFunctionTable[218218] = bhEne11_SelectDir_0x1d50c0; // 0x1d51b0 - g_ps2RecompiledFunctionTable[218243] = bhEne11_SelectDir_0x1d50c0; // 0x1d5214 - g_ps2RecompiledFunctionTable[218247] = bhEne11_SelectDir_0x1d50c0; // 0x1d5224 - g_ps2RecompiledFunctionTable[218281] = bhEne11_SelectDir_0x1d50c0; // 0x1d52ac - g_ps2RecompiledFunctionTable[218306] = bhEne11_SelectDir_0x1d50c0; // 0x1d5310 - g_ps2RecompiledFunctionTable[218310] = bhEne11_SelectDir_0x1d50c0; // 0x1d5320 - g_ps2RecompiledFunctionTable[218344] = bhEne11_SelectDir_0x1d50c0; // 0x1d53a8 - g_ps2RecompiledFunctionTable[218369] = bhEne11_SelectDir_0x1d50c0; // 0x1d540c - g_ps2RecompiledFunctionTable[218373] = bhEne11_SelectDir_0x1d50c0; // 0x1d541c - g_ps2RecompiledFunctionTable[218407] = bhEne11_SelectDir_0x1d50c0; // 0x1d54a4 - g_ps2RecompiledFunctionTable[218432] = bhEne11_SelectDir_0x1d50c0; // 0x1d5508 - g_ps2RecompiledFunctionTable[218436] = bhEne11_SelectDir_0x1d50c0; // 0x1d5518 - g_ps2RecompiledFunctionTable[218452] = bhEne11_SelectDir_0x1d50c0; // 0x1d5558 - g_ps2RecompiledFunctionTable[218464] = bhEne11_SelectDir_0x1d50c0; // 0x1d5588 - g_ps2RecompiledFunctionTable[218468] = bhEne11_SelectDir_0x1d50c0; // 0x1d5598 - g_ps2RecompiledFunctionTable[218473] = bhEne11_SelectDir_0x1d50c0; // 0x1d55ac - g_ps2RecompiledFunctionTable[218475] = bhEne11_SelectDir_0x1d50c0; // 0x1d55b4 - g_ps2RecompiledFunctionTable[218481] = bhEne11_SelectDir_0x1d50c0; // 0x1d55cc - g_ps2RecompiledFunctionTable[218486] = bhEne11_SelectDir_0x1d50c0; // 0x1d55e0 - g_ps2RecompiledFunctionTable[218492] = bhEne11_SelectDir_0x1d50c0; // 0x1d55f8 - g_ps2RecompiledFunctionTable[218505] = bhEne11_SelectDir_0x1d50c0; // 0x1d562c - g_ps2RecompiledFunctionTable[218506] = bhEne11_SelectDir_0x1d50c0; // 0x1d5630 - g_ps2RecompiledFunctionTable[218530] = bhEne12_0x1d5690; // 0x1d5690 - g_ps2RecompiledFunctionTable[218531] = bhEne12_0x1d5690; // 0x1d5694 - g_ps2RecompiledFunctionTable[218532] = bhEne12_0x1d5690; // 0x1d5698 - g_ps2RecompiledFunctionTable[218533] = bhEne12_0x1d5690; // 0x1d569c - g_ps2RecompiledFunctionTable[218534] = bhEne12_0x1d5690; // 0x1d56a0 - g_ps2RecompiledFunctionTable[218535] = bhEne12_0x1d5690; // 0x1d56a4 - g_ps2RecompiledFunctionTable[218536] = bhEne12_0x1d5690; // 0x1d56a8 - g_ps2RecompiledFunctionTable[218537] = bhEne12_0x1d5690; // 0x1d56ac - g_ps2RecompiledFunctionTable[218538] = bhEne12_0x1d5690; // 0x1d56b0 - g_ps2RecompiledFunctionTable[218539] = bhEne12_0x1d5690; // 0x1d56b4 - g_ps2RecompiledFunctionTable[218540] = bhEne12_0x1d5690; // 0x1d56b8 - g_ps2RecompiledFunctionTable[218541] = bhEne12_0x1d5690; // 0x1d56bc - g_ps2RecompiledFunctionTable[218542] = bhEne12_0x1d5690; // 0x1d56c0 - g_ps2RecompiledFunctionTable[218543] = bhEne12_0x1d5690; // 0x1d56c4 - g_ps2RecompiledFunctionTable[218544] = bhEne12_0x1d5690; // 0x1d56c8 - g_ps2RecompiledFunctionTable[218545] = bhEne12_0x1d5690; // 0x1d56cc - g_ps2RecompiledFunctionTable[218546] = bhEne12_0x1d5690; // 0x1d56d0 - g_ps2RecompiledFunctionTable[218547] = bhEne12_0x1d5690; // 0x1d56d4 - g_ps2RecompiledFunctionTable[218548] = bhEne12_0x1d5690; // 0x1d56d8 - g_ps2RecompiledFunctionTable[218549] = bhEne12_0x1d5690; // 0x1d56dc - g_ps2RecompiledFunctionTable[218550] = bhEne12_0x1d5690; // 0x1d56e0 - g_ps2RecompiledFunctionTable[218551] = bhEne12_0x1d5690; // 0x1d56e4 - g_ps2RecompiledFunctionTable[218552] = bhEne12_0x1d5690; // 0x1d56e8 - g_ps2RecompiledFunctionTable[218553] = bhEne12_0x1d5690; // 0x1d56ec - g_ps2RecompiledFunctionTable[218554] = bhEne12_0x1d5690; // 0x1d56f0 - g_ps2RecompiledFunctionTable[218555] = bhEne12_0x1d5690; // 0x1d56f4 - g_ps2RecompiledFunctionTable[218556] = bhEne12_0x1d5690; // 0x1d56f8 - g_ps2RecompiledFunctionTable[218557] = bhEne12_0x1d5690; // 0x1d56fc - g_ps2RecompiledFunctionTable[218558] = bhEne12_0x1d5690; // 0x1d5700 - g_ps2RecompiledFunctionTable[218559] = bhEne12_0x1d5690; // 0x1d5704 - g_ps2RecompiledFunctionTable[218560] = bhEne12_0x1d5690; // 0x1d5708 - g_ps2RecompiledFunctionTable[218561] = bhEne12_0x1d5690; // 0x1d570c - g_ps2RecompiledFunctionTable[218562] = bhEne12_0x1d5690; // 0x1d5710 - g_ps2RecompiledFunctionTable[218563] = bhEne12_0x1d5690; // 0x1d5714 - g_ps2RecompiledFunctionTable[218564] = bhEne12_0x1d5690; // 0x1d5718 - g_ps2RecompiledFunctionTable[218565] = bhEne12_0x1d5690; // 0x1d571c - g_ps2RecompiledFunctionTable[218566] = bhEne12_0x1d5690; // 0x1d5720 - g_ps2RecompiledFunctionTable[218567] = bhEne12_0x1d5690; // 0x1d5724 - g_ps2RecompiledFunctionTable[218568] = bhEne12_0x1d5690; // 0x1d5728 - g_ps2RecompiledFunctionTable[218569] = bhEne12_0x1d5690; // 0x1d572c - g_ps2RecompiledFunctionTable[218570] = bhEne12_0x1d5690; // 0x1d5730 - g_ps2RecompiledFunctionTable[218571] = bhEne12_0x1d5690; // 0x1d5734 - g_ps2RecompiledFunctionTable[218572] = bhEne12_0x1d5690; // 0x1d5738 - g_ps2RecompiledFunctionTable[218573] = bhEne12_0x1d5690; // 0x1d573c - g_ps2RecompiledFunctionTable[218574] = bhEne12_0x1d5690; // 0x1d5740 - g_ps2RecompiledFunctionTable[218575] = bhEne12_0x1d5690; // 0x1d5744 - g_ps2RecompiledFunctionTable[218576] = bhEne12_0x1d5690; // 0x1d5748 - g_ps2RecompiledFunctionTable[218577] = bhEne12_0x1d5690; // 0x1d574c - g_ps2RecompiledFunctionTable[218578] = bhEne12_0x1d5690; // 0x1d5750 - g_ps2RecompiledFunctionTable[218579] = bhEne12_0x1d5690; // 0x1d5754 - g_ps2RecompiledFunctionTable[218580] = bhEne12_0x1d5690; // 0x1d5758 - g_ps2RecompiledFunctionTable[218581] = bhEne12_0x1d5690; // 0x1d575c - g_ps2RecompiledFunctionTable[218582] = bhEne12_0x1d5690; // 0x1d5760 - g_ps2RecompiledFunctionTable[218583] = bhEne12_0x1d5690; // 0x1d5764 - g_ps2RecompiledFunctionTable[218584] = bhEne12_0x1d5690; // 0x1d5768 - g_ps2RecompiledFunctionTable[218585] = bhEne12_0x1d5690; // 0x1d576c - g_ps2RecompiledFunctionTable[218586] = bhEne12_0x1d5690; // 0x1d5770 - g_ps2RecompiledFunctionTable[218587] = bhEne12_0x1d5690; // 0x1d5774 - g_ps2RecompiledFunctionTable[218588] = bhEne12_0x1d5690; // 0x1d5778 - g_ps2RecompiledFunctionTable[218589] = bhEne12_0x1d5690; // 0x1d577c - g_ps2RecompiledFunctionTable[218590] = bhEne12_0x1d5690; // 0x1d5780 - g_ps2RecompiledFunctionTable[218591] = bhEne12_0x1d5690; // 0x1d5784 - g_ps2RecompiledFunctionTable[218592] = bhEne12_0x1d5690; // 0x1d5788 - g_ps2RecompiledFunctionTable[218593] = bhEne12_0x1d5690; // 0x1d578c - g_ps2RecompiledFunctionTable[218594] = bhEne12_0x1d5690; // 0x1d5790 - g_ps2RecompiledFunctionTable[218595] = bhEne12_0x1d5690; // 0x1d5794 - g_ps2RecompiledFunctionTable[218596] = bhEne12_0x1d5690; // 0x1d5798 - g_ps2RecompiledFunctionTable[218597] = bhEne12_0x1d5690; // 0x1d579c - g_ps2RecompiledFunctionTable[218598] = bhEne12_0x1d5690; // 0x1d57a0 - g_ps2RecompiledFunctionTable[218599] = bhEne12_0x1d5690; // 0x1d57a4 - g_ps2RecompiledFunctionTable[218600] = bhEne12_0x1d5690; // 0x1d57a8 - g_ps2RecompiledFunctionTable[218601] = bhEne12_0x1d5690; // 0x1d57ac - g_ps2RecompiledFunctionTable[218602] = bhEne12_0x1d5690; // 0x1d57b0 - g_ps2RecompiledFunctionTable[218603] = bhEne12_0x1d5690; // 0x1d57b4 - g_ps2RecompiledFunctionTable[218604] = bhEne12_0x1d5690; // 0x1d57b8 - g_ps2RecompiledFunctionTable[218605] = bhEne12_0x1d5690; // 0x1d57bc - g_ps2RecompiledFunctionTable[218606] = bhEne12_0x1d5690; // 0x1d57c0 - g_ps2RecompiledFunctionTable[218607] = bhEne12_0x1d5690; // 0x1d57c4 - g_ps2RecompiledFunctionTable[218608] = bhEne12_0x1d5690; // 0x1d57c8 - g_ps2RecompiledFunctionTable[218609] = bhEne12_0x1d5690; // 0x1d57cc - g_ps2RecompiledFunctionTable[218610] = bhEne12_0x1d5690; // 0x1d57d0 - g_ps2RecompiledFunctionTable[218611] = bhEne12_0x1d5690; // 0x1d57d4 - g_ps2RecompiledFunctionTable[218612] = bhEne12_0x1d5690; // 0x1d57d8 - g_ps2RecompiledFunctionTable[218614] = bhEne12_Init_0x1d57e0; // 0x1d57e0 - g_ps2RecompiledFunctionTable[218672] = bhEne12_Init_0x1d57e0; // 0x1d58c8 - g_ps2RecompiledFunctionTable[218694] = bhEne12_Init_0x1d57e0; // 0x1d5920 - g_ps2RecompiledFunctionTable[218731] = bhEne12_Init_0x1d57e0; // 0x1d59b4 - g_ps2RecompiledFunctionTable[218762] = bhEne12_Brain_0x1d5a30; // 0x1d5a30 - g_ps2RecompiledFunctionTable[218763] = bhEne12_Brain_0x1d5a30; // 0x1d5a34 - g_ps2RecompiledFunctionTable[218764] = bhEne12_Brain_0x1d5a30; // 0x1d5a38 - g_ps2RecompiledFunctionTable[218765] = bhEne12_Brain_0x1d5a30; // 0x1d5a3c - g_ps2RecompiledFunctionTable[218766] = bhEne12_Brain_0x1d5a30; // 0x1d5a40 - g_ps2RecompiledFunctionTable[218767] = bhEne12_Brain_0x1d5a30; // 0x1d5a44 - g_ps2RecompiledFunctionTable[218768] = bhEne12_Brain_0x1d5a30; // 0x1d5a48 - g_ps2RecompiledFunctionTable[218769] = bhEne12_Brain_0x1d5a30; // 0x1d5a4c - g_ps2RecompiledFunctionTable[218770] = bhEne12_BR00_0x1d5a50; // 0x1d5a50 - g_ps2RecompiledFunctionTable[218784] = bhEne12_BR00_0x1d5a50; // 0x1d5a88 - g_ps2RecompiledFunctionTable[218802] = bhEne12_BR00_0x1d5a50; // 0x1d5ad0 - g_ps2RecompiledFunctionTable[218805] = bhEne12_BR00_0x1d5a50; // 0x1d5adc - g_ps2RecompiledFunctionTable[218841] = bhEne12_BR00_0x1d5a50; // 0x1d5b6c - g_ps2RecompiledFunctionTable[218892] = bhEne12_BR00_0x1d5a50; // 0x1d5c38 - g_ps2RecompiledFunctionTable[218900] = bhEne12_BR00_0x1d5a50; // 0x1d5c58 - g_ps2RecompiledFunctionTable[218915] = bhEne12_BR00_0x1d5a50; // 0x1d5c94 - g_ps2RecompiledFunctionTable[218935] = bhEne12_BR00_0x1d5a50; // 0x1d5ce4 - g_ps2RecompiledFunctionTable[218944] = bhEne12_BR00_0x1d5a50; // 0x1d5d08 - g_ps2RecompiledFunctionTable[218948] = bhEne12_BR00_0x1d5a50; // 0x1d5d18 - g_ps2RecompiledFunctionTable[218961] = bhEne12_BR00_0x1d5a50; // 0x1d5d4c - g_ps2RecompiledFunctionTable[218967] = bhEne12_BR00_0x1d5a50; // 0x1d5d64 - g_ps2RecompiledFunctionTable[218980] = bhEne12_BR00_0x1d5a50; // 0x1d5d98 - g_ps2RecompiledFunctionTable[219030] = bhEne12_Move_0x1d5e60; // 0x1d5e60 - g_ps2RecompiledFunctionTable[219031] = bhEne12_Move_0x1d5e60; // 0x1d5e64 - g_ps2RecompiledFunctionTable[219032] = bhEne12_Move_0x1d5e60; // 0x1d5e68 - g_ps2RecompiledFunctionTable[219033] = bhEne12_Move_0x1d5e60; // 0x1d5e6c - g_ps2RecompiledFunctionTable[219034] = bhEne12_Move_0x1d5e60; // 0x1d5e70 - g_ps2RecompiledFunctionTable[219035] = bhEne12_Move_0x1d5e60; // 0x1d5e74 - g_ps2RecompiledFunctionTable[219036] = bhEne12_Move_0x1d5e60; // 0x1d5e78 - g_ps2RecompiledFunctionTable[219037] = bhEne12_Move_0x1d5e60; // 0x1d5e7c - g_ps2RecompiledFunctionTable[219038] = bhEne12_Move_0x1d5e60; // 0x1d5e80 - g_ps2RecompiledFunctionTable[219039] = bhEne12_Move_0x1d5e60; // 0x1d5e84 - g_ps2RecompiledFunctionTable[219040] = bhEne12_Move_0x1d5e60; // 0x1d5e88 - g_ps2RecompiledFunctionTable[219041] = bhEne12_Move_0x1d5e60; // 0x1d5e8c - g_ps2RecompiledFunctionTable[219042] = bhEne12_Move_0x1d5e60; // 0x1d5e90 - g_ps2RecompiledFunctionTable[219043] = bhEne12_Move_0x1d5e60; // 0x1d5e94 - g_ps2RecompiledFunctionTable[219044] = bhEne12_Move_0x1d5e60; // 0x1d5e98 - g_ps2RecompiledFunctionTable[219045] = bhEne12_Move_0x1d5e60; // 0x1d5e9c - g_ps2RecompiledFunctionTable[219046] = bhEne12_Move_0x1d5e60; // 0x1d5ea0 - g_ps2RecompiledFunctionTable[219047] = bhEne12_Move_0x1d5e60; // 0x1d5ea4 - g_ps2RecompiledFunctionTable[219048] = bhEne12_Move_0x1d5e60; // 0x1d5ea8 - g_ps2RecompiledFunctionTable[219049] = bhEne12_Move_0x1d5e60; // 0x1d5eac - g_ps2RecompiledFunctionTable[219050] = bhEne12_Move_0x1d5e60; // 0x1d5eb0 - g_ps2RecompiledFunctionTable[219051] = bhEne12_Move_0x1d5e60; // 0x1d5eb4 - g_ps2RecompiledFunctionTable[219052] = bhEne12_Move_0x1d5e60; // 0x1d5eb8 - g_ps2RecompiledFunctionTable[219053] = bhEne12_Move_0x1d5e60; // 0x1d5ebc - g_ps2RecompiledFunctionTable[219054] = bhEne12_Move_0x1d5e60; // 0x1d5ec0 - g_ps2RecompiledFunctionTable[219055] = bhEne12_Move_0x1d5e60; // 0x1d5ec4 - g_ps2RecompiledFunctionTable[219056] = bhEne12_Move_0x1d5e60; // 0x1d5ec8 - g_ps2RecompiledFunctionTable[219057] = bhEne12_Move_0x1d5e60; // 0x1d5ecc - g_ps2RecompiledFunctionTable[219058] = bhEne12_Move_0x1d5e60; // 0x1d5ed0 - g_ps2RecompiledFunctionTable[219062] = bhEne12_MV00_0x1d5ee0; // 0x1d5ee0 - g_ps2RecompiledFunctionTable[219111] = bhEne12_MV00_0x1d5ee0; // 0x1d5fa4 - g_ps2RecompiledFunctionTable[219125] = bhEne12_MV00_0x1d5ee0; // 0x1d5fdc - g_ps2RecompiledFunctionTable[219138] = bhEne12_MV01_0x1d6010; // 0x1d6010 - g_ps2RecompiledFunctionTable[219182] = bhEne12_MV01_0x1d6010; // 0x1d60c0 - g_ps2RecompiledFunctionTable[219190] = bhEne12_MV01_0x1d6010; // 0x1d60e0 - g_ps2RecompiledFunctionTable[219201] = bhEne12_MV01_0x1d6010; // 0x1d610c - g_ps2RecompiledFunctionTable[219209] = bhEne12_MV01_0x1d6010; // 0x1d612c - g_ps2RecompiledFunctionTable[219216] = bhEne12_MV01_0x1d6010; // 0x1d6148 - g_ps2RecompiledFunctionTable[219225] = bhEne12_MV01_0x1d6010; // 0x1d616c - g_ps2RecompiledFunctionTable[219232] = bhEne12_MV01_0x1d6010; // 0x1d6188 - g_ps2RecompiledFunctionTable[219239] = bhEne12_MV01_0x1d6010; // 0x1d61a4 - g_ps2RecompiledFunctionTable[219256] = bhEne12_MV01_0x1d6010; // 0x1d61e8 - g_ps2RecompiledFunctionTable[219270] = bhEne12_MV02_0x1d6220; // 0x1d6220 - g_ps2RecompiledFunctionTable[219327] = bhEne12_MV02_0x1d6220; // 0x1d6304 - g_ps2RecompiledFunctionTable[219352] = bhEne12_MV02_0x1d6220; // 0x1d6368 - g_ps2RecompiledFunctionTable[219372] = bhEne12_MV02_0x1d6220; // 0x1d63b8 - g_ps2RecompiledFunctionTable[219380] = bhEne12_MV02_0x1d6220; // 0x1d63d8 - g_ps2RecompiledFunctionTable[219387] = bhEne12_MV02_0x1d6220; // 0x1d63f4 - g_ps2RecompiledFunctionTable[219394] = bhEne12_MV02_0x1d6220; // 0x1d6410 - g_ps2RecompiledFunctionTable[219403] = bhEne12_MV02_0x1d6220; // 0x1d6434 - g_ps2RecompiledFunctionTable[219410] = bhEne12_MV02_0x1d6220; // 0x1d6450 - g_ps2RecompiledFunctionTable[219417] = bhEne12_MV02_0x1d6220; // 0x1d646c - g_ps2RecompiledFunctionTable[219426] = bhEne12_MV03_0x1d6490; // 0x1d6490 - g_ps2RecompiledFunctionTable[219481] = bhEne12_MV03_0x1d6490; // 0x1d656c - g_ps2RecompiledFunctionTable[219483] = bhEne12_MV03_0x1d6490; // 0x1d6574 - g_ps2RecompiledFunctionTable[219486] = bhEne12_MV03_0x1d6490; // 0x1d6580 - g_ps2RecompiledFunctionTable[219488] = bhEne12_MV03_0x1d6490; // 0x1d6588 - g_ps2RecompiledFunctionTable[219506] = bhEne12_MV03_0x1d6490; // 0x1d65d0 - g_ps2RecompiledFunctionTable[219530] = bhEne12_MV03_0x1d6490; // 0x1d6630 - g_ps2RecompiledFunctionTable[219533] = bhEne12_MV03_0x1d6490; // 0x1d663c - g_ps2RecompiledFunctionTable[219535] = bhEne12_MV03_0x1d6490; // 0x1d6644 - g_ps2RecompiledFunctionTable[219539] = bhEne12_MV03_0x1d6490; // 0x1d6654 - g_ps2RecompiledFunctionTable[219543] = bhEne12_MV03_0x1d6490; // 0x1d6664 - g_ps2RecompiledFunctionTable[219545] = bhEne12_MV03_0x1d6490; // 0x1d666c - g_ps2RecompiledFunctionTable[219549] = bhEne12_MV03_0x1d6490; // 0x1d667c - g_ps2RecompiledFunctionTable[219584] = bhEne12_MV03_0x1d6490; // 0x1d6708 - g_ps2RecompiledFunctionTable[219592] = bhEne12_MV03_0x1d6490; // 0x1d6728 - g_ps2RecompiledFunctionTable[219599] = bhEne12_MV03_0x1d6490; // 0x1d6744 - g_ps2RecompiledFunctionTable[219606] = bhEne12_MV03_0x1d6490; // 0x1d6760 - g_ps2RecompiledFunctionTable[219615] = bhEne12_MV03_0x1d6490; // 0x1d6784 - g_ps2RecompiledFunctionTable[219622] = bhEne12_MV03_0x1d6490; // 0x1d67a0 - g_ps2RecompiledFunctionTable[219629] = bhEne12_MV03_0x1d6490; // 0x1d67bc - g_ps2RecompiledFunctionTable[219641] = bhEne12_MV03_0x1d6490; // 0x1d67ec - g_ps2RecompiledFunctionTable[219647] = bhEne12_MV03_0x1d6490; // 0x1d6804 - g_ps2RecompiledFunctionTable[219660] = bhEne12_MV03_0x1d6490; // 0x1d6838 - g_ps2RecompiledFunctionTable[219666] = bhEne12_MV04_0x1d6850; // 0x1d6850 - g_ps2RecompiledFunctionTable[219725] = bhEne12_MV04_0x1d6850; // 0x1d693c - g_ps2RecompiledFunctionTable[219734] = bhEne12_MV04_0x1d6850; // 0x1d6960 - g_ps2RecompiledFunctionTable[219744] = bhEne12_MV04_0x1d6850; // 0x1d6988 - g_ps2RecompiledFunctionTable[219753] = bhEne12_MV04_0x1d6850; // 0x1d69ac - g_ps2RecompiledFunctionTable[219763] = bhEne12_MV04_0x1d6850; // 0x1d69d4 - g_ps2RecompiledFunctionTable[219772] = bhEne12_MV04_0x1d6850; // 0x1d69f8 - g_ps2RecompiledFunctionTable[219789] = bhEne12_MV04_0x1d6850; // 0x1d6a3c - g_ps2RecompiledFunctionTable[219847] = bhEne12_MV04_0x1d6850; // 0x1d6b24 - g_ps2RecompiledFunctionTable[219851] = bhEne12_MV04_0x1d6850; // 0x1d6b34 - g_ps2RecompiledFunctionTable[219853] = bhEne12_MV04_0x1d6850; // 0x1d6b3c - g_ps2RecompiledFunctionTable[219866] = bhEne12_MV04_0x1d6850; // 0x1d6b70 - g_ps2RecompiledFunctionTable[219878] = bhEne12_MV04_0x1d6850; // 0x1d6ba0 - g_ps2RecompiledFunctionTable[219885] = bhEne12_MV04_0x1d6850; // 0x1d6bbc - g_ps2RecompiledFunctionTable[219893] = bhEne12_MV04_0x1d6850; // 0x1d6bdc - g_ps2RecompiledFunctionTable[219896] = bhEne12_MV04_0x1d6850; // 0x1d6be8 - g_ps2RecompiledFunctionTable[219900] = bhEne12_MV04_0x1d6850; // 0x1d6bf8 - g_ps2RecompiledFunctionTable[219918] = bhEne12_MV04_0x1d6850; // 0x1d6c40 - g_ps2RecompiledFunctionTable[219921] = bhEne12_MV04_0x1d6850; // 0x1d6c4c - g_ps2RecompiledFunctionTable[219923] = bhEne12_MV04_0x1d6850; // 0x1d6c54 - g_ps2RecompiledFunctionTable[219927] = bhEne12_MV04_0x1d6850; // 0x1d6c64 - g_ps2RecompiledFunctionTable[219930] = bhEne12_MV04_0x1d6850; // 0x1d6c70 - g_ps2RecompiledFunctionTable[219933] = bhEne12_MV04_0x1d6850; // 0x1d6c7c - g_ps2RecompiledFunctionTable[219937] = bhEne12_MV04_0x1d6850; // 0x1d6c8c - g_ps2RecompiledFunctionTable[219939] = bhEne12_MV04_0x1d6850; // 0x1d6c94 - g_ps2RecompiledFunctionTable[219943] = bhEne12_MV04_0x1d6850; // 0x1d6ca4 - g_ps2RecompiledFunctionTable[219978] = bhEne12_MV04_0x1d6850; // 0x1d6d30 - g_ps2RecompiledFunctionTable[219986] = bhEne12_MV04_0x1d6850; // 0x1d6d50 - g_ps2RecompiledFunctionTable[219993] = bhEne12_MV04_0x1d6850; // 0x1d6d6c - g_ps2RecompiledFunctionTable[220000] = bhEne12_MV04_0x1d6850; // 0x1d6d88 - g_ps2RecompiledFunctionTable[220009] = bhEne12_MV04_0x1d6850; // 0x1d6dac - g_ps2RecompiledFunctionTable[220016] = bhEne12_MV04_0x1d6850; // 0x1d6dc8 - g_ps2RecompiledFunctionTable[220023] = bhEne12_MV04_0x1d6850; // 0x1d6de4 - g_ps2RecompiledFunctionTable[220035] = bhEne12_MV04_0x1d6850; // 0x1d6e14 - g_ps2RecompiledFunctionTable[220041] = bhEne12_MV04_0x1d6850; // 0x1d6e2c - g_ps2RecompiledFunctionTable[220054] = bhEne12_MV04_0x1d6850; // 0x1d6e60 - g_ps2RecompiledFunctionTable[220066] = bhEne12_MV05_0x1d6e90; // 0x1d6e90 - g_ps2RecompiledFunctionTable[220070] = bhEne12_MV06_0x1d6ea0; // 0x1d6ea0 - g_ps2RecompiledFunctionTable[220094] = bhEne12_MV07_0x1d6f00; // 0x1d6f00 - g_ps2RecompiledFunctionTable[220106] = bhEne12_MV07_0x1d6f00; // 0x1d6f30 - g_ps2RecompiledFunctionTable[220113] = bhEne12_MV07_0x1d6f00; // 0x1d6f4c - g_ps2RecompiledFunctionTable[220166] = bhEne12_Nage_0x1d7020; // 0x1d7020 - g_ps2RecompiledFunctionTable[220167] = bhEne12_Nage_0x1d7020; // 0x1d7024 - g_ps2RecompiledFunctionTable[220168] = bhEne12_Nage_0x1d7020; // 0x1d7028 - g_ps2RecompiledFunctionTable[220169] = bhEne12_Nage_0x1d7020; // 0x1d702c - g_ps2RecompiledFunctionTable[220170] = bhEne12_Nage_0x1d7020; // 0x1d7030 - g_ps2RecompiledFunctionTable[220171] = bhEne12_Nage_0x1d7020; // 0x1d7034 - g_ps2RecompiledFunctionTable[220172] = bhEne12_Nage_0x1d7020; // 0x1d7038 - g_ps2RecompiledFunctionTable[220173] = bhEne12_Nage_0x1d7020; // 0x1d703c - g_ps2RecompiledFunctionTable[220174] = bhEne12_NG00_0x1d7040; // 0x1d7040 - g_ps2RecompiledFunctionTable[220241] = bhEne12_NG00_0x1d7040; // 0x1d714c - g_ps2RecompiledFunctionTable[220261] = bhEne12_NG00_0x1d7040; // 0x1d719c - g_ps2RecompiledFunctionTable[220289] = bhEne12_NG00_0x1d7040; // 0x1d720c - g_ps2RecompiledFunctionTable[220310] = bhEne12_NG00_0x1d7040; // 0x1d7260 - g_ps2RecompiledFunctionTable[220315] = bhEne12_NG00_0x1d7040; // 0x1d7274 - g_ps2RecompiledFunctionTable[220326] = bhEne12_NG00_0x1d7040; // 0x1d72a0 - g_ps2RecompiledFunctionTable[220331] = bhEne12_NG00_0x1d7040; // 0x1d72b4 - g_ps2RecompiledFunctionTable[220391] = bhEne12_NG00_0x1d7040; // 0x1d73a4 - g_ps2RecompiledFunctionTable[220402] = bhEne12_NG00_0x1d7040; // 0x1d73d0 - g_ps2RecompiledFunctionTable[220413] = bhEne12_NG00_0x1d7040; // 0x1d73fc - g_ps2RecompiledFunctionTable[220422] = bhEne12_NG00_0x1d7040; // 0x1d7420 - g_ps2RecompiledFunctionTable[220432] = bhEne12_NG00_0x1d7040; // 0x1d7448 - g_ps2RecompiledFunctionTable[220446] = bhEne12_Damage_0x1d7480; // 0x1d7480 - g_ps2RecompiledFunctionTable[220447] = bhEne12_Damage_0x1d7480; // 0x1d7484 - g_ps2RecompiledFunctionTable[220448] = bhEne12_Damage_0x1d7480; // 0x1d7488 - g_ps2RecompiledFunctionTable[220449] = bhEne12_Damage_0x1d7480; // 0x1d748c - g_ps2RecompiledFunctionTable[220450] = bhEne12_Damage_0x1d7480; // 0x1d7490 - g_ps2RecompiledFunctionTable[220451] = bhEne12_Damage_0x1d7480; // 0x1d7494 - g_ps2RecompiledFunctionTable[220452] = bhEne12_Damage_0x1d7480; // 0x1d7498 - g_ps2RecompiledFunctionTable[220453] = bhEne12_Damage_0x1d7480; // 0x1d749c - g_ps2RecompiledFunctionTable[220454] = bhEne12_Damage_0x1d7480; // 0x1d74a0 - g_ps2RecompiledFunctionTable[220455] = bhEne12_Damage_0x1d7480; // 0x1d74a4 - g_ps2RecompiledFunctionTable[220456] = bhEne12_Damage_0x1d7480; // 0x1d74a8 - g_ps2RecompiledFunctionTable[220457] = bhEne12_Damage_0x1d7480; // 0x1d74ac - g_ps2RecompiledFunctionTable[220458] = bhEne12_Damage_0x1d7480; // 0x1d74b0 - g_ps2RecompiledFunctionTable[220459] = bhEne12_Damage_0x1d7480; // 0x1d74b4 - g_ps2RecompiledFunctionTable[220460] = bhEne12_Damage_0x1d7480; // 0x1d74b8 - g_ps2RecompiledFunctionTable[220461] = bhEne12_Damage_0x1d7480; // 0x1d74bc - g_ps2RecompiledFunctionTable[220462] = bhEne12_Damage_0x1d7480; // 0x1d74c0 - g_ps2RecompiledFunctionTable[220463] = bhEne12_Damage_0x1d7480; // 0x1d74c4 - g_ps2RecompiledFunctionTable[220464] = bhEne12_Damage_0x1d7480; // 0x1d74c8 - g_ps2RecompiledFunctionTable[220465] = bhEne12_Damage_0x1d7480; // 0x1d74cc - g_ps2RecompiledFunctionTable[220466] = bhEne12_Damage_0x1d7480; // 0x1d74d0 - g_ps2RecompiledFunctionTable[220467] = bhEne12_Damage_0x1d7480; // 0x1d74d4 - g_ps2RecompiledFunctionTable[220468] = bhEne12_Damage_0x1d7480; // 0x1d74d8 - g_ps2RecompiledFunctionTable[220469] = bhEne12_Damage_0x1d7480; // 0x1d74dc - g_ps2RecompiledFunctionTable[220470] = bhEne12_Damage_0x1d7480; // 0x1d74e0 - g_ps2RecompiledFunctionTable[220471] = bhEne12_Damage_0x1d7480; // 0x1d74e4 - g_ps2RecompiledFunctionTable[220472] = bhEne12_Damage_0x1d7480; // 0x1d74e8 - g_ps2RecompiledFunctionTable[220473] = bhEne12_Damage_0x1d7480; // 0x1d74ec - g_ps2RecompiledFunctionTable[220474] = bhEne12_Damage_0x1d7480; // 0x1d74f0 - g_ps2RecompiledFunctionTable[220475] = bhEne12_Damage_0x1d7480; // 0x1d74f4 - g_ps2RecompiledFunctionTable[220476] = bhEne12_Damage_0x1d7480; // 0x1d74f8 - g_ps2RecompiledFunctionTable[220477] = bhEne12_Damage_0x1d7480; // 0x1d74fc - g_ps2RecompiledFunctionTable[220478] = bhEne12_Damage_0x1d7480; // 0x1d7500 - g_ps2RecompiledFunctionTable[220479] = bhEne12_Damage_0x1d7480; // 0x1d7504 - g_ps2RecompiledFunctionTable[220480] = bhEne12_Damage_0x1d7480; // 0x1d7508 - g_ps2RecompiledFunctionTable[220481] = bhEne12_Damage_0x1d7480; // 0x1d750c - g_ps2RecompiledFunctionTable[220482] = bhEne12_Damage_0x1d7480; // 0x1d7510 - g_ps2RecompiledFunctionTable[220483] = bhEne12_Damage_0x1d7480; // 0x1d7514 - g_ps2RecompiledFunctionTable[220484] = bhEne12_Damage_0x1d7480; // 0x1d7518 - g_ps2RecompiledFunctionTable[220485] = bhEne12_Damage_0x1d7480; // 0x1d751c - g_ps2RecompiledFunctionTable[220486] = bhEne12_Damage_0x1d7480; // 0x1d7520 - g_ps2RecompiledFunctionTable[220487] = bhEne12_Damage_0x1d7480; // 0x1d7524 - g_ps2RecompiledFunctionTable[220488] = bhEne12_Damage_0x1d7480; // 0x1d7528 - g_ps2RecompiledFunctionTable[220489] = bhEne12_Damage_0x1d7480; // 0x1d752c - g_ps2RecompiledFunctionTable[220490] = bhEne12_Damage_0x1d7480; // 0x1d7530 - g_ps2RecompiledFunctionTable[220491] = bhEne12_Damage_0x1d7480; // 0x1d7534 - g_ps2RecompiledFunctionTable[220492] = bhEne12_Damage_0x1d7480; // 0x1d7538 - g_ps2RecompiledFunctionTable[220493] = bhEne12_Damage_0x1d7480; // 0x1d753c - g_ps2RecompiledFunctionTable[220494] = bhEne12_Damage_0x1d7480; // 0x1d7540 - g_ps2RecompiledFunctionTable[220495] = bhEne12_Damage_0x1d7480; // 0x1d7544 - g_ps2RecompiledFunctionTable[220496] = bhEne12_Damage_0x1d7480; // 0x1d7548 - g_ps2RecompiledFunctionTable[220497] = bhEne12_Damage_0x1d7480; // 0x1d754c - g_ps2RecompiledFunctionTable[220498] = bhEne12_Damage_0x1d7480; // 0x1d7550 - g_ps2RecompiledFunctionTable[220499] = bhEne12_Damage_0x1d7480; // 0x1d7554 - g_ps2RecompiledFunctionTable[220502] = bhEne12_DG00_0x1d7560; // 0x1d7560 - g_ps2RecompiledFunctionTable[220524] = bhEne12_DG00_0x1d7560; // 0x1d75b8 - g_ps2RecompiledFunctionTable[220600] = bhEne12_DG00_0x1d7560; // 0x1d76e8 - g_ps2RecompiledFunctionTable[220606] = bhEne12_DG00_0x1d7560; // 0x1d7700 - g_ps2RecompiledFunctionTable[220619] = bhEne12_DG00_0x1d7560; // 0x1d7734 - g_ps2RecompiledFunctionTable[220678] = bhEne12_Die_0x1d7820; // 0x1d7820 - g_ps2RecompiledFunctionTable[220679] = bhEne12_Die_0x1d7820; // 0x1d7824 - g_ps2RecompiledFunctionTable[220680] = bhEne12_Die_0x1d7820; // 0x1d7828 - g_ps2RecompiledFunctionTable[220681] = bhEne12_Die_0x1d7820; // 0x1d782c - g_ps2RecompiledFunctionTable[220682] = bhEne12_Die_0x1d7820; // 0x1d7830 - g_ps2RecompiledFunctionTable[220683] = bhEne12_Die_0x1d7820; // 0x1d7834 - g_ps2RecompiledFunctionTable[220684] = bhEne12_Die_0x1d7820; // 0x1d7838 - g_ps2RecompiledFunctionTable[220685] = bhEne12_Die_0x1d7820; // 0x1d783c - g_ps2RecompiledFunctionTable[220686] = bhEne12_DD00_0x1d7840; // 0x1d7840 - g_ps2RecompiledFunctionTable[220740] = bhEne12_DD00_0x1d7840; // 0x1d7918 - g_ps2RecompiledFunctionTable[220758] = bhEne12_InitDamage_0x1d7960; // 0x1d7960 - g_ps2RecompiledFunctionTable[220771] = bhEne12_InitDamage_0x1d7960; // 0x1d7994 - g_ps2RecompiledFunctionTable[220798] = bhEne12_InitDamage_0x1d7960; // 0x1d7a00 - g_ps2RecompiledFunctionTable[220830] = bhEne12_LookPlayaer_0x1d7a80; // 0x1d7a80 - g_ps2RecompiledFunctionTable[220882] = bhEne12_LookPlayaer_0x1d7a80; // 0x1d7b50 - g_ps2RecompiledFunctionTable[220890] = bhEne12_LookPlayaer_0x1d7a80; // 0x1d7b70 - g_ps2RecompiledFunctionTable[220895] = bhEne12_LookPlayaer_0x1d7a80; // 0x1d7b84 - g_ps2RecompiledFunctionTable[220901] = bhEne12_LookPlayaer_0x1d7a80; // 0x1d7b9c - g_ps2RecompiledFunctionTable[220932] = bhEne12_LookPlayaer_0x1d7a80; // 0x1d7c18 - g_ps2RecompiledFunctionTable[220937] = bhEne12_LookPlayaer_0x1d7a80; // 0x1d7c2c - g_ps2RecompiledFunctionTable[220939] = bhEne12_LookPlayaer_0x1d7a80; // 0x1d7c34 - g_ps2RecompiledFunctionTable[220943] = bhEne12_LookPlayaer_0x1d7a80; // 0x1d7c44 - g_ps2RecompiledFunctionTable[220945] = bhEne12_LookPlayaer_0x1d7a80; // 0x1d7c4c - g_ps2RecompiledFunctionTable[220950] = bhEne12_LookPlayaer_0x1d7a80; // 0x1d7c60 - g_ps2RecompiledFunctionTable[220956] = bhEne12_LookPlayaer_0x1d7a80; // 0x1d7c78 - g_ps2RecompiledFunctionTable[220978] = bhEne12_LookPlayaer_0x1d7a80; // 0x1d7cd0 - g_ps2RecompiledFunctionTable[220983] = bhEne12_LookPlayaer_0x1d7a80; // 0x1d7ce4 - g_ps2RecompiledFunctionTable[220987] = bhEne12_LookPlayaer_0x1d7a80; // 0x1d7cf4 - g_ps2RecompiledFunctionTable[220995] = bhEne12_LookPlayaer_0x1d7a80; // 0x1d7d14 - g_ps2RecompiledFunctionTable[220998] = bhEne12_LookPlayaer_0x1d7a80; // 0x1d7d20 - g_ps2RecompiledFunctionTable[221000] = bhEne12_LookPlayaer_0x1d7a80; // 0x1d7d28 - g_ps2RecompiledFunctionTable[221005] = bhEne12_LookPlayaer_0x1d7a80; // 0x1d7d3c - g_ps2RecompiledFunctionTable[221009] = bhEne12_LookPlayaer_0x1d7a80; // 0x1d7d4c - g_ps2RecompiledFunctionTable[221014] = bhEne12_LookPlayaer_0x1d7a80; // 0x1d7d60 - g_ps2RecompiledFunctionTable[221016] = bhEne12_LookPlayaer_0x1d7a80; // 0x1d7d68 - g_ps2RecompiledFunctionTable[221021] = bhEne12_LookPlayaer_0x1d7a80; // 0x1d7d7c - g_ps2RecompiledFunctionTable[221025] = bhEne12_LookPlayaer_0x1d7a80; // 0x1d7d8c - g_ps2RecompiledFunctionTable[221034] = bhEne12_LookPlayaer_0x1d7a80; // 0x1d7db0 - g_ps2RecompiledFunctionTable[221039] = bhEne12_LookPlayaer_0x1d7a80; // 0x1d7dc4 - g_ps2RecompiledFunctionTable[221041] = bhEne12_LookPlayaer_0x1d7a80; // 0x1d7dcc - g_ps2RecompiledFunctionTable[221045] = bhEne12_LookPlayaer_0x1d7a80; // 0x1d7ddc - g_ps2RecompiledFunctionTable[221048] = bhEne12_LookPlayaer_0x1d7a80; // 0x1d7de8 - g_ps2RecompiledFunctionTable[221050] = bhEne12_LookPlayaer_0x1d7a80; // 0x1d7df0 - g_ps2RecompiledFunctionTable[221055] = bhEne12_LookPlayaer_0x1d7a80; // 0x1d7e04 - g_ps2RecompiledFunctionTable[221058] = bhEne12_LookPlayaer_0x1d7a80; // 0x1d7e10 - g_ps2RecompiledFunctionTable[221063] = bhEne12_LookPlayaer_0x1d7a80; // 0x1d7e24 - g_ps2RecompiledFunctionTable[221068] = bhEne12_LookPlayaer_0x1d7a80; // 0x1d7e38 - g_ps2RecompiledFunctionTable[221071] = bhEne12_LookPlayaer_0x1d7a80; // 0x1d7e44 - g_ps2RecompiledFunctionTable[221073] = bhEne12_LookPlayaer_0x1d7a80; // 0x1d7e4c - g_ps2RecompiledFunctionTable[221078] = bhEne12_LookPlayaer_0x1d7a80; // 0x1d7e60 - g_ps2RecompiledFunctionTable[221086] = bhEne12_LookPlayaer_0x1d7a80; // 0x1d7e80 - g_ps2RecompiledFunctionTable[221090] = bhEne12_LookPlayaer_0x1d7a80; // 0x1d7e90 - g_ps2RecompiledFunctionTable[221094] = bhEne12_LookPlayaer_0x1d7a80; // 0x1d7ea0 - g_ps2RecompiledFunctionTable[221097] = bhEne12_LookPlayaer_0x1d7a80; // 0x1d7eac - g_ps2RecompiledFunctionTable[221109] = bhEne12_LookPlayaer_0x1d7a80; // 0x1d7edc - g_ps2RecompiledFunctionTable[221112] = bhEne12_LookPlayaer_0x1d7a80; // 0x1d7ee8 - g_ps2RecompiledFunctionTable[221117] = bhEne12_LookPlayaer_0x1d7a80; // 0x1d7efc - g_ps2RecompiledFunctionTable[221120] = bhEne12_LookPlayaer_0x1d7a80; // 0x1d7f08 - g_ps2RecompiledFunctionTable[221125] = bhEne12_LookPlayaer_0x1d7a80; // 0x1d7f1c - g_ps2RecompiledFunctionTable[221136] = bhEne12_LookPlayaer_0x1d7a80; // 0x1d7f48 - g_ps2RecompiledFunctionTable[221141] = bhEne12_LookPlayaer_0x1d7a80; // 0x1d7f5c - g_ps2RecompiledFunctionTable[221145] = bhEne12_LookPlayaer_0x1d7a80; // 0x1d7f6c - g_ps2RecompiledFunctionTable[221170] = bhEne12_HitMark_0x1d7fd0; // 0x1d7fd0 - g_ps2RecompiledFunctionTable[221224] = bhEne12_HitMark_0x1d7fd0; // 0x1d80a8 - g_ps2RecompiledFunctionTable[221240] = bhEne12_HitMark_0x1d7fd0; // 0x1d80e8 - g_ps2RecompiledFunctionTable[221256] = bhEne12_HitMark_0x1d7fd0; // 0x1d8128 - g_ps2RecompiledFunctionTable[221294] = bhEne12_HitMark_0x1d7fd0; // 0x1d81c0 - g_ps2RecompiledFunctionTable[221308] = bhEne12_HitMark_0x1d7fd0; // 0x1d81f8 - g_ps2RecompiledFunctionTable[221326] = bhEne12_HitMark_0x1d7fd0; // 0x1d8240 - g_ps2RecompiledFunctionTable[221340] = bhEne12_HitMark_0x1d7fd0; // 0x1d8278 - g_ps2RecompiledFunctionTable[221350] = bhEne12_HitMark_0x1d7fd0; // 0x1d82a0 - g_ps2RecompiledFunctionTable[221366] = bhEne12_HitMark_0x1d7fd0; // 0x1d82e0 - g_ps2RecompiledFunctionTable[221382] = bhEne12_HitMark_0x1d7fd0; // 0x1d8320 - g_ps2RecompiledFunctionTable[221397] = bhEne12_HitMark_0x1d7fd0; // 0x1d835c - g_ps2RecompiledFunctionTable[221410] = bhEne12_HitMark_0x1d7fd0; // 0x1d8390 - g_ps2RecompiledFunctionTable[221423] = bhEne12_HitMark_0x1d7fd0; // 0x1d83c4 - g_ps2RecompiledFunctionTable[221429] = bhEne12_HitMark_0x1d7fd0; // 0x1d83dc - g_ps2RecompiledFunctionTable[221454] = bhEne12_HitMark_0x1d7fd0; // 0x1d8440 - g_ps2RecompiledFunctionTable[221470] = bhEne12_HitMark_0x1d7fd0; // 0x1d8480 - g_ps2RecompiledFunctionTable[221486] = bhEne12_HitMark_0x1d7fd0; // 0x1d84c0 - g_ps2RecompiledFunctionTable[221504] = bhEne12_HitMark_0x1d7fd0; // 0x1d8508 - g_ps2RecompiledFunctionTable[221514] = bhEne12_FixedLegPos_0x1d8530; // 0x1d8530 - g_ps2RecompiledFunctionTable[221615] = bhEne12_FixedLegPos_0x1d8530; // 0x1d86c4 - g_ps2RecompiledFunctionTable[221630] = bhEne12_PlayerControl_0x1d8700; // 0x1d8700 - g_ps2RecompiledFunctionTable[221702] = bhEne12_PlayerControl_0x1d8700; // 0x1d8820 - g_ps2RecompiledFunctionTable[221705] = bhEne12_PlayerControl_0x1d8700; // 0x1d882c - g_ps2RecompiledFunctionTable[221854] = bhEne12_PlayerControl_0x1d8700; // 0x1d8a80 - g_ps2RecompiledFunctionTable[221869] = bhEne12_PlayerControl_0x1d8700; // 0x1d8abc - g_ps2RecompiledFunctionTable[221984] = bhEne12_PlayerControl_0x1d8700; // 0x1d8c88 - g_ps2RecompiledFunctionTable[222013] = bhEne12_PlayerControl_0x1d8700; // 0x1d8cfc - g_ps2RecompiledFunctionTable[222042] = bhEne12_PlayerControl_0x1d8700; // 0x1d8d70 - g_ps2RecompiledFunctionTable[222058] = bhEne12_FlameLiquid_0x1d8db0; // 0x1d8db0 - g_ps2RecompiledFunctionTable[222089] = bhEne12_FlameLiquid_0x1d8db0; // 0x1d8e2c - g_ps2RecompiledFunctionTable[222093] = bhEne12_FlameLiquid_0x1d8db0; // 0x1d8e3c - g_ps2RecompiledFunctionTable[222095] = bhEne12_FlameLiquid_0x1d8db0; // 0x1d8e44 - g_ps2RecompiledFunctionTable[222151] = bhEne12_FlameLiquid_0x1d8db0; // 0x1d8f24 - g_ps2RecompiledFunctionTable[222192] = bhEne12_FlameLiquid_0x1d8db0; // 0x1d8fc8 - g_ps2RecompiledFunctionTable[222222] = bhEne12_FlameLiquid_0x1d8db0; // 0x1d9040 - g_ps2RecompiledFunctionTable[222227] = bhEne12_FlameLiquid_0x1d8db0; // 0x1d9054 - g_ps2RecompiledFunctionTable[222234] = bhEne12_FlameLiquid_0x1d8db0; // 0x1d9070 - g_ps2RecompiledFunctionTable[222254] = bhEne12_Acid_0x1d90c0; // 0x1d90c0 - g_ps2RecompiledFunctionTable[222275] = bhEne12_Acid_0x1d90c0; // 0x1d9114 - g_ps2RecompiledFunctionTable[222280] = bhEne12_Acid_0x1d90c0; // 0x1d9128 - g_ps2RecompiledFunctionTable[222317] = bhEne12_Acid_0x1d90c0; // 0x1d91bc - g_ps2RecompiledFunctionTable[222319] = bhEne12_Acid_0x1d90c0; // 0x1d91c4 - g_ps2RecompiledFunctionTable[222353] = bhEne12_Acid_0x1d90c0; // 0x1d924c - g_ps2RecompiledFunctionTable[222383] = bhEne12_Acid_0x1d90c0; // 0x1d92c4 - g_ps2RecompiledFunctionTable[222385] = bhEne12_Acid_0x1d90c0; // 0x1d92cc - g_ps2RecompiledFunctionTable[222399] = bhEne12_Acid_0x1d90c0; // 0x1d9304 - g_ps2RecompiledFunctionTable[222402] = bhEne12_Acid_0x1d90c0; // 0x1d9310 - g_ps2RecompiledFunctionTable[222406] = bhEne12_Acid_0x1d90c0; // 0x1d9320 - g_ps2RecompiledFunctionTable[222408] = bhEne12_Acid_0x1d90c0; // 0x1d9328 - g_ps2RecompiledFunctionTable[222450] = bhEne12_CheckWall_0x1d93d0; // 0x1d93d0 - g_ps2RecompiledFunctionTable[222477] = bhEne12_CheckWall_0x1d93d0; // 0x1d943c - g_ps2RecompiledFunctionTable[222488] = bhEne12_CheckWall_0x1d93d0; // 0x1d9468 - g_ps2RecompiledFunctionTable[222498] = bhEne12_Blood_0x1d9490; // 0x1d9490 - g_ps2RecompiledFunctionTable[222534] = bhEne12_Blood_0x1d9490; // 0x1d9520 - g_ps2RecompiledFunctionTable[222538] = bhEne12_Blood_0x1d9490; // 0x1d9530 - g_ps2RecompiledFunctionTable[222540] = bhEne12_Blood_0x1d9490; // 0x1d9538 - g_ps2RecompiledFunctionTable[222554] = bhEne12_Blood_0x1d9490; // 0x1d9570 - g_ps2RecompiledFunctionTable[222574] = bhEne12_Blood_0x1d9490; // 0x1d95c0 - g_ps2RecompiledFunctionTable[222577] = bhEne12_Blood_0x1d9490; // 0x1d95cc - g_ps2RecompiledFunctionTable[222597] = bhEne12_Blood_0x1d9490; // 0x1d961c - g_ps2RecompiledFunctionTable[222606] = bhEne12_Blood_0x1d9490; // 0x1d9640 - g_ps2RecompiledFunctionTable[222647] = bhEne12_Blood_0x1d9490; // 0x1d96e4 - g_ps2RecompiledFunctionTable[222682] = bhEne12_AvoidWall_0x1d9770; // 0x1d9770 - g_ps2RecompiledFunctionTable[222708] = bhEne12_AvoidWall_0x1d9770; // 0x1d97d8 - g_ps2RecompiledFunctionTable[222725] = bhEne12_AvoidWall_0x1d9770; // 0x1d981c - g_ps2RecompiledFunctionTable[222739] = bhEne12_AvoidWall_0x1d9770; // 0x1d9854 - g_ps2RecompiledFunctionTable[222754] = bhEne12_CallSE_0x1d9890; // 0x1d9890 - g_ps2RecompiledFunctionTable[222794] = bhEne12_CallSE_0x1d9890; // 0x1d9930 - g_ps2RecompiledFunctionTable[222801] = bhEne12_CallSE_0x1d9890; // 0x1d994c - g_ps2RecompiledFunctionTable[222810] = bhEne12_CallSE_0x1d9890; // 0x1d9970 - g_ps2RecompiledFunctionTable[222817] = bhEne12_CallSE_0x1d9890; // 0x1d998c - g_ps2RecompiledFunctionTable[222826] = bhEne12_CallSE_0x1d9890; // 0x1d99b0 - g_ps2RecompiledFunctionTable[222830] = bhEne12_CallSE_0x1d9890; // 0x1d99c0 - g_ps2RecompiledFunctionTable[222838] = bhEne12_CallSE_0x1d9890; // 0x1d99e0 - g_ps2RecompiledFunctionTable[222847] = bhEne12_CallSE_0x1d9890; // 0x1d9a04 - g_ps2RecompiledFunctionTable[222855] = bhEne12_CallSE_0x1d9890; // 0x1d9a24 - g_ps2RecompiledFunctionTable[222864] = bhEne12_CallSE_0x1d9890; // 0x1d9a48 - g_ps2RecompiledFunctionTable[222873] = bhEne12_CallSE_0x1d9890; // 0x1d9a6c - g_ps2RecompiledFunctionTable[222880] = bhEne12_CallSE_0x1d9890; // 0x1d9a88 - g_ps2RecompiledFunctionTable[222889] = bhEne12_CallSE_0x1d9890; // 0x1d9aac - g_ps2RecompiledFunctionTable[222896] = bhEne12_CallSE_0x1d9890; // 0x1d9ac8 - g_ps2RecompiledFunctionTable[222903] = bhEne12_CallSE_0x1d9890; // 0x1d9ae4 - g_ps2RecompiledFunctionTable[222912] = bhEne12_CallSE_0x1d9890; // 0x1d9b08 - g_ps2RecompiledFunctionTable[222920] = bhEne12_CallSE_0x1d9890; // 0x1d9b28 - g_ps2RecompiledFunctionTable[222928] = bhEne12_CallSE_0x1d9890; // 0x1d9b48 - g_ps2RecompiledFunctionTable[222934] = bhEne12_CallFootSE_0x1d9b60; // 0x1d9b60 - g_ps2RecompiledFunctionTable[222950] = bhEne12_CallFootSE_0x1d9b60; // 0x1d9ba0 - g_ps2RecompiledFunctionTable[222957] = bhEne12_CallFootSE_0x1d9b60; // 0x1d9bbc - g_ps2RecompiledFunctionTable[222961] = bhEne12_CallFootSE_0x1d9b60; // 0x1d9bcc - g_ps2RecompiledFunctionTable[222972] = bhEne12_CallFootSE_0x1d9b60; // 0x1d9bf8 - g_ps2RecompiledFunctionTable[222979] = bhEne12_CallFootSE_0x1d9b60; // 0x1d9c14 - g_ps2RecompiledFunctionTable[222986] = bhEne12_SetFireBintaEffect_0x1d9c30; // 0x1d9c30 - g_ps2RecompiledFunctionTable[223051] = bhEne12_SetFireBintaEffect_0x1d9c30; // 0x1d9d34 - g_ps2RecompiledFunctionTable[223072] = bhEne12_SetFireBintaEffect_0x1d9c30; // 0x1d9d88 - g_ps2RecompiledFunctionTable[223111] = bhEne12_SetFireBintaEffect_0x1d9c30; // 0x1d9e24 - g_ps2RecompiledFunctionTable[223175] = bhEne12_SetFireBintaEffect_0x1d9c30; // 0x1d9f24 - g_ps2RecompiledFunctionTable[223210] = bhEne12_SetFireBintaEffect_0x1d9c30; // 0x1d9fb0 - g_ps2RecompiledFunctionTable[223212] = bhEne12_SetFireBintaEffect_0x1d9c30; // 0x1d9fb8 - g_ps2RecompiledFunctionTable[223247] = bhEne12_SetFireBintaEffect_0x1d9c30; // 0x1da044 - g_ps2RecompiledFunctionTable[223283] = bhEne12_SetFireBintaEffect_0x1d9c30; // 0x1da0d4 - g_ps2RecompiledFunctionTable[223285] = bhEne12_SetFireBintaEffect_0x1d9c30; // 0x1da0dc - g_ps2RecompiledFunctionTable[223316] = bhEne12_SetFireBintaEffect_0x1d9c30; // 0x1da158 - g_ps2RecompiledFunctionTable[223352] = bhEne12_SetFireBintaEffect_0x1d9c30; // 0x1da1e8 - g_ps2RecompiledFunctionTable[223354] = bhEne12_SetFireBintaEffect_0x1d9c30; // 0x1da1f0 - g_ps2RecompiledFunctionTable[223388] = bhEne12_SetFireBintaEffect_0x1d9c30; // 0x1da278 - g_ps2RecompiledFunctionTable[223430] = bhEne12_SetFireBintaEffect_0x1d9c30; // 0x1da320 - g_ps2RecompiledFunctionTable[223438] = bhEne13_0x1da340; // 0x1da340 - g_ps2RecompiledFunctionTable[223439] = bhEne13_0x1da340; // 0x1da344 - g_ps2RecompiledFunctionTable[223440] = bhEne13_0x1da340; // 0x1da348 - g_ps2RecompiledFunctionTable[223441] = bhEne13_0x1da340; // 0x1da34c - g_ps2RecompiledFunctionTable[223442] = bhEne13_0x1da340; // 0x1da350 - g_ps2RecompiledFunctionTable[223443] = bhEne13_0x1da340; // 0x1da354 - g_ps2RecompiledFunctionTable[223444] = bhEne13_0x1da340; // 0x1da358 - g_ps2RecompiledFunctionTable[223445] = bhEne13_0x1da340; // 0x1da35c - g_ps2RecompiledFunctionTable[223446] = bhEne13_0x1da340; // 0x1da360 - g_ps2RecompiledFunctionTable[223447] = bhEne13_0x1da340; // 0x1da364 - g_ps2RecompiledFunctionTable[223448] = bhEne13_0x1da340; // 0x1da368 - g_ps2RecompiledFunctionTable[223449] = bhEne13_0x1da340; // 0x1da36c - g_ps2RecompiledFunctionTable[223450] = bhEne13_0x1da340; // 0x1da370 - g_ps2RecompiledFunctionTable[223451] = bhEne13_0x1da340; // 0x1da374 - g_ps2RecompiledFunctionTable[223452] = bhEne13_0x1da340; // 0x1da378 - g_ps2RecompiledFunctionTable[223453] = bhEne13_0x1da340; // 0x1da37c - g_ps2RecompiledFunctionTable[223454] = bhEne13_0x1da340; // 0x1da380 - g_ps2RecompiledFunctionTable[223455] = bhEne13_0x1da340; // 0x1da384 - g_ps2RecompiledFunctionTable[223456] = bhEne13_0x1da340; // 0x1da388 - g_ps2RecompiledFunctionTable[223457] = bhEne13_0x1da340; // 0x1da38c - g_ps2RecompiledFunctionTable[223458] = bhEne13_0x1da340; // 0x1da390 - g_ps2RecompiledFunctionTable[223459] = bhEne13_0x1da340; // 0x1da394 - g_ps2RecompiledFunctionTable[223460] = bhEne13_0x1da340; // 0x1da398 - g_ps2RecompiledFunctionTable[223461] = bhEne13_0x1da340; // 0x1da39c - g_ps2RecompiledFunctionTable[223462] = bhEne13_0x1da340; // 0x1da3a0 - g_ps2RecompiledFunctionTable[223463] = bhEne13_0x1da340; // 0x1da3a4 - g_ps2RecompiledFunctionTable[223464] = bhEne13_0x1da340; // 0x1da3a8 - g_ps2RecompiledFunctionTable[223466] = bhEne13_Init_0x1da3b0; // 0x1da3b0 - g_ps2RecompiledFunctionTable[223518] = bhEne13_Init_0x1da3b0; // 0x1da480 - g_ps2RecompiledFunctionTable[223525] = bhEne13_Init_0x1da3b0; // 0x1da49c - g_ps2RecompiledFunctionTable[223556] = bhEne13_Init_0x1da3b0; // 0x1da518 - g_ps2RecompiledFunctionTable[223587] = bhEne13_Init_0x1da3b0; // 0x1da594 - g_ps2RecompiledFunctionTable[223618] = bhEne13_Init_0x1da3b0; // 0x1da610 - g_ps2RecompiledFunctionTable[223664] = bhEne13_Init_0x1da3b0; // 0x1da6c8 - g_ps2RecompiledFunctionTable[223670] = bhEne13_Init_0x1da3b0; // 0x1da6e0 - g_ps2RecompiledFunctionTable[223713] = bhEne13_Init_0x1da3b0; // 0x1da78c - g_ps2RecompiledFunctionTable[223756] = bhEne13_Init_0x1da3b0; // 0x1da838 - g_ps2RecompiledFunctionTable[223764] = bhEne13_Init_0x1da3b0; // 0x1da858 - g_ps2RecompiledFunctionTable[223772] = bhEne13_Init_0x1da3b0; // 0x1da878 - g_ps2RecompiledFunctionTable[223780] = bhEne13_Init_0x1da3b0; // 0x1da898 - g_ps2RecompiledFunctionTable[223788] = bhEne13_Init_0x1da3b0; // 0x1da8b8 - g_ps2RecompiledFunctionTable[223796] = bhEne13_Init_0x1da3b0; // 0x1da8d8 - g_ps2RecompiledFunctionTable[223822] = bhEne13_Init_0x1da3b0; // 0x1da940 - g_ps2RecompiledFunctionTable[223828] = bhEne13_Init_0x1da3b0; // 0x1da958 - g_ps2RecompiledFunctionTable[223834] = bhEne13_Init_0x1da3b0; // 0x1da970 - g_ps2RecompiledFunctionTable[223840] = bhEne13_Init_0x1da3b0; // 0x1da988 - g_ps2RecompiledFunctionTable[223846] = bhEne13_Init_0x1da3b0; // 0x1da9a0 - g_ps2RecompiledFunctionTable[223854] = bhEne13_Init_0x1da3b0; // 0x1da9c0 - g_ps2RecompiledFunctionTable[223914] = bhEne13_Brain_0x1daab0; // 0x1daab0 - g_ps2RecompiledFunctionTable[223915] = bhEne13_Brain_0x1daab0; // 0x1daab4 - g_ps2RecompiledFunctionTable[223916] = bhEne13_Brain_0x1daab0; // 0x1daab8 - g_ps2RecompiledFunctionTable[223917] = bhEne13_Brain_0x1daab0; // 0x1daabc - g_ps2RecompiledFunctionTable[223918] = bhEne13_Brain_0x1daab0; // 0x1daac0 - g_ps2RecompiledFunctionTable[223919] = bhEne13_Brain_0x1daab0; // 0x1daac4 - g_ps2RecompiledFunctionTable[223920] = bhEne13_Brain_0x1daab0; // 0x1daac8 - g_ps2RecompiledFunctionTable[223921] = bhEne13_Brain_0x1daab0; // 0x1daacc - g_ps2RecompiledFunctionTable[223922] = bhEne13_BR00_0x1daad0; // 0x1daad0 - g_ps2RecompiledFunctionTable[223939] = bhEne13_BR00_0x1daad0; // 0x1dab14 - g_ps2RecompiledFunctionTable[224025] = bhEne13_BR00_0x1daad0; // 0x1dac6c - g_ps2RecompiledFunctionTable[224034] = bhEne13_BR00_0x1daad0; // 0x1dac90 - g_ps2RecompiledFunctionTable[224083] = bhEne13_BR00_0x1daad0; // 0x1dad54 - g_ps2RecompiledFunctionTable[224096] = bhEne13_BR00_0x1daad0; // 0x1dad88 - g_ps2RecompiledFunctionTable[224101] = bhEne13_BR00_0x1daad0; // 0x1dad9c - g_ps2RecompiledFunctionTable[224131] = bhEne13_BR00_0x1daad0; // 0x1dae14 - g_ps2RecompiledFunctionTable[224158] = bhEne13_BR01_0x1dae80; // 0x1dae80 - g_ps2RecompiledFunctionTable[224175] = bhEne13_BR01_0x1dae80; // 0x1daec4 - g_ps2RecompiledFunctionTable[224232] = bhEne13_BR01_0x1dae80; // 0x1dafa8 - g_ps2RecompiledFunctionTable[224241] = bhEne13_BR01_0x1dae80; // 0x1dafcc - g_ps2RecompiledFunctionTable[224286] = bhEne13_Move_0x1db080; // 0x1db080 - g_ps2RecompiledFunctionTable[224287] = bhEne13_Move_0x1db080; // 0x1db084 - g_ps2RecompiledFunctionTable[224288] = bhEne13_Move_0x1db080; // 0x1db088 - g_ps2RecompiledFunctionTable[224289] = bhEne13_Move_0x1db080; // 0x1db08c - g_ps2RecompiledFunctionTable[224290] = bhEne13_Move_0x1db080; // 0x1db090 - g_ps2RecompiledFunctionTable[224291] = bhEne13_Move_0x1db080; // 0x1db094 - g_ps2RecompiledFunctionTable[224292] = bhEne13_Move_0x1db080; // 0x1db098 - g_ps2RecompiledFunctionTable[224293] = bhEne13_Move_0x1db080; // 0x1db09c - g_ps2RecompiledFunctionTable[224294] = bhEne13_Move_0x1db080; // 0x1db0a0 - g_ps2RecompiledFunctionTable[224295] = bhEne13_Move_0x1db080; // 0x1db0a4 - g_ps2RecompiledFunctionTable[224296] = bhEne13_Move_0x1db080; // 0x1db0a8 - g_ps2RecompiledFunctionTable[224297] = bhEne13_Move_0x1db080; // 0x1db0ac - g_ps2RecompiledFunctionTable[224298] = bhEne13_Move_0x1db080; // 0x1db0b0 - g_ps2RecompiledFunctionTable[224299] = bhEne13_Move_0x1db080; // 0x1db0b4 - g_ps2RecompiledFunctionTable[224300] = bhEne13_Move_0x1db080; // 0x1db0b8 - g_ps2RecompiledFunctionTable[224301] = bhEne13_Move_0x1db080; // 0x1db0bc - g_ps2RecompiledFunctionTable[224302] = bhEne13_Move_0x1db080; // 0x1db0c0 - g_ps2RecompiledFunctionTable[224303] = bhEne13_Move_0x1db080; // 0x1db0c4 - g_ps2RecompiledFunctionTable[224304] = bhEne13_Move_0x1db080; // 0x1db0c8 - g_ps2RecompiledFunctionTable[224305] = bhEne13_Move_0x1db080; // 0x1db0cc - g_ps2RecompiledFunctionTable[224306] = bhEne13_Move_0x1db080; // 0x1db0d0 - g_ps2RecompiledFunctionTable[224307] = bhEne13_Move_0x1db080; // 0x1db0d4 - g_ps2RecompiledFunctionTable[224308] = bhEne13_Move_0x1db080; // 0x1db0d8 - g_ps2RecompiledFunctionTable[224309] = bhEne13_Move_0x1db080; // 0x1db0dc - g_ps2RecompiledFunctionTable[224310] = bhEne13_Move_0x1db080; // 0x1db0e0 - g_ps2RecompiledFunctionTable[224311] = bhEne13_Move_0x1db080; // 0x1db0e4 - g_ps2RecompiledFunctionTable[224312] = bhEne13_Move_0x1db080; // 0x1db0e8 - g_ps2RecompiledFunctionTable[224313] = bhEne13_Move_0x1db080; // 0x1db0ec - g_ps2RecompiledFunctionTable[224314] = bhEne13_Move_0x1db080; // 0x1db0f0 - g_ps2RecompiledFunctionTable[224315] = bhEne13_Move_0x1db080; // 0x1db0f4 - g_ps2RecompiledFunctionTable[224316] = bhEne13_Move_0x1db080; // 0x1db0f8 - g_ps2RecompiledFunctionTable[224317] = bhEne13_Move_0x1db080; // 0x1db0fc - g_ps2RecompiledFunctionTable[224318] = bhEne13_Move_0x1db080; // 0x1db100 - g_ps2RecompiledFunctionTable[224319] = bhEne13_Move_0x1db080; // 0x1db104 - g_ps2RecompiledFunctionTable[224320] = bhEne13_Move_0x1db080; // 0x1db108 - g_ps2RecompiledFunctionTable[224321] = bhEne13_Move_0x1db080; // 0x1db10c - g_ps2RecompiledFunctionTable[224322] = bhEne13_Move_0x1db080; // 0x1db110 - g_ps2RecompiledFunctionTable[224323] = bhEne13_Move_0x1db080; // 0x1db114 - g_ps2RecompiledFunctionTable[224324] = bhEne13_Move_0x1db080; // 0x1db118 - g_ps2RecompiledFunctionTable[224325] = bhEne13_Move_0x1db080; // 0x1db11c - g_ps2RecompiledFunctionTable[224326] = bhEne13_Move_0x1db080; // 0x1db120 - g_ps2RecompiledFunctionTable[224327] = bhEne13_Move_0x1db080; // 0x1db124 - g_ps2RecompiledFunctionTable[224328] = bhEne13_Move_0x1db080; // 0x1db128 - g_ps2RecompiledFunctionTable[224329] = bhEne13_Move_0x1db080; // 0x1db12c - g_ps2RecompiledFunctionTable[224330] = bhEne13_Move_0x1db080; // 0x1db130 - g_ps2RecompiledFunctionTable[224331] = bhEne13_Move_0x1db080; // 0x1db134 - g_ps2RecompiledFunctionTable[224332] = bhEne13_Move_0x1db080; // 0x1db138 - g_ps2RecompiledFunctionTable[224333] = bhEne13_Move_0x1db080; // 0x1db13c - g_ps2RecompiledFunctionTable[224334] = bhEne13_Move_0x1db080; // 0x1db140 - g_ps2RecompiledFunctionTable[224335] = bhEne13_Move_0x1db080; // 0x1db144 - g_ps2RecompiledFunctionTable[224336] = bhEne13_Move_0x1db080; // 0x1db148 - g_ps2RecompiledFunctionTable[224337] = bhEne13_Move_0x1db080; // 0x1db14c - g_ps2RecompiledFunctionTable[224338] = bhEne13_Move_0x1db080; // 0x1db150 - g_ps2RecompiledFunctionTable[224339] = bhEne13_Move_0x1db080; // 0x1db154 - g_ps2RecompiledFunctionTable[224340] = bhEne13_Move_0x1db080; // 0x1db158 - g_ps2RecompiledFunctionTable[224341] = bhEne13_Move_0x1db080; // 0x1db15c - g_ps2RecompiledFunctionTable[224342] = bhEne13_Move_0x1db080; // 0x1db160 - g_ps2RecompiledFunctionTable[224343] = bhEne13_Move_0x1db080; // 0x1db164 - g_ps2RecompiledFunctionTable[224344] = bhEne13_Move_0x1db080; // 0x1db168 - g_ps2RecompiledFunctionTable[224345] = bhEne13_Move_0x1db080; // 0x1db16c - g_ps2RecompiledFunctionTable[224346] = bhEne13_Move_0x1db080; // 0x1db170 - g_ps2RecompiledFunctionTable[224347] = bhEne13_Move_0x1db080; // 0x1db174 - g_ps2RecompiledFunctionTable[224348] = bhEne13_Move_0x1db080; // 0x1db178 - g_ps2RecompiledFunctionTable[224349] = bhEne13_Move_0x1db080; // 0x1db17c - g_ps2RecompiledFunctionTable[224350] = bhEne13_Move_0x1db080; // 0x1db180 - g_ps2RecompiledFunctionTable[224354] = bhEne13_MV00_0x1db190; // 0x1db190 - g_ps2RecompiledFunctionTable[224370] = bhEne13_MV01_0x1db1d0; // 0x1db1d0 - g_ps2RecompiledFunctionTable[224426] = bhEne13_MV02_0x1db2b0; // 0x1db2b0 - g_ps2RecompiledFunctionTable[224474] = bhEne13_MV03_0x1db370; // 0x1db370 - g_ps2RecompiledFunctionTable[224538] = bhEne13_Nage_0x1db470; // 0x1db470 - g_ps2RecompiledFunctionTable[224542] = bhEne13_Damage_0x1db480; // 0x1db480 - g_ps2RecompiledFunctionTable[224543] = bhEne13_Damage_0x1db480; // 0x1db484 - g_ps2RecompiledFunctionTable[224544] = bhEne13_Damage_0x1db480; // 0x1db488 - g_ps2RecompiledFunctionTable[224545] = bhEne13_Damage_0x1db480; // 0x1db48c - g_ps2RecompiledFunctionTable[224546] = bhEne13_Damage_0x1db480; // 0x1db490 - g_ps2RecompiledFunctionTable[224547] = bhEne13_Damage_0x1db480; // 0x1db494 - g_ps2RecompiledFunctionTable[224548] = bhEne13_Damage_0x1db480; // 0x1db498 - g_ps2RecompiledFunctionTable[224549] = bhEne13_Damage_0x1db480; // 0x1db49c - g_ps2RecompiledFunctionTable[224550] = bhEne13_Damage_0x1db480; // 0x1db4a0 - g_ps2RecompiledFunctionTable[224551] = bhEne13_Damage_0x1db480; // 0x1db4a4 - g_ps2RecompiledFunctionTable[224552] = bhEne13_Damage_0x1db480; // 0x1db4a8 - g_ps2RecompiledFunctionTable[224553] = bhEne13_Damage_0x1db480; // 0x1db4ac - g_ps2RecompiledFunctionTable[224554] = bhEne13_Damage_0x1db480; // 0x1db4b0 - g_ps2RecompiledFunctionTable[224555] = bhEne13_Damage_0x1db480; // 0x1db4b4 - g_ps2RecompiledFunctionTable[224556] = bhEne13_Damage_0x1db480; // 0x1db4b8 - g_ps2RecompiledFunctionTable[224557] = bhEne13_Damage_0x1db480; // 0x1db4bc - g_ps2RecompiledFunctionTable[224558] = bhEne13_Damage_0x1db480; // 0x1db4c0 - g_ps2RecompiledFunctionTable[224559] = bhEne13_Damage_0x1db480; // 0x1db4c4 - g_ps2RecompiledFunctionTable[224560] = bhEne13_Damage_0x1db480; // 0x1db4c8 - g_ps2RecompiledFunctionTable[224561] = bhEne13_Damage_0x1db480; // 0x1db4cc - g_ps2RecompiledFunctionTable[224562] = bhEne13_Damage_0x1db480; // 0x1db4d0 - g_ps2RecompiledFunctionTable[224563] = bhEne13_Damage_0x1db480; // 0x1db4d4 - g_ps2RecompiledFunctionTable[224564] = bhEne13_Damage_0x1db480; // 0x1db4d8 - g_ps2RecompiledFunctionTable[224565] = bhEne13_Damage_0x1db480; // 0x1db4dc - g_ps2RecompiledFunctionTable[224566] = bhEne13_Damage_0x1db480; // 0x1db4e0 - g_ps2RecompiledFunctionTable[224567] = bhEne13_Damage_0x1db480; // 0x1db4e4 - g_ps2RecompiledFunctionTable[224568] = bhEne13_Damage_0x1db480; // 0x1db4e8 - g_ps2RecompiledFunctionTable[224569] = bhEne13_Damage_0x1db480; // 0x1db4ec - g_ps2RecompiledFunctionTable[224570] = bhEne13_Damage_0x1db480; // 0x1db4f0 - g_ps2RecompiledFunctionTable[224571] = bhEne13_Damage_0x1db480; // 0x1db4f4 - g_ps2RecompiledFunctionTable[224572] = bhEne13_Damage_0x1db480; // 0x1db4f8 - g_ps2RecompiledFunctionTable[224573] = bhEne13_Damage_0x1db480; // 0x1db4fc - g_ps2RecompiledFunctionTable[224574] = bhEne13_Damage_0x1db480; // 0x1db500 - g_ps2RecompiledFunctionTable[224575] = bhEne13_Damage_0x1db480; // 0x1db504 - g_ps2RecompiledFunctionTable[224576] = bhEne13_Damage_0x1db480; // 0x1db508 - g_ps2RecompiledFunctionTable[224577] = bhEne13_Damage_0x1db480; // 0x1db50c - g_ps2RecompiledFunctionTable[224578] = bhEne13_Damage_0x1db480; // 0x1db510 - g_ps2RecompiledFunctionTable[224579] = bhEne13_Damage_0x1db480; // 0x1db514 - g_ps2RecompiledFunctionTable[224580] = bhEne13_Damage_0x1db480; // 0x1db518 - g_ps2RecompiledFunctionTable[224581] = bhEne13_Damage_0x1db480; // 0x1db51c - g_ps2RecompiledFunctionTable[224582] = bhEne13_Damage_0x1db480; // 0x1db520 - g_ps2RecompiledFunctionTable[224583] = bhEne13_Damage_0x1db480; // 0x1db524 - g_ps2RecompiledFunctionTable[224584] = bhEne13_Damage_0x1db480; // 0x1db528 - g_ps2RecompiledFunctionTable[224585] = bhEne13_Damage_0x1db480; // 0x1db52c - g_ps2RecompiledFunctionTable[224586] = bhEne13_Damage_0x1db480; // 0x1db530 - g_ps2RecompiledFunctionTable[224587] = bhEne13_Damage_0x1db480; // 0x1db534 - g_ps2RecompiledFunctionTable[224588] = bhEne13_Damage_0x1db480; // 0x1db538 - g_ps2RecompiledFunctionTable[224589] = bhEne13_Damage_0x1db480; // 0x1db53c - g_ps2RecompiledFunctionTable[224590] = bhEne13_Damage_0x1db480; // 0x1db540 - g_ps2RecompiledFunctionTable[224591] = bhEne13_Damage_0x1db480; // 0x1db544 - g_ps2RecompiledFunctionTable[224592] = bhEne13_Damage_0x1db480; // 0x1db548 - g_ps2RecompiledFunctionTable[224593] = bhEne13_Damage_0x1db480; // 0x1db54c - g_ps2RecompiledFunctionTable[224594] = bhEne13_Damage_0x1db480; // 0x1db550 - g_ps2RecompiledFunctionTable[224595] = bhEne13_Damage_0x1db480; // 0x1db554 - g_ps2RecompiledFunctionTable[224596] = bhEne13_Damage_0x1db480; // 0x1db558 - g_ps2RecompiledFunctionTable[224597] = bhEne13_Damage_0x1db480; // 0x1db55c - g_ps2RecompiledFunctionTable[224598] = bhEne13_Damage_0x1db480; // 0x1db560 - g_ps2RecompiledFunctionTable[224599] = bhEne13_Damage_0x1db480; // 0x1db564 - g_ps2RecompiledFunctionTable[224600] = bhEne13_Damage_0x1db480; // 0x1db568 - g_ps2RecompiledFunctionTable[224601] = bhEne13_Damage_0x1db480; // 0x1db56c - g_ps2RecompiledFunctionTable[224602] = bhEne13_Damage_0x1db480; // 0x1db570 - g_ps2RecompiledFunctionTable[224603] = bhEne13_Damage_0x1db480; // 0x1db574 - g_ps2RecompiledFunctionTable[224604] = bhEne13_Damage_0x1db480; // 0x1db578 - g_ps2RecompiledFunctionTable[224605] = bhEne13_Damage_0x1db480; // 0x1db57c - g_ps2RecompiledFunctionTable[224606] = bhEne13_Damage_0x1db480; // 0x1db580 - g_ps2RecompiledFunctionTable[224607] = bhEne13_Damage_0x1db480; // 0x1db584 - g_ps2RecompiledFunctionTable[224608] = bhEne13_Damage_0x1db480; // 0x1db588 - g_ps2RecompiledFunctionTable[224609] = bhEne13_Damage_0x1db480; // 0x1db58c - g_ps2RecompiledFunctionTable[224610] = bhEne13_Damage_0x1db480; // 0x1db590 - g_ps2RecompiledFunctionTable[224611] = bhEne13_Damage_0x1db480; // 0x1db594 - g_ps2RecompiledFunctionTable[224612] = bhEne13_Damage_0x1db480; // 0x1db598 - g_ps2RecompiledFunctionTable[224613] = bhEne13_Damage_0x1db480; // 0x1db59c - g_ps2RecompiledFunctionTable[224614] = bhEne13_Damage_0x1db480; // 0x1db5a0 - g_ps2RecompiledFunctionTable[224615] = bhEne13_Damage_0x1db480; // 0x1db5a4 - g_ps2RecompiledFunctionTable[224616] = bhEne13_Damage_0x1db480; // 0x1db5a8 - g_ps2RecompiledFunctionTable[224617] = bhEne13_Damage_0x1db480; // 0x1db5ac - g_ps2RecompiledFunctionTable[224618] = bhEne13_Damage_0x1db480; // 0x1db5b0 - g_ps2RecompiledFunctionTable[224619] = bhEne13_Damage_0x1db480; // 0x1db5b4 - g_ps2RecompiledFunctionTable[224620] = bhEne13_Damage_0x1db480; // 0x1db5b8 - g_ps2RecompiledFunctionTable[224621] = bhEne13_Damage_0x1db480; // 0x1db5bc - g_ps2RecompiledFunctionTable[224622] = bhEne13_Damage_0x1db480; // 0x1db5c0 - g_ps2RecompiledFunctionTable[224623] = bhEne13_Damage_0x1db480; // 0x1db5c4 - g_ps2RecompiledFunctionTable[224624] = bhEne13_Damage_0x1db480; // 0x1db5c8 - g_ps2RecompiledFunctionTable[224625] = bhEne13_Damage_0x1db480; // 0x1db5cc - g_ps2RecompiledFunctionTable[224626] = bhEne13_Damage_0x1db480; // 0x1db5d0 - g_ps2RecompiledFunctionTable[224627] = bhEne13_Damage_0x1db480; // 0x1db5d4 - g_ps2RecompiledFunctionTable[224628] = bhEne13_Damage_0x1db480; // 0x1db5d8 - g_ps2RecompiledFunctionTable[224629] = bhEne13_Damage_0x1db480; // 0x1db5dc - g_ps2RecompiledFunctionTable[224630] = bhEne13_Damage_0x1db480; // 0x1db5e0 - g_ps2RecompiledFunctionTable[224631] = bhEne13_Damage_0x1db480; // 0x1db5e4 - g_ps2RecompiledFunctionTable[224632] = bhEne13_Damage_0x1db480; // 0x1db5e8 - g_ps2RecompiledFunctionTable[224633] = bhEne13_Damage_0x1db480; // 0x1db5ec - g_ps2RecompiledFunctionTable[224634] = bhEne13_Damage_0x1db480; // 0x1db5f0 - g_ps2RecompiledFunctionTable[224635] = bhEne13_Damage_0x1db480; // 0x1db5f4 - g_ps2RecompiledFunctionTable[224636] = bhEne13_Damage_0x1db480; // 0x1db5f8 - g_ps2RecompiledFunctionTable[224637] = bhEne13_Damage_0x1db480; // 0x1db5fc - g_ps2RecompiledFunctionTable[224638] = bhEne13_Damage_0x1db480; // 0x1db600 - g_ps2RecompiledFunctionTable[224639] = bhEne13_Damage_0x1db480; // 0x1db604 - g_ps2RecompiledFunctionTable[224640] = bhEne13_Damage_0x1db480; // 0x1db608 - g_ps2RecompiledFunctionTable[224641] = bhEne13_Damage_0x1db480; // 0x1db60c - g_ps2RecompiledFunctionTable[224642] = bhEne13_Damage_0x1db480; // 0x1db610 - g_ps2RecompiledFunctionTable[224643] = bhEne13_Damage_0x1db480; // 0x1db614 - g_ps2RecompiledFunctionTable[224644] = bhEne13_Damage_0x1db480; // 0x1db618 - g_ps2RecompiledFunctionTable[224645] = bhEne13_Damage_0x1db480; // 0x1db61c - g_ps2RecompiledFunctionTable[224646] = bhEne13_Damage_0x1db480; // 0x1db620 - g_ps2RecompiledFunctionTable[224647] = bhEne13_Damage_0x1db480; // 0x1db624 - g_ps2RecompiledFunctionTable[224648] = bhEne13_Damage_0x1db480; // 0x1db628 - g_ps2RecompiledFunctionTable[224649] = bhEne13_Damage_0x1db480; // 0x1db62c - g_ps2RecompiledFunctionTable[224650] = bhEne13_Damage_0x1db480; // 0x1db630 - g_ps2RecompiledFunctionTable[224654] = bhEne13_DG00_0x1db640; // 0x1db640 - g_ps2RecompiledFunctionTable[224706] = bhEne13_Die_0x1db710; // 0x1db710 - g_ps2RecompiledFunctionTable[224731] = bhEne13_Die_0x1db710; // 0x1db774 - g_ps2RecompiledFunctionTable[224754] = bhEne13_Die_0x1db710; // 0x1db7d0 - g_ps2RecompiledFunctionTable[224802] = bhEne13_Die_0x1db710; // 0x1db890 - g_ps2RecompiledFunctionTable[224806] = bhEne13_InitDamage_0x1db8a0; // 0x1db8a0 - g_ps2RecompiledFunctionTable[224824] = bhEne13_InitDamage_0x1db8a0; // 0x1db8e8 - g_ps2RecompiledFunctionTable[224838] = bhEne13_InitDamage_0x1db8a0; // 0x1db920 - g_ps2RecompiledFunctionTable[224867] = bhEne13_InitDamage_0x1db8a0; // 0x1db994 - g_ps2RecompiledFunctionTable[224904] = bhEne13_InitDamage_0x1db8a0; // 0x1dba28 - g_ps2RecompiledFunctionTable[224994] = bhEne13_Finish_0x1dbb90; // 0x1dbb90 - g_ps2RecompiledFunctionTable[225005] = bhEne13_Finish_0x1dbb90; // 0x1dbbbc - g_ps2RecompiledFunctionTable[225014] = bhEne13_Finish_0x1dbb90; // 0x1dbbe0 - g_ps2RecompiledFunctionTable[225024] = bhEne13_Finish_0x1dbb90; // 0x1dbc08 - g_ps2RecompiledFunctionTable[225038] = bhEne13_Finish_0x1dbb90; // 0x1dbc40 - g_ps2RecompiledFunctionTable[225079] = bhEne13_Finish_0x1dbb90; // 0x1dbce4 - g_ps2RecompiledFunctionTable[225094] = bhEne13_ScaleModel_0x1dbd20; // 0x1dbd20 - g_ps2RecompiledFunctionTable[225103] = bhEne13_ScaleModel_0x1dbd20; // 0x1dbd44 - g_ps2RecompiledFunctionTable[225130] = bhEne13_StoreObject_0x1dbdb0; // 0x1dbdb0 - g_ps2RecompiledFunctionTable[225153] = bhEne13_StoreObject_0x1dbdb0; // 0x1dbe0c - g_ps2RecompiledFunctionTable[225167] = bhEne13_StoreObject_0x1dbdb0; // 0x1dbe44 - g_ps2RecompiledFunctionTable[225174] = bhEne13_StoreObject_0x1dbdb0; // 0x1dbe60 - g_ps2RecompiledFunctionTable[225214] = bhEne13_RestoreObject_0x1dbf00; // 0x1dbf00 - g_ps2RecompiledFunctionTable[225226] = bhEne13_RestoreObject_0x1dbf00; // 0x1dbf30 - g_ps2RecompiledFunctionTable[225242] = bhEne13_RestoreObject_0x1dbf00; // 0x1dbf70 - g_ps2RecompiledFunctionTable[225270] = bhEne13_PutAttacker_0x1dbfe0; // 0x1dbfe0 - g_ps2RecompiledFunctionTable[225300] = bhEne13_PutAttacker_0x1dbfe0; // 0x1dc058 - g_ps2RecompiledFunctionTable[225313] = bhEne13_PutAttacker_0x1dbfe0; // 0x1dc08c - g_ps2RecompiledFunctionTable[225316] = bhEne13_PutAttacker_0x1dbfe0; // 0x1dc098 - g_ps2RecompiledFunctionTable[225324] = bhEne13_PutAttacker_0x1dbfe0; // 0x1dc0b8 - g_ps2RecompiledFunctionTable[225350] = bhEne13_PutAttacker_0x1dbfe0; // 0x1dc120 - g_ps2RecompiledFunctionTable[225366] = bhEne13_Tentacle_0x1dc160; // 0x1dc160 - g_ps2RecompiledFunctionTable[225386] = bhEne13_GetHatchNo_0x1dc1b0; // 0x1dc1b0 - g_ps2RecompiledFunctionTable[225390] = bhEne13_GetTentaNo_0x1dc1c0; // 0x1dc1c0 - g_ps2RecompiledFunctionTable[225394] = bhEne13_GetChild_0x1dc1d0; // 0x1dc1d0 - g_ps2RecompiledFunctionTable[225402] = bhEne13_CameraControl_0x1dc1f0; // 0x1dc1f0 - g_ps2RecompiledFunctionTable[225419] = bhEne13_CameraControl_0x1dc1f0; // 0x1dc234 - g_ps2RecompiledFunctionTable[225436] = bhEne13_CameraControl_0x1dc1f0; // 0x1dc278 - g_ps2RecompiledFunctionTable[225453] = bhEne13_CameraControl_0x1dc1f0; // 0x1dc2bc - g_ps2RecompiledFunctionTable[225479] = bhEne13_CameraControl_0x1dc1f0; // 0x1dc324 - g_ps2RecompiledFunctionTable[225496] = bhEne13_CameraControl_0x1dc1f0; // 0x1dc368 - g_ps2RecompiledFunctionTable[225513] = bhEne13_CameraControl_0x1dc1f0; // 0x1dc3ac - g_ps2RecompiledFunctionTable[225546] = bhEne13_SetCamera_0x1dc430; // 0x1dc430 - g_ps2RecompiledFunctionTable[225550] = bhEne13_SelectTentacle_0x1dc440; // 0x1dc440 - g_ps2RecompiledFunctionTable[225563] = bhEne13_SelectTentacle_0x1dc440; // 0x1dc474 - g_ps2RecompiledFunctionTable[225568] = bhEne13_SelectTentacle_0x1dc440; // 0x1dc488 - g_ps2RecompiledFunctionTable[225602] = bhEne13_PlayerControl_0x1dc510; // 0x1dc510 - g_ps2RecompiledFunctionTable[225713] = bhEne13_PlayerControl_0x1dc510; // 0x1dc6cc - g_ps2RecompiledFunctionTable[225716] = bhEne13_PlayerControl_0x1dc510; // 0x1dc6d8 - g_ps2RecompiledFunctionTable[225731] = bhEne13_PlayerControl_0x1dc510; // 0x1dc714 - g_ps2RecompiledFunctionTable[225744] = bhEne13_PlayerControl_0x1dc510; // 0x1dc748 - g_ps2RecompiledFunctionTable[225847] = bhEne13_PlayerControl_0x1dc510; // 0x1dc8e4 - g_ps2RecompiledFunctionTable[225977] = bhEne13_PlayerControl_0x1dc510; // 0x1dcaec - g_ps2RecompiledFunctionTable[225980] = bhEne13_PlayerControl_0x1dc510; // 0x1dcaf8 - g_ps2RecompiledFunctionTable[225995] = bhEne13_PlayerControl_0x1dc510; // 0x1dcb34 - g_ps2RecompiledFunctionTable[226008] = bhEne13_PlayerControl_0x1dc510; // 0x1dcb68 - g_ps2RecompiledFunctionTable[226110] = bhEne13B_0x1dcd00; // 0x1dcd00 - g_ps2RecompiledFunctionTable[226111] = bhEne13B_0x1dcd00; // 0x1dcd04 - g_ps2RecompiledFunctionTable[226112] = bhEne13B_0x1dcd00; // 0x1dcd08 - g_ps2RecompiledFunctionTable[226113] = bhEne13B_0x1dcd00; // 0x1dcd0c - g_ps2RecompiledFunctionTable[226114] = bhEne13B_0x1dcd00; // 0x1dcd10 - g_ps2RecompiledFunctionTable[226115] = bhEne13B_0x1dcd00; // 0x1dcd14 - g_ps2RecompiledFunctionTable[226116] = bhEne13B_0x1dcd00; // 0x1dcd18 - g_ps2RecompiledFunctionTable[226117] = bhEne13B_0x1dcd00; // 0x1dcd1c - g_ps2RecompiledFunctionTable[226118] = bhEne13B_0x1dcd00; // 0x1dcd20 - g_ps2RecompiledFunctionTable[226119] = bhEne13B_0x1dcd00; // 0x1dcd24 - g_ps2RecompiledFunctionTable[226120] = bhEne13B_0x1dcd00; // 0x1dcd28 - g_ps2RecompiledFunctionTable[226121] = bhEne13B_0x1dcd00; // 0x1dcd2c - g_ps2RecompiledFunctionTable[226122] = bhEne13B_0x1dcd00; // 0x1dcd30 - g_ps2RecompiledFunctionTable[226123] = bhEne13B_0x1dcd00; // 0x1dcd34 - g_ps2RecompiledFunctionTable[226124] = bhEne13B_0x1dcd00; // 0x1dcd38 - g_ps2RecompiledFunctionTable[226125] = bhEne13B_0x1dcd00; // 0x1dcd3c - g_ps2RecompiledFunctionTable[226126] = bhEne13B_0x1dcd00; // 0x1dcd40 - g_ps2RecompiledFunctionTable[226127] = bhEne13B_0x1dcd00; // 0x1dcd44 - g_ps2RecompiledFunctionTable[226128] = bhEne13B_0x1dcd00; // 0x1dcd48 - g_ps2RecompiledFunctionTable[226129] = bhEne13B_0x1dcd00; // 0x1dcd4c - g_ps2RecompiledFunctionTable[226130] = bhEne13B_0x1dcd00; // 0x1dcd50 - g_ps2RecompiledFunctionTable[226131] = bhEne13B_0x1dcd00; // 0x1dcd54 - g_ps2RecompiledFunctionTable[226132] = bhEne13B_0x1dcd00; // 0x1dcd58 - g_ps2RecompiledFunctionTable[226133] = bhEne13B_0x1dcd00; // 0x1dcd5c - g_ps2RecompiledFunctionTable[226134] = bhEne13B_0x1dcd00; // 0x1dcd60 - g_ps2RecompiledFunctionTable[226135] = bhEne13B_0x1dcd00; // 0x1dcd64 - g_ps2RecompiledFunctionTable[226136] = bhEne13B_0x1dcd00; // 0x1dcd68 - g_ps2RecompiledFunctionTable[226137] = bhEne13B_0x1dcd00; // 0x1dcd6c - g_ps2RecompiledFunctionTable[226138] = bhEne13B_0x1dcd00; // 0x1dcd70 - g_ps2RecompiledFunctionTable[226139] = bhEne13B_0x1dcd00; // 0x1dcd74 - g_ps2RecompiledFunctionTable[226140] = bhEne13B_0x1dcd00; // 0x1dcd78 - g_ps2RecompiledFunctionTable[226141] = bhEne13B_0x1dcd00; // 0x1dcd7c - g_ps2RecompiledFunctionTable[226142] = bhEne13B_0x1dcd00; // 0x1dcd80 - g_ps2RecompiledFunctionTable[226143] = bhEne13B_0x1dcd00; // 0x1dcd84 - g_ps2RecompiledFunctionTable[226144] = bhEne13B_0x1dcd00; // 0x1dcd88 - g_ps2RecompiledFunctionTable[226145] = bhEne13B_0x1dcd00; // 0x1dcd8c - g_ps2RecompiledFunctionTable[226146] = bhEne13B_0x1dcd00; // 0x1dcd90 - g_ps2RecompiledFunctionTable[226147] = bhEne13B_0x1dcd00; // 0x1dcd94 - g_ps2RecompiledFunctionTable[226148] = bhEne13B_0x1dcd00; // 0x1dcd98 - g_ps2RecompiledFunctionTable[226149] = bhEne13B_0x1dcd00; // 0x1dcd9c - g_ps2RecompiledFunctionTable[226150] = bhEne13B_0x1dcd00; // 0x1dcda0 - g_ps2RecompiledFunctionTable[226151] = bhEne13B_0x1dcd00; // 0x1dcda4 - g_ps2RecompiledFunctionTable[226152] = bhEne13B_0x1dcd00; // 0x1dcda8 - g_ps2RecompiledFunctionTable[226153] = bhEne13B_0x1dcd00; // 0x1dcdac - g_ps2RecompiledFunctionTable[226154] = bhEne13B_0x1dcd00; // 0x1dcdb0 - g_ps2RecompiledFunctionTable[226155] = bhEne13B_0x1dcd00; // 0x1dcdb4 - g_ps2RecompiledFunctionTable[226156] = bhEne13B_0x1dcd00; // 0x1dcdb8 - g_ps2RecompiledFunctionTable[226157] = bhEne13B_0x1dcd00; // 0x1dcdbc - g_ps2RecompiledFunctionTable[226158] = bhEne13B_0x1dcd00; // 0x1dcdc0 - g_ps2RecompiledFunctionTable[226159] = bhEne13B_0x1dcd00; // 0x1dcdc4 - g_ps2RecompiledFunctionTable[226160] = bhEne13B_0x1dcd00; // 0x1dcdc8 - g_ps2RecompiledFunctionTable[226161] = bhEne13B_0x1dcd00; // 0x1dcdcc - g_ps2RecompiledFunctionTable[226162] = bhEne13B_0x1dcd00; // 0x1dcdd0 - g_ps2RecompiledFunctionTable[226163] = bhEne13B_0x1dcd00; // 0x1dcdd4 - g_ps2RecompiledFunctionTable[226164] = bhEne13B_0x1dcd00; // 0x1dcdd8 - g_ps2RecompiledFunctionTable[226165] = bhEne13B_0x1dcd00; // 0x1dcddc - g_ps2RecompiledFunctionTable[226166] = bhEne13B_0x1dcd00; // 0x1dcde0 - g_ps2RecompiledFunctionTable[226167] = bhEne13B_0x1dcd00; // 0x1dcde4 - g_ps2RecompiledFunctionTable[226168] = bhEne13B_0x1dcd00; // 0x1dcde8 - g_ps2RecompiledFunctionTable[226169] = bhEne13B_0x1dcd00; // 0x1dcdec - g_ps2RecompiledFunctionTable[226170] = bhEne13B_0x1dcd00; // 0x1dcdf0 - g_ps2RecompiledFunctionTable[226171] = bhEne13B_0x1dcd00; // 0x1dcdf4 - g_ps2RecompiledFunctionTable[226172] = bhEne13B_0x1dcd00; // 0x1dcdf8 - g_ps2RecompiledFunctionTable[226173] = bhEne13B_0x1dcd00; // 0x1dcdfc - g_ps2RecompiledFunctionTable[226174] = bhEne13B_0x1dcd00; // 0x1dce00 - g_ps2RecompiledFunctionTable[226175] = bhEne13B_0x1dcd00; // 0x1dce04 - g_ps2RecompiledFunctionTable[226176] = bhEne13B_0x1dcd00; // 0x1dce08 - g_ps2RecompiledFunctionTable[226177] = bhEne13B_0x1dcd00; // 0x1dce0c - g_ps2RecompiledFunctionTable[226178] = bhEne13B_0x1dcd00; // 0x1dce10 - g_ps2RecompiledFunctionTable[226179] = bhEne13B_0x1dcd00; // 0x1dce14 - g_ps2RecompiledFunctionTable[226182] = bhEne13B_Init_0x1dce20; // 0x1dce20 - g_ps2RecompiledFunctionTable[226225] = bhEne13B_Init_0x1dce20; // 0x1dcecc - g_ps2RecompiledFunctionTable[226227] = bhEne13B_Init_0x1dce20; // 0x1dced4 - g_ps2RecompiledFunctionTable[226233] = bhEne13B_Init_0x1dce20; // 0x1dceec - g_ps2RecompiledFunctionTable[226240] = bhEne13B_Init_0x1dce20; // 0x1dcf08 - g_ps2RecompiledFunctionTable[226322] = bhEne13B_Move_0x1dd050; // 0x1dd050 - g_ps2RecompiledFunctionTable[226323] = bhEne13B_Move_0x1dd050; // 0x1dd054 - g_ps2RecompiledFunctionTable[226324] = bhEne13B_Move_0x1dd050; // 0x1dd058 - g_ps2RecompiledFunctionTable[226325] = bhEne13B_Move_0x1dd050; // 0x1dd05c - g_ps2RecompiledFunctionTable[226326] = bhEne13B_Move_0x1dd050; // 0x1dd060 - g_ps2RecompiledFunctionTable[226327] = bhEne13B_Move_0x1dd050; // 0x1dd064 - g_ps2RecompiledFunctionTable[226328] = bhEne13B_Move_0x1dd050; // 0x1dd068 - g_ps2RecompiledFunctionTable[226329] = bhEne13B_Move_0x1dd050; // 0x1dd06c - g_ps2RecompiledFunctionTable[226330] = bhEne13B_MV00_0x1dd070; // 0x1dd070 - g_ps2RecompiledFunctionTable[226334] = bhEne13B_MV01_0x1dd080; // 0x1dd080 - g_ps2RecompiledFunctionTable[226376] = bhEne13B_MV01_0x1dd080; // 0x1dd128 - g_ps2RecompiledFunctionTable[226407] = bhEne13B_MV01_0x1dd080; // 0x1dd1a4 - g_ps2RecompiledFunctionTable[226414] = bhEne13B_MV01_0x1dd080; // 0x1dd1c0 - g_ps2RecompiledFunctionTable[226443] = bhEne13B_MV01_0x1dd080; // 0x1dd234 - g_ps2RecompiledFunctionTable[226596] = bhEne13B_MV01_0x1dd080; // 0x1dd498 - g_ps2RecompiledFunctionTable[226615] = bhEne13B_MV01_0x1dd080; // 0x1dd4e4 - g_ps2RecompiledFunctionTable[226663] = bhEne13B_MV01_0x1dd080; // 0x1dd5a4 - g_ps2RecompiledFunctionTable[226674] = bhEne13B_MV01_0x1dd080; // 0x1dd5d0 - g_ps2RecompiledFunctionTable[226742] = bhEne13B_MV01_0x1dd080; // 0x1dd6e0 - g_ps2RecompiledFunctionTable[226751] = bhEne13B_MV01_0x1dd080; // 0x1dd704 - g_ps2RecompiledFunctionTable[226764] = bhEne13B_MV01_0x1dd080; // 0x1dd738 - g_ps2RecompiledFunctionTable[226794] = bhEne13B_MV01_0x1dd080; // 0x1dd7b0 - g_ps2RecompiledFunctionTable[226803] = bhEne13B_MV01_0x1dd080; // 0x1dd7d4 - g_ps2RecompiledFunctionTable[226816] = bhEne13B_MV01_0x1dd080; // 0x1dd808 - g_ps2RecompiledFunctionTable[226828] = bhEne13B_MV01_0x1dd080; // 0x1dd838 - g_ps2RecompiledFunctionTable[226833] = bhEne13B_MV01_0x1dd080; // 0x1dd84c - g_ps2RecompiledFunctionTable[226836] = bhEne13B_MV01_0x1dd080; // 0x1dd858 - g_ps2RecompiledFunctionTable[226845] = bhEne13B_MV01_0x1dd080; // 0x1dd87c - g_ps2RecompiledFunctionTable[226886] = bhEne13B_Nage_0x1dd920; // 0x1dd920 - g_ps2RecompiledFunctionTable[226890] = bhEne13B_Damage_0x1dd930; // 0x1dd930 - g_ps2RecompiledFunctionTable[226894] = bhEne13B_Die_0x1dd940; // 0x1dd940 - g_ps2RecompiledFunctionTable[226904] = bhEne13B_Die_0x1dd940; // 0x1dd968 - g_ps2RecompiledFunctionTable[226922] = bhEne13B_SetHittab_0x1dd9b0; // 0x1dd9b0 - g_ps2RecompiledFunctionTable[226946] = bhEne13B_SetHittab_0x1dd9b0; // 0x1dda10 - g_ps2RecompiledFunctionTable[226976] = bhEne13B_SetHittab_0x1dd9b0; // 0x1dda88 - g_ps2RecompiledFunctionTable[226994] = bhEne14_0x1ddad0; // 0x1ddad0 - g_ps2RecompiledFunctionTable[226995] = bhEne14_0x1ddad0; // 0x1ddad4 - g_ps2RecompiledFunctionTable[226996] = bhEne14_0x1ddad0; // 0x1ddad8 - g_ps2RecompiledFunctionTable[226997] = bhEne14_0x1ddad0; // 0x1ddadc - g_ps2RecompiledFunctionTable[226998] = bhEne14_0x1ddad0; // 0x1ddae0 - g_ps2RecompiledFunctionTable[226999] = bhEne14_0x1ddad0; // 0x1ddae4 - g_ps2RecompiledFunctionTable[227000] = bhEne14_0x1ddad0; // 0x1ddae8 - g_ps2RecompiledFunctionTable[227001] = bhEne14_0x1ddad0; // 0x1ddaec - g_ps2RecompiledFunctionTable[227002] = bhEne14_0x1ddad0; // 0x1ddaf0 - g_ps2RecompiledFunctionTable[227003] = bhEne14_0x1ddad0; // 0x1ddaf4 - g_ps2RecompiledFunctionTable[227004] = bhEne14_0x1ddad0; // 0x1ddaf8 - g_ps2RecompiledFunctionTable[227005] = bhEne14_0x1ddad0; // 0x1ddafc - g_ps2RecompiledFunctionTable[227006] = bhEne14_0x1ddad0; // 0x1ddb00 - g_ps2RecompiledFunctionTable[227007] = bhEne14_0x1ddad0; // 0x1ddb04 - g_ps2RecompiledFunctionTable[227008] = bhEne14_0x1ddad0; // 0x1ddb08 - g_ps2RecompiledFunctionTable[227009] = bhEne14_0x1ddad0; // 0x1ddb0c - g_ps2RecompiledFunctionTable[227010] = bhEne14_0x1ddad0; // 0x1ddb10 - g_ps2RecompiledFunctionTable[227011] = bhEne14_0x1ddad0; // 0x1ddb14 - g_ps2RecompiledFunctionTable[227012] = bhEne14_0x1ddad0; // 0x1ddb18 - g_ps2RecompiledFunctionTable[227013] = bhEne14_0x1ddad0; // 0x1ddb1c - g_ps2RecompiledFunctionTable[227014] = bhEne14_0x1ddad0; // 0x1ddb20 - g_ps2RecompiledFunctionTable[227015] = bhEne14_0x1ddad0; // 0x1ddb24 - g_ps2RecompiledFunctionTable[227016] = bhEne14_0x1ddad0; // 0x1ddb28 - g_ps2RecompiledFunctionTable[227017] = bhEne14_0x1ddad0; // 0x1ddb2c - g_ps2RecompiledFunctionTable[227018] = bhEne14_0x1ddad0; // 0x1ddb30 - g_ps2RecompiledFunctionTable[227019] = bhEne14_0x1ddad0; // 0x1ddb34 - g_ps2RecompiledFunctionTable[227020] = bhEne14_0x1ddad0; // 0x1ddb38 - g_ps2RecompiledFunctionTable[227021] = bhEne14_0x1ddad0; // 0x1ddb3c - g_ps2RecompiledFunctionTable[227022] = bhEne14_0x1ddad0; // 0x1ddb40 - g_ps2RecompiledFunctionTable[227023] = bhEne14_0x1ddad0; // 0x1ddb44 - g_ps2RecompiledFunctionTable[227024] = bhEne14_0x1ddad0; // 0x1ddb48 - g_ps2RecompiledFunctionTable[227025] = bhEne14_0x1ddad0; // 0x1ddb4c - g_ps2RecompiledFunctionTable[227026] = bhEne14_0x1ddad0; // 0x1ddb50 - g_ps2RecompiledFunctionTable[227027] = bhEne14_0x1ddad0; // 0x1ddb54 - g_ps2RecompiledFunctionTable[227028] = bhEne14_0x1ddad0; // 0x1ddb58 - g_ps2RecompiledFunctionTable[227029] = bhEne14_0x1ddad0; // 0x1ddb5c - g_ps2RecompiledFunctionTable[227030] = bhEne14_0x1ddad0; // 0x1ddb60 - g_ps2RecompiledFunctionTable[227031] = bhEne14_0x1ddad0; // 0x1ddb64 - g_ps2RecompiledFunctionTable[227032] = bhEne14_0x1ddad0; // 0x1ddb68 - g_ps2RecompiledFunctionTable[227033] = bhEne14_0x1ddad0; // 0x1ddb6c - g_ps2RecompiledFunctionTable[227034] = bhEne14_0x1ddad0; // 0x1ddb70 - g_ps2RecompiledFunctionTable[227035] = bhEne14_0x1ddad0; // 0x1ddb74 - g_ps2RecompiledFunctionTable[227036] = bhEne14_0x1ddad0; // 0x1ddb78 - g_ps2RecompiledFunctionTable[227037] = bhEne14_0x1ddad0; // 0x1ddb7c - g_ps2RecompiledFunctionTable[227038] = bhEne14_0x1ddad0; // 0x1ddb80 - g_ps2RecompiledFunctionTable[227039] = bhEne14_0x1ddad0; // 0x1ddb84 - g_ps2RecompiledFunctionTable[227040] = bhEne14_0x1ddad0; // 0x1ddb88 - g_ps2RecompiledFunctionTable[227041] = bhEne14_0x1ddad0; // 0x1ddb8c - g_ps2RecompiledFunctionTable[227042] = bhEne14_0x1ddad0; // 0x1ddb90 - g_ps2RecompiledFunctionTable[227043] = bhEne14_0x1ddad0; // 0x1ddb94 - g_ps2RecompiledFunctionTable[227044] = bhEne14_0x1ddad0; // 0x1ddb98 - g_ps2RecompiledFunctionTable[227045] = bhEne14_0x1ddad0; // 0x1ddb9c - g_ps2RecompiledFunctionTable[227046] = bhEne14_0x1ddad0; // 0x1ddba0 - g_ps2RecompiledFunctionTable[227047] = bhEne14_0x1ddad0; // 0x1ddba4 - g_ps2RecompiledFunctionTable[227048] = bhEne14_0x1ddad0; // 0x1ddba8 - g_ps2RecompiledFunctionTable[227049] = bhEne14_0x1ddad0; // 0x1ddbac - g_ps2RecompiledFunctionTable[227050] = bhEne14_0x1ddad0; // 0x1ddbb0 - g_ps2RecompiledFunctionTable[227051] = bhEne14_0x1ddad0; // 0x1ddbb4 - g_ps2RecompiledFunctionTable[227052] = bhEne14_0x1ddad0; // 0x1ddbb8 - g_ps2RecompiledFunctionTable[227053] = bhEne14_0x1ddad0; // 0x1ddbbc - g_ps2RecompiledFunctionTable[227054] = bhEne14_0x1ddad0; // 0x1ddbc0 - g_ps2RecompiledFunctionTable[227055] = bhEne14_0x1ddad0; // 0x1ddbc4 - g_ps2RecompiledFunctionTable[227056] = bhEne14_0x1ddad0; // 0x1ddbc8 - g_ps2RecompiledFunctionTable[227057] = bhEne14_0x1ddad0; // 0x1ddbcc - g_ps2RecompiledFunctionTable[227058] = bhEne14_0x1ddad0; // 0x1ddbd0 - g_ps2RecompiledFunctionTable[227059] = bhEne14_0x1ddad0; // 0x1ddbd4 - g_ps2RecompiledFunctionTable[227060] = bhEne14_0x1ddad0; // 0x1ddbd8 - g_ps2RecompiledFunctionTable[227061] = bhEne14_0x1ddad0; // 0x1ddbdc - g_ps2RecompiledFunctionTable[227062] = bhEne14_0x1ddad0; // 0x1ddbe0 - g_ps2RecompiledFunctionTable[227063] = bhEne14_0x1ddad0; // 0x1ddbe4 - g_ps2RecompiledFunctionTable[227064] = bhEne14_0x1ddad0; // 0x1ddbe8 - g_ps2RecompiledFunctionTable[227065] = bhEne14_0x1ddad0; // 0x1ddbec - g_ps2RecompiledFunctionTable[227066] = bhEne14_0x1ddad0; // 0x1ddbf0 - g_ps2RecompiledFunctionTable[227067] = bhEne14_0x1ddad0; // 0x1ddbf4 - g_ps2RecompiledFunctionTable[227068] = bhEne14_0x1ddad0; // 0x1ddbf8 - g_ps2RecompiledFunctionTable[227069] = bhEne14_0x1ddad0; // 0x1ddbfc - g_ps2RecompiledFunctionTable[227070] = bhEne14_0x1ddad0; // 0x1ddc00 - g_ps2RecompiledFunctionTable[227071] = bhEne14_0x1ddad0; // 0x1ddc04 - g_ps2RecompiledFunctionTable[227072] = bhEne14_0x1ddad0; // 0x1ddc08 - g_ps2RecompiledFunctionTable[227073] = bhEne14_0x1ddad0; // 0x1ddc0c - g_ps2RecompiledFunctionTable[227074] = bhEne14_0x1ddad0; // 0x1ddc10 - g_ps2RecompiledFunctionTable[227075] = bhEne14_0x1ddad0; // 0x1ddc14 - g_ps2RecompiledFunctionTable[227076] = bhEne14_0x1ddad0; // 0x1ddc18 - g_ps2RecompiledFunctionTable[227077] = bhEne14_0x1ddad0; // 0x1ddc1c - g_ps2RecompiledFunctionTable[227078] = bhEne14_0x1ddad0; // 0x1ddc20 - g_ps2RecompiledFunctionTable[227079] = bhEne14_0x1ddad0; // 0x1ddc24 - g_ps2RecompiledFunctionTable[227080] = bhEne14_0x1ddad0; // 0x1ddc28 - g_ps2RecompiledFunctionTable[227081] = bhEne14_0x1ddad0; // 0x1ddc2c - g_ps2RecompiledFunctionTable[227082] = bhEne14_Init_0x1ddc30; // 0x1ddc30 - g_ps2RecompiledFunctionTable[227166] = bhEne14_Init_0x1ddc30; // 0x1ddd80 - g_ps2RecompiledFunctionTable[227184] = bhEne14_Init_0x1ddc30; // 0x1dddc8 - g_ps2RecompiledFunctionTable[227230] = bhEne14_Init_0x1ddc30; // 0x1dde80 - g_ps2RecompiledFunctionTable[227246] = bhEne14_Init_0x1ddc30; // 0x1ddec0 - g_ps2RecompiledFunctionTable[227250] = bhEne14_Brain_0x1dded0; // 0x1dded0 - g_ps2RecompiledFunctionTable[227251] = bhEne14_Brain_0x1dded0; // 0x1dded4 - g_ps2RecompiledFunctionTable[227252] = bhEne14_Brain_0x1dded0; // 0x1dded8 - g_ps2RecompiledFunctionTable[227253] = bhEne14_Brain_0x1dded0; // 0x1ddedc - g_ps2RecompiledFunctionTable[227254] = bhEne14_Brain_0x1dded0; // 0x1ddee0 - g_ps2RecompiledFunctionTable[227255] = bhEne14_Brain_0x1dded0; // 0x1ddee4 - g_ps2RecompiledFunctionTable[227256] = bhEne14_Brain_0x1dded0; // 0x1ddee8 - g_ps2RecompiledFunctionTable[227257] = bhEne14_Brain_0x1dded0; // 0x1ddeec - g_ps2RecompiledFunctionTable[227258] = bhEne14_BR00_0x1ddef0; // 0x1ddef0 - g_ps2RecompiledFunctionTable[227262] = bhEne14_BR01_0x1ddf00; // 0x1ddf00 - g_ps2RecompiledFunctionTable[227266] = bhEne14_Move_0x1ddf10; // 0x1ddf10 - g_ps2RecompiledFunctionTable[227267] = bhEne14_Move_0x1ddf10; // 0x1ddf14 - g_ps2RecompiledFunctionTable[227268] = bhEne14_Move_0x1ddf10; // 0x1ddf18 - g_ps2RecompiledFunctionTable[227269] = bhEne14_Move_0x1ddf10; // 0x1ddf1c - g_ps2RecompiledFunctionTable[227270] = bhEne14_Move_0x1ddf10; // 0x1ddf20 - g_ps2RecompiledFunctionTable[227271] = bhEne14_Move_0x1ddf10; // 0x1ddf24 - g_ps2RecompiledFunctionTable[227272] = bhEne14_Move_0x1ddf10; // 0x1ddf28 - g_ps2RecompiledFunctionTable[227273] = bhEne14_Move_0x1ddf10; // 0x1ddf2c - g_ps2RecompiledFunctionTable[227274] = bhEne14_Move_0x1ddf10; // 0x1ddf30 - g_ps2RecompiledFunctionTable[227275] = bhEne14_Move_0x1ddf10; // 0x1ddf34 - g_ps2RecompiledFunctionTable[227276] = bhEne14_Move_0x1ddf10; // 0x1ddf38 - g_ps2RecompiledFunctionTable[227277] = bhEne14_Move_0x1ddf10; // 0x1ddf3c - g_ps2RecompiledFunctionTable[227278] = bhEne14_Move_0x1ddf10; // 0x1ddf40 - g_ps2RecompiledFunctionTable[227279] = bhEne14_Move_0x1ddf10; // 0x1ddf44 - g_ps2RecompiledFunctionTable[227280] = bhEne14_Move_0x1ddf10; // 0x1ddf48 - g_ps2RecompiledFunctionTable[227281] = bhEne14_Move_0x1ddf10; // 0x1ddf4c - g_ps2RecompiledFunctionTable[227282] = bhEne14_Move_0x1ddf10; // 0x1ddf50 - g_ps2RecompiledFunctionTable[227283] = bhEne14_Move_0x1ddf10; // 0x1ddf54 - g_ps2RecompiledFunctionTable[227284] = bhEne14_Move_0x1ddf10; // 0x1ddf58 - g_ps2RecompiledFunctionTable[227285] = bhEne14_Move_0x1ddf10; // 0x1ddf5c - g_ps2RecompiledFunctionTable[227286] = bhEne14_Move_0x1ddf10; // 0x1ddf60 - g_ps2RecompiledFunctionTable[227287] = bhEne14_Move_0x1ddf10; // 0x1ddf64 - g_ps2RecompiledFunctionTable[227288] = bhEne14_Move_0x1ddf10; // 0x1ddf68 - g_ps2RecompiledFunctionTable[227289] = bhEne14_Move_0x1ddf10; // 0x1ddf6c - g_ps2RecompiledFunctionTable[227290] = bhEne14_Move_0x1ddf10; // 0x1ddf70 - g_ps2RecompiledFunctionTable[227291] = bhEne14_Move_0x1ddf10; // 0x1ddf74 - g_ps2RecompiledFunctionTable[227292] = bhEne14_Move_0x1ddf10; // 0x1ddf78 - g_ps2RecompiledFunctionTable[227293] = bhEne14_Move_0x1ddf10; // 0x1ddf7c - g_ps2RecompiledFunctionTable[227294] = bhEne14_Move_0x1ddf10; // 0x1ddf80 - g_ps2RecompiledFunctionTable[227295] = bhEne14_Move_0x1ddf10; // 0x1ddf84 - g_ps2RecompiledFunctionTable[227296] = bhEne14_Move_0x1ddf10; // 0x1ddf88 - g_ps2RecompiledFunctionTable[227297] = bhEne14_Move_0x1ddf10; // 0x1ddf8c - g_ps2RecompiledFunctionTable[227298] = bhEne14_Move_0x1ddf10; // 0x1ddf90 - g_ps2RecompiledFunctionTable[227299] = bhEne14_Move_0x1ddf10; // 0x1ddf94 - g_ps2RecompiledFunctionTable[227300] = bhEne14_Move_0x1ddf10; // 0x1ddf98 - g_ps2RecompiledFunctionTable[227302] = bhEne14_MV00_0x1ddfa0; // 0x1ddfa0 - g_ps2RecompiledFunctionTable[227326] = bhEne14_MV01_0x1de000; // 0x1de000 - g_ps2RecompiledFunctionTable[227382] = bhEne14_MV02_0x1de0e0; // 0x1de0e0 - g_ps2RecompiledFunctionTable[227413] = bhEne14_MV02_0x1de0e0; // 0x1de15c - g_ps2RecompiledFunctionTable[227488] = bhEne14_MV02_0x1de0e0; // 0x1de288 - g_ps2RecompiledFunctionTable[227494] = bhEne14_MV02_0x1de0e0; // 0x1de2a0 - g_ps2RecompiledFunctionTable[227504] = bhEne14_MV02_0x1de0e0; // 0x1de2c8 - g_ps2RecompiledFunctionTable[227530] = bhEne14_MV03_0x1de330; // 0x1de330 - g_ps2RecompiledFunctionTable[227534] = bhEne14_MV04_0x1de340; // 0x1de340 - g_ps2RecompiledFunctionTable[227568] = bhEne14_MV04_0x1de340; // 0x1de3c8 - g_ps2RecompiledFunctionTable[227593] = bhEne14_MV04_0x1de340; // 0x1de42c - g_ps2RecompiledFunctionTable[227620] = bhEne14_MV04_0x1de340; // 0x1de498 - g_ps2RecompiledFunctionTable[227624] = bhEne14_MV04_0x1de340; // 0x1de4a8 - g_ps2RecompiledFunctionTable[227628] = bhEne14_MV04_0x1de340; // 0x1de4b8 - g_ps2RecompiledFunctionTable[227630] = bhEne14_MV04_0x1de340; // 0x1de4c0 - g_ps2RecompiledFunctionTable[227654] = bhEne14_MV04_0x1de340; // 0x1de520 - g_ps2RecompiledFunctionTable[227663] = bhEne14_MV04_0x1de340; // 0x1de544 - g_ps2RecompiledFunctionTable[227683] = bhEne14_MV04_0x1de340; // 0x1de594 - g_ps2RecompiledFunctionTable[227698] = bhEne14_MV04_0x1de340; // 0x1de5d0 - g_ps2RecompiledFunctionTable[227718] = bhEne14_MV04_0x1de340; // 0x1de620 - g_ps2RecompiledFunctionTable[227731] = bhEne14_MV04_0x1de340; // 0x1de654 - g_ps2RecompiledFunctionTable[227746] = bhEne14_MV04_0x1de340; // 0x1de690 - g_ps2RecompiledFunctionTable[227754] = bhEne14_MV04_0x1de340; // 0x1de6b0 - g_ps2RecompiledFunctionTable[227761] = bhEne14_MV04_0x1de340; // 0x1de6cc - g_ps2RecompiledFunctionTable[227789] = bhEne14_MV04_0x1de340; // 0x1de73c - g_ps2RecompiledFunctionTable[227803] = bhEne14_MV04_0x1de340; // 0x1de774 - g_ps2RecompiledFunctionTable[227819] = bhEne14_MV04_0x1de340; // 0x1de7b4 - g_ps2RecompiledFunctionTable[227832] = bhEne14_MV04_0x1de340; // 0x1de7e8 - g_ps2RecompiledFunctionTable[227847] = bhEne14_MV04_0x1de340; // 0x1de824 - g_ps2RecompiledFunctionTable[227855] = bhEne14_MV04_0x1de340; // 0x1de844 - g_ps2RecompiledFunctionTable[227862] = bhEne14_MV04_0x1de340; // 0x1de860 - g_ps2RecompiledFunctionTable[227884] = bhEne14_MV04_0x1de340; // 0x1de8b8 - g_ps2RecompiledFunctionTable[227900] = bhEne14_MV04_0x1de340; // 0x1de8f8 - g_ps2RecompiledFunctionTable[227909] = bhEne14_MV04_0x1de340; // 0x1de91c - g_ps2RecompiledFunctionTable[227924] = bhEne14_MV04_0x1de340; // 0x1de958 - g_ps2RecompiledFunctionTable[227932] = bhEne14_MV04_0x1de340; // 0x1de978 - g_ps2RecompiledFunctionTable[227939] = bhEne14_MV04_0x1de340; // 0x1de994 - g_ps2RecompiledFunctionTable[227998] = bhEne14_MV04_0x1de340; // 0x1dea80 - g_ps2RecompiledFunctionTable[228019] = bhEne14_MV04_0x1de340; // 0x1dead4 - g_ps2RecompiledFunctionTable[228026] = bhEne14_MV04_0x1de340; // 0x1deaf0 - g_ps2RecompiledFunctionTable[228096] = bhEne14_MV04_0x1de340; // 0x1dec08 - g_ps2RecompiledFunctionTable[228112] = bhEne14_MV04_0x1de340; // 0x1dec48 - g_ps2RecompiledFunctionTable[228130] = bhEne14_MV05_0x1dec90; // 0x1dec90 - g_ps2RecompiledFunctionTable[228134] = bhEne14_MV06_0x1deca0; // 0x1deca0 - g_ps2RecompiledFunctionTable[228138] = bhEne14_MV07_0x1decb0; // 0x1decb0 - g_ps2RecompiledFunctionTable[228142] = bhEne14_MV08_0x1decc0; // 0x1decc0 - g_ps2RecompiledFunctionTable[228146] = bhEne14_MV09_0x1decd0; // 0x1decd0 - g_ps2RecompiledFunctionTable[228150] = bhEne14_MV10_0x1dece0; // 0x1dece0 - g_ps2RecompiledFunctionTable[228154] = bhEne14_MV11_0x1decf0; // 0x1decf0 - g_ps2RecompiledFunctionTable[228188] = bhEne14_MV11_0x1decf0; // 0x1ded78 - g_ps2RecompiledFunctionTable[228212] = bhEne14_MV11_0x1decf0; // 0x1dedd8 - g_ps2RecompiledFunctionTable[228223] = bhEne14_MV11_0x1decf0; // 0x1dee04 - g_ps2RecompiledFunctionTable[228250] = bhEne14_MV11_0x1decf0; // 0x1dee70 - g_ps2RecompiledFunctionTable[228254] = bhEne14_MV11_0x1decf0; // 0x1dee80 - g_ps2RecompiledFunctionTable[228258] = bhEne14_MV11_0x1decf0; // 0x1dee90 - g_ps2RecompiledFunctionTable[228267] = bhEne14_MV11_0x1decf0; // 0x1deeb4 - g_ps2RecompiledFunctionTable[228276] = bhEne14_MV11_0x1decf0; // 0x1deed8 - g_ps2RecompiledFunctionTable[228296] = bhEne14_MV11_0x1decf0; // 0x1def28 - g_ps2RecompiledFunctionTable[228300] = bhEne14_MV11_0x1decf0; // 0x1def38 - g_ps2RecompiledFunctionTable[228320] = bhEne14_MV11_0x1decf0; // 0x1def88 - g_ps2RecompiledFunctionTable[228323] = bhEne14_MV11_0x1decf0; // 0x1def94 - g_ps2RecompiledFunctionTable[228338] = bhEne14_MV11_0x1decf0; // 0x1defd0 - g_ps2RecompiledFunctionTable[228346] = bhEne14_MV11_0x1decf0; // 0x1deff0 - g_ps2RecompiledFunctionTable[228353] = bhEne14_MV11_0x1decf0; // 0x1df00c - g_ps2RecompiledFunctionTable[228401] = bhEne14_MV11_0x1decf0; // 0x1df0cc - g_ps2RecompiledFunctionTable[228422] = bhEne14_MV11_0x1decf0; // 0x1df120 - g_ps2RecompiledFunctionTable[228429] = bhEne14_MV11_0x1decf0; // 0x1df13c - g_ps2RecompiledFunctionTable[228438] = bhEne14_MV11_0x1decf0; // 0x1df160 - g_ps2RecompiledFunctionTable[228449] = bhEne14_MV11_0x1decf0; // 0x1df18c - g_ps2RecompiledFunctionTable[228498] = bhEne14_MV11_0x1decf0; // 0x1df250 - g_ps2RecompiledFunctionTable[228512] = bhEne14_MV11_0x1decf0; // 0x1df288 - g_ps2RecompiledFunctionTable[228530] = bhEne14_Nage_0x1df2d0; // 0x1df2d0 - g_ps2RecompiledFunctionTable[228531] = bhEne14_Nage_0x1df2d0; // 0x1df2d4 - g_ps2RecompiledFunctionTable[228532] = bhEne14_Nage_0x1df2d0; // 0x1df2d8 - g_ps2RecompiledFunctionTable[228533] = bhEne14_Nage_0x1df2d0; // 0x1df2dc - g_ps2RecompiledFunctionTable[228534] = bhEne14_Nage_0x1df2d0; // 0x1df2e0 - g_ps2RecompiledFunctionTable[228535] = bhEne14_Nage_0x1df2d0; // 0x1df2e4 - g_ps2RecompiledFunctionTable[228536] = bhEne14_Nage_0x1df2d0; // 0x1df2e8 - g_ps2RecompiledFunctionTable[228537] = bhEne14_Nage_0x1df2d0; // 0x1df2ec - g_ps2RecompiledFunctionTable[228538] = bhEne14_NG00_0x1df2f0; // 0x1df2f0 - g_ps2RecompiledFunctionTable[228542] = bhEne14_Damage_0x1df300; // 0x1df300 - g_ps2RecompiledFunctionTable[228543] = bhEne14_Damage_0x1df300; // 0x1df304 - g_ps2RecompiledFunctionTable[228544] = bhEne14_Damage_0x1df300; // 0x1df308 - g_ps2RecompiledFunctionTable[228545] = bhEne14_Damage_0x1df300; // 0x1df30c - g_ps2RecompiledFunctionTable[228546] = bhEne14_Damage_0x1df300; // 0x1df310 - g_ps2RecompiledFunctionTable[228547] = bhEne14_Damage_0x1df300; // 0x1df314 - g_ps2RecompiledFunctionTable[228548] = bhEne14_Damage_0x1df300; // 0x1df318 - g_ps2RecompiledFunctionTable[228549] = bhEne14_Damage_0x1df300; // 0x1df31c - g_ps2RecompiledFunctionTable[228550] = bhEne14_DG00_0x1df320; // 0x1df320 - g_ps2RecompiledFunctionTable[228610] = bhEne14_DG01_0x1df410; // 0x1df410 - g_ps2RecompiledFunctionTable[228670] = bhEne14_Die_0x1df500; // 0x1df500 - g_ps2RecompiledFunctionTable[228674] = bhEne14_InitDamage_0x1df510; // 0x1df510 - g_ps2RecompiledFunctionTable[228678] = bhEne14_LookPlayaer_0x1df520; // 0x1df520 - g_ps2RecompiledFunctionTable[228738] = bhEne14_LookPlayaer_0x1df520; // 0x1df610 - g_ps2RecompiledFunctionTable[228746] = bhEne14_LookPlayaer_0x1df520; // 0x1df630 - g_ps2RecompiledFunctionTable[228751] = bhEne14_LookPlayaer_0x1df520; // 0x1df644 - g_ps2RecompiledFunctionTable[228757] = bhEne14_LookPlayaer_0x1df520; // 0x1df65c - g_ps2RecompiledFunctionTable[228789] = bhEne14_LookPlayaer_0x1df520; // 0x1df6dc - g_ps2RecompiledFunctionTable[228794] = bhEne14_LookPlayaer_0x1df520; // 0x1df6f0 - g_ps2RecompiledFunctionTable[228796] = bhEne14_LookPlayaer_0x1df520; // 0x1df6f8 - g_ps2RecompiledFunctionTable[228800] = bhEne14_LookPlayaer_0x1df520; // 0x1df708 - g_ps2RecompiledFunctionTable[228802] = bhEne14_LookPlayaer_0x1df520; // 0x1df710 - g_ps2RecompiledFunctionTable[228807] = bhEne14_LookPlayaer_0x1df520; // 0x1df724 - g_ps2RecompiledFunctionTable[228813] = bhEne14_LookPlayaer_0x1df520; // 0x1df73c - g_ps2RecompiledFunctionTable[228836] = bhEne14_LookPlayaer_0x1df520; // 0x1df798 - g_ps2RecompiledFunctionTable[228841] = bhEne14_LookPlayaer_0x1df520; // 0x1df7ac - g_ps2RecompiledFunctionTable[228845] = bhEne14_LookPlayaer_0x1df520; // 0x1df7bc - g_ps2RecompiledFunctionTable[228853] = bhEne14_LookPlayaer_0x1df520; // 0x1df7dc - g_ps2RecompiledFunctionTable[228856] = bhEne14_LookPlayaer_0x1df520; // 0x1df7e8 - g_ps2RecompiledFunctionTable[228858] = bhEne14_LookPlayaer_0x1df520; // 0x1df7f0 - g_ps2RecompiledFunctionTable[228863] = bhEne14_LookPlayaer_0x1df520; // 0x1df804 - g_ps2RecompiledFunctionTable[228867] = bhEne14_LookPlayaer_0x1df520; // 0x1df814 - g_ps2RecompiledFunctionTable[228872] = bhEne14_LookPlayaer_0x1df520; // 0x1df828 - g_ps2RecompiledFunctionTable[228874] = bhEne14_LookPlayaer_0x1df520; // 0x1df830 - g_ps2RecompiledFunctionTable[228879] = bhEne14_LookPlayaer_0x1df520; // 0x1df844 - g_ps2RecompiledFunctionTable[228883] = bhEne14_LookPlayaer_0x1df520; // 0x1df854 - g_ps2RecompiledFunctionTable[228893] = bhEne14_LookPlayaer_0x1df520; // 0x1df87c - g_ps2RecompiledFunctionTable[228898] = bhEne14_LookPlayaer_0x1df520; // 0x1df890 - g_ps2RecompiledFunctionTable[228900] = bhEne14_LookPlayaer_0x1df520; // 0x1df898 - g_ps2RecompiledFunctionTable[228904] = bhEne14_LookPlayaer_0x1df520; // 0x1df8a8 - g_ps2RecompiledFunctionTable[228907] = bhEne14_LookPlayaer_0x1df520; // 0x1df8b4 - g_ps2RecompiledFunctionTable[228909] = bhEne14_LookPlayaer_0x1df520; // 0x1df8bc - g_ps2RecompiledFunctionTable[228914] = bhEne14_LookPlayaer_0x1df520; // 0x1df8d0 - g_ps2RecompiledFunctionTable[228917] = bhEne14_LookPlayaer_0x1df520; // 0x1df8dc - g_ps2RecompiledFunctionTable[228922] = bhEne14_LookPlayaer_0x1df520; // 0x1df8f0 - g_ps2RecompiledFunctionTable[228927] = bhEne14_LookPlayaer_0x1df520; // 0x1df904 - g_ps2RecompiledFunctionTable[228930] = bhEne14_LookPlayaer_0x1df520; // 0x1df910 - g_ps2RecompiledFunctionTable[228932] = bhEne14_LookPlayaer_0x1df520; // 0x1df918 - g_ps2RecompiledFunctionTable[228937] = bhEne14_LookPlayaer_0x1df520; // 0x1df92c - g_ps2RecompiledFunctionTable[228945] = bhEne14_LookPlayaer_0x1df520; // 0x1df94c - g_ps2RecompiledFunctionTable[228949] = bhEne14_LookPlayaer_0x1df520; // 0x1df95c - g_ps2RecompiledFunctionTable[228953] = bhEne14_LookPlayaer_0x1df520; // 0x1df96c - g_ps2RecompiledFunctionTable[228956] = bhEne14_LookPlayaer_0x1df520; // 0x1df978 - g_ps2RecompiledFunctionTable[228968] = bhEne14_LookPlayaer_0x1df520; // 0x1df9a8 - g_ps2RecompiledFunctionTable[228975] = bhEne14_LookPlayaer_0x1df520; // 0x1df9c4 - g_ps2RecompiledFunctionTable[228980] = bhEne14_LookPlayaer_0x1df520; // 0x1df9d8 - g_ps2RecompiledFunctionTable[228983] = bhEne14_LookPlayaer_0x1df520; // 0x1df9e4 - g_ps2RecompiledFunctionTable[228988] = bhEne14_LookPlayaer_0x1df520; // 0x1df9f8 - g_ps2RecompiledFunctionTable[228999] = bhEne14_LookPlayaer_0x1df520; // 0x1dfa24 - g_ps2RecompiledFunctionTable[229004] = bhEne14_LookPlayaer_0x1df520; // 0x1dfa38 - g_ps2RecompiledFunctionTable[229008] = bhEne14_LookPlayaer_0x1df520; // 0x1dfa48 - g_ps2RecompiledFunctionTable[229022] = bhEne14_TailInit_0x1dfa80; // 0x1dfa80 - g_ps2RecompiledFunctionTable[229029] = bhEne14_TailInit_0x1dfa80; // 0x1dfa9c - g_ps2RecompiledFunctionTable[229062] = bhEne14_TailSwing_0x1dfb20; // 0x1dfb20 - g_ps2RecompiledFunctionTable[229071] = bhEne14_TailSwing_0x1dfb20; // 0x1dfb44 - g_ps2RecompiledFunctionTable[229073] = bhEne14_TailSwing_0x1dfb20; // 0x1dfb4c - g_ps2RecompiledFunctionTable[229098] = bhEne14_TailSwing_0x1dfb20; // 0x1dfbb0 - g_ps2RecompiledFunctionTable[229173] = bhEne14_TailSwing_0x1dfb20; // 0x1dfcdc - g_ps2RecompiledFunctionTable[229195] = bhEne14_TailSwing_0x1dfb20; // 0x1dfd34 - g_ps2RecompiledFunctionTable[229224] = bhEne14_TailSwing_0x1dfb20; // 0x1dfda8 - g_ps2RecompiledFunctionTable[229254] = bhEne14_TailSwing_0x1dfb20; // 0x1dfe20 - g_ps2RecompiledFunctionTable[229255] = bhEne14_TailSwing_0x1dfb20; // 0x1dfe24 - g_ps2RecompiledFunctionTable[229257] = bhEne14_TailSwing_0x1dfb20; // 0x1dfe2c - g_ps2RecompiledFunctionTable[229259] = bhEne14_TailSwing_0x1dfb20; // 0x1dfe34 - g_ps2RecompiledFunctionTable[229269] = bhEne14_TailSwing_0x1dfb20; // 0x1dfe5c - g_ps2RecompiledFunctionTable[229271] = bhEne14_TailSwing_0x1dfb20; // 0x1dfe64 - g_ps2RecompiledFunctionTable[229276] = bhEne14_TailSwing_0x1dfb20; // 0x1dfe78 - g_ps2RecompiledFunctionTable[229280] = bhEne14_TailSwing_0x1dfb20; // 0x1dfe88 - g_ps2RecompiledFunctionTable[229283] = bhEne14_TailSwing_0x1dfb20; // 0x1dfe94 - g_ps2RecompiledFunctionTable[229311] = bhEne14_TailSwing_0x1dfb20; // 0x1dff04 - g_ps2RecompiledFunctionTable[229314] = bhEne14_TailSwing_0x1dfb20; // 0x1dff10 - g_ps2RecompiledFunctionTable[229326] = bhEne14_HitMark_0x1dff40; // 0x1dff40 - g_ps2RecompiledFunctionTable[229341] = bhEne14_HitMark_0x1dff40; // 0x1dff7c - g_ps2RecompiledFunctionTable[229385] = bhEne14_HitMark_0x1dff40; // 0x1e002c - g_ps2RecompiledFunctionTable[229401] = bhEne14_HitMark_0x1dff40; // 0x1e006c - g_ps2RecompiledFunctionTable[229417] = bhEne14_HitMark_0x1dff40; // 0x1e00ac - g_ps2RecompiledFunctionTable[229455] = bhEne14_HitMark_0x1dff40; // 0x1e0144 - g_ps2RecompiledFunctionTable[229469] = bhEne14_HitMark_0x1dff40; // 0x1e017c - g_ps2RecompiledFunctionTable[229483] = bhEne14_HitMark_0x1dff40; // 0x1e01b4 - g_ps2RecompiledFunctionTable[229493] = bhEne14_HitMark_0x1dff40; // 0x1e01dc - g_ps2RecompiledFunctionTable[229509] = bhEne14_HitMark_0x1dff40; // 0x1e021c - g_ps2RecompiledFunctionTable[229525] = bhEne14_HitMark_0x1dff40; // 0x1e025c - g_ps2RecompiledFunctionTable[229540] = bhEne14_HitMark_0x1dff40; // 0x1e0298 - g_ps2RecompiledFunctionTable[229553] = bhEne14_HitMark_0x1dff40; // 0x1e02cc - g_ps2RecompiledFunctionTable[229566] = bhEne14_HitMark_0x1dff40; // 0x1e0300 - g_ps2RecompiledFunctionTable[229572] = bhEne14_HitMark_0x1dff40; // 0x1e0318 - g_ps2RecompiledFunctionTable[229596] = bhEne14_HitMark_0x1dff40; // 0x1e0378 - g_ps2RecompiledFunctionTable[229612] = bhEne14_HitMark_0x1dff40; // 0x1e03b8 - g_ps2RecompiledFunctionTable[229628] = bhEne14_HitMark_0x1dff40; // 0x1e03f8 - g_ps2RecompiledFunctionTable[229646] = bhEne14_HitMark_0x1dff40; // 0x1e0440 - g_ps2RecompiledFunctionTable[229694] = bhEne14_Acid_0x1e0500; // 0x1e0500 - g_ps2RecompiledFunctionTable[229718] = bhEne14_Acid_0x1e0500; // 0x1e0560 - g_ps2RecompiledFunctionTable[229730] = bhEne14_Acid_0x1e0500; // 0x1e0590 - g_ps2RecompiledFunctionTable[229740] = bhEne14_Acid_0x1e0500; // 0x1e05b8 - g_ps2RecompiledFunctionTable[229804] = bhEne14_Acid_0x1e0500; // 0x1e06b8 - g_ps2RecompiledFunctionTable[229806] = bhEne14_Acid_0x1e0500; // 0x1e06c0 - g_ps2RecompiledFunctionTable[229844] = bhEne14_Acid_0x1e0500; // 0x1e0758 - g_ps2RecompiledFunctionTable[229869] = bhEne14_Acid_0x1e0500; // 0x1e07bc - g_ps2RecompiledFunctionTable[229871] = bhEne14_Acid_0x1e0500; // 0x1e07c4 - g_ps2RecompiledFunctionTable[229887] = bhEne14_Acid_0x1e0500; // 0x1e0804 - g_ps2RecompiledFunctionTable[229890] = bhEne14_Acid_0x1e0500; // 0x1e0810 - g_ps2RecompiledFunctionTable[229892] = bhEne14_Acid_0x1e0500; // 0x1e0818 - g_ps2RecompiledFunctionTable[229906] = bhEne14_Acid_0x1e0500; // 0x1e0850 - g_ps2RecompiledFunctionTable[229909] = bhEne14_Acid_0x1e0500; // 0x1e085c - g_ps2RecompiledFunctionTable[229913] = bhEne14_Acid_0x1e0500; // 0x1e086c - g_ps2RecompiledFunctionTable[229915] = bhEne14_Acid_0x1e0500; // 0x1e0874 - g_ps2RecompiledFunctionTable[229958] = bhEne14_SetMotion_0x1e0920; // 0x1e0920 - g_ps2RecompiledFunctionTable[229974] = bhEne14_SetMotion_0x1e0920; // 0x1e0960 - g_ps2RecompiledFunctionTable[230016] = bhEne14_SetMotion_0x1e0920; // 0x1e0a08 - g_ps2RecompiledFunctionTable[230058] = bhEne14_CheckWall_0x1e0ab0; // 0x1e0ab0 - g_ps2RecompiledFunctionTable[230063] = bhEne14_CheckWall_0x1e0ab0; // 0x1e0ac4 - g_ps2RecompiledFunctionTable[230070] = bhEne14_CheckWall_0x1e0ab0; // 0x1e0ae0 - g_ps2RecompiledFunctionTable[230079] = bhEne14_CheckWall_0x1e0ab0; // 0x1e0b04 - g_ps2RecompiledFunctionTable[230090] = bhEne14_PlayerControl_0x1e0b30; // 0x1e0b30 - g_ps2RecompiledFunctionTable[230169] = bhEne14_PlayerControl_0x1e0b30; // 0x1e0c6c - g_ps2RecompiledFunctionTable[230172] = bhEne14_PlayerControl_0x1e0b30; // 0x1e0c78 - g_ps2RecompiledFunctionTable[230250] = bhEne14_CallSE_0x1e0db0; // 0x1e0db0 - g_ps2RecompiledFunctionTable[230281] = bhEne14_CallSE_0x1e0db0; // 0x1e0e2c - g_ps2RecompiledFunctionTable[230291] = bhEne14_CallSE_0x1e0db0; // 0x1e0e54 - g_ps2RecompiledFunctionTable[230299] = bhEne14_CallSE_0x1e0db0; // 0x1e0e74 - g_ps2RecompiledFunctionTable[230308] = bhEne14_CallSE_0x1e0db0; // 0x1e0e98 - g_ps2RecompiledFunctionTable[230314] = target_direction_0x1e0eb0; // 0x1e0eb0 - g_ps2RecompiledFunctionTable[230325] = target_direction_0x1e0eb0; // 0x1e0edc - g_ps2RecompiledFunctionTable[230359] = target_direction_0x1e0eb0; // 0x1e0f64 - g_ps2RecompiledFunctionTable[230366] = target_distance_0x1e0f80; // 0x1e0f80 - g_ps2RecompiledFunctionTable[230380] = target_distance_0x1e0f80; // 0x1e0fb8 - g_ps2RecompiledFunctionTable[230386] = GetLocalEneNo_0x1e0fd0; // 0x1e0fd0 - g_ps2RecompiledFunctionTable[230391] = GetLocalEneNo_0x1e0fd0; // 0x1e0fe4 - g_ps2RecompiledFunctionTable[230404] = GetLocalEneNo_0x1e0fd0; // 0x1e1018 - g_ps2RecompiledFunctionTable[230409] = GetLocalEneNo_0x1e0fd0; // 0x1e102c - g_ps2RecompiledFunctionTable[230414] = SetMtnSE_0x1e1040; // 0x1e1040 - g_ps2RecompiledFunctionTable[230424] = SetMtnSE_0x1e1040; // 0x1e1068 - g_ps2RecompiledFunctionTable[230434] = SetMtnSE_0x1e1040; // 0x1e1090 - g_ps2RecompiledFunctionTable[230444] = SetMtnSE_0x1e1040; // 0x1e10b8 - g_ps2RecompiledFunctionTable[230458] = bhEne15_0x1e10f0; // 0x1e10f0 - g_ps2RecompiledFunctionTable[230459] = bhEne15_0x1e10f0; // 0x1e10f4 - g_ps2RecompiledFunctionTable[230460] = bhEne15_0x1e10f0; // 0x1e10f8 - g_ps2RecompiledFunctionTable[230461] = bhEne15_0x1e10f0; // 0x1e10fc - g_ps2RecompiledFunctionTable[230462] = bhEne15_0x1e10f0; // 0x1e1100 - g_ps2RecompiledFunctionTable[230463] = bhEne15_0x1e10f0; // 0x1e1104 - g_ps2RecompiledFunctionTable[230464] = bhEne15_0x1e10f0; // 0x1e1108 - g_ps2RecompiledFunctionTable[230465] = bhEne15_0x1e10f0; // 0x1e110c - g_ps2RecompiledFunctionTable[230466] = bhEne15_0x1e10f0; // 0x1e1110 - g_ps2RecompiledFunctionTable[230467] = bhEne15_0x1e10f0; // 0x1e1114 - g_ps2RecompiledFunctionTable[230468] = bhEne15_0x1e10f0; // 0x1e1118 - g_ps2RecompiledFunctionTable[230469] = bhEne15_0x1e10f0; // 0x1e111c - g_ps2RecompiledFunctionTable[230470] = bhEne15_0x1e10f0; // 0x1e1120 - g_ps2RecompiledFunctionTable[230471] = bhEne15_0x1e10f0; // 0x1e1124 - g_ps2RecompiledFunctionTable[230472] = bhEne15_0x1e10f0; // 0x1e1128 - g_ps2RecompiledFunctionTable[230473] = bhEne15_0x1e10f0; // 0x1e112c - g_ps2RecompiledFunctionTable[230474] = bhEne15_0x1e10f0; // 0x1e1130 - g_ps2RecompiledFunctionTable[230475] = bhEne15_0x1e10f0; // 0x1e1134 - g_ps2RecompiledFunctionTable[230476] = bhEne15_0x1e10f0; // 0x1e1138 - g_ps2RecompiledFunctionTable[230477] = bhEne15_0x1e10f0; // 0x1e113c - g_ps2RecompiledFunctionTable[230478] = bhEne15_0x1e10f0; // 0x1e1140 - g_ps2RecompiledFunctionTable[230479] = bhEne15_0x1e10f0; // 0x1e1144 - g_ps2RecompiledFunctionTable[230480] = bhEne15_0x1e10f0; // 0x1e1148 - g_ps2RecompiledFunctionTable[230481] = bhEne15_0x1e10f0; // 0x1e114c - g_ps2RecompiledFunctionTable[230482] = bhEne15_0x1e10f0; // 0x1e1150 - g_ps2RecompiledFunctionTable[230483] = bhEne15_0x1e10f0; // 0x1e1154 - g_ps2RecompiledFunctionTable[230484] = bhEne15_0x1e10f0; // 0x1e1158 - g_ps2RecompiledFunctionTable[230485] = bhEne15_0x1e10f0; // 0x1e115c - g_ps2RecompiledFunctionTable[230486] = bhEne15_0x1e10f0; // 0x1e1160 - g_ps2RecompiledFunctionTable[230487] = bhEne15_0x1e10f0; // 0x1e1164 - g_ps2RecompiledFunctionTable[230488] = bhEne15_0x1e10f0; // 0x1e1168 - g_ps2RecompiledFunctionTable[230489] = bhEne15_0x1e10f0; // 0x1e116c - g_ps2RecompiledFunctionTable[230490] = bhEne15_0x1e10f0; // 0x1e1170 - g_ps2RecompiledFunctionTable[230491] = bhEne15_0x1e10f0; // 0x1e1174 - g_ps2RecompiledFunctionTable[230492] = bhEne15_0x1e10f0; // 0x1e1178 - g_ps2RecompiledFunctionTable[230493] = bhEne15_0x1e10f0; // 0x1e117c - g_ps2RecompiledFunctionTable[230494] = bhEne15_0x1e10f0; // 0x1e1180 - g_ps2RecompiledFunctionTable[230495] = bhEne15_0x1e10f0; // 0x1e1184 - g_ps2RecompiledFunctionTable[230496] = bhEne15_0x1e10f0; // 0x1e1188 - g_ps2RecompiledFunctionTable[230497] = bhEne15_0x1e10f0; // 0x1e118c - g_ps2RecompiledFunctionTable[230498] = bhEne15_0x1e10f0; // 0x1e1190 - g_ps2RecompiledFunctionTable[230499] = bhEne15_0x1e10f0; // 0x1e1194 - g_ps2RecompiledFunctionTable[230500] = bhEne15_0x1e10f0; // 0x1e1198 - g_ps2RecompiledFunctionTable[230501] = bhEne15_0x1e10f0; // 0x1e119c - g_ps2RecompiledFunctionTable[230502] = bhEne15_0x1e10f0; // 0x1e11a0 - g_ps2RecompiledFunctionTable[230503] = bhEne15_0x1e10f0; // 0x1e11a4 - g_ps2RecompiledFunctionTable[230504] = bhEne15_0x1e10f0; // 0x1e11a8 - g_ps2RecompiledFunctionTable[230505] = bhEne15_0x1e10f0; // 0x1e11ac - g_ps2RecompiledFunctionTable[230506] = bhEne15_0x1e10f0; // 0x1e11b0 - g_ps2RecompiledFunctionTable[230507] = bhEne15_0x1e10f0; // 0x1e11b4 - g_ps2RecompiledFunctionTable[230508] = bhEne15_0x1e10f0; // 0x1e11b8 - g_ps2RecompiledFunctionTable[230509] = bhEne15_0x1e10f0; // 0x1e11bc - g_ps2RecompiledFunctionTable[230510] = bhEne15_0x1e10f0; // 0x1e11c0 - g_ps2RecompiledFunctionTable[230511] = bhEne15_0x1e10f0; // 0x1e11c4 - g_ps2RecompiledFunctionTable[230512] = bhEne15_0x1e10f0; // 0x1e11c8 - g_ps2RecompiledFunctionTable[230513] = bhEne15_0x1e10f0; // 0x1e11cc - g_ps2RecompiledFunctionTable[230514] = bhEne15_0x1e10f0; // 0x1e11d0 - g_ps2RecompiledFunctionTable[230515] = bhEne15_0x1e10f0; // 0x1e11d4 - g_ps2RecompiledFunctionTable[230516] = bhEne15_0x1e10f0; // 0x1e11d8 - g_ps2RecompiledFunctionTable[230517] = bhEne15_0x1e10f0; // 0x1e11dc - g_ps2RecompiledFunctionTable[230518] = bhEne15_0x1e10f0; // 0x1e11e0 - g_ps2RecompiledFunctionTable[230519] = bhEne15_0x1e10f0; // 0x1e11e4 - g_ps2RecompiledFunctionTable[230520] = bhEne15_0x1e10f0; // 0x1e11e8 - g_ps2RecompiledFunctionTable[230521] = bhEne15_0x1e10f0; // 0x1e11ec - g_ps2RecompiledFunctionTable[230522] = bhEne15_0x1e10f0; // 0x1e11f0 - g_ps2RecompiledFunctionTable[230523] = bhEne15_0x1e10f0; // 0x1e11f4 - g_ps2RecompiledFunctionTable[230524] = bhEne15_0x1e10f0; // 0x1e11f8 - g_ps2RecompiledFunctionTable[230525] = bhEne15_0x1e10f0; // 0x1e11fc - g_ps2RecompiledFunctionTable[230526] = bhEne15_0x1e10f0; // 0x1e1200 - g_ps2RecompiledFunctionTable[230527] = bhEne15_0x1e10f0; // 0x1e1204 - g_ps2RecompiledFunctionTable[230528] = bhEne15_0x1e10f0; // 0x1e1208 - g_ps2RecompiledFunctionTable[230529] = bhEne15_0x1e10f0; // 0x1e120c - g_ps2RecompiledFunctionTable[230530] = bhEne15_0x1e10f0; // 0x1e1210 - g_ps2RecompiledFunctionTable[230531] = bhEne15_0x1e10f0; // 0x1e1214 - g_ps2RecompiledFunctionTable[230532] = bhEne15_0x1e10f0; // 0x1e1218 - g_ps2RecompiledFunctionTable[230533] = bhEne15_0x1e10f0; // 0x1e121c - g_ps2RecompiledFunctionTable[230534] = bhEne15_0x1e10f0; // 0x1e1220 - g_ps2RecompiledFunctionTable[230535] = bhEne15_0x1e10f0; // 0x1e1224 - g_ps2RecompiledFunctionTable[230536] = bhEne15_0x1e10f0; // 0x1e1228 - g_ps2RecompiledFunctionTable[230537] = bhEne15_0x1e10f0; // 0x1e122c - g_ps2RecompiledFunctionTable[230538] = bhEne15_0x1e10f0; // 0x1e1230 - g_ps2RecompiledFunctionTable[230539] = bhEne15_0x1e10f0; // 0x1e1234 - g_ps2RecompiledFunctionTable[230540] = bhEne15_0x1e10f0; // 0x1e1238 - g_ps2RecompiledFunctionTable[230541] = bhEne15_0x1e10f0; // 0x1e123c - g_ps2RecompiledFunctionTable[230542] = bhEne15_0x1e10f0; // 0x1e1240 - g_ps2RecompiledFunctionTable[230543] = bhEne15_0x1e10f0; // 0x1e1244 - g_ps2RecompiledFunctionTable[230544] = bhEne15_0x1e10f0; // 0x1e1248 - g_ps2RecompiledFunctionTable[230545] = bhEne15_0x1e10f0; // 0x1e124c - g_ps2RecompiledFunctionTable[230546] = bhEne15_0x1e10f0; // 0x1e1250 - g_ps2RecompiledFunctionTable[230547] = bhEne15_0x1e10f0; // 0x1e1254 - g_ps2RecompiledFunctionTable[230548] = bhEne15_0x1e10f0; // 0x1e1258 - g_ps2RecompiledFunctionTable[230549] = bhEne15_0x1e10f0; // 0x1e125c - g_ps2RecompiledFunctionTable[230550] = bhEne15_0x1e10f0; // 0x1e1260 - g_ps2RecompiledFunctionTable[230551] = bhEne15_0x1e10f0; // 0x1e1264 - g_ps2RecompiledFunctionTable[230552] = bhEne15_0x1e10f0; // 0x1e1268 - g_ps2RecompiledFunctionTable[230553] = bhEne15_0x1e10f0; // 0x1e126c - g_ps2RecompiledFunctionTable[230554] = bhEne15_0x1e10f0; // 0x1e1270 - g_ps2RecompiledFunctionTable[230555] = bhEne15_0x1e10f0; // 0x1e1274 - g_ps2RecompiledFunctionTable[230556] = bhEne15_0x1e10f0; // 0x1e1278 - g_ps2RecompiledFunctionTable[230557] = bhEne15_0x1e10f0; // 0x1e127c - g_ps2RecompiledFunctionTable[230558] = bhEne15_0x1e10f0; // 0x1e1280 - g_ps2RecompiledFunctionTable[230559] = bhEne15_0x1e10f0; // 0x1e1284 - g_ps2RecompiledFunctionTable[230560] = bhEne15_0x1e10f0; // 0x1e1288 - g_ps2RecompiledFunctionTable[230561] = bhEne15_0x1e10f0; // 0x1e128c - g_ps2RecompiledFunctionTable[230562] = bhEne15_0x1e10f0; // 0x1e1290 - g_ps2RecompiledFunctionTable[230563] = bhEne15_0x1e10f0; // 0x1e1294 - g_ps2RecompiledFunctionTable[230564] = bhEne15_0x1e10f0; // 0x1e1298 - g_ps2RecompiledFunctionTable[230565] = bhEne15_0x1e10f0; // 0x1e129c - g_ps2RecompiledFunctionTable[230566] = bhEne15_0x1e10f0; // 0x1e12a0 - g_ps2RecompiledFunctionTable[230567] = bhEne15_0x1e10f0; // 0x1e12a4 - g_ps2RecompiledFunctionTable[230568] = bhEne15_0x1e10f0; // 0x1e12a8 - g_ps2RecompiledFunctionTable[230569] = bhEne15_0x1e10f0; // 0x1e12ac - g_ps2RecompiledFunctionTable[230570] = bhEne15_0x1e10f0; // 0x1e12b0 - g_ps2RecompiledFunctionTable[230571] = bhEne15_0x1e10f0; // 0x1e12b4 - g_ps2RecompiledFunctionTable[230572] = bhEne15_0x1e10f0; // 0x1e12b8 - g_ps2RecompiledFunctionTable[230573] = bhEne15_0x1e10f0; // 0x1e12bc - g_ps2RecompiledFunctionTable[230574] = bhEne15_0x1e10f0; // 0x1e12c0 - g_ps2RecompiledFunctionTable[230575] = bhEne15_0x1e10f0; // 0x1e12c4 - g_ps2RecompiledFunctionTable[230576] = bhEne15_0x1e10f0; // 0x1e12c8 - g_ps2RecompiledFunctionTable[230577] = bhEne15_0x1e10f0; // 0x1e12cc - g_ps2RecompiledFunctionTable[230578] = bhEne15_0x1e10f0; // 0x1e12d0 - g_ps2RecompiledFunctionTable[230579] = bhEne15_0x1e10f0; // 0x1e12d4 - g_ps2RecompiledFunctionTable[230580] = bhEne15_0x1e10f0; // 0x1e12d8 - g_ps2RecompiledFunctionTable[230581] = bhEne15_0x1e10f0; // 0x1e12dc - g_ps2RecompiledFunctionTable[230582] = bhEne15_0x1e10f0; // 0x1e12e0 - g_ps2RecompiledFunctionTable[230583] = bhEne15_0x1e10f0; // 0x1e12e4 - g_ps2RecompiledFunctionTable[230584] = bhEne15_0x1e10f0; // 0x1e12e8 - g_ps2RecompiledFunctionTable[230585] = bhEne15_0x1e10f0; // 0x1e12ec - g_ps2RecompiledFunctionTable[230586] = bhEne15_0x1e10f0; // 0x1e12f0 - g_ps2RecompiledFunctionTable[230587] = bhEne15_0x1e10f0; // 0x1e12f4 - g_ps2RecompiledFunctionTable[230588] = bhEne15_0x1e10f0; // 0x1e12f8 - g_ps2RecompiledFunctionTable[230589] = bhEne15_0x1e10f0; // 0x1e12fc - g_ps2RecompiledFunctionTable[230590] = bhEne15_0x1e10f0; // 0x1e1300 - g_ps2RecompiledFunctionTable[230591] = bhEne15_0x1e10f0; // 0x1e1304 - g_ps2RecompiledFunctionTable[230592] = bhEne15_0x1e10f0; // 0x1e1308 - g_ps2RecompiledFunctionTable[230593] = bhEne15_0x1e10f0; // 0x1e130c - g_ps2RecompiledFunctionTable[230594] = bhEne15_0x1e10f0; // 0x1e1310 - g_ps2RecompiledFunctionTable[230595] = bhEne15_0x1e10f0; // 0x1e1314 - g_ps2RecompiledFunctionTable[230596] = bhEne15_0x1e10f0; // 0x1e1318 - g_ps2RecompiledFunctionTable[230597] = bhEne15_0x1e10f0; // 0x1e131c - g_ps2RecompiledFunctionTable[230598] = bhEne15_0x1e10f0; // 0x1e1320 - g_ps2RecompiledFunctionTable[230602] = Init_0x1e1330; // 0x1e1330 - g_ps2RecompiledFunctionTable[230611] = Init_0x1e1330; // 0x1e1354 - g_ps2RecompiledFunctionTable[230620] = Init_0x1e1330; // 0x1e1378 - g_ps2RecompiledFunctionTable[230625] = Init_0x1e1330; // 0x1e138c - g_ps2RecompiledFunctionTable[230650] = Init_0x1e1330; // 0x1e13f0 - g_ps2RecompiledFunctionTable[230668] = Init_0x1e1330; // 0x1e1438 - g_ps2RecompiledFunctionTable[230688] = Init_0x1e1330; // 0x1e1488 - g_ps2RecompiledFunctionTable[230717] = Init_0x1e1330; // 0x1e14fc - g_ps2RecompiledFunctionTable[230747] = Init_0x1e1330; // 0x1e1574 - g_ps2RecompiledFunctionTable[230760] = Init_0x1e1330; // 0x1e15a8 - g_ps2RecompiledFunctionTable[230782] = Move_0x1e1600; // 0x1e1600 - g_ps2RecompiledFunctionTable[230783] = Move_0x1e1600; // 0x1e1604 - g_ps2RecompiledFunctionTable[230784] = Move_0x1e1600; // 0x1e1608 - g_ps2RecompiledFunctionTable[230785] = Move_0x1e1600; // 0x1e160c - g_ps2RecompiledFunctionTable[230786] = Move_0x1e1600; // 0x1e1610 - g_ps2RecompiledFunctionTable[230787] = Move_0x1e1600; // 0x1e1614 - g_ps2RecompiledFunctionTable[230788] = Move_0x1e1600; // 0x1e1618 - g_ps2RecompiledFunctionTable[230789] = Move_0x1e1600; // 0x1e161c - g_ps2RecompiledFunctionTable[230790] = Move_0x1e1600; // 0x1e1620 - g_ps2RecompiledFunctionTable[230791] = Move_0x1e1600; // 0x1e1624 - g_ps2RecompiledFunctionTable[230792] = Move_0x1e1600; // 0x1e1628 - g_ps2RecompiledFunctionTable[230793] = Move_0x1e1600; // 0x1e162c - g_ps2RecompiledFunctionTable[230794] = Move_0x1e1600; // 0x1e1630 - g_ps2RecompiledFunctionTable[230795] = Move_0x1e1600; // 0x1e1634 - g_ps2RecompiledFunctionTable[230796] = Move_0x1e1600; // 0x1e1638 - g_ps2RecompiledFunctionTable[230797] = Move_0x1e1600; // 0x1e163c - g_ps2RecompiledFunctionTable[230798] = Move_0x1e1600; // 0x1e1640 - g_ps2RecompiledFunctionTable[230799] = Move_0x1e1600; // 0x1e1644 - g_ps2RecompiledFunctionTable[230800] = Move_0x1e1600; // 0x1e1648 - g_ps2RecompiledFunctionTable[230801] = Move_0x1e1600; // 0x1e164c - g_ps2RecompiledFunctionTable[230802] = Move_0x1e1600; // 0x1e1650 - g_ps2RecompiledFunctionTable[230803] = Move_0x1e1600; // 0x1e1654 - g_ps2RecompiledFunctionTable[230804] = Move_0x1e1600; // 0x1e1658 - g_ps2RecompiledFunctionTable[230805] = Move_0x1e1600; // 0x1e165c - g_ps2RecompiledFunctionTable[230806] = Move_0x1e1600; // 0x1e1660 - g_ps2RecompiledFunctionTable[230807] = Move_0x1e1600; // 0x1e1664 - g_ps2RecompiledFunctionTable[230808] = Move_0x1e1600; // 0x1e1668 - g_ps2RecompiledFunctionTable[230809] = Move_0x1e1600; // 0x1e166c - g_ps2RecompiledFunctionTable[230810] = Move_0x1e1600; // 0x1e1670 - g_ps2RecompiledFunctionTable[230811] = Move_0x1e1600; // 0x1e1674 - g_ps2RecompiledFunctionTable[230812] = Move_0x1e1600; // 0x1e1678 - g_ps2RecompiledFunctionTable[230814] = Stand_0x1e1680; // 0x1e1680 - g_ps2RecompiledFunctionTable[230823] = Stand_0x1e1680; // 0x1e16a4 - g_ps2RecompiledFunctionTable[230825] = Stand_0x1e1680; // 0x1e16ac - g_ps2RecompiledFunctionTable[230840] = Stand_0x1e1680; // 0x1e16e8 - g_ps2RecompiledFunctionTable[230845] = Stand_0x1e1680; // 0x1e16fc - g_ps2RecompiledFunctionTable[230860] = Stand_0x1e1680; // 0x1e1738 - g_ps2RecompiledFunctionTable[230865] = Stand_0x1e1680; // 0x1e174c - g_ps2RecompiledFunctionTable[230870] = Stand_0x1e1680; // 0x1e1760 - g_ps2RecompiledFunctionTable[230875] = Stand_0x1e1680; // 0x1e1774 - g_ps2RecompiledFunctionTable[230897] = Stand_0x1e1680; // 0x1e17cc - g_ps2RecompiledFunctionTable[230908] = Stand_0x1e1680; // 0x1e17f8 - g_ps2RecompiledFunctionTable[230919] = Stand_0x1e1680; // 0x1e1824 - g_ps2RecompiledFunctionTable[230926] = ps2___attack_0x1e1840; // 0x1e1840 - g_ps2RecompiledFunctionTable[230945] = ps2___attack_0x1e1840; // 0x1e188c - g_ps2RecompiledFunctionTable[230966] = ps2___attack_0x1e1840; // 0x1e18e0 - g_ps2RecompiledFunctionTable[230975] = ps2___attack_0x1e1840; // 0x1e1904 - g_ps2RecompiledFunctionTable[230996] = ps2___attack_0x1e1840; // 0x1e1958 - g_ps2RecompiledFunctionTable[231011] = ps2___attack_0x1e1840; // 0x1e1994 - g_ps2RecompiledFunctionTable[231034] = ps2___attack_0x1e1840; // 0x1e19f0 - g_ps2RecompiledFunctionTable[231043] = ps2___attack_0x1e1840; // 0x1e1a14 - g_ps2RecompiledFunctionTable[231064] = ps2___attack_0x1e1840; // 0x1e1a68 - g_ps2RecompiledFunctionTable[231079] = ps2___attack_0x1e1840; // 0x1e1aa4 - g_ps2RecompiledFunctionTable[231089] = ps2___attack_0x1e1840; // 0x1e1acc - g_ps2RecompiledFunctionTable[231098] = ps2___attack_0x1e1840; // 0x1e1af0 - g_ps2RecompiledFunctionTable[231119] = ps2___attack_0x1e1840; // 0x1e1b44 - g_ps2RecompiledFunctionTable[231134] = ps2___attack_0x1e1840; // 0x1e1b80 - g_ps2RecompiledFunctionTable[231144] = ps2___attack_0x1e1840; // 0x1e1ba8 - g_ps2RecompiledFunctionTable[231153] = ps2___attack_0x1e1840; // 0x1e1bcc - g_ps2RecompiledFunctionTable[231174] = ps2___attack_0x1e1840; // 0x1e1c20 - g_ps2RecompiledFunctionTable[231188] = ps2___attack_0x1e1840; // 0x1e1c58 - g_ps2RecompiledFunctionTable[231206] = ps2___attack_0x1e1840; // 0x1e1ca0 - g_ps2RecompiledFunctionTable[231214] = ps2___attack_0x1e1840; // 0x1e1cc0 - g_ps2RecompiledFunctionTable[231235] = ps2___attack_0x1e1840; // 0x1e1d14 - g_ps2RecompiledFunctionTable[231248] = ps2___attack_0x1e1840; // 0x1e1d48 - g_ps2RecompiledFunctionTable[231258] = ps2___attack_0x1e1840; // 0x1e1d70 - g_ps2RecompiledFunctionTable[231281] = ps2___attack_0x1e1840; // 0x1e1dcc - g_ps2RecompiledFunctionTable[231295] = ps2___attack_0x1e1840; // 0x1e1e04 - g_ps2RecompiledFunctionTable[231312] = ps2___attack_0x1e1840; // 0x1e1e48 - g_ps2RecompiledFunctionTable[231335] = ps2___attack_0x1e1840; // 0x1e1ea4 - g_ps2RecompiledFunctionTable[231348] = ps2___attack_0x1e1840; // 0x1e1ed8 - g_ps2RecompiledFunctionTable[231354] = CloseTurn_0x1e1ef0; // 0x1e1ef0 - g_ps2RecompiledFunctionTable[231363] = CloseTurn_0x1e1ef0; // 0x1e1f14 - g_ps2RecompiledFunctionTable[231365] = CloseTurn_0x1e1ef0; // 0x1e1f1c - g_ps2RecompiledFunctionTable[231380] = CloseTurn_0x1e1ef0; // 0x1e1f58 - g_ps2RecompiledFunctionTable[231385] = CloseTurn_0x1e1ef0; // 0x1e1f6c - g_ps2RecompiledFunctionTable[231390] = CloseTurn_0x1e1ef0; // 0x1e1f80 - g_ps2RecompiledFunctionTable[231395] = CloseTurn_0x1e1ef0; // 0x1e1f94 - g_ps2RecompiledFunctionTable[231417] = CloseTurn_0x1e1ef0; // 0x1e1fec - g_ps2RecompiledFunctionTable[231428] = CloseTurn_0x1e1ef0; // 0x1e2018 - g_ps2RecompiledFunctionTable[231433] = CloseTurn_0x1e1ef0; // 0x1e202c - g_ps2RecompiledFunctionTable[231442] = CloseTurn_0x1e1ef0; // 0x1e2050 - g_ps2RecompiledFunctionTable[231446] = Chase_0x1e2060; // 0x1e2060 - g_ps2RecompiledFunctionTable[231455] = Chase_0x1e2060; // 0x1e2084 - g_ps2RecompiledFunctionTable[231457] = Chase_0x1e2060; // 0x1e208c - g_ps2RecompiledFunctionTable[231472] = Chase_0x1e2060; // 0x1e20c8 - g_ps2RecompiledFunctionTable[231477] = Chase_0x1e2060; // 0x1e20dc - g_ps2RecompiledFunctionTable[231482] = ps2___goalAng_0x1e20f0; // 0x1e20f0 - g_ps2RecompiledFunctionTable[231506] = ps2___goalAng_0x1e20f0; // 0x1e2150 - g_ps2RecompiledFunctionTable[231510] = ps2___goalAng_0x1e20f0; // 0x1e2160 - g_ps2RecompiledFunctionTable[231518] = _goalAng_0x1e2180; // 0x1e2180 - g_ps2RecompiledFunctionTable[231523] = _goalAng_0x1e2180; // 0x1e2194 - g_ps2RecompiledFunctionTable[231526] = _goalAng_0x1e2180; // 0x1e21a0 - g_ps2RecompiledFunctionTable[231531] = _goalAng_0x1e2180; // 0x1e21b4 - g_ps2RecompiledFunctionTable[231534] = _goalAng2_0x1e21c0; // 0x1e21c0 - g_ps2RecompiledFunctionTable[231539] = _goalAng2_0x1e21c0; // 0x1e21d4 - g_ps2RecompiledFunctionTable[231542] = _goalAng2_0x1e21c0; // 0x1e21e0 - g_ps2RecompiledFunctionTable[231545] = _goalAng2_0x1e21c0; // 0x1e21ec - g_ps2RecompiledFunctionTable[231550] = _goalAng2_0x1e21c0; // 0x1e2200 - g_ps2RecompiledFunctionTable[231554] = KeepFar_0x1e2210; // 0x1e2210 - g_ps2RecompiledFunctionTable[231559] = KeepFar_0x1e2210; // 0x1e2224 - g_ps2RecompiledFunctionTable[231575] = KeepFar_0x1e2210; // 0x1e2264 - g_ps2RecompiledFunctionTable[231580] = KeepFar_0x1e2210; // 0x1e2278 - g_ps2RecompiledFunctionTable[231589] = KeepFar_0x1e2210; // 0x1e229c - g_ps2RecompiledFunctionTable[231593] = KeepFar_0x1e2210; // 0x1e22ac - g_ps2RecompiledFunctionTable[231598] = KeepFar_0x1e2210; // 0x1e22c0 - g_ps2RecompiledFunctionTable[231602] = KeepFar_0x1e2210; // 0x1e22d0 - g_ps2RecompiledFunctionTable[231605] = KeepFar_0x1e2210; // 0x1e22dc - g_ps2RecompiledFunctionTable[231620] = KeepFar_0x1e2210; // 0x1e2318 - g_ps2RecompiledFunctionTable[231625] = KeepFar_0x1e2210; // 0x1e232c - g_ps2RecompiledFunctionTable[231630] = Attack_0x1e2340; // 0x1e2340 - g_ps2RecompiledFunctionTable[231657] = Attack_0x1e2340; // 0x1e23ac - g_ps2RecompiledFunctionTable[231716] = Attack_0x1e2340; // 0x1e2498 - g_ps2RecompiledFunctionTable[231782] = Attack_0x1e2340; // 0x1e25a0 - g_ps2RecompiledFunctionTable[231840] = Attack_0x1e2340; // 0x1e2688 - g_ps2RecompiledFunctionTable[231854] = Attack_0x1e2340; // 0x1e26c0 - g_ps2RecompiledFunctionTable[232031] = Attack_0x1e2340; // 0x1e2984 - g_ps2RecompiledFunctionTable[232279] = Attack_0x1e2340; // 0x1e2d64 - g_ps2RecompiledFunctionTable[232484] = Attack_0x1e2340; // 0x1e3098 - g_ps2RecompiledFunctionTable[232585] = Attack_0x1e2340; // 0x1e322c - g_ps2RecompiledFunctionTable[232588] = Attack_0x1e2340; // 0x1e3238 - g_ps2RecompiledFunctionTable[232592] = Attack_0x1e2340; // 0x1e3248 - g_ps2RecompiledFunctionTable[232611] = Attack_0x1e2340; // 0x1e3294 - g_ps2RecompiledFunctionTable[232619] = Attack_0x1e2340; // 0x1e32b4 - g_ps2RecompiledFunctionTable[232623] = Attack_0x1e2340; // 0x1e32c4 - g_ps2RecompiledFunctionTable[232696] = Attack_0x1e2340; // 0x1e33e8 - g_ps2RecompiledFunctionTable[232698] = Attack_0x1e2340; // 0x1e33f0 - g_ps2RecompiledFunctionTable[232706] = Attack_0x1e2340; // 0x1e3410 - g_ps2RecompiledFunctionTable[232729] = Attack_0x1e2340; // 0x1e346c - g_ps2RecompiledFunctionTable[232733] = Attack_0x1e2340; // 0x1e347c - g_ps2RecompiledFunctionTable[232768] = Attack_0x1e2340; // 0x1e3508 - g_ps2RecompiledFunctionTable[232791] = Attack_0x1e2340; // 0x1e3564 - g_ps2RecompiledFunctionTable[232798] = Attack_0x1e2340; // 0x1e3580 - g_ps2RecompiledFunctionTable[232819] = Attack_0x1e2340; // 0x1e35d4 - g_ps2RecompiledFunctionTable[232823] = Attack_0x1e2340; // 0x1e35e4 - g_ps2RecompiledFunctionTable[232826] = Attack_0x1e2340; // 0x1e35f0 - g_ps2RecompiledFunctionTable[232837] = Attack_0x1e2340; // 0x1e361c - g_ps2RecompiledFunctionTable[232859] = Attack_0x1e2340; // 0x1e3674 - g_ps2RecompiledFunctionTable[232907] = Attack_0x1e2340; // 0x1e3734 - g_ps2RecompiledFunctionTable[233028] = Attack_0x1e2340; // 0x1e3918 - g_ps2RecompiledFunctionTable[233032] = Attack_0x1e2340; // 0x1e3928 - g_ps2RecompiledFunctionTable[233035] = Attack_0x1e2340; // 0x1e3934 - g_ps2RecompiledFunctionTable[233052] = Attack_0x1e2340; // 0x1e3978 - g_ps2RecompiledFunctionTable[233109] = Attack_0x1e2340; // 0x1e3a5c - g_ps2RecompiledFunctionTable[233149] = Attack_0x1e2340; // 0x1e3afc - g_ps2RecompiledFunctionTable[233163] = Attack_0x1e2340; // 0x1e3b34 - g_ps2RecompiledFunctionTable[233176] = Attack_0x1e2340; // 0x1e3b68 - g_ps2RecompiledFunctionTable[233186] = Throw_0x1e3b90; // 0x1e3b90 - g_ps2RecompiledFunctionTable[233202] = Throw_0x1e3b90; // 0x1e3bd0 - g_ps2RecompiledFunctionTable[233220] = Throw_0x1e3b90; // 0x1e3c18 - g_ps2RecompiledFunctionTable[233239] = Throw_0x1e3b90; // 0x1e3c64 - g_ps2RecompiledFunctionTable[233244] = Throw_0x1e3b90; // 0x1e3c78 - g_ps2RecompiledFunctionTable[233249] = Throw_0x1e3b90; // 0x1e3c8c - g_ps2RecompiledFunctionTable[233264] = Throw_0x1e3b90; // 0x1e3cc8 - g_ps2RecompiledFunctionTable[233284] = Throw_0x1e3b90; // 0x1e3d18 - g_ps2RecompiledFunctionTable[233289] = Throw_0x1e3b90; // 0x1e3d2c - g_ps2RecompiledFunctionTable[233294] = Throw_0x1e3b90; // 0x1e3d40 - g_ps2RecompiledFunctionTable[233305] = Throw_0x1e3b90; // 0x1e3d6c - g_ps2RecompiledFunctionTable[233323] = Throw_0x1e3b90; // 0x1e3db4 - g_ps2RecompiledFunctionTable[233372] = Throw_0x1e3b90; // 0x1e3e78 - g_ps2RecompiledFunctionTable[233407] = Throw_0x1e3b90; // 0x1e3f04 - g_ps2RecompiledFunctionTable[233412] = Throw_0x1e3b90; // 0x1e3f18 - g_ps2RecompiledFunctionTable[233415] = Throw_0x1e3b90; // 0x1e3f24 - g_ps2RecompiledFunctionTable[233442] = Throw_0x1e3b90; // 0x1e3f90 - g_ps2RecompiledFunctionTable[233448] = Throw_0x1e3b90; // 0x1e3fa8 - g_ps2RecompiledFunctionTable[233455] = Throw_0x1e3b90; // 0x1e3fc4 - g_ps2RecompiledFunctionTable[233458] = Throw_0x1e3b90; // 0x1e3fd0 - g_ps2RecompiledFunctionTable[233463] = Throw_0x1e3b90; // 0x1e3fe4 - g_ps2RecompiledFunctionTable[233492] = Throw_0x1e3b90; // 0x1e4058 - g_ps2RecompiledFunctionTable[233497] = Throw_0x1e3b90; // 0x1e406c - g_ps2RecompiledFunctionTable[233501] = Throw_0x1e3b90; // 0x1e407c - g_ps2RecompiledFunctionTable[233503] = Throw_0x1e3b90; // 0x1e4084 - g_ps2RecompiledFunctionTable[233519] = Throw_0x1e3b90; // 0x1e40c4 - g_ps2RecompiledFunctionTable[233524] = Throw_0x1e3b90; // 0x1e40d8 - g_ps2RecompiledFunctionTable[233530] = Throw_0x1e3b90; // 0x1e40f0 - g_ps2RecompiledFunctionTable[233535] = Throw_0x1e3b90; // 0x1e4104 - g_ps2RecompiledFunctionTable[233549] = Throw_0x1e3b90; // 0x1e413c - g_ps2RecompiledFunctionTable[233556] = Throw_0x1e3b90; // 0x1e4158 - g_ps2RecompiledFunctionTable[233567] = Throw_0x1e3b90; // 0x1e4184 - g_ps2RecompiledFunctionTable[233603] = Throw_0x1e3b90; // 0x1e4214 - g_ps2RecompiledFunctionTable[233618] = Throw_0x1e3b90; // 0x1e4250 - g_ps2RecompiledFunctionTable[233626] = Damage_0x1e4270; // 0x1e4270 - g_ps2RecompiledFunctionTable[233672] = Damage_0x1e4270; // 0x1e4328 - g_ps2RecompiledFunctionTable[233692] = Damage_0x1e4270; // 0x1e4378 - g_ps2RecompiledFunctionTable[233698] = Die_0x1e4390; // 0x1e4390 - g_ps2RecompiledFunctionTable[233717] = Die_0x1e4390; // 0x1e43dc - g_ps2RecompiledFunctionTable[233720] = Die_0x1e4390; // 0x1e43e8 - g_ps2RecompiledFunctionTable[233730] = Die_0x1e4390; // 0x1e4410 - g_ps2RecompiledFunctionTable[233814] = NearestCapsule_0x1e4560; // 0x1e4560 - g_ps2RecompiledFunctionTable[233834] = NearestCapsule_0x1e4560; // 0x1e45b0 - g_ps2RecompiledFunctionTable[233913] = NearestCapsule_0x1e4560; // 0x1e46ec - g_ps2RecompiledFunctionTable[233942] = NearestCapsule_0x1e4560; // 0x1e4760 - g_ps2RecompiledFunctionTable[234018] = CheckDamage_0x1e4890; // 0x1e4890 - g_ps2RecompiledFunctionTable[234032] = CheckDamage_0x1e4890; // 0x1e48c8 - g_ps2RecompiledFunctionTable[234066] = CheckDamage_0x1e4890; // 0x1e4950 - g_ps2RecompiledFunctionTable[234069] = CheckDamage_0x1e4890; // 0x1e495c - g_ps2RecompiledFunctionTable[234071] = CheckDamage_0x1e4890; // 0x1e4964 - g_ps2RecompiledFunctionTable[234120] = CheckDamage_0x1e4890; // 0x1e4a28 - g_ps2RecompiledFunctionTable[234167] = CheckDamage_0x1e4890; // 0x1e4ae4 - g_ps2RecompiledFunctionTable[234181] = CheckDamage_0x1e4890; // 0x1e4b1c - g_ps2RecompiledFunctionTable[234193] = CheckDamage_0x1e4890; // 0x1e4b4c - g_ps2RecompiledFunctionTable[234209] = CheckDamage_0x1e4890; // 0x1e4b8c - g_ps2RecompiledFunctionTable[234221] = CheckDamage_0x1e4890; // 0x1e4bbc - g_ps2RecompiledFunctionTable[234229] = CheckDamage_0x1e4890; // 0x1e4bdc - g_ps2RecompiledFunctionTable[234236] = CheckDamage_0x1e4890; // 0x1e4bf8 - g_ps2RecompiledFunctionTable[234240] = CheckDamage_0x1e4890; // 0x1e4c08 - g_ps2RecompiledFunctionTable[234250] = CheckDamage_0x1e4890; // 0x1e4c30 - g_ps2RecompiledFunctionTable[234257] = CheckDamage_0x1e4890; // 0x1e4c4c - g_ps2RecompiledFunctionTable[234270] = CheckDamage_0x1e4890; // 0x1e4c80 - g_ps2RecompiledFunctionTable[234312] = CheckDamage_0x1e4890; // 0x1e4d28 - g_ps2RecompiledFunctionTable[234321] = CheckDamage_0x1e4890; // 0x1e4d4c - g_ps2RecompiledFunctionTable[234333] = CheckDamage_0x1e4890; // 0x1e4d7c - g_ps2RecompiledFunctionTable[234342] = CheckDamage_0x1e4890; // 0x1e4da0 - g_ps2RecompiledFunctionTable[234404] = CheckDamage_0x1e4890; // 0x1e4e98 - g_ps2RecompiledFunctionTable[234427] = CheckDamage_0x1e4890; // 0x1e4ef4 - g_ps2RecompiledFunctionTable[234454] = CheckDamage_0x1e4890; // 0x1e4f60 - g_ps2RecompiledFunctionTable[234478] = CheckDamage_0x1e4890; // 0x1e4fc0 - g_ps2RecompiledFunctionTable[234500] = CheckDamage_0x1e4890; // 0x1e5018 - g_ps2RecompiledFunctionTable[234560] = CheckDamage_0x1e4890; // 0x1e5108 - g_ps2RecompiledFunctionTable[234569] = CheckDamage_0x1e4890; // 0x1e512c - g_ps2RecompiledFunctionTable[234575] = CheckDamage_0x1e4890; // 0x1e5144 - g_ps2RecompiledFunctionTable[234582] = GetRelay_0x1e5160; // 0x1e5160 - g_ps2RecompiledFunctionTable[234589] = GetRelay_0x1e5160; // 0x1e517c - g_ps2RecompiledFunctionTable[234632] = GetRelay_0x1e5160; // 0x1e5228 - g_ps2RecompiledFunctionTable[234678] = SetMtn_0x1e52e0; // 0x1e52e0 - g_ps2RecompiledFunctionTable[234688] = SetMtn_0x1e52e0; // 0x1e5308 - g_ps2RecompiledFunctionTable[234705] = SetMtn_0x1e52e0; // 0x1e534c - g_ps2RecompiledFunctionTable[234716] = SetMtn_0x1e52e0; // 0x1e5378 - g_ps2RecompiledFunctionTable[234753] = SetMtn_0x1e52e0; // 0x1e540c - g_ps2RecompiledFunctionTable[234774] = SetMtn_0x1e52e0; // 0x1e5460 - g_ps2RecompiledFunctionTable[234778] = ReqMtn_0x1e5470; // 0x1e5470 - g_ps2RecompiledFunctionTable[234782] = SetPlyMtn_0x1e5480; // 0x1e5480 - g_ps2RecompiledFunctionTable[234808] = SetPlyMtn_0x1e5480; // 0x1e54e8 - g_ps2RecompiledFunctionTable[234854] = VacumeToPoint_0x1e55a0; // 0x1e55a0 - g_ps2RecompiledFunctionTable[234869] = VacumeToPoint_0x1e55a0; // 0x1e55dc - g_ps2RecompiledFunctionTable[234871] = VacumeToPoint_0x1e55a0; // 0x1e55e4 - g_ps2RecompiledFunctionTable[234878] = VacumeToPoint_0x1e55a0; // 0x1e5600 - g_ps2RecompiledFunctionTable[234893] = VacumeToPoint_0x1e55a0; // 0x1e563c - g_ps2RecompiledFunctionTable[234910] = LockLeg_0x1e5680; // 0x1e5680 - g_ps2RecompiledFunctionTable[234917] = LockLeg_0x1e5680; // 0x1e569c - g_ps2RecompiledFunctionTable[234933] = LockLeg_0x1e5680; // 0x1e56dc - g_ps2RecompiledFunctionTable[234969] = LockLeg_0x1e5680; // 0x1e576c - g_ps2RecompiledFunctionTable[234974] = LockLeg_0x1e5680; // 0x1e5780 - g_ps2RecompiledFunctionTable[234994] = bhEne15_AttackPlayerCC_0x1e57d0; // 0x1e57d0 - g_ps2RecompiledFunctionTable[235012] = bhEne15_AttackPlayerCC_0x1e57d0; // 0x1e5818 - g_ps2RecompiledFunctionTable[235038] = bhEne15_AttackPlayerCC_0x1e57d0; // 0x1e5880 - g_ps2RecompiledFunctionTable[235056] = bhEne15_AttackPlayerCC_0x1e57d0; // 0x1e58c8 - g_ps2RecompiledFunctionTable[235062] = bhEne15_AttackPlayerCC_0x1e57d0; // 0x1e58e0 - g_ps2RecompiledFunctionTable[235081] = bhEne15_AttackPlayerCC_0x1e57d0; // 0x1e592c - g_ps2RecompiledFunctionTable[235086] = bhEne15_AttackPlayerCC_0x1e57d0; // 0x1e5940 - g_ps2RecompiledFunctionTable[235092] = bhEne15_AttackPlayerCC_0x1e57d0; // 0x1e5958 - g_ps2RecompiledFunctionTable[235097] = bhEne15_AttackPlayerCC_0x1e57d0; // 0x1e596c - g_ps2RecompiledFunctionTable[235158] = bhEne15_AttackPlayerBC_0x1e5a60; // 0x1e5a60 - g_ps2RecompiledFunctionTable[235176] = bhEne15_AttackPlayerBC_0x1e5a60; // 0x1e5aa8 - g_ps2RecompiledFunctionTable[235214] = bhEne15_AttackPlayerBC_0x1e5a60; // 0x1e5b40 - g_ps2RecompiledFunctionTable[235232] = bhEne15_AttackPlayerBC_0x1e5a60; // 0x1e5b88 - g_ps2RecompiledFunctionTable[235238] = bhEne15_AttackPlayerBC_0x1e5a60; // 0x1e5ba0 - g_ps2RecompiledFunctionTable[235257] = bhEne15_AttackPlayerBC_0x1e5a60; // 0x1e5bec - g_ps2RecompiledFunctionTable[235262] = bhEne15_AttackPlayerBC_0x1e5a60; // 0x1e5c00 - g_ps2RecompiledFunctionTable[235268] = bhEne15_AttackPlayerBC_0x1e5a60; // 0x1e5c18 - g_ps2RecompiledFunctionTable[235273] = bhEne15_AttackPlayerBC_0x1e5a60; // 0x1e5c2c - g_ps2RecompiledFunctionTable[235334] = bhEne15_AttackPlayerSS_0x1e5d20; // 0x1e5d20 - g_ps2RecompiledFunctionTable[235361] = bhEne15_AttackPlayerSS_0x1e5d20; // 0x1e5d8c - g_ps2RecompiledFunctionTable[235366] = bhEne15_AttackPlayerSS_0x1e5d20; // 0x1e5da0 - g_ps2RecompiledFunctionTable[235371] = bhEne15_AttackPlayerSS_0x1e5d20; // 0x1e5db4 - g_ps2RecompiledFunctionTable[235377] = bhEne15_AttackPlayerSS_0x1e5d20; // 0x1e5dcc - g_ps2RecompiledFunctionTable[235382] = bhEne15_AttackPlayerSS_0x1e5d20; // 0x1e5de0 - g_ps2RecompiledFunctionTable[235430] = SetSmoke_0x1e5ea0; // 0x1e5ea0 - g_ps2RecompiledFunctionTable[235486] = SpecialAttack_0x1e5f80; // 0x1e5f80 - g_ps2RecompiledFunctionTable[235516] = SpecialAttack_0x1e5f80; // 0x1e5ff8 - g_ps2RecompiledFunctionTable[235547] = SpecialAttack_0x1e5f80; // 0x1e6074 - g_ps2RecompiledFunctionTable[235606] = _bhEne_SetPoison_0x1e6160; // 0x1e6160 - g_ps2RecompiledFunctionTable[235685] = _bhEne_SetPoison_0x1e6160; // 0x1e629c - g_ps2RecompiledFunctionTable[235810] = _bhEne_SetPoison_0x1e6160; // 0x1e6490 - g_ps2RecompiledFunctionTable[235960] = _bhEne_SetPoison_0x1e6160; // 0x1e66e8 - g_ps2RecompiledFunctionTable[236042] = _bhEne_SetPoison2_0x1e6830; // 0x1e6830 - g_ps2RecompiledFunctionTable[236083] = _bhEne_SetPoison2_0x1e6830; // 0x1e68d4 - g_ps2RecompiledFunctionTable[236137] = _bhEne_SetPoison2_0x1e6830; // 0x1e69ac - g_ps2RecompiledFunctionTable[236186] = bhEne_SetPoison_0x1e6a70; // 0x1e6a70 - g_ps2RecompiledFunctionTable[236232] = bhEne_SetPoison_0x1e6a70; // 0x1e6b28 - g_ps2RecompiledFunctionTable[236235] = bhEne_SetPoison_0x1e6a70; // 0x1e6b34 - g_ps2RecompiledFunctionTable[236240] = bhEne_SetPoison_0x1e6a70; // 0x1e6b48 - g_ps2RecompiledFunctionTable[236245] = bhEne_SetPoison_0x1e6a70; // 0x1e6b5c - g_ps2RecompiledFunctionTable[236253] = bhEne_SetPoison_0x1e6a70; // 0x1e6b7c - g_ps2RecompiledFunctionTable[236269] = bhEne_SetPoison_0x1e6a70; // 0x1e6bbc - g_ps2RecompiledFunctionTable[236298] = bhEne_SetPoison_0x1e6a70; // 0x1e6c30 - g_ps2RecompiledFunctionTable[236306] = PoisonAttack_0x1e6c50; // 0x1e6c50 - g_ps2RecompiledFunctionTable[236340] = PoisonAttack_0x1e6c50; // 0x1e6cd8 - g_ps2RecompiledFunctionTable[236349] = PoisonAttack_0x1e6c50; // 0x1e6cfc - g_ps2RecompiledFunctionTable[236371] = PoisonAttack_0x1e6c50; // 0x1e6d54 - g_ps2RecompiledFunctionTable[236383] = PoisonAttack_0x1e6c50; // 0x1e6d84 - g_ps2RecompiledFunctionTable[236391] = PoisonAttack_0x1e6c50; // 0x1e6da4 - g_ps2RecompiledFunctionTable[236434] = AddWindForce_0x1e6e50; // 0x1e6e50 - g_ps2RecompiledFunctionTable[236446] = AddWindForce_0x1e6e50; // 0x1e6e80 - g_ps2RecompiledFunctionTable[236460] = AddWindForce_0x1e6e50; // 0x1e6eb8 - g_ps2RecompiledFunctionTable[236473] = AddWindForce_0x1e6e50; // 0x1e6eec - g_ps2RecompiledFunctionTable[236487] = AddWindForce_0x1e6e50; // 0x1e6f24 - g_ps2RecompiledFunctionTable[236499] = AddWindForce_0x1e6e50; // 0x1e6f54 - g_ps2RecompiledFunctionTable[236502] = AddWindForce_0x1e6e50; // 0x1e6f60 - g_ps2RecompiledFunctionTable[236505] = AddWindForce_0x1e6e50; // 0x1e6f6c - g_ps2RecompiledFunctionTable[236510] = bhEff_E15_Poison_0x1e6f80; // 0x1e6f80 - g_ps2RecompiledFunctionTable[236576] = bhEff_E15_Poison_0x1e6f80; // 0x1e7088 - g_ps2RecompiledFunctionTable[236581] = bhEff_E15_Poison_0x1e6f80; // 0x1e709c - g_ps2RecompiledFunctionTable[236593] = bhEff_E15_Poison_0x1e6f80; // 0x1e70cc - g_ps2RecompiledFunctionTable[236633] = bhEff_E15_Poison_0x1e6f80; // 0x1e716c - g_ps2RecompiledFunctionTable[236645] = bhEff_E15_Poison_0x1e6f80; // 0x1e719c - g_ps2RecompiledFunctionTable[236649] = bhEff_E15_Poison_0x1e6f80; // 0x1e71ac - g_ps2RecompiledFunctionTable[236653] = bhEff_E15_Poison_0x1e6f80; // 0x1e71bc - g_ps2RecompiledFunctionTable[236655] = bhEff_E15_Poison_0x1e6f80; // 0x1e71c4 - g_ps2RecompiledFunctionTable[236659] = bhEff_E15_Poison_0x1e6f80; // 0x1e71d4 - g_ps2RecompiledFunctionTable[236671] = bhEff_E15_Poison_0x1e6f80; // 0x1e7204 - g_ps2RecompiledFunctionTable[236675] = bhEff_E15_Poison_0x1e6f80; // 0x1e7214 - g_ps2RecompiledFunctionTable[236679] = bhEff_E15_Poison_0x1e6f80; // 0x1e7224 - g_ps2RecompiledFunctionTable[236681] = bhEff_E15_Poison_0x1e6f80; // 0x1e722c - g_ps2RecompiledFunctionTable[236685] = bhEff_E15_Poison_0x1e6f80; // 0x1e723c - g_ps2RecompiledFunctionTable[236697] = bhEff_E15_Poison_0x1e6f80; // 0x1e726c - g_ps2RecompiledFunctionTable[236701] = bhEff_E15_Poison_0x1e6f80; // 0x1e727c - g_ps2RecompiledFunctionTable[236705] = bhEff_E15_Poison_0x1e6f80; // 0x1e728c - g_ps2RecompiledFunctionTable[236707] = bhEff_E15_Poison_0x1e6f80; // 0x1e7294 - g_ps2RecompiledFunctionTable[236715] = bhEff_E15_Poison_0x1e6f80; // 0x1e72b4 - g_ps2RecompiledFunctionTable[236741] = bhEff_E15_Poison_0x1e6f80; // 0x1e731c - g_ps2RecompiledFunctionTable[236753] = bhEff_E15_Poison_0x1e6f80; // 0x1e734c - g_ps2RecompiledFunctionTable[236761] = bhEff_E15_Poison_0x1e6f80; // 0x1e736c - g_ps2RecompiledFunctionTable[236765] = bhEff_E15_Poison_0x1e6f80; // 0x1e737c - g_ps2RecompiledFunctionTable[236777] = bhEff_E15_Poison_0x1e6f80; // 0x1e73ac - g_ps2RecompiledFunctionTable[236786] = bhEff_E15_Poison_0x1e6f80; // 0x1e73d0 - g_ps2RecompiledFunctionTable[236790] = bhEff_E15_Poison_0x1e6f80; // 0x1e73e0 - g_ps2RecompiledFunctionTable[236803] = bhEff_E15_Poison_0x1e6f80; // 0x1e7414 - g_ps2RecompiledFunctionTable[236816] = bhEff_E15_Poison_0x1e6f80; // 0x1e7448 - g_ps2RecompiledFunctionTable[236833] = bhEff_E15_Poison_0x1e6f80; // 0x1e748c - g_ps2RecompiledFunctionTable[236852] = bhEff_E15_Poison_0x1e6f80; // 0x1e74d8 - g_ps2RecompiledFunctionTable[236869] = bhEff_E15_Poison_0x1e6f80; // 0x1e751c - g_ps2RecompiledFunctionTable[236883] = bhEff_E15_Poison_0x1e6f80; // 0x1e7554 - g_ps2RecompiledFunctionTable[236895] = bhEff_E15_Poison_0x1e6f80; // 0x1e7584 - g_ps2RecompiledFunctionTable[236903] = bhEff_E15_Poison_0x1e6f80; // 0x1e75a4 - g_ps2RecompiledFunctionTable[236907] = bhEff_E15_Poison_0x1e6f80; // 0x1e75b4 - g_ps2RecompiledFunctionTable[236919] = bhEff_E15_Poison_0x1e6f80; // 0x1e75e4 - g_ps2RecompiledFunctionTable[236928] = bhEff_E15_Poison_0x1e6f80; // 0x1e7608 - g_ps2RecompiledFunctionTable[236932] = bhEff_E15_Poison_0x1e6f80; // 0x1e7618 - g_ps2RecompiledFunctionTable[236945] = bhEff_E15_Poison_0x1e6f80; // 0x1e764c - g_ps2RecompiledFunctionTable[236958] = bhEff_E15_Poison_0x1e6f80; // 0x1e7680 - g_ps2RecompiledFunctionTable[236975] = bhEff_E15_Poison_0x1e6f80; // 0x1e76c4 - g_ps2RecompiledFunctionTable[236997] = bhEff_E15_Poison_0x1e6f80; // 0x1e771c - g_ps2RecompiledFunctionTable[237014] = bhEff_E15_Poison_0x1e6f80; // 0x1e7760 - g_ps2RecompiledFunctionTable[237027] = bhEff_E15_Poison_0x1e6f80; // 0x1e7794 - g_ps2RecompiledFunctionTable[237040] = bhEff_E15_Poison_0x1e6f80; // 0x1e77c8 - g_ps2RecompiledFunctionTable[237226] = bhEne15_RotChar_0x1e7ab0; // 0x1e7ab0 - g_ps2RecompiledFunctionTable[237258] = AbleToFall_0x1e7b30; // 0x1e7b30 - g_ps2RecompiledFunctionTable[237294] = ps2__DrivePlayer_0x1e7bc0; // 0x1e7bc0 - g_ps2RecompiledFunctionTable[237311] = ps2__DrivePlayer_0x1e7bc0; // 0x1e7c04 - g_ps2RecompiledFunctionTable[237322] = ps2__DrivePlayer_0x1e7bc0; // 0x1e7c30 - g_ps2RecompiledFunctionTable[237332] = ps2__DrivePlayer_0x1e7bc0; // 0x1e7c58 - g_ps2RecompiledFunctionTable[237339] = ps2__DrivePlayer_0x1e7bc0; // 0x1e7c74 - g_ps2RecompiledFunctionTable[237341] = ps2__DrivePlayer_0x1e7bc0; // 0x1e7c7c - g_ps2RecompiledFunctionTable[237348] = ps2__DrivePlayer_0x1e7bc0; // 0x1e7c98 - g_ps2RecompiledFunctionTable[237355] = ps2__DrivePlayer_0x1e7bc0; // 0x1e7cb4 - g_ps2RecompiledFunctionTable[237357] = ps2__DrivePlayer_0x1e7bc0; // 0x1e7cbc - g_ps2RecompiledFunctionTable[237396] = ps2__DrivePlayer_0x1e7bc0; // 0x1e7d58 - g_ps2RecompiledFunctionTable[237414] = ps2__DrivePlayer_0x1e7bc0; // 0x1e7da0 - g_ps2RecompiledFunctionTable[237470] = DrivePlayer_0x1e7e80; // 0x1e7e80 - g_ps2RecompiledFunctionTable[237480] = DrivePlayer_0x1e7e80; // 0x1e7ea8 - g_ps2RecompiledFunctionTable[237482] = DrivePlayer_0x1e7e80; // 0x1e7eb0 - g_ps2RecompiledFunctionTable[237550] = DrivePlayer_0x1e7e80; // 0x1e7fc0 - g_ps2RecompiledFunctionTable[237601] = DrivePlayer_0x1e7e80; // 0x1e808c - g_ps2RecompiledFunctionTable[237607] = DrivePlayer_0x1e7e80; // 0x1e80a4 - g_ps2RecompiledFunctionTable[237614] = DrivePlayer_0x1e7e80; // 0x1e80c0 - g_ps2RecompiledFunctionTable[237617] = DrivePlayer_0x1e7e80; // 0x1e80cc - g_ps2RecompiledFunctionTable[237640] = DrivePlayer_0x1e7e80; // 0x1e8128 - g_ps2RecompiledFunctionTable[237652] = DrivePlayer_0x1e7e80; // 0x1e8158 - g_ps2RecompiledFunctionTable[237655] = DrivePlayer_0x1e7e80; // 0x1e8164 - g_ps2RecompiledFunctionTable[237694] = FallingPlayer_0x1e8200; // 0x1e8200 - g_ps2RecompiledFunctionTable[237703] = FallingPlayer_0x1e8200; // 0x1e8224 - g_ps2RecompiledFunctionTable[237708] = FallingPlayer_0x1e8200; // 0x1e8238 - g_ps2RecompiledFunctionTable[237764] = FallingPlayer_0x1e8200; // 0x1e8318 - g_ps2RecompiledFunctionTable[237818] = SlidePlayer_0x1e83f0; // 0x1e83f0 - g_ps2RecompiledFunctionTable[237826] = SlidePlayer_0x1e83f0; // 0x1e8410 - g_ps2RecompiledFunctionTable[237869] = SlidePlayer_0x1e83f0; // 0x1e84bc - g_ps2RecompiledFunctionTable[237908] = SlidePlayer_0x1e83f0; // 0x1e8558 - g_ps2RecompiledFunctionTable[237912] = SlidePlayer_0x1e83f0; // 0x1e8568 - g_ps2RecompiledFunctionTable[237941] = SlidePlayer_0x1e83f0; // 0x1e85dc - g_ps2RecompiledFunctionTable[237953] = SlidePlayer_0x1e83f0; // 0x1e860c - g_ps2RecompiledFunctionTable[237961] = SlidePlayer_0x1e83f0; // 0x1e862c - g_ps2RecompiledFunctionTable[237969] = SlidePlayer_0x1e83f0; // 0x1e864c - g_ps2RecompiledFunctionTable[237988] = SlidePlayer_0x1e83f0; // 0x1e8698 - g_ps2RecompiledFunctionTable[237990] = SlidePlayer_0x1e83f0; // 0x1e86a0 - g_ps2RecompiledFunctionTable[238043] = SlidePlayer_0x1e83f0; // 0x1e8774 - g_ps2RecompiledFunctionTable[238113] = SlidePlayer_0x1e83f0; // 0x1e888c - g_ps2RecompiledFunctionTable[238116] = SlidePlayer_0x1e83f0; // 0x1e8898 - g_ps2RecompiledFunctionTable[238134] = StandupPlayer_0x1e88e0; // 0x1e88e0 - g_ps2RecompiledFunctionTable[238170] = StandupPlayer_0x1e88e0; // 0x1e8970 - g_ps2RecompiledFunctionTable[238177] = StandupPlayer_0x1e88e0; // 0x1e898c - g_ps2RecompiledFunctionTable[238226] = HoldPlayer_0x1e8a50; // 0x1e8a50 - g_ps2RecompiledFunctionTable[238240] = HoldPlayer_0x1e8a50; // 0x1e8a88 - g_ps2RecompiledFunctionTable[238252] = HoldPlayer_0x1e8a50; // 0x1e8ab8 - g_ps2RecompiledFunctionTable[238257] = HoldPlayer_0x1e8a50; // 0x1e8acc - g_ps2RecompiledFunctionTable[238262] = HoldPlayer_0x1e8a50; // 0x1e8ae0 - g_ps2RecompiledFunctionTable[238265] = HoldPlayer_0x1e8a50; // 0x1e8aec - g_ps2RecompiledFunctionTable[238270] = HoldPlayer_0x1e8a50; // 0x1e8b00 - g_ps2RecompiledFunctionTable[238275] = HoldPlayer_0x1e8a50; // 0x1e8b14 - g_ps2RecompiledFunctionTable[238293] = HoldPlayer_0x1e8a50; // 0x1e8b5c - g_ps2RecompiledFunctionTable[238297] = HoldPlayer_0x1e8a50; // 0x1e8b6c - g_ps2RecompiledFunctionTable[238302] = FlyingPlayer_0x1e8b80; // 0x1e8b80 - g_ps2RecompiledFunctionTable[238316] = FlyingPlayer_0x1e8b80; // 0x1e8bb8 - g_ps2RecompiledFunctionTable[238335] = FlyingPlayer_0x1e8b80; // 0x1e8c04 - g_ps2RecompiledFunctionTable[238338] = FlyingPlayer_0x1e8b80; // 0x1e8c10 - g_ps2RecompiledFunctionTable[238350] = FallDiePlayer_0x1e8c40; // 0x1e8c40 - g_ps2RecompiledFunctionTable[238404] = FallDiePlayer_0x1e8c40; // 0x1e8d18 - g_ps2RecompiledFunctionTable[238407] = FallDiePlayer_0x1e8c40; // 0x1e8d24 - g_ps2RecompiledFunctionTable[238434] = DiePlayer_0x1e8d90; // 0x1e8d90 - g_ps2RecompiledFunctionTable[238444] = DiePlayer_0x1e8d90; // 0x1e8db8 - g_ps2RecompiledFunctionTable[238490] = ChangeAmbient_0x1e8e70; // 0x1e8e70 - g_ps2RecompiledFunctionTable[238503] = ChangeAmbient_0x1e8e70; // 0x1e8ea4 - g_ps2RecompiledFunctionTable[238578] = SetMince_0x1e8fd0; // 0x1e8fd0 - g_ps2RecompiledFunctionTable[238615] = SetMince_0x1e8fd0; // 0x1e9064 - g_ps2RecompiledFunctionTable[238654] = SetMince_0x1e8fd0; // 0x1e9100 - g_ps2RecompiledFunctionTable[238657] = SetMince_0x1e8fd0; // 0x1e910c - g_ps2RecompiledFunctionTable[238660] = SetMince_0x1e8fd0; // 0x1e9118 - g_ps2RecompiledFunctionTable[238677] = SetMince_0x1e8fd0; // 0x1e915c - g_ps2RecompiledFunctionTable[238691] = SetMince_0x1e8fd0; // 0x1e9194 - g_ps2RecompiledFunctionTable[238730] = CoreInit_0x1e9230; // 0x1e9230 - g_ps2RecompiledFunctionTable[238769] = CoreInit_0x1e9230; // 0x1e92cc - g_ps2RecompiledFunctionTable[238774] = CoreInit_0x1e9230; // 0x1e92e0 - g_ps2RecompiledFunctionTable[238779] = CoreInit_0x1e9230; // 0x1e92f4 - g_ps2RecompiledFunctionTable[238798] = CoreMove_0x1e9340; // 0x1e9340 - g_ps2RecompiledFunctionTable[238918] = CoreDie_0x1e9520; // 0x1e9520 - g_ps2RecompiledFunctionTable[239105] = CoreDie_0x1e9520; // 0x1e980c - g_ps2RecompiledFunctionTable[239111] = CoreDie_0x1e9520; // 0x1e9824 - g_ps2RecompiledFunctionTable[239243] = CoreDie_0x1e9520; // 0x1e9a34 - g_ps2RecompiledFunctionTable[239250] = CoreDie_0x1e9520; // 0x1e9a50 - g_ps2RecompiledFunctionTable[239259] = CoreDie_0x1e9520; // 0x1e9a74 - g_ps2RecompiledFunctionTable[239263] = CoreDie_0x1e9520; // 0x1e9a84 - g_ps2RecompiledFunctionTable[239264] = CoreDie_0x1e9520; // 0x1e9a88 - g_ps2RecompiledFunctionTable[239266] = CoreDie_0x1e9520; // 0x1e9a90 - g_ps2RecompiledFunctionTable[239278] = CoreDie_0x1e9520; // 0x1e9ac0 - g_ps2RecompiledFunctionTable[239282] = CoreDie_0x1e9520; // 0x1e9ad0 - g_ps2RecompiledFunctionTable[239286] = CoreDie_0x1e9520; // 0x1e9ae0 - g_ps2RecompiledFunctionTable[239288] = CoreDie_0x1e9520; // 0x1e9ae8 - g_ps2RecompiledFunctionTable[239292] = CoreDie_0x1e9520; // 0x1e9af8 - g_ps2RecompiledFunctionTable[239304] = CoreDie_0x1e9520; // 0x1e9b28 - g_ps2RecompiledFunctionTable[239308] = CoreDie_0x1e9520; // 0x1e9b38 - g_ps2RecompiledFunctionTable[239312] = CoreDie_0x1e9520; // 0x1e9b48 - g_ps2RecompiledFunctionTable[239314] = CoreDie_0x1e9520; // 0x1e9b50 - g_ps2RecompiledFunctionTable[239318] = CoreDie_0x1e9520; // 0x1e9b60 - g_ps2RecompiledFunctionTable[239330] = CoreDie_0x1e9520; // 0x1e9b90 - g_ps2RecompiledFunctionTable[239334] = CoreDie_0x1e9520; // 0x1e9ba0 - g_ps2RecompiledFunctionTable[239338] = CoreDie_0x1e9520; // 0x1e9bb0 - g_ps2RecompiledFunctionTable[239340] = CoreDie_0x1e9520; // 0x1e9bb8 - g_ps2RecompiledFunctionTable[239347] = CoreDie_0x1e9520; // 0x1e9bd4 - g_ps2RecompiledFunctionTable[239355] = CoreDie_0x1e9520; // 0x1e9bf4 - g_ps2RecompiledFunctionTable[239360] = CoreDie_0x1e9520; // 0x1e9c08 - g_ps2RecompiledFunctionTable[239370] = bhEne53_0x1e9c30; // 0x1e9c30 - g_ps2RecompiledFunctionTable[239389] = bhEne53_0x1e9c30; // 0x1e9c7c - g_ps2RecompiledFunctionTable[239392] = bhEne53_0x1e9c30; // 0x1e9c88 - g_ps2RecompiledFunctionTable[239396] = bhEne53_0x1e9c30; // 0x1e9c98 - g_ps2RecompiledFunctionTable[239400] = bhEne53_0x1e9c30; // 0x1e9ca8 - g_ps2RecompiledFunctionTable[239406] = bhEne16_0x1e9cc0; // 0x1e9cc0 - g_ps2RecompiledFunctionTable[239407] = bhEne16_0x1e9cc0; // 0x1e9cc4 - g_ps2RecompiledFunctionTable[239408] = bhEne16_0x1e9cc0; // 0x1e9cc8 - g_ps2RecompiledFunctionTable[239409] = bhEne16_0x1e9cc0; // 0x1e9ccc - g_ps2RecompiledFunctionTable[239410] = bhEne16_0x1e9cc0; // 0x1e9cd0 - g_ps2RecompiledFunctionTable[239411] = bhEne16_0x1e9cc0; // 0x1e9cd4 - g_ps2RecompiledFunctionTable[239412] = bhEne16_0x1e9cc0; // 0x1e9cd8 - g_ps2RecompiledFunctionTable[239413] = bhEne16_0x1e9cc0; // 0x1e9cdc - g_ps2RecompiledFunctionTable[239414] = bhEne16_0x1e9cc0; // 0x1e9ce0 - g_ps2RecompiledFunctionTable[239415] = bhEne16_0x1e9cc0; // 0x1e9ce4 - g_ps2RecompiledFunctionTable[239416] = bhEne16_0x1e9cc0; // 0x1e9ce8 - g_ps2RecompiledFunctionTable[239417] = bhEne16_0x1e9cc0; // 0x1e9cec - g_ps2RecompiledFunctionTable[239418] = bhEne16_0x1e9cc0; // 0x1e9cf0 - g_ps2RecompiledFunctionTable[239419] = bhEne16_0x1e9cc0; // 0x1e9cf4 - g_ps2RecompiledFunctionTable[239420] = bhEne16_0x1e9cc0; // 0x1e9cf8 - g_ps2RecompiledFunctionTable[239421] = bhEne16_0x1e9cc0; // 0x1e9cfc - g_ps2RecompiledFunctionTable[239422] = bhEne16_0x1e9cc0; // 0x1e9d00 - g_ps2RecompiledFunctionTable[239423] = bhEne16_0x1e9cc0; // 0x1e9d04 - g_ps2RecompiledFunctionTable[239424] = bhEne16_0x1e9cc0; // 0x1e9d08 - g_ps2RecompiledFunctionTable[239425] = bhEne16_0x1e9cc0; // 0x1e9d0c - g_ps2RecompiledFunctionTable[239426] = bhEne16_0x1e9cc0; // 0x1e9d10 - g_ps2RecompiledFunctionTable[239427] = bhEne16_0x1e9cc0; // 0x1e9d14 - g_ps2RecompiledFunctionTable[239428] = bhEne16_0x1e9cc0; // 0x1e9d18 - g_ps2RecompiledFunctionTable[239429] = bhEne16_0x1e9cc0; // 0x1e9d1c - g_ps2RecompiledFunctionTable[239430] = bhEne16_0x1e9cc0; // 0x1e9d20 - g_ps2RecompiledFunctionTable[239431] = bhEne16_0x1e9cc0; // 0x1e9d24 - g_ps2RecompiledFunctionTable[239432] = bhEne16_0x1e9cc0; // 0x1e9d28 - g_ps2RecompiledFunctionTable[239433] = bhEne16_0x1e9cc0; // 0x1e9d2c - g_ps2RecompiledFunctionTable[239434] = bhEne16_0x1e9cc0; // 0x1e9d30 - g_ps2RecompiledFunctionTable[239435] = bhEne16_0x1e9cc0; // 0x1e9d34 - g_ps2RecompiledFunctionTable[239436] = bhEne16_0x1e9cc0; // 0x1e9d38 - g_ps2RecompiledFunctionTable[239437] = bhEne16_0x1e9cc0; // 0x1e9d3c - g_ps2RecompiledFunctionTable[239438] = bhEne16_0x1e9cc0; // 0x1e9d40 - g_ps2RecompiledFunctionTable[239442] = bhEne16_Init_0x1e9d50; // 0x1e9d50 - g_ps2RecompiledFunctionTable[239466] = bhEne16_Init_0x1e9d50; // 0x1e9db0 - g_ps2RecompiledFunctionTable[239533] = bhEne16_Init_0x1e9d50; // 0x1e9ebc - g_ps2RecompiledFunctionTable[239551] = bhEne16_Init_0x1e9d50; // 0x1e9f04 - g_ps2RecompiledFunctionTable[239566] = bhEne16_Brain_0x1e9f40; // 0x1e9f40 - g_ps2RecompiledFunctionTable[239567] = bhEne16_Brain_0x1e9f40; // 0x1e9f44 - g_ps2RecompiledFunctionTable[239568] = bhEne16_Brain_0x1e9f40; // 0x1e9f48 - g_ps2RecompiledFunctionTable[239569] = bhEne16_Brain_0x1e9f40; // 0x1e9f4c - g_ps2RecompiledFunctionTable[239570] = bhEne16_BR00_0x1e9f50; // 0x1e9f50 - g_ps2RecompiledFunctionTable[239580] = bhEne16_BR00_0x1e9f50; // 0x1e9f78 - g_ps2RecompiledFunctionTable[239598] = bhEne16_Move_0x1e9fc0; // 0x1e9fc0 - g_ps2RecompiledFunctionTable[239599] = bhEne16_Move_0x1e9fc0; // 0x1e9fc4 - g_ps2RecompiledFunctionTable[239600] = bhEne16_Move_0x1e9fc0; // 0x1e9fc8 - g_ps2RecompiledFunctionTable[239601] = bhEne16_Move_0x1e9fc0; // 0x1e9fcc - g_ps2RecompiledFunctionTable[239602] = bhEne16_Move_0x1e9fc0; // 0x1e9fd0 - g_ps2RecompiledFunctionTable[239603] = bhEne16_Move_0x1e9fc0; // 0x1e9fd4 - g_ps2RecompiledFunctionTable[239604] = bhEne16_Move_0x1e9fc0; // 0x1e9fd8 - g_ps2RecompiledFunctionTable[239605] = bhEne16_Move_0x1e9fc0; // 0x1e9fdc - g_ps2RecompiledFunctionTable[239606] = bhEne16_Move_0x1e9fc0; // 0x1e9fe0 - g_ps2RecompiledFunctionTable[239607] = bhEne16_Move_0x1e9fc0; // 0x1e9fe4 - g_ps2RecompiledFunctionTable[239608] = bhEne16_Move_0x1e9fc0; // 0x1e9fe8 - g_ps2RecompiledFunctionTable[239609] = bhEne16_Move_0x1e9fc0; // 0x1e9fec - g_ps2RecompiledFunctionTable[239610] = bhEne16_Move_0x1e9fc0; // 0x1e9ff0 - g_ps2RecompiledFunctionTable[239611] = bhEne16_Move_0x1e9fc0; // 0x1e9ff4 - g_ps2RecompiledFunctionTable[239612] = bhEne16_Move_0x1e9fc0; // 0x1e9ff8 - g_ps2RecompiledFunctionTable[239613] = bhEne16_Move_0x1e9fc0; // 0x1e9ffc - g_ps2RecompiledFunctionTable[239614] = bhEne16_Move_0x1e9fc0; // 0x1ea000 - g_ps2RecompiledFunctionTable[239615] = bhEne16_Move_0x1e9fc0; // 0x1ea004 - g_ps2RecompiledFunctionTable[239616] = bhEne16_Move_0x1e9fc0; // 0x1ea008 - g_ps2RecompiledFunctionTable[239617] = bhEne16_Move_0x1e9fc0; // 0x1ea00c - g_ps2RecompiledFunctionTable[239618] = bhEne16_Move_0x1e9fc0; // 0x1ea010 - g_ps2RecompiledFunctionTable[239622] = bhEne16_MV00_0x1ea020; // 0x1ea020 - g_ps2RecompiledFunctionTable[239630] = bhEne16_MV01_0x1ea040; // 0x1ea040 - g_ps2RecompiledFunctionTable[239638] = bhEne16_MV02_0x1ea060; // 0x1ea060 - g_ps2RecompiledFunctionTable[239711] = bhEne16_MV02_0x1ea060; // 0x1ea184 - g_ps2RecompiledFunctionTable[239748] = bhEne16_MV02_0x1ea060; // 0x1ea218 - g_ps2RecompiledFunctionTable[239786] = bhEne16_MV02_0x1ea060; // 0x1ea2b0 - g_ps2RecompiledFunctionTable[239827] = bhEne16_MV02_0x1ea060; // 0x1ea354 - g_ps2RecompiledFunctionTable[239845] = bhEne16_MV02_0x1ea060; // 0x1ea39c - g_ps2RecompiledFunctionTable[239882] = bhEne16_MV02_0x1ea060; // 0x1ea430 - g_ps2RecompiledFunctionTable[239887] = bhEne16_MV02_0x1ea060; // 0x1ea444 - g_ps2RecompiledFunctionTable[239892] = bhEne16_MV02_0x1ea060; // 0x1ea458 - g_ps2RecompiledFunctionTable[240008] = bhEne16_MV02_0x1ea060; // 0x1ea628 - g_ps2RecompiledFunctionTable[240020] = bhEne16_MV02_0x1ea060; // 0x1ea658 - g_ps2RecompiledFunctionTable[240055] = bhEne16_MV02_0x1ea060; // 0x1ea6e4 - g_ps2RecompiledFunctionTable[240108] = bhEne16_MV02_0x1ea060; // 0x1ea7b8 - g_ps2RecompiledFunctionTable[240140] = bhEne16_MV02_0x1ea060; // 0x1ea838 - g_ps2RecompiledFunctionTable[240154] = bhEne16_MV02_0x1ea060; // 0x1ea870 - g_ps2RecompiledFunctionTable[240185] = bhEne16_MV02_0x1ea060; // 0x1ea8ec - g_ps2RecompiledFunctionTable[240207] = bhEne16_MV02_0x1ea060; // 0x1ea944 - g_ps2RecompiledFunctionTable[240229] = bhEne16_MV02_0x1ea060; // 0x1ea99c - g_ps2RecompiledFunctionTable[240262] = bhEne16_MV02_0x1ea060; // 0x1eaa20 - g_ps2RecompiledFunctionTable[240266] = bhEne16_MV02_0x1ea060; // 0x1eaa30 - g_ps2RecompiledFunctionTable[240269] = bhEne16_MV02_0x1ea060; // 0x1eaa3c - g_ps2RecompiledFunctionTable[240286] = bhEne16_GetEffNum_0x1eaa80; // 0x1eaa80 - g_ps2RecompiledFunctionTable[240290] = bhEne16_GetEffPos_0x1eaa90; // 0x1eaa90 - g_ps2RecompiledFunctionTable[240294] = bhEne16_AddEffPos_0x1eaaa0; // 0x1eaaa0 - g_ps2RecompiledFunctionTable[240301] = bhEne16_AddEffPos_0x1eaaa0; // 0x1eaabc - g_ps2RecompiledFunctionTable[240330] = bhEne17_DmmyBrain_0x1eab30; // 0x1eab30 - g_ps2RecompiledFunctionTable[240334] = bhEne17_0x1eab40; // 0x1eab40 - g_ps2RecompiledFunctionTable[240340] = bhEne17_0x1eab40; // 0x1eab58 - g_ps2RecompiledFunctionTable[240354] = bhEne17_0x1eab40; // 0x1eab90 - g_ps2RecompiledFunctionTable[240359] = bhEne17_0x1eab40; // 0x1eaba4 - g_ps2RecompiledFunctionTable[240362] = bhEne17_0x1eab40; // 0x1eabb0 - g_ps2RecompiledFunctionTable[240368] = bhEne17_0x1eab40; // 0x1eabc8 - g_ps2RecompiledFunctionTable[240382] = bhEne17_0x1eab40; // 0x1eac00 - g_ps2RecompiledFunctionTable[240384] = bhEne17_0x1eab40; // 0x1eac08 - g_ps2RecompiledFunctionTable[240390] = bhEne17_0x1eab40; // 0x1eac20 - g_ps2RecompiledFunctionTable[240425] = bhEne17_0x1eab40; // 0x1eacac - g_ps2RecompiledFunctionTable[240429] = bhEne17_0x1eab40; // 0x1eacbc - g_ps2RecompiledFunctionTable[240433] = bhEne17_0x1eab40; // 0x1eaccc - g_ps2RecompiledFunctionTable[240437] = bhEne17_0x1eab40; // 0x1eacdc - g_ps2RecompiledFunctionTable[240441] = bhEne17_0x1eab40; // 0x1eacec - g_ps2RecompiledFunctionTable[240450] = bhEne17_0x1eab40; // 0x1ead10 - g_ps2RecompiledFunctionTable[240454] = bhEne17_0x1eab40; // 0x1ead20 - g_ps2RecompiledFunctionTable[240462] = bhEne17_EneToPlyDist_0x1ead40; // 0x1ead40 - g_ps2RecompiledFunctionTable[240479] = bhEne17_EneToPlyDist_0x1ead40; // 0x1ead84 - g_ps2RecompiledFunctionTable[240486] = bhEne17_MainLoop_0x1eada0; // 0x1eada0 - g_ps2RecompiledFunctionTable[240487] = bhEne17_MainLoop_0x1eada0; // 0x1eada4 - g_ps2RecompiledFunctionTable[240488] = bhEne17_MainLoop_0x1eada0; // 0x1eada8 - g_ps2RecompiledFunctionTable[240489] = bhEne17_MainLoop_0x1eada0; // 0x1eadac - g_ps2RecompiledFunctionTable[240490] = bhEne17_MainLoop_0x1eada0; // 0x1eadb0 - g_ps2RecompiledFunctionTable[240491] = bhEne17_MainLoop_0x1eada0; // 0x1eadb4 - g_ps2RecompiledFunctionTable[240492] = bhEne17_MainLoop_0x1eada0; // 0x1eadb8 - g_ps2RecompiledFunctionTable[240493] = bhEne17_MainLoop_0x1eada0; // 0x1eadbc - g_ps2RecompiledFunctionTable[240494] = bhEne17_MainLoop_0x1eada0; // 0x1eadc0 - g_ps2RecompiledFunctionTable[240495] = bhEne17_MainLoop_0x1eada0; // 0x1eadc4 - g_ps2RecompiledFunctionTable[240496] = bhEne17_MainLoop_0x1eada0; // 0x1eadc8 - g_ps2RecompiledFunctionTable[240497] = bhEne17_MainLoop_0x1eada0; // 0x1eadcc - g_ps2RecompiledFunctionTable[240498] = bhEne17_MainLoop_0x1eada0; // 0x1eadd0 - g_ps2RecompiledFunctionTable[240499] = bhEne17_MainLoop_0x1eada0; // 0x1eadd4 - g_ps2RecompiledFunctionTable[240500] = bhEne17_MainLoop_0x1eada0; // 0x1eadd8 - g_ps2RecompiledFunctionTable[240501] = bhEne17_MainLoop_0x1eada0; // 0x1eaddc - g_ps2RecompiledFunctionTable[240502] = bhEne17_MainLoop_0x1eada0; // 0x1eade0 - g_ps2RecompiledFunctionTable[240503] = bhEne17_MainLoop_0x1eada0; // 0x1eade4 - g_ps2RecompiledFunctionTable[240504] = bhEne17_MainLoop_0x1eada0; // 0x1eade8 - g_ps2RecompiledFunctionTable[240506] = bhEne17_DmgChk_0x1eadf0; // 0x1eadf0 - g_ps2RecompiledFunctionTable[240521] = bhEne17_DmgChk_0x1eadf0; // 0x1eae2c - g_ps2RecompiledFunctionTable[240526] = bhEne17_DmgChk_0x1eadf0; // 0x1eae40 - g_ps2RecompiledFunctionTable[240558] = bhEne17_DmgChk_0x1eadf0; // 0x1eaec0 - g_ps2RecompiledFunctionTable[240562] = bhEne17_ChgDmgMode_0x1eaed0; // 0x1eaed0 - g_ps2RecompiledFunctionTable[240606] = bhEne17_DamageAdd_0x1eaf80; // 0x1eaf80 - g_ps2RecompiledFunctionTable[240620] = bhEne17_DamageAdd_0x1eaf80; // 0x1eafb8 - g_ps2RecompiledFunctionTable[240628] = bhEne17_DamageAdd_0x1eaf80; // 0x1eafd8 - g_ps2RecompiledFunctionTable[240649] = bhEne17_DamageAdd_0x1eaf80; // 0x1eb02c - g_ps2RecompiledFunctionTable[240656] = bhEne17_DamageAdd_0x1eaf80; // 0x1eb048 - g_ps2RecompiledFunctionTable[240688] = bhEne17_DamageAdd_0x1eaf80; // 0x1eb0c8 - g_ps2RecompiledFunctionTable[240696] = bhEne17_DamageAdd_0x1eaf80; // 0x1eb0e8 - g_ps2RecompiledFunctionTable[240712] = bhEne17_DamageAdd_0x1eaf80; // 0x1eb128 - g_ps2RecompiledFunctionTable[240722] = bhEne17_SetMtn_0x1eb150; // 0x1eb150 - g_ps2RecompiledFunctionTable[240767] = bhEne17_SetMtn_0x1eb150; // 0x1eb204 - g_ps2RecompiledFunctionTable[240776] = bhEne17_SetMtn_0x1eb150; // 0x1eb228 - g_ps2RecompiledFunctionTable[240778] = bhEne17_SetMtn_0x1eb150; // 0x1eb230 - g_ps2RecompiledFunctionTable[240781] = bhEne17_SetMtn_0x1eb150; // 0x1eb23c - g_ps2RecompiledFunctionTable[240794] = bhEne17_SetMtn_0x1eb150; // 0x1eb270 - g_ps2RecompiledFunctionTable[240808] = bhEne17_SetMtn_0x1eb150; // 0x1eb2a8 - g_ps2RecompiledFunctionTable[240810] = bhEne17_SetMtn_0x1eb150; // 0x1eb2b0 - g_ps2RecompiledFunctionTable[240914] = bhEne17_SetMtn_0x1eb150; // 0x1eb450 - g_ps2RecompiledFunctionTable[240916] = bhEne17_SetMtn_0x1eb150; // 0x1eb458 - g_ps2RecompiledFunctionTable[240935] = bhEne17_SetMtn_0x1eb150; // 0x1eb4a4 - g_ps2RecompiledFunctionTable[240955] = bhEne17_SetMtn_0x1eb150; // 0x1eb4f4 - g_ps2RecompiledFunctionTable[240993] = bhEne17_SetMtn_0x1eb150; // 0x1eb58c - g_ps2RecompiledFunctionTable[240998] = bhEne17_SetMtn_0x1eb150; // 0x1eb5a0 - g_ps2RecompiledFunctionTable[241013] = bhEne17_SetMtn_0x1eb150; // 0x1eb5dc - g_ps2RecompiledFunctionTable[241016] = bhEne17_SetMtn_0x1eb150; // 0x1eb5e8 - g_ps2RecompiledFunctionTable[241042] = bhEne17_MtnTblPlay_0x1eb650; // 0x1eb650 - g_ps2RecompiledFunctionTable[241091] = bhEne17_MtnTblPlay_0x1eb650; // 0x1eb714 - g_ps2RecompiledFunctionTable[241097] = bhEne17_MtnTblPlay_0x1eb650; // 0x1eb72c - g_ps2RecompiledFunctionTable[241132] = bhEne17_MtnTblPlay_0x1eb650; // 0x1eb7b8 - g_ps2RecompiledFunctionTable[241140] = bhEne17_MtnTblPlay_0x1eb650; // 0x1eb7d8 - g_ps2RecompiledFunctionTable[241148] = bhEne17_MtnTblPlay_0x1eb650; // 0x1eb7f8 - g_ps2RecompiledFunctionTable[241156] = bhEne17_MtnTblPlay_0x1eb650; // 0x1eb818 - g_ps2RecompiledFunctionTable[241196] = bhEne17_MtnTblPlay_0x1eb650; // 0x1eb8b8 - g_ps2RecompiledFunctionTable[241202] = bhEne17_MtnTblPlay_0x1eb650; // 0x1eb8d0 - g_ps2RecompiledFunctionTable[241211] = bhEne17_MtnTblPlay_0x1eb650; // 0x1eb8f4 - g_ps2RecompiledFunctionTable[241230] = bhEne17_CollCheck_0x1eb940; // 0x1eb940 - g_ps2RecompiledFunctionTable[241247] = bhEne17_CollCheck_0x1eb940; // 0x1eb984 - g_ps2RecompiledFunctionTable[241250] = bhEne17_CollCheck_0x1eb940; // 0x1eb990 - g_ps2RecompiledFunctionTable[241254] = bhEne17_CollCheckWall_0x1eb9a0; // 0x1eb9a0 - g_ps2RecompiledFunctionTable[241263] = bhEne17_CollCheckWall_0x1eb9a0; // 0x1eb9c4 - g_ps2RecompiledFunctionTable[241277] = bhEne17_CollCheckWall_0x1eb9a0; // 0x1eb9fc - g_ps2RecompiledFunctionTable[241279] = bhEne17_CollCheckWall_0x1eb9a0; // 0x1eba04 - g_ps2RecompiledFunctionTable[241286] = bhEne17_CalcEnemy_0x1eba20; // 0x1eba20 - g_ps2RecompiledFunctionTable[241291] = bhEne17_CalcEnemy_0x1eba20; // 0x1eba34 - g_ps2RecompiledFunctionTable[241342] = bhEne17_Init_0x1ebb00; // 0x1ebb00 - g_ps2RecompiledFunctionTable[241343] = bhEne17_Init_0x1ebb00; // 0x1ebb04 - g_ps2RecompiledFunctionTable[241344] = bhEne17_Init_0x1ebb00; // 0x1ebb08 - g_ps2RecompiledFunctionTable[241345] = bhEne17_Init_0x1ebb00; // 0x1ebb0c - g_ps2RecompiledFunctionTable[241346] = bhEne17_Init_0x1ebb00; // 0x1ebb10 - g_ps2RecompiledFunctionTable[241347] = bhEne17_Init_0x1ebb00; // 0x1ebb14 - g_ps2RecompiledFunctionTable[241348] = bhEne17_Init_0x1ebb00; // 0x1ebb18 - g_ps2RecompiledFunctionTable[241349] = bhEne17_Init_0x1ebb00; // 0x1ebb1c - g_ps2RecompiledFunctionTable[241350] = bhEne17_Init_0x1ebb00; // 0x1ebb20 - g_ps2RecompiledFunctionTable[241351] = bhEne17_Init_0x1ebb00; // 0x1ebb24 - g_ps2RecompiledFunctionTable[241352] = bhEne17_Init_0x1ebb00; // 0x1ebb28 - g_ps2RecompiledFunctionTable[241353] = bhEne17_Init_0x1ebb00; // 0x1ebb2c - g_ps2RecompiledFunctionTable[241354] = bhEne17_Init_0x1ebb00; // 0x1ebb30 - g_ps2RecompiledFunctionTable[241355] = bhEne17_Init_0x1ebb00; // 0x1ebb34 - g_ps2RecompiledFunctionTable[241356] = bhEne17_Init_0x1ebb00; // 0x1ebb38 - g_ps2RecompiledFunctionTable[241357] = bhEne17_Init_0x1ebb00; // 0x1ebb3c - g_ps2RecompiledFunctionTable[241358] = bhEne17_Init_0x1ebb00; // 0x1ebb40 - g_ps2RecompiledFunctionTable[241359] = bhEne17_Init_0x1ebb00; // 0x1ebb44 - g_ps2RecompiledFunctionTable[241360] = bhEne17_Init_0x1ebb00; // 0x1ebb48 - g_ps2RecompiledFunctionTable[241361] = bhEne17_Init_0x1ebb00; // 0x1ebb4c - g_ps2RecompiledFunctionTable[241362] = bhEne17_Init_0x1ebb00; // 0x1ebb50 - g_ps2RecompiledFunctionTable[241363] = bhEne17_Init_0x1ebb00; // 0x1ebb54 - g_ps2RecompiledFunctionTable[241364] = bhEne17_Init_0x1ebb00; // 0x1ebb58 - g_ps2RecompiledFunctionTable[241365] = bhEne17_Init_0x1ebb00; // 0x1ebb5c - g_ps2RecompiledFunctionTable[241366] = bhEne17_Init_0x1ebb00; // 0x1ebb60 - g_ps2RecompiledFunctionTable[241367] = bhEne17_Init_0x1ebb00; // 0x1ebb64 - g_ps2RecompiledFunctionTable[241368] = bhEne17_Init_0x1ebb00; // 0x1ebb68 - g_ps2RecompiledFunctionTable[241369] = bhEne17_Init_0x1ebb00; // 0x1ebb6c - g_ps2RecompiledFunctionTable[241370] = bhEne17_Init_0x1ebb00; // 0x1ebb70 - g_ps2RecompiledFunctionTable[241371] = bhEne17_Init_0x1ebb00; // 0x1ebb74 - g_ps2RecompiledFunctionTable[241372] = bhEne17_Init_0x1ebb00; // 0x1ebb78 - g_ps2RecompiledFunctionTable[241373] = bhEne17_Init_0x1ebb00; // 0x1ebb7c - g_ps2RecompiledFunctionTable[241374] = bhEne17_Init_0x1ebb00; // 0x1ebb80 - g_ps2RecompiledFunctionTable[241375] = bhEne17_Init_0x1ebb00; // 0x1ebb84 - g_ps2RecompiledFunctionTable[241376] = bhEne17_Init_0x1ebb00; // 0x1ebb88 - g_ps2RecompiledFunctionTable[241377] = bhEne17_Init_0x1ebb00; // 0x1ebb8c - g_ps2RecompiledFunctionTable[241378] = bhEne17_Init_0x1ebb00; // 0x1ebb90 - g_ps2RecompiledFunctionTable[241379] = bhEne17_Init_0x1ebb00; // 0x1ebb94 - g_ps2RecompiledFunctionTable[241380] = bhEne17_Init_0x1ebb00; // 0x1ebb98 - g_ps2RecompiledFunctionTable[241381] = bhEne17_Init_0x1ebb00; // 0x1ebb9c - g_ps2RecompiledFunctionTable[241382] = bhEne17_Init_0x1ebb00; // 0x1ebba0 - g_ps2RecompiledFunctionTable[241383] = bhEne17_Init_0x1ebb00; // 0x1ebba4 - g_ps2RecompiledFunctionTable[241384] = bhEne17_Init_0x1ebb00; // 0x1ebba8 - g_ps2RecompiledFunctionTable[241385] = bhEne17_Init_0x1ebb00; // 0x1ebbac - g_ps2RecompiledFunctionTable[241386] = bhEne17_Init_0x1ebb00; // 0x1ebbb0 - g_ps2RecompiledFunctionTable[241387] = bhEne17_Init_0x1ebb00; // 0x1ebbb4 - g_ps2RecompiledFunctionTable[241388] = bhEne17_Init_0x1ebb00; // 0x1ebbb8 - g_ps2RecompiledFunctionTable[241389] = bhEne17_Init_0x1ebb00; // 0x1ebbbc - g_ps2RecompiledFunctionTable[241390] = bhEne17_Init_0x1ebb00; // 0x1ebbc0 - g_ps2RecompiledFunctionTable[241391] = bhEne17_Init_0x1ebb00; // 0x1ebbc4 - g_ps2RecompiledFunctionTable[241392] = bhEne17_Init_0x1ebb00; // 0x1ebbc8 - g_ps2RecompiledFunctionTable[241393] = bhEne17_Init_0x1ebb00; // 0x1ebbcc - g_ps2RecompiledFunctionTable[241394] = bhEne17_Init_0x1ebb00; // 0x1ebbd0 - g_ps2RecompiledFunctionTable[241395] = bhEne17_Init_0x1ebb00; // 0x1ebbd4 - g_ps2RecompiledFunctionTable[241396] = bhEne17_Init_0x1ebb00; // 0x1ebbd8 - g_ps2RecompiledFunctionTable[241397] = bhEne17_Init_0x1ebb00; // 0x1ebbdc - g_ps2RecompiledFunctionTable[241398] = bhEne17_Init_0x1ebb00; // 0x1ebbe0 - g_ps2RecompiledFunctionTable[241399] = bhEne17_Init_0x1ebb00; // 0x1ebbe4 - g_ps2RecompiledFunctionTable[241400] = bhEne17_Init_0x1ebb00; // 0x1ebbe8 - g_ps2RecompiledFunctionTable[241401] = bhEne17_Init_0x1ebb00; // 0x1ebbec - g_ps2RecompiledFunctionTable[241402] = bhEne17_Init_0x1ebb00; // 0x1ebbf0 - g_ps2RecompiledFunctionTable[241403] = bhEne17_Init_0x1ebb00; // 0x1ebbf4 - g_ps2RecompiledFunctionTable[241404] = bhEne17_Init_0x1ebb00; // 0x1ebbf8 - g_ps2RecompiledFunctionTable[241405] = bhEne17_Init_0x1ebb00; // 0x1ebbfc - g_ps2RecompiledFunctionTable[241406] = bhEne17_Init_0x1ebb00; // 0x1ebc00 - g_ps2RecompiledFunctionTable[241407] = bhEne17_Init_0x1ebb00; // 0x1ebc04 - g_ps2RecompiledFunctionTable[241408] = bhEne17_Init_0x1ebb00; // 0x1ebc08 - g_ps2RecompiledFunctionTable[241409] = bhEne17_Init_0x1ebb00; // 0x1ebc0c - g_ps2RecompiledFunctionTable[241410] = bhEne17_Init_0x1ebb00; // 0x1ebc10 - g_ps2RecompiledFunctionTable[241411] = bhEne17_Init_0x1ebb00; // 0x1ebc14 - g_ps2RecompiledFunctionTable[241412] = bhEne17_Init_0x1ebb00; // 0x1ebc18 - g_ps2RecompiledFunctionTable[241413] = bhEne17_Init_0x1ebb00; // 0x1ebc1c - g_ps2RecompiledFunctionTable[241414] = bhEne17_Init_0x1ebb00; // 0x1ebc20 - g_ps2RecompiledFunctionTable[241415] = bhEne17_Init_0x1ebb00; // 0x1ebc24 - g_ps2RecompiledFunctionTable[241416] = bhEne17_Init_0x1ebb00; // 0x1ebc28 - g_ps2RecompiledFunctionTable[241417] = bhEne17_Init_0x1ebb00; // 0x1ebc2c - g_ps2RecompiledFunctionTable[241418] = bhEne17_Init_0x1ebb00; // 0x1ebc30 - g_ps2RecompiledFunctionTable[241419] = bhEne17_Init_0x1ebb00; // 0x1ebc34 - g_ps2RecompiledFunctionTable[241420] = bhEne17_Init_0x1ebb00; // 0x1ebc38 - g_ps2RecompiledFunctionTable[241421] = bhEne17_Init_0x1ebb00; // 0x1ebc3c - g_ps2RecompiledFunctionTable[241422] = bhEne17_Init_0x1ebb00; // 0x1ebc40 - g_ps2RecompiledFunctionTable[241423] = bhEne17_Init_0x1ebb00; // 0x1ebc44 - g_ps2RecompiledFunctionTable[241424] = bhEne17_Init_0x1ebb00; // 0x1ebc48 - g_ps2RecompiledFunctionTable[241425] = bhEne17_Init_0x1ebb00; // 0x1ebc4c - g_ps2RecompiledFunctionTable[241426] = bhEne17_Init_0x1ebb00; // 0x1ebc50 - g_ps2RecompiledFunctionTable[241427] = bhEne17_Init_0x1ebb00; // 0x1ebc54 - g_ps2RecompiledFunctionTable[241428] = bhEne17_Init_0x1ebb00; // 0x1ebc58 - g_ps2RecompiledFunctionTable[241429] = bhEne17_Init_0x1ebb00; // 0x1ebc5c - g_ps2RecompiledFunctionTable[241430] = bhEne17_Init_0x1ebb00; // 0x1ebc60 - g_ps2RecompiledFunctionTable[241431] = bhEne17_Init_0x1ebb00; // 0x1ebc64 - g_ps2RecompiledFunctionTable[241432] = bhEne17_Init_0x1ebb00; // 0x1ebc68 - g_ps2RecompiledFunctionTable[241433] = bhEne17_Init_0x1ebb00; // 0x1ebc6c - g_ps2RecompiledFunctionTable[241434] = bhEne17_Init_0x1ebb00; // 0x1ebc70 - g_ps2RecompiledFunctionTable[241435] = bhEne17_Init_0x1ebb00; // 0x1ebc74 - g_ps2RecompiledFunctionTable[241436] = bhEne17_Init_0x1ebb00; // 0x1ebc78 - g_ps2RecompiledFunctionTable[241437] = bhEne17_Init_0x1ebb00; // 0x1ebc7c - g_ps2RecompiledFunctionTable[241438] = bhEne17_Init_0x1ebb00; // 0x1ebc80 - g_ps2RecompiledFunctionTable[241439] = bhEne17_Init_0x1ebb00; // 0x1ebc84 - g_ps2RecompiledFunctionTable[241440] = bhEne17_Init_0x1ebb00; // 0x1ebc88 - g_ps2RecompiledFunctionTable[241441] = bhEne17_Init_0x1ebb00; // 0x1ebc8c - g_ps2RecompiledFunctionTable[241442] = bhEne17_Init_0x1ebb00; // 0x1ebc90 - g_ps2RecompiledFunctionTable[241443] = bhEne17_Init_0x1ebb00; // 0x1ebc94 - g_ps2RecompiledFunctionTable[241444] = bhEne17_Init_0x1ebb00; // 0x1ebc98 - g_ps2RecompiledFunctionTable[241445] = bhEne17_Init_0x1ebb00; // 0x1ebc9c - g_ps2RecompiledFunctionTable[241446] = bhEne17_Init_0x1ebb00; // 0x1ebca0 - g_ps2RecompiledFunctionTable[241447] = bhEne17_Init_0x1ebb00; // 0x1ebca4 - g_ps2RecompiledFunctionTable[241448] = bhEne17_Init_0x1ebb00; // 0x1ebca8 - g_ps2RecompiledFunctionTable[241449] = bhEne17_Init_0x1ebb00; // 0x1ebcac - g_ps2RecompiledFunctionTable[241450] = bhEne17_Init_0x1ebb00; // 0x1ebcb0 - g_ps2RecompiledFunctionTable[241451] = bhEne17_Init_0x1ebb00; // 0x1ebcb4 - g_ps2RecompiledFunctionTable[241452] = bhEne17_Init_0x1ebb00; // 0x1ebcb8 - g_ps2RecompiledFunctionTable[241453] = bhEne17_Init_0x1ebb00; // 0x1ebcbc - g_ps2RecompiledFunctionTable[241454] = bhEne17_Init_0x1ebb00; // 0x1ebcc0 - g_ps2RecompiledFunctionTable[241455] = bhEne17_Init_0x1ebb00; // 0x1ebcc4 - g_ps2RecompiledFunctionTable[241456] = bhEne17_Init_0x1ebb00; // 0x1ebcc8 - g_ps2RecompiledFunctionTable[241457] = bhEne17_Init_0x1ebb00; // 0x1ebccc - g_ps2RecompiledFunctionTable[241458] = bhEne17_Init_0x1ebb00; // 0x1ebcd0 - g_ps2RecompiledFunctionTable[241459] = bhEne17_Init_0x1ebb00; // 0x1ebcd4 - g_ps2RecompiledFunctionTable[241460] = bhEne17_Init_0x1ebb00; // 0x1ebcd8 - g_ps2RecompiledFunctionTable[241461] = bhEne17_Init_0x1ebb00; // 0x1ebcdc - g_ps2RecompiledFunctionTable[241462] = bhEne17_Init_0x1ebb00; // 0x1ebce0 - g_ps2RecompiledFunctionTable[241463] = bhEne17_Init_0x1ebb00; // 0x1ebce4 - g_ps2RecompiledFunctionTable[241464] = bhEne17_Init_0x1ebb00; // 0x1ebce8 - g_ps2RecompiledFunctionTable[241465] = bhEne17_Init_0x1ebb00; // 0x1ebcec - g_ps2RecompiledFunctionTable[241466] = bhEne17_Init_0x1ebb00; // 0x1ebcf0 - g_ps2RecompiledFunctionTable[241467] = bhEne17_Init_0x1ebb00; // 0x1ebcf4 - g_ps2RecompiledFunctionTable[241468] = bhEne17_Init_0x1ebb00; // 0x1ebcf8 - g_ps2RecompiledFunctionTable[241469] = bhEne17_Init_0x1ebb00; // 0x1ebcfc - g_ps2RecompiledFunctionTable[241470] = bhEne17_Init_0x1ebb00; // 0x1ebd00 - g_ps2RecompiledFunctionTable[241471] = bhEne17_Init_0x1ebb00; // 0x1ebd04 - g_ps2RecompiledFunctionTable[241472] = bhEne17_Init_0x1ebb00; // 0x1ebd08 - g_ps2RecompiledFunctionTable[241473] = bhEne17_Init_0x1ebb00; // 0x1ebd0c - g_ps2RecompiledFunctionTable[241474] = bhEne17_Init_0x1ebb00; // 0x1ebd10 - g_ps2RecompiledFunctionTable[241475] = bhEne17_Init_0x1ebb00; // 0x1ebd14 - g_ps2RecompiledFunctionTable[241476] = bhEne17_Init_0x1ebb00; // 0x1ebd18 - g_ps2RecompiledFunctionTable[241477] = bhEne17_Init_0x1ebb00; // 0x1ebd1c - g_ps2RecompiledFunctionTable[241478] = bhEne17_Init_0x1ebb00; // 0x1ebd20 - g_ps2RecompiledFunctionTable[241479] = bhEne17_Init_0x1ebb00; // 0x1ebd24 - g_ps2RecompiledFunctionTable[241480] = bhEne17_Init_0x1ebb00; // 0x1ebd28 - g_ps2RecompiledFunctionTable[241481] = bhEne17_Init_0x1ebb00; // 0x1ebd2c - g_ps2RecompiledFunctionTable[241482] = bhEne17_Init_0x1ebb00; // 0x1ebd30 - g_ps2RecompiledFunctionTable[241483] = bhEne17_Init_0x1ebb00; // 0x1ebd34 - g_ps2RecompiledFunctionTable[241484] = bhEne17_Init_0x1ebb00; // 0x1ebd38 - g_ps2RecompiledFunctionTable[241485] = bhEne17_Init_0x1ebb00; // 0x1ebd3c - g_ps2RecompiledFunctionTable[241486] = bhEne17_Init_0x1ebb00; // 0x1ebd40 - g_ps2RecompiledFunctionTable[241487] = bhEne17_Init_0x1ebb00; // 0x1ebd44 - g_ps2RecompiledFunctionTable[241488] = bhEne17_Init_0x1ebb00; // 0x1ebd48 - g_ps2RecompiledFunctionTable[241489] = bhEne17_Init_0x1ebb00; // 0x1ebd4c - g_ps2RecompiledFunctionTable[241490] = bhEne17_Init_0x1ebb00; // 0x1ebd50 - g_ps2RecompiledFunctionTable[241491] = bhEne17_Init_0x1ebb00; // 0x1ebd54 - g_ps2RecompiledFunctionTable[241492] = bhEne17_Init_0x1ebb00; // 0x1ebd58 - g_ps2RecompiledFunctionTable[241493] = bhEne17_Init_0x1ebb00; // 0x1ebd5c - g_ps2RecompiledFunctionTable[241494] = bhEne17_Init_0x1ebb00; // 0x1ebd60 - g_ps2RecompiledFunctionTable[241495] = bhEne17_Init_0x1ebb00; // 0x1ebd64 - g_ps2RecompiledFunctionTable[241496] = bhEne17_Init_0x1ebb00; // 0x1ebd68 - g_ps2RecompiledFunctionTable[241497] = bhEne17_Init_0x1ebb00; // 0x1ebd6c - g_ps2RecompiledFunctionTable[241498] = bhEne17_InitType00_0x1ebd70; // 0x1ebd70 - g_ps2RecompiledFunctionTable[241502] = bhEne17_SetLinkWork_0x1ebd80; // 0x1ebd80 - g_ps2RecompiledFunctionTable[241516] = bhEne17_SetLinkWork_0x1ebd80; // 0x1ebdb8 - g_ps2RecompiledFunctionTable[241524] = bhEne17_SetLinkWork_0x1ebd80; // 0x1ebdd8 - g_ps2RecompiledFunctionTable[241558] = bhEne17_Move_0x1ebe60; // 0x1ebe60 - g_ps2RecompiledFunctionTable[241559] = bhEne17_Move_0x1ebe60; // 0x1ebe64 - g_ps2RecompiledFunctionTable[241560] = bhEne17_Move_0x1ebe60; // 0x1ebe68 - g_ps2RecompiledFunctionTable[241561] = bhEne17_Move_0x1ebe60; // 0x1ebe6c - g_ps2RecompiledFunctionTable[241562] = bhEne17_Damage_0x1ebe70; // 0x1ebe70 - g_ps2RecompiledFunctionTable[241563] = bhEne17_Damage_0x1ebe70; // 0x1ebe74 - g_ps2RecompiledFunctionTable[241564] = bhEne17_Damage_0x1ebe70; // 0x1ebe78 - g_ps2RecompiledFunctionTable[241565] = bhEne17_Damage_0x1ebe70; // 0x1ebe7c - g_ps2RecompiledFunctionTable[241566] = bhEne17_Nage_0x1ebe80; // 0x1ebe80 - g_ps2RecompiledFunctionTable[241570] = bhEne17_Die_0x1ebe90; // 0x1ebe90 - g_ps2RecompiledFunctionTable[241574] = bhEne17_Brain_0x1ebea0; // 0x1ebea0 - g_ps2RecompiledFunctionTable[241575] = bhEne17_Brain_0x1ebea0; // 0x1ebea4 - g_ps2RecompiledFunctionTable[241576] = bhEne17_Brain_0x1ebea0; // 0x1ebea8 - g_ps2RecompiledFunctionTable[241577] = bhEne17_Brain_0x1ebea0; // 0x1ebeac - g_ps2RecompiledFunctionTable[241578] = bhEne17_Brain_0x1ebea0; // 0x1ebeb0 - g_ps2RecompiledFunctionTable[241579] = bhEne17_Brain_0x1ebea0; // 0x1ebeb4 - g_ps2RecompiledFunctionTable[241580] = bhEne17_Brain_0x1ebea0; // 0x1ebeb8 - g_ps2RecompiledFunctionTable[241581] = bhEne17_Brain_0x1ebea0; // 0x1ebebc - g_ps2RecompiledFunctionTable[241582] = bhEne17_Brain_0x1ebea0; // 0x1ebec0 - g_ps2RecompiledFunctionTable[241583] = bhEne17_Brain_0x1ebea0; // 0x1ebec4 - g_ps2RecompiledFunctionTable[241584] = bhEne17_Brain_0x1ebea0; // 0x1ebec8 - g_ps2RecompiledFunctionTable[241585] = bhEne17_Brain_0x1ebea0; // 0x1ebecc - g_ps2RecompiledFunctionTable[241586] = bhEne17_Brain_0x1ebea0; // 0x1ebed0 - g_ps2RecompiledFunctionTable[241587] = bhEne17_Brain_0x1ebea0; // 0x1ebed4 - g_ps2RecompiledFunctionTable[241588] = bhEne17_Brain_0x1ebea0; // 0x1ebed8 - g_ps2RecompiledFunctionTable[241589] = bhEne17_Brain_0x1ebea0; // 0x1ebedc - g_ps2RecompiledFunctionTable[241590] = bhEne17_Brain_0x1ebea0; // 0x1ebee0 - g_ps2RecompiledFunctionTable[241591] = bhEne17_Brain_0x1ebea0; // 0x1ebee4 - g_ps2RecompiledFunctionTable[241592] = bhEne17_Brain_0x1ebea0; // 0x1ebee8 - g_ps2RecompiledFunctionTable[241593] = bhEne17_Brain_0x1ebea0; // 0x1ebeec - g_ps2RecompiledFunctionTable[241594] = bhEne17_Brain_0x1ebea0; // 0x1ebef0 - g_ps2RecompiledFunctionTable[241595] = bhEne17_Brain_0x1ebea0; // 0x1ebef4 - g_ps2RecompiledFunctionTable[241596] = bhEne17_Brain_0x1ebea0; // 0x1ebef8 - g_ps2RecompiledFunctionTable[241597] = bhEne17_Brain_0x1ebea0; // 0x1ebefc - g_ps2RecompiledFunctionTable[241598] = bhEne17_Brain_0x1ebea0; // 0x1ebf00 - g_ps2RecompiledFunctionTable[241599] = bhEne17_Brain_0x1ebea0; // 0x1ebf04 - g_ps2RecompiledFunctionTable[241600] = bhEne17_Brain_0x1ebea0; // 0x1ebf08 - g_ps2RecompiledFunctionTable[241601] = bhEne17_Brain_0x1ebea0; // 0x1ebf0c - g_ps2RecompiledFunctionTable[241602] = bhEne17_Brain_0x1ebea0; // 0x1ebf10 - g_ps2RecompiledFunctionTable[241603] = bhEne17_Brain_0x1ebea0; // 0x1ebf14 - g_ps2RecompiledFunctionTable[241604] = bhEne17_Brain_0x1ebea0; // 0x1ebf18 - g_ps2RecompiledFunctionTable[241605] = bhEne17_Brain_0x1ebea0; // 0x1ebf1c - g_ps2RecompiledFunctionTable[241606] = bhEne17_Brain_0x1ebea0; // 0x1ebf20 - g_ps2RecompiledFunctionTable[241607] = bhEne17_Brain_0x1ebea0; // 0x1ebf24 - g_ps2RecompiledFunctionTable[241608] = bhEne17_Brain_0x1ebea0; // 0x1ebf28 - g_ps2RecompiledFunctionTable[241609] = bhEne17_Brain_0x1ebea0; // 0x1ebf2c - g_ps2RecompiledFunctionTable[241610] = bhEne17_Brain_0x1ebea0; // 0x1ebf30 - g_ps2RecompiledFunctionTable[241611] = bhEne17_Brain_0x1ebea0; // 0x1ebf34 - g_ps2RecompiledFunctionTable[241612] = bhEne17_Brain_0x1ebea0; // 0x1ebf38 - g_ps2RecompiledFunctionTable[241613] = bhEne17_Brain_0x1ebea0; // 0x1ebf3c - g_ps2RecompiledFunctionTable[241614] = bhEne17_Brain_0x1ebea0; // 0x1ebf40 - g_ps2RecompiledFunctionTable[241615] = bhEne17_Brain_0x1ebea0; // 0x1ebf44 - g_ps2RecompiledFunctionTable[241616] = bhEne17_Brain_0x1ebea0; // 0x1ebf48 - g_ps2RecompiledFunctionTable[241617] = bhEne17_Brain_0x1ebea0; // 0x1ebf4c - g_ps2RecompiledFunctionTable[241618] = bhEne17_Brain_0x1ebea0; // 0x1ebf50 - g_ps2RecompiledFunctionTable[241619] = bhEne17_Brain_0x1ebea0; // 0x1ebf54 - g_ps2RecompiledFunctionTable[241620] = bhEne17_Brain_0x1ebea0; // 0x1ebf58 - g_ps2RecompiledFunctionTable[241621] = bhEne17_Brain_0x1ebea0; // 0x1ebf5c - g_ps2RecompiledFunctionTable[241622] = bhEne17_Brain_0x1ebea0; // 0x1ebf60 - g_ps2RecompiledFunctionTable[241626] = bhEne17_Brain00_0x1ebf70; // 0x1ebf70 - g_ps2RecompiledFunctionTable[241657] = bhEne17_Brain00_0x1ebf70; // 0x1ebfec - g_ps2RecompiledFunctionTable[241694] = bhEne17_MVType00_0x1ec080; // 0x1ec080 - g_ps2RecompiledFunctionTable[241695] = bhEne17_MVType00_0x1ec080; // 0x1ec084 - g_ps2RecompiledFunctionTable[241696] = bhEne17_MVType00_0x1ec080; // 0x1ec088 - g_ps2RecompiledFunctionTable[241697] = bhEne17_MVType00_0x1ec080; // 0x1ec08c - g_ps2RecompiledFunctionTable[241698] = bhEne17_MVType00_0x1ec080; // 0x1ec090 - g_ps2RecompiledFunctionTable[241699] = bhEne17_MVType00_0x1ec080; // 0x1ec094 - g_ps2RecompiledFunctionTable[241700] = bhEne17_MVType00_0x1ec080; // 0x1ec098 - g_ps2RecompiledFunctionTable[241701] = bhEne17_MVType00_0x1ec080; // 0x1ec09c - g_ps2RecompiledFunctionTable[241702] = bhEne17_MVType00_0x1ec080; // 0x1ec0a0 - g_ps2RecompiledFunctionTable[241703] = bhEne17_MVType00_0x1ec080; // 0x1ec0a4 - g_ps2RecompiledFunctionTable[241704] = bhEne17_MVType00_0x1ec080; // 0x1ec0a8 - g_ps2RecompiledFunctionTable[241705] = bhEne17_MVType00_0x1ec080; // 0x1ec0ac - g_ps2RecompiledFunctionTable[241706] = bhEne17_MVType00_0x1ec080; // 0x1ec0b0 - g_ps2RecompiledFunctionTable[241707] = bhEne17_MVType00_0x1ec080; // 0x1ec0b4 - g_ps2RecompiledFunctionTable[241708] = bhEne17_MVType00_0x1ec080; // 0x1ec0b8 - g_ps2RecompiledFunctionTable[241709] = bhEne17_MVType00_0x1ec080; // 0x1ec0bc - g_ps2RecompiledFunctionTable[241710] = bhEne17_MVType00_0x1ec080; // 0x1ec0c0 - g_ps2RecompiledFunctionTable[241711] = bhEne17_MVType00_0x1ec080; // 0x1ec0c4 - g_ps2RecompiledFunctionTable[241712] = bhEne17_MVType00_0x1ec080; // 0x1ec0c8 - g_ps2RecompiledFunctionTable[241713] = bhEne17_MVType00_0x1ec080; // 0x1ec0cc - g_ps2RecompiledFunctionTable[241714] = bhEne17_MVType00_0x1ec080; // 0x1ec0d0 - g_ps2RecompiledFunctionTable[241718] = bhEne17_MV00_0x1ec0e0; // 0x1ec0e0 - g_ps2RecompiledFunctionTable[241733] = bhEne17_MV00_0x1ec0e0; // 0x1ec11c - g_ps2RecompiledFunctionTable[241818] = bhEne17_MV01_0x1ec270; // 0x1ec270 - g_ps2RecompiledFunctionTable[241832] = bhEne17_MV01_0x1ec270; // 0x1ec2a8 - g_ps2RecompiledFunctionTable[241845] = bhEne17_MV01_0x1ec270; // 0x1ec2dc - g_ps2RecompiledFunctionTable[241866] = bhEne17_MV01_0x1ec270; // 0x1ec330 - g_ps2RecompiledFunctionTable[241878] = bhEne17_MV02_0x1ec360; // 0x1ec360 - g_ps2RecompiledFunctionTable[241894] = bhEne17_MV02_0x1ec360; // 0x1ec3a0 - g_ps2RecompiledFunctionTable[241911] = bhEne17_MV02_0x1ec360; // 0x1ec3e4 - g_ps2RecompiledFunctionTable[241923] = bhEne17_MV02_0x1ec360; // 0x1ec414 - g_ps2RecompiledFunctionTable[241950] = bhEne17_MV03_0x1ec480; // 0x1ec480 - g_ps2RecompiledFunctionTable[241970] = bhEne17_MV03_0x1ec480; // 0x1ec4d0 - g_ps2RecompiledFunctionTable[241997] = bhEne17_MV03_0x1ec480; // 0x1ec53c - g_ps2RecompiledFunctionTable[242011] = bhEne17_MV03_0x1ec480; // 0x1ec574 - g_ps2RecompiledFunctionTable[242021] = bhEne17_MV03_0x1ec480; // 0x1ec59c - g_ps2RecompiledFunctionTable[242027] = bhEne17_MV03_0x1ec480; // 0x1ec5b4 - g_ps2RecompiledFunctionTable[242039] = bhEne17_MV03_0x1ec480; // 0x1ec5e4 - g_ps2RecompiledFunctionTable[242041] = bhEne17_MV03_0x1ec480; // 0x1ec5ec - g_ps2RecompiledFunctionTable[242060] = bhEne17_MV03_0x1ec480; // 0x1ec638 - g_ps2RecompiledFunctionTable[242080] = bhEne17_MV03_0x1ec480; // 0x1ec688 - g_ps2RecompiledFunctionTable[242094] = bhEne17_MV03_0x1ec480; // 0x1ec6c0 - g_ps2RecompiledFunctionTable[242146] = bhEne17_MV04_0x1ec790; // 0x1ec790 - g_ps2RecompiledFunctionTable[242161] = bhEne17_MV04_0x1ec790; // 0x1ec7cc - g_ps2RecompiledFunctionTable[242185] = bhEne17_MV04_0x1ec790; // 0x1ec82c - g_ps2RecompiledFunctionTable[242214] = bhEne17_MV05_0x1ec8a0; // 0x1ec8a0 - g_ps2RecompiledFunctionTable[242234] = bhEne17_MV05_0x1ec8a0; // 0x1ec8f0 - g_ps2RecompiledFunctionTable[242256] = bhEne17_MV05_0x1ec8a0; // 0x1ec948 - g_ps2RecompiledFunctionTable[242266] = bhEne17_MV05_0x1ec8a0; // 0x1ec970 - g_ps2RecompiledFunctionTable[242279] = bhEne17_MV05_0x1ec8a0; // 0x1ec9a4 - g_ps2RecompiledFunctionTable[242289] = bhEne17_MV05_0x1ec8a0; // 0x1ec9cc - g_ps2RecompiledFunctionTable[242295] = bhEne17_MV05_0x1ec8a0; // 0x1ec9e4 - g_ps2RecompiledFunctionTable[242307] = bhEne17_MV05_0x1ec8a0; // 0x1eca14 - g_ps2RecompiledFunctionTable[242309] = bhEne17_MV05_0x1ec8a0; // 0x1eca1c - g_ps2RecompiledFunctionTable[242328] = bhEne17_MV05_0x1ec8a0; // 0x1eca68 - g_ps2RecompiledFunctionTable[242348] = bhEne17_MV05_0x1ec8a0; // 0x1ecab8 - g_ps2RecompiledFunctionTable[242362] = bhEne17_MV06_0x1ecaf0; // 0x1ecaf0 - g_ps2RecompiledFunctionTable[242377] = bhEne17_MV06_0x1ecaf0; // 0x1ecb2c - g_ps2RecompiledFunctionTable[242446] = bhEne17_DGType00_0x1ecc40; // 0x1ecc40 - g_ps2RecompiledFunctionTable[242447] = bhEne17_DGType00_0x1ecc40; // 0x1ecc44 - g_ps2RecompiledFunctionTable[242448] = bhEne17_DGType00_0x1ecc40; // 0x1ecc48 - g_ps2RecompiledFunctionTable[242449] = bhEne17_DGType00_0x1ecc40; // 0x1ecc4c - g_ps2RecompiledFunctionTable[242450] = bhEne17_DGType00_0x1ecc40; // 0x1ecc50 - g_ps2RecompiledFunctionTable[242451] = bhEne17_DGType00_0x1ecc40; // 0x1ecc54 - g_ps2RecompiledFunctionTable[242452] = bhEne17_DGType00_0x1ecc40; // 0x1ecc58 - g_ps2RecompiledFunctionTable[242453] = bhEne17_DGType00_0x1ecc40; // 0x1ecc5c - g_ps2RecompiledFunctionTable[242454] = bhEne17_DG00_0x1ecc60; // 0x1ecc60 - g_ps2RecompiledFunctionTable[242493] = bhEne17_DG00_0x1ecc60; // 0x1eccfc - g_ps2RecompiledFunctionTable[242500] = bhEne17_DG00_0x1ecc60; // 0x1ecd18 - g_ps2RecompiledFunctionTable[242506] = bhEne17_DG00_0x1ecc60; // 0x1ecd30 - g_ps2RecompiledFunctionTable[242509] = bhEne17_DG00_0x1ecc60; // 0x1ecd3c - g_ps2RecompiledFunctionTable[242514] = bhEne17_DG00_0x1ecc60; // 0x1ecd50 - g_ps2RecompiledFunctionTable[242586] = bhEne17_DG00_0x1ecc60; // 0x1ece70 - g_ps2RecompiledFunctionTable[242638] = bhEne17_PlyDG00_0x1ecf40; // 0x1ecf40 - g_ps2RecompiledFunctionTable[242689] = bhEne17_PlyDG00_0x1ecf40; // 0x1ed00c - g_ps2RecompiledFunctionTable[242700] = bhEne17_PlyDG00_0x1ecf40; // 0x1ed038 - g_ps2RecompiledFunctionTable[242705] = bhEne17_PlyDG00_0x1ecf40; // 0x1ed04c - g_ps2RecompiledFunctionTable[242713] = bhEne17_PlyDG00_0x1ecf40; // 0x1ed06c - g_ps2RecompiledFunctionTable[242718] = bhEne17_PlyDG00_0x1ecf40; // 0x1ed080 - g_ps2RecompiledFunctionTable[242724] = bhEne17_PlyDG00_0x1ecf40; // 0x1ed098 - g_ps2RecompiledFunctionTable[242761] = bhEne17_PlyDG00_0x1ecf40; // 0x1ed12c - g_ps2RecompiledFunctionTable[242774] = bhEne17_PlyDG00_0x1ecf40; // 0x1ed160 - g_ps2RecompiledFunctionTable[242784] = bhEne17_PlyDG00_0x1ecf40; // 0x1ed188 - g_ps2RecompiledFunctionTable[242834] = bhEne17_PlyDG01_0x1ed250; // 0x1ed250 - g_ps2RecompiledFunctionTable[242898] = bhEne17_PlyDG01_0x1ed250; // 0x1ed350 - g_ps2RecompiledFunctionTable[242907] = bhEne17_PlyDG01_0x1ed250; // 0x1ed374 - g_ps2RecompiledFunctionTable[242912] = bhEne17_PlyDG01_0x1ed250; // 0x1ed388 - g_ps2RecompiledFunctionTable[242917] = bhEne17_PlyDG01_0x1ed250; // 0x1ed39c - g_ps2RecompiledFunctionTable[242922] = bhEne17_PlyDG01_0x1ed250; // 0x1ed3b0 - g_ps2RecompiledFunctionTable[242930] = bhEne17_PlyDG01_0x1ed250; // 0x1ed3d0 - g_ps2RecompiledFunctionTable[242973] = bhEne17_PlyDG01_0x1ed250; // 0x1ed47c - g_ps2RecompiledFunctionTable[242977] = bhEne17_PlyDG01_0x1ed250; // 0x1ed48c - g_ps2RecompiledFunctionTable[243064] = bhEne17_PlyDG01_0x1ed250; // 0x1ed5e8 - g_ps2RecompiledFunctionTable[243069] = bhEne17_PlyDG01_0x1ed250; // 0x1ed5fc - g_ps2RecompiledFunctionTable[243074] = bhEne17_PlyDG01_0x1ed250; // 0x1ed610 - g_ps2RecompiledFunctionTable[243078] = bhEne17_PlyDG01_0x1ed250; // 0x1ed620 - g_ps2RecompiledFunctionTable[243086] = bhEne17_PlayerDGCheck_0x1ed640; // 0x1ed640 - g_ps2RecompiledFunctionTable[243118] = bhEne17_PlayerDGCheck_0x1ed640; // 0x1ed6c0 - g_ps2RecompiledFunctionTable[243149] = bhEne17_PlayerDGCheck_0x1ed640; // 0x1ed73c - g_ps2RecompiledFunctionTable[243163] = bhEne17_PlayerDGCheck_0x1ed640; // 0x1ed774 - g_ps2RecompiledFunctionTable[243165] = bhEne17_PlayerDGCheck_0x1ed640; // 0x1ed77c - g_ps2RecompiledFunctionTable[243224] = bhEne17_PlayerDGCheck_0x1ed640; // 0x1ed868 - g_ps2RecompiledFunctionTable[243240] = bhEne17_PlayerDGCheck_0x1ed640; // 0x1ed8a8 - g_ps2RecompiledFunctionTable[243246] = bhEne17_PlayerDGCheck_0x1ed640; // 0x1ed8c0 - g_ps2RecompiledFunctionTable[243252] = bhEne17_PlayerDGCheck_0x1ed640; // 0x1ed8d8 - g_ps2RecompiledFunctionTable[243258] = bhEne17_PlayerDGCheck_0x1ed640; // 0x1ed8f0 - g_ps2RecompiledFunctionTable[243264] = bhEne17_PlayerDGCheck_0x1ed640; // 0x1ed908 - g_ps2RecompiledFunctionTable[243270] = bhEne17_PlayerDGCheck_0x1ed640; // 0x1ed920 - g_ps2RecompiledFunctionTable[243276] = bhEne17_PlayerDGCheck_0x1ed640; // 0x1ed938 - g_ps2RecompiledFunctionTable[243282] = bhEne17_PlayerDGCheck_0x1ed640; // 0x1ed950 - g_ps2RecompiledFunctionTable[243289] = bhEne17_PlayerDGCheck_0x1ed640; // 0x1ed96c - g_ps2RecompiledFunctionTable[243306] = bhEne17_SePlay_0x1ed9b0; // 0x1ed9b0 - g_ps2RecompiledFunctionTable[243321] = bhEne17_SePlay_0x1ed9b0; // 0x1ed9ec - g_ps2RecompiledFunctionTable[243326] = bhEne17_CameraControl_0x1eda00; // 0x1eda00 - g_ps2RecompiledFunctionTable[243347] = bhEne17_CameraControl_0x1eda00; // 0x1eda54 - g_ps2RecompiledFunctionTable[243386] = bhEne17_AfterimageAxEffect_0x1edaf0; // 0x1edaf0 - g_ps2RecompiledFunctionTable[243402] = bhEne17_AfterimageAxEffect_0x1edaf0; // 0x1edb30 - g_ps2RecompiledFunctionTable[243459] = bhEne17_AfterimageAxEffect_0x1edaf0; // 0x1edc14 - g_ps2RecompiledFunctionTable[243494] = bhEne17_AfterimageAxEffect_0x1edaf0; // 0x1edca0 - g_ps2RecompiledFunctionTable[243499] = bhEne17_AfterimageAxEffect_0x1edaf0; // 0x1edcb4 - g_ps2RecompiledFunctionTable[243506] = bhEne17_AfterimageAxEffect_0x1edaf0; // 0x1edcd0 - g_ps2RecompiledFunctionTable[243511] = bhEne17_AfterimageAxEffect_0x1edaf0; // 0x1edce4 - g_ps2RecompiledFunctionTable[243518] = bhEne17_AfterimageAxEffect_0x1edaf0; // 0x1edd00 - g_ps2RecompiledFunctionTable[243523] = bhEne17_AfterimageAxEffect_0x1edaf0; // 0x1edd14 - g_ps2RecompiledFunctionTable[243542] = bhEne17_SetSmokeEffect_0x1edd60; // 0x1edd60 - g_ps2RecompiledFunctionTable[243614] = bhEne17_SetSmokeEffect_0x1edd60; // 0x1ede80 - g_ps2RecompiledFunctionTable[243627] = bhEne17_SetSmokeEffect_0x1edd60; // 0x1edeb4 - g_ps2RecompiledFunctionTable[243634] = bhEne17_SetSmokeEffect_0x1edd60; // 0x1eded0 - g_ps2RecompiledFunctionTable[243636] = bhEne17_SetSmokeEffect_0x1edd60; // 0x1eded8 - g_ps2RecompiledFunctionTable[243660] = bhEne17_SetSmokeEffect_0x1edd60; // 0x1edf38 - g_ps2RecompiledFunctionTable[243692] = bhEne17_SetSmokeEffect_0x1edd60; // 0x1edfb8 - g_ps2RecompiledFunctionTable[243712] = bhEne17_SetSmokeEffect_0x1edd60; // 0x1ee008 - g_ps2RecompiledFunctionTable[243754] = bhEne17_SetSmokeEffect2_0x1ee0b0; // 0x1ee0b0 - g_ps2RecompiledFunctionTable[243819] = bhEne17_SetSmokeEffect2_0x1ee0b0; // 0x1ee1b4 - g_ps2RecompiledFunctionTable[243821] = bhEne17_SetSmokeEffect2_0x1ee0b0; // 0x1ee1bc - g_ps2RecompiledFunctionTable[243842] = bhEne17_SetSmokeEffect2_0x1ee0b0; // 0x1ee210 - g_ps2RecompiledFunctionTable[243871] = bhEne17_SetSmokeEffect2_0x1ee0b0; // 0x1ee284 - g_ps2RecompiledFunctionTable[243891] = bhEne17_SetSmokeEffect2_0x1ee0b0; // 0x1ee2d4 - g_ps2RecompiledFunctionTable[243930] = bhEne17_SetSmokeEffect3_0x1ee370; // 0x1ee370 - g_ps2RecompiledFunctionTable[244002] = bhEne17_SetSmokeEffect3_0x1ee370; // 0x1ee490 - g_ps2RecompiledFunctionTable[244026] = bhEne17_SetSmokeEffect3_0x1ee370; // 0x1ee4f0 - g_ps2RecompiledFunctionTable[244058] = bhEne17_SetSmokeEffect3_0x1ee370; // 0x1ee570 - g_ps2RecompiledFunctionTable[244084] = bhEne17_SetSmokeEffect3_0x1ee370; // 0x1ee5d8 - g_ps2RecompiledFunctionTable[244126] = bhEne17_SetLight_0x1ee680; // 0x1ee680 - g_ps2RecompiledFunctionTable[244158] = bhEne17LArm_0x1ee700; // 0x1ee700 - g_ps2RecompiledFunctionTable[244159] = bhEne17LArm_0x1ee700; // 0x1ee704 - g_ps2RecompiledFunctionTable[244160] = bhEne17LArm_0x1ee700; // 0x1ee708 - g_ps2RecompiledFunctionTable[244161] = bhEne17LArm_0x1ee700; // 0x1ee70c - g_ps2RecompiledFunctionTable[244162] = bhEne17LArm_0x1ee700; // 0x1ee710 - g_ps2RecompiledFunctionTable[244163] = bhEne17LArm_0x1ee700; // 0x1ee714 - g_ps2RecompiledFunctionTable[244164] = bhEne17LArm_0x1ee700; // 0x1ee718 - g_ps2RecompiledFunctionTable[244165] = bhEne17LArm_0x1ee700; // 0x1ee71c - g_ps2RecompiledFunctionTable[244166] = bhEne17LArm_0x1ee700; // 0x1ee720 - g_ps2RecompiledFunctionTable[244167] = bhEne17LArm_0x1ee700; // 0x1ee724 - g_ps2RecompiledFunctionTable[244168] = bhEne17LArm_0x1ee700; // 0x1ee728 - g_ps2RecompiledFunctionTable[244169] = bhEne17LArm_0x1ee700; // 0x1ee72c - g_ps2RecompiledFunctionTable[244170] = bhEne17LArm_0x1ee700; // 0x1ee730 - g_ps2RecompiledFunctionTable[244171] = bhEne17LArm_0x1ee700; // 0x1ee734 - g_ps2RecompiledFunctionTable[244172] = bhEne17LArm_0x1ee700; // 0x1ee738 - g_ps2RecompiledFunctionTable[244173] = bhEne17LArm_0x1ee700; // 0x1ee73c - g_ps2RecompiledFunctionTable[244174] = bhEne17LArm_0x1ee700; // 0x1ee740 - g_ps2RecompiledFunctionTable[244175] = bhEne17LArm_0x1ee700; // 0x1ee744 - g_ps2RecompiledFunctionTable[244176] = bhEne17LArm_0x1ee700; // 0x1ee748 - g_ps2RecompiledFunctionTable[244177] = bhEne17LArm_0x1ee700; // 0x1ee74c - g_ps2RecompiledFunctionTable[244178] = bhEne17LArm_0x1ee700; // 0x1ee750 - g_ps2RecompiledFunctionTable[244179] = bhEne17LArm_0x1ee700; // 0x1ee754 - g_ps2RecompiledFunctionTable[244180] = bhEne17LArm_0x1ee700; // 0x1ee758 - g_ps2RecompiledFunctionTable[244181] = bhEne17LArm_0x1ee700; // 0x1ee75c - g_ps2RecompiledFunctionTable[244182] = bhEne17LArm_0x1ee700; // 0x1ee760 - g_ps2RecompiledFunctionTable[244183] = bhEne17LArm_0x1ee700; // 0x1ee764 - g_ps2RecompiledFunctionTable[244184] = bhEne17LArm_0x1ee700; // 0x1ee768 - g_ps2RecompiledFunctionTable[244185] = bhEne17LArm_0x1ee700; // 0x1ee76c - g_ps2RecompiledFunctionTable[244186] = bhEne17LArm_0x1ee700; // 0x1ee770 - g_ps2RecompiledFunctionTable[244187] = bhEne17LArm_0x1ee700; // 0x1ee774 - g_ps2RecompiledFunctionTable[244188] = bhEne17LArm_0x1ee700; // 0x1ee778 - g_ps2RecompiledFunctionTable[244189] = bhEne17LArm_0x1ee700; // 0x1ee77c - g_ps2RecompiledFunctionTable[244190] = bhEne17LArm_0x1ee700; // 0x1ee780 - g_ps2RecompiledFunctionTable[244191] = bhEne17LArm_0x1ee700; // 0x1ee784 - g_ps2RecompiledFunctionTable[244192] = bhEne17LArm_0x1ee700; // 0x1ee788 - g_ps2RecompiledFunctionTable[244193] = bhEne17LArm_0x1ee700; // 0x1ee78c - g_ps2RecompiledFunctionTable[244194] = bhEne17LArm_0x1ee700; // 0x1ee790 - g_ps2RecompiledFunctionTable[244195] = bhEne17LArm_0x1ee700; // 0x1ee794 - g_ps2RecompiledFunctionTable[244196] = bhEne17LArm_0x1ee700; // 0x1ee798 - g_ps2RecompiledFunctionTable[244197] = bhEne17LArm_0x1ee700; // 0x1ee79c - g_ps2RecompiledFunctionTable[244198] = bhEne17LArm_0x1ee700; // 0x1ee7a0 - g_ps2RecompiledFunctionTable[244199] = bhEne17LArm_0x1ee700; // 0x1ee7a4 - g_ps2RecompiledFunctionTable[244200] = bhEne17LArm_0x1ee700; // 0x1ee7a8 - g_ps2RecompiledFunctionTable[244201] = bhEne17LArm_0x1ee700; // 0x1ee7ac - g_ps2RecompiledFunctionTable[244202] = bhEne17LArm_0x1ee700; // 0x1ee7b0 - g_ps2RecompiledFunctionTable[244203] = bhEne17LArm_0x1ee700; // 0x1ee7b4 - g_ps2RecompiledFunctionTable[244204] = bhEne17LArm_0x1ee700; // 0x1ee7b8 - g_ps2RecompiledFunctionTable[244205] = bhEne17LArm_0x1ee700; // 0x1ee7bc - g_ps2RecompiledFunctionTable[244206] = bhEne17LArm_0x1ee700; // 0x1ee7c0 - g_ps2RecompiledFunctionTable[244207] = bhEne17LArm_0x1ee700; // 0x1ee7c4 - g_ps2RecompiledFunctionTable[244210] = bhEne17LArm_Init_0x1ee7d0; // 0x1ee7d0 - g_ps2RecompiledFunctionTable[244221] = bhEne17LArm_Init_0x1ee7d0; // 0x1ee7fc - g_ps2RecompiledFunctionTable[244232] = bhEne17LArm_Init_0x1ee7d0; // 0x1ee828 - g_ps2RecompiledFunctionTable[244246] = bhEne17LArm_Move_0x1ee860; // 0x1ee860 - g_ps2RecompiledFunctionTable[244250] = bhEne17RArm_0x1ee870; // 0x1ee870 - g_ps2RecompiledFunctionTable[244251] = bhEne17RArm_0x1ee870; // 0x1ee874 - g_ps2RecompiledFunctionTable[244252] = bhEne17RArm_0x1ee870; // 0x1ee878 - g_ps2RecompiledFunctionTable[244253] = bhEne17RArm_0x1ee870; // 0x1ee87c - g_ps2RecompiledFunctionTable[244254] = bhEne17RArm_0x1ee870; // 0x1ee880 - g_ps2RecompiledFunctionTable[244255] = bhEne17RArm_0x1ee870; // 0x1ee884 - g_ps2RecompiledFunctionTable[244256] = bhEne17RArm_0x1ee870; // 0x1ee888 - g_ps2RecompiledFunctionTable[244257] = bhEne17RArm_0x1ee870; // 0x1ee88c - g_ps2RecompiledFunctionTable[244258] = bhEne17RArm_0x1ee870; // 0x1ee890 - g_ps2RecompiledFunctionTable[244259] = bhEne17RArm_0x1ee870; // 0x1ee894 - g_ps2RecompiledFunctionTable[244260] = bhEne17RArm_0x1ee870; // 0x1ee898 - g_ps2RecompiledFunctionTable[244261] = bhEne17RArm_0x1ee870; // 0x1ee89c - g_ps2RecompiledFunctionTable[244262] = bhEne17RArm_0x1ee870; // 0x1ee8a0 - g_ps2RecompiledFunctionTable[244263] = bhEne17RArm_0x1ee870; // 0x1ee8a4 - g_ps2RecompiledFunctionTable[244264] = bhEne17RArm_0x1ee870; // 0x1ee8a8 - g_ps2RecompiledFunctionTable[244265] = bhEne17RArm_0x1ee870; // 0x1ee8ac - g_ps2RecompiledFunctionTable[244266] = bhEne17RArm_0x1ee870; // 0x1ee8b0 - g_ps2RecompiledFunctionTable[244267] = bhEne17RArm_0x1ee870; // 0x1ee8b4 - g_ps2RecompiledFunctionTable[244270] = bhEne17RArm_Init_0x1ee8c0; // 0x1ee8c0 - g_ps2RecompiledFunctionTable[244286] = bhEne17RArm_Move_0x1ee900; // 0x1ee900 - g_ps2RecompiledFunctionTable[244290] = bhEne17_AxsCheck_0x1ee910; // 0x1ee910 - g_ps2RecompiledFunctionTable[244308] = bhEne17_AxsCheck_0x1ee910; // 0x1ee958 - g_ps2RecompiledFunctionTable[244310] = bhEne17_AxsCheck_0x1ee910; // 0x1ee960 - g_ps2RecompiledFunctionTable[244377] = bhEne17_AxsCheck_0x1ee910; // 0x1eea6c - g_ps2RecompiledFunctionTable[244405] = bhEne17_AxsCheck_0x1ee910; // 0x1eeadc - g_ps2RecompiledFunctionTable[244418] = bhEne17_AxsCheck_0x1ee910; // 0x1eeb10 - g_ps2RecompiledFunctionTable[244424] = bhEne17_AxsCheck_0x1ee910; // 0x1eeb28 - g_ps2RecompiledFunctionTable[244452] = bhEne17_AxsCheck_0x1ee910; // 0x1eeb98 - g_ps2RecompiledFunctionTable[244465] = bhEne17_AxsCheck_0x1ee910; // 0x1eebcc - g_ps2RecompiledFunctionTable[244478] = bhEne18_0x1eec00; // 0x1eec00 - g_ps2RecompiledFunctionTable[244479] = bhEne18_0x1eec00; // 0x1eec04 - g_ps2RecompiledFunctionTable[244480] = bhEne18_0x1eec00; // 0x1eec08 - g_ps2RecompiledFunctionTable[244481] = bhEne18_0x1eec00; // 0x1eec0c - g_ps2RecompiledFunctionTable[244482] = bhEne18_0x1eec00; // 0x1eec10 - g_ps2RecompiledFunctionTable[244483] = bhEne18_0x1eec00; // 0x1eec14 - g_ps2RecompiledFunctionTable[244484] = bhEne18_0x1eec00; // 0x1eec18 - g_ps2RecompiledFunctionTable[244485] = bhEne18_0x1eec00; // 0x1eec1c - g_ps2RecompiledFunctionTable[244486] = bhEne18_0x1eec00; // 0x1eec20 - g_ps2RecompiledFunctionTable[244487] = bhEne18_0x1eec00; // 0x1eec24 - g_ps2RecompiledFunctionTable[244488] = bhEne18_0x1eec00; // 0x1eec28 - g_ps2RecompiledFunctionTable[244489] = bhEne18_0x1eec00; // 0x1eec2c - g_ps2RecompiledFunctionTable[244490] = bhEne18_0x1eec00; // 0x1eec30 - g_ps2RecompiledFunctionTable[244491] = bhEne18_0x1eec00; // 0x1eec34 - g_ps2RecompiledFunctionTable[244492] = bhEne18_0x1eec00; // 0x1eec38 - g_ps2RecompiledFunctionTable[244493] = bhEne18_0x1eec00; // 0x1eec3c - g_ps2RecompiledFunctionTable[244494] = bhEne18_0x1eec00; // 0x1eec40 - g_ps2RecompiledFunctionTable[244495] = bhEne18_0x1eec00; // 0x1eec44 - g_ps2RecompiledFunctionTable[244496] = bhEne18_0x1eec00; // 0x1eec48 - g_ps2RecompiledFunctionTable[244497] = bhEne18_0x1eec00; // 0x1eec4c - g_ps2RecompiledFunctionTable[244498] = bhEne18_0x1eec00; // 0x1eec50 - g_ps2RecompiledFunctionTable[244499] = bhEne18_0x1eec00; // 0x1eec54 - g_ps2RecompiledFunctionTable[244500] = bhEne18_0x1eec00; // 0x1eec58 - g_ps2RecompiledFunctionTable[244501] = bhEne18_0x1eec00; // 0x1eec5c - g_ps2RecompiledFunctionTable[244502] = bhEne18_0x1eec00; // 0x1eec60 - g_ps2RecompiledFunctionTable[244503] = bhEne18_0x1eec00; // 0x1eec64 - g_ps2RecompiledFunctionTable[244504] = bhEne18_0x1eec00; // 0x1eec68 - g_ps2RecompiledFunctionTable[244505] = bhEne18_0x1eec00; // 0x1eec6c - g_ps2RecompiledFunctionTable[244506] = bhEne18_0x1eec00; // 0x1eec70 - g_ps2RecompiledFunctionTable[244507] = bhEne18_0x1eec00; // 0x1eec74 - g_ps2RecompiledFunctionTable[244508] = bhEne18_0x1eec00; // 0x1eec78 - g_ps2RecompiledFunctionTable[244510] = bhEne18_Init_0x1eec80; // 0x1eec80 - g_ps2RecompiledFunctionTable[244570] = bhEne18_Init_0x1eec80; // 0x1eed70 - g_ps2RecompiledFunctionTable[244595] = bhEne18_Init_0x1eec80; // 0x1eedd4 - g_ps2RecompiledFunctionTable[244706] = bhEne18_Init_0x1eec80; // 0x1eef90 - g_ps2RecompiledFunctionTable[244709] = bhEne18_Init_0x1eec80; // 0x1eef9c - g_ps2RecompiledFunctionTable[244713] = bhEne18_Init_0x1eec80; // 0x1eefac - g_ps2RecompiledFunctionTable[244733] = bhEne18_Init_0x1eec80; // 0x1eeffc - g_ps2RecompiledFunctionTable[244736] = bhEne18_Init_0x1eec80; // 0x1ef008 - g_ps2RecompiledFunctionTable[244740] = bhEne18_Init_0x1eec80; // 0x1ef018 - g_ps2RecompiledFunctionTable[244767] = bhEne18_Init_0x1eec80; // 0x1ef084 - g_ps2RecompiledFunctionTable[244770] = bhEne18_Init_0x1eec80; // 0x1ef090 - g_ps2RecompiledFunctionTable[244774] = bhEne18_Init_0x1eec80; // 0x1ef0a0 - g_ps2RecompiledFunctionTable[244794] = bhEne18_Init_0x1eec80; // 0x1ef0f0 - g_ps2RecompiledFunctionTable[244797] = bhEne18_Init_0x1eec80; // 0x1ef0fc - g_ps2RecompiledFunctionTable[244801] = bhEne18_Init_0x1eec80; // 0x1ef10c - g_ps2RecompiledFunctionTable[244828] = bhEne18_Init_0x1eec80; // 0x1ef178 - g_ps2RecompiledFunctionTable[244831] = bhEne18_Init_0x1eec80; // 0x1ef184 - g_ps2RecompiledFunctionTable[244835] = bhEne18_Init_0x1eec80; // 0x1ef194 - g_ps2RecompiledFunctionTable[244853] = bhEne18_Init_0x1eec80; // 0x1ef1dc - g_ps2RecompiledFunctionTable[244856] = bhEne18_Init_0x1eec80; // 0x1ef1e8 - g_ps2RecompiledFunctionTable[244860] = bhEne18_Init_0x1eec80; // 0x1ef1f8 - g_ps2RecompiledFunctionTable[244888] = bhEne18_Init_0x1eec80; // 0x1ef268 - g_ps2RecompiledFunctionTable[244891] = bhEne18_Init_0x1eec80; // 0x1ef274 - g_ps2RecompiledFunctionTable[244895] = bhEne18_Init_0x1eec80; // 0x1ef284 - g_ps2RecompiledFunctionTable[244914] = bhEne18_Init_0x1eec80; // 0x1ef2d0 - g_ps2RecompiledFunctionTable[244917] = bhEne18_Init_0x1eec80; // 0x1ef2dc - g_ps2RecompiledFunctionTable[244921] = bhEne18_Init_0x1eec80; // 0x1ef2ec - g_ps2RecompiledFunctionTable[244949] = bhEne18_Init_0x1eec80; // 0x1ef35c - g_ps2RecompiledFunctionTable[244952] = bhEne18_Init_0x1eec80; // 0x1ef368 - g_ps2RecompiledFunctionTable[244956] = bhEne18_Init_0x1eec80; // 0x1ef378 - g_ps2RecompiledFunctionTable[244975] = bhEne18_Init_0x1eec80; // 0x1ef3c4 - g_ps2RecompiledFunctionTable[244978] = bhEne18_Init_0x1eec80; // 0x1ef3d0 - g_ps2RecompiledFunctionTable[244982] = bhEne18_Init_0x1eec80; // 0x1ef3e0 - g_ps2RecompiledFunctionTable[245006] = bhEne18_Move_0x1ef440; // 0x1ef440 - g_ps2RecompiledFunctionTable[245007] = bhEne18_Move_0x1ef440; // 0x1ef444 - g_ps2RecompiledFunctionTable[245008] = bhEne18_Move_0x1ef440; // 0x1ef448 - g_ps2RecompiledFunctionTable[245009] = bhEne18_Move_0x1ef440; // 0x1ef44c - g_ps2RecompiledFunctionTable[245010] = bhEne18_Move_0x1ef440; // 0x1ef450 - g_ps2RecompiledFunctionTable[245011] = bhEne18_Move_0x1ef440; // 0x1ef454 - g_ps2RecompiledFunctionTable[245012] = bhEne18_Move_0x1ef440; // 0x1ef458 - g_ps2RecompiledFunctionTable[245013] = bhEne18_Move_0x1ef440; // 0x1ef45c - g_ps2RecompiledFunctionTable[245014] = bhEne18_MV00_0x1ef460; // 0x1ef460 - g_ps2RecompiledFunctionTable[245034] = bhEne18_MV01_0x1ef4b0; // 0x1ef4b0 - g_ps2RecompiledFunctionTable[245057] = bhEne18_MV01_0x1ef4b0; // 0x1ef50c - g_ps2RecompiledFunctionTable[245094] = bhEne18_MV02_0x1ef5a0; // 0x1ef5a0 - g_ps2RecompiledFunctionTable[245122] = bhEne18_MV02_0x1ef5a0; // 0x1ef610 - g_ps2RecompiledFunctionTable[245130] = bhEne18_MV02_0x1ef5a0; // 0x1ef630 - g_ps2RecompiledFunctionTable[245133] = bhEne18_MV02_0x1ef5a0; // 0x1ef63c - g_ps2RecompiledFunctionTable[245144] = bhEne18_MV02_0x1ef5a0; // 0x1ef668 - g_ps2RecompiledFunctionTable[245149] = bhEne18_MV02_0x1ef5a0; // 0x1ef67c - g_ps2RecompiledFunctionTable[245156] = bhEne18_MV02_0x1ef5a0; // 0x1ef698 - g_ps2RecompiledFunctionTable[245231] = bhEne18_MV02_0x1ef5a0; // 0x1ef7c4 - g_ps2RecompiledFunctionTable[245250] = bhEne18_MV03_0x1ef810; // 0x1ef810 - g_ps2RecompiledFunctionTable[245254] = bhEne18_MV04_0x1ef820; // 0x1ef820 - g_ps2RecompiledFunctionTable[245282] = bhEne18_MV04_0x1ef820; // 0x1ef890 - g_ps2RecompiledFunctionTable[245285] = bhEne18_MV04_0x1ef820; // 0x1ef89c - g_ps2RecompiledFunctionTable[245293] = bhEne18_MV04_0x1ef820; // 0x1ef8bc - g_ps2RecompiledFunctionTable[245296] = bhEne18_MV04_0x1ef820; // 0x1ef8c8 - g_ps2RecompiledFunctionTable[245307] = bhEne18_MV04_0x1ef820; // 0x1ef8f4 - g_ps2RecompiledFunctionTable[245312] = bhEne18_MV04_0x1ef820; // 0x1ef908 - g_ps2RecompiledFunctionTable[245323] = bhEne18_MV04_0x1ef820; // 0x1ef934 - g_ps2RecompiledFunctionTable[245329] = bhEne18_MV04_0x1ef820; // 0x1ef94c - g_ps2RecompiledFunctionTable[245406] = bhEne18_MV04_0x1ef820; // 0x1efa80 - g_ps2RecompiledFunctionTable[245426] = bhEne18_MV05_0x1efad0; // 0x1efad0 - g_ps2RecompiledFunctionTable[245454] = bhEne18_MV05_0x1efad0; // 0x1efb40 - g_ps2RecompiledFunctionTable[245457] = bhEne18_MV05_0x1efad0; // 0x1efb4c - g_ps2RecompiledFunctionTable[245465] = bhEne18_MV05_0x1efad0; // 0x1efb6c - g_ps2RecompiledFunctionTable[245468] = bhEne18_MV05_0x1efad0; // 0x1efb78 - g_ps2RecompiledFunctionTable[245479] = bhEne18_MV05_0x1efad0; // 0x1efba4 - g_ps2RecompiledFunctionTable[245484] = bhEne18_MV05_0x1efad0; // 0x1efbb8 - g_ps2RecompiledFunctionTable[245495] = bhEne18_MV05_0x1efad0; // 0x1efbe4 - g_ps2RecompiledFunctionTable[245501] = bhEne18_MV05_0x1efad0; // 0x1efbfc - g_ps2RecompiledFunctionTable[245578] = bhEne18_MV05_0x1efad0; // 0x1efd30 - g_ps2RecompiledFunctionTable[245598] = bhEne18_Nage_0x1efd80; // 0x1efd80 - g_ps2RecompiledFunctionTable[245602] = bhEne18_Damage_0x1efd90; // 0x1efd90 - g_ps2RecompiledFunctionTable[245606] = bhEne18_Die_0x1efda0; // 0x1efda0 - g_ps2RecompiledFunctionTable[245626] = bhEne18_HitMark_0x1efdf0; // 0x1efdf0 - g_ps2RecompiledFunctionTable[245642] = bhEne18_HitMark_0x1efdf0; // 0x1efe30 - g_ps2RecompiledFunctionTable[245671] = bhEne18_HitMark_0x1efdf0; // 0x1efea4 - g_ps2RecompiledFunctionTable[245684] = bhEne18_HitMark_0x1efdf0; // 0x1efed8 - g_ps2RecompiledFunctionTable[245699] = bhEne18_HitMark_0x1efdf0; // 0x1eff14 - g_ps2RecompiledFunctionTable[245715] = bhEne18_HitMark_0x1efdf0; // 0x1eff54 - g_ps2RecompiledFunctionTable[245731] = bhEne18_HitMark_0x1efdf0; // 0x1eff94 - g_ps2RecompiledFunctionTable[245769] = bhEne18_HitMark_0x1efdf0; // 0x1f002c - g_ps2RecompiledFunctionTable[245783] = bhEne18_HitMark_0x1efdf0; // 0x1f0064 - g_ps2RecompiledFunctionTable[245798] = bhEne18_HitMark_0x1efdf0; // 0x1f00a0 - g_ps2RecompiledFunctionTable[245816] = bhEne18_HitMark_0x1efdf0; // 0x1f00e8 - g_ps2RecompiledFunctionTable[245818] = bhEne18_HitMark_0x1efdf0; // 0x1f00f0 - g_ps2RecompiledFunctionTable[245831] = bhEne18_HitMark_0x1efdf0; // 0x1f0124 - g_ps2RecompiledFunctionTable[245846] = bhEne18_HitMark_0x1efdf0; // 0x1f0160 - g_ps2RecompiledFunctionTable[245862] = bhEne18_HitMark_0x1efdf0; // 0x1f01a0 - g_ps2RecompiledFunctionTable[245878] = bhEne18_HitMark_0x1efdf0; // 0x1f01e0 - g_ps2RecompiledFunctionTable[245893] = bhEne18_HitMark_0x1efdf0; // 0x1f021c - g_ps2RecompiledFunctionTable[245906] = bhEne18_HitMark_0x1efdf0; // 0x1f0250 - g_ps2RecompiledFunctionTable[245919] = bhEne18_HitMark_0x1efdf0; // 0x1f0284 - g_ps2RecompiledFunctionTable[245925] = bhEne18_HitMark_0x1efdf0; // 0x1f029c - g_ps2RecompiledFunctionTable[245945] = bhEne18_HitMark_0x1efdf0; // 0x1f02ec - g_ps2RecompiledFunctionTable[245958] = bhEne18_HitMark_0x1efdf0; // 0x1f0320 - g_ps2RecompiledFunctionTable[245973] = bhEne18_HitMark_0x1efdf0; // 0x1f035c - g_ps2RecompiledFunctionTable[245989] = bhEne18_HitMark_0x1efdf0; // 0x1f039c - g_ps2RecompiledFunctionTable[246005] = bhEne18_HitMark_0x1efdf0; // 0x1f03dc - g_ps2RecompiledFunctionTable[246023] = bhEne18_HitMark_0x1efdf0; // 0x1f0424 - g_ps2RecompiledFunctionTable[246034] = bhEne19_0x1f0450; // 0x1f0450 - g_ps2RecompiledFunctionTable[246035] = bhEne19_0x1f0450; // 0x1f0454 - g_ps2RecompiledFunctionTable[246036] = bhEne19_0x1f0450; // 0x1f0458 - g_ps2RecompiledFunctionTable[246037] = bhEne19_0x1f0450; // 0x1f045c - g_ps2RecompiledFunctionTable[246038] = bhEne19_0x1f0450; // 0x1f0460 - g_ps2RecompiledFunctionTable[246039] = bhEne19_0x1f0450; // 0x1f0464 - g_ps2RecompiledFunctionTable[246040] = bhEne19_0x1f0450; // 0x1f0468 - g_ps2RecompiledFunctionTable[246041] = bhEne19_0x1f0450; // 0x1f046c - g_ps2RecompiledFunctionTable[246042] = bhEne19_0x1f0450; // 0x1f0470 - g_ps2RecompiledFunctionTable[246043] = bhEne19_0x1f0450; // 0x1f0474 - g_ps2RecompiledFunctionTable[246044] = bhEne19_0x1f0450; // 0x1f0478 - g_ps2RecompiledFunctionTable[246045] = bhEne19_0x1f0450; // 0x1f047c - g_ps2RecompiledFunctionTable[246046] = bhEne19_0x1f0450; // 0x1f0480 - g_ps2RecompiledFunctionTable[246047] = bhEne19_0x1f0450; // 0x1f0484 - g_ps2RecompiledFunctionTable[246048] = bhEne19_0x1f0450; // 0x1f0488 - g_ps2RecompiledFunctionTable[246049] = bhEne19_0x1f0450; // 0x1f048c - g_ps2RecompiledFunctionTable[246050] = bhEne19_0x1f0450; // 0x1f0490 - g_ps2RecompiledFunctionTable[246051] = bhEne19_0x1f0450; // 0x1f0494 - g_ps2RecompiledFunctionTable[246052] = bhEne19_0x1f0450; // 0x1f0498 - g_ps2RecompiledFunctionTable[246053] = bhEne19_0x1f0450; // 0x1f049c - g_ps2RecompiledFunctionTable[246054] = bhEne19_0x1f0450; // 0x1f04a0 - g_ps2RecompiledFunctionTable[246055] = bhEne19_0x1f0450; // 0x1f04a4 - g_ps2RecompiledFunctionTable[246056] = bhEne19_0x1f0450; // 0x1f04a8 - g_ps2RecompiledFunctionTable[246057] = bhEne19_0x1f0450; // 0x1f04ac - g_ps2RecompiledFunctionTable[246058] = bhEne19_0x1f0450; // 0x1f04b0 - g_ps2RecompiledFunctionTable[246059] = bhEne19_0x1f0450; // 0x1f04b4 - g_ps2RecompiledFunctionTable[246060] = bhEne19_0x1f0450; // 0x1f04b8 - g_ps2RecompiledFunctionTable[246061] = bhEne19_0x1f0450; // 0x1f04bc - g_ps2RecompiledFunctionTable[246062] = bhEne19_0x1f0450; // 0x1f04c0 - g_ps2RecompiledFunctionTable[246063] = bhEne19_0x1f0450; // 0x1f04c4 - g_ps2RecompiledFunctionTable[246064] = bhEne19_0x1f0450; // 0x1f04c8 - g_ps2RecompiledFunctionTable[246065] = bhEne19_0x1f0450; // 0x1f04cc - g_ps2RecompiledFunctionTable[246066] = bhEne19_0x1f0450; // 0x1f04d0 - g_ps2RecompiledFunctionTable[246067] = bhEne19_0x1f0450; // 0x1f04d4 - g_ps2RecompiledFunctionTable[246068] = bhEne19_0x1f0450; // 0x1f04d8 - g_ps2RecompiledFunctionTable[246069] = bhEne19_0x1f0450; // 0x1f04dc - g_ps2RecompiledFunctionTable[246070] = bhEne19_0x1f0450; // 0x1f04e0 - g_ps2RecompiledFunctionTable[246071] = bhEne19_0x1f0450; // 0x1f04e4 - g_ps2RecompiledFunctionTable[246072] = bhEne19_0x1f0450; // 0x1f04e8 - g_ps2RecompiledFunctionTable[246073] = bhEne19_0x1f0450; // 0x1f04ec - g_ps2RecompiledFunctionTable[246074] = bhEne19_0x1f0450; // 0x1f04f0 - g_ps2RecompiledFunctionTable[246075] = bhEne19_0x1f0450; // 0x1f04f4 - g_ps2RecompiledFunctionTable[246076] = bhEne19_0x1f0450; // 0x1f04f8 - g_ps2RecompiledFunctionTable[246077] = bhEne19_0x1f0450; // 0x1f04fc - g_ps2RecompiledFunctionTable[246078] = bhEne19_0x1f0450; // 0x1f0500 - g_ps2RecompiledFunctionTable[246079] = bhEne19_0x1f0450; // 0x1f0504 - g_ps2RecompiledFunctionTable[246080] = bhEne19_0x1f0450; // 0x1f0508 - g_ps2RecompiledFunctionTable[246081] = bhEne19_0x1f0450; // 0x1f050c - g_ps2RecompiledFunctionTable[246082] = bhEne19_0x1f0450; // 0x1f0510 - g_ps2RecompiledFunctionTable[246083] = bhEne19_0x1f0450; // 0x1f0514 - g_ps2RecompiledFunctionTable[246084] = bhEne19_0x1f0450; // 0x1f0518 - g_ps2RecompiledFunctionTable[246085] = bhEne19_0x1f0450; // 0x1f051c - g_ps2RecompiledFunctionTable[246086] = bhEne19_0x1f0450; // 0x1f0520 - g_ps2RecompiledFunctionTable[246087] = bhEne19_0x1f0450; // 0x1f0524 - g_ps2RecompiledFunctionTable[246088] = bhEne19_0x1f0450; // 0x1f0528 - g_ps2RecompiledFunctionTable[246089] = bhEne19_0x1f0450; // 0x1f052c - g_ps2RecompiledFunctionTable[246090] = bhEne19_0x1f0450; // 0x1f0530 - g_ps2RecompiledFunctionTable[246091] = bhEne19_0x1f0450; // 0x1f0534 - g_ps2RecompiledFunctionTable[246092] = bhEne19_0x1f0450; // 0x1f0538 - g_ps2RecompiledFunctionTable[246093] = bhEne19_0x1f0450; // 0x1f053c - g_ps2RecompiledFunctionTable[246094] = bhEne19_0x1f0450; // 0x1f0540 - g_ps2RecompiledFunctionTable[246095] = bhEne19_0x1f0450; // 0x1f0544 - g_ps2RecompiledFunctionTable[246096] = bhEne19_0x1f0450; // 0x1f0548 - g_ps2RecompiledFunctionTable[246097] = bhEne19_0x1f0450; // 0x1f054c - g_ps2RecompiledFunctionTable[246098] = bhEne19_0x1f0450; // 0x1f0550 - g_ps2RecompiledFunctionTable[246099] = bhEne19_0x1f0450; // 0x1f0554 - g_ps2RecompiledFunctionTable[246100] = bhEne19_0x1f0450; // 0x1f0558 - g_ps2RecompiledFunctionTable[246101] = bhEne19_0x1f0450; // 0x1f055c - g_ps2RecompiledFunctionTable[246102] = bhEne19_0x1f0450; // 0x1f0560 - g_ps2RecompiledFunctionTable[246103] = bhEne19_0x1f0450; // 0x1f0564 - g_ps2RecompiledFunctionTable[246104] = bhEne19_0x1f0450; // 0x1f0568 - g_ps2RecompiledFunctionTable[246105] = bhEne19_0x1f0450; // 0x1f056c - g_ps2RecompiledFunctionTable[246106] = bhEne19_0x1f0450; // 0x1f0570 - g_ps2RecompiledFunctionTable[246107] = bhEne19_0x1f0450; // 0x1f0574 - g_ps2RecompiledFunctionTable[246108] = bhEne19_0x1f0450; // 0x1f0578 - g_ps2RecompiledFunctionTable[246109] = bhEne19_0x1f0450; // 0x1f057c - g_ps2RecompiledFunctionTable[246110] = bhEne19_0x1f0450; // 0x1f0580 - g_ps2RecompiledFunctionTable[246111] = bhEne19_0x1f0450; // 0x1f0584 - g_ps2RecompiledFunctionTable[246112] = bhEne19_0x1f0450; // 0x1f0588 - g_ps2RecompiledFunctionTable[246113] = bhEne19_0x1f0450; // 0x1f058c - g_ps2RecompiledFunctionTable[246114] = bhEne19_0x1f0450; // 0x1f0590 - g_ps2RecompiledFunctionTable[246115] = bhEne19_0x1f0450; // 0x1f0594 - g_ps2RecompiledFunctionTable[246116] = bhEne19_0x1f0450; // 0x1f0598 - g_ps2RecompiledFunctionTable[246118] = bhEne19_Init_0x1f05a0; // 0x1f05a0 - g_ps2RecompiledFunctionTable[246129] = bhEne19_Init_0x1f05a0; // 0x1f05cc - g_ps2RecompiledFunctionTable[246134] = bhEne19_Init_0x1f05a0; // 0x1f05e0 - g_ps2RecompiledFunctionTable[246256] = bhEne19_Init_0x1f05a0; // 0x1f07c8 - g_ps2RecompiledFunctionTable[246332] = bhEne19_Init_0x1f05a0; // 0x1f08f8 - g_ps2RecompiledFunctionTable[246338] = bhEne19_Init_0x1f05a0; // 0x1f0910 - g_ps2RecompiledFunctionTable[246362] = bhEne19_Move_0x1f0970; // 0x1f0970 - g_ps2RecompiledFunctionTable[246363] = bhEne19_Move_0x1f0970; // 0x1f0974 - g_ps2RecompiledFunctionTable[246364] = bhEne19_Move_0x1f0970; // 0x1f0978 - g_ps2RecompiledFunctionTable[246365] = bhEne19_Move_0x1f0970; // 0x1f097c - g_ps2RecompiledFunctionTable[246366] = bhEne19_Move_0x1f0970; // 0x1f0980 - g_ps2RecompiledFunctionTable[246367] = bhEne19_Move_0x1f0970; // 0x1f0984 - g_ps2RecompiledFunctionTable[246368] = bhEne19_Move_0x1f0970; // 0x1f0988 - g_ps2RecompiledFunctionTable[246369] = bhEne19_Move_0x1f0970; // 0x1f098c - g_ps2RecompiledFunctionTable[246370] = bhEne19_Move_0x1f0970; // 0x1f0990 - g_ps2RecompiledFunctionTable[246371] = bhEne19_Move_0x1f0970; // 0x1f0994 - g_ps2RecompiledFunctionTable[246372] = bhEne19_Move_0x1f0970; // 0x1f0998 - g_ps2RecompiledFunctionTable[246373] = bhEne19_Move_0x1f0970; // 0x1f099c - g_ps2RecompiledFunctionTable[246374] = bhEne19_Move_0x1f0970; // 0x1f09a0 - g_ps2RecompiledFunctionTable[246375] = bhEne19_Move_0x1f0970; // 0x1f09a4 - g_ps2RecompiledFunctionTable[246376] = bhEne19_Move_0x1f0970; // 0x1f09a8 - g_ps2RecompiledFunctionTable[246377] = bhEne19_Move_0x1f0970; // 0x1f09ac - g_ps2RecompiledFunctionTable[246378] = bhEne19_Move_0x1f0970; // 0x1f09b0 - g_ps2RecompiledFunctionTable[246379] = bhEne19_Move_0x1f0970; // 0x1f09b4 - g_ps2RecompiledFunctionTable[246380] = bhEne19_Move_0x1f0970; // 0x1f09b8 - g_ps2RecompiledFunctionTable[246381] = bhEne19_Move_0x1f0970; // 0x1f09bc - g_ps2RecompiledFunctionTable[246382] = bhEne19_Move_0x1f0970; // 0x1f09c0 - g_ps2RecompiledFunctionTable[246383] = bhEne19_Move_0x1f0970; // 0x1f09c4 - g_ps2RecompiledFunctionTable[246384] = bhEne19_Move_0x1f0970; // 0x1f09c8 - g_ps2RecompiledFunctionTable[246385] = bhEne19_Move_0x1f0970; // 0x1f09cc - g_ps2RecompiledFunctionTable[246386] = bhEne19_Move_0x1f0970; // 0x1f09d0 - g_ps2RecompiledFunctionTable[246387] = bhEne19_Move_0x1f0970; // 0x1f09d4 - g_ps2RecompiledFunctionTable[246388] = bhEne19_Move_0x1f0970; // 0x1f09d8 - g_ps2RecompiledFunctionTable[246389] = bhEne19_Move_0x1f0970; // 0x1f09dc - g_ps2RecompiledFunctionTable[246390] = bhEne19_Move_0x1f0970; // 0x1f09e0 - g_ps2RecompiledFunctionTable[246391] = bhEne19_Move_0x1f0970; // 0x1f09e4 - g_ps2RecompiledFunctionTable[246392] = bhEne19_Move_0x1f0970; // 0x1f09e8 - g_ps2RecompiledFunctionTable[246393] = bhEne19_Move_0x1f0970; // 0x1f09ec - g_ps2RecompiledFunctionTable[246394] = bhEne19_Move_0x1f0970; // 0x1f09f0 - g_ps2RecompiledFunctionTable[246395] = bhEne19_Move_0x1f0970; // 0x1f09f4 - g_ps2RecompiledFunctionTable[246396] = bhEne19_Move_0x1f0970; // 0x1f09f8 - g_ps2RecompiledFunctionTable[246397] = bhEne19_Move_0x1f0970; // 0x1f09fc - g_ps2RecompiledFunctionTable[246398] = bhEne19_Move_0x1f0970; // 0x1f0a00 - g_ps2RecompiledFunctionTable[246399] = bhEne19_Move_0x1f0970; // 0x1f0a04 - g_ps2RecompiledFunctionTable[246400] = bhEne19_Move_0x1f0970; // 0x1f0a08 - g_ps2RecompiledFunctionTable[246401] = bhEne19_Move_0x1f0970; // 0x1f0a0c - g_ps2RecompiledFunctionTable[246402] = bhEne19_Move_0x1f0970; // 0x1f0a10 - g_ps2RecompiledFunctionTable[246403] = bhEne19_Move_0x1f0970; // 0x1f0a14 - g_ps2RecompiledFunctionTable[246404] = bhEne19_Move_0x1f0970; // 0x1f0a18 - g_ps2RecompiledFunctionTable[246405] = bhEne19_Move_0x1f0970; // 0x1f0a1c - g_ps2RecompiledFunctionTable[246406] = bhEne19_Move_0x1f0970; // 0x1f0a20 - g_ps2RecompiledFunctionTable[246407] = bhEne19_Move_0x1f0970; // 0x1f0a24 - g_ps2RecompiledFunctionTable[246408] = bhEne19_Move_0x1f0970; // 0x1f0a28 - g_ps2RecompiledFunctionTable[246409] = bhEne19_Move_0x1f0970; // 0x1f0a2c - g_ps2RecompiledFunctionTable[246410] = bhEne19_Move_0x1f0970; // 0x1f0a30 - g_ps2RecompiledFunctionTable[246411] = bhEne19_Move_0x1f0970; // 0x1f0a34 - g_ps2RecompiledFunctionTable[246412] = bhEne19_Move_0x1f0970; // 0x1f0a38 - g_ps2RecompiledFunctionTable[246413] = bhEne19_Move_0x1f0970; // 0x1f0a3c - g_ps2RecompiledFunctionTable[246414] = bhEne19_Move_0x1f0970; // 0x1f0a40 - g_ps2RecompiledFunctionTable[246415] = bhEne19_Move_0x1f0970; // 0x1f0a44 - g_ps2RecompiledFunctionTable[246416] = bhEne19_Move_0x1f0970; // 0x1f0a48 - g_ps2RecompiledFunctionTable[246417] = bhEne19_Move_0x1f0970; // 0x1f0a4c - g_ps2RecompiledFunctionTable[246418] = bhEne19_Move_0x1f0970; // 0x1f0a50 - g_ps2RecompiledFunctionTable[246419] = bhEne19_Move_0x1f0970; // 0x1f0a54 - g_ps2RecompiledFunctionTable[246420] = bhEne19_Move_0x1f0970; // 0x1f0a58 - g_ps2RecompiledFunctionTable[246421] = bhEne19_Move_0x1f0970; // 0x1f0a5c - g_ps2RecompiledFunctionTable[246422] = bhEne19_Move_0x1f0970; // 0x1f0a60 - g_ps2RecompiledFunctionTable[246423] = bhEne19_Move_0x1f0970; // 0x1f0a64 - g_ps2RecompiledFunctionTable[246424] = bhEne19_Move_0x1f0970; // 0x1f0a68 - g_ps2RecompiledFunctionTable[246425] = bhEne19_Move_0x1f0970; // 0x1f0a6c - g_ps2RecompiledFunctionTable[246426] = bhEne19_Move_0x1f0970; // 0x1f0a70 - g_ps2RecompiledFunctionTable[246427] = bhEne19_Move_0x1f0970; // 0x1f0a74 - g_ps2RecompiledFunctionTable[246428] = bhEne19_Move_0x1f0970; // 0x1f0a78 - g_ps2RecompiledFunctionTable[246429] = bhEne19_Move_0x1f0970; // 0x1f0a7c - g_ps2RecompiledFunctionTable[246430] = bhEne19_Move_0x1f0970; // 0x1f0a80 - g_ps2RecompiledFunctionTable[246431] = bhEne19_Move_0x1f0970; // 0x1f0a84 - g_ps2RecompiledFunctionTable[246432] = bhEne19_Move_0x1f0970; // 0x1f0a88 - g_ps2RecompiledFunctionTable[246433] = bhEne19_Move_0x1f0970; // 0x1f0a8c - g_ps2RecompiledFunctionTable[246434] = bhEne19_Move_0x1f0970; // 0x1f0a90 - g_ps2RecompiledFunctionTable[246435] = bhEne19_Move_0x1f0970; // 0x1f0a94 - g_ps2RecompiledFunctionTable[246436] = bhEne19_Move_0x1f0970; // 0x1f0a98 - g_ps2RecompiledFunctionTable[246437] = bhEne19_Move_0x1f0970; // 0x1f0a9c - g_ps2RecompiledFunctionTable[246438] = bhEne19_Move_0x1f0970; // 0x1f0aa0 - g_ps2RecompiledFunctionTable[246439] = bhEne19_Move_0x1f0970; // 0x1f0aa4 - g_ps2RecompiledFunctionTable[246440] = bhEne19_Move_0x1f0970; // 0x1f0aa8 - g_ps2RecompiledFunctionTable[246441] = bhEne19_Move_0x1f0970; // 0x1f0aac - g_ps2RecompiledFunctionTable[246442] = bhEne19_Move_0x1f0970; // 0x1f0ab0 - g_ps2RecompiledFunctionTable[246443] = bhEne19_Move_0x1f0970; // 0x1f0ab4 - g_ps2RecompiledFunctionTable[246444] = bhEne19_Move_0x1f0970; // 0x1f0ab8 - g_ps2RecompiledFunctionTable[246445] = bhEne19_Move_0x1f0970; // 0x1f0abc - g_ps2RecompiledFunctionTable[246446] = bhEne19_Move_0x1f0970; // 0x1f0ac0 - g_ps2RecompiledFunctionTable[246447] = bhEne19_Move_0x1f0970; // 0x1f0ac4 - g_ps2RecompiledFunctionTable[246448] = bhEne19_Move_0x1f0970; // 0x1f0ac8 - g_ps2RecompiledFunctionTable[246449] = bhEne19_Move_0x1f0970; // 0x1f0acc - g_ps2RecompiledFunctionTable[246450] = bhEne19_Move_0x1f0970; // 0x1f0ad0 - g_ps2RecompiledFunctionTable[246451] = bhEne19_Move_0x1f0970; // 0x1f0ad4 - g_ps2RecompiledFunctionTable[246452] = bhEne19_Move_0x1f0970; // 0x1f0ad8 - g_ps2RecompiledFunctionTable[246453] = bhEne19_Move_0x1f0970; // 0x1f0adc - g_ps2RecompiledFunctionTable[246454] = bhEne19_Move_0x1f0970; // 0x1f0ae0 - g_ps2RecompiledFunctionTable[246455] = bhEne19_Move_0x1f0970; // 0x1f0ae4 - g_ps2RecompiledFunctionTable[246456] = bhEne19_Move_0x1f0970; // 0x1f0ae8 - g_ps2RecompiledFunctionTable[246457] = bhEne19_Move_0x1f0970; // 0x1f0aec - g_ps2RecompiledFunctionTable[246458] = bhEne19_Move_0x1f0970; // 0x1f0af0 - g_ps2RecompiledFunctionTable[246459] = bhEne19_Move_0x1f0970; // 0x1f0af4 - g_ps2RecompiledFunctionTable[246460] = bhEne19_Move_0x1f0970; // 0x1f0af8 - g_ps2RecompiledFunctionTable[246461] = bhEne19_Move_0x1f0970; // 0x1f0afc - g_ps2RecompiledFunctionTable[246462] = bhEne19_Move_0x1f0970; // 0x1f0b00 - g_ps2RecompiledFunctionTable[246463] = bhEne19_Move_0x1f0970; // 0x1f0b04 - g_ps2RecompiledFunctionTable[246464] = bhEne19_Move_0x1f0970; // 0x1f0b08 - g_ps2RecompiledFunctionTable[246465] = bhEne19_Move_0x1f0970; // 0x1f0b0c - g_ps2RecompiledFunctionTable[246466] = bhEne19_Move_0x1f0970; // 0x1f0b10 - g_ps2RecompiledFunctionTable[246467] = bhEne19_Move_0x1f0970; // 0x1f0b14 - g_ps2RecompiledFunctionTable[246468] = bhEne19_Move_0x1f0970; // 0x1f0b18 - g_ps2RecompiledFunctionTable[246469] = bhEne19_Move_0x1f0970; // 0x1f0b1c - g_ps2RecompiledFunctionTable[246470] = bhEne19_Move_0x1f0970; // 0x1f0b20 - g_ps2RecompiledFunctionTable[246471] = bhEne19_Move_0x1f0970; // 0x1f0b24 - g_ps2RecompiledFunctionTable[246472] = bhEne19_Move_0x1f0970; // 0x1f0b28 - g_ps2RecompiledFunctionTable[246473] = bhEne19_Move_0x1f0970; // 0x1f0b2c - g_ps2RecompiledFunctionTable[246474] = bhEne19_Move_0x1f0970; // 0x1f0b30 - g_ps2RecompiledFunctionTable[246475] = bhEne19_Move_0x1f0970; // 0x1f0b34 - g_ps2RecompiledFunctionTable[246476] = bhEne19_Move_0x1f0970; // 0x1f0b38 - g_ps2RecompiledFunctionTable[246477] = bhEne19_Move_0x1f0970; // 0x1f0b3c - g_ps2RecompiledFunctionTable[246478] = bhEne19_Move_0x1f0970; // 0x1f0b40 - g_ps2RecompiledFunctionTable[246479] = bhEne19_Move_0x1f0970; // 0x1f0b44 - g_ps2RecompiledFunctionTable[246480] = bhEne19_Move_0x1f0970; // 0x1f0b48 - g_ps2RecompiledFunctionTable[246481] = bhEne19_Move_0x1f0970; // 0x1f0b4c - g_ps2RecompiledFunctionTable[246482] = bhEne19_Move_0x1f0970; // 0x1f0b50 - g_ps2RecompiledFunctionTable[246483] = bhEne19_Move_0x1f0970; // 0x1f0b54 - g_ps2RecompiledFunctionTable[246484] = bhEne19_Move_0x1f0970; // 0x1f0b58 - g_ps2RecompiledFunctionTable[246485] = bhEne19_Move_0x1f0970; // 0x1f0b5c - g_ps2RecompiledFunctionTable[246486] = bhEne19_Move_0x1f0970; // 0x1f0b60 - g_ps2RecompiledFunctionTable[246487] = bhEne19_Move_0x1f0970; // 0x1f0b64 - g_ps2RecompiledFunctionTable[246488] = bhEne19_Move_0x1f0970; // 0x1f0b68 - g_ps2RecompiledFunctionTable[246489] = bhEne19_Move_0x1f0970; // 0x1f0b6c - g_ps2RecompiledFunctionTable[246490] = bhEne19_Move_0x1f0970; // 0x1f0b70 - g_ps2RecompiledFunctionTable[246491] = bhEne19_Move_0x1f0970; // 0x1f0b74 - g_ps2RecompiledFunctionTable[246492] = bhEne19_Move_0x1f0970; // 0x1f0b78 - g_ps2RecompiledFunctionTable[246493] = bhEne19_Move_0x1f0970; // 0x1f0b7c - g_ps2RecompiledFunctionTable[246494] = bhEne19_Move_0x1f0970; // 0x1f0b80 - g_ps2RecompiledFunctionTable[246495] = bhEne19_Move_0x1f0970; // 0x1f0b84 - g_ps2RecompiledFunctionTable[246496] = bhEne19_Move_0x1f0970; // 0x1f0b88 - g_ps2RecompiledFunctionTable[246497] = bhEne19_Move_0x1f0970; // 0x1f0b8c - g_ps2RecompiledFunctionTable[246498] = bhEne19_Move_0x1f0970; // 0x1f0b90 - g_ps2RecompiledFunctionTable[246499] = bhEne19_Move_0x1f0970; // 0x1f0b94 - g_ps2RecompiledFunctionTable[246500] = bhEne19_Move_0x1f0970; // 0x1f0b98 - g_ps2RecompiledFunctionTable[246501] = bhEne19_Move_0x1f0970; // 0x1f0b9c - g_ps2RecompiledFunctionTable[246502] = bhEne19_Move_0x1f0970; // 0x1f0ba0 - g_ps2RecompiledFunctionTable[246503] = bhEne19_Move_0x1f0970; // 0x1f0ba4 - g_ps2RecompiledFunctionTable[246504] = bhEne19_Move_0x1f0970; // 0x1f0ba8 - g_ps2RecompiledFunctionTable[246505] = bhEne19_Move_0x1f0970; // 0x1f0bac - g_ps2RecompiledFunctionTable[246506] = bhEne19_Damage_0x1f0bb0; // 0x1f0bb0 - g_ps2RecompiledFunctionTable[246510] = bhEne19_Die_0x1f0bc0; // 0x1f0bc0 - g_ps2RecompiledFunctionTable[246518] = bhEne19_Event_0x1f0be0; // 0x1f0be0 - g_ps2RecompiledFunctionTable[246539] = bhEne19_Event_0x1f0be0; // 0x1f0c34 - g_ps2RecompiledFunctionTable[246544] = bhEne19_Event_0x1f0be0; // 0x1f0c48 - g_ps2RecompiledFunctionTable[246547] = bhEne19_Event_0x1f0be0; // 0x1f0c54 - g_ps2RecompiledFunctionTable[246554] = bhEne19_Br00_0x1f0c70; // 0x1f0c70 - g_ps2RecompiledFunctionTable[246567] = bhEne19_Br00_0x1f0c70; // 0x1f0ca4 - g_ps2RecompiledFunctionTable[246587] = bhEne19_Br00_0x1f0c70; // 0x1f0cf4 - g_ps2RecompiledFunctionTable[246617] = bhEne19_Br00_0x1f0c70; // 0x1f0d6c - g_ps2RecompiledFunctionTable[246991] = bhEne19_Br00_0x1f0c70; // 0x1f1344 - g_ps2RecompiledFunctionTable[247002] = bhEne19_Br01_0x1f1370; // 0x1f1370 - g_ps2RecompiledFunctionTable[247034] = bhEne19_Br01_0x1f1370; // 0x1f13f0 - g_ps2RecompiledFunctionTable[247082] = bhEne19_Br01_0x1f1370; // 0x1f14b0 - g_ps2RecompiledFunctionTable[247135] = bhEne19_Br01_0x1f1370; // 0x1f1584 - g_ps2RecompiledFunctionTable[247150] = bhEne19_Br01_0x1f1370; // 0x1f15c0 - g_ps2RecompiledFunctionTable[247634] = bhEne19_Br01_0x1f1370; // 0x1f1d50 - g_ps2RecompiledFunctionTable[247646] = bhEne19_Br02_0x1f1d80; // 0x1f1d80 - g_ps2RecompiledFunctionTable[247678] = bhEne19_Br02_0x1f1d80; // 0x1f1e00 - g_ps2RecompiledFunctionTable[247685] = bhEne19_Br02_0x1f1d80; // 0x1f1e1c - g_ps2RecompiledFunctionTable[247705] = bhEne19_Br02_0x1f1d80; // 0x1f1e6c - g_ps2RecompiledFunctionTable[247726] = bhEne19_Br02_0x1f1d80; // 0x1f1ec0 - g_ps2RecompiledFunctionTable[247748] = bhEne19_Br02_0x1f1d80; // 0x1f1f18 - g_ps2RecompiledFunctionTable[248110] = bhEne19_Br02_0x1f1d80; // 0x1f24c0 - g_ps2RecompiledFunctionTable[248122] = bhEne19_Mv00_0x1f24f0; // 0x1f24f0 - g_ps2RecompiledFunctionTable[248126] = bhEne19_Mv01_0x1f2500; // 0x1f2500 - g_ps2RecompiledFunctionTable[248130] = bhEne19_Mv02_0x1f2510; // 0x1f2510 - g_ps2RecompiledFunctionTable[248138] = bhEne19_Mv03_0x1f2530; // 0x1f2530 - g_ps2RecompiledFunctionTable[248142] = bhEne19_Mv04a_0x1f2540; // 0x1f2540 - g_ps2RecompiledFunctionTable[248150] = bhEne19_Mv04b_0x1f2560; // 0x1f2560 - g_ps2RecompiledFunctionTable[248170] = bhEne19_Mv05_0x1f25b0; // 0x1f25b0 - g_ps2RecompiledFunctionTable[248190] = bhEne19_Mv06_0x1f2600; // 0x1f2600 - g_ps2RecompiledFunctionTable[248194] = bhEne19_Mv07_0x1f2610; // 0x1f2610 - g_ps2RecompiledFunctionTable[248238] = bhEne19_Mv07_0x1f2610; // 0x1f26c0 - g_ps2RecompiledFunctionTable[248255] = bhEne19_Mv07_0x1f2610; // 0x1f2704 - g_ps2RecompiledFunctionTable[248267] = bhEne19_Mv07_0x1f2610; // 0x1f2734 - g_ps2RecompiledFunctionTable[248298] = bhEne19_Mv08_0x1f27b0; // 0x1f27b0 - g_ps2RecompiledFunctionTable[248317] = bhEne19_Mv08_0x1f27b0; // 0x1f27fc - g_ps2RecompiledFunctionTable[248324] = bhEne19_Mv08_0x1f27b0; // 0x1f2818 - g_ps2RecompiledFunctionTable[248359] = bhEne19_Mv08_0x1f27b0; // 0x1f28a4 - g_ps2RecompiledFunctionTable[248395] = bhEne19_Mv08_0x1f27b0; // 0x1f2934 - g_ps2RecompiledFunctionTable[248406] = bhEne19_Mv09_0x1f2960; // 0x1f2960 - g_ps2RecompiledFunctionTable[248424] = bhEne19_Mv09_0x1f2960; // 0x1f29a8 - g_ps2RecompiledFunctionTable[248431] = bhEne19_Mv09_0x1f2960; // 0x1f29c4 - g_ps2RecompiledFunctionTable[248466] = bhEne19_Mv09_0x1f2960; // 0x1f2a50 - g_ps2RecompiledFunctionTable[248502] = bhEne19_Mv09_0x1f2960; // 0x1f2ae0 - g_ps2RecompiledFunctionTable[248514] = bhEne19_Mv10_0x1f2b10; // 0x1f2b10 - g_ps2RecompiledFunctionTable[248552] = bhEne19_Mv10_0x1f2b10; // 0x1f2ba8 - g_ps2RecompiledFunctionTable[248561] = bhEne19_Mv10_0x1f2b10; // 0x1f2bcc - g_ps2RecompiledFunctionTable[248570] = bhEne19_Mv10_0x1f2b10; // 0x1f2bf0 - g_ps2RecompiledFunctionTable[248575] = bhEne19_Mv10_0x1f2b10; // 0x1f2c04 - g_ps2RecompiledFunctionTable[248582] = bhEne19_Mv10_0x1f2b10; // 0x1f2c20 - g_ps2RecompiledFunctionTable[248589] = bhEne19_Mv10_0x1f2b10; // 0x1f2c3c - g_ps2RecompiledFunctionTable[248596] = bhEne19_Mv10_0x1f2b10; // 0x1f2c58 - g_ps2RecompiledFunctionTable[248603] = bhEne19_Mv10_0x1f2b10; // 0x1f2c74 - g_ps2RecompiledFunctionTable[248608] = bhEne19_Mv10_0x1f2b10; // 0x1f2c88 - g_ps2RecompiledFunctionTable[248620] = bhEne19_Mv10_0x1f2b10; // 0x1f2cb8 - g_ps2RecompiledFunctionTable[248627] = bhEne19_Mv10_0x1f2b10; // 0x1f2cd4 - g_ps2RecompiledFunctionTable[248647] = bhEne19_Mv10_0x1f2b10; // 0x1f2d24 - g_ps2RecompiledFunctionTable[248652] = bhEne19_Mv10_0x1f2b10; // 0x1f2d38 - g_ps2RecompiledFunctionTable[248662] = bhEne19_Mv11_0x1f2d60; // 0x1f2d60 - g_ps2RecompiledFunctionTable[248678] = bhEne19_Mv11_0x1f2d60; // 0x1f2da0 - g_ps2RecompiledFunctionTable[248685] = bhEne19_Mv11_0x1f2d60; // 0x1f2dbc - g_ps2RecompiledFunctionTable[248694] = bhEne19_Mv12_0x1f2de0; // 0x1f2de0 - g_ps2RecompiledFunctionTable[248709] = bhEne19_Mv12_0x1f2de0; // 0x1f2e1c - g_ps2RecompiledFunctionTable[248716] = bhEne19_Mv12_0x1f2de0; // 0x1f2e38 - g_ps2RecompiledFunctionTable[248726] = bhEne19_Mv13_0x1f2e60; // 0x1f2e60 - g_ps2RecompiledFunctionTable[248778] = bhEne19_Mv13_0x1f2e60; // 0x1f2f30 - g_ps2RecompiledFunctionTable[248787] = bhEne19_Mv13_0x1f2e60; // 0x1f2f54 - g_ps2RecompiledFunctionTable[248799] = bhEne19_Mv13_0x1f2e60; // 0x1f2f84 - g_ps2RecompiledFunctionTable[248804] = bhEne19_Mv13_0x1f2e60; // 0x1f2f98 - g_ps2RecompiledFunctionTable[248811] = bhEne19_Mv13_0x1f2e60; // 0x1f2fb4 - g_ps2RecompiledFunctionTable[248818] = bhEne19_Mv13_0x1f2e60; // 0x1f2fd0 - g_ps2RecompiledFunctionTable[248825] = bhEne19_Mv13_0x1f2e60; // 0x1f2fec - g_ps2RecompiledFunctionTable[248842] = bhEne19_Mv13_0x1f2e60; // 0x1f3030 - g_ps2RecompiledFunctionTable[248847] = bhEne19_Mv13_0x1f2e60; // 0x1f3044 - g_ps2RecompiledFunctionTable[248859] = bhEne19_Mv13_0x1f2e60; // 0x1f3074 - g_ps2RecompiledFunctionTable[248872] = bhEne19_Mv13_0x1f2e60; // 0x1f30a8 - g_ps2RecompiledFunctionTable[248879] = bhEne19_Mv13_0x1f2e60; // 0x1f30c4 - g_ps2RecompiledFunctionTable[248897] = bhEne19_Mv13_0x1f2e60; // 0x1f310c - g_ps2RecompiledFunctionTable[248939] = bhEne19_Mv13_0x1f2e60; // 0x1f31b4 - g_ps2RecompiledFunctionTable[248954] = bhEne19_Mv14_0x1f31f0; // 0x1f31f0 - g_ps2RecompiledFunctionTable[249006] = bhEne19_Mv14_0x1f31f0; // 0x1f32c0 - g_ps2RecompiledFunctionTable[249015] = bhEne19_Mv14_0x1f31f0; // 0x1f32e4 - g_ps2RecompiledFunctionTable[249027] = bhEne19_Mv14_0x1f31f0; // 0x1f3314 - g_ps2RecompiledFunctionTable[249032] = bhEne19_Mv14_0x1f31f0; // 0x1f3328 - g_ps2RecompiledFunctionTable[249039] = bhEne19_Mv14_0x1f31f0; // 0x1f3344 - g_ps2RecompiledFunctionTable[249048] = bhEne19_Mv14_0x1f31f0; // 0x1f3368 - g_ps2RecompiledFunctionTable[249055] = bhEne19_Mv14_0x1f31f0; // 0x1f3384 - g_ps2RecompiledFunctionTable[249062] = bhEne19_Mv14_0x1f31f0; // 0x1f33a0 - g_ps2RecompiledFunctionTable[249079] = bhEne19_Mv14_0x1f31f0; // 0x1f33e4 - g_ps2RecompiledFunctionTable[249084] = bhEne19_Mv14_0x1f31f0; // 0x1f33f8 - g_ps2RecompiledFunctionTable[249096] = bhEne19_Mv14_0x1f31f0; // 0x1f3428 - g_ps2RecompiledFunctionTable[249109] = bhEne19_Mv14_0x1f31f0; // 0x1f345c - g_ps2RecompiledFunctionTable[249116] = bhEne19_Mv14_0x1f31f0; // 0x1f3478 - g_ps2RecompiledFunctionTable[249134] = bhEne19_Mv14_0x1f31f0; // 0x1f34c0 - g_ps2RecompiledFunctionTable[249176] = bhEne19_Mv14_0x1f31f0; // 0x1f3568 - g_ps2RecompiledFunctionTable[249194] = bhEne19_Mv15_0x1f35b0; // 0x1f35b0 - g_ps2RecompiledFunctionTable[249214] = bhEne19_Mv16_0x1f3600; // 0x1f3600 - g_ps2RecompiledFunctionTable[249234] = bhEne19_Mv17_0x1f3650; // 0x1f3650 - g_ps2RecompiledFunctionTable[249258] = bhEne19_Mv18_0x1f36b0; // 0x1f36b0 - g_ps2RecompiledFunctionTable[249274] = bhEne19_Mv19_0x1f36f0; // 0x1f36f0 - g_ps2RecompiledFunctionTable[249282] = bhEne19_Mv20_0x1f3710; // 0x1f3710 - g_ps2RecompiledFunctionTable[249302] = bhEne19_ActionSearch_0x1f3760; // 0x1f3760 - g_ps2RecompiledFunctionTable[249311] = bhEne19_ActionSearch_0x1f3760; // 0x1f3784 - g_ps2RecompiledFunctionTable[249334] = bhEne19_ActionChange_0x1f37e0; // 0x1f37e0 - g_ps2RecompiledFunctionTable[249346] = bhEne19_ActionChange_0x1f37e0; // 0x1f3810 - g_ps2RecompiledFunctionTable[249354] = bhEne19_ActionChange_0x1f37e0; // 0x1f3830 - g_ps2RecompiledFunctionTable[249361] = bhEne19_ActionChange_0x1f37e0; // 0x1f384c - g_ps2RecompiledFunctionTable[249376] = bhEne19_ActionChange_0x1f37e0; // 0x1f3888 - g_ps2RecompiledFunctionTable[249384] = bhEne19_ActionChange_0x1f37e0; // 0x1f38a8 - g_ps2RecompiledFunctionTable[249386] = bhEne19_ActionChange_0x1f37e0; // 0x1f38b0 - g_ps2RecompiledFunctionTable[249412] = bhEne19_ActionChange_0x1f37e0; // 0x1f3918 - g_ps2RecompiledFunctionTable[249438] = bhEne19_ActionMain_0x1f3980; // 0x1f3980 - g_ps2RecompiledFunctionTable[249439] = bhEne19_ActionMain_0x1f3980; // 0x1f3984 - g_ps2RecompiledFunctionTable[249440] = bhEne19_ActionMain_0x1f3980; // 0x1f3988 - g_ps2RecompiledFunctionTable[249441] = bhEne19_ActionMain_0x1f3980; // 0x1f398c - g_ps2RecompiledFunctionTable[249442] = bhEne19_ActionMain_0x1f3980; // 0x1f3990 - g_ps2RecompiledFunctionTable[249443] = bhEne19_ActionMain_0x1f3980; // 0x1f3994 - g_ps2RecompiledFunctionTable[249444] = bhEne19_ActionMain_0x1f3980; // 0x1f3998 - g_ps2RecompiledFunctionTable[249445] = bhEne19_ActionMain_0x1f3980; // 0x1f399c - g_ps2RecompiledFunctionTable[249446] = bhEne19_ActionMain_0x1f3980; // 0x1f39a0 - g_ps2RecompiledFunctionTable[249447] = bhEne19_ActionMain_0x1f3980; // 0x1f39a4 - g_ps2RecompiledFunctionTable[249448] = bhEne19_ActionMain_0x1f3980; // 0x1f39a8 - g_ps2RecompiledFunctionTable[249449] = bhEne19_ActionMain_0x1f3980; // 0x1f39ac - g_ps2RecompiledFunctionTable[249450] = bhEne19_ActionMain_0x1f3980; // 0x1f39b0 - g_ps2RecompiledFunctionTable[249451] = bhEne19_ActionMain_0x1f3980; // 0x1f39b4 - g_ps2RecompiledFunctionTable[249452] = bhEne19_ActionMain_0x1f3980; // 0x1f39b8 - g_ps2RecompiledFunctionTable[249453] = bhEne19_ActionMain_0x1f3980; // 0x1f39bc - g_ps2RecompiledFunctionTable[249454] = bhEne19_ActionMain_0x1f3980; // 0x1f39c0 - g_ps2RecompiledFunctionTable[249455] = bhEne19_ActionMain_0x1f3980; // 0x1f39c4 - g_ps2RecompiledFunctionTable[249456] = bhEne19_ActionMain_0x1f3980; // 0x1f39c8 - g_ps2RecompiledFunctionTable[249457] = bhEne19_ActionMain_0x1f3980; // 0x1f39cc - g_ps2RecompiledFunctionTable[249458] = bhEne19_ActionMain_0x1f3980; // 0x1f39d0 - g_ps2RecompiledFunctionTable[249459] = bhEne19_ActionMain_0x1f3980; // 0x1f39d4 - g_ps2RecompiledFunctionTable[249460] = bhEne19_ActionMain_0x1f3980; // 0x1f39d8 - g_ps2RecompiledFunctionTable[249461] = bhEne19_ActionMain_0x1f3980; // 0x1f39dc - g_ps2RecompiledFunctionTable[249462] = bhEne19_ActionMain_0x1f3980; // 0x1f39e0 - g_ps2RecompiledFunctionTable[249463] = bhEne19_ActionMain_0x1f3980; // 0x1f39e4 - g_ps2RecompiledFunctionTable[249464] = bhEne19_ActionMain_0x1f3980; // 0x1f39e8 - g_ps2RecompiledFunctionTable[249465] = bhEne19_ActionMain_0x1f3980; // 0x1f39ec - g_ps2RecompiledFunctionTable[249466] = bhEne19_ActionMain_0x1f3980; // 0x1f39f0 - g_ps2RecompiledFunctionTable[249467] = bhEne19_ActionMain_0x1f3980; // 0x1f39f4 - g_ps2RecompiledFunctionTable[249468] = bhEne19_ActionMain_0x1f3980; // 0x1f39f8 - g_ps2RecompiledFunctionTable[249469] = bhEne19_ActionMain_0x1f3980; // 0x1f39fc - g_ps2RecompiledFunctionTable[249470] = bhEne19_ActionMain_0x1f3980; // 0x1f3a00 - g_ps2RecompiledFunctionTable[249471] = bhEne19_ActionMain_0x1f3980; // 0x1f3a04 - g_ps2RecompiledFunctionTable[249472] = bhEne19_ActionMain_0x1f3980; // 0x1f3a08 - g_ps2RecompiledFunctionTable[249473] = bhEne19_ActionMain_0x1f3980; // 0x1f3a0c - g_ps2RecompiledFunctionTable[249474] = bhEne19_ActionMain_0x1f3980; // 0x1f3a10 - g_ps2RecompiledFunctionTable[249475] = bhEne19_ActionMain_0x1f3980; // 0x1f3a14 - g_ps2RecompiledFunctionTable[249476] = bhEne19_ActionMain_0x1f3980; // 0x1f3a18 - g_ps2RecompiledFunctionTable[249477] = bhEne19_ActionMain_0x1f3980; // 0x1f3a1c - g_ps2RecompiledFunctionTable[249478] = bhEne19_ActionMain_0x1f3980; // 0x1f3a20 - g_ps2RecompiledFunctionTable[249479] = bhEne19_ActionMain_0x1f3980; // 0x1f3a24 - g_ps2RecompiledFunctionTable[249480] = bhEne19_ActionMain_0x1f3980; // 0x1f3a28 - g_ps2RecompiledFunctionTable[249481] = bhEne19_ActionMain_0x1f3980; // 0x1f3a2c - g_ps2RecompiledFunctionTable[249482] = bhEne19_ActionMain_0x1f3980; // 0x1f3a30 - g_ps2RecompiledFunctionTable[249483] = bhEne19_ActionMain_0x1f3980; // 0x1f3a34 - g_ps2RecompiledFunctionTable[249484] = bhEne19_ActionMain_0x1f3980; // 0x1f3a38 - g_ps2RecompiledFunctionTable[249485] = bhEne19_ActionMain_0x1f3980; // 0x1f3a3c - g_ps2RecompiledFunctionTable[249486] = bhEne19_ActionMain_0x1f3980; // 0x1f3a40 - g_ps2RecompiledFunctionTable[249487] = bhEne19_ActionMain_0x1f3980; // 0x1f3a44 - g_ps2RecompiledFunctionTable[249488] = bhEne19_ActionMain_0x1f3980; // 0x1f3a48 - g_ps2RecompiledFunctionTable[249489] = bhEne19_ActionMain_0x1f3980; // 0x1f3a4c - g_ps2RecompiledFunctionTable[249490] = bhEne19_ActionMain_0x1f3980; // 0x1f3a50 - g_ps2RecompiledFunctionTable[249491] = bhEne19_ActionMain_0x1f3980; // 0x1f3a54 - g_ps2RecompiledFunctionTable[249492] = bhEne19_ActionMain_0x1f3980; // 0x1f3a58 - g_ps2RecompiledFunctionTable[249493] = bhEne19_ActionMain_0x1f3980; // 0x1f3a5c - g_ps2RecompiledFunctionTable[249494] = bhEne19_ActionMain_0x1f3980; // 0x1f3a60 - g_ps2RecompiledFunctionTable[249495] = bhEne19_ActionMain_0x1f3980; // 0x1f3a64 - g_ps2RecompiledFunctionTable[249496] = bhEne19_ActionMain_0x1f3980; // 0x1f3a68 - g_ps2RecompiledFunctionTable[249497] = bhEne19_ActionMain_0x1f3980; // 0x1f3a6c - g_ps2RecompiledFunctionTable[249498] = bhEne19_ActionMain_0x1f3980; // 0x1f3a70 - g_ps2RecompiledFunctionTable[249499] = bhEne19_ActionMain_0x1f3980; // 0x1f3a74 - g_ps2RecompiledFunctionTable[249500] = bhEne19_ActionMain_0x1f3980; // 0x1f3a78 - g_ps2RecompiledFunctionTable[249501] = bhEne19_ActionMain_0x1f3980; // 0x1f3a7c - g_ps2RecompiledFunctionTable[249502] = bhEne19_ActionMain_0x1f3980; // 0x1f3a80 - g_ps2RecompiledFunctionTable[249503] = bhEne19_ActionMain_0x1f3980; // 0x1f3a84 - g_ps2RecompiledFunctionTable[249504] = bhEne19_ActionMain_0x1f3980; // 0x1f3a88 - g_ps2RecompiledFunctionTable[249505] = bhEne19_ActionMain_0x1f3980; // 0x1f3a8c - g_ps2RecompiledFunctionTable[249506] = bhEne19_ActionMain_0x1f3980; // 0x1f3a90 - g_ps2RecompiledFunctionTable[249507] = bhEne19_ActionMain_0x1f3980; // 0x1f3a94 - g_ps2RecompiledFunctionTable[249508] = bhEne19_ActionMain_0x1f3980; // 0x1f3a98 - g_ps2RecompiledFunctionTable[249509] = bhEne19_ActionMain_0x1f3980; // 0x1f3a9c - g_ps2RecompiledFunctionTable[249510] = bhEne19_ActionMain_0x1f3980; // 0x1f3aa0 - g_ps2RecompiledFunctionTable[249511] = bhEne19_ActionMain_0x1f3980; // 0x1f3aa4 - g_ps2RecompiledFunctionTable[249512] = bhEne19_ActionMain_0x1f3980; // 0x1f3aa8 - g_ps2RecompiledFunctionTable[249513] = bhEne19_ActionMain_0x1f3980; // 0x1f3aac - g_ps2RecompiledFunctionTable[249514] = bhEne19_ActionMain_0x1f3980; // 0x1f3ab0 - g_ps2RecompiledFunctionTable[249515] = bhEne19_ActionMain_0x1f3980; // 0x1f3ab4 - g_ps2RecompiledFunctionTable[249516] = bhEne19_ActionMain_0x1f3980; // 0x1f3ab8 - g_ps2RecompiledFunctionTable[249517] = bhEne19_ActionMain_0x1f3980; // 0x1f3abc - g_ps2RecompiledFunctionTable[249518] = bhEne19_ActionMain_0x1f3980; // 0x1f3ac0 - g_ps2RecompiledFunctionTable[249519] = bhEne19_ActionMain_0x1f3980; // 0x1f3ac4 - g_ps2RecompiledFunctionTable[249520] = bhEne19_ActionMain_0x1f3980; // 0x1f3ac8 - g_ps2RecompiledFunctionTable[249521] = bhEne19_ActionMain_0x1f3980; // 0x1f3acc - g_ps2RecompiledFunctionTable[249522] = bhEne19_ActionMain_0x1f3980; // 0x1f3ad0 - g_ps2RecompiledFunctionTable[249523] = bhEne19_ActionMain_0x1f3980; // 0x1f3ad4 - g_ps2RecompiledFunctionTable[249524] = bhEne19_ActionMain_0x1f3980; // 0x1f3ad8 - g_ps2RecompiledFunctionTable[249525] = bhEne19_ActionMain_0x1f3980; // 0x1f3adc - g_ps2RecompiledFunctionTable[249526] = bhEne19_ActionMain_0x1f3980; // 0x1f3ae0 - g_ps2RecompiledFunctionTable[249527] = bhEne19_ActionMain_0x1f3980; // 0x1f3ae4 - g_ps2RecompiledFunctionTable[249528] = bhEne19_ActionMain_0x1f3980; // 0x1f3ae8 - g_ps2RecompiledFunctionTable[249529] = bhEne19_ActionMain_0x1f3980; // 0x1f3aec - g_ps2RecompiledFunctionTable[249530] = bhEne19_ActionMain_0x1f3980; // 0x1f3af0 - g_ps2RecompiledFunctionTable[249531] = bhEne19_ActionMain_0x1f3980; // 0x1f3af4 - g_ps2RecompiledFunctionTable[249532] = bhEne19_ActionMain_0x1f3980; // 0x1f3af8 - g_ps2RecompiledFunctionTable[249533] = bhEne19_ActionMain_0x1f3980; // 0x1f3afc - g_ps2RecompiledFunctionTable[249534] = bhEne19_ActionMain_0x1f3980; // 0x1f3b00 - g_ps2RecompiledFunctionTable[249535] = bhEne19_ActionMain_0x1f3980; // 0x1f3b04 - g_ps2RecompiledFunctionTable[249536] = bhEne19_ActionMain_0x1f3980; // 0x1f3b08 - g_ps2RecompiledFunctionTable[249537] = bhEne19_ActionMain_0x1f3980; // 0x1f3b0c - g_ps2RecompiledFunctionTable[249538] = bhEne19_ActionMain_0x1f3980; // 0x1f3b10 - g_ps2RecompiledFunctionTable[249539] = bhEne19_ActionMain_0x1f3980; // 0x1f3b14 - g_ps2RecompiledFunctionTable[249540] = bhEne19_ActionMain_0x1f3980; // 0x1f3b18 - g_ps2RecompiledFunctionTable[249541] = bhEne19_ActionMain_0x1f3980; // 0x1f3b1c - g_ps2RecompiledFunctionTable[249542] = bhEne19_ActionMain_0x1f3980; // 0x1f3b20 - g_ps2RecompiledFunctionTable[249543] = bhEne19_ActionMain_0x1f3980; // 0x1f3b24 - g_ps2RecompiledFunctionTable[249544] = bhEne19_ActionMain_0x1f3980; // 0x1f3b28 - g_ps2RecompiledFunctionTable[249545] = bhEne19_ActionMain_0x1f3980; // 0x1f3b2c - g_ps2RecompiledFunctionTable[249546] = bhEne19_ActionMain_0x1f3980; // 0x1f3b30 - g_ps2RecompiledFunctionTable[249547] = bhEne19_ActionMain_0x1f3980; // 0x1f3b34 - g_ps2RecompiledFunctionTable[249548] = bhEne19_ActionMain_0x1f3980; // 0x1f3b38 - g_ps2RecompiledFunctionTable[249549] = bhEne19_ActionMain_0x1f3980; // 0x1f3b3c - g_ps2RecompiledFunctionTable[249550] = bhEne19_ActionMain_0x1f3980; // 0x1f3b40 - g_ps2RecompiledFunctionTable[249551] = bhEne19_ActionMain_0x1f3980; // 0x1f3b44 - g_ps2RecompiledFunctionTable[249552] = bhEne19_ActionMain_0x1f3980; // 0x1f3b48 - g_ps2RecompiledFunctionTable[249553] = bhEne19_ActionMain_0x1f3980; // 0x1f3b4c - g_ps2RecompiledFunctionTable[249554] = bhEne19_ActionMain_0x1f3980; // 0x1f3b50 - g_ps2RecompiledFunctionTable[249555] = bhEne19_ActionMain_0x1f3980; // 0x1f3b54 - g_ps2RecompiledFunctionTable[249556] = bhEne19_ActionMain_0x1f3980; // 0x1f3b58 - g_ps2RecompiledFunctionTable[249557] = bhEne19_ActionMain_0x1f3980; // 0x1f3b5c - g_ps2RecompiledFunctionTable[249558] = bhEne19_ActionMain_0x1f3980; // 0x1f3b60 - g_ps2RecompiledFunctionTable[249559] = bhEne19_ActionMain_0x1f3980; // 0x1f3b64 - g_ps2RecompiledFunctionTable[249560] = bhEne19_ActionMain_0x1f3980; // 0x1f3b68 - g_ps2RecompiledFunctionTable[249561] = bhEne19_ActionMain_0x1f3980; // 0x1f3b6c - g_ps2RecompiledFunctionTable[249562] = bhEne19_ActionMain_0x1f3980; // 0x1f3b70 - g_ps2RecompiledFunctionTable[249563] = bhEne19_ActionMain_0x1f3980; // 0x1f3b74 - g_ps2RecompiledFunctionTable[249564] = bhEne19_ActionMain_0x1f3980; // 0x1f3b78 - g_ps2RecompiledFunctionTable[249565] = bhEne19_ActionMain_0x1f3980; // 0x1f3b7c - g_ps2RecompiledFunctionTable[249566] = bhEne19_ActionMain_0x1f3980; // 0x1f3b80 - g_ps2RecompiledFunctionTable[249567] = bhEne19_ActionMain_0x1f3980; // 0x1f3b84 - g_ps2RecompiledFunctionTable[249568] = bhEne19_ActionMain_0x1f3980; // 0x1f3b88 - g_ps2RecompiledFunctionTable[249569] = bhEne19_ActionMain_0x1f3980; // 0x1f3b8c - g_ps2RecompiledFunctionTable[249570] = bhEne19_ActionMain_0x1f3980; // 0x1f3b90 - g_ps2RecompiledFunctionTable[249571] = bhEne19_ActionMain_0x1f3980; // 0x1f3b94 - g_ps2RecompiledFunctionTable[249572] = bhEne19_ActionMain_0x1f3980; // 0x1f3b98 - g_ps2RecompiledFunctionTable[249573] = bhEne19_ActionMain_0x1f3980; // 0x1f3b9c - g_ps2RecompiledFunctionTable[249574] = bhEne19_ActionMain_0x1f3980; // 0x1f3ba0 - g_ps2RecompiledFunctionTable[249575] = bhEne19_ActionMain_0x1f3980; // 0x1f3ba4 - g_ps2RecompiledFunctionTable[249576] = bhEne19_ActionMain_0x1f3980; // 0x1f3ba8 - g_ps2RecompiledFunctionTable[249577] = bhEne19_ActionMain_0x1f3980; // 0x1f3bac - g_ps2RecompiledFunctionTable[249578] = bhEne19_ActionMain_0x1f3980; // 0x1f3bb0 - g_ps2RecompiledFunctionTable[249579] = bhEne19_ActionMain_0x1f3980; // 0x1f3bb4 - g_ps2RecompiledFunctionTable[249580] = bhEne19_ActionMain_0x1f3980; // 0x1f3bb8 - g_ps2RecompiledFunctionTable[249581] = bhEne19_ActionMain_0x1f3980; // 0x1f3bbc - g_ps2RecompiledFunctionTable[249582] = bhEne19_ActionMain_0x1f3980; // 0x1f3bc0 - g_ps2RecompiledFunctionTable[249583] = bhEne19_ActionMain_0x1f3980; // 0x1f3bc4 - g_ps2RecompiledFunctionTable[249584] = bhEne19_ActionMain_0x1f3980; // 0x1f3bc8 - g_ps2RecompiledFunctionTable[249585] = bhEne19_ActionMain_0x1f3980; // 0x1f3bcc - g_ps2RecompiledFunctionTable[249586] = bhEne19_ActionMain_0x1f3980; // 0x1f3bd0 - g_ps2RecompiledFunctionTable[249587] = bhEne19_ActionMain_0x1f3980; // 0x1f3bd4 - g_ps2RecompiledFunctionTable[249588] = bhEne19_ActionMain_0x1f3980; // 0x1f3bd8 - g_ps2RecompiledFunctionTable[249590] = bhEne19_TargetAnalyze_0x1f3be0; // 0x1f3be0 - g_ps2RecompiledFunctionTable[249617] = bhEne19_TargetAnalyze_0x1f3be0; // 0x1f3c4c - g_ps2RecompiledFunctionTable[249669] = bhEne19_TargetAnalyze_0x1f3be0; // 0x1f3d1c - g_ps2RecompiledFunctionTable[249690] = bhEne19_TargetAnalyze_0x1f3be0; // 0x1f3d70 - g_ps2RecompiledFunctionTable[249695] = bhEne19_TargetAnalyze_0x1f3be0; // 0x1f3d84 - g_ps2RecompiledFunctionTable[249701] = bhEne19_TargetAnalyze_0x1f3be0; // 0x1f3d9c - g_ps2RecompiledFunctionTable[249765] = bhEne19_TargetAnalyze_0x1f3be0; // 0x1f3e9c - g_ps2RecompiledFunctionTable[249780] = bhEne19_TargetAnalyze_0x1f3be0; // 0x1f3ed8 - g_ps2RecompiledFunctionTable[249794] = bhEne19_PositonFix_0x1f3f10; // 0x1f3f10 - g_ps2RecompiledFunctionTable[249829] = bhEne19_PositonFix_0x1f3f10; // 0x1f3f9c - g_ps2RecompiledFunctionTable[249833] = bhEne19_PositonFix_0x1f3f10; // 0x1f3fac - g_ps2RecompiledFunctionTable[249842] = bhEne19_PositonFix_0x1f3f10; // 0x1f3fd0 - g_ps2RecompiledFunctionTable[249873] = bhEne19_PositonFix_0x1f3f10; // 0x1f404c - g_ps2RecompiledFunctionTable[249878] = bhEne19_PositonFix_0x1f3f10; // 0x1f4060 - g_ps2RecompiledFunctionTable[249883] = bhEne19_PositonFix_0x1f3f10; // 0x1f4074 - g_ps2RecompiledFunctionTable[249886] = bhEne19_PositonFix_0x1f3f10; // 0x1f4080 - g_ps2RecompiledFunctionTable[249890] = bhEne19_PositonFix_0x1f3f10; // 0x1f4090 - g_ps2RecompiledFunctionTable[249893] = bhEne19_PositonFix_0x1f3f10; // 0x1f409c - g_ps2RecompiledFunctionTable[249914] = bhEne19_HeadTurn_0x1f40f0; // 0x1f40f0 - g_ps2RecompiledFunctionTable[249934] = bhEne19_HeadTurn_0x1f40f0; // 0x1f4140 - g_ps2RecompiledFunctionTable[249939] = bhEne19_HeadTurn_0x1f40f0; // 0x1f4154 - g_ps2RecompiledFunctionTable[249982] = bhEne19_AttackHitCheck_0x1f4200; // 0x1f4200 - g_ps2RecompiledFunctionTable[250016] = bhEne19_AttackHitCheck_0x1f4200; // 0x1f4288 - g_ps2RecompiledFunctionTable[250021] = bhEne19_AttackHitCheck_0x1f4200; // 0x1f429c - g_ps2RecompiledFunctionTable[250039] = bhEne19_AttackHitCheck_0x1f4200; // 0x1f42e4 - g_ps2RecompiledFunctionTable[250044] = bhEne19_AttackHitCheck_0x1f4200; // 0x1f42f8 - g_ps2RecompiledFunctionTable[250074] = bhEne19_CalcEnemy_0x1f4370; // 0x1f4370 - g_ps2RecompiledFunctionTable[250081] = bhEne19_CalcEnemy_0x1f4370; // 0x1f438c - g_ps2RecompiledFunctionTable[250134] = bhEne19_DmgCheck_0x1f4460; // 0x1f4460 - g_ps2RecompiledFunctionTable[250135] = bhEne19_DmgCheck_0x1f4460; // 0x1f4464 - g_ps2RecompiledFunctionTable[250136] = bhEne19_DmgCheck_0x1f4460; // 0x1f4468 - g_ps2RecompiledFunctionTable[250137] = bhEne19_DmgCheck_0x1f4460; // 0x1f446c - g_ps2RecompiledFunctionTable[250138] = bhEne19_DmgCheck_0x1f4460; // 0x1f4470 - g_ps2RecompiledFunctionTable[250139] = bhEne19_DmgCheck_0x1f4460; // 0x1f4474 - g_ps2RecompiledFunctionTable[250140] = bhEne19_DmgCheck_0x1f4460; // 0x1f4478 - g_ps2RecompiledFunctionTable[250141] = bhEne19_DmgCheck_0x1f4460; // 0x1f447c - g_ps2RecompiledFunctionTable[250142] = bhEne19_DmgCheck_0x1f4460; // 0x1f4480 - g_ps2RecompiledFunctionTable[250143] = bhEne19_DmgCheck_0x1f4460; // 0x1f4484 - g_ps2RecompiledFunctionTable[250144] = bhEne19_DmgCheck_0x1f4460; // 0x1f4488 - g_ps2RecompiledFunctionTable[250145] = bhEne19_DmgCheck_0x1f4460; // 0x1f448c - g_ps2RecompiledFunctionTable[250146] = bhEne19_DmgCheck_0x1f4460; // 0x1f4490 - g_ps2RecompiledFunctionTable[250147] = bhEne19_DmgCheck_0x1f4460; // 0x1f4494 - g_ps2RecompiledFunctionTable[250148] = bhEne19_DmgCheck_0x1f4460; // 0x1f4498 - g_ps2RecompiledFunctionTable[250149] = bhEne19_DmgCheck_0x1f4460; // 0x1f449c - g_ps2RecompiledFunctionTable[250150] = bhEne19_DmgCheck_0x1f4460; // 0x1f44a0 - g_ps2RecompiledFunctionTable[250151] = bhEne19_DmgCheck_0x1f4460; // 0x1f44a4 - g_ps2RecompiledFunctionTable[250152] = bhEne19_DmgCheck_0x1f4460; // 0x1f44a8 - g_ps2RecompiledFunctionTable[250153] = bhEne19_DmgCheck_0x1f4460; // 0x1f44ac - g_ps2RecompiledFunctionTable[250154] = bhEne19_DmgCheck_0x1f4460; // 0x1f44b0 - g_ps2RecompiledFunctionTable[250155] = bhEne19_DmgCheck_0x1f4460; // 0x1f44b4 - g_ps2RecompiledFunctionTable[250156] = bhEne19_DmgCheck_0x1f4460; // 0x1f44b8 - g_ps2RecompiledFunctionTable[250157] = bhEne19_DmgCheck_0x1f4460; // 0x1f44bc - g_ps2RecompiledFunctionTable[250158] = bhEne19_DmgCheck_0x1f4460; // 0x1f44c0 - g_ps2RecompiledFunctionTable[250159] = bhEne19_DmgCheck_0x1f4460; // 0x1f44c4 - g_ps2RecompiledFunctionTable[250160] = bhEne19_DmgCheck_0x1f4460; // 0x1f44c8 - g_ps2RecompiledFunctionTable[250161] = bhEne19_DmgCheck_0x1f4460; // 0x1f44cc - g_ps2RecompiledFunctionTable[250162] = bhEne19_DmgCheck_0x1f4460; // 0x1f44d0 - g_ps2RecompiledFunctionTable[250163] = bhEne19_DmgCheck_0x1f4460; // 0x1f44d4 - g_ps2RecompiledFunctionTable[250164] = bhEne19_DmgCheck_0x1f4460; // 0x1f44d8 - g_ps2RecompiledFunctionTable[250165] = bhEne19_DmgCheck_0x1f4460; // 0x1f44dc - g_ps2RecompiledFunctionTable[250166] = bhEne19_DmgCheck_0x1f4460; // 0x1f44e0 - g_ps2RecompiledFunctionTable[250167] = bhEne19_DmgCheck_0x1f4460; // 0x1f44e4 - g_ps2RecompiledFunctionTable[250168] = bhEne19_DmgCheck_0x1f4460; // 0x1f44e8 - g_ps2RecompiledFunctionTable[250169] = bhEne19_DmgCheck_0x1f4460; // 0x1f44ec - g_ps2RecompiledFunctionTable[250170] = bhEne19_DmgCheck_0x1f4460; // 0x1f44f0 - g_ps2RecompiledFunctionTable[250171] = bhEne19_DmgCheck_0x1f4460; // 0x1f44f4 - g_ps2RecompiledFunctionTable[250172] = bhEne19_DmgCheck_0x1f4460; // 0x1f44f8 - g_ps2RecompiledFunctionTable[250173] = bhEne19_DmgCheck_0x1f4460; // 0x1f44fc - g_ps2RecompiledFunctionTable[250174] = bhEne19_DmgCheck_0x1f4460; // 0x1f4500 - g_ps2RecompiledFunctionTable[250175] = bhEne19_DmgCheck_0x1f4460; // 0x1f4504 - g_ps2RecompiledFunctionTable[250176] = bhEne19_DmgCheck_0x1f4460; // 0x1f4508 - g_ps2RecompiledFunctionTable[250177] = bhEne19_DmgCheck_0x1f4460; // 0x1f450c - g_ps2RecompiledFunctionTable[250178] = bhEne19_DmgCheck_0x1f4460; // 0x1f4510 - g_ps2RecompiledFunctionTable[250179] = bhEne19_DmgCheck_0x1f4460; // 0x1f4514 - g_ps2RecompiledFunctionTable[250180] = bhEne19_DmgCheck_0x1f4460; // 0x1f4518 - g_ps2RecompiledFunctionTable[250181] = bhEne19_DmgCheck_0x1f4460; // 0x1f451c - g_ps2RecompiledFunctionTable[250182] = bhEne19_DmgCheck_0x1f4460; // 0x1f4520 - g_ps2RecompiledFunctionTable[250183] = bhEne19_DmgCheck_0x1f4460; // 0x1f4524 - g_ps2RecompiledFunctionTable[250184] = bhEne19_DmgCheck_0x1f4460; // 0x1f4528 - g_ps2RecompiledFunctionTable[250185] = bhEne19_DmgCheck_0x1f4460; // 0x1f452c - g_ps2RecompiledFunctionTable[250186] = bhEne19_DmgCheck_0x1f4460; // 0x1f4530 - g_ps2RecompiledFunctionTable[250187] = bhEne19_DmgCheck_0x1f4460; // 0x1f4534 - g_ps2RecompiledFunctionTable[250188] = bhEne19_DmgCheck_0x1f4460; // 0x1f4538 - g_ps2RecompiledFunctionTable[250189] = bhEne19_DmgCheck_0x1f4460; // 0x1f453c - g_ps2RecompiledFunctionTable[250190] = bhEne19_DmgCheck_0x1f4460; // 0x1f4540 - g_ps2RecompiledFunctionTable[250191] = bhEne19_DmgCheck_0x1f4460; // 0x1f4544 - g_ps2RecompiledFunctionTable[250192] = bhEne19_DmgCheck_0x1f4460; // 0x1f4548 - g_ps2RecompiledFunctionTable[250193] = bhEne19_DmgCheck_0x1f4460; // 0x1f454c - g_ps2RecompiledFunctionTable[250194] = bhEne19_DmgCheck_0x1f4460; // 0x1f4550 - g_ps2RecompiledFunctionTable[250195] = bhEne19_DmgCheck_0x1f4460; // 0x1f4554 - g_ps2RecompiledFunctionTable[250196] = bhEne19_DmgCheck_0x1f4460; // 0x1f4558 - g_ps2RecompiledFunctionTable[250197] = bhEne19_DmgCheck_0x1f4460; // 0x1f455c - g_ps2RecompiledFunctionTable[250198] = bhEne19_DmgCheck_0x1f4460; // 0x1f4560 - g_ps2RecompiledFunctionTable[250199] = bhEne19_DmgCheck_0x1f4460; // 0x1f4564 - g_ps2RecompiledFunctionTable[250200] = bhEne19_DmgCheck_0x1f4460; // 0x1f4568 - g_ps2RecompiledFunctionTable[250201] = bhEne19_DmgCheck_0x1f4460; // 0x1f456c - g_ps2RecompiledFunctionTable[250202] = bhEne19_DmgCheck_0x1f4460; // 0x1f4570 - g_ps2RecompiledFunctionTable[250203] = bhEne19_DmgCheck_0x1f4460; // 0x1f4574 - g_ps2RecompiledFunctionTable[250204] = bhEne19_DmgCheck_0x1f4460; // 0x1f4578 - g_ps2RecompiledFunctionTable[250205] = bhEne19_DmgCheck_0x1f4460; // 0x1f457c - g_ps2RecompiledFunctionTable[250206] = bhEne19_DmgCheck_0x1f4460; // 0x1f4580 - g_ps2RecompiledFunctionTable[250207] = bhEne19_DmgCheck_0x1f4460; // 0x1f4584 - g_ps2RecompiledFunctionTable[250208] = bhEne19_DmgCheck_0x1f4460; // 0x1f4588 - g_ps2RecompiledFunctionTable[250209] = bhEne19_DmgCheck_0x1f4460; // 0x1f458c - g_ps2RecompiledFunctionTable[250210] = bhEne19_DmgCheck_0x1f4460; // 0x1f4590 - g_ps2RecompiledFunctionTable[250211] = bhEne19_DmgCheck_0x1f4460; // 0x1f4594 - g_ps2RecompiledFunctionTable[250212] = bhEne19_DmgCheck_0x1f4460; // 0x1f4598 - g_ps2RecompiledFunctionTable[250213] = bhEne19_DmgCheck_0x1f4460; // 0x1f459c - g_ps2RecompiledFunctionTable[250214] = bhEne19_DmgCheck_0x1f4460; // 0x1f45a0 - g_ps2RecompiledFunctionTable[250215] = bhEne19_DmgCheck_0x1f4460; // 0x1f45a4 - g_ps2RecompiledFunctionTable[250216] = bhEne19_DmgCheck_0x1f4460; // 0x1f45a8 - g_ps2RecompiledFunctionTable[250217] = bhEne19_DmgCheck_0x1f4460; // 0x1f45ac - g_ps2RecompiledFunctionTable[250218] = bhEne19_DmgCheck_0x1f4460; // 0x1f45b0 - g_ps2RecompiledFunctionTable[250219] = bhEne19_DmgCheck_0x1f4460; // 0x1f45b4 - g_ps2RecompiledFunctionTable[250220] = bhEne19_DmgCheck_0x1f4460; // 0x1f45b8 - g_ps2RecompiledFunctionTable[250221] = bhEne19_DmgCheck_0x1f4460; // 0x1f45bc - g_ps2RecompiledFunctionTable[250222] = bhEne19_DmgCheck_0x1f4460; // 0x1f45c0 - g_ps2RecompiledFunctionTable[250223] = bhEne19_DmgCheck_0x1f4460; // 0x1f45c4 - g_ps2RecompiledFunctionTable[250224] = bhEne19_DmgCheck_0x1f4460; // 0x1f45c8 - g_ps2RecompiledFunctionTable[250225] = bhEne19_DmgCheck_0x1f4460; // 0x1f45cc - g_ps2RecompiledFunctionTable[250226] = bhEne19_DmgCheck_0x1f4460; // 0x1f45d0 - g_ps2RecompiledFunctionTable[250227] = bhEne19_DmgCheck_0x1f4460; // 0x1f45d4 - g_ps2RecompiledFunctionTable[250228] = bhEne19_DmgCheck_0x1f4460; // 0x1f45d8 - g_ps2RecompiledFunctionTable[250229] = bhEne19_DmgCheck_0x1f4460; // 0x1f45dc - g_ps2RecompiledFunctionTable[250230] = bhEne19_DmgCheck_0x1f4460; // 0x1f45e0 - g_ps2RecompiledFunctionTable[250231] = bhEne19_DmgCheck_0x1f4460; // 0x1f45e4 - g_ps2RecompiledFunctionTable[250232] = bhEne19_DmgCheck_0x1f4460; // 0x1f45e8 - g_ps2RecompiledFunctionTable[250233] = bhEne19_DmgCheck_0x1f4460; // 0x1f45ec - g_ps2RecompiledFunctionTable[250234] = bhEne19_DmgCheck_0x1f4460; // 0x1f45f0 - g_ps2RecompiledFunctionTable[250235] = bhEne19_DmgCheck_0x1f4460; // 0x1f45f4 - g_ps2RecompiledFunctionTable[250236] = bhEne19_DmgCheck_0x1f4460; // 0x1f45f8 - g_ps2RecompiledFunctionTable[250237] = bhEne19_DmgCheck_0x1f4460; // 0x1f45fc - g_ps2RecompiledFunctionTable[250238] = bhEne19_DmgCheck_0x1f4460; // 0x1f4600 - g_ps2RecompiledFunctionTable[250239] = bhEne19_DmgCheck_0x1f4460; // 0x1f4604 - g_ps2RecompiledFunctionTable[250240] = bhEne19_DmgCheck_0x1f4460; // 0x1f4608 - g_ps2RecompiledFunctionTable[250241] = bhEne19_DmgCheck_0x1f4460; // 0x1f460c - g_ps2RecompiledFunctionTable[250242] = bhEne19_DmgCheck_0x1f4460; // 0x1f4610 - g_ps2RecompiledFunctionTable[250243] = bhEne19_DmgCheck_0x1f4460; // 0x1f4614 - g_ps2RecompiledFunctionTable[250244] = bhEne19_DmgCheck_0x1f4460; // 0x1f4618 - g_ps2RecompiledFunctionTable[250245] = bhEne19_DmgCheck_0x1f4460; // 0x1f461c - g_ps2RecompiledFunctionTable[250246] = bhEne19_DmgCheck_0x1f4460; // 0x1f4620 - g_ps2RecompiledFunctionTable[250247] = bhEne19_DmgCheck_0x1f4460; // 0x1f4624 - g_ps2RecompiledFunctionTable[250248] = bhEne19_DmgCheck_0x1f4460; // 0x1f4628 - g_ps2RecompiledFunctionTable[250249] = bhEne19_DmgCheck_0x1f4460; // 0x1f462c - g_ps2RecompiledFunctionTable[250250] = bhEne19_DmgCheck_0x1f4460; // 0x1f4630 - g_ps2RecompiledFunctionTable[250251] = bhEne19_DmgCheck_0x1f4460; // 0x1f4634 - g_ps2RecompiledFunctionTable[250252] = bhEne19_DmgCheck_0x1f4460; // 0x1f4638 - g_ps2RecompiledFunctionTable[250253] = bhEne19_DmgCheck_0x1f4460; // 0x1f463c - g_ps2RecompiledFunctionTable[250254] = bhEne19_DmgCheck_0x1f4460; // 0x1f4640 - g_ps2RecompiledFunctionTable[250255] = bhEne19_DmgCheck_0x1f4460; // 0x1f4644 - g_ps2RecompiledFunctionTable[250256] = bhEne19_DmgCheck_0x1f4460; // 0x1f4648 - g_ps2RecompiledFunctionTable[250257] = bhEne19_DmgCheck_0x1f4460; // 0x1f464c - g_ps2RecompiledFunctionTable[250258] = bhEne19_DmgCheck_0x1f4460; // 0x1f4650 - g_ps2RecompiledFunctionTable[250259] = bhEne19_DmgCheck_0x1f4460; // 0x1f4654 - g_ps2RecompiledFunctionTable[250260] = bhEne19_DmgCheck_0x1f4460; // 0x1f4658 - g_ps2RecompiledFunctionTable[250261] = bhEne19_DmgCheck_0x1f4460; // 0x1f465c - g_ps2RecompiledFunctionTable[250262] = bhEne19_DmgCheck_0x1f4460; // 0x1f4660 - g_ps2RecompiledFunctionTable[250263] = bhEne19_DmgCheck_0x1f4460; // 0x1f4664 - g_ps2RecompiledFunctionTable[250264] = bhEne19_DmgCheck_0x1f4460; // 0x1f4668 - g_ps2RecompiledFunctionTable[250265] = bhEne19_DmgCheck_0x1f4460; // 0x1f466c - g_ps2RecompiledFunctionTable[250266] = bhEne19_DmgCheck_0x1f4460; // 0x1f4670 - g_ps2RecompiledFunctionTable[250267] = bhEne19_DmgCheck_0x1f4460; // 0x1f4674 - g_ps2RecompiledFunctionTable[250268] = bhEne19_DmgCheck_0x1f4460; // 0x1f4678 - g_ps2RecompiledFunctionTable[250269] = bhEne19_DmgCheck_0x1f4460; // 0x1f467c - g_ps2RecompiledFunctionTable[250270] = bhEne19_DmgCheck_0x1f4460; // 0x1f4680 - g_ps2RecompiledFunctionTable[250271] = bhEne19_DmgCheck_0x1f4460; // 0x1f4684 - g_ps2RecompiledFunctionTable[250272] = bhEne19_DmgCheck_0x1f4460; // 0x1f4688 - g_ps2RecompiledFunctionTable[250273] = bhEne19_DmgCheck_0x1f4460; // 0x1f468c - g_ps2RecompiledFunctionTable[250274] = bhEne19_DmgCheck_0x1f4460; // 0x1f4690 - g_ps2RecompiledFunctionTable[250275] = bhEne19_DmgCheck_0x1f4460; // 0x1f4694 - g_ps2RecompiledFunctionTable[250276] = bhEne19_DmgCheck_0x1f4460; // 0x1f4698 - g_ps2RecompiledFunctionTable[250277] = bhEne19_DmgCheck_0x1f4460; // 0x1f469c - g_ps2RecompiledFunctionTable[250278] = bhEne19_DmgCheck_0x1f4460; // 0x1f46a0 - g_ps2RecompiledFunctionTable[250279] = bhEne19_DmgCheck_0x1f4460; // 0x1f46a4 - g_ps2RecompiledFunctionTable[250280] = bhEne19_DmgCheck_0x1f4460; // 0x1f46a8 - g_ps2RecompiledFunctionTable[250281] = bhEne19_DmgCheck_0x1f4460; // 0x1f46ac - g_ps2RecompiledFunctionTable[250282] = bhEne19_DmgCheck_0x1f4460; // 0x1f46b0 - g_ps2RecompiledFunctionTable[250283] = bhEne19_DmgCheck_0x1f4460; // 0x1f46b4 - g_ps2RecompiledFunctionTable[250284] = bhEne19_DmgCheck_0x1f4460; // 0x1f46b8 - g_ps2RecompiledFunctionTable[250285] = bhEne19_DmgCheck_0x1f4460; // 0x1f46bc - g_ps2RecompiledFunctionTable[250286] = bhEne19_DmgCheck_0x1f4460; // 0x1f46c0 - g_ps2RecompiledFunctionTable[250287] = bhEne19_DmgCheck_0x1f4460; // 0x1f46c4 - g_ps2RecompiledFunctionTable[250288] = bhEne19_DmgCheck_0x1f4460; // 0x1f46c8 - g_ps2RecompiledFunctionTable[250289] = bhEne19_DmgCheck_0x1f4460; // 0x1f46cc - g_ps2RecompiledFunctionTable[250290] = bhEne19_DmgCheck_0x1f4460; // 0x1f46d0 - g_ps2RecompiledFunctionTable[250291] = bhEne19_DmgCheck_0x1f4460; // 0x1f46d4 - g_ps2RecompiledFunctionTable[250292] = bhEne19_DmgCheck_0x1f4460; // 0x1f46d8 - g_ps2RecompiledFunctionTable[250293] = bhEne19_DmgCheck_0x1f4460; // 0x1f46dc - g_ps2RecompiledFunctionTable[250294] = bhEne19_DmgCheck_0x1f4460; // 0x1f46e0 - g_ps2RecompiledFunctionTable[250295] = bhEne19_DmgCheck_0x1f4460; // 0x1f46e4 - g_ps2RecompiledFunctionTable[250296] = bhEne19_DmgCheck_0x1f4460; // 0x1f46e8 - g_ps2RecompiledFunctionTable[250297] = bhEne19_DmgCheck_0x1f4460; // 0x1f46ec - g_ps2RecompiledFunctionTable[250298] = bhEne19_DmgCheck_0x1f4460; // 0x1f46f0 - g_ps2RecompiledFunctionTable[250299] = bhEne19_DmgCheck_0x1f4460; // 0x1f46f4 - g_ps2RecompiledFunctionTable[250300] = bhEne19_DmgCheck_0x1f4460; // 0x1f46f8 - g_ps2RecompiledFunctionTable[250301] = bhEne19_DmgCheck_0x1f4460; // 0x1f46fc - g_ps2RecompiledFunctionTable[250302] = bhEne19_DmgCheck_0x1f4460; // 0x1f4700 - g_ps2RecompiledFunctionTable[250303] = bhEne19_DmgCheck_0x1f4460; // 0x1f4704 - g_ps2RecompiledFunctionTable[250304] = bhEne19_DmgCheck_0x1f4460; // 0x1f4708 - g_ps2RecompiledFunctionTable[250305] = bhEne19_DmgCheck_0x1f4460; // 0x1f470c - g_ps2RecompiledFunctionTable[250306] = bhEne19_DmgCheck_0x1f4460; // 0x1f4710 - g_ps2RecompiledFunctionTable[250307] = bhEne19_DmgCheck_0x1f4460; // 0x1f4714 - g_ps2RecompiledFunctionTable[250308] = bhEne19_DmgCheck_0x1f4460; // 0x1f4718 - g_ps2RecompiledFunctionTable[250309] = bhEne19_DmgCheck_0x1f4460; // 0x1f471c - g_ps2RecompiledFunctionTable[250310] = bhEne19_DmgCheck_0x1f4460; // 0x1f4720 - g_ps2RecompiledFunctionTable[250311] = bhEne19_DmgCheck_0x1f4460; // 0x1f4724 - g_ps2RecompiledFunctionTable[250312] = bhEne19_DmgCheck_0x1f4460; // 0x1f4728 - g_ps2RecompiledFunctionTable[250313] = bhEne19_DmgCheck_0x1f4460; // 0x1f472c - g_ps2RecompiledFunctionTable[250314] = bhEne19_DmgCheck_0x1f4460; // 0x1f4730 - g_ps2RecompiledFunctionTable[250315] = bhEne19_DmgCheck_0x1f4460; // 0x1f4734 - g_ps2RecompiledFunctionTable[250316] = bhEne19_DmgCheck_0x1f4460; // 0x1f4738 - g_ps2RecompiledFunctionTable[250317] = bhEne19_DmgCheck_0x1f4460; // 0x1f473c - g_ps2RecompiledFunctionTable[250318] = bhEne19_DmgCheck_0x1f4460; // 0x1f4740 - g_ps2RecompiledFunctionTable[250319] = bhEne19_DmgCheck_0x1f4460; // 0x1f4744 - g_ps2RecompiledFunctionTable[250320] = bhEne19_DmgCheck_0x1f4460; // 0x1f4748 - g_ps2RecompiledFunctionTable[250321] = bhEne19_DmgCheck_0x1f4460; // 0x1f474c - g_ps2RecompiledFunctionTable[250322] = bhEne19_DmgCheck_0x1f4460; // 0x1f4750 - g_ps2RecompiledFunctionTable[250323] = bhEne19_DmgCheck_0x1f4460; // 0x1f4754 - g_ps2RecompiledFunctionTable[250324] = bhEne19_DmgCheck_0x1f4460; // 0x1f4758 - g_ps2RecompiledFunctionTable[250325] = bhEne19_DmgCheck_0x1f4460; // 0x1f475c - g_ps2RecompiledFunctionTable[250326] = bhEne19_DmgCheck_0x1f4460; // 0x1f4760 - g_ps2RecompiledFunctionTable[250327] = bhEne19_DmgCheck_0x1f4460; // 0x1f4764 - g_ps2RecompiledFunctionTable[250328] = bhEne19_DmgCheck_0x1f4460; // 0x1f4768 - g_ps2RecompiledFunctionTable[250329] = bhEne19_DmgCheck_0x1f4460; // 0x1f476c - g_ps2RecompiledFunctionTable[250330] = bhEne19_DmgCheck_0x1f4460; // 0x1f4770 - g_ps2RecompiledFunctionTable[250331] = bhEne19_DmgCheck_0x1f4460; // 0x1f4774 - g_ps2RecompiledFunctionTable[250332] = bhEne19_DmgCheck_0x1f4460; // 0x1f4778 - g_ps2RecompiledFunctionTable[250334] = bhEne19_SetDmgEffect_0x1f4780; // 0x1f4780 - g_ps2RecompiledFunctionTable[250354] = bhEne19_SetDmgEffect_0x1f4780; // 0x1f47d0 - g_ps2RecompiledFunctionTable[250390] = bhEne19_SetDmgEffect_0x1f4780; // 0x1f4860 - g_ps2RecompiledFunctionTable[250406] = bhEne19_SetDmgEffect_0x1f4780; // 0x1f48a0 - g_ps2RecompiledFunctionTable[250430] = bhEne19_SetDmgEffect_0x1f4780; // 0x1f4900 - g_ps2RecompiledFunctionTable[250440] = bhEne19_SetDmgEffect_0x1f4780; // 0x1f4928 - g_ps2RecompiledFunctionTable[250454] = bhEne19_SetDmgEffect_0x1f4780; // 0x1f4960 - g_ps2RecompiledFunctionTable[250459] = bhEne19_SetDmgEffect_0x1f4780; // 0x1f4974 - g_ps2RecompiledFunctionTable[250467] = bhEne19_SetDmgEffect_0x1f4780; // 0x1f4994 - g_ps2RecompiledFunctionTable[250472] = bhEne19_SetDmgEffect_0x1f4780; // 0x1f49a8 - g_ps2RecompiledFunctionTable[250523] = bhEne19_SetDmgEffect_0x1f4780; // 0x1f4a74 - g_ps2RecompiledFunctionTable[250525] = bhEne19_SetDmgEffect_0x1f4780; // 0x1f4a7c - g_ps2RecompiledFunctionTable[250541] = bhEne19_SetDmgEffect_0x1f4780; // 0x1f4abc - g_ps2RecompiledFunctionTable[250566] = bhEne19_SetDmgEffect_0x1f4780; // 0x1f4b20 - g_ps2RecompiledFunctionTable[250587] = bhEne19_SetDmgEffect_0x1f4780; // 0x1f4b74 - g_ps2RecompiledFunctionTable[250590] = bhEne19_SetDmgEffect_0x1f4780; // 0x1f4b80 - g_ps2RecompiledFunctionTable[250595] = bhEne19_SetDmgEffect_0x1f4780; // 0x1f4b94 - g_ps2RecompiledFunctionTable[250667] = bhEne19_SetDmgEffect_0x1f4780; // 0x1f4cb4 - g_ps2RecompiledFunctionTable[250689] = bhEne19_SetDmgEffect_0x1f4780; // 0x1f4d0c - g_ps2RecompiledFunctionTable[250694] = bhEne19_SetDmgEffect_0x1f4780; // 0x1f4d20 - g_ps2RecompiledFunctionTable[250713] = bhEne19_SetDmgEffect_0x1f4780; // 0x1f4d6c - g_ps2RecompiledFunctionTable[250715] = bhEne19_SetDmgEffect_0x1f4780; // 0x1f4d74 - g_ps2RecompiledFunctionTable[250731] = bhEne19_SetDmgEffect_0x1f4780; // 0x1f4db4 - g_ps2RecompiledFunctionTable[250752] = bhEne19_SetDmgEffect_0x1f4780; // 0x1f4e08 - g_ps2RecompiledFunctionTable[250766] = bhEne19_CollisionCircle2Oval_0x1f4e40; // 0x1f4e40 - g_ps2RecompiledFunctionTable[250795] = bhEne19_CollisionCircle2Oval_0x1f4e40; // 0x1f4eb4 - g_ps2RecompiledFunctionTable[250800] = bhEne19_CollisionCircle2Oval_0x1f4e40; // 0x1f4ec8 - g_ps2RecompiledFunctionTable[250803] = bhEne19_CollisionCircle2Oval_0x1f4e40; // 0x1f4ed4 - g_ps2RecompiledFunctionTable[250808] = bhEne19_CollisionCircle2Oval_0x1f4e40; // 0x1f4ee8 - g_ps2RecompiledFunctionTable[250821] = bhEne19_CollisionCircle2Oval_0x1f4e40; // 0x1f4f1c - g_ps2RecompiledFunctionTable[250829] = bhEne19_CollisionCircle2Oval_0x1f4e40; // 0x1f4f3c - g_ps2RecompiledFunctionTable[250837] = bhEne19_CollisionCircle2Oval_0x1f4e40; // 0x1f4f5c - g_ps2RecompiledFunctionTable[250839] = bhEne19_CollisionCircle2Oval_0x1f4e40; // 0x1f4f64 - g_ps2RecompiledFunctionTable[250852] = bhEne19_CollisionCircle2Oval_0x1f4e40; // 0x1f4f98 - g_ps2RecompiledFunctionTable[250865] = bhEne19_CollisionCircle2Oval_0x1f4e40; // 0x1f4fcc - g_ps2RecompiledFunctionTable[250878] = bhEne19_TyBloodSet_0x1f5000; // 0x1f5000 - g_ps2RecompiledFunctionTable[250899] = bhEne19_TyBloodSet_0x1f5000; // 0x1f5054 - g_ps2RecompiledFunctionTable[250912] = bhEne19_TyBloodSet_0x1f5000; // 0x1f5088 - g_ps2RecompiledFunctionTable[250927] = bhEne19_TyBloodSet_0x1f5000; // 0x1f50c4 - g_ps2RecompiledFunctionTable[250984] = bhEne19_TyBloodSet_0x1f5000; // 0x1f51a8 - g_ps2RecompiledFunctionTable[250990] = bhEne19_TyBloodSet_0x1f5000; // 0x1f51c0 - g_ps2RecompiledFunctionTable[251012] = bhEne19_TyBloodSet_0x1f5000; // 0x1f5218 - g_ps2RecompiledFunctionTable[251034] = bhEne19_TyBloodSet_0x1f5000; // 0x1f5270 - g_ps2RecompiledFunctionTable[251069] = bhEne19_TyBloodSet_0x1f5000; // 0x1f52fc - g_ps2RecompiledFunctionTable[251082] = bhEne19_ClawReset_0x1f5330; // 0x1f5330 - g_ps2RecompiledFunctionTable[251110] = bhEne19_SoundSet_0x1f53a0; // 0x1f53a0 - g_ps2RecompiledFunctionTable[251143] = bhEne19_SoundSet_0x1f53a0; // 0x1f5424 - g_ps2RecompiledFunctionTable[251195] = bhEne19_SoundSet_0x1f53a0; // 0x1f54f4 - g_ps2RecompiledFunctionTable[251260] = bhEne19_SoundSet_0x1f53a0; // 0x1f55f8 - g_ps2RecompiledFunctionTable[251299] = bhEne19_SoundSet_0x1f53a0; // 0x1f5694 - g_ps2RecompiledFunctionTable[251344] = bhEne19_SoundSet_0x1f53a0; // 0x1f5748 - g_ps2RecompiledFunctionTable[251438] = bhEne19_SoundSet_0x1f53a0; // 0x1f58c0 - g_ps2RecompiledFunctionTable[251470] = bhEne19_SoundSet_0x1f53a0; // 0x1f5940 - g_ps2RecompiledFunctionTable[251478] = bhEne19_MtnAttrbuteGet_0x1f5960; // 0x1f5960 - g_ps2RecompiledFunctionTable[251498] = bhEne19_PlySetDamage_0x1f59b0; // 0x1f59b0 - g_ps2RecompiledFunctionTable[251562] = bhEne19_PlySetDamage_0x1f59b0; // 0x1f5ab0 - g_ps2RecompiledFunctionTable[251570] = bhEne19_PlyMoveMain_0x1f5ad0; // 0x1f5ad0 - g_ps2RecompiledFunctionTable[251584] = bhEne19_PlyMoveMain_0x1f5ad0; // 0x1f5b08 - g_ps2RecompiledFunctionTable[251780] = bhEne19_PlyMoveMain_0x1f5ad0; // 0x1f5e18 - g_ps2RecompiledFunctionTable[251783] = bhEne19_PlyMoveMain_0x1f5ad0; // 0x1f5e24 - g_ps2RecompiledFunctionTable[251790] = bhEne19_PlyDmg042_0x1f5e40; // 0x1f5e40 - g_ps2RecompiledFunctionTable[251806] = bhEne19_PlyDmg042_0x1f5e40; // 0x1f5e80 - g_ps2RecompiledFunctionTable[251815] = bhEne19_PlyDmg042_0x1f5e40; // 0x1f5ea4 - g_ps2RecompiledFunctionTable[251822] = bhEne19_PlyDmg042_0x1f5e40; // 0x1f5ec0 - g_ps2RecompiledFunctionTable[251846] = bhEne19_PlyDmg042_0x1f5e40; // 0x1f5f20 - g_ps2RecompiledFunctionTable[251945] = bhEne19_PlyDmg042_0x1f5e40; // 0x1f60ac - g_ps2RecompiledFunctionTable[251954] = bhEne19_PlyDmg043_0x1f60d0; // 0x1f60d0 - g_ps2RecompiledFunctionTable[251961] = bhEne19_PlyDmg043_0x1f60d0; // 0x1f60ec - g_ps2RecompiledFunctionTable[252039] = bhEne19_PlyDmg043_0x1f60d0; // 0x1f6224 - g_ps2RecompiledFunctionTable[252046] = bhEne19_PlyDmg044_0x1f6240; // 0x1f6240 - g_ps2RecompiledFunctionTable[252070] = bhEne19_PlyDmg045_0x1f62a0; // 0x1f62a0 - g_ps2RecompiledFunctionTable[252086] = bhEne19_PlyDmg046_047_0x1f62e0; // 0x1f62e0 - g_ps2RecompiledFunctionTable[252090] = bhEne19_PlyDmg050_051_0x1f62f0; // 0x1f62f0 - g_ps2RecompiledFunctionTable[252100] = bhEne19_PlyDmg050_051_0x1f62f0; // 0x1f6318 - g_ps2RecompiledFunctionTable[252103] = bhEne19_PlyDmg050_051_0x1f62f0; // 0x1f6324 - g_ps2RecompiledFunctionTable[252110] = bhEne19_PlyDmg052_053_0x1f6340; // 0x1f6340 - g_ps2RecompiledFunctionTable[252127] = bhEne19_PlyDmg052_053_0x1f6340; // 0x1f6384 - g_ps2RecompiledFunctionTable[252137] = bhEne19_PlyDmg052_053_0x1f6340; // 0x1f63ac - g_ps2RecompiledFunctionTable[252144] = bhEne19_PlyDmg052_053_0x1f6340; // 0x1f63c8 - g_ps2RecompiledFunctionTable[252167] = bhEne19_PlyDmg052_053_0x1f6340; // 0x1f6424 - g_ps2RecompiledFunctionTable[252226] = bhEne19_PlyDmg052_053_0x1f6340; // 0x1f6510 - g_ps2RecompiledFunctionTable[252253] = bhEne19_PlyDmg052_053_0x1f6340; // 0x1f657c - g_ps2RecompiledFunctionTable[252267] = bhEne19_PlyDmg052_053_0x1f6340; // 0x1f65b4 - g_ps2RecompiledFunctionTable[252279] = bhEne19_PlyDmg052_053_0x1f6340; // 0x1f65e4 - g_ps2RecompiledFunctionTable[252348] = bhEne19_PlyDmg052_053_0x1f6340; // 0x1f66f8 - g_ps2RecompiledFunctionTable[252375] = bhEne19_PlyDmg052_053_0x1f6340; // 0x1f6764 - g_ps2RecompiledFunctionTable[252390] = bhEne19_PlyDmg117_118_0x1f67a0; // 0x1f67a0 - g_ps2RecompiledFunctionTable[252406] = bhEne19_PlyDmg117_118_0x1f67a0; // 0x1f67e0 - g_ps2RecompiledFunctionTable[252415] = bhEne19_PlyDmg117_118_0x1f67a0; // 0x1f6804 - g_ps2RecompiledFunctionTable[252422] = bhEne19_PlyDmg117_118_0x1f67a0; // 0x1f6820 - g_ps2RecompiledFunctionTable[252446] = bhEne19_PlyDmg117_118_0x1f67a0; // 0x1f6880 - g_ps2RecompiledFunctionTable[252550] = bhEne19_PlyDmg117_118_0x1f67a0; // 0x1f6a20 - g_ps2RecompiledFunctionTable[252553] = bhEne19_PlyDmg117_118_0x1f67a0; // 0x1f6a2c - g_ps2RecompiledFunctionTable[252562] = bhEne19_PlyDmgDie_0x1f6a50; // 0x1f6a50 - g_ps2RecompiledFunctionTable[252602] = bhEne19_PlyDmgRtn_0x1f6af0; // 0x1f6af0 - g_ps2RecompiledFunctionTable[252642] = bhEne19_PlyDmgFal_0x1f6b90; // 0x1f6b90 - g_ps2RecompiledFunctionTable[252725] = bhEne19_PlyDmgFal_0x1f6b90; // 0x1f6cdc - g_ps2RecompiledFunctionTable[252765] = bhEne19_PlyDmgFal_0x1f6b90; // 0x1f6d7c - g_ps2RecompiledFunctionTable[252772] = bhEne19_PlyDmgFal_0x1f6b90; // 0x1f6d98 - g_ps2RecompiledFunctionTable[252782] = bhEne19_PlyDmgFal_0x1f6b90; // 0x1f6dc0 - g_ps2RecompiledFunctionTable[252788] = bhEne19_PlyDmgFal_0x1f6b90; // 0x1f6dd8 - g_ps2RecompiledFunctionTable[252810] = bhEne_PlyActionInit_0x1f6e30; // 0x1f6e30 - g_ps2RecompiledFunctionTable[252822] = bhEne_PlyActionMain_0x1f6e60; // 0x1f6e60 - g_ps2RecompiledFunctionTable[252823] = bhEne_PlyActionMain_0x1f6e60; // 0x1f6e64 - g_ps2RecompiledFunctionTable[252824] = bhEne_PlyActionMain_0x1f6e60; // 0x1f6e68 - g_ps2RecompiledFunctionTable[252825] = bhEne_PlyActionMain_0x1f6e60; // 0x1f6e6c - g_ps2RecompiledFunctionTable[252826] = bhEne_PlyActionMain_0x1f6e60; // 0x1f6e70 - g_ps2RecompiledFunctionTable[252827] = bhEne_PlyActionMain_0x1f6e60; // 0x1f6e74 - g_ps2RecompiledFunctionTable[252828] = bhEne_PlyActionMain_0x1f6e60; // 0x1f6e78 - g_ps2RecompiledFunctionTable[252829] = bhEne_PlyActionMain_0x1f6e60; // 0x1f6e7c - g_ps2RecompiledFunctionTable[252830] = bhEne_PlyActionMain_0x1f6e60; // 0x1f6e80 - g_ps2RecompiledFunctionTable[252831] = bhEne_PlyActionMain_0x1f6e60; // 0x1f6e84 - g_ps2RecompiledFunctionTable[252832] = bhEne_PlyActionMain_0x1f6e60; // 0x1f6e88 - g_ps2RecompiledFunctionTable[252833] = bhEne_PlyActionMain_0x1f6e60; // 0x1f6e8c - g_ps2RecompiledFunctionTable[252834] = bhEne_PlyActionMain_0x1f6e60; // 0x1f6e90 - g_ps2RecompiledFunctionTable[252835] = bhEne_PlyActionMain_0x1f6e60; // 0x1f6e94 - g_ps2RecompiledFunctionTable[252836] = bhEne_PlyActionMain_0x1f6e60; // 0x1f6e98 - g_ps2RecompiledFunctionTable[252837] = bhEne_PlyActionMain_0x1f6e60; // 0x1f6e9c - g_ps2RecompiledFunctionTable[252838] = bhEne_PlyActionMain_0x1f6e60; // 0x1f6ea0 - g_ps2RecompiledFunctionTable[252839] = bhEne_PlyActionMain_0x1f6e60; // 0x1f6ea4 - g_ps2RecompiledFunctionTable[252840] = bhEne_PlyActionMain_0x1f6e60; // 0x1f6ea8 - g_ps2RecompiledFunctionTable[252841] = bhEne_PlyActionMain_0x1f6e60; // 0x1f6eac - g_ps2RecompiledFunctionTable[252842] = bhEne_PlyActionMain_0x1f6e60; // 0x1f6eb0 - g_ps2RecompiledFunctionTable[252843] = bhEne_PlyActionMain_0x1f6e60; // 0x1f6eb4 - g_ps2RecompiledFunctionTable[252844] = bhEne_PlyActionMain_0x1f6e60; // 0x1f6eb8 - g_ps2RecompiledFunctionTable[252845] = bhEne_PlyActionMain_0x1f6e60; // 0x1f6ebc - g_ps2RecompiledFunctionTable[252846] = bhEne_PlyActionMain_0x1f6e60; // 0x1f6ec0 - g_ps2RecompiledFunctionTable[252847] = bhEne_PlyActionMain_0x1f6e60; // 0x1f6ec4 - g_ps2RecompiledFunctionTable[252848] = bhEne_PlyActionMain_0x1f6e60; // 0x1f6ec8 - g_ps2RecompiledFunctionTable[252849] = bhEne_PlyActionMain_0x1f6e60; // 0x1f6ecc - g_ps2RecompiledFunctionTable[252850] = bhEne_PlyActionMain_0x1f6e60; // 0x1f6ed0 - g_ps2RecompiledFunctionTable[252851] = bhEne_PlyActionMain_0x1f6e60; // 0x1f6ed4 - g_ps2RecompiledFunctionTable[252852] = bhEne_PlyActionMain_0x1f6e60; // 0x1f6ed8 - g_ps2RecompiledFunctionTable[252853] = bhEne_PlyActionMain_0x1f6e60; // 0x1f6edc - g_ps2RecompiledFunctionTable[252854] = bhEne_PlyActionMain_0x1f6e60; // 0x1f6ee0 - g_ps2RecompiledFunctionTable[252855] = bhEne_PlyActionMain_0x1f6e60; // 0x1f6ee4 - g_ps2RecompiledFunctionTable[252856] = bhEne_PlyActionMain_0x1f6e60; // 0x1f6ee8 - g_ps2RecompiledFunctionTable[252857] = bhEne_PlyActionMain_0x1f6e60; // 0x1f6eec - g_ps2RecompiledFunctionTable[252858] = bhEne_PlyActionMain_0x1f6e60; // 0x1f6ef0 - g_ps2RecompiledFunctionTable[252859] = bhEne_PlyActionMain_0x1f6e60; // 0x1f6ef4 - g_ps2RecompiledFunctionTable[252860] = bhEne_PlyActionMain_0x1f6e60; // 0x1f6ef8 - g_ps2RecompiledFunctionTable[252861] = bhEne_PlyActionMain_0x1f6e60; // 0x1f6efc - g_ps2RecompiledFunctionTable[252862] = bhEne_PlyActionMain_0x1f6e60; // 0x1f6f00 - g_ps2RecompiledFunctionTable[252863] = bhEne_PlyActionMain_0x1f6e60; // 0x1f6f04 - g_ps2RecompiledFunctionTable[252864] = bhEne_PlyActionMain_0x1f6e60; // 0x1f6f08 - g_ps2RecompiledFunctionTable[252865] = bhEne_PlyActionMain_0x1f6e60; // 0x1f6f0c - g_ps2RecompiledFunctionTable[252866] = bhEne_PlyActionMain_0x1f6e60; // 0x1f6f10 - g_ps2RecompiledFunctionTable[252870] = bhEne_PlyActionChange_0x1f6f20; // 0x1f6f20 - g_ps2RecompiledFunctionTable[252906] = bhEne_PlyActionChange_0x1f6f20; // 0x1f6fb0 - g_ps2RecompiledFunctionTable[252914] = bhEne_PlyActionChange_0x1f6f20; // 0x1f6fd0 - g_ps2RecompiledFunctionTable[252916] = bhEne_PlyActionChange_0x1f6f20; // 0x1f6fd8 - g_ps2RecompiledFunctionTable[252962] = bhEne_CalcCombRate_0x1f7090; // 0x1f7090 - g_ps2RecompiledFunctionTable[252986] = bhEne19_CheckDmgLvl0_0x1f70f0; // 0x1f70f0 - g_ps2RecompiledFunctionTable[252993] = bhEne19_CheckDmgLvl0_0x1f70f0; // 0x1f710c - g_ps2RecompiledFunctionTable[253042] = bhEne19_CheckDmgLvl1_0x1f71d0; // 0x1f71d0 - g_ps2RecompiledFunctionTable[253048] = bhEne19_CheckDmgLvl1_0x1f71d0; // 0x1f71e8 - g_ps2RecompiledFunctionTable[253106] = bhEne19_CheckDmgLvl2_0x1f72d0; // 0x1f72d0 - g_ps2RecompiledFunctionTable[253113] = bhEne19_CheckDmgLvl2_0x1f72d0; // 0x1f72ec - g_ps2RecompiledFunctionTable[253150] = bhEne19_SetLeftClaw_0x1f7380; // 0x1f7380 - g_ps2RecompiledFunctionTable[253190] = bhEne19_SetLeftClaw_0x1f7380; // 0x1f7420 - g_ps2RecompiledFunctionTable[253194] = bhEne19_SetClawPlane_0x1f7430; // 0x1f7430 - g_ps2RecompiledFunctionTable[253216] = bhEne19_SetClawPlane_0x1f7430; // 0x1f7488 - g_ps2RecompiledFunctionTable[253222] = bhEne20_0x1f74a0; // 0x1f74a0 - g_ps2RecompiledFunctionTable[253223] = bhEne20_0x1f74a0; // 0x1f74a4 - g_ps2RecompiledFunctionTable[253224] = bhEne20_0x1f74a0; // 0x1f74a8 - g_ps2RecompiledFunctionTable[253225] = bhEne20_0x1f74a0; // 0x1f74ac - g_ps2RecompiledFunctionTable[253226] = bhEne20_0x1f74a0; // 0x1f74b0 - g_ps2RecompiledFunctionTable[253227] = bhEne20_0x1f74a0; // 0x1f74b4 - g_ps2RecompiledFunctionTable[253228] = bhEne20_0x1f74a0; // 0x1f74b8 - g_ps2RecompiledFunctionTable[253229] = bhEne20_0x1f74a0; // 0x1f74bc - g_ps2RecompiledFunctionTable[253230] = bhEne20_0x1f74a0; // 0x1f74c0 - g_ps2RecompiledFunctionTable[253231] = bhEne20_0x1f74a0; // 0x1f74c4 - g_ps2RecompiledFunctionTable[253232] = bhEne20_0x1f74a0; // 0x1f74c8 - g_ps2RecompiledFunctionTable[253233] = bhEne20_0x1f74a0; // 0x1f74cc - g_ps2RecompiledFunctionTable[253234] = bhEne20_0x1f74a0; // 0x1f74d0 - g_ps2RecompiledFunctionTable[253235] = bhEne20_0x1f74a0; // 0x1f74d4 - g_ps2RecompiledFunctionTable[253236] = bhEne20_0x1f74a0; // 0x1f74d8 - g_ps2RecompiledFunctionTable[253237] = bhEne20_0x1f74a0; // 0x1f74dc - g_ps2RecompiledFunctionTable[253238] = bhEne20_0x1f74a0; // 0x1f74e0 - g_ps2RecompiledFunctionTable[253239] = bhEne20_0x1f74a0; // 0x1f74e4 - g_ps2RecompiledFunctionTable[253240] = bhEne20_0x1f74a0; // 0x1f74e8 - g_ps2RecompiledFunctionTable[253241] = bhEne20_0x1f74a0; // 0x1f74ec - g_ps2RecompiledFunctionTable[253242] = bhEne20_0x1f74a0; // 0x1f74f0 - g_ps2RecompiledFunctionTable[253243] = bhEne20_0x1f74a0; // 0x1f74f4 - g_ps2RecompiledFunctionTable[253244] = bhEne20_0x1f74a0; // 0x1f74f8 - g_ps2RecompiledFunctionTable[253246] = bhEne20_Init_0x1f7500; // 0x1f7500 - g_ps2RecompiledFunctionTable[253255] = bhEne20_Init_0x1f7500; // 0x1f7524 - g_ps2RecompiledFunctionTable[253284] = bhEne20_Init_0x1f7500; // 0x1f7598 - g_ps2RecompiledFunctionTable[253289] = bhEne20_Init_0x1f7500; // 0x1f75ac - g_ps2RecompiledFunctionTable[253314] = bhEne20_Move_0x1f7610; // 0x1f7610 - g_ps2RecompiledFunctionTable[253315] = bhEne20_Move_0x1f7610; // 0x1f7614 - g_ps2RecompiledFunctionTable[253316] = bhEne20_Move_0x1f7610; // 0x1f7618 - g_ps2RecompiledFunctionTable[253317] = bhEne20_Move_0x1f7610; // 0x1f761c - g_ps2RecompiledFunctionTable[253318] = bhEne20_Move_0x1f7610; // 0x1f7620 - g_ps2RecompiledFunctionTable[253319] = bhEne20_Move_0x1f7610; // 0x1f7624 - g_ps2RecompiledFunctionTable[253320] = bhEne20_Move_0x1f7610; // 0x1f7628 - g_ps2RecompiledFunctionTable[253321] = bhEne20_Move_0x1f7610; // 0x1f762c - g_ps2RecompiledFunctionTable[253322] = bhEne20_Move_0x1f7610; // 0x1f7630 - g_ps2RecompiledFunctionTable[253323] = bhEne20_Move_0x1f7610; // 0x1f7634 - g_ps2RecompiledFunctionTable[253324] = bhEne20_Move_0x1f7610; // 0x1f7638 - g_ps2RecompiledFunctionTable[253325] = bhEne20_Move_0x1f7610; // 0x1f763c - g_ps2RecompiledFunctionTable[253326] = bhEne20_Move_0x1f7610; // 0x1f7640 - g_ps2RecompiledFunctionTable[253327] = bhEne20_Move_0x1f7610; // 0x1f7644 - g_ps2RecompiledFunctionTable[253328] = bhEne20_Move_0x1f7610; // 0x1f7648 - g_ps2RecompiledFunctionTable[253329] = bhEne20_Move_0x1f7610; // 0x1f764c - g_ps2RecompiledFunctionTable[253330] = bhEne20_Move_0x1f7610; // 0x1f7650 - g_ps2RecompiledFunctionTable[253334] = bhEne20_MV00_0x1f7660; // 0x1f7660 - g_ps2RecompiledFunctionTable[253357] = bhEne20_MV00_0x1f7660; // 0x1f76bc - g_ps2RecompiledFunctionTable[253375] = bhEne20_MV00_0x1f7660; // 0x1f7704 - g_ps2RecompiledFunctionTable[253398] = bhEne20_MV01_0x1f7760; // 0x1f7760 - g_ps2RecompiledFunctionTable[253422] = bhEne20_MV01_0x1f7760; // 0x1f77c0 - g_ps2RecompiledFunctionTable[253436] = bhEne20_MV01_0x1f7760; // 0x1f77f8 - g_ps2RecompiledFunctionTable[253444] = bhEne20_MV01_0x1f7760; // 0x1f7818 - g_ps2RecompiledFunctionTable[253474] = bhEne20_MV02_0x1f7890; // 0x1f7890 - g_ps2RecompiledFunctionTable[253498] = bhEne20_MV02_0x1f7890; // 0x1f78f0 - g_ps2RecompiledFunctionTable[253512] = bhEne20_MV02_0x1f7890; // 0x1f7928 - g_ps2RecompiledFunctionTable[253526] = bhEne20_MV03_0x1f7960; // 0x1f7960 - g_ps2RecompiledFunctionTable[253550] = bhEne20_MV03_0x1f7960; // 0x1f79c0 - g_ps2RecompiledFunctionTable[253564] = bhEne20_MV03_0x1f7960; // 0x1f79f8 - g_ps2RecompiledFunctionTable[253578] = bhEne20_MV04_0x1f7a30; // 0x1f7a30 - g_ps2RecompiledFunctionTable[253615] = bhEne20_MV04_0x1f7a30; // 0x1f7ac4 - g_ps2RecompiledFunctionTable[253630] = bhEne20_MV05_0x1f7b00; // 0x1f7b00 - g_ps2RecompiledFunctionTable[253667] = bhEne20_MV05_0x1f7b00; // 0x1f7b94 - g_ps2RecompiledFunctionTable[253682] = bhEne20_MV06_0x1f7bd0; // 0x1f7bd0 - g_ps2RecompiledFunctionTable[253750] = bhEne20_MV07_0x1f7ce0; // 0x1f7ce0 - g_ps2RecompiledFunctionTable[253818] = bhEne20_Nage_0x1f7df0; // 0x1f7df0 - g_ps2RecompiledFunctionTable[253822] = bhEne20_Damage_0x1f7e00; // 0x1f7e00 - g_ps2RecompiledFunctionTable[253826] = bhEne20_Die_0x1f7e10; // 0x1f7e10 - g_ps2RecompiledFunctionTable[253830] = bhEne21_0x1f7e20; // 0x1f7e20 - g_ps2RecompiledFunctionTable[253831] = bhEne21_0x1f7e20; // 0x1f7e24 - g_ps2RecompiledFunctionTable[253832] = bhEne21_0x1f7e20; // 0x1f7e28 - g_ps2RecompiledFunctionTable[253833] = bhEne21_0x1f7e20; // 0x1f7e2c - g_ps2RecompiledFunctionTable[253834] = bhEne21_0x1f7e20; // 0x1f7e30 - g_ps2RecompiledFunctionTable[253835] = bhEne21_0x1f7e20; // 0x1f7e34 - g_ps2RecompiledFunctionTable[253836] = bhEne21_0x1f7e20; // 0x1f7e38 - g_ps2RecompiledFunctionTable[253837] = bhEne21_0x1f7e20; // 0x1f7e3c - g_ps2RecompiledFunctionTable[253838] = bhEne21_0x1f7e20; // 0x1f7e40 - g_ps2RecompiledFunctionTable[253839] = bhEne21_0x1f7e20; // 0x1f7e44 - g_ps2RecompiledFunctionTable[253840] = bhEne21_0x1f7e20; // 0x1f7e48 - g_ps2RecompiledFunctionTable[253841] = bhEne21_0x1f7e20; // 0x1f7e4c - g_ps2RecompiledFunctionTable[253842] = bhEne21_0x1f7e20; // 0x1f7e50 - g_ps2RecompiledFunctionTable[253843] = bhEne21_0x1f7e20; // 0x1f7e54 - g_ps2RecompiledFunctionTable[253844] = bhEne21_0x1f7e20; // 0x1f7e58 - g_ps2RecompiledFunctionTable[253845] = bhEne21_0x1f7e20; // 0x1f7e5c - g_ps2RecompiledFunctionTable[253846] = bhEne21_0x1f7e20; // 0x1f7e60 - g_ps2RecompiledFunctionTable[253847] = bhEne21_0x1f7e20; // 0x1f7e64 - g_ps2RecompiledFunctionTable[253848] = bhEne21_0x1f7e20; // 0x1f7e68 - g_ps2RecompiledFunctionTable[253849] = bhEne21_0x1f7e20; // 0x1f7e6c - g_ps2RecompiledFunctionTable[253850] = bhEne21_0x1f7e20; // 0x1f7e70 - g_ps2RecompiledFunctionTable[253851] = bhEne21_0x1f7e20; // 0x1f7e74 - g_ps2RecompiledFunctionTable[253852] = bhEne21_0x1f7e20; // 0x1f7e78 - g_ps2RecompiledFunctionTable[253853] = bhEne21_0x1f7e20; // 0x1f7e7c - g_ps2RecompiledFunctionTable[253854] = bhEne21_0x1f7e20; // 0x1f7e80 - g_ps2RecompiledFunctionTable[253855] = bhEne21_0x1f7e20; // 0x1f7e84 - g_ps2RecompiledFunctionTable[253856] = bhEne21_0x1f7e20; // 0x1f7e88 - g_ps2RecompiledFunctionTable[253857] = bhEne21_0x1f7e20; // 0x1f7e8c - g_ps2RecompiledFunctionTable[253858] = bhEne21_0x1f7e20; // 0x1f7e90 - g_ps2RecompiledFunctionTable[253859] = bhEne21_0x1f7e20; // 0x1f7e94 - g_ps2RecompiledFunctionTable[253860] = bhEne21_0x1f7e20; // 0x1f7e98 - g_ps2RecompiledFunctionTable[253861] = bhEne21_0x1f7e20; // 0x1f7e9c - g_ps2RecompiledFunctionTable[253862] = bhEne21_0x1f7e20; // 0x1f7ea0 - g_ps2RecompiledFunctionTable[253863] = bhEne21_0x1f7e20; // 0x1f7ea4 - g_ps2RecompiledFunctionTable[253864] = bhEne21_0x1f7e20; // 0x1f7ea8 - g_ps2RecompiledFunctionTable[253865] = bhEne21_0x1f7e20; // 0x1f7eac - g_ps2RecompiledFunctionTable[253866] = bhEne21_0x1f7e20; // 0x1f7eb0 - g_ps2RecompiledFunctionTable[253867] = bhEne21_0x1f7e20; // 0x1f7eb4 - g_ps2RecompiledFunctionTable[253868] = bhEne21_0x1f7e20; // 0x1f7eb8 - g_ps2RecompiledFunctionTable[253869] = bhEne21_0x1f7e20; // 0x1f7ebc - g_ps2RecompiledFunctionTable[253870] = bhEne21_0x1f7e20; // 0x1f7ec0 - g_ps2RecompiledFunctionTable[253871] = bhEne21_0x1f7e20; // 0x1f7ec4 - g_ps2RecompiledFunctionTable[253872] = bhEne21_0x1f7e20; // 0x1f7ec8 - g_ps2RecompiledFunctionTable[253873] = bhEne21_0x1f7e20; // 0x1f7ecc - g_ps2RecompiledFunctionTable[253874] = bhEne21_0x1f7e20; // 0x1f7ed0 - g_ps2RecompiledFunctionTable[253875] = bhEne21_0x1f7e20; // 0x1f7ed4 - g_ps2RecompiledFunctionTable[253876] = bhEne21_0x1f7e20; // 0x1f7ed8 - g_ps2RecompiledFunctionTable[253877] = bhEne21_0x1f7e20; // 0x1f7edc - g_ps2RecompiledFunctionTable[253878] = bhEne21_0x1f7e20; // 0x1f7ee0 - g_ps2RecompiledFunctionTable[253879] = bhEne21_0x1f7e20; // 0x1f7ee4 - g_ps2RecompiledFunctionTable[253880] = bhEne21_0x1f7e20; // 0x1f7ee8 - g_ps2RecompiledFunctionTable[253881] = bhEne21_0x1f7e20; // 0x1f7eec - g_ps2RecompiledFunctionTable[253882] = bhEne21_0x1f7e20; // 0x1f7ef0 - g_ps2RecompiledFunctionTable[253883] = bhEne21_0x1f7e20; // 0x1f7ef4 - g_ps2RecompiledFunctionTable[253884] = bhEne21_0x1f7e20; // 0x1f7ef8 - g_ps2RecompiledFunctionTable[253885] = bhEne21_0x1f7e20; // 0x1f7efc - g_ps2RecompiledFunctionTable[253886] = bhEne21_0x1f7e20; // 0x1f7f00 - g_ps2RecompiledFunctionTable[253887] = bhEne21_0x1f7e20; // 0x1f7f04 - g_ps2RecompiledFunctionTable[253888] = bhEne21_0x1f7e20; // 0x1f7f08 - g_ps2RecompiledFunctionTable[253889] = bhEne21_0x1f7e20; // 0x1f7f0c - g_ps2RecompiledFunctionTable[253890] = bhEne21_0x1f7e20; // 0x1f7f10 - g_ps2RecompiledFunctionTable[253891] = bhEne21_0x1f7e20; // 0x1f7f14 - g_ps2RecompiledFunctionTable[253892] = bhEne21_0x1f7e20; // 0x1f7f18 - g_ps2RecompiledFunctionTable[253893] = bhEne21_0x1f7e20; // 0x1f7f1c - g_ps2RecompiledFunctionTable[253894] = bhEne21_0x1f7e20; // 0x1f7f20 - g_ps2RecompiledFunctionTable[253895] = bhEne21_0x1f7e20; // 0x1f7f24 - g_ps2RecompiledFunctionTable[253896] = bhEne21_0x1f7e20; // 0x1f7f28 - g_ps2RecompiledFunctionTable[253897] = bhEne21_0x1f7e20; // 0x1f7f2c - g_ps2RecompiledFunctionTable[253898] = bhEne21_0x1f7e20; // 0x1f7f30 - g_ps2RecompiledFunctionTable[253899] = bhEne21_0x1f7e20; // 0x1f7f34 - g_ps2RecompiledFunctionTable[253900] = bhEne21_0x1f7e20; // 0x1f7f38 - g_ps2RecompiledFunctionTable[253901] = bhEne21_0x1f7e20; // 0x1f7f3c - g_ps2RecompiledFunctionTable[253902] = bhEne21_0x1f7e20; // 0x1f7f40 - g_ps2RecompiledFunctionTable[253903] = bhEne21_0x1f7e20; // 0x1f7f44 - g_ps2RecompiledFunctionTable[253904] = bhEne21_0x1f7e20; // 0x1f7f48 - g_ps2RecompiledFunctionTable[253905] = bhEne21_0x1f7e20; // 0x1f7f4c - g_ps2RecompiledFunctionTable[253906] = bhEne21_0x1f7e20; // 0x1f7f50 - g_ps2RecompiledFunctionTable[253907] = bhEne21_0x1f7e20; // 0x1f7f54 - g_ps2RecompiledFunctionTable[253908] = bhEne21_0x1f7e20; // 0x1f7f58 - g_ps2RecompiledFunctionTable[253909] = bhEne21_0x1f7e20; // 0x1f7f5c - g_ps2RecompiledFunctionTable[253910] = bhEne21_0x1f7e20; // 0x1f7f60 - g_ps2RecompiledFunctionTable[253911] = bhEne21_0x1f7e20; // 0x1f7f64 - g_ps2RecompiledFunctionTable[253912] = bhEne21_0x1f7e20; // 0x1f7f68 - g_ps2RecompiledFunctionTable[253913] = bhEne21_0x1f7e20; // 0x1f7f6c - g_ps2RecompiledFunctionTable[253914] = bhEne21_0x1f7e20; // 0x1f7f70 - g_ps2RecompiledFunctionTable[253915] = bhEne21_0x1f7e20; // 0x1f7f74 - g_ps2RecompiledFunctionTable[253916] = bhEne21_0x1f7e20; // 0x1f7f78 - g_ps2RecompiledFunctionTable[253917] = bhEne21_0x1f7e20; // 0x1f7f7c - g_ps2RecompiledFunctionTable[253918] = bhEne21_0x1f7e20; // 0x1f7f80 - g_ps2RecompiledFunctionTable[253919] = bhEne21_0x1f7e20; // 0x1f7f84 - g_ps2RecompiledFunctionTable[253920] = bhEne21_0x1f7e20; // 0x1f7f88 - g_ps2RecompiledFunctionTable[253921] = bhEne21_0x1f7e20; // 0x1f7f8c - g_ps2RecompiledFunctionTable[253922] = bhEne21_0x1f7e20; // 0x1f7f90 - g_ps2RecompiledFunctionTable[253923] = bhEne21_0x1f7e20; // 0x1f7f94 - g_ps2RecompiledFunctionTable[253924] = bhEne21_0x1f7e20; // 0x1f7f98 - g_ps2RecompiledFunctionTable[253925] = bhEne21_0x1f7e20; // 0x1f7f9c - g_ps2RecompiledFunctionTable[253926] = bhEne21_0x1f7e20; // 0x1f7fa0 - g_ps2RecompiledFunctionTable[253927] = bhEne21_0x1f7e20; // 0x1f7fa4 - g_ps2RecompiledFunctionTable[253928] = bhEne21_0x1f7e20; // 0x1f7fa8 - g_ps2RecompiledFunctionTable[253929] = bhEne21_0x1f7e20; // 0x1f7fac - g_ps2RecompiledFunctionTable[253930] = bhEne21_0x1f7e20; // 0x1f7fb0 - g_ps2RecompiledFunctionTable[253931] = bhEne21_0x1f7e20; // 0x1f7fb4 - g_ps2RecompiledFunctionTable[253932] = bhEne21_0x1f7e20; // 0x1f7fb8 - g_ps2RecompiledFunctionTable[253933] = bhEne21_0x1f7e20; // 0x1f7fbc - g_ps2RecompiledFunctionTable[253934] = bhEne21_0x1f7e20; // 0x1f7fc0 - g_ps2RecompiledFunctionTable[253935] = bhEne21_0x1f7e20; // 0x1f7fc4 - g_ps2RecompiledFunctionTable[253936] = bhEne21_0x1f7e20; // 0x1f7fc8 - g_ps2RecompiledFunctionTable[253937] = bhEne21_0x1f7e20; // 0x1f7fcc - g_ps2RecompiledFunctionTable[253938] = bhEne21_0x1f7e20; // 0x1f7fd0 - g_ps2RecompiledFunctionTable[253939] = bhEne21_0x1f7e20; // 0x1f7fd4 - g_ps2RecompiledFunctionTable[253940] = bhEne21_0x1f7e20; // 0x1f7fd8 - g_ps2RecompiledFunctionTable[253941] = bhEne21_0x1f7e20; // 0x1f7fdc - g_ps2RecompiledFunctionTable[253942] = bhEne21_0x1f7e20; // 0x1f7fe0 - g_ps2RecompiledFunctionTable[253943] = bhEne21_0x1f7e20; // 0x1f7fe4 - g_ps2RecompiledFunctionTable[253944] = bhEne21_0x1f7e20; // 0x1f7fe8 - g_ps2RecompiledFunctionTable[253945] = bhEne21_0x1f7e20; // 0x1f7fec - g_ps2RecompiledFunctionTable[253946] = bhEne21_0x1f7e20; // 0x1f7ff0 - g_ps2RecompiledFunctionTable[253947] = bhEne21_0x1f7e20; // 0x1f7ff4 - g_ps2RecompiledFunctionTable[253948] = bhEne21_0x1f7e20; // 0x1f7ff8 - g_ps2RecompiledFunctionTable[253949] = bhEne21_0x1f7e20; // 0x1f7ffc - g_ps2RecompiledFunctionTable[253950] = bhEne21_Init_0x1f8000; // 0x1f8000 - g_ps2RecompiledFunctionTable[253959] = bhEne21_Init_0x1f8000; // 0x1f8024 - g_ps2RecompiledFunctionTable[254083] = bhEne21_Init_0x1f8000; // 0x1f8214 - g_ps2RecompiledFunctionTable[254122] = bhEne21_Init_0x1f8000; // 0x1f82b0 - g_ps2RecompiledFunctionTable[254130] = bhEne21_SearchPlayer_0x1f82d0; // 0x1f82d0 - g_ps2RecompiledFunctionTable[254147] = bhEne21_SearchPlayer_0x1f82d0; // 0x1f8314 - g_ps2RecompiledFunctionTable[254167] = bhEne21_SearchPlayer_0x1f82d0; // 0x1f8364 - g_ps2RecompiledFunctionTable[254172] = bhEne21_SearchPlayer_0x1f82d0; // 0x1f8378 - g_ps2RecompiledFunctionTable[254181] = bhEne21_SearchPlayer_0x1f82d0; // 0x1f839c - g_ps2RecompiledFunctionTable[254198] = bhEne21_Brain_0x1f83e0; // 0x1f83e0 - g_ps2RecompiledFunctionTable[254202] = bhEne21_BR00_0x1f83f0; // 0x1f83f0 - g_ps2RecompiledFunctionTable[254226] = bhEne21_BR00_0x1f83f0; // 0x1f8450 - g_ps2RecompiledFunctionTable[254243] = bhEne21_BR00_0x1f83f0; // 0x1f8494 - g_ps2RecompiledFunctionTable[254253] = bhEne21_BR00_0x1f83f0; // 0x1f84bc - g_ps2RecompiledFunctionTable[254278] = bhEne21_Move_0x1f8520; // 0x1f8520 - g_ps2RecompiledFunctionTable[254279] = bhEne21_Move_0x1f8520; // 0x1f8524 - g_ps2RecompiledFunctionTable[254280] = bhEne21_Move_0x1f8520; // 0x1f8528 - g_ps2RecompiledFunctionTable[254281] = bhEne21_Move_0x1f8520; // 0x1f852c - g_ps2RecompiledFunctionTable[254282] = bhEne21_Move_0x1f8520; // 0x1f8530 - g_ps2RecompiledFunctionTable[254283] = bhEne21_Move_0x1f8520; // 0x1f8534 - g_ps2RecompiledFunctionTable[254284] = bhEne21_Move_0x1f8520; // 0x1f8538 - g_ps2RecompiledFunctionTable[254285] = bhEne21_Move_0x1f8520; // 0x1f853c - g_ps2RecompiledFunctionTable[254286] = bhEne21_Move_0x1f8520; // 0x1f8540 - g_ps2RecompiledFunctionTable[254287] = bhEne21_Move_0x1f8520; // 0x1f8544 - g_ps2RecompiledFunctionTable[254288] = bhEne21_Move_0x1f8520; // 0x1f8548 - g_ps2RecompiledFunctionTable[254289] = bhEne21_Move_0x1f8520; // 0x1f854c - g_ps2RecompiledFunctionTable[254290] = bhEne21_Move_0x1f8520; // 0x1f8550 - g_ps2RecompiledFunctionTable[254291] = bhEne21_Move_0x1f8520; // 0x1f8554 - g_ps2RecompiledFunctionTable[254292] = bhEne21_Move_0x1f8520; // 0x1f8558 - g_ps2RecompiledFunctionTable[254293] = bhEne21_Move_0x1f8520; // 0x1f855c - g_ps2RecompiledFunctionTable[254294] = bhEne21_Move_0x1f8520; // 0x1f8560 - g_ps2RecompiledFunctionTable[254295] = bhEne21_Move_0x1f8520; // 0x1f8564 - g_ps2RecompiledFunctionTable[254296] = bhEne21_Move_0x1f8520; // 0x1f8568 - g_ps2RecompiledFunctionTable[254297] = bhEne21_Move_0x1f8520; // 0x1f856c - g_ps2RecompiledFunctionTable[254298] = bhEne21_Move_0x1f8520; // 0x1f8570 - g_ps2RecompiledFunctionTable[254299] = bhEne21_Move_0x1f8520; // 0x1f8574 - g_ps2RecompiledFunctionTable[254300] = bhEne21_Move_0x1f8520; // 0x1f8578 - g_ps2RecompiledFunctionTable[254301] = bhEne21_Move_0x1f8520; // 0x1f857c - g_ps2RecompiledFunctionTable[254302] = bhEne21_Move_0x1f8520; // 0x1f8580 - g_ps2RecompiledFunctionTable[254303] = bhEne21_Move_0x1f8520; // 0x1f8584 - g_ps2RecompiledFunctionTable[254304] = bhEne21_Move_0x1f8520; // 0x1f8588 - g_ps2RecompiledFunctionTable[254305] = bhEne21_Move_0x1f8520; // 0x1f858c - g_ps2RecompiledFunctionTable[254306] = bhEne21_Move_0x1f8520; // 0x1f8590 - g_ps2RecompiledFunctionTable[254307] = bhEne21_Move_0x1f8520; // 0x1f8594 - g_ps2RecompiledFunctionTable[254308] = bhEne21_Move_0x1f8520; // 0x1f8598 - g_ps2RecompiledFunctionTable[254309] = bhEne21_Move_0x1f8520; // 0x1f859c - g_ps2RecompiledFunctionTable[254310] = bhEne21_Move_0x1f8520; // 0x1f85a0 - g_ps2RecompiledFunctionTable[254311] = bhEne21_Move_0x1f8520; // 0x1f85a4 - g_ps2RecompiledFunctionTable[254314] = bhEne21_MV00_0x1f85b0; // 0x1f85b0 - g_ps2RecompiledFunctionTable[254332] = bhEne21_MV00_0x1f85b0; // 0x1f85f8 - g_ps2RecompiledFunctionTable[254344] = bhEne21_MV00_0x1f85b0; // 0x1f8628 - g_ps2RecompiledFunctionTable[254360] = bhEne21_MV00_0x1f85b0; // 0x1f8668 - g_ps2RecompiledFunctionTable[254370] = bhEne21_MV00_0x1f85b0; // 0x1f8690 - g_ps2RecompiledFunctionTable[254375] = bhEne21_MV00_0x1f85b0; // 0x1f86a4 - g_ps2RecompiledFunctionTable[254390] = bhEne21_MV01_0x1f86e0; // 0x1f86e0 - g_ps2RecompiledFunctionTable[254408] = bhEne21_MV01_0x1f86e0; // 0x1f8728 - g_ps2RecompiledFunctionTable[254420] = bhEne21_MV01_0x1f86e0; // 0x1f8758 - g_ps2RecompiledFunctionTable[254447] = bhEne21_MV01_0x1f86e0; // 0x1f87c4 - g_ps2RecompiledFunctionTable[254456] = bhEne21_MV01_0x1f86e0; // 0x1f87e8 - g_ps2RecompiledFunctionTable[254458] = bhEne21_MV01_0x1f86e0; // 0x1f87f0 - g_ps2RecompiledFunctionTable[254467] = bhEne21_MV01_0x1f86e0; // 0x1f8814 - g_ps2RecompiledFunctionTable[254477] = bhEne21_MV01_0x1f86e0; // 0x1f883c - g_ps2RecompiledFunctionTable[254504] = bhEne21_MV01_0x1f86e0; // 0x1f88a8 - g_ps2RecompiledFunctionTable[254512] = bhEne21_MV01_0x1f86e0; // 0x1f88c8 - g_ps2RecompiledFunctionTable[254533] = bhEne21_MV01_0x1f86e0; // 0x1f891c - g_ps2RecompiledFunctionTable[254562] = bhEne21_MV02_0x1f8990; // 0x1f8990 - g_ps2RecompiledFunctionTable[254580] = bhEne21_MV02_0x1f8990; // 0x1f89d8 - g_ps2RecompiledFunctionTable[254592] = bhEne21_MV02_0x1f8990; // 0x1f8a08 - g_ps2RecompiledFunctionTable[254622] = bhEne21_MV02_0x1f8990; // 0x1f8a80 - g_ps2RecompiledFunctionTable[254631] = bhEne21_MV02_0x1f8990; // 0x1f8aa4 - g_ps2RecompiledFunctionTable[254633] = bhEne21_MV02_0x1f8990; // 0x1f8aac - g_ps2RecompiledFunctionTable[254642] = bhEne21_MV02_0x1f8990; // 0x1f8ad0 - g_ps2RecompiledFunctionTable[254658] = bhEne21_MV03_0x1f8b10; // 0x1f8b10 - g_ps2RecompiledFunctionTable[254676] = bhEne21_MV03_0x1f8b10; // 0x1f8b58 - g_ps2RecompiledFunctionTable[254688] = bhEne21_MV03_0x1f8b10; // 0x1f8b88 - g_ps2RecompiledFunctionTable[254718] = bhEne21_MV03_0x1f8b10; // 0x1f8c00 - g_ps2RecompiledFunctionTable[254727] = bhEne21_MV03_0x1f8b10; // 0x1f8c24 - g_ps2RecompiledFunctionTable[254729] = bhEne21_MV03_0x1f8b10; // 0x1f8c2c - g_ps2RecompiledFunctionTable[254738] = bhEne21_MV03_0x1f8b10; // 0x1f8c50 - g_ps2RecompiledFunctionTable[254754] = bhEne21_MV04_0x1f8c90; // 0x1f8c90 - g_ps2RecompiledFunctionTable[254772] = bhEne21_MV04_0x1f8c90; // 0x1f8cd8 - g_ps2RecompiledFunctionTable[254784] = bhEne21_MV04_0x1f8c90; // 0x1f8d08 - g_ps2RecompiledFunctionTable[254803] = bhEne21_MV04_0x1f8c90; // 0x1f8d54 - g_ps2RecompiledFunctionTable[254812] = bhEne21_MV04_0x1f8c90; // 0x1f8d78 - g_ps2RecompiledFunctionTable[254826] = bhEne21_MV05_0x1f8db0; // 0x1f8db0 - g_ps2RecompiledFunctionTable[254844] = bhEne21_MV05_0x1f8db0; // 0x1f8df8 - g_ps2RecompiledFunctionTable[254856] = bhEne21_MV05_0x1f8db0; // 0x1f8e28 - g_ps2RecompiledFunctionTable[254875] = bhEne21_MV05_0x1f8db0; // 0x1f8e74 - g_ps2RecompiledFunctionTable[254884] = bhEne21_MV05_0x1f8db0; // 0x1f8e98 - g_ps2RecompiledFunctionTable[254898] = bhEne21_MV06_0x1f8ed0; // 0x1f8ed0 - g_ps2RecompiledFunctionTable[254916] = bhEne21_MV06_0x1f8ed0; // 0x1f8f18 - g_ps2RecompiledFunctionTable[254922] = bhEne21_MV06_0x1f8ed0; // 0x1f8f30 - g_ps2RecompiledFunctionTable[254945] = bhEne21_MV06_0x1f8ed0; // 0x1f8f8c - g_ps2RecompiledFunctionTable[255029] = bhEne21_MV06_0x1f8ed0; // 0x1f90dc - g_ps2RecompiledFunctionTable[255081] = bhEne21_MV06_0x1f8ed0; // 0x1f91ac - g_ps2RecompiledFunctionTable[255094] = bhEne21_MV07_0x1f91e0; // 0x1f91e0 - g_ps2RecompiledFunctionTable[255098] = bhEne21_MV08_0x1f91f0; // 0x1f91f0 - g_ps2RecompiledFunctionTable[255106] = bhEne21_Nage_0x1f9210; // 0x1f9210 - g_ps2RecompiledFunctionTable[255107] = bhEne21_Nage_0x1f9210; // 0x1f9214 - g_ps2RecompiledFunctionTable[255108] = bhEne21_Nage_0x1f9210; // 0x1f9218 - g_ps2RecompiledFunctionTable[255109] = bhEne21_Nage_0x1f9210; // 0x1f921c - g_ps2RecompiledFunctionTable[255110] = bhEne21_Nage_0x1f9210; // 0x1f9220 - g_ps2RecompiledFunctionTable[255111] = bhEne21_Nage_0x1f9210; // 0x1f9224 - g_ps2RecompiledFunctionTable[255112] = bhEne21_Nage_0x1f9210; // 0x1f9228 - g_ps2RecompiledFunctionTable[255113] = bhEne21_Nage_0x1f9210; // 0x1f922c - g_ps2RecompiledFunctionTable[255114] = bhEne21_NG00_0x1f9230; // 0x1f9230 - g_ps2RecompiledFunctionTable[255164] = bhEne21_NG00_0x1f9230; // 0x1f92f8 - g_ps2RecompiledFunctionTable[255203] = bhEne21_NG00_0x1f9230; // 0x1f9394 - g_ps2RecompiledFunctionTable[255220] = bhEne21_NG00_0x1f9230; // 0x1f93d8 - g_ps2RecompiledFunctionTable[255229] = bhEne21_NG00_0x1f9230; // 0x1f93fc - g_ps2RecompiledFunctionTable[255278] = bhEne21_NG00_0x1f9230; // 0x1f94c0 - g_ps2RecompiledFunctionTable[255281] = bhEne21_NG00_0x1f9230; // 0x1f94cc - g_ps2RecompiledFunctionTable[255301] = bhEne21_NG00_0x1f9230; // 0x1f951c - g_ps2RecompiledFunctionTable[255346] = bhEne21_Damage_0x1f95d0; // 0x1f95d0 - g_ps2RecompiledFunctionTable[255355] = bhEne21_Damage_0x1f95d0; // 0x1f95f4 - g_ps2RecompiledFunctionTable[255379] = bhEne21_Damage_0x1f95d0; // 0x1f9654 - g_ps2RecompiledFunctionTable[255383] = bhEne21_Damage_0x1f95d0; // 0x1f9664 - g_ps2RecompiledFunctionTable[255406] = bhEne21_Die_0x1f96c0; // 0x1f96c0 - g_ps2RecompiledFunctionTable[255407] = bhEne21_Die_0x1f96c0; // 0x1f96c4 - g_ps2RecompiledFunctionTable[255408] = bhEne21_Die_0x1f96c0; // 0x1f96c8 - g_ps2RecompiledFunctionTable[255409] = bhEne21_Die_0x1f96c0; // 0x1f96cc - g_ps2RecompiledFunctionTable[255410] = bhEne21_Die_0x1f96c0; // 0x1f96d0 - g_ps2RecompiledFunctionTable[255411] = bhEne21_Die_0x1f96c0; // 0x1f96d4 - g_ps2RecompiledFunctionTable[255412] = bhEne21_Die_0x1f96c0; // 0x1f96d8 - g_ps2RecompiledFunctionTable[255413] = bhEne21_Die_0x1f96c0; // 0x1f96dc - g_ps2RecompiledFunctionTable[255414] = bhEne21_DD00_0x1f96e0; // 0x1f96e0 - g_ps2RecompiledFunctionTable[255466] = bhEne21_DD00_0x1f96e0; // 0x1f97b0 - g_ps2RecompiledFunctionTable[255502] = bhEne21_DD00_0x1f96e0; // 0x1f9840 - g_ps2RecompiledFunctionTable[255518] = bhEne21_PlayerControl_0x1f9880; // 0x1f9880 - g_ps2RecompiledFunctionTable[255734] = bhEne21_AllWayWallCheck_0x1f9be0; // 0x1f9be0 - g_ps2RecompiledFunctionTable[255749] = bhEne21_AllWayWallCheck_0x1f9be0; // 0x1f9c1c - g_ps2RecompiledFunctionTable[255751] = bhEne21_AllWayWallCheck_0x1f9be0; // 0x1f9c24 - g_ps2RecompiledFunctionTable[255757] = bhEne21_AllWayWallCheck_0x1f9be0; // 0x1f9c3c - g_ps2RecompiledFunctionTable[255768] = bhEne21_AllWayWallCheck_0x1f9be0; // 0x1f9c68 - g_ps2RecompiledFunctionTable[255790] = bhEne21_AllWayWallCheck_0x1f9be0; // 0x1f9cc0 - g_ps2RecompiledFunctionTable[255792] = bhEne21_AllWayWallCheck_0x1f9be0; // 0x1f9cc8 - g_ps2RecompiledFunctionTable[255798] = bhEne21_AllWayWallCheck_0x1f9be0; // 0x1f9ce0 - g_ps2RecompiledFunctionTable[255809] = bhEne21_AllWayWallCheck_0x1f9be0; // 0x1f9d0c - g_ps2RecompiledFunctionTable[255830] = bhEne21_AllWayWallCheck_0x1f9be0; // 0x1f9d60 - g_ps2RecompiledFunctionTable[255832] = bhEne21_AllWayWallCheck_0x1f9be0; // 0x1f9d68 - g_ps2RecompiledFunctionTable[255838] = bhEne21_AllWayWallCheck_0x1f9be0; // 0x1f9d80 - g_ps2RecompiledFunctionTable[255849] = bhEne21_AllWayWallCheck_0x1f9be0; // 0x1f9dac - g_ps2RecompiledFunctionTable[255871] = bhEne21_AllWayWallCheck_0x1f9be0; // 0x1f9e04 - g_ps2RecompiledFunctionTable[255873] = bhEne21_AllWayWallCheck_0x1f9be0; // 0x1f9e0c - g_ps2RecompiledFunctionTable[255879] = bhEne21_AllWayWallCheck_0x1f9be0; // 0x1f9e24 - g_ps2RecompiledFunctionTable[255890] = bhEne21_AllWayWallCheck_0x1f9be0; // 0x1f9e50 - g_ps2RecompiledFunctionTable[255914] = bhEne21_SetSparkEff_0x1f9eb0; // 0x1f9eb0 - g_ps2RecompiledFunctionTable[255934] = bhEne21_SetSparkEff_0x1f9eb0; // 0x1f9f00 - g_ps2RecompiledFunctionTable[256024] = bhEne21_SetSparkEff_0x1f9eb0; // 0x1fa068 - g_ps2RecompiledFunctionTable[256041] = bhEne21_SetSparkEff_0x1f9eb0; // 0x1fa0ac - g_ps2RecompiledFunctionTable[256055] = bhEne21_SetSparkEff_0x1f9eb0; // 0x1fa0e4 - g_ps2RecompiledFunctionTable[256072] = bhEne21_SetSparkEff_0x1f9eb0; // 0x1fa128 - g_ps2RecompiledFunctionTable[256086] = bhEne21_SetSparkEff_0x1f9eb0; // 0x1fa160 - g_ps2RecompiledFunctionTable[256103] = bhEne21_SetSparkEff_0x1f9eb0; // 0x1fa1a4 - g_ps2RecompiledFunctionTable[256119] = bhEne21_SetSparkEff_0x1f9eb0; // 0x1fa1e4 - g_ps2RecompiledFunctionTable[256134] = bhEne21_SetSparkEff_0x1f9eb0; // 0x1fa220 - g_ps2RecompiledFunctionTable[256152] = bhEne21_SetSparkEff_0x1f9eb0; // 0x1fa268 - g_ps2RecompiledFunctionTable[256169] = bhEne21_SetSparkEff_0x1f9eb0; // 0x1fa2ac - g_ps2RecompiledFunctionTable[256187] = bhEne21_SetSparkEff_0x1f9eb0; // 0x1fa2f4 - g_ps2RecompiledFunctionTable[256249] = bhEne21_SetSparkEff_0x1f9eb0; // 0x1fa3ec - g_ps2RecompiledFunctionTable[256286] = bhEff_E21_Spark_0x1fa480; // 0x1fa480 - g_ps2RecompiledFunctionTable[256339] = bhEff_E21_Spark_0x1fa480; // 0x1fa554 - g_ps2RecompiledFunctionTable[256366] = bhEff_E21_Spark_0x1fa480; // 0x1fa5c0 - g_ps2RecompiledFunctionTable[256375] = bhEff_E21_Spark_0x1fa480; // 0x1fa5e4 - g_ps2RecompiledFunctionTable[256393] = bhEff_E21_Spark_0x1fa480; // 0x1fa62c - g_ps2RecompiledFunctionTable[256402] = bhEff_E21_Spark_0x1fa480; // 0x1fa650 - g_ps2RecompiledFunctionTable[256494] = bhEne21_SetMarkEff_0x1fa7c0; // 0x1fa7c0 - g_ps2RecompiledFunctionTable[256580] = bhEne21_SetMarkEff_0x1fa7c0; // 0x1fa918 - g_ps2RecompiledFunctionTable[256610] = bhEff_E21_Mark_0x1fa990; // 0x1fa990 - g_ps2RecompiledFunctionTable[256742] = bhEne22_DmmyBrain_0x1faba0; // 0x1faba0 - g_ps2RecompiledFunctionTable[256746] = bhEne22_0x1fabb0; // 0x1fabb0 - g_ps2RecompiledFunctionTable[256751] = bhEne22_0x1fabb0; // 0x1fabc4 - g_ps2RecompiledFunctionTable[256765] = bhEne22_0x1fabb0; // 0x1fabfc - g_ps2RecompiledFunctionTable[256770] = bhEne22_0x1fabb0; // 0x1fac10 - g_ps2RecompiledFunctionTable[256776] = bhEne22_0x1fabb0; // 0x1fac28 - g_ps2RecompiledFunctionTable[256790] = bhEne22_0x1fabb0; // 0x1fac60 - g_ps2RecompiledFunctionTable[256792] = bhEne22_0x1fabb0; // 0x1fac68 - g_ps2RecompiledFunctionTable[256859] = bhEne22_0x1fabb0; // 0x1fad74 - g_ps2RecompiledFunctionTable[256866] = bhEne22_MainLoop_0x1fad90; // 0x1fad90 - g_ps2RecompiledFunctionTable[256867] = bhEne22_MainLoop_0x1fad90; // 0x1fad94 - g_ps2RecompiledFunctionTable[256868] = bhEne22_MainLoop_0x1fad90; // 0x1fad98 - g_ps2RecompiledFunctionTable[256869] = bhEne22_MainLoop_0x1fad90; // 0x1fad9c - g_ps2RecompiledFunctionTable[256870] = bhEne22_MainLoop_0x1fad90; // 0x1fada0 - g_ps2RecompiledFunctionTable[256871] = bhEne22_MainLoop_0x1fad90; // 0x1fada4 - g_ps2RecompiledFunctionTable[256872] = bhEne22_MainLoop_0x1fad90; // 0x1fada8 - g_ps2RecompiledFunctionTable[256873] = bhEne22_MainLoop_0x1fad90; // 0x1fadac - g_ps2RecompiledFunctionTable[256874] = bhEne22_MainLoop_0x1fad90; // 0x1fadb0 - g_ps2RecompiledFunctionTable[256875] = bhEne22_MainLoop_0x1fad90; // 0x1fadb4 - g_ps2RecompiledFunctionTable[256876] = bhEne22_MainLoop_0x1fad90; // 0x1fadb8 - g_ps2RecompiledFunctionTable[256877] = bhEne22_MainLoop_0x1fad90; // 0x1fadbc - g_ps2RecompiledFunctionTable[256878] = bhEne22_MainLoop_0x1fad90; // 0x1fadc0 - g_ps2RecompiledFunctionTable[256879] = bhEne22_MainLoop_0x1fad90; // 0x1fadc4 - g_ps2RecompiledFunctionTable[256880] = bhEne22_MainLoop_0x1fad90; // 0x1fadc8 - g_ps2RecompiledFunctionTable[256881] = bhEne22_MainLoop_0x1fad90; // 0x1fadcc - g_ps2RecompiledFunctionTable[256882] = bhEne22_MainLoop_0x1fad90; // 0x1fadd0 - g_ps2RecompiledFunctionTable[256883] = bhEne22_MainLoop_0x1fad90; // 0x1fadd4 - g_ps2RecompiledFunctionTable[256884] = bhEne22_MainLoop_0x1fad90; // 0x1fadd8 - g_ps2RecompiledFunctionTable[256886] = bhEne22_DmgChk_0x1fade0; // 0x1fade0 - g_ps2RecompiledFunctionTable[256907] = bhEne22_DmgChk_0x1fade0; // 0x1fae34 - g_ps2RecompiledFunctionTable[256915] = bhEne22_DmgChk_0x1fade0; // 0x1fae54 - g_ps2RecompiledFunctionTable[256924] = bhEne22_DmgChk_0x1fade0; // 0x1fae78 - g_ps2RecompiledFunctionTable[256958] = bhEne22_DmgChk_0x1fade0; // 0x1faf00 - g_ps2RecompiledFunctionTable[256966] = bhEne22_ChgDmgMode_0x1faf20; // 0x1faf20 - g_ps2RecompiledFunctionTable[257058] = bhEne22_DamageAdd_0x1fb090; // 0x1fb090 - g_ps2RecompiledFunctionTable[257080] = bhEne22_DamageAdd_0x1fb090; // 0x1fb0e8 - g_ps2RecompiledFunctionTable[257101] = bhEne22_DamageAdd_0x1fb090; // 0x1fb13c - g_ps2RecompiledFunctionTable[257108] = bhEne22_DamageAdd_0x1fb090; // 0x1fb158 - g_ps2RecompiledFunctionTable[257140] = bhEne22_DamageAdd_0x1fb090; // 0x1fb1d8 - g_ps2RecompiledFunctionTable[257148] = bhEne22_DamageAdd_0x1fb090; // 0x1fb1f8 - g_ps2RecompiledFunctionTable[257164] = bhEne22_DamageAdd_0x1fb090; // 0x1fb238 - g_ps2RecompiledFunctionTable[257174] = bhEne22_CollCheck_0x1fb260; // 0x1fb260 - g_ps2RecompiledFunctionTable[257191] = bhEne22_CollCheck_0x1fb260; // 0x1fb2a4 - g_ps2RecompiledFunctionTable[257194] = bhEne22_CollCheck_0x1fb260; // 0x1fb2b0 - g_ps2RecompiledFunctionTable[257198] = bhEne22_CollCheckWall_0x1fb2c0; // 0x1fb2c0 - g_ps2RecompiledFunctionTable[257217] = bhEne22_CollCheckWall_0x1fb2c0; // 0x1fb30c - g_ps2RecompiledFunctionTable[257228] = bhEne22_CollCheckWall_0x1fb2c0; // 0x1fb338 - g_ps2RecompiledFunctionTable[257258] = bhEne22_CollCheckWall_0x1fb2c0; // 0x1fb3b0 - g_ps2RecompiledFunctionTable[257287] = bhEne22_CollCheckWall_0x1fb2c0; // 0x1fb424 - g_ps2RecompiledFunctionTable[257321] = bhEne22_CollCheckWall_0x1fb2c0; // 0x1fb4ac - g_ps2RecompiledFunctionTable[257354] = bhEne22_CollCheckWall_0x1fb2c0; // 0x1fb530 - g_ps2RecompiledFunctionTable[257387] = bhEne22_CollCheckWall_0x1fb2c0; // 0x1fb5b4 - g_ps2RecompiledFunctionTable[257420] = bhEne22_CollCheckWall_0x1fb2c0; // 0x1fb638 - g_ps2RecompiledFunctionTable[257453] = bhEne22_CollCheckWall_0x1fb2c0; // 0x1fb6bc - g_ps2RecompiledFunctionTable[257486] = bhEne22_CollCheckWall_0x1fb2c0; // 0x1fb740 - g_ps2RecompiledFunctionTable[257519] = bhEne22_CollCheckWall_0x1fb2c0; // 0x1fb7c4 - g_ps2RecompiledFunctionTable[257539] = bhEne22_CollCheckWall_0x1fb2c0; // 0x1fb814 - g_ps2RecompiledFunctionTable[257556] = bhEne22_CollCheckWall_0x1fb2c0; // 0x1fb858 - g_ps2RecompiledFunctionTable[257590] = bhEne22_CollCheckWall_0x1fb2c0; // 0x1fb8e0 - g_ps2RecompiledFunctionTable[257614] = bhEne22_Init_0x1fb940; // 0x1fb940 - g_ps2RecompiledFunctionTable[257615] = bhEne22_Init_0x1fb940; // 0x1fb944 - g_ps2RecompiledFunctionTable[257616] = bhEne22_Init_0x1fb940; // 0x1fb948 - g_ps2RecompiledFunctionTable[257617] = bhEne22_Init_0x1fb940; // 0x1fb94c - g_ps2RecompiledFunctionTable[257618] = bhEne22_Init_0x1fb940; // 0x1fb950 - g_ps2RecompiledFunctionTable[257619] = bhEne22_Init_0x1fb940; // 0x1fb954 - g_ps2RecompiledFunctionTable[257620] = bhEne22_Init_0x1fb940; // 0x1fb958 - g_ps2RecompiledFunctionTable[257621] = bhEne22_Init_0x1fb940; // 0x1fb95c - g_ps2RecompiledFunctionTable[257622] = bhEne22_Init_0x1fb940; // 0x1fb960 - g_ps2RecompiledFunctionTable[257623] = bhEne22_Init_0x1fb940; // 0x1fb964 - g_ps2RecompiledFunctionTable[257624] = bhEne22_Init_0x1fb940; // 0x1fb968 - g_ps2RecompiledFunctionTable[257625] = bhEne22_Init_0x1fb940; // 0x1fb96c - g_ps2RecompiledFunctionTable[257626] = bhEne22_Init_0x1fb940; // 0x1fb970 - g_ps2RecompiledFunctionTable[257627] = bhEne22_Init_0x1fb940; // 0x1fb974 - g_ps2RecompiledFunctionTable[257628] = bhEne22_Init_0x1fb940; // 0x1fb978 - g_ps2RecompiledFunctionTable[257629] = bhEne22_Init_0x1fb940; // 0x1fb97c - g_ps2RecompiledFunctionTable[257630] = bhEne22_Init_0x1fb940; // 0x1fb980 - g_ps2RecompiledFunctionTable[257631] = bhEne22_Init_0x1fb940; // 0x1fb984 - g_ps2RecompiledFunctionTable[257632] = bhEne22_Init_0x1fb940; // 0x1fb988 - g_ps2RecompiledFunctionTable[257633] = bhEne22_Init_0x1fb940; // 0x1fb98c - g_ps2RecompiledFunctionTable[257634] = bhEne22_Init_0x1fb940; // 0x1fb990 - g_ps2RecompiledFunctionTable[257635] = bhEne22_Init_0x1fb940; // 0x1fb994 - g_ps2RecompiledFunctionTable[257636] = bhEne22_Init_0x1fb940; // 0x1fb998 - g_ps2RecompiledFunctionTable[257637] = bhEne22_Init_0x1fb940; // 0x1fb99c - g_ps2RecompiledFunctionTable[257638] = bhEne22_Init_0x1fb940; // 0x1fb9a0 - g_ps2RecompiledFunctionTable[257639] = bhEne22_Init_0x1fb940; // 0x1fb9a4 - g_ps2RecompiledFunctionTable[257640] = bhEne22_Init_0x1fb940; // 0x1fb9a8 - g_ps2RecompiledFunctionTable[257641] = bhEne22_Init_0x1fb940; // 0x1fb9ac - g_ps2RecompiledFunctionTable[257642] = bhEne22_Init_0x1fb940; // 0x1fb9b0 - g_ps2RecompiledFunctionTable[257643] = bhEne22_Init_0x1fb940; // 0x1fb9b4 - g_ps2RecompiledFunctionTable[257644] = bhEne22_Init_0x1fb940; // 0x1fb9b8 - g_ps2RecompiledFunctionTable[257645] = bhEne22_Init_0x1fb940; // 0x1fb9bc - g_ps2RecompiledFunctionTable[257646] = bhEne22_Init_0x1fb940; // 0x1fb9c0 - g_ps2RecompiledFunctionTable[257647] = bhEne22_Init_0x1fb940; // 0x1fb9c4 - g_ps2RecompiledFunctionTable[257648] = bhEne22_Init_0x1fb940; // 0x1fb9c8 - g_ps2RecompiledFunctionTable[257649] = bhEne22_Init_0x1fb940; // 0x1fb9cc - g_ps2RecompiledFunctionTable[257650] = bhEne22_Init_0x1fb940; // 0x1fb9d0 - g_ps2RecompiledFunctionTable[257651] = bhEne22_Init_0x1fb940; // 0x1fb9d4 - g_ps2RecompiledFunctionTable[257652] = bhEne22_Init_0x1fb940; // 0x1fb9d8 - g_ps2RecompiledFunctionTable[257653] = bhEne22_Init_0x1fb940; // 0x1fb9dc - g_ps2RecompiledFunctionTable[257654] = bhEne22_Init_0x1fb940; // 0x1fb9e0 - g_ps2RecompiledFunctionTable[257655] = bhEne22_Init_0x1fb940; // 0x1fb9e4 - g_ps2RecompiledFunctionTable[257656] = bhEne22_Init_0x1fb940; // 0x1fb9e8 - g_ps2RecompiledFunctionTable[257657] = bhEne22_Init_0x1fb940; // 0x1fb9ec - g_ps2RecompiledFunctionTable[257658] = bhEne22_Init_0x1fb940; // 0x1fb9f0 - g_ps2RecompiledFunctionTable[257659] = bhEne22_Init_0x1fb940; // 0x1fb9f4 - g_ps2RecompiledFunctionTable[257660] = bhEne22_Init_0x1fb940; // 0x1fb9f8 - g_ps2RecompiledFunctionTable[257661] = bhEne22_Init_0x1fb940; // 0x1fb9fc - g_ps2RecompiledFunctionTable[257662] = bhEne22_Init_0x1fb940; // 0x1fba00 - g_ps2RecompiledFunctionTable[257663] = bhEne22_Init_0x1fb940; // 0x1fba04 - g_ps2RecompiledFunctionTable[257664] = bhEne22_Init_0x1fb940; // 0x1fba08 - g_ps2RecompiledFunctionTable[257665] = bhEne22_Init_0x1fb940; // 0x1fba0c - g_ps2RecompiledFunctionTable[257666] = bhEne22_Init_0x1fb940; // 0x1fba10 - g_ps2RecompiledFunctionTable[257667] = bhEne22_Init_0x1fb940; // 0x1fba14 - g_ps2RecompiledFunctionTable[257668] = bhEne22_Init_0x1fb940; // 0x1fba18 - g_ps2RecompiledFunctionTable[257669] = bhEne22_Init_0x1fb940; // 0x1fba1c - g_ps2RecompiledFunctionTable[257670] = bhEne22_Init_0x1fb940; // 0x1fba20 - g_ps2RecompiledFunctionTable[257671] = bhEne22_Init_0x1fb940; // 0x1fba24 - g_ps2RecompiledFunctionTable[257672] = bhEne22_Init_0x1fb940; // 0x1fba28 - g_ps2RecompiledFunctionTable[257673] = bhEne22_Init_0x1fb940; // 0x1fba2c - g_ps2RecompiledFunctionTable[257674] = bhEne22_Init_0x1fb940; // 0x1fba30 - g_ps2RecompiledFunctionTable[257675] = bhEne22_Init_0x1fb940; // 0x1fba34 - g_ps2RecompiledFunctionTable[257676] = bhEne22_Init_0x1fb940; // 0x1fba38 - g_ps2RecompiledFunctionTable[257677] = bhEne22_Init_0x1fb940; // 0x1fba3c - g_ps2RecompiledFunctionTable[257678] = bhEne22_Init_0x1fb940; // 0x1fba40 - g_ps2RecompiledFunctionTable[257679] = bhEne22_Init_0x1fb940; // 0x1fba44 - g_ps2RecompiledFunctionTable[257680] = bhEne22_Init_0x1fb940; // 0x1fba48 - g_ps2RecompiledFunctionTable[257681] = bhEne22_Init_0x1fb940; // 0x1fba4c - g_ps2RecompiledFunctionTable[257682] = bhEne22_Init_0x1fb940; // 0x1fba50 - g_ps2RecompiledFunctionTable[257683] = bhEne22_Init_0x1fb940; // 0x1fba54 - g_ps2RecompiledFunctionTable[257684] = bhEne22_Init_0x1fb940; // 0x1fba58 - g_ps2RecompiledFunctionTable[257685] = bhEne22_Init_0x1fb940; // 0x1fba5c - g_ps2RecompiledFunctionTable[257686] = bhEne22_Init_0x1fb940; // 0x1fba60 - g_ps2RecompiledFunctionTable[257687] = bhEne22_Init_0x1fb940; // 0x1fba64 - g_ps2RecompiledFunctionTable[257688] = bhEne22_Init_0x1fb940; // 0x1fba68 - g_ps2RecompiledFunctionTable[257689] = bhEne22_Init_0x1fb940; // 0x1fba6c - g_ps2RecompiledFunctionTable[257690] = bhEne22_Init_0x1fb940; // 0x1fba70 - g_ps2RecompiledFunctionTable[257691] = bhEne22_Init_0x1fb940; // 0x1fba74 - g_ps2RecompiledFunctionTable[257692] = bhEne22_Init_0x1fb940; // 0x1fba78 - g_ps2RecompiledFunctionTable[257693] = bhEne22_Init_0x1fb940; // 0x1fba7c - g_ps2RecompiledFunctionTable[257694] = bhEne22_Init_0x1fb940; // 0x1fba80 - g_ps2RecompiledFunctionTable[257695] = bhEne22_Init_0x1fb940; // 0x1fba84 - g_ps2RecompiledFunctionTable[257696] = bhEne22_Init_0x1fb940; // 0x1fba88 - g_ps2RecompiledFunctionTable[257697] = bhEne22_Init_0x1fb940; // 0x1fba8c - g_ps2RecompiledFunctionTable[257698] = bhEne22_Init_0x1fb940; // 0x1fba90 - g_ps2RecompiledFunctionTable[257699] = bhEne22_Init_0x1fb940; // 0x1fba94 - g_ps2RecompiledFunctionTable[257700] = bhEne22_Init_0x1fb940; // 0x1fba98 - g_ps2RecompiledFunctionTable[257701] = bhEne22_Init_0x1fb940; // 0x1fba9c - g_ps2RecompiledFunctionTable[257702] = bhEne22_Init_0x1fb940; // 0x1fbaa0 - g_ps2RecompiledFunctionTable[257703] = bhEne22_Init_0x1fb940; // 0x1fbaa4 - g_ps2RecompiledFunctionTable[257704] = bhEne22_Init_0x1fb940; // 0x1fbaa8 - g_ps2RecompiledFunctionTable[257705] = bhEne22_Init_0x1fb940; // 0x1fbaac - g_ps2RecompiledFunctionTable[257706] = bhEne22_Init_0x1fb940; // 0x1fbab0 - g_ps2RecompiledFunctionTable[257707] = bhEne22_Init_0x1fb940; // 0x1fbab4 - g_ps2RecompiledFunctionTable[257708] = bhEne22_Init_0x1fb940; // 0x1fbab8 - g_ps2RecompiledFunctionTable[257709] = bhEne22_Init_0x1fb940; // 0x1fbabc - g_ps2RecompiledFunctionTable[257710] = bhEne22_Init_0x1fb940; // 0x1fbac0 - g_ps2RecompiledFunctionTable[257711] = bhEne22_Init_0x1fb940; // 0x1fbac4 - g_ps2RecompiledFunctionTable[257712] = bhEne22_Init_0x1fb940; // 0x1fbac8 - g_ps2RecompiledFunctionTable[257713] = bhEne22_Init_0x1fb940; // 0x1fbacc - g_ps2RecompiledFunctionTable[257714] = bhEne22_Init_0x1fb940; // 0x1fbad0 - g_ps2RecompiledFunctionTable[257715] = bhEne22_Init_0x1fb940; // 0x1fbad4 - g_ps2RecompiledFunctionTable[257716] = bhEne22_Init_0x1fb940; // 0x1fbad8 - g_ps2RecompiledFunctionTable[257717] = bhEne22_Init_0x1fb940; // 0x1fbadc - g_ps2RecompiledFunctionTable[257718] = bhEne22_Init_0x1fb940; // 0x1fbae0 - g_ps2RecompiledFunctionTable[257719] = bhEne22_Init_0x1fb940; // 0x1fbae4 - g_ps2RecompiledFunctionTable[257720] = bhEne22_Init_0x1fb940; // 0x1fbae8 - g_ps2RecompiledFunctionTable[257721] = bhEne22_Init_0x1fb940; // 0x1fbaec - g_ps2RecompiledFunctionTable[257722] = bhEne22_Init_0x1fb940; // 0x1fbaf0 - g_ps2RecompiledFunctionTable[257723] = bhEne22_Init_0x1fb940; // 0x1fbaf4 - g_ps2RecompiledFunctionTable[257724] = bhEne22_Init_0x1fb940; // 0x1fbaf8 - g_ps2RecompiledFunctionTable[257725] = bhEne22_Init_0x1fb940; // 0x1fbafc - g_ps2RecompiledFunctionTable[257726] = bhEne22_Init_0x1fb940; // 0x1fbb00 - g_ps2RecompiledFunctionTable[257727] = bhEne22_Init_0x1fb940; // 0x1fbb04 - g_ps2RecompiledFunctionTable[257728] = bhEne22_Init_0x1fb940; // 0x1fbb08 - g_ps2RecompiledFunctionTable[257729] = bhEne22_Init_0x1fb940; // 0x1fbb0c - g_ps2RecompiledFunctionTable[257730] = bhEne22_Init_0x1fb940; // 0x1fbb10 - g_ps2RecompiledFunctionTable[257731] = bhEne22_Init_0x1fb940; // 0x1fbb14 - g_ps2RecompiledFunctionTable[257732] = bhEne22_Init_0x1fb940; // 0x1fbb18 - g_ps2RecompiledFunctionTable[257733] = bhEne22_Init_0x1fb940; // 0x1fbb1c - g_ps2RecompiledFunctionTable[257734] = bhEne22_Init_0x1fb940; // 0x1fbb20 - g_ps2RecompiledFunctionTable[257735] = bhEne22_Init_0x1fb940; // 0x1fbb24 - g_ps2RecompiledFunctionTable[257736] = bhEne22_Init_0x1fb940; // 0x1fbb28 - g_ps2RecompiledFunctionTable[257737] = bhEne22_Init_0x1fb940; // 0x1fbb2c - g_ps2RecompiledFunctionTable[257738] = bhEne22_Init_0x1fb940; // 0x1fbb30 - g_ps2RecompiledFunctionTable[257739] = bhEne22_Init_0x1fb940; // 0x1fbb34 - g_ps2RecompiledFunctionTable[257740] = bhEne22_Init_0x1fb940; // 0x1fbb38 - g_ps2RecompiledFunctionTable[257741] = bhEne22_Init_0x1fb940; // 0x1fbb3c - g_ps2RecompiledFunctionTable[257742] = bhEne22_Init_0x1fb940; // 0x1fbb40 - g_ps2RecompiledFunctionTable[257743] = bhEne22_Init_0x1fb940; // 0x1fbb44 - g_ps2RecompiledFunctionTable[257744] = bhEne22_Init_0x1fb940; // 0x1fbb48 - g_ps2RecompiledFunctionTable[257745] = bhEne22_Init_0x1fb940; // 0x1fbb4c - g_ps2RecompiledFunctionTable[257746] = bhEne22_Init_0x1fb940; // 0x1fbb50 - g_ps2RecompiledFunctionTable[257747] = bhEne22_Init_0x1fb940; // 0x1fbb54 - g_ps2RecompiledFunctionTable[257748] = bhEne22_Init_0x1fb940; // 0x1fbb58 - g_ps2RecompiledFunctionTable[257750] = bhEne22_InitType00_0x1fbb60; // 0x1fbb60 - g_ps2RecompiledFunctionTable[257754] = bhEne22_Move_0x1fbb70; // 0x1fbb70 - g_ps2RecompiledFunctionTable[257755] = bhEne22_Move_0x1fbb70; // 0x1fbb74 - g_ps2RecompiledFunctionTable[257756] = bhEne22_Move_0x1fbb70; // 0x1fbb78 - g_ps2RecompiledFunctionTable[257757] = bhEne22_Move_0x1fbb70; // 0x1fbb7c - g_ps2RecompiledFunctionTable[257758] = bhEne22_Move_0x1fbb70; // 0x1fbb80 - g_ps2RecompiledFunctionTable[257759] = bhEne22_Move_0x1fbb70; // 0x1fbb84 - g_ps2RecompiledFunctionTable[257760] = bhEne22_Move_0x1fbb70; // 0x1fbb88 - g_ps2RecompiledFunctionTable[257761] = bhEne22_Move_0x1fbb70; // 0x1fbb8c - g_ps2RecompiledFunctionTable[257762] = bhEne22_Move_0x1fbb70; // 0x1fbb90 - g_ps2RecompiledFunctionTable[257763] = bhEne22_Move_0x1fbb70; // 0x1fbb94 - g_ps2RecompiledFunctionTable[257764] = bhEne22_Move_0x1fbb70; // 0x1fbb98 - g_ps2RecompiledFunctionTable[257765] = bhEne22_Move_0x1fbb70; // 0x1fbb9c - g_ps2RecompiledFunctionTable[257766] = bhEne22_Move_0x1fbb70; // 0x1fbba0 - g_ps2RecompiledFunctionTable[257767] = bhEne22_Move_0x1fbb70; // 0x1fbba4 - g_ps2RecompiledFunctionTable[257768] = bhEne22_Move_0x1fbb70; // 0x1fbba8 - g_ps2RecompiledFunctionTable[257769] = bhEne22_Move_0x1fbb70; // 0x1fbbac - g_ps2RecompiledFunctionTable[257770] = bhEne22_Move_0x1fbb70; // 0x1fbbb0 - g_ps2RecompiledFunctionTable[257771] = bhEne22_Move_0x1fbb70; // 0x1fbbb4 - g_ps2RecompiledFunctionTable[257772] = bhEne22_Move_0x1fbb70; // 0x1fbbb8 - g_ps2RecompiledFunctionTable[257773] = bhEne22_Move_0x1fbb70; // 0x1fbbbc - g_ps2RecompiledFunctionTable[257774] = bhEne22_Move_0x1fbb70; // 0x1fbbc0 - g_ps2RecompiledFunctionTable[257775] = bhEne22_Move_0x1fbb70; // 0x1fbbc4 - g_ps2RecompiledFunctionTable[257776] = bhEne22_Move_0x1fbb70; // 0x1fbbc8 - g_ps2RecompiledFunctionTable[257777] = bhEne22_Move_0x1fbb70; // 0x1fbbcc - g_ps2RecompiledFunctionTable[257778] = bhEne22_Move_0x1fbb70; // 0x1fbbd0 - g_ps2RecompiledFunctionTable[257779] = bhEne22_Move_0x1fbb70; // 0x1fbbd4 - g_ps2RecompiledFunctionTable[257780] = bhEne22_Move_0x1fbb70; // 0x1fbbd8 - g_ps2RecompiledFunctionTable[257781] = bhEne22_Move_0x1fbb70; // 0x1fbbdc - g_ps2RecompiledFunctionTable[257782] = bhEne22_Move_0x1fbb70; // 0x1fbbe0 - g_ps2RecompiledFunctionTable[257783] = bhEne22_Move_0x1fbb70; // 0x1fbbe4 - g_ps2RecompiledFunctionTable[257784] = bhEne22_Move_0x1fbb70; // 0x1fbbe8 - g_ps2RecompiledFunctionTable[257785] = bhEne22_Move_0x1fbb70; // 0x1fbbec - g_ps2RecompiledFunctionTable[257786] = bhEne22_Move_0x1fbb70; // 0x1fbbf0 - g_ps2RecompiledFunctionTable[257787] = bhEne22_Move_0x1fbb70; // 0x1fbbf4 - g_ps2RecompiledFunctionTable[257788] = bhEne22_Move_0x1fbb70; // 0x1fbbf8 - g_ps2RecompiledFunctionTable[257789] = bhEne22_Move_0x1fbb70; // 0x1fbbfc - g_ps2RecompiledFunctionTable[257790] = bhEne22_Move_0x1fbb70; // 0x1fbc00 - g_ps2RecompiledFunctionTable[257791] = bhEne22_Move_0x1fbb70; // 0x1fbc04 - g_ps2RecompiledFunctionTable[257792] = bhEne22_Move_0x1fbb70; // 0x1fbc08 - g_ps2RecompiledFunctionTable[257793] = bhEne22_Move_0x1fbb70; // 0x1fbc0c - g_ps2RecompiledFunctionTable[257794] = bhEne22_Move_0x1fbb70; // 0x1fbc10 - g_ps2RecompiledFunctionTable[257795] = bhEne22_Move_0x1fbb70; // 0x1fbc14 - g_ps2RecompiledFunctionTable[257796] = bhEne22_Move_0x1fbb70; // 0x1fbc18 - g_ps2RecompiledFunctionTable[257797] = bhEne22_Move_0x1fbb70; // 0x1fbc1c - g_ps2RecompiledFunctionTable[257798] = bhEne22_Move_0x1fbb70; // 0x1fbc20 - g_ps2RecompiledFunctionTable[257799] = bhEne22_Move_0x1fbb70; // 0x1fbc24 - g_ps2RecompiledFunctionTable[257800] = bhEne22_Move_0x1fbb70; // 0x1fbc28 - g_ps2RecompiledFunctionTable[257801] = bhEne22_Move_0x1fbb70; // 0x1fbc2c - g_ps2RecompiledFunctionTable[257802] = bhEne22_Move_0x1fbb70; // 0x1fbc30 - g_ps2RecompiledFunctionTable[257803] = bhEne22_Move_0x1fbb70; // 0x1fbc34 - g_ps2RecompiledFunctionTable[257804] = bhEne22_Move_0x1fbb70; // 0x1fbc38 - g_ps2RecompiledFunctionTable[257805] = bhEne22_Move_0x1fbb70; // 0x1fbc3c - g_ps2RecompiledFunctionTable[257806] = bhEne22_Move_0x1fbb70; // 0x1fbc40 - g_ps2RecompiledFunctionTable[257807] = bhEne22_Move_0x1fbb70; // 0x1fbc44 - g_ps2RecompiledFunctionTable[257808] = bhEne22_Move_0x1fbb70; // 0x1fbc48 - g_ps2RecompiledFunctionTable[257809] = bhEne22_Move_0x1fbb70; // 0x1fbc4c - g_ps2RecompiledFunctionTable[257810] = bhEne22_Move_0x1fbb70; // 0x1fbc50 - g_ps2RecompiledFunctionTable[257811] = bhEne22_Move_0x1fbb70; // 0x1fbc54 - g_ps2RecompiledFunctionTable[257812] = bhEne22_Move_0x1fbb70; // 0x1fbc58 - g_ps2RecompiledFunctionTable[257813] = bhEne22_Move_0x1fbb70; // 0x1fbc5c - g_ps2RecompiledFunctionTable[257814] = bhEne22_Move_0x1fbb70; // 0x1fbc60 - g_ps2RecompiledFunctionTable[257815] = bhEne22_Move_0x1fbb70; // 0x1fbc64 - g_ps2RecompiledFunctionTable[257816] = bhEne22_Move_0x1fbb70; // 0x1fbc68 - g_ps2RecompiledFunctionTable[257817] = bhEne22_Move_0x1fbb70; // 0x1fbc6c - g_ps2RecompiledFunctionTable[257818] = bhEne22_Move_0x1fbb70; // 0x1fbc70 - g_ps2RecompiledFunctionTable[257819] = bhEne22_Move_0x1fbb70; // 0x1fbc74 - g_ps2RecompiledFunctionTable[257820] = bhEne22_Move_0x1fbb70; // 0x1fbc78 - g_ps2RecompiledFunctionTable[257821] = bhEne22_Move_0x1fbb70; // 0x1fbc7c - g_ps2RecompiledFunctionTable[257822] = bhEne22_Move_0x1fbb70; // 0x1fbc80 - g_ps2RecompiledFunctionTable[257823] = bhEne22_Move_0x1fbb70; // 0x1fbc84 - g_ps2RecompiledFunctionTable[257824] = bhEne22_Move_0x1fbb70; // 0x1fbc88 - g_ps2RecompiledFunctionTable[257825] = bhEne22_Move_0x1fbb70; // 0x1fbc8c - g_ps2RecompiledFunctionTable[257826] = bhEne22_Move_0x1fbb70; // 0x1fbc90 - g_ps2RecompiledFunctionTable[257827] = bhEne22_Move_0x1fbb70; // 0x1fbc94 - g_ps2RecompiledFunctionTable[257828] = bhEne22_Move_0x1fbb70; // 0x1fbc98 - g_ps2RecompiledFunctionTable[257829] = bhEne22_Move_0x1fbb70; // 0x1fbc9c - g_ps2RecompiledFunctionTable[257830] = bhEne22_Move_0x1fbb70; // 0x1fbca0 - g_ps2RecompiledFunctionTable[257831] = bhEne22_Move_0x1fbb70; // 0x1fbca4 - g_ps2RecompiledFunctionTable[257832] = bhEne22_Move_0x1fbb70; // 0x1fbca8 - g_ps2RecompiledFunctionTable[257833] = bhEne22_Move_0x1fbb70; // 0x1fbcac - g_ps2RecompiledFunctionTable[257834] = bhEne22_Move_0x1fbb70; // 0x1fbcb0 - g_ps2RecompiledFunctionTable[257835] = bhEne22_Move_0x1fbb70; // 0x1fbcb4 - g_ps2RecompiledFunctionTable[257836] = bhEne22_Move_0x1fbb70; // 0x1fbcb8 - g_ps2RecompiledFunctionTable[257837] = bhEne22_Move_0x1fbb70; // 0x1fbcbc - g_ps2RecompiledFunctionTable[257838] = bhEne22_Move_0x1fbb70; // 0x1fbcc0 - g_ps2RecompiledFunctionTable[257839] = bhEne22_Move_0x1fbb70; // 0x1fbcc4 - g_ps2RecompiledFunctionTable[257840] = bhEne22_Move_0x1fbb70; // 0x1fbcc8 - g_ps2RecompiledFunctionTable[257842] = bhEne22_Nage_0x1fbcd0; // 0x1fbcd0 - g_ps2RecompiledFunctionTable[257846] = bhEne22_Damage_0x1fbce0; // 0x1fbce0 - g_ps2RecompiledFunctionTable[257847] = bhEne22_Damage_0x1fbce0; // 0x1fbce4 - g_ps2RecompiledFunctionTable[257848] = bhEne22_Damage_0x1fbce0; // 0x1fbce8 - g_ps2RecompiledFunctionTable[257849] = bhEne22_Damage_0x1fbce0; // 0x1fbcec - g_ps2RecompiledFunctionTable[257850] = bhEne22_Damage_0x1fbce0; // 0x1fbcf0 - g_ps2RecompiledFunctionTable[257851] = bhEne22_Damage_0x1fbce0; // 0x1fbcf4 - g_ps2RecompiledFunctionTable[257852] = bhEne22_Damage_0x1fbce0; // 0x1fbcf8 - g_ps2RecompiledFunctionTable[257853] = bhEne22_Damage_0x1fbce0; // 0x1fbcfc - g_ps2RecompiledFunctionTable[257854] = bhEne22_Die_0x1fbd00; // 0x1fbd00 - g_ps2RecompiledFunctionTable[257855] = bhEne22_Die_0x1fbd00; // 0x1fbd04 - g_ps2RecompiledFunctionTable[257856] = bhEne22_Die_0x1fbd00; // 0x1fbd08 - g_ps2RecompiledFunctionTable[257857] = bhEne22_Die_0x1fbd00; // 0x1fbd0c - g_ps2RecompiledFunctionTable[257858] = bhEne22_Die_0x1fbd00; // 0x1fbd10 - g_ps2RecompiledFunctionTable[257859] = bhEne22_Die_0x1fbd00; // 0x1fbd14 - g_ps2RecompiledFunctionTable[257860] = bhEne22_Die_0x1fbd00; // 0x1fbd18 - g_ps2RecompiledFunctionTable[257861] = bhEne22_Die_0x1fbd00; // 0x1fbd1c - g_ps2RecompiledFunctionTable[257862] = bhEne22_PlyerHitCheck_0x1fbd20; // 0x1fbd20 - g_ps2RecompiledFunctionTable[257912] = bhEne22_PlyerHitCheck_0x1fbd20; // 0x1fbde8 - g_ps2RecompiledFunctionTable[257917] = bhEne22_PlyerHitCheck_0x1fbd20; // 0x1fbdfc - g_ps2RecompiledFunctionTable[257930] = bhEne22_PlyerHitCheck_0x1fbd20; // 0x1fbe30 - g_ps2RecompiledFunctionTable[257946] = bhEne22_PlyerHitCheck_0x1fbd20; // 0x1fbe70 - g_ps2RecompiledFunctionTable[257997] = bhEne22_PlyerHitCheck_0x1fbd20; // 0x1fbf3c - g_ps2RecompiledFunctionTable[258000] = bhEne22_PlyerHitCheck_0x1fbd20; // 0x1fbf48 - g_ps2RecompiledFunctionTable[258005] = bhEne22_PlyerHitCheck_0x1fbd20; // 0x1fbf5c - g_ps2RecompiledFunctionTable[258018] = bhEne22_PlyerHitCheck_0x1fbd20; // 0x1fbf90 - g_ps2RecompiledFunctionTable[258026] = bhEne22_EneSearch_0x1fbfb0; // 0x1fbfb0 - g_ps2RecompiledFunctionTable[258041] = bhEne22_EneSearch_0x1fbfb0; // 0x1fbfec - g_ps2RecompiledFunctionTable[258082] = bhEne22_Brain_0x1fc090; // 0x1fc090 - g_ps2RecompiledFunctionTable[258083] = bhEne22_Brain_0x1fc090; // 0x1fc094 - g_ps2RecompiledFunctionTable[258084] = bhEne22_Brain_0x1fc090; // 0x1fc098 - g_ps2RecompiledFunctionTable[258085] = bhEne22_Brain_0x1fc090; // 0x1fc09c - g_ps2RecompiledFunctionTable[258086] = bhEne22_Brain_0x1fc090; // 0x1fc0a0 - g_ps2RecompiledFunctionTable[258087] = bhEne22_Brain_0x1fc090; // 0x1fc0a4 - g_ps2RecompiledFunctionTable[258088] = bhEne22_Brain_0x1fc090; // 0x1fc0a8 - g_ps2RecompiledFunctionTable[258089] = bhEne22_Brain_0x1fc090; // 0x1fc0ac - g_ps2RecompiledFunctionTable[258090] = bhEne22_Brain_0x1fc090; // 0x1fc0b0 - g_ps2RecompiledFunctionTable[258091] = bhEne22_Brain_0x1fc090; // 0x1fc0b4 - g_ps2RecompiledFunctionTable[258092] = bhEne22_Brain_0x1fc090; // 0x1fc0b8 - g_ps2RecompiledFunctionTable[258093] = bhEne22_Brain_0x1fc090; // 0x1fc0bc - g_ps2RecompiledFunctionTable[258094] = bhEne22_Brain_0x1fc090; // 0x1fc0c0 - g_ps2RecompiledFunctionTable[258095] = bhEne22_Brain_0x1fc090; // 0x1fc0c4 - g_ps2RecompiledFunctionTable[258096] = bhEne22_Brain_0x1fc090; // 0x1fc0c8 - g_ps2RecompiledFunctionTable[258097] = bhEne22_Brain_0x1fc090; // 0x1fc0cc - g_ps2RecompiledFunctionTable[258098] = bhEne22_Brain_0x1fc090; // 0x1fc0d0 - g_ps2RecompiledFunctionTable[258099] = bhEne22_Brain_0x1fc090; // 0x1fc0d4 - g_ps2RecompiledFunctionTable[258100] = bhEne22_Brain_0x1fc090; // 0x1fc0d8 - g_ps2RecompiledFunctionTable[258101] = bhEne22_Brain_0x1fc090; // 0x1fc0dc - g_ps2RecompiledFunctionTable[258102] = bhEne22_Brain_0x1fc090; // 0x1fc0e0 - g_ps2RecompiledFunctionTable[258103] = bhEne22_Brain_0x1fc090; // 0x1fc0e4 - g_ps2RecompiledFunctionTable[258106] = bhEne22_Brain00_0x1fc0f0; // 0x1fc0f0 - g_ps2RecompiledFunctionTable[258147] = bhEne22_Brain00_0x1fc0f0; // 0x1fc194 - g_ps2RecompiledFunctionTable[258165] = bhEne22_Brain00_0x1fc0f0; // 0x1fc1dc - g_ps2RecompiledFunctionTable[258181] = bhEne22_Brain00_0x1fc0f0; // 0x1fc21c - g_ps2RecompiledFunctionTable[258186] = bhEne22_Brain00_0x1fc0f0; // 0x1fc230 - g_ps2RecompiledFunctionTable[258210] = bhEne22_Brain01_0x1fc290; // 0x1fc290 - g_ps2RecompiledFunctionTable[258222] = bhEne22_Brain01_0x1fc290; // 0x1fc2c0 - g_ps2RecompiledFunctionTable[258226] = bhEne22_Brain01_0x1fc290; // 0x1fc2d0 - g_ps2RecompiledFunctionTable[258242] = bhEne22_Brain02_0x1fc310; // 0x1fc310 - g_ps2RecompiledFunctionTable[258266] = bhEne22_Brain02_0x1fc310; // 0x1fc370 - g_ps2RecompiledFunctionTable[258270] = bhEne22_Brain02_0x1fc310; // 0x1fc380 - g_ps2RecompiledFunctionTable[258274] = bhEne22_Brain04_0x1fc390; // 0x1fc390 - g_ps2RecompiledFunctionTable[258290] = bhEne22_MVType00_0x1fc3d0; // 0x1fc3d0 - g_ps2RecompiledFunctionTable[258291] = bhEne22_MVType00_0x1fc3d0; // 0x1fc3d4 - g_ps2RecompiledFunctionTable[258292] = bhEne22_MVType00_0x1fc3d0; // 0x1fc3d8 - g_ps2RecompiledFunctionTable[258293] = bhEne22_MVType00_0x1fc3d0; // 0x1fc3dc - g_ps2RecompiledFunctionTable[258294] = bhEne22_MVType00_0x1fc3d0; // 0x1fc3e0 - g_ps2RecompiledFunctionTable[258295] = bhEne22_MVType00_0x1fc3d0; // 0x1fc3e4 - g_ps2RecompiledFunctionTable[258296] = bhEne22_MVType00_0x1fc3d0; // 0x1fc3e8 - g_ps2RecompiledFunctionTable[258297] = bhEne22_MVType00_0x1fc3d0; // 0x1fc3ec - g_ps2RecompiledFunctionTable[258298] = bhEne22_MVType00_0x1fc3d0; // 0x1fc3f0 - g_ps2RecompiledFunctionTable[258299] = bhEne22_MVType00_0x1fc3d0; // 0x1fc3f4 - g_ps2RecompiledFunctionTable[258300] = bhEne22_MVType00_0x1fc3d0; // 0x1fc3f8 - g_ps2RecompiledFunctionTable[258301] = bhEne22_MVType00_0x1fc3d0; // 0x1fc3fc - g_ps2RecompiledFunctionTable[258302] = bhEne22_MVType00_0x1fc3d0; // 0x1fc400 - g_ps2RecompiledFunctionTable[258303] = bhEne22_MVType00_0x1fc3d0; // 0x1fc404 - g_ps2RecompiledFunctionTable[258304] = bhEne22_MVType00_0x1fc3d0; // 0x1fc408 - g_ps2RecompiledFunctionTable[258305] = bhEne22_MVType00_0x1fc3d0; // 0x1fc40c - g_ps2RecompiledFunctionTable[258306] = bhEne22_MVType00_0x1fc3d0; // 0x1fc410 - g_ps2RecompiledFunctionTable[258307] = bhEne22_MVType00_0x1fc3d0; // 0x1fc414 - g_ps2RecompiledFunctionTable[258308] = bhEne22_MVType00_0x1fc3d0; // 0x1fc418 - g_ps2RecompiledFunctionTable[258309] = bhEne22_MVType00_0x1fc3d0; // 0x1fc41c - g_ps2RecompiledFunctionTable[258310] = bhEne22_MVType00_0x1fc3d0; // 0x1fc420 - g_ps2RecompiledFunctionTable[258314] = bhEne22_MV00_0x1fc430; // 0x1fc430 - g_ps2RecompiledFunctionTable[258329] = bhEne22_MV00_0x1fc430; // 0x1fc46c - g_ps2RecompiledFunctionTable[258336] = bhEne22_MV00_0x1fc430; // 0x1fc488 - g_ps2RecompiledFunctionTable[258346] = bhEne22_MV00_0x1fc430; // 0x1fc4b0 - g_ps2RecompiledFunctionTable[258364] = bhEne22_MV00_0x1fc430; // 0x1fc4f8 - g_ps2RecompiledFunctionTable[258388] = bhEne22_MV00_0x1fc430; // 0x1fc558 - g_ps2RecompiledFunctionTable[258400] = bhEne22_MV00_0x1fc430; // 0x1fc588 - g_ps2RecompiledFunctionTable[258406] = bhEne22_MV01_0x1fc5a0; // 0x1fc5a0 - g_ps2RecompiledFunctionTable[258429] = bhEne22_MV01_0x1fc5a0; // 0x1fc5fc - g_ps2RecompiledFunctionTable[258448] = bhEne22_MV01_0x1fc5a0; // 0x1fc648 - g_ps2RecompiledFunctionTable[258450] = bhEne22_MV01_0x1fc5a0; // 0x1fc650 - g_ps2RecompiledFunctionTable[258479] = bhEne22_MV01_0x1fc5a0; // 0x1fc6c4 - g_ps2RecompiledFunctionTable[258482] = bhEne22_MV01_0x1fc5a0; // 0x1fc6d0 - g_ps2RecompiledFunctionTable[258488] = bhEne22_MV01_0x1fc5a0; // 0x1fc6e8 - g_ps2RecompiledFunctionTable[258495] = bhEne22_MV01_0x1fc5a0; // 0x1fc704 - g_ps2RecompiledFunctionTable[258499] = bhEne22_MV01_0x1fc5a0; // 0x1fc714 - g_ps2RecompiledFunctionTable[258532] = bhEne22_MV01_0x1fc5a0; // 0x1fc798 - g_ps2RecompiledFunctionTable[258548] = bhEne22_MV01_0x1fc5a0; // 0x1fc7d8 - g_ps2RecompiledFunctionTable[258560] = bhEne22_MV01_0x1fc5a0; // 0x1fc808 - g_ps2RecompiledFunctionTable[258577] = bhEne22_MV01_0x1fc5a0; // 0x1fc84c - g_ps2RecompiledFunctionTable[258591] = bhEne22_MV01_0x1fc5a0; // 0x1fc884 - g_ps2RecompiledFunctionTable[258594] = bhEne22_MV01_0x1fc5a0; // 0x1fc890 - g_ps2RecompiledFunctionTable[258603] = bhEne22_MV01_0x1fc5a0; // 0x1fc8b4 - g_ps2RecompiledFunctionTable[258609] = bhEne22_MV01_0x1fc5a0; // 0x1fc8cc - g_ps2RecompiledFunctionTable[258650] = bhEne22_MV01_0x1fc5a0; // 0x1fc970 - g_ps2RecompiledFunctionTable[258654] = bhEne22_MV02_0x1fc980; // 0x1fc980 - g_ps2RecompiledFunctionTable[258690] = bhEne22_MV02_0x1fc980; // 0x1fca10 - g_ps2RecompiledFunctionTable[258707] = bhEne22_MV02_0x1fc980; // 0x1fca54 - g_ps2RecompiledFunctionTable[258731] = bhEne22_MV02_0x1fc980; // 0x1fcab4 - g_ps2RecompiledFunctionTable[258756] = bhEne22_MV02_0x1fc980; // 0x1fcb18 - g_ps2RecompiledFunctionTable[258759] = bhEne22_MV02_0x1fc980; // 0x1fcb24 - g_ps2RecompiledFunctionTable[258791] = bhEne22_MV02_0x1fc980; // 0x1fcba4 - g_ps2RecompiledFunctionTable[258817] = bhEne22_MV02_0x1fc980; // 0x1fcc0c - g_ps2RecompiledFunctionTable[258837] = bhEne22_MV02_0x1fc980; // 0x1fcc5c - g_ps2RecompiledFunctionTable[258854] = bhEne22_MV02_0x1fc980; // 0x1fcca0 - g_ps2RecompiledFunctionTable[258858] = bhEne22_MV02_0x1fc980; // 0x1fccb0 - g_ps2RecompiledFunctionTable[258867] = bhEne22_MV02_0x1fc980; // 0x1fccd4 - g_ps2RecompiledFunctionTable[258880] = bhEne22_MV02_0x1fc980; // 0x1fcd08 - g_ps2RecompiledFunctionTable[258884] = bhEne22_MV02_0x1fc980; // 0x1fcd18 - g_ps2RecompiledFunctionTable[258917] = bhEne22_MV02_0x1fc980; // 0x1fcd9c - g_ps2RecompiledFunctionTable[258946] = bhEne22_MV02_0x1fc980; // 0x1fce10 - g_ps2RecompiledFunctionTable[258954] = bhEne22_MV02_0x1fc980; // 0x1fce30 - g_ps2RecompiledFunctionTable[258966] = bhEne22_MV02_0x1fc980; // 0x1fce60 - g_ps2RecompiledFunctionTable[258978] = bhEne22_MV02_0x1fc980; // 0x1fce90 - g_ps2RecompiledFunctionTable[258985] = bhEne22_MV02_0x1fc980; // 0x1fceac - g_ps2RecompiledFunctionTable[258988] = bhEne22_MV02_0x1fc980; // 0x1fceb8 - g_ps2RecompiledFunctionTable[259026] = bhEne22_MV02_0x1fc980; // 0x1fcf50 - g_ps2RecompiledFunctionTable[259058] = bhEne22_MV02_0x1fc980; // 0x1fcfd0 - g_ps2RecompiledFunctionTable[259077] = bhEne22_MV02_0x1fc980; // 0x1fd01c - g_ps2RecompiledFunctionTable[259102] = bhEne22_MV02_0x1fc980; // 0x1fd080 - g_ps2RecompiledFunctionTable[259121] = bhEne22_MV02_0x1fc980; // 0x1fd0cc - g_ps2RecompiledFunctionTable[259128] = bhEne22_MV02_0x1fc980; // 0x1fd0e8 - g_ps2RecompiledFunctionTable[259134] = bhEne22_MV02_0x1fc980; // 0x1fd100 - g_ps2RecompiledFunctionTable[259140] = bhEne22_MV02_0x1fc980; // 0x1fd118 - g_ps2RecompiledFunctionTable[259147] = bhEne22_MV02_0x1fc980; // 0x1fd134 - g_ps2RecompiledFunctionTable[259200] = bhEne22_MV02_0x1fc980; // 0x1fd208 - g_ps2RecompiledFunctionTable[259219] = bhEne22_MV02_0x1fc980; // 0x1fd254 - g_ps2RecompiledFunctionTable[259226] = bhEne22_MV02_0x1fc980; // 0x1fd270 - g_ps2RecompiledFunctionTable[259233] = bhEne22_MV02_0x1fc980; // 0x1fd28c - g_ps2RecompiledFunctionTable[259238] = bhEne22_MV03_0x1fd2a0; // 0x1fd2a0 - g_ps2RecompiledFunctionTable[259242] = bhEne22_MV04_0x1fd2b0; // 0x1fd2b0 - g_ps2RecompiledFunctionTable[259257] = bhEne22_MV04_0x1fd2b0; // 0x1fd2ec - g_ps2RecompiledFunctionTable[259408] = bhEne22_MV04_0x1fd2b0; // 0x1fd548 - g_ps2RecompiledFunctionTable[259415] = bhEne22_MV04_0x1fd2b0; // 0x1fd564 - g_ps2RecompiledFunctionTable[259450] = bhEne22_MV05_0x1fd5f0; // 0x1fd5f0 - g_ps2RecompiledFunctionTable[259454] = bhEne22_MV06_0x1fd600; // 0x1fd600 - g_ps2RecompiledFunctionTable[259469] = bhEne22_MV06_0x1fd600; // 0x1fd63c - g_ps2RecompiledFunctionTable[259514] = bhEne22_DGType00_0x1fd6f0; // 0x1fd6f0 - g_ps2RecompiledFunctionTable[259515] = bhEne22_DGType00_0x1fd6f0; // 0x1fd6f4 - g_ps2RecompiledFunctionTable[259516] = bhEne22_DGType00_0x1fd6f0; // 0x1fd6f8 - g_ps2RecompiledFunctionTable[259517] = bhEne22_DGType00_0x1fd6f0; // 0x1fd6fc - g_ps2RecompiledFunctionTable[259518] = bhEne22_DGType00_0x1fd6f0; // 0x1fd700 - g_ps2RecompiledFunctionTable[259519] = bhEne22_DGType00_0x1fd6f0; // 0x1fd704 - g_ps2RecompiledFunctionTable[259520] = bhEne22_DGType00_0x1fd6f0; // 0x1fd708 - g_ps2RecompiledFunctionTable[259521] = bhEne22_DGType00_0x1fd6f0; // 0x1fd70c - g_ps2RecompiledFunctionTable[259522] = bhEne22_DG00_0x1fd710; // 0x1fd710 - g_ps2RecompiledFunctionTable[259542] = bhEne22_DG00_0x1fd710; // 0x1fd760 - g_ps2RecompiledFunctionTable[259551] = bhEne22_DG00_0x1fd710; // 0x1fd784 - g_ps2RecompiledFunctionTable[259560] = bhEne22_DG00_0x1fd710; // 0x1fd7a8 - g_ps2RecompiledFunctionTable[259569] = bhEne22_DG00_0x1fd710; // 0x1fd7cc - g_ps2RecompiledFunctionTable[259602] = bhEne22_DG00_0x1fd710; // 0x1fd850 - g_ps2RecompiledFunctionTable[259605] = bhEne22_DG00_0x1fd710; // 0x1fd85c - g_ps2RecompiledFunctionTable[259610] = bhEne22_DG01_0x1fd870; // 0x1fd870 - g_ps2RecompiledFunctionTable[259630] = bhEne22_DG01_0x1fd870; // 0x1fd8c0 - g_ps2RecompiledFunctionTable[259632] = bhEne22_DG01_0x1fd870; // 0x1fd8c8 - g_ps2RecompiledFunctionTable[259650] = bhEne22_DG01_0x1fd870; // 0x1fd910 - g_ps2RecompiledFunctionTable[259659] = bhEne22_DG01_0x1fd870; // 0x1fd934 - g_ps2RecompiledFunctionTable[259661] = bhEne22_DG01_0x1fd870; // 0x1fd93c - g_ps2RecompiledFunctionTable[259679] = bhEne22_DG01_0x1fd870; // 0x1fd984 - g_ps2RecompiledFunctionTable[259706] = bhEne22_DG02_0x1fd9f0; // 0x1fd9f0 - g_ps2RecompiledFunctionTable[259710] = bhEne22_DDType00_0x1fda00; // 0x1fda00 - g_ps2RecompiledFunctionTable[259711] = bhEne22_DDType00_0x1fda00; // 0x1fda04 - g_ps2RecompiledFunctionTable[259712] = bhEne22_DDType00_0x1fda00; // 0x1fda08 - g_ps2RecompiledFunctionTable[259713] = bhEne22_DDType00_0x1fda00; // 0x1fda0c - g_ps2RecompiledFunctionTable[259714] = bhEne22_DDType00_0x1fda00; // 0x1fda10 - g_ps2RecompiledFunctionTable[259715] = bhEne22_DDType00_0x1fda00; // 0x1fda14 - g_ps2RecompiledFunctionTable[259716] = bhEne22_DDType00_0x1fda00; // 0x1fda18 - g_ps2RecompiledFunctionTable[259717] = bhEne22_DDType00_0x1fda00; // 0x1fda1c - g_ps2RecompiledFunctionTable[259718] = bhEne22_DD00_0x1fda20; // 0x1fda20 - g_ps2RecompiledFunctionTable[259741] = bhEne22_DD00_0x1fda20; // 0x1fda7c - g_ps2RecompiledFunctionTable[259747] = bhEne22_DD00_0x1fda20; // 0x1fda94 - g_ps2RecompiledFunctionTable[259778] = bhEne22_DD00_0x1fda20; // 0x1fdb10 - g_ps2RecompiledFunctionTable[259794] = bhEne22_DD00_0x1fda20; // 0x1fdb50 - g_ps2RecompiledFunctionTable[259802] = bhEne22_DD01_0x1fdb70; // 0x1fdb70 - g_ps2RecompiledFunctionTable[259806] = bhEne22_PlyDG00_0x1fdb80; // 0x1fdb80 - g_ps2RecompiledFunctionTable[259856] = bhEne22_PlyDG00_0x1fdb80; // 0x1fdc48 - g_ps2RecompiledFunctionTable[259865] = bhEne22_PlyDG00_0x1fdb80; // 0x1fdc6c - g_ps2RecompiledFunctionTable[259868] = bhEne22_PlyDG00_0x1fdb80; // 0x1fdc78 - g_ps2RecompiledFunctionTable[259884] = bhEne22_PlyDG00_0x1fdb80; // 0x1fdcb8 - g_ps2RecompiledFunctionTable[259930] = bhEne22_PlyDG01_0x1fdd70; // 0x1fdd70 - g_ps2RecompiledFunctionTable[259992] = bhEne22_PlyDG01_0x1fdd70; // 0x1fde68 - g_ps2RecompiledFunctionTable[260001] = bhEne22_PlyDG01_0x1fdd70; // 0x1fde8c - g_ps2RecompiledFunctionTable[260006] = bhEne22_PlyDG01_0x1fdd70; // 0x1fdea0 - g_ps2RecompiledFunctionTable[260013] = bhEne22_PlyDG01_0x1fdd70; // 0x1fdebc - g_ps2RecompiledFunctionTable[260018] = bhEne22_PlyDG01_0x1fdd70; // 0x1fded0 - g_ps2RecompiledFunctionTable[260024] = bhEne22_PlyDG01_0x1fdd70; // 0x1fdee8 - g_ps2RecompiledFunctionTable[260026] = bhEne22_PlyDG01_0x1fdd70; // 0x1fdef0 - g_ps2RecompiledFunctionTable[260078] = bhEne22_PlyDG01_0x1fdd70; // 0x1fdfc0 - g_ps2RecompiledFunctionTable[260086] = bhEne22_PlyDG01_0x1fdd70; // 0x1fdfe0 - g_ps2RecompiledFunctionTable[260168] = bhEne22_PlyDG01_0x1fdd70; // 0x1fe128 - g_ps2RecompiledFunctionTable[260173] = bhEne22_PlyDG01_0x1fdd70; // 0x1fe13c - g_ps2RecompiledFunctionTable[260178] = bhEne22_PlyDG01_0x1fdd70; // 0x1fe150 - g_ps2RecompiledFunctionTable[260182] = bhEne22_PlyDG01_0x1fdd70; // 0x1fe160 - g_ps2RecompiledFunctionTable[260190] = bhEne22_SetMtn_0x1fe180; // 0x1fe180 - g_ps2RecompiledFunctionTable[260208] = bhEne22_SetMtn_0x1fe180; // 0x1fe1c8 - g_ps2RecompiledFunctionTable[260234] = bhEne22_SetMtn_0x1fe180; // 0x1fe230 - g_ps2RecompiledFunctionTable[260247] = bhEne22_SetMtn_0x1fe180; // 0x1fe264 - g_ps2RecompiledFunctionTable[260254] = bhEne22_SetMtn_0x1fe180; // 0x1fe280 - g_ps2RecompiledFunctionTable[260257] = bhEne22_SetMtn_0x1fe180; // 0x1fe28c - g_ps2RecompiledFunctionTable[260266] = bhEne22_CheckMtnTbl_0x1fe2b0; // 0x1fe2b0 - g_ps2RecompiledFunctionTable[260286] = bhEne22_CheckMtnTbl_0x1fe2b0; // 0x1fe300 - g_ps2RecompiledFunctionTable[260292] = bhEne22_CheckMtnTbl_0x1fe2b0; // 0x1fe318 - g_ps2RecompiledFunctionTable[260302] = bhEne22_CheckMtnTbl_0x1fe2b0; // 0x1fe340 - g_ps2RecompiledFunctionTable[260322] = bhEne22_GetTranslateMtn_0x1fe390; // 0x1fe390 - g_ps2RecompiledFunctionTable[260401] = bhEne22_GetTranslateMtn_0x1fe390; // 0x1fe4cc - g_ps2RecompiledFunctionTable[260406] = bhEne22_GetTranslateMtn_0x1fe390; // 0x1fe4e0 - g_ps2RecompiledFunctionTable[260411] = bhEne22_GetTranslateMtn_0x1fe390; // 0x1fe4f4 - g_ps2RecompiledFunctionTable[260415] = bhEne22_GetTranslateMtn_0x1fe390; // 0x1fe504 - g_ps2RecompiledFunctionTable[260422] = bhEne22_SparkEffect_0x1fe520; // 0x1fe520 - g_ps2RecompiledFunctionTable[260446] = bhEne22_SparkEffect_0x1fe520; // 0x1fe580 - g_ps2RecompiledFunctionTable[260454] = bhEne22_SparkEffect_0x1fe520; // 0x1fe5a0 - g_ps2RecompiledFunctionTable[260461] = bhEne22_SparkEffect_0x1fe520; // 0x1fe5bc - g_ps2RecompiledFunctionTable[260465] = bhEne22_SparkEffect_0x1fe520; // 0x1fe5cc - g_ps2RecompiledFunctionTable[260479] = bhEne22_SparkEffect_0x1fe520; // 0x1fe604 - g_ps2RecompiledFunctionTable[260484] = bhEne22_SparkEffect_0x1fe520; // 0x1fe618 - g_ps2RecompiledFunctionTable[260491] = bhEne22_SparkEffect_0x1fe520; // 0x1fe634 - g_ps2RecompiledFunctionTable[260497] = bhEne22_SparkEffect_0x1fe520; // 0x1fe64c - g_ps2RecompiledFunctionTable[260524] = bhEne22_SparkEffect_0x1fe520; // 0x1fe6b8 - g_ps2RecompiledFunctionTable[260528] = bhEne22_SparkEffect_0x1fe520; // 0x1fe6c8 - g_ps2RecompiledFunctionTable[260562] = bhEne22_SparkEffect_0x1fe520; // 0x1fe750 - g_ps2RecompiledFunctionTable[260566] = bhEne22_SparkEffect_0x1fe520; // 0x1fe760 - g_ps2RecompiledFunctionTable[260587] = bhEne22_SparkEffect_0x1fe520; // 0x1fe7b4 - g_ps2RecompiledFunctionTable[260605] = bhEne22_SparkEffect_0x1fe520; // 0x1fe7fc - g_ps2RecompiledFunctionTable[260612] = bhEne22_SparkEffect_0x1fe520; // 0x1fe818 - g_ps2RecompiledFunctionTable[260618] = bhEne22_SparkEffect_0x1fe520; // 0x1fe830 - g_ps2RecompiledFunctionTable[260625] = bhEne22_SparkEffect_0x1fe520; // 0x1fe84c - g_ps2RecompiledFunctionTable[260642] = bhEne22_GetDengekiColorAddr_0x1fe890; // 0x1fe890 - g_ps2RecompiledFunctionTable[260648] = bhEne22_GetDengekiColorAddr_0x1fe890; // 0x1fe8a8 - g_ps2RecompiledFunctionTable[260698] = bhEne22_SetWaterEffect_0x1fe970; // 0x1fe970 - g_ps2RecompiledFunctionTable[260711] = bhEne22_SetWaterEffect_0x1fe970; // 0x1fe9a4 - g_ps2RecompiledFunctionTable[260741] = bhEne22_SetWaterEffect_0x1fe970; // 0x1fea1c - g_ps2RecompiledFunctionTable[260748] = bhEne22_SetWaterEffect_0x1fe970; // 0x1fea38 - g_ps2RecompiledFunctionTable[260759] = bhEne22_SetWaterEffect_0x1fe970; // 0x1fea64 - g_ps2RecompiledFunctionTable[260782] = bhEne22_SetWaterEffect_0x1fe970; // 0x1feac0 - g_ps2RecompiledFunctionTable[260794] = bhEne22_GetAreaNo_0x1feaf0; // 0x1feaf0 - g_ps2RecompiledFunctionTable[260814] = bhEne22_GetAreaNo_0x1feaf0; // 0x1feb40 - g_ps2RecompiledFunctionTable[260821] = bhEne22_GetAreaNo_0x1feaf0; // 0x1feb5c - g_ps2RecompiledFunctionTable[260838] = bhEne22_AreaCheck_0x1feba0; // 0x1feba0 - g_ps2RecompiledFunctionTable[260846] = bhEne22_AreaCheck_0x1feba0; // 0x1febc0 - g_ps2RecompiledFunctionTable[260850] = bhEne22_AreaCheck_0x1feba0; // 0x1febd0 - g_ps2RecompiledFunctionTable[260862] = bhEne22_SetTrgPos_0x1fec00; // 0x1fec00 - g_ps2RecompiledFunctionTable[260889] = bhEne22_SetTrgPos_0x1fec00; // 0x1fec6c - g_ps2RecompiledFunctionTable[260895] = bhEne22_SetTrgPos_0x1fec00; // 0x1fec84 - g_ps2RecompiledFunctionTable[260908] = bhEne22_SetTrgPos_0x1fec00; // 0x1fecb8 - g_ps2RecompiledFunctionTable[260931] = bhEne22_SetTrgPos_0x1fec00; // 0x1fed14 - g_ps2RecompiledFunctionTable[260978] = bhEne22_SePlay_0x1fedd0; // 0x1fedd0 - g_ps2RecompiledFunctionTable[260991] = bhEne22_SePlay_0x1fedd0; // 0x1fee04 - g_ps2RecompiledFunctionTable[260994] = bhEne22_SetDengekiEffect_0x1fee10; // 0x1fee10 - g_ps2RecompiledFunctionTable[261065] = bhEne22_SetDengekiEffect_0x1fee10; // 0x1fef2c - g_ps2RecompiledFunctionTable[261090] = bhEne22_SetDengekiEffect_0x1fee10; // 0x1fef90 - g_ps2RecompiledFunctionTable[261134] = bhEne22_SetDengekiEffect2_0x1ff040; // 0x1ff040 - g_ps2RecompiledFunctionTable[261215] = bhEne22_SetDengekiEffect2_0x1ff040; // 0x1ff184 - g_ps2RecompiledFunctionTable[261224] = bhEne22_SetDengekiEffect2_0x1ff040; // 0x1ff1a8 - g_ps2RecompiledFunctionTable[261233] = bhEne22_SetDengekiEffect2_0x1ff040; // 0x1ff1cc - g_ps2RecompiledFunctionTable[261253] = bhEne22_SetDengekiEffect2_0x1ff040; // 0x1ff21c - g_ps2RecompiledFunctionTable[261286] = bhEne22_SetElectricShockEffect_0x1ff2a0; // 0x1ff2a0 - g_ps2RecompiledFunctionTable[261297] = bhEne22_SetElectricShockEffect_0x1ff2a0; // 0x1ff2cc - g_ps2RecompiledFunctionTable[261309] = bhEne22_SetElectricShockEffect_0x1ff2a0; // 0x1ff2fc - g_ps2RecompiledFunctionTable[261321] = bhEne22_SetElectricShockEffect_0x1ff2a0; // 0x1ff32c - g_ps2RecompiledFunctionTable[261325] = bhEne22_SetElectricShockEffect_0x1ff2a0; // 0x1ff33c - g_ps2RecompiledFunctionTable[261328] = bhEne22_SetElectricShockEffect_0x1ff2a0; // 0x1ff348 - g_ps2RecompiledFunctionTable[261331] = bhEne22_SetElectricShockEffect_0x1ff2a0; // 0x1ff354 - g_ps2RecompiledFunctionTable[261335] = bhEne22_SetElectricShockEffect_0x1ff2a0; // 0x1ff364 - g_ps2RecompiledFunctionTable[261337] = bhEne22_SetElectricShockEffect_0x1ff2a0; // 0x1ff36c - g_ps2RecompiledFunctionTable[261343] = bhEne22_SetElectricShockEffect_0x1ff2a0; // 0x1ff384 - g_ps2RecompiledFunctionTable[261360] = bhEne22_SetElectricShockEffect_0x1ff2a0; // 0x1ff3c8 - g_ps2RecompiledFunctionTable[261367] = bhEne22_SetElectricShockEffect_0x1ff2a0; // 0x1ff3e4 - g_ps2RecompiledFunctionTable[261369] = bhEne22_SetElectricShockEffect_0x1ff2a0; // 0x1ff3ec - g_ps2RecompiledFunctionTable[261381] = bhEne22_SetElectricShockEffect_0x1ff2a0; // 0x1ff41c - g_ps2RecompiledFunctionTable[261393] = bhEne22_SetElectricShockEffect_0x1ff2a0; // 0x1ff44c - g_ps2RecompiledFunctionTable[261397] = bhEne22_SetElectricShockEffect_0x1ff2a0; // 0x1ff45c - g_ps2RecompiledFunctionTable[261400] = bhEne22_SetElectricShockEffect_0x1ff2a0; // 0x1ff468 - g_ps2RecompiledFunctionTable[261403] = bhEne22_SetElectricShockEffect_0x1ff2a0; // 0x1ff474 - g_ps2RecompiledFunctionTable[261407] = bhEne22_SetElectricShockEffect_0x1ff2a0; // 0x1ff484 - g_ps2RecompiledFunctionTable[261409] = bhEne22_SetElectricShockEffect_0x1ff2a0; // 0x1ff48c - g_ps2RecompiledFunctionTable[261415] = bhEne22_SetElectricShockEffect_0x1ff2a0; // 0x1ff4a4 - g_ps2RecompiledFunctionTable[261432] = bhEne22_SetElectricShockEffect_0x1ff2a0; // 0x1ff4e8 - g_ps2RecompiledFunctionTable[261448] = bhEne22_SetElectricShockEffect_0x1ff2a0; // 0x1ff528 - g_ps2RecompiledFunctionTable[261457] = bhEne22_SetElectricShockEffect_0x1ff2a0; // 0x1ff54c - g_ps2RecompiledFunctionTable[261467] = bhEne22_SetElectricShockEffect_0x1ff2a0; // 0x1ff574 - g_ps2RecompiledFunctionTable[261469] = bhEne22_SetElectricShockEffect_0x1ff2a0; // 0x1ff57c - g_ps2RecompiledFunctionTable[261481] = bhEne22_SetElectricShockEffect_0x1ff2a0; // 0x1ff5ac - g_ps2RecompiledFunctionTable[261493] = bhEne22_SetElectricShockEffect_0x1ff2a0; // 0x1ff5dc - g_ps2RecompiledFunctionTable[261497] = bhEne22_SetElectricShockEffect_0x1ff2a0; // 0x1ff5ec - g_ps2RecompiledFunctionTable[261500] = bhEne22_SetElectricShockEffect_0x1ff2a0; // 0x1ff5f8 - g_ps2RecompiledFunctionTable[261503] = bhEne22_SetElectricShockEffect_0x1ff2a0; // 0x1ff604 - g_ps2RecompiledFunctionTable[261507] = bhEne22_SetElectricShockEffect_0x1ff2a0; // 0x1ff614 - g_ps2RecompiledFunctionTable[261509] = bhEne22_SetElectricShockEffect_0x1ff2a0; // 0x1ff61c - g_ps2RecompiledFunctionTable[261515] = bhEne22_SetElectricShockEffect_0x1ff2a0; // 0x1ff634 - g_ps2RecompiledFunctionTable[261532] = bhEne22_SetElectricShockEffect_0x1ff2a0; // 0x1ff678 - g_ps2RecompiledFunctionTable[261550] = bhEne22_SetElectricShockEffect2_0x1ff6c0; // 0x1ff6c0 - g_ps2RecompiledFunctionTable[261570] = bhEne22_SetElectricShockEffect2_0x1ff6c0; // 0x1ff710 - g_ps2RecompiledFunctionTable[261573] = bhEne22_SetElectricShockEffect2_0x1ff6c0; // 0x1ff71c - g_ps2RecompiledFunctionTable[261585] = bhEne22_SetElectricShockEffect2_0x1ff6c0; // 0x1ff74c - g_ps2RecompiledFunctionTable[261589] = bhEne22_SetElectricShockEffect2_0x1ff6c0; // 0x1ff75c - g_ps2RecompiledFunctionTable[261591] = bhEne22_SetElectricShockEffect2_0x1ff6c0; // 0x1ff764 - g_ps2RecompiledFunctionTable[261593] = bhEne22_SetElectricShockEffect2_0x1ff6c0; // 0x1ff76c - g_ps2RecompiledFunctionTable[261605] = bhEne22_SetElectricShockEffect2_0x1ff6c0; // 0x1ff79c - g_ps2RecompiledFunctionTable[261609] = bhEne22_SetElectricShockEffect2_0x1ff6c0; // 0x1ff7ac - g_ps2RecompiledFunctionTable[261611] = bhEne22_SetElectricShockEffect2_0x1ff6c0; // 0x1ff7b4 - g_ps2RecompiledFunctionTable[261619] = bhEne22_SetElectricShockEffect2_0x1ff6c0; // 0x1ff7d4 - g_ps2RecompiledFunctionTable[261642] = bhEne22_SetElectricLightEffect_0x1ff830; // 0x1ff830 - g_ps2RecompiledFunctionTable[261714] = bhEne22_SetElectricLightEffect_0x1ff830; // 0x1ff950 - g_ps2RecompiledFunctionTable[261754] = bhEne22_SetLight_0x1ff9f0; // 0x1ff9f0 - g_ps2RecompiledFunctionTable[261814] = bhEne22_CtrLight_0x1ffae0; // 0x1ffae0 - g_ps2RecompiledFunctionTable[261864] = bhEne22_CtrLight_0x1ffae0; // 0x1ffba8 - g_ps2RecompiledFunctionTable[261904] = bhEne22_CtrLight_0x1ffae0; // 0x1ffc48 - g_ps2RecompiledFunctionTable[261962] = bhEne22_CtrLight_0x1ffae0; // 0x1ffd30 - g_ps2RecompiledFunctionTable[261998] = bhEne22_ChgDengekiColor_0x1ffdc0; // 0x1ffdc0 - g_ps2RecompiledFunctionTable[262015] = bhEne22_ChgDengekiColor_0x1ffdc0; // 0x1ffe04 - g_ps2RecompiledFunctionTable[262094] = bhEne23_0x1fff40; // 0x1fff40 - g_ps2RecompiledFunctionTable[262095] = bhEne23_0x1fff40; // 0x1fff44 - g_ps2RecompiledFunctionTable[262096] = bhEne23_0x1fff40; // 0x1fff48 - g_ps2RecompiledFunctionTable[262097] = bhEne23_0x1fff40; // 0x1fff4c - g_ps2RecompiledFunctionTable[262098] = bhEne23_0x1fff40; // 0x1fff50 - g_ps2RecompiledFunctionTable[262099] = bhEne23_0x1fff40; // 0x1fff54 - g_ps2RecompiledFunctionTable[262100] = bhEne23_0x1fff40; // 0x1fff58 - g_ps2RecompiledFunctionTable[262101] = bhEne23_0x1fff40; // 0x1fff5c - g_ps2RecompiledFunctionTable[262102] = bhEne23_0x1fff40; // 0x1fff60 - g_ps2RecompiledFunctionTable[262103] = bhEne23_0x1fff40; // 0x1fff64 - g_ps2RecompiledFunctionTable[262104] = bhEne23_0x1fff40; // 0x1fff68 - g_ps2RecompiledFunctionTable[262105] = bhEne23_0x1fff40; // 0x1fff6c - g_ps2RecompiledFunctionTable[262106] = bhEne23_0x1fff40; // 0x1fff70 - g_ps2RecompiledFunctionTable[262107] = bhEne23_0x1fff40; // 0x1fff74 - g_ps2RecompiledFunctionTable[262108] = bhEne23_0x1fff40; // 0x1fff78 - g_ps2RecompiledFunctionTable[262109] = bhEne23_0x1fff40; // 0x1fff7c - g_ps2RecompiledFunctionTable[262110] = bhEne23_0x1fff40; // 0x1fff80 - g_ps2RecompiledFunctionTable[262111] = bhEne23_0x1fff40; // 0x1fff84 - g_ps2RecompiledFunctionTable[262112] = bhEne23_0x1fff40; // 0x1fff88 - g_ps2RecompiledFunctionTable[262113] = bhEne23_0x1fff40; // 0x1fff8c - g_ps2RecompiledFunctionTable[262114] = bhEne23_0x1fff40; // 0x1fff90 - g_ps2RecompiledFunctionTable[262115] = bhEne23_0x1fff40; // 0x1fff94 - g_ps2RecompiledFunctionTable[262116] = bhEne23_0x1fff40; // 0x1fff98 - g_ps2RecompiledFunctionTable[262117] = bhEne23_0x1fff40; // 0x1fff9c - g_ps2RecompiledFunctionTable[262118] = bhEne23_0x1fff40; // 0x1fffa0 - g_ps2RecompiledFunctionTable[262119] = bhEne23_0x1fff40; // 0x1fffa4 - g_ps2RecompiledFunctionTable[262120] = bhEne23_0x1fff40; // 0x1fffa8 - g_ps2RecompiledFunctionTable[262121] = bhEne23_0x1fff40; // 0x1fffac - g_ps2RecompiledFunctionTable[262122] = bhEne23_0x1fff40; // 0x1fffb0 - g_ps2RecompiledFunctionTable[262123] = bhEne23_0x1fff40; // 0x1fffb4 - g_ps2RecompiledFunctionTable[262124] = bhEne23_0x1fff40; // 0x1fffb8 - g_ps2RecompiledFunctionTable[262125] = bhEne23_0x1fff40; // 0x1fffbc - g_ps2RecompiledFunctionTable[262126] = bhEne23_0x1fff40; // 0x1fffc0 - g_ps2RecompiledFunctionTable[262127] = bhEne23_0x1fff40; // 0x1fffc4 - g_ps2RecompiledFunctionTable[262128] = bhEne23_0x1fff40; // 0x1fffc8 - g_ps2RecompiledFunctionTable[262129] = bhEne23_0x1fff40; // 0x1fffcc - g_ps2RecompiledFunctionTable[262130] = bhEne23_0x1fff40; // 0x1fffd0 - g_ps2RecompiledFunctionTable[262131] = bhEne23_0x1fff40; // 0x1fffd4 - g_ps2RecompiledFunctionTable[262132] = bhEne23_0x1fff40; // 0x1fffd8 - g_ps2RecompiledFunctionTable[262133] = bhEne23_0x1fff40; // 0x1fffdc - g_ps2RecompiledFunctionTable[262134] = bhEne23_0x1fff40; // 0x1fffe0 - g_ps2RecompiledFunctionTable[262135] = bhEne23_0x1fff40; // 0x1fffe4 - g_ps2RecompiledFunctionTable[262136] = bhEne23_0x1fff40; // 0x1fffe8 - g_ps2RecompiledFunctionTable[262137] = bhEne23_0x1fff40; // 0x1fffec - g_ps2RecompiledFunctionTable[262138] = bhEne23_0x1fff40; // 0x1ffff0 - g_ps2RecompiledFunctionTable[262139] = bhEne23_0x1fff40; // 0x1ffff4 - g_ps2RecompiledFunctionTable[262140] = bhEne23_0x1fff40; // 0x1ffff8 - g_ps2RecompiledFunctionTable[262141] = bhEne23_0x1fff40; // 0x1ffffc - g_ps2RecompiledFunctionTable[262142] = bhEne23_0x1fff40; // 0x200000 - g_ps2RecompiledFunctionTable[262143] = bhEne23_0x1fff40; // 0x200004 - g_ps2RecompiledFunctionTable[262144] = bhEne23_0x1fff40; // 0x200008 - g_ps2RecompiledFunctionTable[262145] = bhEne23_0x1fff40; // 0x20000c - g_ps2RecompiledFunctionTable[262146] = bhEne23_0x1fff40; // 0x200010 - g_ps2RecompiledFunctionTable[262147] = bhEne23_0x1fff40; // 0x200014 - g_ps2RecompiledFunctionTable[262148] = bhEne23_0x1fff40; // 0x200018 - g_ps2RecompiledFunctionTable[262149] = bhEne23_0x1fff40; // 0x20001c - g_ps2RecompiledFunctionTable[262150] = bhEne23_0x1fff40; // 0x200020 - g_ps2RecompiledFunctionTable[262151] = bhEne23_0x1fff40; // 0x200024 - g_ps2RecompiledFunctionTable[262152] = bhEne23_0x1fff40; // 0x200028 - g_ps2RecompiledFunctionTable[262153] = bhEne23_0x1fff40; // 0x20002c - g_ps2RecompiledFunctionTable[262154] = bhEne23_0x1fff40; // 0x200030 - g_ps2RecompiledFunctionTable[262155] = bhEne23_0x1fff40; // 0x200034 - g_ps2RecompiledFunctionTable[262156] = bhEne23_0x1fff40; // 0x200038 - g_ps2RecompiledFunctionTable[262157] = bhEne23_0x1fff40; // 0x20003c - g_ps2RecompiledFunctionTable[262158] = bhEne23_0x1fff40; // 0x200040 - g_ps2RecompiledFunctionTable[262159] = bhEne23_0x1fff40; // 0x200044 - g_ps2RecompiledFunctionTable[262160] = bhEne23_0x1fff40; // 0x200048 - g_ps2RecompiledFunctionTable[262161] = bhEne23_0x1fff40; // 0x20004c - g_ps2RecompiledFunctionTable[262162] = bhEne23_0x1fff40; // 0x200050 - g_ps2RecompiledFunctionTable[262163] = bhEne23_0x1fff40; // 0x200054 - g_ps2RecompiledFunctionTable[262164] = bhEne23_0x1fff40; // 0x200058 - g_ps2RecompiledFunctionTable[262165] = bhEne23_0x1fff40; // 0x20005c - g_ps2RecompiledFunctionTable[262166] = bhEne23_0x1fff40; // 0x200060 - g_ps2RecompiledFunctionTable[262167] = bhEne23_0x1fff40; // 0x200064 - g_ps2RecompiledFunctionTable[262168] = bhEne23_0x1fff40; // 0x200068 - g_ps2RecompiledFunctionTable[262169] = bhEne23_0x1fff40; // 0x20006c - g_ps2RecompiledFunctionTable[262170] = bhEne23_0x1fff40; // 0x200070 - g_ps2RecompiledFunctionTable[262171] = bhEne23_0x1fff40; // 0x200074 - g_ps2RecompiledFunctionTable[262172] = bhEne23_0x1fff40; // 0x200078 - g_ps2RecompiledFunctionTable[262173] = bhEne23_0x1fff40; // 0x20007c - g_ps2RecompiledFunctionTable[262174] = bhEne23_0x1fff40; // 0x200080 - g_ps2RecompiledFunctionTable[262175] = bhEne23_0x1fff40; // 0x200084 - g_ps2RecompiledFunctionTable[262176] = bhEne23_0x1fff40; // 0x200088 - g_ps2RecompiledFunctionTable[262177] = bhEne23_0x1fff40; // 0x20008c - g_ps2RecompiledFunctionTable[262178] = bhEne23_0x1fff40; // 0x200090 - g_ps2RecompiledFunctionTable[262179] = bhEne23_0x1fff40; // 0x200094 - g_ps2RecompiledFunctionTable[262180] = bhEne23_0x1fff40; // 0x200098 - g_ps2RecompiledFunctionTable[262181] = bhEne23_0x1fff40; // 0x20009c - g_ps2RecompiledFunctionTable[262182] = bhEne23_0x1fff40; // 0x2000a0 - g_ps2RecompiledFunctionTable[262183] = bhEne23_0x1fff40; // 0x2000a4 - g_ps2RecompiledFunctionTable[262184] = bhEne23_0x1fff40; // 0x2000a8 - g_ps2RecompiledFunctionTable[262185] = bhEne23_0x1fff40; // 0x2000ac - g_ps2RecompiledFunctionTable[262186] = bhEne23_0x1fff40; // 0x2000b0 - g_ps2RecompiledFunctionTable[262187] = bhEne23_0x1fff40; // 0x2000b4 - g_ps2RecompiledFunctionTable[262188] = bhEne23_0x1fff40; // 0x2000b8 - g_ps2RecompiledFunctionTable[262189] = bhEne23_0x1fff40; // 0x2000bc - g_ps2RecompiledFunctionTable[262190] = bhEne23_0x1fff40; // 0x2000c0 - g_ps2RecompiledFunctionTable[262191] = bhEne23_0x1fff40; // 0x2000c4 - g_ps2RecompiledFunctionTable[262192] = bhEne23_0x1fff40; // 0x2000c8 - g_ps2RecompiledFunctionTable[262193] = bhEne23_0x1fff40; // 0x2000cc - g_ps2RecompiledFunctionTable[262194] = bhEne23_0x1fff40; // 0x2000d0 - g_ps2RecompiledFunctionTable[262195] = bhEne23_0x1fff40; // 0x2000d4 - g_ps2RecompiledFunctionTable[262196] = bhEne23_0x1fff40; // 0x2000d8 - g_ps2RecompiledFunctionTable[262197] = bhEne23_0x1fff40; // 0x2000dc - g_ps2RecompiledFunctionTable[262198] = bhEne23_0x1fff40; // 0x2000e0 - g_ps2RecompiledFunctionTable[262199] = bhEne23_0x1fff40; // 0x2000e4 - g_ps2RecompiledFunctionTable[262200] = bhEne23_0x1fff40; // 0x2000e8 - g_ps2RecompiledFunctionTable[262201] = bhEne23_0x1fff40; // 0x2000ec - g_ps2RecompiledFunctionTable[262202] = bhEne23_0x1fff40; // 0x2000f0 - g_ps2RecompiledFunctionTable[262203] = bhEne23_0x1fff40; // 0x2000f4 - g_ps2RecompiledFunctionTable[262204] = bhEne23_0x1fff40; // 0x2000f8 - g_ps2RecompiledFunctionTable[262205] = bhEne23_0x1fff40; // 0x2000fc - g_ps2RecompiledFunctionTable[262206] = bhEne23_0x1fff40; // 0x200100 - g_ps2RecompiledFunctionTable[262207] = bhEne23_0x1fff40; // 0x200104 - g_ps2RecompiledFunctionTable[262208] = bhEne23_0x1fff40; // 0x200108 - g_ps2RecompiledFunctionTable[262209] = bhEne23_0x1fff40; // 0x20010c - g_ps2RecompiledFunctionTable[262210] = bhEne23_0x1fff40; // 0x200110 - g_ps2RecompiledFunctionTable[262211] = bhEne23_0x1fff40; // 0x200114 - g_ps2RecompiledFunctionTable[262212] = bhEne23_0x1fff40; // 0x200118 - g_ps2RecompiledFunctionTable[262213] = bhEne23_0x1fff40; // 0x20011c - g_ps2RecompiledFunctionTable[262214] = bhEne23_0x1fff40; // 0x200120 - g_ps2RecompiledFunctionTable[262215] = bhEne23_0x1fff40; // 0x200124 - g_ps2RecompiledFunctionTable[262216] = bhEne23_0x1fff40; // 0x200128 - g_ps2RecompiledFunctionTable[262217] = bhEne23_0x1fff40; // 0x20012c - g_ps2RecompiledFunctionTable[262218] = bhEne23_0x1fff40; // 0x200130 - g_ps2RecompiledFunctionTable[262219] = bhEne23_0x1fff40; // 0x200134 - g_ps2RecompiledFunctionTable[262220] = bhEne23_0x1fff40; // 0x200138 - g_ps2RecompiledFunctionTable[262221] = bhEne23_0x1fff40; // 0x20013c - g_ps2RecompiledFunctionTable[262222] = bhEne23_0x1fff40; // 0x200140 - g_ps2RecompiledFunctionTable[262223] = bhEne23_0x1fff40; // 0x200144 - g_ps2RecompiledFunctionTable[262224] = bhEne23_0x1fff40; // 0x200148 - g_ps2RecompiledFunctionTable[262225] = bhEne23_0x1fff40; // 0x20014c - g_ps2RecompiledFunctionTable[262226] = bhEne23_0x1fff40; // 0x200150 - g_ps2RecompiledFunctionTable[262230] = bhEne23_Init_0x200160; // 0x200160 - g_ps2RecompiledFunctionTable[262266] = bhEne23_Init_0x200160; // 0x2001f0 - g_ps2RecompiledFunctionTable[262277] = bhEne23_Init_0x200160; // 0x20021c - g_ps2RecompiledFunctionTable[262283] = bhEne23_Init_0x200160; // 0x200234 - g_ps2RecompiledFunctionTable[262289] = bhEne23_Init_0x200160; // 0x20024c - g_ps2RecompiledFunctionTable[262308] = bhEne23_Init_0x200160; // 0x200298 - g_ps2RecompiledFunctionTable[262321] = bhEne23_Init_0x200160; // 0x2002cc - g_ps2RecompiledFunctionTable[262349] = bhEne23_Init_0x200160; // 0x20033c - g_ps2RecompiledFunctionTable[262353] = bhEne23_Init_0x200160; // 0x20034c - g_ps2RecompiledFunctionTable[262366] = bhEne23_Init_0x200160; // 0x200380 - g_ps2RecompiledFunctionTable[262424] = bhEne23_Init_0x200160; // 0x200468 - g_ps2RecompiledFunctionTable[262457] = bhEne23_Init_0x200160; // 0x2004ec - g_ps2RecompiledFunctionTable[262466] = bhEne23_Init_0x200160; // 0x200510 - g_ps2RecompiledFunctionTable[262469] = bhEne23_Init_0x200160; // 0x20051c - g_ps2RecompiledFunctionTable[262492] = bhEne23_Init_0x200160; // 0x200578 - g_ps2RecompiledFunctionTable[262499] = bhEne23_Init_0x200160; // 0x200594 - g_ps2RecompiledFunctionTable[262526] = bhEne23_Init_0x200160; // 0x200600 - g_ps2RecompiledFunctionTable[262563] = bhEne23_Init_0x200160; // 0x200694 - g_ps2RecompiledFunctionTable[262620] = bhEne23_Init_0x200160; // 0x200778 - g_ps2RecompiledFunctionTable[262628] = bhEne23_Init_0x200160; // 0x200798 - g_ps2RecompiledFunctionTable[262632] = bhEne23_Init_0x200160; // 0x2007a8 - g_ps2RecompiledFunctionTable[262662] = bhEne23_Brain_0x200820; // 0x200820 - g_ps2RecompiledFunctionTable[262663] = bhEne23_Brain_0x200820; // 0x200824 - g_ps2RecompiledFunctionTable[262664] = bhEne23_Brain_0x200820; // 0x200828 - g_ps2RecompiledFunctionTable[262665] = bhEne23_Brain_0x200820; // 0x20082c - g_ps2RecompiledFunctionTable[262666] = bhEne23_Brain_0x200820; // 0x200830 - g_ps2RecompiledFunctionTable[262667] = bhEne23_Brain_0x200820; // 0x200834 - g_ps2RecompiledFunctionTable[262668] = bhEne23_Brain_0x200820; // 0x200838 - g_ps2RecompiledFunctionTable[262669] = bhEne23_Brain_0x200820; // 0x20083c - g_ps2RecompiledFunctionTable[262670] = bhEne23_BR00_0x200840; // 0x200840 - g_ps2RecompiledFunctionTable[262685] = bhEne23_BR00_0x200840; // 0x20087c - g_ps2RecompiledFunctionTable[262690] = bhEne23_BR00_0x200840; // 0x200890 - g_ps2RecompiledFunctionTable[262745] = bhEne23_BR00_0x200840; // 0x20096c - g_ps2RecompiledFunctionTable[262752] = bhEne23_BR00_0x200840; // 0x200988 - g_ps2RecompiledFunctionTable[262766] = bhEne23_BR00_0x200840; // 0x2009c0 - g_ps2RecompiledFunctionTable[262779] = bhEne23_BR00_0x200840; // 0x2009f4 - g_ps2RecompiledFunctionTable[262793] = bhEne23_BR00_0x200840; // 0x200a2c - g_ps2RecompiledFunctionTable[262802] = bhEne23_BR00_0x200840; // 0x200a50 - g_ps2RecompiledFunctionTable[262815] = bhEne23_BR00_0x200840; // 0x200a84 - g_ps2RecompiledFunctionTable[262850] = bhEne23_BR00_0x200840; // 0x200b10 - g_ps2RecompiledFunctionTable[262859] = bhEne23_BR00_0x200840; // 0x200b34 - g_ps2RecompiledFunctionTable[262868] = bhEne23_BR00_0x200840; // 0x200b58 - g_ps2RecompiledFunctionTable[262881] = bhEne23_BR00_0x200840; // 0x200b8c - g_ps2RecompiledFunctionTable[262895] = bhEne23_BR00_0x200840; // 0x200bc4 - g_ps2RecompiledFunctionTable[262904] = bhEne23_BR00_0x200840; // 0x200be8 - g_ps2RecompiledFunctionTable[262917] = bhEne23_BR00_0x200840; // 0x200c1c - g_ps2RecompiledFunctionTable[262926] = bhEne23_BR01_0x200c40; // 0x200c40 - g_ps2RecompiledFunctionTable[262941] = bhEne23_BR01_0x200c40; // 0x200c7c - g_ps2RecompiledFunctionTable[262946] = bhEne23_BR01_0x200c40; // 0x200c90 - g_ps2RecompiledFunctionTable[263001] = bhEne23_BR01_0x200c40; // 0x200d6c - g_ps2RecompiledFunctionTable[263008] = bhEne23_BR01_0x200c40; // 0x200d88 - g_ps2RecompiledFunctionTable[263022] = bhEne23_BR01_0x200c40; // 0x200dc0 - g_ps2RecompiledFunctionTable[263035] = bhEne23_BR01_0x200c40; // 0x200df4 - g_ps2RecompiledFunctionTable[263070] = bhEne23_BR01_0x200c40; // 0x200e80 - g_ps2RecompiledFunctionTable[263079] = bhEne23_BR01_0x200c40; // 0x200ea4 - g_ps2RecompiledFunctionTable[263088] = bhEne23_BR01_0x200c40; // 0x200ec8 - g_ps2RecompiledFunctionTable[263101] = bhEne23_BR01_0x200c40; // 0x200efc - g_ps2RecompiledFunctionTable[263110] = bhEne23_Move_0x200f20; // 0x200f20 - g_ps2RecompiledFunctionTable[263111] = bhEne23_Move_0x200f20; // 0x200f24 - g_ps2RecompiledFunctionTable[263112] = bhEne23_Move_0x200f20; // 0x200f28 - g_ps2RecompiledFunctionTable[263113] = bhEne23_Move_0x200f20; // 0x200f2c - g_ps2RecompiledFunctionTable[263114] = bhEne23_Move_0x200f20; // 0x200f30 - g_ps2RecompiledFunctionTable[263115] = bhEne23_Move_0x200f20; // 0x200f34 - g_ps2RecompiledFunctionTable[263116] = bhEne23_Move_0x200f20; // 0x200f38 - g_ps2RecompiledFunctionTable[263117] = bhEne23_Move_0x200f20; // 0x200f3c - g_ps2RecompiledFunctionTable[263118] = bhEne23_Move_0x200f20; // 0x200f40 - g_ps2RecompiledFunctionTable[263119] = bhEne23_Move_0x200f20; // 0x200f44 - g_ps2RecompiledFunctionTable[263120] = bhEne23_Move_0x200f20; // 0x200f48 - g_ps2RecompiledFunctionTable[263121] = bhEne23_Move_0x200f20; // 0x200f4c - g_ps2RecompiledFunctionTable[263122] = bhEne23_Move_0x200f20; // 0x200f50 - g_ps2RecompiledFunctionTable[263123] = bhEne23_Move_0x200f20; // 0x200f54 - g_ps2RecompiledFunctionTable[263124] = bhEne23_Move_0x200f20; // 0x200f58 - g_ps2RecompiledFunctionTable[263125] = bhEne23_Move_0x200f20; // 0x200f5c - g_ps2RecompiledFunctionTable[263126] = bhEne23_Move_0x200f20; // 0x200f60 - g_ps2RecompiledFunctionTable[263127] = bhEne23_Move_0x200f20; // 0x200f64 - g_ps2RecompiledFunctionTable[263128] = bhEne23_Move_0x200f20; // 0x200f68 - g_ps2RecompiledFunctionTable[263129] = bhEne23_Move_0x200f20; // 0x200f6c - g_ps2RecompiledFunctionTable[263130] = bhEne23_Move_0x200f20; // 0x200f70 - g_ps2RecompiledFunctionTable[263131] = bhEne23_Move_0x200f20; // 0x200f74 - g_ps2RecompiledFunctionTable[263132] = bhEne23_Move_0x200f20; // 0x200f78 - g_ps2RecompiledFunctionTable[263133] = bhEne23_Move_0x200f20; // 0x200f7c - g_ps2RecompiledFunctionTable[263134] = bhEne23_Move_0x200f20; // 0x200f80 - g_ps2RecompiledFunctionTable[263135] = bhEne23_Move_0x200f20; // 0x200f84 - g_ps2RecompiledFunctionTable[263136] = bhEne23_Move_0x200f20; // 0x200f88 - g_ps2RecompiledFunctionTable[263137] = bhEne23_Move_0x200f20; // 0x200f8c - g_ps2RecompiledFunctionTable[263138] = bhEne23_Move_0x200f20; // 0x200f90 - g_ps2RecompiledFunctionTable[263139] = bhEne23_Move_0x200f20; // 0x200f94 - g_ps2RecompiledFunctionTable[263140] = bhEne23_Move_0x200f20; // 0x200f98 - g_ps2RecompiledFunctionTable[263141] = bhEne23_Move_0x200f20; // 0x200f9c - g_ps2RecompiledFunctionTable[263142] = bhEne23_Move_0x200f20; // 0x200fa0 - g_ps2RecompiledFunctionTable[263143] = bhEne23_Move_0x200f20; // 0x200fa4 - g_ps2RecompiledFunctionTable[263146] = bhEne23_MV00_0x200fb0; // 0x200fb0 - g_ps2RecompiledFunctionTable[263183] = bhEne23_MV00_0x200fb0; // 0x201044 - g_ps2RecompiledFunctionTable[263196] = bhEne23_MV00_0x200fb0; // 0x201078 - g_ps2RecompiledFunctionTable[263220] = bhEne23_MV00_0x200fb0; // 0x2010d8 - g_ps2RecompiledFunctionTable[263244] = bhEne23_MV00_0x200fb0; // 0x201138 - g_ps2RecompiledFunctionTable[263254] = bhEne23_MV01_0x201160; // 0x201160 - g_ps2RecompiledFunctionTable[263306] = bhEne23_MV01_0x201160; // 0x201230 - g_ps2RecompiledFunctionTable[263319] = bhEne23_MV01_0x201160; // 0x201264 - g_ps2RecompiledFunctionTable[263321] = bhEne23_MV01_0x201160; // 0x20126c - g_ps2RecompiledFunctionTable[263371] = bhEne23_MV01_0x201160; // 0x201334 - g_ps2RecompiledFunctionTable[263384] = bhEne23_MV01_0x201160; // 0x201368 - g_ps2RecompiledFunctionTable[263392] = bhEne23_MV01_0x201160; // 0x201388 - g_ps2RecompiledFunctionTable[263415] = bhEne23_MV01_0x201160; // 0x2013e4 - g_ps2RecompiledFunctionTable[263447] = bhEne23_MV01_0x201160; // 0x201464 - g_ps2RecompiledFunctionTable[263455] = bhEne23_MV01_0x201160; // 0x201484 - g_ps2RecompiledFunctionTable[263492] = bhEne23_MV01_0x201160; // 0x201518 - g_ps2RecompiledFunctionTable[263503] = bhEne23_MV01_0x201160; // 0x201544 - g_ps2RecompiledFunctionTable[263509] = bhEne23_MV01_0x201160; // 0x20155c - g_ps2RecompiledFunctionTable[263513] = bhEne23_MV01_0x201160; // 0x20156c - g_ps2RecompiledFunctionTable[263532] = bhEne23_MV01_0x201160; // 0x2015b8 - g_ps2RecompiledFunctionTable[263556] = bhEne23_MV01_0x201160; // 0x201618 - g_ps2RecompiledFunctionTable[263566] = bhEne23_MV02_0x201640; // 0x201640 - g_ps2RecompiledFunctionTable[263618] = bhEne23_MV02_0x201640; // 0x201710 - g_ps2RecompiledFunctionTable[263631] = bhEne23_MV02_0x201640; // 0x201744 - g_ps2RecompiledFunctionTable[263634] = bhEne23_MV02_0x201640; // 0x201750 - g_ps2RecompiledFunctionTable[263678] = bhEne23_MV02_0x201640; // 0x201800 - g_ps2RecompiledFunctionTable[263752] = bhEne23_MV02_0x201640; // 0x201928 - g_ps2RecompiledFunctionTable[263762] = bhEne23_MV02_0x201640; // 0x201950 - g_ps2RecompiledFunctionTable[263768] = bhEne23_MV02_0x201640; // 0x201968 - g_ps2RecompiledFunctionTable[263784] = bhEne23_MV02_0x201640; // 0x2019a8 - g_ps2RecompiledFunctionTable[263798] = bhEne23_MV02_0x201640; // 0x2019e0 - g_ps2RecompiledFunctionTable[263802] = bhEne23_MV02_0x201640; // 0x2019f0 - g_ps2RecompiledFunctionTable[263826] = bhEne23_MV03_0x201a50; // 0x201a50 - g_ps2RecompiledFunctionTable[263878] = bhEne23_MV03_0x201a50; // 0x201b20 - g_ps2RecompiledFunctionTable[263891] = bhEne23_MV03_0x201a50; // 0x201b54 - g_ps2RecompiledFunctionTable[263894] = bhEne23_MV03_0x201a50; // 0x201b60 - g_ps2RecompiledFunctionTable[263939] = bhEne23_MV03_0x201a50; // 0x201c14 - g_ps2RecompiledFunctionTable[264014] = bhEne23_MV03_0x201a50; // 0x201d40 - g_ps2RecompiledFunctionTable[264035] = bhEne23_MV03_0x201a50; // 0x201d94 - g_ps2RecompiledFunctionTable[264049] = bhEne23_MV03_0x201a50; // 0x201dcc - g_ps2RecompiledFunctionTable[264053] = bhEne23_MV03_0x201a50; // 0x201ddc - g_ps2RecompiledFunctionTable[264055] = bhEne23_MV03_0x201a50; // 0x201de4 - g_ps2RecompiledFunctionTable[264086] = bhEne23_MV04_0x201e60; // 0x201e60 - g_ps2RecompiledFunctionTable[264090] = bhEne23_MV05_0x201e70; // 0x201e70 - g_ps2RecompiledFunctionTable[264180] = bhEne23_MV05_0x201e70; // 0x201fd8 - g_ps2RecompiledFunctionTable[264185] = bhEne23_MV05_0x201e70; // 0x201fec - g_ps2RecompiledFunctionTable[264190] = bhEne23_MV05_0x201e70; // 0x202000 - g_ps2RecompiledFunctionTable[264220] = bhEne23_MV05_0x201e70; // 0x202078 - g_ps2RecompiledFunctionTable[264239] = bhEne23_MV05_0x201e70; // 0x2020c4 - g_ps2RecompiledFunctionTable[264250] = bhEne23_MV06_0x2020f0; // 0x2020f0 - g_ps2RecompiledFunctionTable[264308] = bhEne23_MV06_0x2020f0; // 0x2021d8 - g_ps2RecompiledFunctionTable[264322] = bhEne23_MV06_0x2020f0; // 0x202210 - g_ps2RecompiledFunctionTable[264350] = bhEne23_MV07_0x202280; // 0x202280 - g_ps2RecompiledFunctionTable[264354] = bhEne23_MV08_0x202290; // 0x202290 - g_ps2RecompiledFunctionTable[264358] = bhEne23_MV09_0x2022a0; // 0x2022a0 - g_ps2RecompiledFunctionTable[264414] = bhEne23_MV09_0x2022a0; // 0x202380 - g_ps2RecompiledFunctionTable[264418] = bhEne23_MV10_0x202390; // 0x202390 - g_ps2RecompiledFunctionTable[264547] = bhEne23_MV10_0x202390; // 0x202594 - g_ps2RecompiledFunctionTable[264553] = bhEne23_MV10_0x202390; // 0x2025ac - g_ps2RecompiledFunctionTable[264560] = bhEne23_MV10_0x202390; // 0x2025c8 - g_ps2RecompiledFunctionTable[264566] = bhEne23_MV10_0x202390; // 0x2025e0 - g_ps2RecompiledFunctionTable[264580] = bhEne23_MV10_0x202390; // 0x202618 - g_ps2RecompiledFunctionTable[264586] = bhEne23_MV10_0x202390; // 0x202630 - g_ps2RecompiledFunctionTable[264595] = bhEne23_MV10_0x202390; // 0x202654 - g_ps2RecompiledFunctionTable[264601] = bhEne23_MV10_0x202390; // 0x20266c - g_ps2RecompiledFunctionTable[264617] = bhEne23_MV10_0x202390; // 0x2026ac - g_ps2RecompiledFunctionTable[264648] = bhEne23_MV10_0x202390; // 0x202728 - g_ps2RecompiledFunctionTable[264672] = bhEne23_MV10_0x202390; // 0x202788 - g_ps2RecompiledFunctionTable[264700] = bhEne23_MV10_0x202390; // 0x2027f8 - g_ps2RecompiledFunctionTable[264718] = bhEne23_MV11_0x202840; // 0x202840 - g_ps2RecompiledFunctionTable[264774] = bhEne23_MV11_0x202840; // 0x202920 - g_ps2RecompiledFunctionTable[264791] = bhEne23_MV11_0x202840; // 0x202964 - g_ps2RecompiledFunctionTable[264794] = bhEne23_MV11_0x202840; // 0x202970 - g_ps2RecompiledFunctionTable[264803] = bhEne23_MV11_0x202840; // 0x202994 - g_ps2RecompiledFunctionTable[264806] = bhEne23_MV11_0x202840; // 0x2029a0 - g_ps2RecompiledFunctionTable[264815] = bhEne23_MV11_0x202840; // 0x2029c4 - g_ps2RecompiledFunctionTable[264838] = bhEne23_MV12_0x202a20; // 0x202a20 - g_ps2RecompiledFunctionTable[264872] = bhEne23_MV12_0x202a20; // 0x202aa8 - g_ps2RecompiledFunctionTable[264877] = bhEne23_MV12_0x202a20; // 0x202abc - g_ps2RecompiledFunctionTable[264903] = bhEne23_MV12_0x202a20; // 0x202b24 - g_ps2RecompiledFunctionTable[264906] = bhEne23_MV12_0x202a20; // 0x202b30 - g_ps2RecompiledFunctionTable[264929] = bhEne23_MV12_0x202a20; // 0x202b8c - g_ps2RecompiledFunctionTable[264931] = bhEne23_MV12_0x202a20; // 0x202b94 - g_ps2RecompiledFunctionTable[264978] = bhEne23_MV12_0x202a20; // 0x202c50 - g_ps2RecompiledFunctionTable[264986] = bhEne23_MV12_0x202a20; // 0x202c70 - g_ps2RecompiledFunctionTable[264990] = bhEne23_Nage_0x202c80; // 0x202c80 - g_ps2RecompiledFunctionTable[264991] = bhEne23_Nage_0x202c80; // 0x202c84 - g_ps2RecompiledFunctionTable[264992] = bhEne23_Nage_0x202c80; // 0x202c88 - g_ps2RecompiledFunctionTable[264993] = bhEne23_Nage_0x202c80; // 0x202c8c - g_ps2RecompiledFunctionTable[264994] = bhEne23_Nage_0x202c80; // 0x202c90 - g_ps2RecompiledFunctionTable[264995] = bhEne23_Nage_0x202c80; // 0x202c94 - g_ps2RecompiledFunctionTable[264996] = bhEne23_Nage_0x202c80; // 0x202c98 - g_ps2RecompiledFunctionTable[264997] = bhEne23_Nage_0x202c80; // 0x202c9c - g_ps2RecompiledFunctionTable[264998] = bhEne23_NG00_0x202ca0; // 0x202ca0 - g_ps2RecompiledFunctionTable[265002] = bhEne23_Damage_0x202cb0; // 0x202cb0 - g_ps2RecompiledFunctionTable[265003] = bhEne23_Damage_0x202cb0; // 0x202cb4 - g_ps2RecompiledFunctionTable[265004] = bhEne23_Damage_0x202cb0; // 0x202cb8 - g_ps2RecompiledFunctionTable[265005] = bhEne23_Damage_0x202cb0; // 0x202cbc - g_ps2RecompiledFunctionTable[265006] = bhEne23_Damage_0x202cb0; // 0x202cc0 - g_ps2RecompiledFunctionTable[265007] = bhEne23_Damage_0x202cb0; // 0x202cc4 - g_ps2RecompiledFunctionTable[265008] = bhEne23_Damage_0x202cb0; // 0x202cc8 - g_ps2RecompiledFunctionTable[265009] = bhEne23_Damage_0x202cb0; // 0x202ccc - g_ps2RecompiledFunctionTable[265010] = bhEne23_Damage_0x202cb0; // 0x202cd0 - g_ps2RecompiledFunctionTable[265011] = bhEne23_Damage_0x202cb0; // 0x202cd4 - g_ps2RecompiledFunctionTable[265012] = bhEne23_Damage_0x202cb0; // 0x202cd8 - g_ps2RecompiledFunctionTable[265013] = bhEne23_Damage_0x202cb0; // 0x202cdc - g_ps2RecompiledFunctionTable[265014] = bhEne23_Damage_0x202cb0; // 0x202ce0 - g_ps2RecompiledFunctionTable[265015] = bhEne23_Damage_0x202cb0; // 0x202ce4 - g_ps2RecompiledFunctionTable[265016] = bhEne23_Damage_0x202cb0; // 0x202ce8 - g_ps2RecompiledFunctionTable[265017] = bhEne23_Damage_0x202cb0; // 0x202cec - g_ps2RecompiledFunctionTable[265018] = bhEne23_Damage_0x202cb0; // 0x202cf0 - g_ps2RecompiledFunctionTable[265019] = bhEne23_Damage_0x202cb0; // 0x202cf4 - g_ps2RecompiledFunctionTable[265020] = bhEne23_Damage_0x202cb0; // 0x202cf8 - g_ps2RecompiledFunctionTable[265021] = bhEne23_Damage_0x202cb0; // 0x202cfc - g_ps2RecompiledFunctionTable[265022] = bhEne23_Damage_0x202cb0; // 0x202d00 - g_ps2RecompiledFunctionTable[265023] = bhEne23_Damage_0x202cb0; // 0x202d04 - g_ps2RecompiledFunctionTable[265024] = bhEne23_Damage_0x202cb0; // 0x202d08 - g_ps2RecompiledFunctionTable[265025] = bhEne23_Damage_0x202cb0; // 0x202d0c - g_ps2RecompiledFunctionTable[265026] = bhEne23_Damage_0x202cb0; // 0x202d10 - g_ps2RecompiledFunctionTable[265027] = bhEne23_Damage_0x202cb0; // 0x202d14 - g_ps2RecompiledFunctionTable[265028] = bhEne23_Damage_0x202cb0; // 0x202d18 - g_ps2RecompiledFunctionTable[265029] = bhEne23_Damage_0x202cb0; // 0x202d1c - g_ps2RecompiledFunctionTable[265030] = bhEne23_Damage_0x202cb0; // 0x202d20 - g_ps2RecompiledFunctionTable[265031] = bhEne23_Damage_0x202cb0; // 0x202d24 - g_ps2RecompiledFunctionTable[265032] = bhEne23_Damage_0x202cb0; // 0x202d28 - g_ps2RecompiledFunctionTable[265033] = bhEne23_Damage_0x202cb0; // 0x202d2c - g_ps2RecompiledFunctionTable[265034] = bhEne23_Damage_0x202cb0; // 0x202d30 - g_ps2RecompiledFunctionTable[265035] = bhEne23_Damage_0x202cb0; // 0x202d34 - g_ps2RecompiledFunctionTable[265036] = bhEne23_Damage_0x202cb0; // 0x202d38 - g_ps2RecompiledFunctionTable[265037] = bhEne23_Damage_0x202cb0; // 0x202d3c - g_ps2RecompiledFunctionTable[265038] = bhEne23_Damage_0x202cb0; // 0x202d40 - g_ps2RecompiledFunctionTable[265039] = bhEne23_Damage_0x202cb0; // 0x202d44 - g_ps2RecompiledFunctionTable[265040] = bhEne23_Damage_0x202cb0; // 0x202d48 - g_ps2RecompiledFunctionTable[265041] = bhEne23_Damage_0x202cb0; // 0x202d4c - g_ps2RecompiledFunctionTable[265042] = bhEne23_Damage_0x202cb0; // 0x202d50 - g_ps2RecompiledFunctionTable[265043] = bhEne23_Damage_0x202cb0; // 0x202d54 - g_ps2RecompiledFunctionTable[265044] = bhEne23_Damage_0x202cb0; // 0x202d58 - g_ps2RecompiledFunctionTable[265045] = bhEne23_Damage_0x202cb0; // 0x202d5c - g_ps2RecompiledFunctionTable[265046] = bhEne23_Damage_0x202cb0; // 0x202d60 - g_ps2RecompiledFunctionTable[265047] = bhEne23_Damage_0x202cb0; // 0x202d64 - g_ps2RecompiledFunctionTable[265048] = bhEne23_Damage_0x202cb0; // 0x202d68 - g_ps2RecompiledFunctionTable[265049] = bhEne23_Damage_0x202cb0; // 0x202d6c - g_ps2RecompiledFunctionTable[265050] = bhEne23_Damage_0x202cb0; // 0x202d70 - g_ps2RecompiledFunctionTable[265051] = bhEne23_Damage_0x202cb0; // 0x202d74 - g_ps2RecompiledFunctionTable[265052] = bhEne23_Damage_0x202cb0; // 0x202d78 - g_ps2RecompiledFunctionTable[265053] = bhEne23_Damage_0x202cb0; // 0x202d7c - g_ps2RecompiledFunctionTable[265054] = bhEne23_Damage_0x202cb0; // 0x202d80 - g_ps2RecompiledFunctionTable[265055] = bhEne23_Damage_0x202cb0; // 0x202d84 - g_ps2RecompiledFunctionTable[265056] = bhEne23_Damage_0x202cb0; // 0x202d88 - g_ps2RecompiledFunctionTable[265057] = bhEne23_Damage_0x202cb0; // 0x202d8c - g_ps2RecompiledFunctionTable[265058] = bhEne23_Damage_0x202cb0; // 0x202d90 - g_ps2RecompiledFunctionTable[265059] = bhEne23_Damage_0x202cb0; // 0x202d94 - g_ps2RecompiledFunctionTable[265060] = bhEne23_Damage_0x202cb0; // 0x202d98 - g_ps2RecompiledFunctionTable[265061] = bhEne23_Damage_0x202cb0; // 0x202d9c - g_ps2RecompiledFunctionTable[265062] = bhEne23_Damage_0x202cb0; // 0x202da0 - g_ps2RecompiledFunctionTable[265063] = bhEne23_Damage_0x202cb0; // 0x202da4 - g_ps2RecompiledFunctionTable[265064] = bhEne23_Damage_0x202cb0; // 0x202da8 - g_ps2RecompiledFunctionTable[265065] = bhEne23_Damage_0x202cb0; // 0x202dac - g_ps2RecompiledFunctionTable[265066] = bhEne23_Damage_0x202cb0; // 0x202db0 - g_ps2RecompiledFunctionTable[265067] = bhEne23_Damage_0x202cb0; // 0x202db4 - g_ps2RecompiledFunctionTable[265068] = bhEne23_Damage_0x202cb0; // 0x202db8 - g_ps2RecompiledFunctionTable[265069] = bhEne23_Damage_0x202cb0; // 0x202dbc - g_ps2RecompiledFunctionTable[265070] = bhEne23_Damage_0x202cb0; // 0x202dc0 - g_ps2RecompiledFunctionTable[265071] = bhEne23_Damage_0x202cb0; // 0x202dc4 - g_ps2RecompiledFunctionTable[265072] = bhEne23_Damage_0x202cb0; // 0x202dc8 - g_ps2RecompiledFunctionTable[265073] = bhEne23_Damage_0x202cb0; // 0x202dcc - g_ps2RecompiledFunctionTable[265074] = bhEne23_Damage_0x202cb0; // 0x202dd0 - g_ps2RecompiledFunctionTable[265075] = bhEne23_Damage_0x202cb0; // 0x202dd4 - g_ps2RecompiledFunctionTable[265076] = bhEne23_Damage_0x202cb0; // 0x202dd8 - g_ps2RecompiledFunctionTable[265077] = bhEne23_Damage_0x202cb0; // 0x202ddc - g_ps2RecompiledFunctionTable[265078] = bhEne23_Damage_0x202cb0; // 0x202de0 - g_ps2RecompiledFunctionTable[265079] = bhEne23_Damage_0x202cb0; // 0x202de4 - g_ps2RecompiledFunctionTable[265080] = bhEne23_Damage_0x202cb0; // 0x202de8 - g_ps2RecompiledFunctionTable[265081] = bhEne23_Damage_0x202cb0; // 0x202dec - g_ps2RecompiledFunctionTable[265082] = bhEne23_Damage_0x202cb0; // 0x202df0 - g_ps2RecompiledFunctionTable[265083] = bhEne23_Damage_0x202cb0; // 0x202df4 - g_ps2RecompiledFunctionTable[265084] = bhEne23_Damage_0x202cb0; // 0x202df8 - g_ps2RecompiledFunctionTable[265085] = bhEne23_Damage_0x202cb0; // 0x202dfc - g_ps2RecompiledFunctionTable[265086] = bhEne23_Damage_0x202cb0; // 0x202e00 - g_ps2RecompiledFunctionTable[265087] = bhEne23_Damage_0x202cb0; // 0x202e04 - g_ps2RecompiledFunctionTable[265088] = bhEne23_Damage_0x202cb0; // 0x202e08 - g_ps2RecompiledFunctionTable[265089] = bhEne23_Damage_0x202cb0; // 0x202e0c - g_ps2RecompiledFunctionTable[265090] = bhEne23_Damage_0x202cb0; // 0x202e10 - g_ps2RecompiledFunctionTable[265091] = bhEne23_Damage_0x202cb0; // 0x202e14 - g_ps2RecompiledFunctionTable[265092] = bhEne23_Damage_0x202cb0; // 0x202e18 - g_ps2RecompiledFunctionTable[265094] = bhEne23_DG00_0x202e20; // 0x202e20 - g_ps2RecompiledFunctionTable[265098] = bhEne23_DG01_0x202e30; // 0x202e30 - g_ps2RecompiledFunctionTable[265123] = bhEne23_DG01_0x202e30; // 0x202e94 - g_ps2RecompiledFunctionTable[265131] = bhEne23_DG01_0x202e30; // 0x202eb4 - g_ps2RecompiledFunctionTable[265190] = bhEne23_DG02_0x202fa0; // 0x202fa0 - g_ps2RecompiledFunctionTable[265194] = bhEne23_DG03_0x202fb0; // 0x202fb0 - g_ps2RecompiledFunctionTable[265215] = bhEne23_DG03_0x202fb0; // 0x203004 - g_ps2RecompiledFunctionTable[265274] = bhEne23_DG04_0x2030f0; // 0x2030f0 - g_ps2RecompiledFunctionTable[265317] = bhEne23_DG04_0x2030f0; // 0x20319c - g_ps2RecompiledFunctionTable[265320] = bhEne23_DG04_0x2030f0; // 0x2031a8 - g_ps2RecompiledFunctionTable[265339] = bhEne23_DG04_0x2030f0; // 0x2031f4 - g_ps2RecompiledFunctionTable[265345] = bhEne23_DG04_0x2030f0; // 0x20320c - g_ps2RecompiledFunctionTable[265351] = bhEne23_DG04_0x2030f0; // 0x203224 - g_ps2RecompiledFunctionTable[265356] = bhEne23_DG04_0x2030f0; // 0x203238 - g_ps2RecompiledFunctionTable[265361] = bhEne23_DG04_0x2030f0; // 0x20324c - g_ps2RecompiledFunctionTable[265366] = bhEne23_DG04_0x2030f0; // 0x203260 - g_ps2RecompiledFunctionTable[265367] = bhEne23_DG04_0x2030f0; // 0x203264 - g_ps2RecompiledFunctionTable[265371] = bhEne23_DG04_0x2030f0; // 0x203274 - g_ps2RecompiledFunctionTable[265387] = bhEne23_DG04_0x2030f0; // 0x2032b4 - g_ps2RecompiledFunctionTable[265404] = bhEne23_DG04_0x2030f0; // 0x2032f8 - g_ps2RecompiledFunctionTable[265426] = bhEne23_DG04_0x2030f0; // 0x203350 - g_ps2RecompiledFunctionTable[265432] = bhEne23_DG04_0x2030f0; // 0x203368 - g_ps2RecompiledFunctionTable[265438] = bhEne23_DG04_0x2030f0; // 0x203380 - g_ps2RecompiledFunctionTable[265444] = bhEne23_DG04_0x2030f0; // 0x203398 - g_ps2RecompiledFunctionTable[265454] = bhEne23_DG04_0x2030f0; // 0x2033c0 - g_ps2RecompiledFunctionTable[265461] = bhEne23_DG04_0x2030f0; // 0x2033dc - g_ps2RecompiledFunctionTable[265477] = bhEne23_DG04_0x2030f0; // 0x20341c - g_ps2RecompiledFunctionTable[265495] = bhEne23_DG04_0x2030f0; // 0x203464 - g_ps2RecompiledFunctionTable[265518] = bhEne23_DG04_0x2030f0; // 0x2034c0 - g_ps2RecompiledFunctionTable[265524] = bhEne23_DG04_0x2030f0; // 0x2034d8 - g_ps2RecompiledFunctionTable[265526] = bhEne23_DG04_0x2030f0; // 0x2034e0 - g_ps2RecompiledFunctionTable[265542] = bhEne23_DG04_0x2030f0; // 0x203520 - g_ps2RecompiledFunctionTable[265559] = bhEne23_DG04_0x2030f0; // 0x203564 - g_ps2RecompiledFunctionTable[265579] = bhEne23_DG04_0x2030f0; // 0x2035b4 - g_ps2RecompiledFunctionTable[265585] = bhEne23_DG04_0x2030f0; // 0x2035cc - g_ps2RecompiledFunctionTable[265626] = bhEne23_DG05_0x203670; // 0x203670 - g_ps2RecompiledFunctionTable[265630] = bhEne23_DG06_0x203680; // 0x203680 - g_ps2RecompiledFunctionTable[265662] = bhEne23_DG06_0x203680; // 0x203700 - g_ps2RecompiledFunctionTable[265686] = bhEne23_DG06_0x203680; // 0x203760 - g_ps2RecompiledFunctionTable[265693] = bhEne23_DG06_0x203680; // 0x20377c - g_ps2RecompiledFunctionTable[265720] = bhEne23_DG06_0x203680; // 0x2037e8 - g_ps2RecompiledFunctionTable[265769] = bhEne23_DG06_0x203680; // 0x2038ac - g_ps2RecompiledFunctionTable[265772] = bhEne23_DG06_0x203680; // 0x2038b8 - g_ps2RecompiledFunctionTable[265829] = bhEne23_DG06_0x203680; // 0x20399c - g_ps2RecompiledFunctionTable[265838] = bhEne23_DG06_0x203680; // 0x2039c0 - g_ps2RecompiledFunctionTable[265840] = bhEne23_DG06_0x203680; // 0x2039c8 - g_ps2RecompiledFunctionTable[265842] = bhEne23_DG06_0x203680; // 0x2039d0 - g_ps2RecompiledFunctionTable[265847] = bhEne23_DG06_0x203680; // 0x2039e4 - g_ps2RecompiledFunctionTable[265864] = bhEne23_DG06_0x203680; // 0x203a28 - g_ps2RecompiledFunctionTable[265867] = bhEne23_DG06_0x203680; // 0x203a34 - g_ps2RecompiledFunctionTable[265869] = bhEne23_DG06_0x203680; // 0x203a3c - g_ps2RecompiledFunctionTable[265874] = bhEne23_DG06_0x203680; // 0x203a50 - g_ps2RecompiledFunctionTable[265882] = bhEne23_DG06_0x203680; // 0x203a70 - g_ps2RecompiledFunctionTable[265885] = bhEne23_DG06_0x203680; // 0x203a7c - g_ps2RecompiledFunctionTable[265887] = bhEne23_DG06_0x203680; // 0x203a84 - g_ps2RecompiledFunctionTable[265899] = bhEne23_DG06_0x203680; // 0x203ab4 - g_ps2RecompiledFunctionTable[265975] = bhEne23_DG06_0x203680; // 0x203be4 - g_ps2RecompiledFunctionTable[266001] = bhEne23_DG06_0x203680; // 0x203c4c - g_ps2RecompiledFunctionTable[266034] = bhEne23_DG07_0x203cd0; // 0x203cd0 - g_ps2RecompiledFunctionTable[266058] = bhEne23_DG07_0x203cd0; // 0x203d30 - g_ps2RecompiledFunctionTable[266082] = bhEne23_DG07_0x203cd0; // 0x203d90 - g_ps2RecompiledFunctionTable[266089] = bhEne23_DG07_0x203cd0; // 0x203dac - g_ps2RecompiledFunctionTable[266150] = bhEne23_DG07_0x203cd0; // 0x203ea0 - g_ps2RecompiledFunctionTable[266153] = bhEne23_DG07_0x203cd0; // 0x203eac - g_ps2RecompiledFunctionTable[266201] = bhEne23_DG07_0x203cd0; // 0x203f6c - g_ps2RecompiledFunctionTable[266210] = bhEne23_DG07_0x203cd0; // 0x203f90 - g_ps2RecompiledFunctionTable[266212] = bhEne23_DG07_0x203cd0; // 0x203f98 - g_ps2RecompiledFunctionTable[266214] = bhEne23_DG07_0x203cd0; // 0x203fa0 - g_ps2RecompiledFunctionTable[266219] = bhEne23_DG07_0x203cd0; // 0x203fb4 - g_ps2RecompiledFunctionTable[266227] = bhEne23_DG07_0x203cd0; // 0x203fd4 - g_ps2RecompiledFunctionTable[266230] = bhEne23_DG07_0x203cd0; // 0x203fe0 - g_ps2RecompiledFunctionTable[266232] = bhEne23_DG07_0x203cd0; // 0x203fe8 - g_ps2RecompiledFunctionTable[266237] = bhEne23_DG07_0x203cd0; // 0x203ffc - g_ps2RecompiledFunctionTable[266245] = bhEne23_DG07_0x203cd0; // 0x20401c - g_ps2RecompiledFunctionTable[266248] = bhEne23_DG07_0x203cd0; // 0x204028 - g_ps2RecompiledFunctionTable[266250] = bhEne23_DG07_0x203cd0; // 0x204030 - g_ps2RecompiledFunctionTable[266262] = bhEne23_DG07_0x203cd0; // 0x204060 - g_ps2RecompiledFunctionTable[266342] = bhEne23_Die_0x2041a0; // 0x2041a0 - g_ps2RecompiledFunctionTable[266343] = bhEne23_Die_0x2041a0; // 0x2041a4 - g_ps2RecompiledFunctionTable[266344] = bhEne23_Die_0x2041a0; // 0x2041a8 - g_ps2RecompiledFunctionTable[266345] = bhEne23_Die_0x2041a0; // 0x2041ac - g_ps2RecompiledFunctionTable[266346] = bhEne23_Die_0x2041a0; // 0x2041b0 - g_ps2RecompiledFunctionTable[266347] = bhEne23_Die_0x2041a0; // 0x2041b4 - g_ps2RecompiledFunctionTable[266348] = bhEne23_Die_0x2041a0; // 0x2041b8 - g_ps2RecompiledFunctionTable[266349] = bhEne23_Die_0x2041a0; // 0x2041bc - g_ps2RecompiledFunctionTable[266350] = bhEne23_DD00_0x2041c0; // 0x2041c0 - g_ps2RecompiledFunctionTable[266415] = bhEne23_DD00_0x2041c0; // 0x2042c4 - g_ps2RecompiledFunctionTable[266422] = bhEne23_DD00_0x2041c0; // 0x2042e0 - g_ps2RecompiledFunctionTable[266430] = bhEne23_DD01_0x204300; // 0x204300 - g_ps2RecompiledFunctionTable[266457] = bhEne23_DD01_0x204300; // 0x20436c - g_ps2RecompiledFunctionTable[266481] = bhEne23_DD01_0x204300; // 0x2043cc - g_ps2RecompiledFunctionTable[266488] = bhEne23_DD01_0x204300; // 0x2043e8 - g_ps2RecompiledFunctionTable[266515] = bhEne23_DD01_0x204300; // 0x204454 - g_ps2RecompiledFunctionTable[266564] = bhEne23_DD01_0x204300; // 0x204518 - g_ps2RecompiledFunctionTable[266567] = bhEne23_DD01_0x204300; // 0x204524 - g_ps2RecompiledFunctionTable[266623] = bhEne23_DD01_0x204300; // 0x204604 - g_ps2RecompiledFunctionTable[266632] = bhEne23_DD01_0x204300; // 0x204628 - g_ps2RecompiledFunctionTable[266634] = bhEne23_DD01_0x204300; // 0x204630 - g_ps2RecompiledFunctionTable[266636] = bhEne23_DD01_0x204300; // 0x204638 - g_ps2RecompiledFunctionTable[266641] = bhEne23_DD01_0x204300; // 0x20464c - g_ps2RecompiledFunctionTable[266649] = bhEne23_DD01_0x204300; // 0x20466c - g_ps2RecompiledFunctionTable[266652] = bhEne23_DD01_0x204300; // 0x204678 - g_ps2RecompiledFunctionTable[266654] = bhEne23_DD01_0x204300; // 0x204680 - g_ps2RecompiledFunctionTable[266659] = bhEne23_DD01_0x204300; // 0x204694 - g_ps2RecompiledFunctionTable[266667] = bhEne23_DD01_0x204300; // 0x2046b4 - g_ps2RecompiledFunctionTable[266670] = bhEne23_DD01_0x204300; // 0x2046c0 - g_ps2RecompiledFunctionTable[266672] = bhEne23_DD01_0x204300; // 0x2046c8 - g_ps2RecompiledFunctionTable[266684] = bhEne23_DD01_0x204300; // 0x2046f8 - g_ps2RecompiledFunctionTable[266778] = bhEne23_DD01_0x204300; // 0x204870 - g_ps2RecompiledFunctionTable[266800] = bhEne23_DD01_0x204300; // 0x2048c8 - g_ps2RecompiledFunctionTable[266807] = bhEne23_DD01_0x204300; // 0x2048e4 - g_ps2RecompiledFunctionTable[266814] = bhEne23_DD02_0x204900; // 0x204900 - g_ps2RecompiledFunctionTable[266818] = bhEne23_DD03_0x204910; // 0x204910 - g_ps2RecompiledFunctionTable[266845] = bhEne23_DD03_0x204910; // 0x20497c - g_ps2RecompiledFunctionTable[266869] = bhEne23_DD03_0x204910; // 0x2049dc - g_ps2RecompiledFunctionTable[266876] = bhEne23_DD03_0x204910; // 0x2049f8 - g_ps2RecompiledFunctionTable[266939] = bhEne23_DD03_0x204910; // 0x204af4 - g_ps2RecompiledFunctionTable[266942] = bhEne23_DD03_0x204910; // 0x204b00 - g_ps2RecompiledFunctionTable[266990] = bhEne23_DD03_0x204910; // 0x204bc0 - g_ps2RecompiledFunctionTable[266999] = bhEne23_DD03_0x204910; // 0x204be4 - g_ps2RecompiledFunctionTable[267001] = bhEne23_DD03_0x204910; // 0x204bec - g_ps2RecompiledFunctionTable[267003] = bhEne23_DD03_0x204910; // 0x204bf4 - g_ps2RecompiledFunctionTable[267008] = bhEne23_DD03_0x204910; // 0x204c08 - g_ps2RecompiledFunctionTable[267016] = bhEne23_DD03_0x204910; // 0x204c28 - g_ps2RecompiledFunctionTable[267019] = bhEne23_DD03_0x204910; // 0x204c34 - g_ps2RecompiledFunctionTable[267021] = bhEne23_DD03_0x204910; // 0x204c3c - g_ps2RecompiledFunctionTable[267026] = bhEne23_DD03_0x204910; // 0x204c50 - g_ps2RecompiledFunctionTable[267034] = bhEne23_DD03_0x204910; // 0x204c70 - g_ps2RecompiledFunctionTable[267037] = bhEne23_DD03_0x204910; // 0x204c7c - g_ps2RecompiledFunctionTable[267039] = bhEne23_DD03_0x204910; // 0x204c84 - g_ps2RecompiledFunctionTable[267051] = bhEne23_DD03_0x204910; // 0x204cb4 - g_ps2RecompiledFunctionTable[267148] = bhEne23_DD03_0x204910; // 0x204e38 - g_ps2RecompiledFunctionTable[267170] = bhEne23_DD03_0x204910; // 0x204e90 - g_ps2RecompiledFunctionTable[267177] = bhEne23_DD03_0x204910; // 0x204eac - g_ps2RecompiledFunctionTable[267186] = bhEne23_CollisionWalls_0x204ed0; // 0x204ed0 - g_ps2RecompiledFunctionTable[267209] = bhEne23_CollisionWalls_0x204ed0; // 0x204f2c - g_ps2RecompiledFunctionTable[267233] = bhEne23_CollisionWalls_0x204ed0; // 0x204f8c - g_ps2RecompiledFunctionTable[267237] = bhEne23_CollisionWalls_0x204ed0; // 0x204f9c - g_ps2RecompiledFunctionTable[267262] = bhEne23_CollisionWalls_0x204ed0; // 0x205000 - g_ps2RecompiledFunctionTable[267312] = bhEne23_CollisionWalls_0x204ed0; // 0x2050c8 - g_ps2RecompiledFunctionTable[267357] = bhEne23_CollisionWalls_0x204ed0; // 0x20517c - g_ps2RecompiledFunctionTable[267392] = bhEne23_CollisionWalls_0x204ed0; // 0x205208 - g_ps2RecompiledFunctionTable[267408] = bhEne23_CollisionWalls_0x204ed0; // 0x205248 - g_ps2RecompiledFunctionTable[267454] = bhEne23_CollisionLine_0x205300; // 0x205300 - g_ps2RecompiledFunctionTable[267463] = bhEne23_CollisionLine_0x205300; // 0x205324 - g_ps2RecompiledFunctionTable[267476] = bhEne23_CollisionLine_0x205300; // 0x205358 - g_ps2RecompiledFunctionTable[267489] = bhEne23_CollisionLine_0x205300; // 0x20538c - g_ps2RecompiledFunctionTable[267498] = bhEne23_CheckClimbWall_0x2053b0; // 0x2053b0 - g_ps2RecompiledFunctionTable[267523] = bhEne23_CheckClimbWall_0x2053b0; // 0x205414 - g_ps2RecompiledFunctionTable[267566] = bhEne23_CheckClimbWall_0x2053b0; // 0x2054c0 - g_ps2RecompiledFunctionTable[267574] = bhEne23_CheckClimbWall_0x2053b0; // 0x2054e0 - g_ps2RecompiledFunctionTable[267585] = bhEne23_CheckClimbWall_0x2053b0; // 0x20550c - g_ps2RecompiledFunctionTable[267661] = bhEne23_CheckClimbWall_0x2053b0; // 0x20563c - g_ps2RecompiledFunctionTable[267674] = bhEne23_CheckClimbWall_0x2053b0; // 0x205670 - g_ps2RecompiledFunctionTable[267676] = bhEne23_CheckClimbWall_0x2053b0; // 0x205678 - g_ps2RecompiledFunctionTable[267696] = bhEne23_CheckClimbWall_0x2053b0; // 0x2056c8 - g_ps2RecompiledFunctionTable[267699] = bhEne23_CheckClimbWall_0x2053b0; // 0x2056d4 - g_ps2RecompiledFunctionTable[267714] = bhEne23_CheckClimbWall_0x2053b0; // 0x205710 - g_ps2RecompiledFunctionTable[267717] = bhEne23_CheckClimbWall_0x2053b0; // 0x20571c - g_ps2RecompiledFunctionTable[267731] = bhEne23_CheckClimbWall_0x2053b0; // 0x205754 - g_ps2RecompiledFunctionTable[267746] = bhEne23_CheckClimbWall_0x2053b0; // 0x205790 - g_ps2RecompiledFunctionTable[267774] = bhEne23_CheckDiving_0x205800; // 0x205800 - g_ps2RecompiledFunctionTable[267804] = bhEne23_CheckDiving_0x205800; // 0x205878 - g_ps2RecompiledFunctionTable[267824] = bhEne23_CheckDiving_0x205800; // 0x2058c8 - g_ps2RecompiledFunctionTable[267839] = bhEne23_CheckDiving_0x205800; // 0x205904 - g_ps2RecompiledFunctionTable[267854] = bhEne23_DamageInit_0x205940; // 0x205940 - g_ps2RecompiledFunctionTable[267868] = bhEne23_DamageInit_0x205940; // 0x205978 - g_ps2RecompiledFunctionTable[267874] = bhEne23_DamageInit_0x205940; // 0x205990 - g_ps2RecompiledFunctionTable[267940] = bhEne23_DamageInit_0x205940; // 0x205a98 - g_ps2RecompiledFunctionTable[267955] = bhEne23_DamageInit_0x205940; // 0x205ad4 - g_ps2RecompiledFunctionTable[267973] = bhEne23_DamageInit_0x205940; // 0x205b1c - g_ps2RecompiledFunctionTable[268027] = bhEne23_DamageInit_0x205940; // 0x205bf4 - g_ps2RecompiledFunctionTable[268091] = bhEne23_DamageInit_0x205940; // 0x205cf4 - g_ps2RecompiledFunctionTable[268134] = bhEne23_LegBreak_0x205da0; // 0x205da0 - g_ps2RecompiledFunctionTable[268139] = bhEne23_LegBreak_0x205da0; // 0x205db4 - g_ps2RecompiledFunctionTable[268152] = bhEne23_LegBreak_0x205da0; // 0x205de8 - g_ps2RecompiledFunctionTable[268202] = bhEne23_LegBreak_0x205da0; // 0x205eb0 - g_ps2RecompiledFunctionTable[268206] = bhEne23_LegBreak_0x205da0; // 0x205ec0 - g_ps2RecompiledFunctionTable[268210] = bhEne23_LegBreak_0x205da0; // 0x205ed0 - g_ps2RecompiledFunctionTable[268214] = bhEne23_InitChild_0x205ee0; // 0x205ee0 - g_ps2RecompiledFunctionTable[268234] = bhEne23_InitChild_0x205ee0; // 0x205f30 - g_ps2RecompiledFunctionTable[268259] = bhEne23_InitChild_0x205ee0; // 0x205f94 - g_ps2RecompiledFunctionTable[268272] = bhEne23_InitChild_0x205ee0; // 0x205fc8 - g_ps2RecompiledFunctionTable[268274] = bhEne23_InitChild_0x205ee0; // 0x205fd0 - g_ps2RecompiledFunctionTable[268292] = bhEne23_InitChild_0x205ee0; // 0x206018 - g_ps2RecompiledFunctionTable[268297] = bhEne23_InitChild_0x205ee0; // 0x20602c - g_ps2RecompiledFunctionTable[268315] = bhEne23_InitChild_0x205ee0; // 0x206074 - g_ps2RecompiledFunctionTable[268321] = bhEne23_InitChild_0x205ee0; // 0x20608c - g_ps2RecompiledFunctionTable[268343] = bhEne23_InitChild_0x205ee0; // 0x2060e4 - g_ps2RecompiledFunctionTable[268353] = bhEne23_InitChild_0x205ee0; // 0x20610c - g_ps2RecompiledFunctionTable[268367] = bhEne23_InitChild_0x205ee0; // 0x206144 - g_ps2RecompiledFunctionTable[268379] = bhEne23_InitChild_0x205ee0; // 0x206174 - g_ps2RecompiledFunctionTable[268410] = bhEne23_PlayerControl_0x2061f0; // 0x2061f0 - g_ps2RecompiledFunctionTable[268517] = bhEne23_PlayerControl_0x2061f0; // 0x20639c - g_ps2RecompiledFunctionTable[268520] = bhEne23_PlayerControl_0x2061f0; // 0x2063a8 - g_ps2RecompiledFunctionTable[268534] = bhEne23_PlayerControl_0x2061f0; // 0x2063e0 - g_ps2RecompiledFunctionTable[268546] = bhEne23_PlayerControl_0x2061f0; // 0x206410 - g_ps2RecompiledFunctionTable[268626] = bhEne23_PlayerControl_0x2061f0; // 0x206550 - g_ps2RecompiledFunctionTable[268752] = bhEne23_PlayerControl_0x2061f0; // 0x206748 - g_ps2RecompiledFunctionTable[268755] = bhEne23_PlayerControl_0x2061f0; // 0x206754 - g_ps2RecompiledFunctionTable[268769] = bhEne23_PlayerControl_0x2061f0; // 0x20678c - g_ps2RecompiledFunctionTable[268781] = bhEne23_PlayerControl_0x2061f0; // 0x2067bc - g_ps2RecompiledFunctionTable[268858] = bhEne23_Acid_0x2068f0; // 0x2068f0 - g_ps2RecompiledFunctionTable[268945] = bhEne23_Acid_0x2068f0; // 0x206a4c - g_ps2RecompiledFunctionTable[268947] = bhEne23_Acid_0x2068f0; // 0x206a54 - g_ps2RecompiledFunctionTable[268981] = bhEne23_Acid_0x2068f0; // 0x206adc - g_ps2RecompiledFunctionTable[269007] = bhEne23_Acid_0x2068f0; // 0x206b44 - g_ps2RecompiledFunctionTable[269009] = bhEne23_Acid_0x2068f0; // 0x206b4c - g_ps2RecompiledFunctionTable[269025] = bhEne23_Acid_0x2068f0; // 0x206b8c - g_ps2RecompiledFunctionTable[269028] = bhEne23_Acid_0x2068f0; // 0x206b98 - g_ps2RecompiledFunctionTable[269030] = bhEne23_Acid_0x2068f0; // 0x206ba0 - g_ps2RecompiledFunctionTable[269044] = bhEne23_Acid_0x2068f0; // 0x206bd8 - g_ps2RecompiledFunctionTable[269047] = bhEne23_Acid_0x2068f0; // 0x206be4 - g_ps2RecompiledFunctionTable[269051] = bhEne23_Acid_0x2068f0; // 0x206bf4 - g_ps2RecompiledFunctionTable[269053] = bhEne23_Acid_0x2068f0; // 0x206bfc - g_ps2RecompiledFunctionTable[269090] = bhEne23_SearchPlayer_0x206c90; // 0x206c90 - g_ps2RecompiledFunctionTable[269115] = bhEne23_SearchPlayer_0x206c90; // 0x206cf4 - g_ps2RecompiledFunctionTable[269117] = bhEne23_SearchPlayer_0x206c90; // 0x206cfc - g_ps2RecompiledFunctionTable[269121] = bhEne23_SearchPlayer_0x206c90; // 0x206d0c - g_ps2RecompiledFunctionTable[269124] = bhEne23_SearchPlayer_0x206c90; // 0x206d18 - g_ps2RecompiledFunctionTable[269129] = bhEne23_SearchPlayer_0x206c90; // 0x206d2c - g_ps2RecompiledFunctionTable[269138] = bhEne23_Shape_0x206d50; // 0x206d50 - g_ps2RecompiledFunctionTable[269168] = bhEne23_Shape_0x206d50; // 0x206dc8 - g_ps2RecompiledFunctionTable[269178] = bhEne23_CallSE_0x206df0; // 0x206df0 - g_ps2RecompiledFunctionTable[269283] = bhEne23_CallSE_0x206df0; // 0x206f94 - g_ps2RecompiledFunctionTable[269294] = bhEne23_CallSE_0x206df0; // 0x206fc0 - g_ps2RecompiledFunctionTable[269316] = bhEne23_CallSE_0x206df0; // 0x207018 - g_ps2RecompiledFunctionTable[269327] = bhEne23_CallSE_0x206df0; // 0x207044 - g_ps2RecompiledFunctionTable[269334] = bhEne23_CallSE_0x206df0; // 0x207060 - g_ps2RecompiledFunctionTable[269343] = bhEne23_CallSE_0x206df0; // 0x207084 - g_ps2RecompiledFunctionTable[269352] = bhEne23_CallSE_0x206df0; // 0x2070a8 - g_ps2RecompiledFunctionTable[269361] = bhEne23_CallSE_0x206df0; // 0x2070cc - g_ps2RecompiledFunctionTable[269369] = bhEne23_CallSE_0x206df0; // 0x2070ec - g_ps2RecompiledFunctionTable[269374] = bhEne23_HitMark_0x207100; // 0x207100 - g_ps2RecompiledFunctionTable[269421] = bhEne23_HitMark_0x207100; // 0x2071bc - g_ps2RecompiledFunctionTable[269437] = bhEne23_HitMark_0x207100; // 0x2071fc - g_ps2RecompiledFunctionTable[269453] = bhEne23_HitMark_0x207100; // 0x20723c - g_ps2RecompiledFunctionTable[269480] = bhEne23_HitMark_0x207100; // 0x2072a8 - g_ps2RecompiledFunctionTable[269495] = bhEne23_HitMark_0x207100; // 0x2072e4 - g_ps2RecompiledFunctionTable[269509] = bhEne23_HitMark_0x207100; // 0x20731c - g_ps2RecompiledFunctionTable[269519] = bhEne23_HitMark_0x207100; // 0x207344 - g_ps2RecompiledFunctionTable[269535] = bhEne23_HitMark_0x207100; // 0x207384 - g_ps2RecompiledFunctionTable[269551] = bhEne23_HitMark_0x207100; // 0x2073c4 - g_ps2RecompiledFunctionTable[269566] = bhEne23_HitMark_0x207100; // 0x207400 - g_ps2RecompiledFunctionTable[269579] = bhEne23_HitMark_0x207100; // 0x207434 - g_ps2RecompiledFunctionTable[269592] = bhEne23_HitMark_0x207100; // 0x207468 - g_ps2RecompiledFunctionTable[269598] = bhEne23_HitMark_0x207100; // 0x207480 - g_ps2RecompiledFunctionTable[269625] = bhEne23_HitMark_0x207100; // 0x2074ec - g_ps2RecompiledFunctionTable[269641] = bhEne23_HitMark_0x207100; // 0x20752c - g_ps2RecompiledFunctionTable[269657] = bhEne23_HitMark_0x207100; // 0x20756c - g_ps2RecompiledFunctionTable[269675] = bhEne23_HitMark_0x207100; // 0x2075b4 - g_ps2RecompiledFunctionTable[269691] = bhEne23_HitMark_0x207100; // 0x2075f4 - g_ps2RecompiledFunctionTable[269702] = bhEne24_0x207620; // 0x207620 - g_ps2RecompiledFunctionTable[269703] = bhEne24_0x207620; // 0x207624 - g_ps2RecompiledFunctionTable[269704] = bhEne24_0x207620; // 0x207628 - g_ps2RecompiledFunctionTable[269705] = bhEne24_0x207620; // 0x20762c - g_ps2RecompiledFunctionTable[269706] = bhEne24_0x207620; // 0x207630 - g_ps2RecompiledFunctionTable[269707] = bhEne24_0x207620; // 0x207634 - g_ps2RecompiledFunctionTable[269708] = bhEne24_0x207620; // 0x207638 - g_ps2RecompiledFunctionTable[269709] = bhEne24_0x207620; // 0x20763c - g_ps2RecompiledFunctionTable[269710] = bhEne24_0x207620; // 0x207640 - g_ps2RecompiledFunctionTable[269711] = bhEne24_0x207620; // 0x207644 - g_ps2RecompiledFunctionTable[269712] = bhEne24_0x207620; // 0x207648 - g_ps2RecompiledFunctionTable[269713] = bhEne24_0x207620; // 0x20764c - g_ps2RecompiledFunctionTable[269714] = bhEne24_0x207620; // 0x207650 - g_ps2RecompiledFunctionTable[269715] = bhEne24_0x207620; // 0x207654 - g_ps2RecompiledFunctionTable[269716] = bhEne24_0x207620; // 0x207658 - g_ps2RecompiledFunctionTable[269717] = bhEne24_0x207620; // 0x20765c - g_ps2RecompiledFunctionTable[269718] = bhEne24_0x207620; // 0x207660 - g_ps2RecompiledFunctionTable[269719] = bhEne24_0x207620; // 0x207664 - g_ps2RecompiledFunctionTable[269720] = bhEne24_0x207620; // 0x207668 - g_ps2RecompiledFunctionTable[269721] = bhEne24_0x207620; // 0x20766c - g_ps2RecompiledFunctionTable[269722] = bhEne24_0x207620; // 0x207670 - g_ps2RecompiledFunctionTable[269723] = bhEne24_0x207620; // 0x207674 - g_ps2RecompiledFunctionTable[269724] = bhEne24_0x207620; // 0x207678 - g_ps2RecompiledFunctionTable[269725] = bhEne24_0x207620; // 0x20767c - g_ps2RecompiledFunctionTable[269726] = bhEne24_0x207620; // 0x207680 - g_ps2RecompiledFunctionTable[269727] = bhEne24_0x207620; // 0x207684 - g_ps2RecompiledFunctionTable[269728] = bhEne24_0x207620; // 0x207688 - g_ps2RecompiledFunctionTable[269729] = bhEne24_0x207620; // 0x20768c - g_ps2RecompiledFunctionTable[269730] = bhEne24_0x207620; // 0x207690 - g_ps2RecompiledFunctionTable[269731] = bhEne24_0x207620; // 0x207694 - g_ps2RecompiledFunctionTable[269732] = bhEne24_0x207620; // 0x207698 - g_ps2RecompiledFunctionTable[269733] = bhEne24_0x207620; // 0x20769c - g_ps2RecompiledFunctionTable[269734] = bhEne24_0x207620; // 0x2076a0 - g_ps2RecompiledFunctionTable[269735] = bhEne24_0x207620; // 0x2076a4 - g_ps2RecompiledFunctionTable[269736] = bhEne24_0x207620; // 0x2076a8 - g_ps2RecompiledFunctionTable[269737] = bhEne24_0x207620; // 0x2076ac - g_ps2RecompiledFunctionTable[269738] = bhEne24_0x207620; // 0x2076b0 - g_ps2RecompiledFunctionTable[269739] = bhEne24_0x207620; // 0x2076b4 - g_ps2RecompiledFunctionTable[269740] = bhEne24_0x207620; // 0x2076b8 - g_ps2RecompiledFunctionTable[269741] = bhEne24_0x207620; // 0x2076bc - g_ps2RecompiledFunctionTable[269742] = bhEne24_0x207620; // 0x2076c0 - g_ps2RecompiledFunctionTable[269743] = bhEne24_0x207620; // 0x2076c4 - g_ps2RecompiledFunctionTable[269744] = bhEne24_0x207620; // 0x2076c8 - g_ps2RecompiledFunctionTable[269745] = bhEne24_0x207620; // 0x2076cc - g_ps2RecompiledFunctionTable[269746] = bhEne24_0x207620; // 0x2076d0 - g_ps2RecompiledFunctionTable[269747] = bhEne24_0x207620; // 0x2076d4 - g_ps2RecompiledFunctionTable[269748] = bhEne24_0x207620; // 0x2076d8 - g_ps2RecompiledFunctionTable[269749] = bhEne24_0x207620; // 0x2076dc - g_ps2RecompiledFunctionTable[269750] = bhEne24_0x207620; // 0x2076e0 - g_ps2RecompiledFunctionTable[269751] = bhEne24_0x207620; // 0x2076e4 - g_ps2RecompiledFunctionTable[269752] = bhEne24_0x207620; // 0x2076e8 - g_ps2RecompiledFunctionTable[269753] = bhEne24_0x207620; // 0x2076ec - g_ps2RecompiledFunctionTable[269754] = bhEne24_0x207620; // 0x2076f0 - g_ps2RecompiledFunctionTable[269755] = bhEne24_0x207620; // 0x2076f4 - g_ps2RecompiledFunctionTable[269756] = bhEne24_0x207620; // 0x2076f8 - g_ps2RecompiledFunctionTable[269757] = bhEne24_0x207620; // 0x2076fc - g_ps2RecompiledFunctionTable[269758] = bhEne24_0x207620; // 0x207700 - g_ps2RecompiledFunctionTable[269759] = bhEne24_0x207620; // 0x207704 - g_ps2RecompiledFunctionTable[269760] = bhEne24_0x207620; // 0x207708 - g_ps2RecompiledFunctionTable[269761] = bhEne24_0x207620; // 0x20770c - g_ps2RecompiledFunctionTable[269762] = bhEne24_0x207620; // 0x207710 - g_ps2RecompiledFunctionTable[269763] = bhEne24_0x207620; // 0x207714 - g_ps2RecompiledFunctionTable[269764] = bhEne24_0x207620; // 0x207718 - g_ps2RecompiledFunctionTable[269765] = bhEne24_0x207620; // 0x20771c - g_ps2RecompiledFunctionTable[269766] = bhEne24_0x207620; // 0x207720 - g_ps2RecompiledFunctionTable[269767] = bhEne24_0x207620; // 0x207724 - g_ps2RecompiledFunctionTable[269768] = bhEne24_0x207620; // 0x207728 - g_ps2RecompiledFunctionTable[269769] = bhEne24_0x207620; // 0x20772c - g_ps2RecompiledFunctionTable[269770] = bhEne24_0x207620; // 0x207730 - g_ps2RecompiledFunctionTable[269771] = bhEne24_0x207620; // 0x207734 - g_ps2RecompiledFunctionTable[269772] = bhEne24_0x207620; // 0x207738 - g_ps2RecompiledFunctionTable[269774] = bhEne24_Init_0x207740; // 0x207740 - g_ps2RecompiledFunctionTable[269806] = bhEne24_Init_0x207740; // 0x2077c0 - g_ps2RecompiledFunctionTable[269832] = bhEne24_Init_0x207740; // 0x207828 - g_ps2RecompiledFunctionTable[269845] = bhEne24_Init_0x207740; // 0x20785c - g_ps2RecompiledFunctionTable[269854] = bhEne24_Brain_0x207880; // 0x207880 - g_ps2RecompiledFunctionTable[269855] = bhEne24_Brain_0x207880; // 0x207884 - g_ps2RecompiledFunctionTable[269856] = bhEne24_Brain_0x207880; // 0x207888 - g_ps2RecompiledFunctionTable[269857] = bhEne24_Brain_0x207880; // 0x20788c - g_ps2RecompiledFunctionTable[269858] = bhEne24_Brain_0x207880; // 0x207890 - g_ps2RecompiledFunctionTable[269859] = bhEne24_Brain_0x207880; // 0x207894 - g_ps2RecompiledFunctionTable[269860] = bhEne24_Brain_0x207880; // 0x207898 - g_ps2RecompiledFunctionTable[269861] = bhEne24_Brain_0x207880; // 0x20789c - g_ps2RecompiledFunctionTable[269862] = bhEne24_BR00_0x2078a0; // 0x2078a0 - g_ps2RecompiledFunctionTable[269871] = bhEne24_BR00_0x2078a0; // 0x2078c4 - g_ps2RecompiledFunctionTable[269876] = bhEne24_BR00_0x2078a0; // 0x2078d8 - g_ps2RecompiledFunctionTable[269926] = bhEne24_BR00_0x2078a0; // 0x2079a0 - g_ps2RecompiledFunctionTable[269939] = bhEne24_BR00_0x2078a0; // 0x2079d4 - g_ps2RecompiledFunctionTable[269946] = bhEne24_Move_0x2079f0; // 0x2079f0 - g_ps2RecompiledFunctionTable[269947] = bhEne24_Move_0x2079f0; // 0x2079f4 - g_ps2RecompiledFunctionTable[269948] = bhEne24_Move_0x2079f0; // 0x2079f8 - g_ps2RecompiledFunctionTable[269949] = bhEne24_Move_0x2079f0; // 0x2079fc - g_ps2RecompiledFunctionTable[269950] = bhEne24_Move_0x2079f0; // 0x207a00 - g_ps2RecompiledFunctionTable[269951] = bhEne24_Move_0x2079f0; // 0x207a04 - g_ps2RecompiledFunctionTable[269952] = bhEne24_Move_0x2079f0; // 0x207a08 - g_ps2RecompiledFunctionTable[269953] = bhEne24_Move_0x2079f0; // 0x207a0c - g_ps2RecompiledFunctionTable[269954] = bhEne24_Move_0x2079f0; // 0x207a10 - g_ps2RecompiledFunctionTable[269955] = bhEne24_Move_0x2079f0; // 0x207a14 - g_ps2RecompiledFunctionTable[269956] = bhEne24_Move_0x2079f0; // 0x207a18 - g_ps2RecompiledFunctionTable[269957] = bhEne24_Move_0x2079f0; // 0x207a1c - g_ps2RecompiledFunctionTable[269958] = bhEne24_Move_0x2079f0; // 0x207a20 - g_ps2RecompiledFunctionTable[269959] = bhEne24_Move_0x2079f0; // 0x207a24 - g_ps2RecompiledFunctionTable[269960] = bhEne24_Move_0x2079f0; // 0x207a28 - g_ps2RecompiledFunctionTable[269961] = bhEne24_Move_0x2079f0; // 0x207a2c - g_ps2RecompiledFunctionTable[269962] = bhEne24_Move_0x2079f0; // 0x207a30 - g_ps2RecompiledFunctionTable[269963] = bhEne24_Move_0x2079f0; // 0x207a34 - g_ps2RecompiledFunctionTable[269964] = bhEne24_Move_0x2079f0; // 0x207a38 - g_ps2RecompiledFunctionTable[269965] = bhEne24_Move_0x2079f0; // 0x207a3c - g_ps2RecompiledFunctionTable[269966] = bhEne24_Move_0x2079f0; // 0x207a40 - g_ps2RecompiledFunctionTable[269967] = bhEne24_Move_0x2079f0; // 0x207a44 - g_ps2RecompiledFunctionTable[269968] = bhEne24_Move_0x2079f0; // 0x207a48 - g_ps2RecompiledFunctionTable[269969] = bhEne24_Move_0x2079f0; // 0x207a4c - g_ps2RecompiledFunctionTable[269970] = bhEne24_Move_0x2079f0; // 0x207a50 - g_ps2RecompiledFunctionTable[269971] = bhEne24_Move_0x2079f0; // 0x207a54 - g_ps2RecompiledFunctionTable[269972] = bhEne24_Move_0x2079f0; // 0x207a58 - g_ps2RecompiledFunctionTable[269973] = bhEne24_Move_0x2079f0; // 0x207a5c - g_ps2RecompiledFunctionTable[269974] = bhEne24_Move_0x2079f0; // 0x207a60 - g_ps2RecompiledFunctionTable[269975] = bhEne24_Move_0x2079f0; // 0x207a64 - g_ps2RecompiledFunctionTable[269976] = bhEne24_Move_0x2079f0; // 0x207a68 - g_ps2RecompiledFunctionTable[269977] = bhEne24_Move_0x2079f0; // 0x207a6c - g_ps2RecompiledFunctionTable[269978] = bhEne24_Move_0x2079f0; // 0x207a70 - g_ps2RecompiledFunctionTable[269979] = bhEne24_Move_0x2079f0; // 0x207a74 - g_ps2RecompiledFunctionTable[269980] = bhEne24_Move_0x2079f0; // 0x207a78 - g_ps2RecompiledFunctionTable[269981] = bhEne24_Move_0x2079f0; // 0x207a7c - g_ps2RecompiledFunctionTable[269982] = bhEne24_Move_0x2079f0; // 0x207a80 - g_ps2RecompiledFunctionTable[269983] = bhEne24_Move_0x2079f0; // 0x207a84 - g_ps2RecompiledFunctionTable[269984] = bhEne24_Move_0x2079f0; // 0x207a88 - g_ps2RecompiledFunctionTable[269985] = bhEne24_Move_0x2079f0; // 0x207a8c - g_ps2RecompiledFunctionTable[269986] = bhEne24_Move_0x2079f0; // 0x207a90 - g_ps2RecompiledFunctionTable[269987] = bhEne24_Move_0x2079f0; // 0x207a94 - g_ps2RecompiledFunctionTable[269988] = bhEne24_Move_0x2079f0; // 0x207a98 - g_ps2RecompiledFunctionTable[269989] = bhEne24_Move_0x2079f0; // 0x207a9c - g_ps2RecompiledFunctionTable[269990] = bhEne24_Move_0x2079f0; // 0x207aa0 - g_ps2RecompiledFunctionTable[269991] = bhEne24_Move_0x2079f0; // 0x207aa4 - g_ps2RecompiledFunctionTable[269992] = bhEne24_Move_0x2079f0; // 0x207aa8 - g_ps2RecompiledFunctionTable[269993] = bhEne24_Move_0x2079f0; // 0x207aac - g_ps2RecompiledFunctionTable[269994] = bhEne24_Move_0x2079f0; // 0x207ab0 - g_ps2RecompiledFunctionTable[269995] = bhEne24_Move_0x2079f0; // 0x207ab4 - g_ps2RecompiledFunctionTable[269996] = bhEne24_Move_0x2079f0; // 0x207ab8 - g_ps2RecompiledFunctionTable[269997] = bhEne24_Move_0x2079f0; // 0x207abc - g_ps2RecompiledFunctionTable[269998] = bhEne24_Move_0x2079f0; // 0x207ac0 - g_ps2RecompiledFunctionTable[269999] = bhEne24_Move_0x2079f0; // 0x207ac4 - g_ps2RecompiledFunctionTable[270000] = bhEne24_Move_0x2079f0; // 0x207ac8 - g_ps2RecompiledFunctionTable[270001] = bhEne24_Move_0x2079f0; // 0x207acc - g_ps2RecompiledFunctionTable[270002] = bhEne24_Move_0x2079f0; // 0x207ad0 - g_ps2RecompiledFunctionTable[270003] = bhEne24_Move_0x2079f0; // 0x207ad4 - g_ps2RecompiledFunctionTable[270004] = bhEne24_Move_0x2079f0; // 0x207ad8 - g_ps2RecompiledFunctionTable[270005] = bhEne24_Move_0x2079f0; // 0x207adc - g_ps2RecompiledFunctionTable[270006] = bhEne24_Move_0x2079f0; // 0x207ae0 - g_ps2RecompiledFunctionTable[270007] = bhEne24_Move_0x2079f0; // 0x207ae4 - g_ps2RecompiledFunctionTable[270008] = bhEne24_Move_0x2079f0; // 0x207ae8 - g_ps2RecompiledFunctionTable[270009] = bhEne24_Move_0x2079f0; // 0x207aec - g_ps2RecompiledFunctionTable[270010] = bhEne24_Move_0x2079f0; // 0x207af0 - g_ps2RecompiledFunctionTable[270011] = bhEne24_Move_0x2079f0; // 0x207af4 - g_ps2RecompiledFunctionTable[270012] = bhEne24_Move_0x2079f0; // 0x207af8 - g_ps2RecompiledFunctionTable[270013] = bhEne24_Move_0x2079f0; // 0x207afc - g_ps2RecompiledFunctionTable[270014] = bhEne24_Move_0x2079f0; // 0x207b00 - g_ps2RecompiledFunctionTable[270015] = bhEne24_Move_0x2079f0; // 0x207b04 - g_ps2RecompiledFunctionTable[270016] = bhEne24_Move_0x2079f0; // 0x207b08 - g_ps2RecompiledFunctionTable[270017] = bhEne24_Move_0x2079f0; // 0x207b0c - g_ps2RecompiledFunctionTable[270018] = bhEne24_Move_0x2079f0; // 0x207b10 - g_ps2RecompiledFunctionTable[270019] = bhEne24_Move_0x2079f0; // 0x207b14 - g_ps2RecompiledFunctionTable[270020] = bhEne24_Move_0x2079f0; // 0x207b18 - g_ps2RecompiledFunctionTable[270021] = bhEne24_Move_0x2079f0; // 0x207b1c - g_ps2RecompiledFunctionTable[270022] = bhEne24_Move_0x2079f0; // 0x207b20 - g_ps2RecompiledFunctionTable[270023] = bhEne24_Move_0x2079f0; // 0x207b24 - g_ps2RecompiledFunctionTable[270024] = bhEne24_Move_0x2079f0; // 0x207b28 - g_ps2RecompiledFunctionTable[270025] = bhEne24_Move_0x2079f0; // 0x207b2c - g_ps2RecompiledFunctionTable[270026] = bhEne24_Move_0x2079f0; // 0x207b30 - g_ps2RecompiledFunctionTable[270027] = bhEne24_Move_0x2079f0; // 0x207b34 - g_ps2RecompiledFunctionTable[270028] = bhEne24_Move_0x2079f0; // 0x207b38 - g_ps2RecompiledFunctionTable[270029] = bhEne24_Move_0x2079f0; // 0x207b3c - g_ps2RecompiledFunctionTable[270030] = bhEne24_Move_0x2079f0; // 0x207b40 - g_ps2RecompiledFunctionTable[270031] = bhEne24_Move_0x2079f0; // 0x207b44 - g_ps2RecompiledFunctionTable[270032] = bhEne24_Move_0x2079f0; // 0x207b48 - g_ps2RecompiledFunctionTable[270033] = bhEne24_Move_0x2079f0; // 0x207b4c - g_ps2RecompiledFunctionTable[270034] = bhEne24_Move_0x2079f0; // 0x207b50 - g_ps2RecompiledFunctionTable[270035] = bhEne24_Move_0x2079f0; // 0x207b54 - g_ps2RecompiledFunctionTable[270036] = bhEne24_Move_0x2079f0; // 0x207b58 - g_ps2RecompiledFunctionTable[270037] = bhEne24_Move_0x2079f0; // 0x207b5c - g_ps2RecompiledFunctionTable[270038] = bhEne24_Move_0x2079f0; // 0x207b60 - g_ps2RecompiledFunctionTable[270039] = bhEne24_Move_0x2079f0; // 0x207b64 - g_ps2RecompiledFunctionTable[270040] = bhEne24_Move_0x2079f0; // 0x207b68 - g_ps2RecompiledFunctionTable[270041] = bhEne24_Move_0x2079f0; // 0x207b6c - g_ps2RecompiledFunctionTable[270042] = bhEne24_Move_0x2079f0; // 0x207b70 - g_ps2RecompiledFunctionTable[270043] = bhEne24_Move_0x2079f0; // 0x207b74 - g_ps2RecompiledFunctionTable[270044] = bhEne24_Move_0x2079f0; // 0x207b78 - g_ps2RecompiledFunctionTable[270045] = bhEne24_Move_0x2079f0; // 0x207b7c - g_ps2RecompiledFunctionTable[270046] = bhEne24_Move_0x2079f0; // 0x207b80 - g_ps2RecompiledFunctionTable[270047] = bhEne24_Move_0x2079f0; // 0x207b84 - g_ps2RecompiledFunctionTable[270048] = bhEne24_Move_0x2079f0; // 0x207b88 - g_ps2RecompiledFunctionTable[270049] = bhEne24_Move_0x2079f0; // 0x207b8c - g_ps2RecompiledFunctionTable[270050] = bhEne24_Move_0x2079f0; // 0x207b90 - g_ps2RecompiledFunctionTable[270051] = bhEne24_Move_0x2079f0; // 0x207b94 - g_ps2RecompiledFunctionTable[270052] = bhEne24_Move_0x2079f0; // 0x207b98 - g_ps2RecompiledFunctionTable[270053] = bhEne24_Move_0x2079f0; // 0x207b9c - g_ps2RecompiledFunctionTable[270054] = bhEne24_Move_0x2079f0; // 0x207ba0 - g_ps2RecompiledFunctionTable[270055] = bhEne24_Move_0x2079f0; // 0x207ba4 - g_ps2RecompiledFunctionTable[270056] = bhEne24_Move_0x2079f0; // 0x207ba8 - g_ps2RecompiledFunctionTable[270057] = bhEne24_Move_0x2079f0; // 0x207bac - g_ps2RecompiledFunctionTable[270058] = bhEne24_Move_0x2079f0; // 0x207bb0 - g_ps2RecompiledFunctionTable[270059] = bhEne24_Move_0x2079f0; // 0x207bb4 - g_ps2RecompiledFunctionTable[270060] = bhEne24_Move_0x2079f0; // 0x207bb8 - g_ps2RecompiledFunctionTable[270061] = bhEne24_Move_0x2079f0; // 0x207bbc - g_ps2RecompiledFunctionTable[270062] = bhEne24_Move_0x2079f0; // 0x207bc0 - g_ps2RecompiledFunctionTable[270063] = bhEne24_Move_0x2079f0; // 0x207bc4 - g_ps2RecompiledFunctionTable[270064] = bhEne24_Move_0x2079f0; // 0x207bc8 - g_ps2RecompiledFunctionTable[270065] = bhEne24_Move_0x2079f0; // 0x207bcc - g_ps2RecompiledFunctionTable[270066] = bhEne24_Move_0x2079f0; // 0x207bd0 - g_ps2RecompiledFunctionTable[270067] = bhEne24_Move_0x2079f0; // 0x207bd4 - g_ps2RecompiledFunctionTable[270068] = bhEne24_Move_0x2079f0; // 0x207bd8 - g_ps2RecompiledFunctionTable[270069] = bhEne24_Move_0x2079f0; // 0x207bdc - g_ps2RecompiledFunctionTable[270070] = bhEne24_Move_0x2079f0; // 0x207be0 - g_ps2RecompiledFunctionTable[270071] = bhEne24_Move_0x2079f0; // 0x207be4 - g_ps2RecompiledFunctionTable[270072] = bhEne24_Move_0x2079f0; // 0x207be8 - g_ps2RecompiledFunctionTable[270073] = bhEne24_Move_0x2079f0; // 0x207bec - g_ps2RecompiledFunctionTable[270074] = bhEne24_Move_0x2079f0; // 0x207bf0 - g_ps2RecompiledFunctionTable[270075] = bhEne24_Move_0x2079f0; // 0x207bf4 - g_ps2RecompiledFunctionTable[270076] = bhEne24_Move_0x2079f0; // 0x207bf8 - g_ps2RecompiledFunctionTable[270077] = bhEne24_Move_0x2079f0; // 0x207bfc - g_ps2RecompiledFunctionTable[270078] = bhEne24_Move_0x2079f0; // 0x207c00 - g_ps2RecompiledFunctionTable[270079] = bhEne24_Move_0x2079f0; // 0x207c04 - g_ps2RecompiledFunctionTable[270080] = bhEne24_Move_0x2079f0; // 0x207c08 - g_ps2RecompiledFunctionTable[270081] = bhEne24_Move_0x2079f0; // 0x207c0c - g_ps2RecompiledFunctionTable[270082] = bhEne24_Move_0x2079f0; // 0x207c10 - g_ps2RecompiledFunctionTable[270083] = bhEne24_Move_0x2079f0; // 0x207c14 - g_ps2RecompiledFunctionTable[270084] = bhEne24_Move_0x2079f0; // 0x207c18 - g_ps2RecompiledFunctionTable[270085] = bhEne24_Move_0x2079f0; // 0x207c1c - g_ps2RecompiledFunctionTable[270086] = bhEne24_Move_0x2079f0; // 0x207c20 - g_ps2RecompiledFunctionTable[270087] = bhEne24_Move_0x2079f0; // 0x207c24 - g_ps2RecompiledFunctionTable[270088] = bhEne24_Move_0x2079f0; // 0x207c28 - g_ps2RecompiledFunctionTable[270089] = bhEne24_Move_0x2079f0; // 0x207c2c - g_ps2RecompiledFunctionTable[270090] = bhEne24_Move_0x2079f0; // 0x207c30 - g_ps2RecompiledFunctionTable[270091] = bhEne24_Move_0x2079f0; // 0x207c34 - g_ps2RecompiledFunctionTable[270092] = bhEne24_Move_0x2079f0; // 0x207c38 - g_ps2RecompiledFunctionTable[270093] = bhEne24_Move_0x2079f0; // 0x207c3c - g_ps2RecompiledFunctionTable[270094] = bhEne24_Move_0x2079f0; // 0x207c40 - g_ps2RecompiledFunctionTable[270095] = bhEne24_Move_0x2079f0; // 0x207c44 - g_ps2RecompiledFunctionTable[270096] = bhEne24_Move_0x2079f0; // 0x207c48 - g_ps2RecompiledFunctionTable[270097] = bhEne24_Move_0x2079f0; // 0x207c4c - g_ps2RecompiledFunctionTable[270098] = bhEne24_Move_0x2079f0; // 0x207c50 - g_ps2RecompiledFunctionTable[270099] = bhEne24_Move_0x2079f0; // 0x207c54 - g_ps2RecompiledFunctionTable[270100] = bhEne24_Move_0x2079f0; // 0x207c58 - g_ps2RecompiledFunctionTable[270101] = bhEne24_Move_0x2079f0; // 0x207c5c - g_ps2RecompiledFunctionTable[270102] = bhEne24_Move_0x2079f0; // 0x207c60 - g_ps2RecompiledFunctionTable[270103] = bhEne24_Move_0x2079f0; // 0x207c64 - g_ps2RecompiledFunctionTable[270104] = bhEne24_Move_0x2079f0; // 0x207c68 - g_ps2RecompiledFunctionTable[270105] = bhEne24_Move_0x2079f0; // 0x207c6c - g_ps2RecompiledFunctionTable[270106] = bhEne24_Move_0x2079f0; // 0x207c70 - g_ps2RecompiledFunctionTable[270107] = bhEne24_Move_0x2079f0; // 0x207c74 - g_ps2RecompiledFunctionTable[270108] = bhEne24_Move_0x2079f0; // 0x207c78 - g_ps2RecompiledFunctionTable[270109] = bhEne24_Move_0x2079f0; // 0x207c7c - g_ps2RecompiledFunctionTable[270110] = bhEne24_Move_0x2079f0; // 0x207c80 - g_ps2RecompiledFunctionTable[270111] = bhEne24_Move_0x2079f0; // 0x207c84 - g_ps2RecompiledFunctionTable[270112] = bhEne24_Move_0x2079f0; // 0x207c88 - g_ps2RecompiledFunctionTable[270113] = bhEne24_Move_0x2079f0; // 0x207c8c - g_ps2RecompiledFunctionTable[270114] = bhEne24_Move_0x2079f0; // 0x207c90 - g_ps2RecompiledFunctionTable[270115] = bhEne24_Move_0x2079f0; // 0x207c94 - g_ps2RecompiledFunctionTable[270116] = bhEne24_Move_0x2079f0; // 0x207c98 - g_ps2RecompiledFunctionTable[270117] = bhEne24_Move_0x2079f0; // 0x207c9c - g_ps2RecompiledFunctionTable[270118] = bhEne24_Move_0x2079f0; // 0x207ca0 - g_ps2RecompiledFunctionTable[270119] = bhEne24_Move_0x2079f0; // 0x207ca4 - g_ps2RecompiledFunctionTable[270120] = bhEne24_Move_0x2079f0; // 0x207ca8 - g_ps2RecompiledFunctionTable[270121] = bhEne24_Move_0x2079f0; // 0x207cac - g_ps2RecompiledFunctionTable[270122] = bhEne24_Move_0x2079f0; // 0x207cb0 - g_ps2RecompiledFunctionTable[270123] = bhEne24_Move_0x2079f0; // 0x207cb4 - g_ps2RecompiledFunctionTable[270124] = bhEne24_Move_0x2079f0; // 0x207cb8 - g_ps2RecompiledFunctionTable[270125] = bhEne24_Move_0x2079f0; // 0x207cbc - g_ps2RecompiledFunctionTable[270126] = bhEne24_Move_0x2079f0; // 0x207cc0 - g_ps2RecompiledFunctionTable[270127] = bhEne24_Move_0x2079f0; // 0x207cc4 - g_ps2RecompiledFunctionTable[270130] = bhEne24_MV00_0x207cd0; // 0x207cd0 - g_ps2RecompiledFunctionTable[270134] = bhEne24_MV01_0x207ce0; // 0x207ce0 - g_ps2RecompiledFunctionTable[270155] = bhEne24_MV01_0x207ce0; // 0x207d34 - g_ps2RecompiledFunctionTable[270168] = bhEne24_MV01_0x207ce0; // 0x207d68 - g_ps2RecompiledFunctionTable[270180] = bhEne24_MV01_0x207ce0; // 0x207d98 - g_ps2RecompiledFunctionTable[270206] = bhEne24_MV02_0x207e00; // 0x207e00 - g_ps2RecompiledFunctionTable[270221] = bhEne24_MV02_0x207e00; // 0x207e3c - g_ps2RecompiledFunctionTable[270234] = bhEne24_MV02_0x207e00; // 0x207e70 - g_ps2RecompiledFunctionTable[270237] = bhEne24_MV02_0x207e00; // 0x207e7c - g_ps2RecompiledFunctionTable[270257] = bhEne24_MV02_0x207e00; // 0x207ecc - g_ps2RecompiledFunctionTable[270270] = bhEne24_MV02_0x207e00; // 0x207f00 - g_ps2RecompiledFunctionTable[270283] = bhEne24_MV02_0x207e00; // 0x207f34 - g_ps2RecompiledFunctionTable[270292] = bhEne24_MV02_0x207e00; // 0x207f58 - g_ps2RecompiledFunctionTable[270320] = bhEne24_MV02_0x207e00; // 0x207fc8 - g_ps2RecompiledFunctionTable[270332] = bhEne24_MV02_0x207e00; // 0x207ff8 - g_ps2RecompiledFunctionTable[270337] = bhEne24_MV02_0x207e00; // 0x20800c - g_ps2RecompiledFunctionTable[270347] = bhEne24_MV02_0x207e00; // 0x208034 - g_ps2RecompiledFunctionTable[270359] = bhEne24_MV02_0x207e00; // 0x208064 - g_ps2RecompiledFunctionTable[270375] = bhEne24_MV02_0x207e00; // 0x2080a4 - g_ps2RecompiledFunctionTable[270395] = bhEne24_MV02_0x207e00; // 0x2080f4 - g_ps2RecompiledFunctionTable[270397] = bhEne24_MV02_0x207e00; // 0x2080fc - g_ps2RecompiledFunctionTable[270410] = bhEne24_MV02_0x207e00; // 0x208130 - g_ps2RecompiledFunctionTable[270418] = bhEne24_MV03_0x208150; // 0x208150 - g_ps2RecompiledFunctionTable[270432] = bhEne24_MV03_0x208150; // 0x208188 - g_ps2RecompiledFunctionTable[270452] = bhEne24_MV03_0x208150; // 0x2081d8 - g_ps2RecompiledFunctionTable[270465] = bhEne24_MV03_0x208150; // 0x20820c - g_ps2RecompiledFunctionTable[270494] = bhEne24_MV04_0x208280; // 0x208280 - g_ps2RecompiledFunctionTable[270512] = bhEne24_MV04_0x208280; // 0x2082c8 - g_ps2RecompiledFunctionTable[270524] = bhEne24_MV04_0x208280; // 0x2082f8 - g_ps2RecompiledFunctionTable[270591] = bhEne24_MV04_0x208280; // 0x208404 - g_ps2RecompiledFunctionTable[270635] = bhEne24_MV04_0x208280; // 0x2084b4 - g_ps2RecompiledFunctionTable[270642] = bhEne24_MV04_0x208280; // 0x2084d0 - g_ps2RecompiledFunctionTable[270670] = bhEne24_MV05_0x208540; // 0x208540 - g_ps2RecompiledFunctionTable[270730] = bhEne24_Nage_0x208630; // 0x208630 - g_ps2RecompiledFunctionTable[270734] = bhEne24_Damage_0x208640; // 0x208640 - g_ps2RecompiledFunctionTable[270738] = bhEne24_Die_0x208650; // 0x208650 - g_ps2RecompiledFunctionTable[270742] = bhEne24_Dummy_0x208660; // 0x208660 - g_ps2RecompiledFunctionTable[270746] = bhEne24_CollisionWalls_0x208670; // 0x208670 - g_ps2RecompiledFunctionTable[270755] = bhEne24_CollisionWalls_0x208670; // 0x208694 - g_ps2RecompiledFunctionTable[270766] = bhEne24_CollisionLine_0x2086c0; // 0x2086c0 - g_ps2RecompiledFunctionTable[270778] = bhEne24_CollisionLine_0x2086c0; // 0x2086f0 - g_ps2RecompiledFunctionTable[270782] = bhEne24_CollisionLine_0x2086c0; // 0x208700 - g_ps2RecompiledFunctionTable[270784] = bhEne24_CollisionLine_0x2086c0; // 0x208708 - g_ps2RecompiledFunctionTable[270802] = bhEne24_DeadCheck_0x208750; // 0x208750 - g_ps2RecompiledFunctionTable[270822] = bhEne24_DeadCheck_0x208750; // 0x2087a0 - g_ps2RecompiledFunctionTable[270859] = bhEne24_DeadCheck_0x208750; // 0x208834 - g_ps2RecompiledFunctionTable[270863] = bhEne24_DeadCheck_0x208750; // 0x208844 - g_ps2RecompiledFunctionTable[270899] = bhEne24_DeadCheck_0x208750; // 0x2088d4 - g_ps2RecompiledFunctionTable[270930] = bhEne25_0x208950; // 0x208950 - g_ps2RecompiledFunctionTable[270931] = bhEne25_0x208950; // 0x208954 - g_ps2RecompiledFunctionTable[270932] = bhEne25_0x208950; // 0x208958 - g_ps2RecompiledFunctionTable[270933] = bhEne25_0x208950; // 0x20895c - g_ps2RecompiledFunctionTable[270934] = bhEne25_0x208950; // 0x208960 - g_ps2RecompiledFunctionTable[270935] = bhEne25_0x208950; // 0x208964 - g_ps2RecompiledFunctionTable[270936] = bhEne25_0x208950; // 0x208968 - g_ps2RecompiledFunctionTable[270937] = bhEne25_0x208950; // 0x20896c - g_ps2RecompiledFunctionTable[270938] = bhEne25_0x208950; // 0x208970 - g_ps2RecompiledFunctionTable[270939] = bhEne25_0x208950; // 0x208974 - g_ps2RecompiledFunctionTable[270940] = bhEne25_0x208950; // 0x208978 - g_ps2RecompiledFunctionTable[270941] = bhEne25_0x208950; // 0x20897c - g_ps2RecompiledFunctionTable[270942] = bhEne25_0x208950; // 0x208980 - g_ps2RecompiledFunctionTable[270943] = bhEne25_0x208950; // 0x208984 - g_ps2RecompiledFunctionTable[270944] = bhEne25_0x208950; // 0x208988 - g_ps2RecompiledFunctionTable[270945] = bhEne25_0x208950; // 0x20898c - g_ps2RecompiledFunctionTable[270946] = bhEne25_0x208950; // 0x208990 - g_ps2RecompiledFunctionTable[270947] = bhEne25_0x208950; // 0x208994 - g_ps2RecompiledFunctionTable[270948] = bhEne25_0x208950; // 0x208998 - g_ps2RecompiledFunctionTable[270949] = bhEne25_0x208950; // 0x20899c - g_ps2RecompiledFunctionTable[270950] = bhEne25_0x208950; // 0x2089a0 - g_ps2RecompiledFunctionTable[270951] = bhEne25_0x208950; // 0x2089a4 - g_ps2RecompiledFunctionTable[270952] = bhEne25_0x208950; // 0x2089a8 - g_ps2RecompiledFunctionTable[270953] = bhEne25_0x208950; // 0x2089ac - g_ps2RecompiledFunctionTable[270954] = bhEne25_0x208950; // 0x2089b0 - g_ps2RecompiledFunctionTable[270955] = bhEne25_0x208950; // 0x2089b4 - g_ps2RecompiledFunctionTable[270956] = bhEne25_0x208950; // 0x2089b8 - g_ps2RecompiledFunctionTable[270957] = bhEne25_0x208950; // 0x2089bc - g_ps2RecompiledFunctionTable[270958] = bhEne25_0x208950; // 0x2089c0 - g_ps2RecompiledFunctionTable[270959] = bhEne25_0x208950; // 0x2089c4 - g_ps2RecompiledFunctionTable[270962] = bhEne25_Init_0x2089d0; // 0x2089d0 - g_ps2RecompiledFunctionTable[270971] = bhEne25_Init_0x2089d0; // 0x2089f4 - g_ps2RecompiledFunctionTable[271102] = bhEne25_Brain_0x208c00; // 0x208c00 - g_ps2RecompiledFunctionTable[271106] = bhEne25_Move_0x208c10; // 0x208c10 - g_ps2RecompiledFunctionTable[271107] = bhEne25_Move_0x208c10; // 0x208c14 - g_ps2RecompiledFunctionTable[271108] = bhEne25_Move_0x208c10; // 0x208c18 - g_ps2RecompiledFunctionTable[271109] = bhEne25_Move_0x208c10; // 0x208c1c - g_ps2RecompiledFunctionTable[271110] = bhEne25_Move_0x208c10; // 0x208c20 - g_ps2RecompiledFunctionTable[271111] = bhEne25_Move_0x208c10; // 0x208c24 - g_ps2RecompiledFunctionTable[271112] = bhEne25_Move_0x208c10; // 0x208c28 - g_ps2RecompiledFunctionTable[271113] = bhEne25_Move_0x208c10; // 0x208c2c - g_ps2RecompiledFunctionTable[271114] = bhEne25_Move_0x208c10; // 0x208c30 - g_ps2RecompiledFunctionTable[271115] = bhEne25_Move_0x208c10; // 0x208c34 - g_ps2RecompiledFunctionTable[271116] = bhEne25_Move_0x208c10; // 0x208c38 - g_ps2RecompiledFunctionTable[271117] = bhEne25_Move_0x208c10; // 0x208c3c - g_ps2RecompiledFunctionTable[271118] = bhEne25_Move_0x208c10; // 0x208c40 - g_ps2RecompiledFunctionTable[271119] = bhEne25_Move_0x208c10; // 0x208c44 - g_ps2RecompiledFunctionTable[271120] = bhEne25_Move_0x208c10; // 0x208c48 - g_ps2RecompiledFunctionTable[271121] = bhEne25_Move_0x208c10; // 0x208c4c - g_ps2RecompiledFunctionTable[271122] = bhEne25_Move_0x208c10; // 0x208c50 - g_ps2RecompiledFunctionTable[271123] = bhEne25_Move_0x208c10; // 0x208c54 - g_ps2RecompiledFunctionTable[271124] = bhEne25_Move_0x208c10; // 0x208c58 - g_ps2RecompiledFunctionTable[271125] = bhEne25_Move_0x208c10; // 0x208c5c - g_ps2RecompiledFunctionTable[271126] = bhEne25_Move_0x208c10; // 0x208c60 - g_ps2RecompiledFunctionTable[271127] = bhEne25_Move_0x208c10; // 0x208c64 - g_ps2RecompiledFunctionTable[271128] = bhEne25_Move_0x208c10; // 0x208c68 - g_ps2RecompiledFunctionTable[271129] = bhEne25_Move_0x208c10; // 0x208c6c - g_ps2RecompiledFunctionTable[271130] = bhEne25_Move_0x208c10; // 0x208c70 - g_ps2RecompiledFunctionTable[271131] = bhEne25_Move_0x208c10; // 0x208c74 - g_ps2RecompiledFunctionTable[271132] = bhEne25_Move_0x208c10; // 0x208c78 - g_ps2RecompiledFunctionTable[271133] = bhEne25_Move_0x208c10; // 0x208c7c - g_ps2RecompiledFunctionTable[271134] = bhEne25_Move_0x208c10; // 0x208c80 - g_ps2RecompiledFunctionTable[271135] = bhEne25_Move_0x208c10; // 0x208c84 - g_ps2RecompiledFunctionTable[271136] = bhEne25_Move_0x208c10; // 0x208c88 - g_ps2RecompiledFunctionTable[271137] = bhEne25_Move_0x208c10; // 0x208c8c - g_ps2RecompiledFunctionTable[271138] = bhEne25_Move_0x208c10; // 0x208c90 - g_ps2RecompiledFunctionTable[271139] = bhEne25_Move_0x208c10; // 0x208c94 - g_ps2RecompiledFunctionTable[271140] = bhEne25_Move_0x208c10; // 0x208c98 - g_ps2RecompiledFunctionTable[271141] = bhEne25_Move_0x208c10; // 0x208c9c - g_ps2RecompiledFunctionTable[271142] = bhEne25_Move_0x208c10; // 0x208ca0 - g_ps2RecompiledFunctionTable[271143] = bhEne25_Move_0x208c10; // 0x208ca4 - g_ps2RecompiledFunctionTable[271144] = bhEne25_Move_0x208c10; // 0x208ca8 - g_ps2RecompiledFunctionTable[271145] = bhEne25_Move_0x208c10; // 0x208cac - g_ps2RecompiledFunctionTable[271146] = bhEne25_Move_0x208c10; // 0x208cb0 - g_ps2RecompiledFunctionTable[271147] = bhEne25_Move_0x208c10; // 0x208cb4 - g_ps2RecompiledFunctionTable[271148] = bhEne25_Move_0x208c10; // 0x208cb8 - g_ps2RecompiledFunctionTable[271149] = bhEne25_Move_0x208c10; // 0x208cbc - g_ps2RecompiledFunctionTable[271150] = bhEne25_Move_0x208c10; // 0x208cc0 - g_ps2RecompiledFunctionTable[271151] = bhEne25_Move_0x208c10; // 0x208cc4 - g_ps2RecompiledFunctionTable[271152] = bhEne25_Move_0x208c10; // 0x208cc8 - g_ps2RecompiledFunctionTable[271153] = bhEne25_Move_0x208c10; // 0x208ccc - g_ps2RecompiledFunctionTable[271154] = bhEne25_Move_0x208c10; // 0x208cd0 - g_ps2RecompiledFunctionTable[271155] = bhEne25_Move_0x208c10; // 0x208cd4 - g_ps2RecompiledFunctionTable[271156] = bhEne25_Move_0x208c10; // 0x208cd8 - g_ps2RecompiledFunctionTable[271157] = bhEne25_Move_0x208c10; // 0x208cdc - g_ps2RecompiledFunctionTable[271158] = bhEne25_Move_0x208c10; // 0x208ce0 - g_ps2RecompiledFunctionTable[271159] = bhEne25_Move_0x208c10; // 0x208ce4 - g_ps2RecompiledFunctionTable[271160] = bhEne25_Move_0x208c10; // 0x208ce8 - g_ps2RecompiledFunctionTable[271161] = bhEne25_Move_0x208c10; // 0x208cec - g_ps2RecompiledFunctionTable[271162] = bhEne25_Move_0x208c10; // 0x208cf0 - g_ps2RecompiledFunctionTable[271163] = bhEne25_Move_0x208c10; // 0x208cf4 - g_ps2RecompiledFunctionTable[271164] = bhEne25_Move_0x208c10; // 0x208cf8 - g_ps2RecompiledFunctionTable[271165] = bhEne25_Move_0x208c10; // 0x208cfc - g_ps2RecompiledFunctionTable[271166] = bhEne25_Move_0x208c10; // 0x208d00 - g_ps2RecompiledFunctionTable[271167] = bhEne25_Move_0x208c10; // 0x208d04 - g_ps2RecompiledFunctionTable[271168] = bhEne25_Move_0x208c10; // 0x208d08 - g_ps2RecompiledFunctionTable[271169] = bhEne25_Move_0x208c10; // 0x208d0c - g_ps2RecompiledFunctionTable[271170] = bhEne25_Move_0x208c10; // 0x208d10 - g_ps2RecompiledFunctionTable[271171] = bhEne25_Move_0x208c10; // 0x208d14 - g_ps2RecompiledFunctionTable[271172] = bhEne25_Move_0x208c10; // 0x208d18 - g_ps2RecompiledFunctionTable[271173] = bhEne25_Move_0x208c10; // 0x208d1c - g_ps2RecompiledFunctionTable[271174] = bhEne25_Move_0x208c10; // 0x208d20 - g_ps2RecompiledFunctionTable[271175] = bhEne25_Move_0x208c10; // 0x208d24 - g_ps2RecompiledFunctionTable[271176] = bhEne25_Move_0x208c10; // 0x208d28 - g_ps2RecompiledFunctionTable[271177] = bhEne25_Move_0x208c10; // 0x208d2c - g_ps2RecompiledFunctionTable[271178] = bhEne25_Move_0x208c10; // 0x208d30 - g_ps2RecompiledFunctionTable[271179] = bhEne25_Move_0x208c10; // 0x208d34 - g_ps2RecompiledFunctionTable[271180] = bhEne25_Move_0x208c10; // 0x208d38 - g_ps2RecompiledFunctionTable[271181] = bhEne25_Move_0x208c10; // 0x208d3c - g_ps2RecompiledFunctionTable[271182] = bhEne25_Move_0x208c10; // 0x208d40 - g_ps2RecompiledFunctionTable[271183] = bhEne25_Move_0x208c10; // 0x208d44 - g_ps2RecompiledFunctionTable[271184] = bhEne25_Move_0x208c10; // 0x208d48 - g_ps2RecompiledFunctionTable[271185] = bhEne25_Move_0x208c10; // 0x208d4c - g_ps2RecompiledFunctionTable[271186] = bhEne25_Move_0x208c10; // 0x208d50 - g_ps2RecompiledFunctionTable[271187] = bhEne25_Move_0x208c10; // 0x208d54 - g_ps2RecompiledFunctionTable[271188] = bhEne25_Move_0x208c10; // 0x208d58 - g_ps2RecompiledFunctionTable[271189] = bhEne25_Move_0x208c10; // 0x208d5c - g_ps2RecompiledFunctionTable[271190] = bhEne25_Move_0x208c10; // 0x208d60 - g_ps2RecompiledFunctionTable[271191] = bhEne25_Move_0x208c10; // 0x208d64 - g_ps2RecompiledFunctionTable[271192] = bhEne25_Move_0x208c10; // 0x208d68 - g_ps2RecompiledFunctionTable[271193] = bhEne25_Move_0x208c10; // 0x208d6c - g_ps2RecompiledFunctionTable[271194] = bhEne25_Move_0x208c10; // 0x208d70 - g_ps2RecompiledFunctionTable[271195] = bhEne25_Move_0x208c10; // 0x208d74 - g_ps2RecompiledFunctionTable[271196] = bhEne25_Move_0x208c10; // 0x208d78 - g_ps2RecompiledFunctionTable[271197] = bhEne25_Move_0x208c10; // 0x208d7c - g_ps2RecompiledFunctionTable[271198] = bhEne25_Move_0x208c10; // 0x208d80 - g_ps2RecompiledFunctionTable[271199] = bhEne25_Move_0x208c10; // 0x208d84 - g_ps2RecompiledFunctionTable[271202] = bhEne25_MV00_0x208d90; // 0x208d90 - g_ps2RecompiledFunctionTable[271214] = bhEne25_MV01_0x208dc0; // 0x208dc0 - g_ps2RecompiledFunctionTable[271354] = bhEne25_MV01_0x208dc0; // 0x208ff0 - g_ps2RecompiledFunctionTable[271357] = bhEne25_MV01_0x208dc0; // 0x208ffc - g_ps2RecompiledFunctionTable[271361] = bhEne25_MV01_0x208dc0; // 0x20900c - g_ps2RecompiledFunctionTable[271376] = bhEne25_MV01_0x208dc0; // 0x209048 - g_ps2RecompiledFunctionTable[271414] = bhEne25_MV02_0x2090e0; // 0x2090e0 - g_ps2RecompiledFunctionTable[271435] = bhEne25_MV02_0x2090e0; // 0x209134 - g_ps2RecompiledFunctionTable[271474] = bhEne25_MV03_0x2091d0; // 0x2091d0 - g_ps2RecompiledFunctionTable[271502] = bhEne25_Nage_0x209240; // 0x209240 - g_ps2RecompiledFunctionTable[271506] = bhEne25_Damage_0x209250; // 0x209250 - g_ps2RecompiledFunctionTable[271510] = bhEne25_Die_0x209260; // 0x209260 - g_ps2RecompiledFunctionTable[271514] = bhEne25_SetEffect_0x209270; // 0x209270 - g_ps2RecompiledFunctionTable[271521] = bhEne25_SetEffect_0x209270; // 0x20928c - g_ps2RecompiledFunctionTable[271613] = bhEne25_SetEffect_0x209270; // 0x2093fc - g_ps2RecompiledFunctionTable[271645] = bhEne25_SetEffect_0x209270; // 0x20947c - g_ps2RecompiledFunctionTable[271677] = bhEne25_SetEffect_0x209270; // 0x2094fc - g_ps2RecompiledFunctionTable[271709] = bhEne25_SetEffect_0x209270; // 0x20957c - g_ps2RecompiledFunctionTable[271722] = bhEne25_PlayerControl_0x2095b0; // 0x2095b0 - g_ps2RecompiledFunctionTable[271774] = bhEne25_PlayerControl_0x2095b0; // 0x209680 - g_ps2RecompiledFunctionTable[271794] = bhEne26_0x2096d0; // 0x2096d0 - g_ps2RecompiledFunctionTable[271799] = bhEne26_0x2096d0; // 0x2096e4 - g_ps2RecompiledFunctionTable[271803] = bhEne26_0x2096d0; // 0x2096f4 - g_ps2RecompiledFunctionTable[271837] = bhEne26_0x2096d0; // 0x20977c - g_ps2RecompiledFunctionTable[271847] = bhEne26_0x2096d0; // 0x2097a4 - g_ps2RecompiledFunctionTable[271850] = bhEne26_0x2096d0; // 0x2097b0 - g_ps2RecompiledFunctionTable[271854] = bhEne26_DmgCheck_0x2097c0; // 0x2097c0 - g_ps2RecompiledFunctionTable[271869] = bhEne26_DmgCheck_0x2097c0; // 0x2097fc - g_ps2RecompiledFunctionTable[271909] = bhEne26_DmgCheck_0x2097c0; // 0x20989c - g_ps2RecompiledFunctionTable[271953] = bhEne26_DmgCheck_0x2097c0; // 0x20994c - g_ps2RecompiledFunctionTable[271958] = bhEne26_DmgCheck_0x2097c0; // 0x209960 - g_ps2RecompiledFunctionTable[271979] = bhEne26_DmgCheck_0x2097c0; // 0x2099b4 - g_ps2RecompiledFunctionTable[271991] = bhEne26_DmgCheck_0x2097c0; // 0x2099e4 - g_ps2RecompiledFunctionTable[271996] = bhEne26_DmgCheck_0x2097c0; // 0x2099f8 - g_ps2RecompiledFunctionTable[272000] = bhEne26_DmgCheck_0x2097c0; // 0x209a08 - g_ps2RecompiledFunctionTable[272006] = bhEne26_DamageAdd_0x209a20; // 0x209a20 - g_ps2RecompiledFunctionTable[272030] = bhEne26_DamageAdd_0x209a20; // 0x209a80 - g_ps2RecompiledFunctionTable[272070] = bhEne26_DamageAdd_0x209a20; // 0x209b20 - g_ps2RecompiledFunctionTable[272081] = bhEne26_DamageAdd_0x209a20; // 0x209b4c - g_ps2RecompiledFunctionTable[272089] = bhEne26_DamageAdd_0x209a20; // 0x209b6c - g_ps2RecompiledFunctionTable[272093] = bhEne26_DamageAdd_0x209a20; // 0x209b7c - g_ps2RecompiledFunctionTable[272101] = bhEne26_DamageAdd_0x209a20; // 0x209b9c - g_ps2RecompiledFunctionTable[272112] = bhEne26_DamageAdd_0x209a20; // 0x209bc8 - g_ps2RecompiledFunctionTable[272120] = bhEne26_DamageAdd_0x209a20; // 0x209be8 - g_ps2RecompiledFunctionTable[272137] = bhEne26_DamageAdd_0x209a20; // 0x209c2c - g_ps2RecompiledFunctionTable[272146] = bhEne26_LinkFireEffect_0x209c50; // 0x209c50 - g_ps2RecompiledFunctionTable[272215] = bhEne26_LinkFireEffect_0x209c50; // 0x209d64 - g_ps2RecompiledFunctionTable[272236] = bhEne26_LinkFireEffect_0x209c50; // 0x209db8 - g_ps2RecompiledFunctionTable[272264] = bhEne26_LinkFireEffect_0x209c50; // 0x209e28 - g_ps2RecompiledFunctionTable[272293] = bhEne26_LinkFireEffect_0x209c50; // 0x209e9c - g_ps2RecompiledFunctionTable[272322] = bhEne26_DmgCheckType00_0x209f10; // 0x209f10 - g_ps2RecompiledFunctionTable[272345] = bhEne26_DmgCheckType00_0x209f10; // 0x209f6c - g_ps2RecompiledFunctionTable[272352] = bhEne26_DmgCheckType00_0x209f10; // 0x209f88 - g_ps2RecompiledFunctionTable[272355] = bhEne26_DmgCheckType00_0x209f10; // 0x209f94 - g_ps2RecompiledFunctionTable[272361] = bhEne26_DmgCheckType00_0x209f10; // 0x209fac - g_ps2RecompiledFunctionTable[272438] = bhEne26_DmgCheckType00_0x209f10; // 0x20a0e0 - g_ps2RecompiledFunctionTable[272459] = bhEne26_DmgCheckType00_0x209f10; // 0x20a134 - g_ps2RecompiledFunctionTable[272486] = bhEne26_CheckExpHead_0x20a1a0; // 0x20a1a0 - g_ps2RecompiledFunctionTable[272570] = bhEne26_SetBlood_0x20a2f0; // 0x20a2f0 - g_ps2RecompiledFunctionTable[272609] = bhEne26_SetBlood_0x20a2f0; // 0x20a38c - g_ps2RecompiledFunctionTable[272657] = bhEne26_SetBlood_0x20a2f0; // 0x20a44c - g_ps2RecompiledFunctionTable[272664] = bhEne26_SetBlood_0x20a2f0; // 0x20a468 - g_ps2RecompiledFunctionTable[272675] = bhEne26_SetBlood_0x20a2f0; // 0x20a494 - g_ps2RecompiledFunctionTable[272682] = bhEne26_SetBlood_0x20a2f0; // 0x20a4b0 - g_ps2RecompiledFunctionTable[272694] = bhEne26_SetBlood_0x20a2f0; // 0x20a4e0 - g_ps2RecompiledFunctionTable[272721] = bhEne26_SetBlood_0x20a2f0; // 0x20a54c - g_ps2RecompiledFunctionTable[272728] = bhEne26_SetBlood_0x20a2f0; // 0x20a568 - g_ps2RecompiledFunctionTable[272735] = bhEne26_SetBlood_0x20a2f0; // 0x20a584 - g_ps2RecompiledFunctionTable[272770] = bhEne26_SetBlood_0x20a2f0; // 0x20a610 - g_ps2RecompiledFunctionTable[272778] = bhEne26_MainLoop_0x20a630; // 0x20a630 - g_ps2RecompiledFunctionTable[272779] = bhEne26_MainLoop_0x20a630; // 0x20a634 - g_ps2RecompiledFunctionTable[272780] = bhEne26_MainLoop_0x20a630; // 0x20a638 - g_ps2RecompiledFunctionTable[272781] = bhEne26_MainLoop_0x20a630; // 0x20a63c - g_ps2RecompiledFunctionTable[272782] = bhEne26_MainLoop_0x20a630; // 0x20a640 - g_ps2RecompiledFunctionTable[272783] = bhEne26_MainLoop_0x20a630; // 0x20a644 - g_ps2RecompiledFunctionTable[272784] = bhEne26_MainLoop_0x20a630; // 0x20a648 - g_ps2RecompiledFunctionTable[272785] = bhEne26_MainLoop_0x20a630; // 0x20a64c - g_ps2RecompiledFunctionTable[272786] = bhEne26_MainLoop_0x20a630; // 0x20a650 - g_ps2RecompiledFunctionTable[272787] = bhEne26_MainLoop_0x20a630; // 0x20a654 - g_ps2RecompiledFunctionTable[272788] = bhEne26_MainLoop_0x20a630; // 0x20a658 - g_ps2RecompiledFunctionTable[272789] = bhEne26_MainLoop_0x20a630; // 0x20a65c - g_ps2RecompiledFunctionTable[272790] = bhEne26_MainLoop_0x20a630; // 0x20a660 - g_ps2RecompiledFunctionTable[272791] = bhEne26_MainLoop_0x20a630; // 0x20a664 - g_ps2RecompiledFunctionTable[272792] = bhEne26_MainLoop_0x20a630; // 0x20a668 - g_ps2RecompiledFunctionTable[272793] = bhEne26_MainLoop_0x20a630; // 0x20a66c - g_ps2RecompiledFunctionTable[272794] = bhEne26_MainLoop_0x20a630; // 0x20a670 - g_ps2RecompiledFunctionTable[272795] = bhEne26_MainLoop_0x20a630; // 0x20a674 - g_ps2RecompiledFunctionTable[272796] = bhEne26_MainLoop_0x20a630; // 0x20a678 - g_ps2RecompiledFunctionTable[272797] = bhEne26_MainLoop_0x20a630; // 0x20a67c - g_ps2RecompiledFunctionTable[272798] = bhEne26_MainLoop_0x20a630; // 0x20a680 - g_ps2RecompiledFunctionTable[272799] = bhEne26_MainLoop_0x20a630; // 0x20a684 - g_ps2RecompiledFunctionTable[272800] = bhEne26_MainLoop_0x20a630; // 0x20a688 - g_ps2RecompiledFunctionTable[272801] = bhEne26_MainLoop_0x20a630; // 0x20a68c - g_ps2RecompiledFunctionTable[272802] = bhEne26_MainLoop_0x20a630; // 0x20a690 - g_ps2RecompiledFunctionTable[272803] = bhEne26_MainLoop_0x20a630; // 0x20a694 - g_ps2RecompiledFunctionTable[272804] = bhEne26_MainLoop_0x20a630; // 0x20a698 - g_ps2RecompiledFunctionTable[272805] = bhEne26_MainLoop_0x20a630; // 0x20a69c - g_ps2RecompiledFunctionTable[272806] = bhEne26_MainLoop_0x20a630; // 0x20a6a0 - g_ps2RecompiledFunctionTable[272807] = bhEne26_MainLoop_0x20a630; // 0x20a6a4 - g_ps2RecompiledFunctionTable[272810] = bhEne26_PlayerControl_0x20a6b0; // 0x20a6b0 - g_ps2RecompiledFunctionTable[272811] = bhEne26_PlayerControl_0x20a6b0; // 0x20a6b4 - g_ps2RecompiledFunctionTable[272812] = bhEne26_PlayerControl_0x20a6b0; // 0x20a6b8 - g_ps2RecompiledFunctionTable[272813] = bhEne26_PlayerControl_0x20a6b0; // 0x20a6bc - g_ps2RecompiledFunctionTable[272814] = bhEne26_PlayerControl_0x20a6b0; // 0x20a6c0 - g_ps2RecompiledFunctionTable[272815] = bhEne26_PlayerControl_0x20a6b0; // 0x20a6c4 - g_ps2RecompiledFunctionTable[272816] = bhEne26_PlayerControl_0x20a6b0; // 0x20a6c8 - g_ps2RecompiledFunctionTable[272817] = bhEne26_PlayerControl_0x20a6b0; // 0x20a6cc - g_ps2RecompiledFunctionTable[272818] = bhEne26_PlayerControl_0x20a6b0; // 0x20a6d0 - g_ps2RecompiledFunctionTable[272819] = bhEne26_PlayerControl_0x20a6b0; // 0x20a6d4 - g_ps2RecompiledFunctionTable[272820] = bhEne26_PlayerControl_0x20a6b0; // 0x20a6d8 - g_ps2RecompiledFunctionTable[272821] = bhEne26_PlayerControl_0x20a6b0; // 0x20a6dc - g_ps2RecompiledFunctionTable[272822] = bhEne26_PlayerControl_0x20a6b0; // 0x20a6e0 - g_ps2RecompiledFunctionTable[272823] = bhEne26_PlayerControl_0x20a6b0; // 0x20a6e4 - g_ps2RecompiledFunctionTable[272824] = bhEne26_PlayerControl_0x20a6b0; // 0x20a6e8 - g_ps2RecompiledFunctionTable[272825] = bhEne26_PlayerControl_0x20a6b0; // 0x20a6ec - g_ps2RecompiledFunctionTable[272826] = bhEne26_PlayerControl_0x20a6b0; // 0x20a6f0 - g_ps2RecompiledFunctionTable[272827] = bhEne26_PlayerControl_0x20a6b0; // 0x20a6f4 - g_ps2RecompiledFunctionTable[272828] = bhEne26_PlayerControl_0x20a6b0; // 0x20a6f8 - g_ps2RecompiledFunctionTable[272829] = bhEne26_PlayerControl_0x20a6b0; // 0x20a6fc - g_ps2RecompiledFunctionTable[272830] = bhEne26_PlayerControl_0x20a6b0; // 0x20a700 - g_ps2RecompiledFunctionTable[272831] = bhEne26_PlayerControl_0x20a6b0; // 0x20a704 - g_ps2RecompiledFunctionTable[272832] = bhEne26_PlayerControl_0x20a6b0; // 0x20a708 - g_ps2RecompiledFunctionTable[272833] = bhEne26_PlayerControl_0x20a6b0; // 0x20a70c - g_ps2RecompiledFunctionTable[272834] = bhEne26_PlayerControl_0x20a6b0; // 0x20a710 - g_ps2RecompiledFunctionTable[272835] = bhEne26_PlayerControl_0x20a6b0; // 0x20a714 - g_ps2RecompiledFunctionTable[272836] = bhEne26_PlayerControl_0x20a6b0; // 0x20a718 - g_ps2RecompiledFunctionTable[272837] = bhEne26_PlayerControl_0x20a6b0; // 0x20a71c - g_ps2RecompiledFunctionTable[272838] = bhEne26_SetMtn_0x20a720; // 0x20a720 - g_ps2RecompiledFunctionTable[272939] = bhEne26_SetMtn_0x20a720; // 0x20a8b4 - g_ps2RecompiledFunctionTable[272973] = bhEne26_SetMtn_0x20a720; // 0x20a93c - g_ps2RecompiledFunctionTable[273007] = bhEne26_SetMtn_0x20a720; // 0x20a9c4 - g_ps2RecompiledFunctionTable[273021] = bhEne26_SetMtn_0x20a720; // 0x20a9fc - g_ps2RecompiledFunctionTable[273024] = bhEne26_SetMtn_0x20a720; // 0x20aa08 - g_ps2RecompiledFunctionTable[273043] = bhEne26_SetMtn_0x20a720; // 0x20aa54 - g_ps2RecompiledFunctionTable[273103] = bhEne26_SetMtn_0x20a720; // 0x20ab44 - g_ps2RecompiledFunctionTable[273114] = bhEne26_CheckMtnTbl_0x20ab70; // 0x20ab70 - g_ps2RecompiledFunctionTable[273166] = bhEne26_CheckMtnTbl_0x20ab70; // 0x20ac40 - g_ps2RecompiledFunctionTable[273184] = bhEne26_CheckMtnTbl_0x20ab70; // 0x20ac88 - g_ps2RecompiledFunctionTable[273199] = bhEne26_CheckMtnTbl_0x20ab70; // 0x20acc4 - g_ps2RecompiledFunctionTable[273213] = bhEne26_CheckMtnTbl_0x20ab70; // 0x20acfc - g_ps2RecompiledFunctionTable[273252] = bhEne26_CheckMtnTbl_0x20ab70; // 0x20ad98 - g_ps2RecompiledFunctionTable[273260] = bhEne26_CheckMtnTbl_0x20ab70; // 0x20adb8 - g_ps2RecompiledFunctionTable[273272] = bhEne26_CheckMtnTbl_0x20ab70; // 0x20ade8 - g_ps2RecompiledFunctionTable[273280] = bhEne26_CheckMtnTbl_0x20ab70; // 0x20ae08 - g_ps2RecompiledFunctionTable[273292] = bhEne26_CheckMtnTbl_0x20ab70; // 0x20ae38 - g_ps2RecompiledFunctionTable[273300] = bhEne26_CheckMtnTbl_0x20ab70; // 0x20ae58 - g_ps2RecompiledFunctionTable[273312] = bhEne26_CheckMtnTbl_0x20ab70; // 0x20ae88 - g_ps2RecompiledFunctionTable[273320] = bhEne26_CheckMtnTbl_0x20ab70; // 0x20aea8 - g_ps2RecompiledFunctionTable[273356] = bhEne26_CheckMtnTbl_0x20ab70; // 0x20af38 - g_ps2RecompiledFunctionTable[273362] = bhEne26_CheckMtnTbl_0x20ab70; // 0x20af50 - g_ps2RecompiledFunctionTable[273371] = bhEne26_CheckMtnTbl_0x20ab70; // 0x20af74 - g_ps2RecompiledFunctionTable[273388] = bhEne26_CheckMtnTbl_0x20ab70; // 0x20afb8 - g_ps2RecompiledFunctionTable[273394] = bhEne26_CheckMtnTbl_0x20ab70; // 0x20afd0 - g_ps2RecompiledFunctionTable[273402] = bhEne26_CheckMtnTbl_0x20ab70; // 0x20aff0 - g_ps2RecompiledFunctionTable[273422] = bhEne26_SearchNeck_0x20b040; // 0x20b040 - g_ps2RecompiledFunctionTable[273469] = bhEne26_SearchNeck_0x20b040; // 0x20b0fc - g_ps2RecompiledFunctionTable[273514] = bhEne26_CollCheck_0x20b1b0; // 0x20b1b0 - g_ps2RecompiledFunctionTable[273532] = bhEne26_CollCheck_0x20b1b0; // 0x20b1f8 - g_ps2RecompiledFunctionTable[273559] = bhEne26_CollCheck_0x20b1b0; // 0x20b264 - g_ps2RecompiledFunctionTable[273561] = bhEne26_CollCheck_0x20b1b0; // 0x20b26c - g_ps2RecompiledFunctionTable[273564] = bhEne26_CollCheck_0x20b1b0; // 0x20b278 - g_ps2RecompiledFunctionTable[273578] = bhEne26_CollCheck_0x20b1b0; // 0x20b2b0 - g_ps2RecompiledFunctionTable[273594] = bhEne26_CollCheckWall_0x20b2f0; // 0x20b2f0 - g_ps2RecompiledFunctionTable[273615] = bhEne26_CollCheckWall_0x20b2f0; // 0x20b344 - g_ps2RecompiledFunctionTable[273655] = bhEne26_CollCheckWall_0x20b2f0; // 0x20b3e4 - g_ps2RecompiledFunctionTable[273661] = bhEne26_CollCheckWall_0x20b2f0; // 0x20b3fc - g_ps2RecompiledFunctionTable[273705] = bhEne26_CollCheckWall_0x20b2f0; // 0x20b4ac - g_ps2RecompiledFunctionTable[273715] = bhEne26_CollCheckWall_0x20b2f0; // 0x20b4d4 - g_ps2RecompiledFunctionTable[273759] = bhEne26_CollCheckWall_0x20b2f0; // 0x20b584 - g_ps2RecompiledFunctionTable[273765] = bhEne26_CollCheckWall_0x20b2f0; // 0x20b59c - g_ps2RecompiledFunctionTable[273817] = bhEne26_CollCheckWall_0x20b2f0; // 0x20b66c - g_ps2RecompiledFunctionTable[273826] = bhEne26_CollCheckWall_0x20b2f0; // 0x20b690 - g_ps2RecompiledFunctionTable[273848] = bhEne26_CollCheckWall_0x20b2f0; // 0x20b6e8 - g_ps2RecompiledFunctionTable[273880] = bhEne26_CollCheckWall_0x20b2f0; // 0x20b768 - g_ps2RecompiledFunctionTable[273891] = bhEne26_CollCheckWall_0x20b2f0; // 0x20b794 - g_ps2RecompiledFunctionTable[273924] = bhEne26_CollCheckWall_0x20b2f0; // 0x20b818 - g_ps2RecompiledFunctionTable[273933] = bhEne26_CollCheckWall_0x20b2f0; // 0x20b83c - g_ps2RecompiledFunctionTable[273957] = bhEne26_CollCheckWall_0x20b2f0; // 0x20b89c - g_ps2RecompiledFunctionTable[273971] = bhEne26_CollCheckWall_0x20b2f0; // 0x20b8d4 - g_ps2RecompiledFunctionTable[273975] = bhEne26_CollCheckWall_0x20b2f0; // 0x20b8e4 - g_ps2RecompiledFunctionTable[273984] = bhEne26_CollCheckWall_0x20b2f0; // 0x20b908 - g_ps2RecompiledFunctionTable[273988] = bhEne26_CollCheckWall_0x20b2f0; // 0x20b918 - g_ps2RecompiledFunctionTable[274001] = bhEne26_CollCheckWall_0x20b2f0; // 0x20b94c - g_ps2RecompiledFunctionTable[274020] = bhEne26_CollCheckWall_0x20b2f0; // 0x20b998 - g_ps2RecompiledFunctionTable[274042] = bhEne26_PlayerLink_0x20b9f0; // 0x20b9f0 - g_ps2RecompiledFunctionTable[274062] = bhEne26_PlayerLink_0x20b9f0; // 0x20ba40 - g_ps2RecompiledFunctionTable[274067] = bhEne26_PlayerLink_0x20b9f0; // 0x20ba54 - g_ps2RecompiledFunctionTable[274072] = bhEne26_PlayerLink_0x20b9f0; // 0x20ba68 - g_ps2RecompiledFunctionTable[274077] = bhEne26_PlayerLink_0x20b9f0; // 0x20ba7c - g_ps2RecompiledFunctionTable[274133] = bhEne26_PlayerLink_0x20b9f0; // 0x20bb5c - g_ps2RecompiledFunctionTable[274138] = bhEne26_PlayerLink_0x20b9f0; // 0x20bb70 - g_ps2RecompiledFunctionTable[274143] = bhEne26_PlayerLink_0x20b9f0; // 0x20bb84 - g_ps2RecompiledFunctionTable[274147] = bhEne26_PlayerLink_0x20b9f0; // 0x20bb94 - g_ps2RecompiledFunctionTable[274149] = bhEne26_PlayerLink_0x20b9f0; // 0x20bb9c - g_ps2RecompiledFunctionTable[274154] = bhEne26_PlayerLink_0x20b9f0; // 0x20bbb0 - g_ps2RecompiledFunctionTable[274159] = bhEne26_PlayerLink_0x20b9f0; // 0x20bbc4 - g_ps2RecompiledFunctionTable[274166] = bhEne26_CalcEnemy_0x20bbe0; // 0x20bbe0 - g_ps2RecompiledFunctionTable[274171] = bhEne26_CalcEnemy_0x20bbe0; // 0x20bbf4 - g_ps2RecompiledFunctionTable[274218] = bhEne26_Init_0x20bcb0; // 0x20bcb0 - g_ps2RecompiledFunctionTable[274244] = bhEne26_Init_0x20bcb0; // 0x20bd18 - g_ps2RecompiledFunctionTable[274267] = bhEne26_Init_0x20bcb0; // 0x20bd74 - g_ps2RecompiledFunctionTable[274274] = bhEne26_Init_0x20bcb0; // 0x20bd90 - g_ps2RecompiledFunctionTable[274323] = bhEne26_Init_0x20bcb0; // 0x20be54 - g_ps2RecompiledFunctionTable[274346] = bhEne26_Init_0x20bcb0; // 0x20beb0 - g_ps2RecompiledFunctionTable[274368] = bhEne26_Init_0x20bcb0; // 0x20bf08 - g_ps2RecompiledFunctionTable[274373] = bhEne26_Init_0x20bcb0; // 0x20bf1c - g_ps2RecompiledFunctionTable[274375] = bhEne26_Init_0x20bcb0; // 0x20bf24 - g_ps2RecompiledFunctionTable[274390] = bhEne26_Move_0x20bf60; // 0x20bf60 - g_ps2RecompiledFunctionTable[274412] = bhEne26_Move_0x20bf60; // 0x20bfb8 - g_ps2RecompiledFunctionTable[274425] = bhEne26_Move_0x20bf60; // 0x20bfec - g_ps2RecompiledFunctionTable[274430] = bhEne26_MVType_0x20c000; // 0x20c000 - g_ps2RecompiledFunctionTable[274431] = bhEne26_MVType_0x20c000; // 0x20c004 - g_ps2RecompiledFunctionTable[274432] = bhEne26_MVType_0x20c000; // 0x20c008 - g_ps2RecompiledFunctionTable[274433] = bhEne26_MVType_0x20c000; // 0x20c00c - g_ps2RecompiledFunctionTable[274434] = bhEne26_MVType_0x20c000; // 0x20c010 - g_ps2RecompiledFunctionTable[274435] = bhEne26_MVType_0x20c000; // 0x20c014 - g_ps2RecompiledFunctionTable[274436] = bhEne26_MVType_0x20c000; // 0x20c018 - g_ps2RecompiledFunctionTable[274437] = bhEne26_MVType_0x20c000; // 0x20c01c - g_ps2RecompiledFunctionTable[274438] = bhEne26_MVType_0x20c000; // 0x20c020 - g_ps2RecompiledFunctionTable[274439] = bhEne26_MVType_0x20c000; // 0x20c024 - g_ps2RecompiledFunctionTable[274440] = bhEne26_MVType_0x20c000; // 0x20c028 - g_ps2RecompiledFunctionTable[274441] = bhEne26_MVType_0x20c000; // 0x20c02c - g_ps2RecompiledFunctionTable[274442] = bhEne26_MVType_0x20c000; // 0x20c030 - g_ps2RecompiledFunctionTable[274443] = bhEne26_MVType_0x20c000; // 0x20c034 - g_ps2RecompiledFunctionTable[274444] = bhEne26_MVType_0x20c000; // 0x20c038 - g_ps2RecompiledFunctionTable[274445] = bhEne26_MVType_0x20c000; // 0x20c03c - g_ps2RecompiledFunctionTable[274446] = bhEne26_MVType_0x20c000; // 0x20c040 - g_ps2RecompiledFunctionTable[274447] = bhEne26_MVType_0x20c000; // 0x20c044 - g_ps2RecompiledFunctionTable[274448] = bhEne26_MVType_0x20c000; // 0x20c048 - g_ps2RecompiledFunctionTable[274449] = bhEne26_MVType_0x20c000; // 0x20c04c - g_ps2RecompiledFunctionTable[274450] = bhEne26_MVType_0x20c000; // 0x20c050 - g_ps2RecompiledFunctionTable[274451] = bhEne26_MVType_0x20c000; // 0x20c054 - g_ps2RecompiledFunctionTable[274452] = bhEne26_MVType_0x20c000; // 0x20c058 - g_ps2RecompiledFunctionTable[274453] = bhEne26_MVType_0x20c000; // 0x20c05c - g_ps2RecompiledFunctionTable[274454] = bhEne26_MVType_0x20c000; // 0x20c060 - g_ps2RecompiledFunctionTable[274455] = bhEne26_MVType_0x20c000; // 0x20c064 - g_ps2RecompiledFunctionTable[274456] = bhEne26_MVType_0x20c000; // 0x20c068 - g_ps2RecompiledFunctionTable[274457] = bhEne26_MVType_0x20c000; // 0x20c06c - g_ps2RecompiledFunctionTable[274458] = bhEne26_MVType_0x20c000; // 0x20c070 - g_ps2RecompiledFunctionTable[274459] = bhEne26_MVType_0x20c000; // 0x20c074 - g_ps2RecompiledFunctionTable[274460] = bhEne26_MVType_0x20c000; // 0x20c078 - g_ps2RecompiledFunctionTable[274461] = bhEne26_MVType_0x20c000; // 0x20c07c - g_ps2RecompiledFunctionTable[274462] = bhEne26_MVType_0x20c000; // 0x20c080 - g_ps2RecompiledFunctionTable[274463] = bhEne26_MVType_0x20c000; // 0x20c084 - g_ps2RecompiledFunctionTable[274464] = bhEne26_MVType_0x20c000; // 0x20c088 - g_ps2RecompiledFunctionTable[274465] = bhEne26_MVType_0x20c000; // 0x20c08c - g_ps2RecompiledFunctionTable[274466] = bhEne26_MVType_0x20c000; // 0x20c090 - g_ps2RecompiledFunctionTable[274467] = bhEne26_MVType_0x20c000; // 0x20c094 - g_ps2RecompiledFunctionTable[274468] = bhEne26_MVType_0x20c000; // 0x20c098 - g_ps2RecompiledFunctionTable[274469] = bhEne26_MVType_0x20c000; // 0x20c09c - g_ps2RecompiledFunctionTable[274470] = bhEne26_MVType_0x20c000; // 0x20c0a0 - g_ps2RecompiledFunctionTable[274471] = bhEne26_MVType_0x20c000; // 0x20c0a4 - g_ps2RecompiledFunctionTable[274472] = bhEne26_MVType_0x20c000; // 0x20c0a8 - g_ps2RecompiledFunctionTable[274473] = bhEne26_MVType_0x20c000; // 0x20c0ac - g_ps2RecompiledFunctionTable[274474] = bhEne26_MVType_0x20c000; // 0x20c0b0 - g_ps2RecompiledFunctionTable[274475] = bhEne26_MVType_0x20c000; // 0x20c0b4 - g_ps2RecompiledFunctionTable[274476] = bhEne26_MVType_0x20c000; // 0x20c0b8 - g_ps2RecompiledFunctionTable[274477] = bhEne26_MVType_0x20c000; // 0x20c0bc - g_ps2RecompiledFunctionTable[274478] = bhEne26_MVType_0x20c000; // 0x20c0c0 - g_ps2RecompiledFunctionTable[274479] = bhEne26_MVType_0x20c000; // 0x20c0c4 - g_ps2RecompiledFunctionTable[274480] = bhEne26_MVType_0x20c000; // 0x20c0c8 - g_ps2RecompiledFunctionTable[274481] = bhEne26_MVType_0x20c000; // 0x20c0cc - g_ps2RecompiledFunctionTable[274482] = bhEne26_MVType_0x20c000; // 0x20c0d0 - g_ps2RecompiledFunctionTable[274486] = bhEne26_EneSearch_0x20c0e0; // 0x20c0e0 - g_ps2RecompiledFunctionTable[274510] = bhEne26_EneSearch_0x20c0e0; // 0x20c140 - g_ps2RecompiledFunctionTable[274586] = bhEne26_Brain00_0x20c270; // 0x20c270 - g_ps2RecompiledFunctionTable[274591] = bhEne26_Brain00_0x20c270; // 0x20c284 - g_ps2RecompiledFunctionTable[274622] = bhEne26_Brain00_0x20c270; // 0x20c300 - g_ps2RecompiledFunctionTable[274630] = bhEne26_Brain00_0x20c270; // 0x20c320 - g_ps2RecompiledFunctionTable[274649] = bhEne26_Brain00_0x20c270; // 0x20c36c - g_ps2RecompiledFunctionTable[274666] = bhEne26_ActionModeCheck_0x20c3b0; // 0x20c3b0 - g_ps2RecompiledFunctionTable[274685] = bhEne26_ActionModeCheck_0x20c3b0; // 0x20c3fc - g_ps2RecompiledFunctionTable[274728] = bhEne26_ActionModeCheck_0x20c3b0; // 0x20c4a8 - g_ps2RecompiledFunctionTable[274775] = bhEne26_ActionModeCheck_0x20c3b0; // 0x20c564 - g_ps2RecompiledFunctionTable[274812] = bhEne26_ActionModeCheck_0x20c3b0; // 0x20c5f8 - g_ps2RecompiledFunctionTable[274821] = bhEne26_ActionModeCheck_0x20c3b0; // 0x20c61c - g_ps2RecompiledFunctionTable[274834] = bhEne26_ActionModeCheck_0x20c3b0; // 0x20c650 - g_ps2RecompiledFunctionTable[274861] = bhEne26_ActionModeCheck_0x20c3b0; // 0x20c6bc - g_ps2RecompiledFunctionTable[274895] = bhEne26_ActionModeCheck_0x20c3b0; // 0x20c744 - g_ps2RecompiledFunctionTable[274910] = bhEne26_MV00_0x20c780; // 0x20c780 - g_ps2RecompiledFunctionTable[274931] = bhEne26_MV00_0x20c780; // 0x20c7d4 - g_ps2RecompiledFunctionTable[274941] = bhEne26_MV00_0x20c780; // 0x20c7fc - g_ps2RecompiledFunctionTable[274953] = bhEne26_MV00_0x20c780; // 0x20c82c - g_ps2RecompiledFunctionTable[274984] = bhEne26_MV00_0x20c780; // 0x20c8a8 - g_ps2RecompiledFunctionTable[275006] = bhEne26_MV01_0x20c900; // 0x20c900 - g_ps2RecompiledFunctionTable[275024] = bhEne26_MV01_0x20c900; // 0x20c948 - g_ps2RecompiledFunctionTable[275046] = bhEne26_MV01_0x20c900; // 0x20c9a0 - g_ps2RecompiledFunctionTable[275056] = bhEne26_MV01_0x20c900; // 0x20c9c8 - g_ps2RecompiledFunctionTable[275085] = bhEne26_MV01_0x20c900; // 0x20ca3c - g_ps2RecompiledFunctionTable[275095] = bhEne26_MV01_0x20c900; // 0x20ca64 - g_ps2RecompiledFunctionTable[275102] = bhEne26_MV01_0x20c900; // 0x20ca80 - g_ps2RecompiledFunctionTable[275111] = bhEne26_MV01_0x20c900; // 0x20caa4 - g_ps2RecompiledFunctionTable[275137] = bhEne26_MV01_0x20c900; // 0x20cb0c - g_ps2RecompiledFunctionTable[275154] = bhEne26_MV01_0x20c900; // 0x20cb50 - g_ps2RecompiledFunctionTable[275156] = bhEne26_MV01_0x20c900; // 0x20cb58 - g_ps2RecompiledFunctionTable[275170] = bhEne26_MV02_0x20cb90; // 0x20cb90 - g_ps2RecompiledFunctionTable[275191] = bhEne26_MV02_0x20cb90; // 0x20cbe4 - g_ps2RecompiledFunctionTable[275206] = bhEne26_MV02_0x20cb90; // 0x20cc20 - g_ps2RecompiledFunctionTable[275218] = bhEne26_MV02_0x20cb90; // 0x20cc50 - g_ps2RecompiledFunctionTable[275243] = bhEne26_MV02_0x20cb90; // 0x20ccb4 - g_ps2RecompiledFunctionTable[275258] = bhEne26_MV02_0x20cb90; // 0x20ccf0 - g_ps2RecompiledFunctionTable[275270] = bhEne26_MV02_0x20cb90; // 0x20cd20 - g_ps2RecompiledFunctionTable[275330] = bhEne26_MV02_0x20cb90; // 0x20ce10 - g_ps2RecompiledFunctionTable[275335] = bhEne26_MV02_0x20cb90; // 0x20ce24 - g_ps2RecompiledFunctionTable[275352] = bhEne26_MV02_0x20cb90; // 0x20ce68 - g_ps2RecompiledFunctionTable[275358] = bhEne26_MV02_0x20cb90; // 0x20ce80 - g_ps2RecompiledFunctionTable[275375] = bhEne26_MV02_0x20cb90; // 0x20cec4 - g_ps2RecompiledFunctionTable[275377] = bhEne26_MV02_0x20cb90; // 0x20cecc - g_ps2RecompiledFunctionTable[275390] = bhEne26_MV03_0x20cf00; // 0x20cf00 - g_ps2RecompiledFunctionTable[275407] = bhEne26_MV03_0x20cf00; // 0x20cf44 - g_ps2RecompiledFunctionTable[275427] = bhEne26_MV03_0x20cf00; // 0x20cf94 - g_ps2RecompiledFunctionTable[275439] = bhEne26_MV03_0x20cf00; // 0x20cfc4 - g_ps2RecompiledFunctionTable[275478] = bhEne26_MV05_0x20d060; // 0x20d060 - g_ps2RecompiledFunctionTable[275506] = bhEne26_MV05_0x20d060; // 0x20d0d0 - g_ps2RecompiledFunctionTable[275522] = bhEne26_MV05_0x20d060; // 0x20d110 - g_ps2RecompiledFunctionTable[275540] = bhEne26_MV05_0x20d060; // 0x20d158 - g_ps2RecompiledFunctionTable[275553] = bhEne26_MV05_0x20d060; // 0x20d18c - g_ps2RecompiledFunctionTable[275569] = bhEne26_MV05_0x20d060; // 0x20d1cc - g_ps2RecompiledFunctionTable[275591] = bhEne26_MV05_0x20d060; // 0x20d224 - g_ps2RecompiledFunctionTable[275625] = bhEne26_MV05_0x20d060; // 0x20d2ac - g_ps2RecompiledFunctionTable[275648] = bhEne26_MV05_0x20d060; // 0x20d308 - g_ps2RecompiledFunctionTable[275660] = bhEne26_MV05_0x20d060; // 0x20d338 - g_ps2RecompiledFunctionTable[275722] = bhEne26_MV06_0x20d430; // 0x20d430 - g_ps2RecompiledFunctionTable[275737] = bhEne26_MV06_0x20d430; // 0x20d46c - g_ps2RecompiledFunctionTable[275748] = bhEne26_MV06_0x20d430; // 0x20d498 - g_ps2RecompiledFunctionTable[275766] = bhEne26_MV06_0x20d430; // 0x20d4e0 - g_ps2RecompiledFunctionTable[275781] = bhEne26_MV06_0x20d430; // 0x20d51c - g_ps2RecompiledFunctionTable[275814] = bhEne26_MV07_0x20d5a0; // 0x20d5a0 - g_ps2RecompiledFunctionTable[275829] = bhEne26_MV07_0x20d5a0; // 0x20d5dc - g_ps2RecompiledFunctionTable[275842] = bhEne26_MV07_0x20d5a0; // 0x20d610 - g_ps2RecompiledFunctionTable[275914] = bhEne26_MV16_0x20d730; // 0x20d730 - g_ps2RecompiledFunctionTable[275935] = bhEne26_MV16_0x20d730; // 0x20d784 - g_ps2RecompiledFunctionTable[275943] = bhEne26_MV16_0x20d730; // 0x20d7a4 - g_ps2RecompiledFunctionTable[275967] = bhEne26_MV16_0x20d730; // 0x20d804 - g_ps2RecompiledFunctionTable[275982] = bhEne26_Nage_0x20d840; // 0x20d840 - g_ps2RecompiledFunctionTable[275990] = bhEne26_NGType_0x20d860; // 0x20d860 - g_ps2RecompiledFunctionTable[275991] = bhEne26_NGType_0x20d860; // 0x20d864 - g_ps2RecompiledFunctionTable[275992] = bhEne26_NGType_0x20d860; // 0x20d868 - g_ps2RecompiledFunctionTable[275993] = bhEne26_NGType_0x20d860; // 0x20d86c - g_ps2RecompiledFunctionTable[275994] = bhEne26_NGType_0x20d860; // 0x20d870 - g_ps2RecompiledFunctionTable[275995] = bhEne26_NGType_0x20d860; // 0x20d874 - g_ps2RecompiledFunctionTable[275996] = bhEne26_NGType_0x20d860; // 0x20d878 - g_ps2RecompiledFunctionTable[275997] = bhEne26_NGType_0x20d860; // 0x20d87c - g_ps2RecompiledFunctionTable[275998] = bhEne26_NGType_0x20d860; // 0x20d880 - g_ps2RecompiledFunctionTable[275999] = bhEne26_NGType_0x20d860; // 0x20d884 - g_ps2RecompiledFunctionTable[276000] = bhEne26_NGType_0x20d860; // 0x20d888 - g_ps2RecompiledFunctionTable[276001] = bhEne26_NGType_0x20d860; // 0x20d88c - g_ps2RecompiledFunctionTable[276002] = bhEne26_NGType_0x20d860; // 0x20d890 - g_ps2RecompiledFunctionTable[276003] = bhEne26_NGType_0x20d860; // 0x20d894 - g_ps2RecompiledFunctionTable[276004] = bhEne26_NGType_0x20d860; // 0x20d898 - g_ps2RecompiledFunctionTable[276005] = bhEne26_NGType_0x20d860; // 0x20d89c - g_ps2RecompiledFunctionTable[276006] = bhEne26_NGType_0x20d860; // 0x20d8a0 - g_ps2RecompiledFunctionTable[276007] = bhEne26_NGType_0x20d860; // 0x20d8a4 - g_ps2RecompiledFunctionTable[276008] = bhEne26_NGType_0x20d860; // 0x20d8a8 - g_ps2RecompiledFunctionTable[276009] = bhEne26_NGType_0x20d860; // 0x20d8ac - g_ps2RecompiledFunctionTable[276010] = bhEne26_NGType_0x20d860; // 0x20d8b0 - g_ps2RecompiledFunctionTable[276011] = bhEne26_NGType_0x20d860; // 0x20d8b4 - g_ps2RecompiledFunctionTable[276012] = bhEne26_NGType_0x20d860; // 0x20d8b8 - g_ps2RecompiledFunctionTable[276013] = bhEne26_NGType_0x20d860; // 0x20d8bc - g_ps2RecompiledFunctionTable[276014] = bhEne26_NGType_0x20d860; // 0x20d8c0 - g_ps2RecompiledFunctionTable[276015] = bhEne26_NGType_0x20d860; // 0x20d8c4 - g_ps2RecompiledFunctionTable[276016] = bhEne26_NGType_0x20d860; // 0x20d8c8 - g_ps2RecompiledFunctionTable[276017] = bhEne26_NGType_0x20d860; // 0x20d8cc - g_ps2RecompiledFunctionTable[276018] = bhEne26_NGType_0x20d860; // 0x20d8d0 - g_ps2RecompiledFunctionTable[276019] = bhEne26_NGType_0x20d860; // 0x20d8d4 - g_ps2RecompiledFunctionTable[276020] = bhEne26_NGType_0x20d860; // 0x20d8d8 - g_ps2RecompiledFunctionTable[276021] = bhEne26_NGType_0x20d860; // 0x20d8dc - g_ps2RecompiledFunctionTable[276022] = bhEne26_NGType_0x20d860; // 0x20d8e0 - g_ps2RecompiledFunctionTable[276023] = bhEne26_NGType_0x20d860; // 0x20d8e4 - g_ps2RecompiledFunctionTable[276024] = bhEne26_NGType_0x20d860; // 0x20d8e8 - g_ps2RecompiledFunctionTable[276026] = bhEne26_NG00_0x20d8f0; // 0x20d8f0 - g_ps2RecompiledFunctionTable[276055] = bhEne26_NG00_0x20d8f0; // 0x20d964 - g_ps2RecompiledFunctionTable[276067] = bhEne26_NG00_0x20d8f0; // 0x20d994 - g_ps2RecompiledFunctionTable[276078] = bhEne26_NG00_0x20d8f0; // 0x20d9c0 - g_ps2RecompiledFunctionTable[276128] = bhEne26_NG00_0x20d8f0; // 0x20da88 - g_ps2RecompiledFunctionTable[276133] = bhEne26_NG00_0x20d8f0; // 0x20da9c - g_ps2RecompiledFunctionTable[276136] = bhEne26_NG00_0x20d8f0; // 0x20daa8 - g_ps2RecompiledFunctionTable[276140] = bhEne26_NG00_0x20d8f0; // 0x20dab8 - g_ps2RecompiledFunctionTable[276179] = bhEne26_NG00_0x20d8f0; // 0x20db54 - g_ps2RecompiledFunctionTable[276199] = bhEne26_NG00_0x20d8f0; // 0x20dba4 - g_ps2RecompiledFunctionTable[276225] = bhEne26_NG00_0x20d8f0; // 0x20dc0c - g_ps2RecompiledFunctionTable[276269] = bhEne26_NG00_0x20d8f0; // 0x20dcbc - g_ps2RecompiledFunctionTable[276277] = bhEne26_NG00_0x20d8f0; // 0x20dcdc - g_ps2RecompiledFunctionTable[276281] = bhEne26_NG00_0x20d8f0; // 0x20dcec - g_ps2RecompiledFunctionTable[276283] = bhEne26_NG00_0x20d8f0; // 0x20dcf4 - g_ps2RecompiledFunctionTable[276295] = bhEne26_NG00_0x20d8f0; // 0x20dd24 - g_ps2RecompiledFunctionTable[276322] = bhEne26_NG00_0x20d8f0; // 0x20dd90 - g_ps2RecompiledFunctionTable[276415] = bhEne26_NG00_0x20d8f0; // 0x20df04 - g_ps2RecompiledFunctionTable[276438] = bhEne26_PlyDG00_0x20df60; // 0x20df60 - g_ps2RecompiledFunctionTable[276690] = bhEne26_PlyDG00_0x20df60; // 0x20e350 - g_ps2RecompiledFunctionTable[276747] = bhEne26_PlyDG00_0x20df60; // 0x20e434 - g_ps2RecompiledFunctionTable[276755] = bhEne26_PlyDG00_0x20df60; // 0x20e454 - g_ps2RecompiledFunctionTable[276979] = bhEne26_PlyDG00_0x20df60; // 0x20e7d4 - g_ps2RecompiledFunctionTable[277070] = bhEne26_PlyDG00_0x20df60; // 0x20e940 - g_ps2RecompiledFunctionTable[277088] = bhEne26_PlyDG00_0x20df60; // 0x20e988 - g_ps2RecompiledFunctionTable[277099] = bhEne26_PlyDG00_0x20df60; // 0x20e9b4 - g_ps2RecompiledFunctionTable[277166] = bhEne26_Damage_0x20eac0; // 0x20eac0 - g_ps2RecompiledFunctionTable[277174] = bhEne26_DGType_0x20eae0; // 0x20eae0 - g_ps2RecompiledFunctionTable[277175] = bhEne26_DGType_0x20eae0; // 0x20eae4 - g_ps2RecompiledFunctionTable[277176] = bhEne26_DGType_0x20eae0; // 0x20eae8 - g_ps2RecompiledFunctionTable[277177] = bhEne26_DGType_0x20eae0; // 0x20eaec - g_ps2RecompiledFunctionTable[277178] = bhEne26_DGType_0x20eae0; // 0x20eaf0 - g_ps2RecompiledFunctionTable[277179] = bhEne26_DGType_0x20eae0; // 0x20eaf4 - g_ps2RecompiledFunctionTable[277180] = bhEne26_DGType_0x20eae0; // 0x20eaf8 - g_ps2RecompiledFunctionTable[277181] = bhEne26_DGType_0x20eae0; // 0x20eafc - g_ps2RecompiledFunctionTable[277182] = bhEne26_DG00_0x20eb00; // 0x20eb00 - g_ps2RecompiledFunctionTable[277186] = bhEne26_DG01_0x20eb10; // 0x20eb10 - g_ps2RecompiledFunctionTable[277190] = bhEne26_DG02_0x20eb20; // 0x20eb20 - g_ps2RecompiledFunctionTable[277214] = bhEne26_DG02_0x20eb20; // 0x20eb80 - g_ps2RecompiledFunctionTable[277225] = bhEne26_DG02_0x20eb20; // 0x20ebac - g_ps2RecompiledFunctionTable[277240] = bhEne26_DG02_0x20eb20; // 0x20ebe8 - g_ps2RecompiledFunctionTable[277251] = bhEne26_DG02_0x20eb20; // 0x20ec14 - g_ps2RecompiledFunctionTable[277321] = bhEne26_DG02_0x20eb20; // 0x20ed2c - g_ps2RecompiledFunctionTable[277354] = bhEne26_DG03_0x20edb0; // 0x20edb0 - g_ps2RecompiledFunctionTable[277379] = bhEne26_DG03_0x20edb0; // 0x20ee14 - g_ps2RecompiledFunctionTable[277430] = bhEne26_DG04_0x20eee0; // 0x20eee0 - g_ps2RecompiledFunctionTable[277455] = bhEne26_DG04_0x20eee0; // 0x20ef44 - g_ps2RecompiledFunctionTable[277473] = bhEne26_DG04_0x20eee0; // 0x20ef8c - g_ps2RecompiledFunctionTable[277478] = bhEne26_DG04_0x20eee0; // 0x20efa0 - g_ps2RecompiledFunctionTable[277525] = bhEne26_DG04_0x20eee0; // 0x20f05c - g_ps2RecompiledFunctionTable[277562] = bhEne26_DG15_0x20f0f0; // 0x20f0f0 - g_ps2RecompiledFunctionTable[277577] = bhEne26_DG15_0x20f0f0; // 0x20f12c - g_ps2RecompiledFunctionTable[277602] = bhEne26_Die_0x20f190; // 0x20f190 - g_ps2RecompiledFunctionTable[277633] = bhEne26_Die_0x20f190; // 0x20f20c - g_ps2RecompiledFunctionTable[277635] = bhEne26_Die_0x20f190; // 0x20f214 - g_ps2RecompiledFunctionTable[277642] = bhEne26_DDType_0x20f230; // 0x20f230 - g_ps2RecompiledFunctionTable[277643] = bhEne26_DDType_0x20f230; // 0x20f234 - g_ps2RecompiledFunctionTable[277644] = bhEne26_DDType_0x20f230; // 0x20f238 - g_ps2RecompiledFunctionTable[277645] = bhEne26_DDType_0x20f230; // 0x20f23c - g_ps2RecompiledFunctionTable[277646] = bhEne26_DDType_0x20f230; // 0x20f240 - g_ps2RecompiledFunctionTable[277647] = bhEne26_DDType_0x20f230; // 0x20f244 - g_ps2RecompiledFunctionTable[277648] = bhEne26_DDType_0x20f230; // 0x20f248 - g_ps2RecompiledFunctionTable[277649] = bhEne26_DDType_0x20f230; // 0x20f24c - g_ps2RecompiledFunctionTable[277650] = bhEne26_DD00_0x20f250; // 0x20f250 - g_ps2RecompiledFunctionTable[277676] = bhEne26_DD00_0x20f250; // 0x20f2b8 - g_ps2RecompiledFunctionTable[277687] = bhEne26_DD00_0x20f250; // 0x20f2e4 - g_ps2RecompiledFunctionTable[277703] = bhEne26_DD00_0x20f250; // 0x20f324 - g_ps2RecompiledFunctionTable[277715] = bhEne26_DD00_0x20f250; // 0x20f354 - g_ps2RecompiledFunctionTable[277747] = bhEne26_DD00_0x20f250; // 0x20f3d4 - g_ps2RecompiledFunctionTable[277766] = bhEne26_EatCheck_0x20f420; // 0x20f420 - g_ps2RecompiledFunctionTable[277819] = bhEne26_EatCheck_0x20f420; // 0x20f4f4 - g_ps2RecompiledFunctionTable[277834] = bhEne26_EatCheck_0x20f420; // 0x20f530 - g_ps2RecompiledFunctionTable[277878] = bhEne26_EatCheck_0x20f420; // 0x20f5e0 - g_ps2RecompiledFunctionTable[277885] = bhEne26_EatCheck_0x20f420; // 0x20f5fc - g_ps2RecompiledFunctionTable[277922] = bhEne26_ExpHeadEffect_0x20f690; // 0x20f690 - g_ps2RecompiledFunctionTable[277942] = bhEne26_ExpHeadEffect_0x20f690; // 0x20f6e0 - g_ps2RecompiledFunctionTable[277944] = bhEne26_ExpHeadEffect_0x20f690; // 0x20f6e8 - g_ps2RecompiledFunctionTable[277953] = bhEne26_ExpHeadEffect_0x20f690; // 0x20f70c - g_ps2RecompiledFunctionTable[277956] = bhEne26_ExpHeadEffect_0x20f690; // 0x20f718 - g_ps2RecompiledFunctionTable[277959] = bhEne26_ExpHeadEffect_0x20f690; // 0x20f724 - g_ps2RecompiledFunctionTable[277963] = bhEne26_ExpHeadEffect_0x20f690; // 0x20f734 - g_ps2RecompiledFunctionTable[277966] = bhEne26_ExpHeadEffect_0x20f690; // 0x20f740 - g_ps2RecompiledFunctionTable[277969] = bhEne26_ExpHeadEffect_0x20f690; // 0x20f74c - g_ps2RecompiledFunctionTable[277977] = bhEne26_ExpHeadEffect_0x20f690; // 0x20f76c - g_ps2RecompiledFunctionTable[277990] = bhEne26_NeckBloodEffect_0x20f7a0; // 0x20f7a0 - g_ps2RecompiledFunctionTable[278010] = bhEne26_NeckBloodEffect_0x20f7a0; // 0x20f7f0 - g_ps2RecompiledFunctionTable[278017] = bhEne26_NeckBloodEffect_0x20f7a0; // 0x20f80c - g_ps2RecompiledFunctionTable[278020] = bhEne26_NeckBloodEffect_0x20f7a0; // 0x20f818 - g_ps2RecompiledFunctionTable[278025] = bhEne26_NeckBloodEffect_0x20f7a0; // 0x20f82c - g_ps2RecompiledFunctionTable[278029] = bhEne26_NeckBloodEffect_0x20f7a0; // 0x20f83c - g_ps2RecompiledFunctionTable[278032] = bhEne26_NeckBloodEffect_0x20f7a0; // 0x20f848 - g_ps2RecompiledFunctionTable[278045] = bhEne26_NeckBloodEffect_0x20f7a0; // 0x20f87c - g_ps2RecompiledFunctionTable[278047] = bhEne26_NeckBloodEffect_0x20f7a0; // 0x20f884 - g_ps2RecompiledFunctionTable[278050] = bhEne26_NeckBloodEffect_0x20f7a0; // 0x20f890 - g_ps2RecompiledFunctionTable[278055] = bhEne26_NeckBloodEffect_0x20f7a0; // 0x20f8a4 - g_ps2RecompiledFunctionTable[278058] = bhEne26_NeckBloodEffect_0x20f7a0; // 0x20f8b0 - g_ps2RecompiledFunctionTable[278061] = bhEne26_NeckBloodEffect_0x20f7a0; // 0x20f8bc - g_ps2RecompiledFunctionTable[278073] = bhEne26_NeckBloodEffect_0x20f7a0; // 0x20f8ec - g_ps2RecompiledFunctionTable[278090] = bhEne26_KamiEffect_0x20f930; // 0x20f930 - g_ps2RecompiledFunctionTable[278099] = bhEne26_KamiEffect_0x20f930; // 0x20f954 - g_ps2RecompiledFunctionTable[278108] = bhEne26_KamiEffect_0x20f930; // 0x20f978 - g_ps2RecompiledFunctionTable[278123] = bhEne26_KamiEffect_0x20f930; // 0x20f9b4 - g_ps2RecompiledFunctionTable[278132] = bhEne26_KamiEffect_0x20f930; // 0x20f9d8 - g_ps2RecompiledFunctionTable[278146] = bhEne26_SePlay_0x20fa10; // 0x20fa10 - g_ps2RecompiledFunctionTable[278170] = bhEne26_SePlay_0x20fa10; // 0x20fa70 - g_ps2RecompiledFunctionTable[278174] = bhEne26_SePlay_0x20fa10; // 0x20fa80 - g_ps2RecompiledFunctionTable[278191] = bhEne26_SePlay_0x20fa10; // 0x20fac4 - g_ps2RecompiledFunctionTable[278198] = bhEne27_0x20fae0; // 0x20fae0 - g_ps2RecompiledFunctionTable[278199] = bhEne27_0x20fae0; // 0x20fae4 - g_ps2RecompiledFunctionTable[278200] = bhEne27_0x20fae0; // 0x20fae8 - g_ps2RecompiledFunctionTable[278201] = bhEne27_0x20fae0; // 0x20faec - g_ps2RecompiledFunctionTable[278202] = bhEne27_0x20fae0; // 0x20faf0 - g_ps2RecompiledFunctionTable[278203] = bhEne27_0x20fae0; // 0x20faf4 - g_ps2RecompiledFunctionTable[278204] = bhEne27_0x20fae0; // 0x20faf8 - g_ps2RecompiledFunctionTable[278205] = bhEne27_0x20fae0; // 0x20fafc - g_ps2RecompiledFunctionTable[278206] = bhEne27_0x20fae0; // 0x20fb00 - g_ps2RecompiledFunctionTable[278207] = bhEne27_0x20fae0; // 0x20fb04 - g_ps2RecompiledFunctionTable[278208] = bhEne27_0x20fae0; // 0x20fb08 - g_ps2RecompiledFunctionTable[278209] = bhEne27_0x20fae0; // 0x20fb0c - g_ps2RecompiledFunctionTable[278210] = bhEne27_0x20fae0; // 0x20fb10 - g_ps2RecompiledFunctionTable[278211] = bhEne27_0x20fae0; // 0x20fb14 - g_ps2RecompiledFunctionTable[278212] = bhEne27_0x20fae0; // 0x20fb18 - g_ps2RecompiledFunctionTable[278213] = bhEne27_0x20fae0; // 0x20fb1c - g_ps2RecompiledFunctionTable[278214] = bhEne27_0x20fae0; // 0x20fb20 - g_ps2RecompiledFunctionTable[278215] = bhEne27_0x20fae0; // 0x20fb24 - g_ps2RecompiledFunctionTable[278216] = bhEne27_0x20fae0; // 0x20fb28 - g_ps2RecompiledFunctionTable[278217] = bhEne27_0x20fae0; // 0x20fb2c - g_ps2RecompiledFunctionTable[278218] = bhEne27_0x20fae0; // 0x20fb30 - g_ps2RecompiledFunctionTable[278219] = bhEne27_0x20fae0; // 0x20fb34 - g_ps2RecompiledFunctionTable[278220] = bhEne27_0x20fae0; // 0x20fb38 - g_ps2RecompiledFunctionTable[278221] = bhEne27_0x20fae0; // 0x20fb3c - g_ps2RecompiledFunctionTable[278222] = bhEne27_0x20fae0; // 0x20fb40 - g_ps2RecompiledFunctionTable[278223] = bhEne27_0x20fae0; // 0x20fb44 - g_ps2RecompiledFunctionTable[278224] = bhEne27_0x20fae0; // 0x20fb48 - g_ps2RecompiledFunctionTable[278226] = bhEne27_Init_0x20fb50; // 0x20fb50 - g_ps2RecompiledFunctionTable[278257] = bhEne27_Init_0x20fb50; // 0x20fbcc - g_ps2RecompiledFunctionTable[278275] = bhEne27_Init_0x20fb50; // 0x20fc14 - g_ps2RecompiledFunctionTable[278289] = bhEne27_Init_0x20fb50; // 0x20fc4c - g_ps2RecompiledFunctionTable[278318] = bhEne27_Init_0x20fb50; // 0x20fcc0 - g_ps2RecompiledFunctionTable[278398] = bhEne27_Brain_0x20fe00; // 0x20fe00 - g_ps2RecompiledFunctionTable[278399] = bhEne27_Brain_0x20fe00; // 0x20fe04 - g_ps2RecompiledFunctionTable[278400] = bhEne27_Brain_0x20fe00; // 0x20fe08 - g_ps2RecompiledFunctionTable[278401] = bhEne27_Brain_0x20fe00; // 0x20fe0c - g_ps2RecompiledFunctionTable[278402] = bhEne27_BR00_0x20fe10; // 0x20fe10 - g_ps2RecompiledFunctionTable[278419] = bhEne27_BR00_0x20fe10; // 0x20fe54 - g_ps2RecompiledFunctionTable[278458] = bhEne27_Move_0x20fef0; // 0x20fef0 - g_ps2RecompiledFunctionTable[278459] = bhEne27_Move_0x20fef0; // 0x20fef4 - g_ps2RecompiledFunctionTable[278460] = bhEne27_Move_0x20fef0; // 0x20fef8 - g_ps2RecompiledFunctionTable[278461] = bhEne27_Move_0x20fef0; // 0x20fefc - g_ps2RecompiledFunctionTable[278462] = bhEne27_Move_0x20fef0; // 0x20ff00 - g_ps2RecompiledFunctionTable[278463] = bhEne27_Move_0x20fef0; // 0x20ff04 - g_ps2RecompiledFunctionTable[278464] = bhEne27_Move_0x20fef0; // 0x20ff08 - g_ps2RecompiledFunctionTable[278465] = bhEne27_Move_0x20fef0; // 0x20ff0c - g_ps2RecompiledFunctionTable[278466] = bhEne27_Move_0x20fef0; // 0x20ff10 - g_ps2RecompiledFunctionTable[278467] = bhEne27_Move_0x20fef0; // 0x20ff14 - g_ps2RecompiledFunctionTable[278468] = bhEne27_Move_0x20fef0; // 0x20ff18 - g_ps2RecompiledFunctionTable[278469] = bhEne27_Move_0x20fef0; // 0x20ff1c - g_ps2RecompiledFunctionTable[278470] = bhEne27_Move_0x20fef0; // 0x20ff20 - g_ps2RecompiledFunctionTable[278471] = bhEne27_Move_0x20fef0; // 0x20ff24 - g_ps2RecompiledFunctionTable[278472] = bhEne27_Move_0x20fef0; // 0x20ff28 - g_ps2RecompiledFunctionTable[278473] = bhEne27_Move_0x20fef0; // 0x20ff2c - g_ps2RecompiledFunctionTable[278474] = bhEne27_Move_0x20fef0; // 0x20ff30 - g_ps2RecompiledFunctionTable[278475] = bhEne27_Move_0x20fef0; // 0x20ff34 - g_ps2RecompiledFunctionTable[278476] = bhEne27_Move_0x20fef0; // 0x20ff38 - g_ps2RecompiledFunctionTable[278477] = bhEne27_Move_0x20fef0; // 0x20ff3c - g_ps2RecompiledFunctionTable[278478] = bhEne27_Move_0x20fef0; // 0x20ff40 - g_ps2RecompiledFunctionTable[278482] = bhEne27_MV00_0x20ff50; // 0x20ff50 - g_ps2RecompiledFunctionTable[278486] = bhEne27_MV01_0x20ff60; // 0x20ff60 - g_ps2RecompiledFunctionTable[278505] = bhEne27_MV01_0x20ff60; // 0x20ffac - g_ps2RecompiledFunctionTable[278562] = bhEne27_MV02_0x210090; // 0x210090 - g_ps2RecompiledFunctionTable[278603] = bhEne27_MV02_0x210090; // 0x210134 - g_ps2RecompiledFunctionTable[278760] = bhEne27_MV02_0x210090; // 0x2103a8 - g_ps2RecompiledFunctionTable[278771] = bhEne27_MV02_0x210090; // 0x2103d4 - g_ps2RecompiledFunctionTable[278783] = bhEne27_MV02_0x210090; // 0x210404 - g_ps2RecompiledFunctionTable[278786] = bhEne27_MV02_0x210090; // 0x210410 - g_ps2RecompiledFunctionTable[278920] = bhEne27_MV02_0x210090; // 0x210628 - g_ps2RecompiledFunctionTable[278923] = bhEne27_MV02_0x210090; // 0x210634 - g_ps2RecompiledFunctionTable[278927] = bhEne27_MV02_0x210090; // 0x210644 - g_ps2RecompiledFunctionTable[278960] = bhEne27_MV02_0x210090; // 0x2106c8 - g_ps2RecompiledFunctionTable[278964] = bhEne27_MV02_0x210090; // 0x2106d8 - g_ps2RecompiledFunctionTable[278966] = bhEne27_MV02_0x210090; // 0x2106e0 - g_ps2RecompiledFunctionTable[278977] = bhEne27_MV02_0x210090; // 0x21070c - g_ps2RecompiledFunctionTable[278987] = bhEne27_MV02_0x210090; // 0x210734 - g_ps2RecompiledFunctionTable[279018] = bhEne27_Nage_0x2107b0; // 0x2107b0 - g_ps2RecompiledFunctionTable[279022] = bhEne27_Damage_0x2107c0; // 0x2107c0 - g_ps2RecompiledFunctionTable[279026] = bhEne27_Die_0x2107d0; // 0x2107d0 - g_ps2RecompiledFunctionTable[279030] = bhEne27_IncubateEffect_0x2107e0; // 0x2107e0 - g_ps2RecompiledFunctionTable[279098] = bhEne27_CallSE_0x2108f0; // 0x2108f0 - g_ps2RecompiledFunctionTable[279110] = bhEne27_CallSE_0x2108f0; // 0x210920 - g_ps2RecompiledFunctionTable[279133] = bhEne27_CallSE_0x2108f0; // 0x21097c - g_ps2RecompiledFunctionTable[279146] = bhEne27_CallSE_0x2108f0; // 0x2109b0 - g_ps2RecompiledFunctionTable[279161] = bhEne27_CallSE_0x2108f0; // 0x2109ec - g_ps2RecompiledFunctionTable[279166] = bhEne29_0x210a00; // 0x210a00 - g_ps2RecompiledFunctionTable[279167] = bhEne29_0x210a00; // 0x210a04 - g_ps2RecompiledFunctionTable[279168] = bhEne29_0x210a00; // 0x210a08 - g_ps2RecompiledFunctionTable[279169] = bhEne29_0x210a00; // 0x210a0c - g_ps2RecompiledFunctionTable[279170] = bhEne29_0x210a00; // 0x210a10 - g_ps2RecompiledFunctionTable[279171] = bhEne29_0x210a00; // 0x210a14 - g_ps2RecompiledFunctionTable[279172] = bhEne29_0x210a00; // 0x210a18 - g_ps2RecompiledFunctionTable[279173] = bhEne29_0x210a00; // 0x210a1c - g_ps2RecompiledFunctionTable[279174] = bhEne29_0x210a00; // 0x210a20 - g_ps2RecompiledFunctionTable[279175] = bhEne29_0x210a00; // 0x210a24 - g_ps2RecompiledFunctionTable[279176] = bhEne29_0x210a00; // 0x210a28 - g_ps2RecompiledFunctionTable[279177] = bhEne29_0x210a00; // 0x210a2c - g_ps2RecompiledFunctionTable[279178] = bhEne29_0x210a00; // 0x210a30 - g_ps2RecompiledFunctionTable[279179] = bhEne29_0x210a00; // 0x210a34 - g_ps2RecompiledFunctionTable[279180] = bhEne29_0x210a00; // 0x210a38 - g_ps2RecompiledFunctionTable[279181] = bhEne29_0x210a00; // 0x210a3c - g_ps2RecompiledFunctionTable[279182] = bhEne29_0x210a00; // 0x210a40 - g_ps2RecompiledFunctionTable[279183] = bhEne29_0x210a00; // 0x210a44 - g_ps2RecompiledFunctionTable[279184] = bhEne29_0x210a00; // 0x210a48 - g_ps2RecompiledFunctionTable[279185] = bhEne29_0x210a00; // 0x210a4c - g_ps2RecompiledFunctionTable[279186] = bhEne29_0x210a00; // 0x210a50 - g_ps2RecompiledFunctionTable[279187] = bhEne29_0x210a00; // 0x210a54 - g_ps2RecompiledFunctionTable[279188] = bhEne29_0x210a00; // 0x210a58 - g_ps2RecompiledFunctionTable[279189] = bhEne29_0x210a00; // 0x210a5c - g_ps2RecompiledFunctionTable[279190] = bhEne29_0x210a00; // 0x210a60 - g_ps2RecompiledFunctionTable[279194] = bhEne29_Init_0x210a70; // 0x210a70 - g_ps2RecompiledFunctionTable[279205] = bhEne29_Init_0x210a70; // 0x210a9c - g_ps2RecompiledFunctionTable[279210] = bhEne29_Init_0x210a70; // 0x210ab0 - g_ps2RecompiledFunctionTable[279248] = bhEne29_Init_0x210a70; // 0x210b48 - g_ps2RecompiledFunctionTable[279351] = bhEne29_Init_0x210a70; // 0x210ce4 - g_ps2RecompiledFunctionTable[279362] = bhEne29_Init_0x210a70; // 0x210d10 - g_ps2RecompiledFunctionTable[279368] = bhEne29_Init_0x210a70; // 0x210d28 - g_ps2RecompiledFunctionTable[279382] = bhEne29_Move_0x210d60; // 0x210d60 - g_ps2RecompiledFunctionTable[279383] = bhEne29_Move_0x210d60; // 0x210d64 - g_ps2RecompiledFunctionTable[279384] = bhEne29_Move_0x210d60; // 0x210d68 - g_ps2RecompiledFunctionTable[279385] = bhEne29_Move_0x210d60; // 0x210d6c - g_ps2RecompiledFunctionTable[279386] = bhEne29_Move_0x210d60; // 0x210d70 - g_ps2RecompiledFunctionTable[279387] = bhEne29_Move_0x210d60; // 0x210d74 - g_ps2RecompiledFunctionTable[279388] = bhEne29_Move_0x210d60; // 0x210d78 - g_ps2RecompiledFunctionTable[279389] = bhEne29_Move_0x210d60; // 0x210d7c - g_ps2RecompiledFunctionTable[279390] = bhEne29_Move_0x210d60; // 0x210d80 - g_ps2RecompiledFunctionTable[279391] = bhEne29_Move_0x210d60; // 0x210d84 - g_ps2RecompiledFunctionTable[279392] = bhEne29_Move_0x210d60; // 0x210d88 - g_ps2RecompiledFunctionTable[279393] = bhEne29_Move_0x210d60; // 0x210d8c - g_ps2RecompiledFunctionTable[279394] = bhEne29_Move_0x210d60; // 0x210d90 - g_ps2RecompiledFunctionTable[279395] = bhEne29_Move_0x210d60; // 0x210d94 - g_ps2RecompiledFunctionTable[279396] = bhEne29_Move_0x210d60; // 0x210d98 - g_ps2RecompiledFunctionTable[279397] = bhEne29_Move_0x210d60; // 0x210d9c - g_ps2RecompiledFunctionTable[279398] = bhEne29_Move_0x210d60; // 0x210da0 - g_ps2RecompiledFunctionTable[279399] = bhEne29_Move_0x210d60; // 0x210da4 - g_ps2RecompiledFunctionTable[279400] = bhEne29_Move_0x210d60; // 0x210da8 - g_ps2RecompiledFunctionTable[279401] = bhEne29_Move_0x210d60; // 0x210dac - g_ps2RecompiledFunctionTable[279402] = bhEne29_Move_0x210d60; // 0x210db0 - g_ps2RecompiledFunctionTable[279403] = bhEne29_Move_0x210d60; // 0x210db4 - g_ps2RecompiledFunctionTable[279404] = bhEne29_Move_0x210d60; // 0x210db8 - g_ps2RecompiledFunctionTable[279405] = bhEne29_Move_0x210d60; // 0x210dbc - g_ps2RecompiledFunctionTable[279406] = bhEne29_Move_0x210d60; // 0x210dc0 - g_ps2RecompiledFunctionTable[279407] = bhEne29_Move_0x210d60; // 0x210dc4 - g_ps2RecompiledFunctionTable[279408] = bhEne29_Move_0x210d60; // 0x210dc8 - g_ps2RecompiledFunctionTable[279409] = bhEne29_Move_0x210d60; // 0x210dcc - g_ps2RecompiledFunctionTable[279410] = bhEne29_Move_0x210d60; // 0x210dd0 - g_ps2RecompiledFunctionTable[279411] = bhEne29_Move_0x210d60; // 0x210dd4 - g_ps2RecompiledFunctionTable[279412] = bhEne29_Move_0x210d60; // 0x210dd8 - g_ps2RecompiledFunctionTable[279413] = bhEne29_Move_0x210d60; // 0x210ddc - g_ps2RecompiledFunctionTable[279414] = bhEne29_Move_0x210d60; // 0x210de0 - g_ps2RecompiledFunctionTable[279415] = bhEne29_Move_0x210d60; // 0x210de4 - g_ps2RecompiledFunctionTable[279416] = bhEne29_Move_0x210d60; // 0x210de8 - g_ps2RecompiledFunctionTable[279417] = bhEne29_Move_0x210d60; // 0x210dec - g_ps2RecompiledFunctionTable[279418] = bhEne29_Move_0x210d60; // 0x210df0 - g_ps2RecompiledFunctionTable[279419] = bhEne29_Move_0x210d60; // 0x210df4 - g_ps2RecompiledFunctionTable[279420] = bhEne29_Move_0x210d60; // 0x210df8 - g_ps2RecompiledFunctionTable[279421] = bhEne29_Move_0x210d60; // 0x210dfc - g_ps2RecompiledFunctionTable[279422] = bhEne29_Move_0x210d60; // 0x210e00 - g_ps2RecompiledFunctionTable[279423] = bhEne29_Move_0x210d60; // 0x210e04 - g_ps2RecompiledFunctionTable[279424] = bhEne29_Move_0x210d60; // 0x210e08 - g_ps2RecompiledFunctionTable[279425] = bhEne29_Move_0x210d60; // 0x210e0c - g_ps2RecompiledFunctionTable[279426] = bhEne29_Move_0x210d60; // 0x210e10 - g_ps2RecompiledFunctionTable[279427] = bhEne29_Move_0x210d60; // 0x210e14 - g_ps2RecompiledFunctionTable[279428] = bhEne29_Move_0x210d60; // 0x210e18 - g_ps2RecompiledFunctionTable[279429] = bhEne29_Move_0x210d60; // 0x210e1c - g_ps2RecompiledFunctionTable[279430] = bhEne29_Move_0x210d60; // 0x210e20 - g_ps2RecompiledFunctionTable[279431] = bhEne29_Move_0x210d60; // 0x210e24 - g_ps2RecompiledFunctionTable[279432] = bhEne29_Move_0x210d60; // 0x210e28 - g_ps2RecompiledFunctionTable[279433] = bhEne29_Move_0x210d60; // 0x210e2c - g_ps2RecompiledFunctionTable[279434] = bhEne29_Move_0x210d60; // 0x210e30 - g_ps2RecompiledFunctionTable[279435] = bhEne29_Move_0x210d60; // 0x210e34 - g_ps2RecompiledFunctionTable[279436] = bhEne29_Move_0x210d60; // 0x210e38 - g_ps2RecompiledFunctionTable[279437] = bhEne29_Move_0x210d60; // 0x210e3c - g_ps2RecompiledFunctionTable[279438] = bhEne29_Move_0x210d60; // 0x210e40 - g_ps2RecompiledFunctionTable[279439] = bhEne29_Move_0x210d60; // 0x210e44 - g_ps2RecompiledFunctionTable[279440] = bhEne29_Move_0x210d60; // 0x210e48 - g_ps2RecompiledFunctionTable[279441] = bhEne29_Move_0x210d60; // 0x210e4c - g_ps2RecompiledFunctionTable[279442] = bhEne29_Move_0x210d60; // 0x210e50 - g_ps2RecompiledFunctionTable[279443] = bhEne29_Move_0x210d60; // 0x210e54 - g_ps2RecompiledFunctionTable[279444] = bhEne29_Move_0x210d60; // 0x210e58 - g_ps2RecompiledFunctionTable[279445] = bhEne29_Move_0x210d60; // 0x210e5c - g_ps2RecompiledFunctionTable[279446] = bhEne29_Move_0x210d60; // 0x210e60 - g_ps2RecompiledFunctionTable[279447] = bhEne29_Move_0x210d60; // 0x210e64 - g_ps2RecompiledFunctionTable[279448] = bhEne29_Move_0x210d60; // 0x210e68 - g_ps2RecompiledFunctionTable[279449] = bhEne29_Move_0x210d60; // 0x210e6c - g_ps2RecompiledFunctionTable[279450] = bhEne29_Move_0x210d60; // 0x210e70 - g_ps2RecompiledFunctionTable[279451] = bhEne29_Move_0x210d60; // 0x210e74 - g_ps2RecompiledFunctionTable[279452] = bhEne29_Move_0x210d60; // 0x210e78 - g_ps2RecompiledFunctionTable[279453] = bhEne29_Move_0x210d60; // 0x210e7c - g_ps2RecompiledFunctionTable[279454] = bhEne29_Move_0x210d60; // 0x210e80 - g_ps2RecompiledFunctionTable[279455] = bhEne29_Move_0x210d60; // 0x210e84 - g_ps2RecompiledFunctionTable[279456] = bhEne29_Move_0x210d60; // 0x210e88 - g_ps2RecompiledFunctionTable[279457] = bhEne29_Move_0x210d60; // 0x210e8c - g_ps2RecompiledFunctionTable[279458] = bhEne29_Move_0x210d60; // 0x210e90 - g_ps2RecompiledFunctionTable[279459] = bhEne29_Move_0x210d60; // 0x210e94 - g_ps2RecompiledFunctionTable[279460] = bhEne29_Move_0x210d60; // 0x210e98 - g_ps2RecompiledFunctionTable[279461] = bhEne29_Move_0x210d60; // 0x210e9c - g_ps2RecompiledFunctionTable[279462] = bhEne29_Move_0x210d60; // 0x210ea0 - g_ps2RecompiledFunctionTable[279463] = bhEne29_Move_0x210d60; // 0x210ea4 - g_ps2RecompiledFunctionTable[279464] = bhEne29_Move_0x210d60; // 0x210ea8 - g_ps2RecompiledFunctionTable[279465] = bhEne29_Move_0x210d60; // 0x210eac - g_ps2RecompiledFunctionTable[279466] = bhEne29_Move_0x210d60; // 0x210eb0 - g_ps2RecompiledFunctionTable[279467] = bhEne29_Move_0x210d60; // 0x210eb4 - g_ps2RecompiledFunctionTable[279470] = bhEne29_Die_0x210ec0; // 0x210ec0 - g_ps2RecompiledFunctionTable[279474] = bhEne29_Damage_0x210ed0; // 0x210ed0 - g_ps2RecompiledFunctionTable[279478] = bhEne29_Event_0x210ee0; // 0x210ee0 - g_ps2RecompiledFunctionTable[279493] = bhEne29_Event_0x210ee0; // 0x210f1c - g_ps2RecompiledFunctionTable[279498] = bhEne29_Event_0x210ee0; // 0x210f30 - g_ps2RecompiledFunctionTable[279501] = bhEne29_Event_0x210ee0; // 0x210f3c - g_ps2RecompiledFunctionTable[279506] = bhEne29_Br00_0x210f50; // 0x210f50 - g_ps2RecompiledFunctionTable[279533] = bhEne29_Br00_0x210f50; // 0x210fbc - g_ps2RecompiledFunctionTable[279542] = bhEne29_Br00_0x210f50; // 0x210fe0 - g_ps2RecompiledFunctionTable[279707] = bhEne29_Br00_0x210f50; // 0x211274 - g_ps2RecompiledFunctionTable[279718] = bhEne29_Br01_0x2112a0; // 0x2112a0 - g_ps2RecompiledFunctionTable[279749] = bhEne29_Br01_0x2112a0; // 0x21131c - g_ps2RecompiledFunctionTable[279761] = bhEne29_Br01_0x2112a0; // 0x21134c - g_ps2RecompiledFunctionTable[279971] = bhEne29_Br01_0x2112a0; // 0x211694 - g_ps2RecompiledFunctionTable[279982] = bhEne29_Mv00_0x2116c0; // 0x2116c0 - g_ps2RecompiledFunctionTable[279986] = bhEne29_Mv01_0x2116d0; // 0x2116d0 - g_ps2RecompiledFunctionTable[280009] = bhEne29_Mv01_0x2116d0; // 0x21172c - g_ps2RecompiledFunctionTable[280012] = bhEne29_Mv01_0x2116d0; // 0x211738 - g_ps2RecompiledFunctionTable[280020] = bhEne29_Mv01_0x2116d0; // 0x211758 - g_ps2RecompiledFunctionTable[280030] = bhEne29_Mv02_0x211780; // 0x211780 - g_ps2RecompiledFunctionTable[280049] = bhEne29_Mv02_0x211780; // 0x2117cc - g_ps2RecompiledFunctionTable[280054] = bhEne29_Mv03_0x2117e0; // 0x2117e0 - g_ps2RecompiledFunctionTable[280077] = bhEne29_Mv03_0x2117e0; // 0x21183c - g_ps2RecompiledFunctionTable[280080] = bhEne29_Mv03_0x2117e0; // 0x211848 - g_ps2RecompiledFunctionTable[280088] = bhEne29_Mv03_0x2117e0; // 0x211868 - g_ps2RecompiledFunctionTable[280098] = bhEne29_Mv04_0x211890; // 0x211890 - g_ps2RecompiledFunctionTable[280116] = bhEne29_Mv04_0x211890; // 0x2118d8 - g_ps2RecompiledFunctionTable[280134] = bhEne29_Mv04_0x211890; // 0x211920 - g_ps2RecompiledFunctionTable[280142] = bhEne29_Mv20_0x211940; // 0x211940 - g_ps2RecompiledFunctionTable[280147] = bhEne29_Mv20_0x211940; // 0x211954 - g_ps2RecompiledFunctionTable[280155] = bhEne29_Mv20_0x211940; // 0x211974 - g_ps2RecompiledFunctionTable[280162] = bhEne29_ActionInit_0x211990; // 0x211990 - g_ps2RecompiledFunctionTable[280170] = bhEne29_ActionSearch_0x2119b0; // 0x2119b0 - g_ps2RecompiledFunctionTable[280180] = bhEne29_ActionSearch_0x2119b0; // 0x2119d8 - g_ps2RecompiledFunctionTable[280202] = bhEne29_ActionChange_0x211a30; // 0x211a30 - g_ps2RecompiledFunctionTable[280214] = bhEne29_ActionChange_0x211a30; // 0x211a60 - g_ps2RecompiledFunctionTable[280223] = bhEne29_ActionChange_0x211a30; // 0x211a84 - g_ps2RecompiledFunctionTable[280230] = bhEne29_ActionChange_0x211a30; // 0x211aa0 - g_ps2RecompiledFunctionTable[280245] = bhEne29_ActionChange_0x211a30; // 0x211adc - g_ps2RecompiledFunctionTable[280253] = bhEne29_ActionChange_0x211a30; // 0x211afc - g_ps2RecompiledFunctionTable[280255] = bhEne29_ActionChange_0x211a30; // 0x211b04 - g_ps2RecompiledFunctionTable[280281] = bhEne29_ActionChange_0x211a30; // 0x211b6c - g_ps2RecompiledFunctionTable[280294] = bhEne29_ActionMain_0x211ba0; // 0x211ba0 - g_ps2RecompiledFunctionTable[280295] = bhEne29_ActionMain_0x211ba0; // 0x211ba4 - g_ps2RecompiledFunctionTable[280296] = bhEne29_ActionMain_0x211ba0; // 0x211ba8 - g_ps2RecompiledFunctionTable[280297] = bhEne29_ActionMain_0x211ba0; // 0x211bac - g_ps2RecompiledFunctionTable[280298] = bhEne29_ActionMain_0x211ba0; // 0x211bb0 - g_ps2RecompiledFunctionTable[280299] = bhEne29_ActionMain_0x211ba0; // 0x211bb4 - g_ps2RecompiledFunctionTable[280300] = bhEne29_ActionMain_0x211ba0; // 0x211bb8 - g_ps2RecompiledFunctionTable[280301] = bhEne29_ActionMain_0x211ba0; // 0x211bbc - g_ps2RecompiledFunctionTable[280302] = bhEne29_ActionMain_0x211ba0; // 0x211bc0 - g_ps2RecompiledFunctionTable[280303] = bhEne29_ActionMain_0x211ba0; // 0x211bc4 - g_ps2RecompiledFunctionTable[280304] = bhEne29_ActionMain_0x211ba0; // 0x211bc8 - g_ps2RecompiledFunctionTable[280305] = bhEne29_ActionMain_0x211ba0; // 0x211bcc - g_ps2RecompiledFunctionTable[280306] = bhEne29_ActionMain_0x211ba0; // 0x211bd0 - g_ps2RecompiledFunctionTable[280307] = bhEne29_ActionMain_0x211ba0; // 0x211bd4 - g_ps2RecompiledFunctionTable[280308] = bhEne29_ActionMain_0x211ba0; // 0x211bd8 - g_ps2RecompiledFunctionTable[280309] = bhEne29_ActionMain_0x211ba0; // 0x211bdc - g_ps2RecompiledFunctionTable[280310] = bhEne29_ActionMain_0x211ba0; // 0x211be0 - g_ps2RecompiledFunctionTable[280311] = bhEne29_ActionMain_0x211ba0; // 0x211be4 - g_ps2RecompiledFunctionTable[280312] = bhEne29_ActionMain_0x211ba0; // 0x211be8 - g_ps2RecompiledFunctionTable[280313] = bhEne29_ActionMain_0x211ba0; // 0x211bec - g_ps2RecompiledFunctionTable[280314] = bhEne29_ActionMain_0x211ba0; // 0x211bf0 - g_ps2RecompiledFunctionTable[280315] = bhEne29_ActionMain_0x211ba0; // 0x211bf4 - g_ps2RecompiledFunctionTable[280316] = bhEne29_ActionMain_0x211ba0; // 0x211bf8 - g_ps2RecompiledFunctionTable[280317] = bhEne29_ActionMain_0x211ba0; // 0x211bfc - g_ps2RecompiledFunctionTable[280318] = bhEne29_ActionMain_0x211ba0; // 0x211c00 - g_ps2RecompiledFunctionTable[280319] = bhEne29_ActionMain_0x211ba0; // 0x211c04 - g_ps2RecompiledFunctionTable[280320] = bhEne29_ActionMain_0x211ba0; // 0x211c08 - g_ps2RecompiledFunctionTable[280321] = bhEne29_ActionMain_0x211ba0; // 0x211c0c - g_ps2RecompiledFunctionTable[280322] = bhEne29_ActionMain_0x211ba0; // 0x211c10 - g_ps2RecompiledFunctionTable[280323] = bhEne29_ActionMain_0x211ba0; // 0x211c14 - g_ps2RecompiledFunctionTable[280324] = bhEne29_ActionMain_0x211ba0; // 0x211c18 - g_ps2RecompiledFunctionTable[280325] = bhEne29_ActionMain_0x211ba0; // 0x211c1c - g_ps2RecompiledFunctionTable[280326] = bhEne29_ActionMain_0x211ba0; // 0x211c20 - g_ps2RecompiledFunctionTable[280327] = bhEne29_ActionMain_0x211ba0; // 0x211c24 - g_ps2RecompiledFunctionTable[280328] = bhEne29_ActionMain_0x211ba0; // 0x211c28 - g_ps2RecompiledFunctionTable[280329] = bhEne29_ActionMain_0x211ba0; // 0x211c2c - g_ps2RecompiledFunctionTable[280330] = bhEne29_ActionMain_0x211ba0; // 0x211c30 - g_ps2RecompiledFunctionTable[280331] = bhEne29_ActionMain_0x211ba0; // 0x211c34 - g_ps2RecompiledFunctionTable[280332] = bhEne29_ActionMain_0x211ba0; // 0x211c38 - g_ps2RecompiledFunctionTable[280333] = bhEne29_ActionMain_0x211ba0; // 0x211c3c - g_ps2RecompiledFunctionTable[280334] = bhEne29_ActionMain_0x211ba0; // 0x211c40 - g_ps2RecompiledFunctionTable[280335] = bhEne29_ActionMain_0x211ba0; // 0x211c44 - g_ps2RecompiledFunctionTable[280336] = bhEne29_ActionMain_0x211ba0; // 0x211c48 - g_ps2RecompiledFunctionTable[280337] = bhEne29_ActionMain_0x211ba0; // 0x211c4c - g_ps2RecompiledFunctionTable[280338] = bhEne29_ActionMain_0x211ba0; // 0x211c50 - g_ps2RecompiledFunctionTable[280339] = bhEne29_ActionMain_0x211ba0; // 0x211c54 - g_ps2RecompiledFunctionTable[280340] = bhEne29_ActionMain_0x211ba0; // 0x211c58 - g_ps2RecompiledFunctionTable[280341] = bhEne29_ActionMain_0x211ba0; // 0x211c5c - g_ps2RecompiledFunctionTable[280342] = bhEne29_ActionMain_0x211ba0; // 0x211c60 - g_ps2RecompiledFunctionTable[280343] = bhEne29_ActionMain_0x211ba0; // 0x211c64 - g_ps2RecompiledFunctionTable[280346] = bhEne29_TargetAnalyze_0x211c70; // 0x211c70 - g_ps2RecompiledFunctionTable[280380] = bhEne29_TargetAnalyze_0x211c70; // 0x211cf8 - g_ps2RecompiledFunctionTable[280385] = bhEne29_TargetAnalyze_0x211c70; // 0x211d0c - g_ps2RecompiledFunctionTable[280389] = bhEne29_TargetAnalyze_0x211c70; // 0x211d1c - g_ps2RecompiledFunctionTable[280394] = bhEne29_TargetAnalyze_0x211c70; // 0x211d30 - g_ps2RecompiledFunctionTable[280411] = bhEne29_TargetAnalyze_0x211c70; // 0x211d74 - g_ps2RecompiledFunctionTable[280414] = bhEne29_TargetAnalyze_0x211c70; // 0x211d80 - g_ps2RecompiledFunctionTable[280419] = bhEne29_TargetAnalyze_0x211c70; // 0x211d94 - g_ps2RecompiledFunctionTable[280470] = bhEne29_TargetAnalyze_0x211c70; // 0x211e60 - g_ps2RecompiledFunctionTable[280501] = bhEne29_TargetAnalyze_0x211c70; // 0x211edc - g_ps2RecompiledFunctionTable[280522] = bhEne29_CalcEnemy_0x211f30; // 0x211f30 - g_ps2RecompiledFunctionTable[280529] = bhEne29_CalcEnemy_0x211f30; // 0x211f4c - g_ps2RecompiledFunctionTable[280532] = bhEne29_CalcEnemy_0x211f30; // 0x211f58 - g_ps2RecompiledFunctionTable[280558] = bhEne29_DmgCheck_0x211fc0; // 0x211fc0 - g_ps2RecompiledFunctionTable[280566] = bhEne29_DmgCheck_0x211fc0; // 0x211fe0 - g_ps2RecompiledFunctionTable[280579] = bhEne29_DmgCheck_0x211fc0; // 0x212014 - g_ps2RecompiledFunctionTable[280599] = bhEne29_DmgCheck_0x211fc0; // 0x212064 - g_ps2RecompiledFunctionTable[280602] = bhEne29_DmgCheck_0x211fc0; // 0x212070 - g_ps2RecompiledFunctionTable[280605] = bhEne29_DmgCheck_0x211fc0; // 0x21207c - g_ps2RecompiledFunctionTable[280617] = bhEne29_DmgCheck_0x211fc0; // 0x2120ac - g_ps2RecompiledFunctionTable[280620] = bhEne29_DmgCheck_0x211fc0; // 0x2120b8 - g_ps2RecompiledFunctionTable[280678] = bhEne29_AttackHitCheck_0x2121a0; // 0x2121a0 - g_ps2RecompiledFunctionTable[280689] = bhEne29_AttackHitCheck_0x2121a0; // 0x2121cc - g_ps2RecompiledFunctionTable[280717] = bhEne29_AttackHitCheck_0x2121a0; // 0x21223c - g_ps2RecompiledFunctionTable[280728] = bhEne29_AttackHitCheck_0x2121a0; // 0x212268 - g_ps2RecompiledFunctionTable[280736] = bhEne29_AttackHitCheck_0x2121a0; // 0x212288 - g_ps2RecompiledFunctionTable[280758] = bhEne29_PlySetDamage_0x2122e0; // 0x2122e0 - g_ps2RecompiledFunctionTable[280821] = bhEne29_PlySetDamage_0x2122e0; // 0x2123dc - g_ps2RecompiledFunctionTable[280850] = bhEne29_PlyMoveMain_0x212450; // 0x212450 - g_ps2RecompiledFunctionTable[280869] = bhEne29_PlyMoveMain_0x212450; // 0x21249c - g_ps2RecompiledFunctionTable[280908] = bhEne29_PlyMoveMain_0x212450; // 0x212538 - g_ps2RecompiledFunctionTable[280930] = bhEne29_PlyMoveMain_0x212450; // 0x212590 - g_ps2RecompiledFunctionTable[280933] = bhEne29_PlyMoveMain_0x212450; // 0x21259c - g_ps2RecompiledFunctionTable[280946] = bhEne29_PlyActionInit_0x2125d0; // 0x2125d0 - g_ps2RecompiledFunctionTable[280958] = bhEne29_PlyActionMain_0x212600; // 0x212600 - g_ps2RecompiledFunctionTable[280959] = bhEne29_PlyActionMain_0x212600; // 0x212604 - g_ps2RecompiledFunctionTable[280960] = bhEne29_PlyActionMain_0x212600; // 0x212608 - g_ps2RecompiledFunctionTable[280961] = bhEne29_PlyActionMain_0x212600; // 0x21260c - g_ps2RecompiledFunctionTable[280962] = bhEne29_PlyActionMain_0x212600; // 0x212610 - g_ps2RecompiledFunctionTable[280963] = bhEne29_PlyActionMain_0x212600; // 0x212614 - g_ps2RecompiledFunctionTable[280964] = bhEne29_PlyActionMain_0x212600; // 0x212618 - g_ps2RecompiledFunctionTable[280965] = bhEne29_PlyActionMain_0x212600; // 0x21261c - g_ps2RecompiledFunctionTable[280966] = bhEne29_PlyActionMain_0x212600; // 0x212620 - g_ps2RecompiledFunctionTable[280967] = bhEne29_PlyActionMain_0x212600; // 0x212624 - g_ps2RecompiledFunctionTable[280968] = bhEne29_PlyActionMain_0x212600; // 0x212628 - g_ps2RecompiledFunctionTable[280969] = bhEne29_PlyActionMain_0x212600; // 0x21262c - g_ps2RecompiledFunctionTable[280970] = bhEne29_PlyActionMain_0x212600; // 0x212630 - g_ps2RecompiledFunctionTable[280971] = bhEne29_PlyActionMain_0x212600; // 0x212634 - g_ps2RecompiledFunctionTable[280972] = bhEne29_PlyActionMain_0x212600; // 0x212638 - g_ps2RecompiledFunctionTable[280973] = bhEne29_PlyActionMain_0x212600; // 0x21263c - g_ps2RecompiledFunctionTable[280974] = bhEne29_PlyActionMain_0x212600; // 0x212640 - g_ps2RecompiledFunctionTable[280975] = bhEne29_PlyActionMain_0x212600; // 0x212644 - g_ps2RecompiledFunctionTable[280976] = bhEne29_PlyActionMain_0x212600; // 0x212648 - g_ps2RecompiledFunctionTable[280977] = bhEne29_PlyActionMain_0x212600; // 0x21264c - g_ps2RecompiledFunctionTable[280978] = bhEne29_PlyActionMain_0x212600; // 0x212650 - g_ps2RecompiledFunctionTable[280979] = bhEne29_PlyActionMain_0x212600; // 0x212654 - g_ps2RecompiledFunctionTable[280980] = bhEne29_PlyActionMain_0x212600; // 0x212658 - g_ps2RecompiledFunctionTable[280981] = bhEne29_PlyActionMain_0x212600; // 0x21265c - g_ps2RecompiledFunctionTable[280982] = bhEne29_PlyActionMain_0x212600; // 0x212660 - g_ps2RecompiledFunctionTable[280983] = bhEne29_PlyActionMain_0x212600; // 0x212664 - g_ps2RecompiledFunctionTable[280984] = bhEne29_PlyActionMain_0x212600; // 0x212668 - g_ps2RecompiledFunctionTable[280985] = bhEne29_PlyActionMain_0x212600; // 0x21266c - g_ps2RecompiledFunctionTable[280986] = bhEne29_PlyActionMain_0x212600; // 0x212670 - g_ps2RecompiledFunctionTable[280987] = bhEne29_PlyActionMain_0x212600; // 0x212674 - g_ps2RecompiledFunctionTable[280988] = bhEne29_PlyActionMain_0x212600; // 0x212678 - g_ps2RecompiledFunctionTable[280989] = bhEne29_PlyActionMain_0x212600; // 0x21267c - g_ps2RecompiledFunctionTable[280990] = bhEne29_PlyActionMain_0x212600; // 0x212680 - g_ps2RecompiledFunctionTable[280991] = bhEne29_PlyActionMain_0x212600; // 0x212684 - g_ps2RecompiledFunctionTable[280992] = bhEne29_PlyActionMain_0x212600; // 0x212688 - g_ps2RecompiledFunctionTable[280993] = bhEne29_PlyActionMain_0x212600; // 0x21268c - g_ps2RecompiledFunctionTable[280994] = bhEne29_PlyActionMain_0x212600; // 0x212690 - g_ps2RecompiledFunctionTable[280995] = bhEne29_PlyActionMain_0x212600; // 0x212694 - g_ps2RecompiledFunctionTable[280996] = bhEne29_PlyActionMain_0x212600; // 0x212698 - g_ps2RecompiledFunctionTable[280997] = bhEne29_PlyActionMain_0x212600; // 0x21269c - g_ps2RecompiledFunctionTable[280998] = bhEne29_PlyActionMain_0x212600; // 0x2126a0 - g_ps2RecompiledFunctionTable[280999] = bhEne29_PlyActionMain_0x212600; // 0x2126a4 - g_ps2RecompiledFunctionTable[281000] = bhEne29_PlyActionMain_0x212600; // 0x2126a8 - g_ps2RecompiledFunctionTable[281001] = bhEne29_PlyActionMain_0x212600; // 0x2126ac - g_ps2RecompiledFunctionTable[281002] = bhEne29_PlyActionMain_0x212600; // 0x2126b0 - g_ps2RecompiledFunctionTable[281006] = bhEne29_PlyActionChange_0x2126c0; // 0x2126c0 - g_ps2RecompiledFunctionTable[281039] = bhEne29_PlyActionChange_0x2126c0; // 0x212744 - g_ps2RecompiledFunctionTable[281047] = bhEne29_PlyActionChange_0x2126c0; // 0x212764 - g_ps2RecompiledFunctionTable[281049] = bhEne29_PlyActionChange_0x2126c0; // 0x21276c - g_ps2RecompiledFunctionTable[281094] = bhEne29_PlyDmg117_0x212820; // 0x212820 - g_ps2RecompiledFunctionTable[281127] = bhEne29_PlyDmg117_0x212820; // 0x2128a4 - g_ps2RecompiledFunctionTable[281149] = bhEne29_PlyDmg117_0x212820; // 0x2128fc - g_ps2RecompiledFunctionTable[281158] = bhEne29_PlyDmg118_0x212920; // 0x212920 - g_ps2RecompiledFunctionTable[281162] = bhEne29_PlyDmgRtn_0x212930; // 0x212930 - g_ps2RecompiledFunctionTable[281186] = bhEne29_SetDmgEffect_0x212990; // 0x212990 - g_ps2RecompiledFunctionTable[281238] = bhEne29_SetDmgEffect_0x212990; // 0x212a60 - g_ps2RecompiledFunctionTable[281261] = bhEne29_SetDmgEffect_0x212990; // 0x212abc - g_ps2RecompiledFunctionTable[281271] = bhEne29_SetDmgEffect_0x212990; // 0x212ae4 - g_ps2RecompiledFunctionTable[281285] = bhEne29_SetDmgEffect_0x212990; // 0x212b1c - g_ps2RecompiledFunctionTable[281290] = bhEne29_SetDmgEffect_0x212990; // 0x212b30 - g_ps2RecompiledFunctionTable[281300] = bhEne29_SetDmgEffect_0x212990; // 0x212b58 - g_ps2RecompiledFunctionTable[281305] = bhEne29_SetDmgEffect_0x212990; // 0x212b6c - g_ps2RecompiledFunctionTable[281367] = bhEne29_SetDmgEffect_0x212990; // 0x212c64 - g_ps2RecompiledFunctionTable[281371] = bhEne29_SetDmgEffect_0x212990; // 0x212c74 - g_ps2RecompiledFunctionTable[281375] = bhEne29_SetDmgEffect_0x212990; // 0x212c84 - g_ps2RecompiledFunctionTable[281391] = bhEne29_SetDmgEffect_0x212990; // 0x212cc4 - g_ps2RecompiledFunctionTable[281407] = bhEne29_SetDmgEffect_0x212990; // 0x212d04 - g_ps2RecompiledFunctionTable[281427] = bhEne29_SetDmgEffect_0x212990; // 0x212d54 - g_ps2RecompiledFunctionTable[281430] = bhEne29_SetDmgEffect_0x212990; // 0x212d60 - g_ps2RecompiledFunctionTable[281446] = bhEne29_SetDmgEffect_0x212990; // 0x212da0 - g_ps2RecompiledFunctionTable[281463] = bhEne29_SetDmgEffect_0x212990; // 0x212de4 - g_ps2RecompiledFunctionTable[281484] = bhEne29_SetDmgEffect_0x212990; // 0x212e38 - g_ps2RecompiledFunctionTable[281486] = bhEne29_SetDmgEffect_0x212990; // 0x212e40 - g_ps2RecompiledFunctionTable[281502] = bhEne29_SetDmgEffect_0x212990; // 0x212e80 - g_ps2RecompiledFunctionTable[281518] = bhEne29_SetDmgEffect_0x212990; // 0x212ec0 - g_ps2RecompiledFunctionTable[281542] = bhEne29_SetDmgEffect_0x212990; // 0x212f20 - g_ps2RecompiledFunctionTable[281547] = bhEne29_SetDmgEffect_0x212990; // 0x212f34 - g_ps2RecompiledFunctionTable[281563] = bhEne29_SetDmgEffect_0x212990; // 0x212f74 - g_ps2RecompiledFunctionTable[281579] = bhEne29_SetDmgEffect_0x212990; // 0x212fb4 - g_ps2RecompiledFunctionTable[281599] = bhEne29_SetDmgEffect_0x212990; // 0x213004 - g_ps2RecompiledFunctionTable[281631] = bhEne29_SetDmgEffect_0x212990; // 0x213084 - g_ps2RecompiledFunctionTable[281636] = bhEne29_SetDmgEffect_0x212990; // 0x213098 - g_ps2RecompiledFunctionTable[281644] = bhEne29_SetDmgEffect_0x212990; // 0x2130b8 - g_ps2RecompiledFunctionTable[281649] = bhEne29_SetDmgEffect_0x212990; // 0x2130cc - g_ps2RecompiledFunctionTable[281696] = bhEne29_SetDmgEffect_0x212990; // 0x213188 - g_ps2RecompiledFunctionTable[281705] = bhEne29_SetDmgEffect_0x212990; // 0x2131ac - g_ps2RecompiledFunctionTable[281726] = bhEne29_SetDmgEffect_0x212990; // 0x213200 - g_ps2RecompiledFunctionTable[281729] = bhEne29_SetDmgEffect_0x212990; // 0x21320c - g_ps2RecompiledFunctionTable[281734] = bhEne29_SetDmgEffect_0x212990; // 0x213220 - g_ps2RecompiledFunctionTable[281806] = bhEne29_SetDmgEffect_0x212990; // 0x213340 - g_ps2RecompiledFunctionTable[281818] = SetDmgEne_0x213370; // 0x213370 - g_ps2RecompiledFunctionTable[281832] = SetDmgEne_0x213370; // 0x2133a8 - g_ps2RecompiledFunctionTable[281836] = SetDmgEne_0x213370; // 0x2133b8 - g_ps2RecompiledFunctionTable[281862] = CalcDmgEne_0x213420; // 0x213420 - g_ps2RecompiledFunctionTable[281867] = CalcDmgEne_0x213420; // 0x213434 - g_ps2RecompiledFunctionTable[281902] = CheckDmgEne_0x2134c0; // 0x2134c0 - g_ps2RecompiledFunctionTable[281914] = CheckDmgEne_0x2134c0; // 0x2134f0 - g_ps2RecompiledFunctionTable[281927] = CheckDmgEne_0x2134c0; // 0x213524 - g_ps2RecompiledFunctionTable[281953] = CheckDmgEne_0x2134c0; // 0x21358c - g_ps2RecompiledFunctionTable[281994] = bhEne30_0x213630; // 0x213630 - g_ps2RecompiledFunctionTable[281995] = bhEne30_0x213630; // 0x213634 - g_ps2RecompiledFunctionTable[281996] = bhEne30_0x213630; // 0x213638 - g_ps2RecompiledFunctionTable[281997] = bhEne30_0x213630; // 0x21363c - g_ps2RecompiledFunctionTable[281998] = bhEne30_0x213630; // 0x213640 - g_ps2RecompiledFunctionTable[281999] = bhEne30_0x213630; // 0x213644 - g_ps2RecompiledFunctionTable[282000] = bhEne30_0x213630; // 0x213648 - g_ps2RecompiledFunctionTable[282001] = bhEne30_0x213630; // 0x21364c - g_ps2RecompiledFunctionTable[282002] = bhEne30_0x213630; // 0x213650 - g_ps2RecompiledFunctionTable[282003] = bhEne30_0x213630; // 0x213654 - g_ps2RecompiledFunctionTable[282004] = bhEne30_0x213630; // 0x213658 - g_ps2RecompiledFunctionTable[282005] = bhEne30_0x213630; // 0x21365c - g_ps2RecompiledFunctionTable[282006] = bhEne30_0x213630; // 0x213660 - g_ps2RecompiledFunctionTable[282007] = bhEne30_0x213630; // 0x213664 - g_ps2RecompiledFunctionTable[282008] = bhEne30_0x213630; // 0x213668 - g_ps2RecompiledFunctionTable[282009] = bhEne30_0x213630; // 0x21366c - g_ps2RecompiledFunctionTable[282010] = bhEne30_0x213630; // 0x213670 - g_ps2RecompiledFunctionTable[282011] = bhEne30_0x213630; // 0x213674 - g_ps2RecompiledFunctionTable[282012] = bhEne30_0x213630; // 0x213678 - g_ps2RecompiledFunctionTable[282013] = bhEne30_0x213630; // 0x21367c - g_ps2RecompiledFunctionTable[282014] = bhEne30_0x213630; // 0x213680 - g_ps2RecompiledFunctionTable[282015] = bhEne30_0x213630; // 0x213684 - g_ps2RecompiledFunctionTable[282016] = bhEne30_0x213630; // 0x213688 - g_ps2RecompiledFunctionTable[282017] = bhEne30_0x213630; // 0x21368c - g_ps2RecompiledFunctionTable[282018] = bhEne30_0x213630; // 0x213690 - g_ps2RecompiledFunctionTable[282019] = bhEne30_0x213630; // 0x213694 - g_ps2RecompiledFunctionTable[282020] = bhEne30_0x213630; // 0x213698 - g_ps2RecompiledFunctionTable[282021] = bhEne30_0x213630; // 0x21369c - g_ps2RecompiledFunctionTable[282022] = bhEne30_0x213630; // 0x2136a0 - g_ps2RecompiledFunctionTable[282023] = bhEne30_0x213630; // 0x2136a4 - g_ps2RecompiledFunctionTable[282024] = bhEne30_0x213630; // 0x2136a8 - g_ps2RecompiledFunctionTable[282025] = bhEne30_0x213630; // 0x2136ac - g_ps2RecompiledFunctionTable[282026] = bhEne30_0x213630; // 0x2136b0 - g_ps2RecompiledFunctionTable[282027] = bhEne30_0x213630; // 0x2136b4 - g_ps2RecompiledFunctionTable[282028] = bhEne30_0x213630; // 0x2136b8 - g_ps2RecompiledFunctionTable[282029] = bhEne30_0x213630; // 0x2136bc - g_ps2RecompiledFunctionTable[282030] = bhEne30_0x213630; // 0x2136c0 - g_ps2RecompiledFunctionTable[282031] = bhEne30_0x213630; // 0x2136c4 - g_ps2RecompiledFunctionTable[282032] = bhEne30_0x213630; // 0x2136c8 - g_ps2RecompiledFunctionTable[282033] = bhEne30_0x213630; // 0x2136cc - g_ps2RecompiledFunctionTable[282034] = bhEne30_0x213630; // 0x2136d0 - g_ps2RecompiledFunctionTable[282035] = bhEne30_0x213630; // 0x2136d4 - g_ps2RecompiledFunctionTable[282036] = bhEne30_0x213630; // 0x2136d8 - g_ps2RecompiledFunctionTable[282037] = bhEne30_0x213630; // 0x2136dc - g_ps2RecompiledFunctionTable[282038] = bhEne30_0x213630; // 0x2136e0 - g_ps2RecompiledFunctionTable[282039] = bhEne30_0x213630; // 0x2136e4 - g_ps2RecompiledFunctionTable[282040] = bhEne30_0x213630; // 0x2136e8 - g_ps2RecompiledFunctionTable[282041] = bhEne30_0x213630; // 0x2136ec - g_ps2RecompiledFunctionTable[282042] = bhEne30_0x213630; // 0x2136f0 - g_ps2RecompiledFunctionTable[282043] = bhEne30_0x213630; // 0x2136f4 - g_ps2RecompiledFunctionTable[282044] = bhEne30_0x213630; // 0x2136f8 - g_ps2RecompiledFunctionTable[282045] = bhEne30_0x213630; // 0x2136fc - g_ps2RecompiledFunctionTable[282046] = bhEne30_0x213630; // 0x213700 - g_ps2RecompiledFunctionTable[282047] = bhEne30_0x213630; // 0x213704 - g_ps2RecompiledFunctionTable[282048] = bhEne30_0x213630; // 0x213708 - g_ps2RecompiledFunctionTable[282049] = bhEne30_0x213630; // 0x21370c - g_ps2RecompiledFunctionTable[282050] = bhEne30_0x213630; // 0x213710 - g_ps2RecompiledFunctionTable[282051] = bhEne30_0x213630; // 0x213714 - g_ps2RecompiledFunctionTable[282052] = bhEne30_0x213630; // 0x213718 - g_ps2RecompiledFunctionTable[282053] = bhEne30_0x213630; // 0x21371c - g_ps2RecompiledFunctionTable[282054] = bhEne30_0x213630; // 0x213720 - g_ps2RecompiledFunctionTable[282055] = bhEne30_0x213630; // 0x213724 - g_ps2RecompiledFunctionTable[282056] = bhEne30_0x213630; // 0x213728 - g_ps2RecompiledFunctionTable[282057] = bhEne30_0x213630; // 0x21372c - g_ps2RecompiledFunctionTable[282058] = bhEne30_0x213630; // 0x213730 - g_ps2RecompiledFunctionTable[282059] = bhEne30_0x213630; // 0x213734 - g_ps2RecompiledFunctionTable[282060] = bhEne30_0x213630; // 0x213738 - g_ps2RecompiledFunctionTable[282061] = bhEne30_0x213630; // 0x21373c - g_ps2RecompiledFunctionTable[282062] = bhEne30_0x213630; // 0x213740 - g_ps2RecompiledFunctionTable[282063] = bhEne30_0x213630; // 0x213744 - g_ps2RecompiledFunctionTable[282064] = bhEne30_0x213630; // 0x213748 - g_ps2RecompiledFunctionTable[282065] = bhEne30_0x213630; // 0x21374c - g_ps2RecompiledFunctionTable[282066] = bhEne30_0x213630; // 0x213750 - g_ps2RecompiledFunctionTable[282067] = bhEne30_0x213630; // 0x213754 - g_ps2RecompiledFunctionTable[282068] = bhEne30_0x213630; // 0x213758 - g_ps2RecompiledFunctionTable[282069] = bhEne30_0x213630; // 0x21375c - g_ps2RecompiledFunctionTable[282070] = bhEne30_0x213630; // 0x213760 - g_ps2RecompiledFunctionTable[282071] = bhEne30_0x213630; // 0x213764 - g_ps2RecompiledFunctionTable[282072] = bhEne30_0x213630; // 0x213768 - g_ps2RecompiledFunctionTable[282074] = bhEne30_Init_0x213770; // 0x213770 - g_ps2RecompiledFunctionTable[282116] = bhEne30_Init_0x213770; // 0x213818 - g_ps2RecompiledFunctionTable[282129] = bhEne30_Init_0x213770; // 0x21384c - g_ps2RecompiledFunctionTable[282170] = bhEne30_Init_0x213770; // 0x2138f0 - g_ps2RecompiledFunctionTable[282175] = bhEne30_Init_0x213770; // 0x213904 - g_ps2RecompiledFunctionTable[282198] = bhEne30_Init_0x213770; // 0x213960 - g_ps2RecompiledFunctionTable[282237] = bhEne30_Init_0x213770; // 0x2139fc - g_ps2RecompiledFunctionTable[282248] = bhEne30_Init_0x213770; // 0x213a28 - g_ps2RecompiledFunctionTable[282261] = bhEne30_Init_0x213770; // 0x213a5c - g_ps2RecompiledFunctionTable[282278] = bhEne30_Brain_0x213aa0; // 0x213aa0 - g_ps2RecompiledFunctionTable[282279] = bhEne30_Brain_0x213aa0; // 0x213aa4 - g_ps2RecompiledFunctionTable[282280] = bhEne30_Brain_0x213aa0; // 0x213aa8 - g_ps2RecompiledFunctionTable[282281] = bhEne30_Brain_0x213aa0; // 0x213aac - g_ps2RecompiledFunctionTable[282282] = bhEne30_Brain_0x213aa0; // 0x213ab0 - g_ps2RecompiledFunctionTable[282283] = bhEne30_Brain_0x213aa0; // 0x213ab4 - g_ps2RecompiledFunctionTable[282284] = bhEne30_Brain_0x213aa0; // 0x213ab8 - g_ps2RecompiledFunctionTable[282285] = bhEne30_Brain_0x213aa0; // 0x213abc - g_ps2RecompiledFunctionTable[282286] = bhEne30_BR00_0x213ac0; // 0x213ac0 - g_ps2RecompiledFunctionTable[282301] = bhEne30_BR00_0x213ac0; // 0x213afc - g_ps2RecompiledFunctionTable[282317] = bhEne30_BR00_0x213ac0; // 0x213b3c - g_ps2RecompiledFunctionTable[282347] = bhEne30_BR00_0x213ac0; // 0x213bb4 - g_ps2RecompiledFunctionTable[282354] = bhEne30_BR00_0x213ac0; // 0x213bd0 - g_ps2RecompiledFunctionTable[282367] = bhEne30_BR00_0x213ac0; // 0x213c04 - g_ps2RecompiledFunctionTable[282384] = bhEne30_BR00_0x213ac0; // 0x213c48 - g_ps2RecompiledFunctionTable[282397] = bhEne30_BR00_0x213ac0; // 0x213c7c - g_ps2RecompiledFunctionTable[282406] = bhEne30_Move_0x213ca0; // 0x213ca0 - g_ps2RecompiledFunctionTable[282407] = bhEne30_Move_0x213ca0; // 0x213ca4 - g_ps2RecompiledFunctionTable[282408] = bhEne30_Move_0x213ca0; // 0x213ca8 - g_ps2RecompiledFunctionTable[282409] = bhEne30_Move_0x213ca0; // 0x213cac - g_ps2RecompiledFunctionTable[282410] = bhEne30_Move_0x213ca0; // 0x213cb0 - g_ps2RecompiledFunctionTable[282411] = bhEne30_Move_0x213ca0; // 0x213cb4 - g_ps2RecompiledFunctionTable[282412] = bhEne30_Move_0x213ca0; // 0x213cb8 - g_ps2RecompiledFunctionTable[282413] = bhEne30_Move_0x213ca0; // 0x213cbc - g_ps2RecompiledFunctionTable[282414] = bhEne30_Move_0x213ca0; // 0x213cc0 - g_ps2RecompiledFunctionTable[282415] = bhEne30_Move_0x213ca0; // 0x213cc4 - g_ps2RecompiledFunctionTable[282416] = bhEne30_Move_0x213ca0; // 0x213cc8 - g_ps2RecompiledFunctionTable[282417] = bhEne30_Move_0x213ca0; // 0x213ccc - g_ps2RecompiledFunctionTable[282418] = bhEne30_Move_0x213ca0; // 0x213cd0 - g_ps2RecompiledFunctionTable[282419] = bhEne30_Move_0x213ca0; // 0x213cd4 - g_ps2RecompiledFunctionTable[282420] = bhEne30_Move_0x213ca0; // 0x213cd8 - g_ps2RecompiledFunctionTable[282421] = bhEne30_Move_0x213ca0; // 0x213cdc - g_ps2RecompiledFunctionTable[282422] = bhEne30_Move_0x213ca0; // 0x213ce0 - g_ps2RecompiledFunctionTable[282423] = bhEne30_Move_0x213ca0; // 0x213ce4 - g_ps2RecompiledFunctionTable[282424] = bhEne30_Move_0x213ca0; // 0x213ce8 - g_ps2RecompiledFunctionTable[282425] = bhEne30_Move_0x213ca0; // 0x213cec - g_ps2RecompiledFunctionTable[282426] = bhEne30_Move_0x213ca0; // 0x213cf0 - g_ps2RecompiledFunctionTable[282427] = bhEne30_Move_0x213ca0; // 0x213cf4 - g_ps2RecompiledFunctionTable[282428] = bhEne30_Move_0x213ca0; // 0x213cf8 - g_ps2RecompiledFunctionTable[282429] = bhEne30_Move_0x213ca0; // 0x213cfc - g_ps2RecompiledFunctionTable[282430] = bhEne30_Move_0x213ca0; // 0x213d00 - g_ps2RecompiledFunctionTable[282431] = bhEne30_Move_0x213ca0; // 0x213d04 - g_ps2RecompiledFunctionTable[282432] = bhEne30_Move_0x213ca0; // 0x213d08 - g_ps2RecompiledFunctionTable[282433] = bhEne30_Move_0x213ca0; // 0x213d0c - g_ps2RecompiledFunctionTable[282434] = bhEne30_Move_0x213ca0; // 0x213d10 - g_ps2RecompiledFunctionTable[282438] = bhEne30_MV00_0x213d20; // 0x213d20 - g_ps2RecompiledFunctionTable[282442] = bhEne30_MV01_0x213d30; // 0x213d30 - g_ps2RecompiledFunctionTable[282492] = bhEne30_MV01_0x213d30; // 0x213df8 - g_ps2RecompiledFunctionTable[282515] = bhEne30_MV01_0x213d30; // 0x213e54 - g_ps2RecompiledFunctionTable[282527] = bhEne30_MV01_0x213d30; // 0x213e84 - g_ps2RecompiledFunctionTable[282581] = bhEne30_MV01_0x213d30; // 0x213f5c - g_ps2RecompiledFunctionTable[282592] = bhEne30_MV01_0x213d30; // 0x213f88 - g_ps2RecompiledFunctionTable[282598] = bhEne30_MV01_0x213d30; // 0x213fa0 - g_ps2RecompiledFunctionTable[282608] = bhEne30_MV01_0x213d30; // 0x213fc8 - g_ps2RecompiledFunctionTable[282617] = bhEne30_MV01_0x213d30; // 0x213fec - g_ps2RecompiledFunctionTable[282624] = bhEne30_MV01_0x213d30; // 0x214008 - g_ps2RecompiledFunctionTable[282626] = bhEne30_MV01_0x213d30; // 0x214010 - g_ps2RecompiledFunctionTable[282628] = bhEne30_MV01_0x213d30; // 0x214018 - g_ps2RecompiledFunctionTable[282632] = bhEne30_MV01_0x213d30; // 0x214028 - g_ps2RecompiledFunctionTable[282636] = bhEne30_MV01_0x213d30; // 0x214038 - g_ps2RecompiledFunctionTable[282673] = bhEne30_MV01_0x213d30; // 0x2140cc - g_ps2RecompiledFunctionTable[282681] = bhEne30_MV01_0x213d30; // 0x2140ec - g_ps2RecompiledFunctionTable[282686] = bhEne30_MV01_0x213d30; // 0x214100 - g_ps2RecompiledFunctionTable[282692] = bhEne30_MV01_0x213d30; // 0x214118 - g_ps2RecompiledFunctionTable[282696] = bhEne30_MV01_0x213d30; // 0x214128 - g_ps2RecompiledFunctionTable[282703] = bhEne30_MV01_0x213d30; // 0x214144 - g_ps2RecompiledFunctionTable[282722] = bhEne30_MV02_0x214190; // 0x214190 - g_ps2RecompiledFunctionTable[282759] = bhEne30_MV02_0x214190; // 0x214224 - g_ps2RecompiledFunctionTable[282761] = bhEne30_MV02_0x214190; // 0x21422c - g_ps2RecompiledFunctionTable[282778] = bhEne30_MV02_0x214190; // 0x214270 - g_ps2RecompiledFunctionTable[282792] = bhEne30_MV02_0x214190; // 0x2142a8 - g_ps2RecompiledFunctionTable[282810] = bhEne30_MV02_0x214190; // 0x2142f0 - g_ps2RecompiledFunctionTable[282829] = bhEne30_MV02_0x214190; // 0x21433c - g_ps2RecompiledFunctionTable[282848] = bhEne30_MV02_0x214190; // 0x214388 - g_ps2RecompiledFunctionTable[282850] = bhEne30_MV02_0x214190; // 0x214390 - g_ps2RecompiledFunctionTable[282863] = bhEne30_MV02_0x214190; // 0x2143c4 - g_ps2RecompiledFunctionTable[282866] = bhEne30_MV02_0x214190; // 0x2143d0 - g_ps2RecompiledFunctionTable[282870] = bhEne30_MV02_0x214190; // 0x2143e0 - g_ps2RecompiledFunctionTable[282875] = bhEne30_MV02_0x214190; // 0x2143f4 - g_ps2RecompiledFunctionTable[282880] = bhEne30_MV02_0x214190; // 0x214408 - g_ps2RecompiledFunctionTable[282882] = bhEne30_MV02_0x214190; // 0x214410 - g_ps2RecompiledFunctionTable[282899] = bhEne30_MV02_0x214190; // 0x214454 - g_ps2RecompiledFunctionTable[282912] = bhEne30_MV02_0x214190; // 0x214488 - g_ps2RecompiledFunctionTable[282929] = bhEne30_MV02_0x214190; // 0x2144cc - g_ps2RecompiledFunctionTable[282947] = bhEne30_MV02_0x214190; // 0x214514 - g_ps2RecompiledFunctionTable[282966] = bhEne30_MV02_0x214190; // 0x214560 - g_ps2RecompiledFunctionTable[282968] = bhEne30_MV02_0x214190; // 0x214568 - g_ps2RecompiledFunctionTable[282981] = bhEne30_MV02_0x214190; // 0x21459c - g_ps2RecompiledFunctionTable[282984] = bhEne30_MV02_0x214190; // 0x2145a8 - g_ps2RecompiledFunctionTable[282988] = bhEne30_MV02_0x214190; // 0x2145b8 - g_ps2RecompiledFunctionTable[282993] = bhEne30_MV02_0x214190; // 0x2145cc - g_ps2RecompiledFunctionTable[283002] = bhEne30_MV02_0x214190; // 0x2145f0 - g_ps2RecompiledFunctionTable[283035] = bhEne30_MV02_0x214190; // 0x214674 - g_ps2RecompiledFunctionTable[283062] = bhEne30_MV03_0x2146e0; // 0x2146e0 - g_ps2RecompiledFunctionTable[283133] = bhEne30_MV03_0x2146e0; // 0x2147fc - g_ps2RecompiledFunctionTable[283150] = bhEne30_MV04_0x214840; // 0x214840 - g_ps2RecompiledFunctionTable[283170] = bhEne30_MV04_0x214840; // 0x214890 - g_ps2RecompiledFunctionTable[283183] = bhEne30_MV04_0x214840; // 0x2148c4 - g_ps2RecompiledFunctionTable[283202] = bhEne30_MV05_0x214910; // 0x214910 - g_ps2RecompiledFunctionTable[283237] = bhEne30_MV05_0x214910; // 0x21499c - g_ps2RecompiledFunctionTable[283250] = bhEne30_MV05_0x214910; // 0x2149d0 - g_ps2RecompiledFunctionTable[283261] = bhEne30_MV05_0x214910; // 0x2149fc - g_ps2RecompiledFunctionTable[283274] = bhEne30_MV05_0x214910; // 0x214a30 - g_ps2RecompiledFunctionTable[283306] = bhEne30_MV05_0x214910; // 0x214ab0 - g_ps2RecompiledFunctionTable[283330] = bhEne30_MV05_0x214910; // 0x214b10 - g_ps2RecompiledFunctionTable[283345] = bhEne30_MV05_0x214910; // 0x214b4c - g_ps2RecompiledFunctionTable[283352] = bhEne30_MV05_0x214910; // 0x214b68 - g_ps2RecompiledFunctionTable[283381] = bhEne30_MV05_0x214910; // 0x214bdc - g_ps2RecompiledFunctionTable[283399] = bhEne30_MV05_0x214910; // 0x214c24 - g_ps2RecompiledFunctionTable[283422] = bhEne30_MV06_0x214c80; // 0x214c80 - g_ps2RecompiledFunctionTable[283472] = bhEne30_MV06_0x214c80; // 0x214d48 - g_ps2RecompiledFunctionTable[283478] = bhEne30_MV06_0x214c80; // 0x214d60 - g_ps2RecompiledFunctionTable[283484] = bhEne30_MV06_0x214c80; // 0x214d78 - g_ps2RecompiledFunctionTable[283488] = bhEne30_MV06_0x214c80; // 0x214d88 - g_ps2RecompiledFunctionTable[283490] = bhEne30_MV06_0x214c80; // 0x214d90 - g_ps2RecompiledFunctionTable[283507] = bhEne30_MV06_0x214c80; // 0x214dd4 - g_ps2RecompiledFunctionTable[283521] = bhEne30_MV06_0x214c80; // 0x214e0c - g_ps2RecompiledFunctionTable[283539] = bhEne30_MV06_0x214c80; // 0x214e54 - g_ps2RecompiledFunctionTable[283555] = bhEne30_MV06_0x214c80; // 0x214e94 - g_ps2RecompiledFunctionTable[283574] = bhEne30_MV06_0x214c80; // 0x214ee0 - g_ps2RecompiledFunctionTable[283593] = bhEne30_MV06_0x214c80; // 0x214f2c - g_ps2RecompiledFunctionTable[283595] = bhEne30_MV06_0x214c80; // 0x214f34 - g_ps2RecompiledFunctionTable[283611] = bhEne30_MV06_0x214c80; // 0x214f74 - g_ps2RecompiledFunctionTable[283614] = bhEne30_MV06_0x214c80; // 0x214f80 - g_ps2RecompiledFunctionTable[283618] = bhEne30_MV06_0x214c80; // 0x214f90 - g_ps2RecompiledFunctionTable[283623] = bhEne30_MV06_0x214c80; // 0x214fa4 - g_ps2RecompiledFunctionTable[283628] = bhEne30_MV06_0x214c80; // 0x214fb8 - g_ps2RecompiledFunctionTable[283630] = bhEne30_MV06_0x214c80; // 0x214fc0 - g_ps2RecompiledFunctionTable[283647] = bhEne30_MV06_0x214c80; // 0x215004 - g_ps2RecompiledFunctionTable[283660] = bhEne30_MV06_0x214c80; // 0x215038 - g_ps2RecompiledFunctionTable[283677] = bhEne30_MV06_0x214c80; // 0x21507c - g_ps2RecompiledFunctionTable[283693] = bhEne30_MV06_0x214c80; // 0x2150bc - g_ps2RecompiledFunctionTable[283712] = bhEne30_MV06_0x214c80; // 0x215108 - g_ps2RecompiledFunctionTable[283731] = bhEne30_MV06_0x214c80; // 0x215154 - g_ps2RecompiledFunctionTable[283733] = bhEne30_MV06_0x214c80; // 0x21515c - g_ps2RecompiledFunctionTable[283749] = bhEne30_MV06_0x214c80; // 0x21519c - g_ps2RecompiledFunctionTable[283752] = bhEne30_MV06_0x214c80; // 0x2151a8 - g_ps2RecompiledFunctionTable[283756] = bhEne30_MV06_0x214c80; // 0x2151b8 - g_ps2RecompiledFunctionTable[283761] = bhEne30_MV06_0x214c80; // 0x2151cc - g_ps2RecompiledFunctionTable[283794] = bhEne30_MV07_0x215250; // 0x215250 - g_ps2RecompiledFunctionTable[283841] = bhEne30_MV07_0x215250; // 0x21530c - g_ps2RecompiledFunctionTable[283844] = bhEne30_MV07_0x215250; // 0x215318 - g_ps2RecompiledFunctionTable[283854] = bhEne30_MV07_0x215250; // 0x215340 - g_ps2RecompiledFunctionTable[283916] = bhEne30_MV07_0x215250; // 0x215438 - g_ps2RecompiledFunctionTable[283961] = bhEne30_MV07_0x215250; // 0x2154ec - g_ps2RecompiledFunctionTable[283998] = bhEne30_Nage_0x215580; // 0x215580 - g_ps2RecompiledFunctionTable[284002] = bhEne30_Damage_0x215590; // 0x215590 - g_ps2RecompiledFunctionTable[284003] = bhEne30_Damage_0x215590; // 0x215594 - g_ps2RecompiledFunctionTable[284004] = bhEne30_Damage_0x215590; // 0x215598 - g_ps2RecompiledFunctionTable[284005] = bhEne30_Damage_0x215590; // 0x21559c - g_ps2RecompiledFunctionTable[284006] = bhEne30_Damage_0x215590; // 0x2155a0 - g_ps2RecompiledFunctionTable[284007] = bhEne30_Damage_0x215590; // 0x2155a4 - g_ps2RecompiledFunctionTable[284008] = bhEne30_Damage_0x215590; // 0x2155a8 - g_ps2RecompiledFunctionTable[284009] = bhEne30_Damage_0x215590; // 0x2155ac - g_ps2RecompiledFunctionTable[284010] = bhEne30_DG00_0x2155b0; // 0x2155b0 - g_ps2RecompiledFunctionTable[284046] = bhEne30_DG01_0x215640; // 0x215640 - g_ps2RecompiledFunctionTable[284078] = bhEne30_Die_0x2156c0; // 0x2156c0 - g_ps2RecompiledFunctionTable[284079] = bhEne30_Die_0x2156c0; // 0x2156c4 - g_ps2RecompiledFunctionTable[284080] = bhEne30_Die_0x2156c0; // 0x2156c8 - g_ps2RecompiledFunctionTable[284081] = bhEne30_Die_0x2156c0; // 0x2156cc - g_ps2RecompiledFunctionTable[284082] = bhEne30_Die_0x2156c0; // 0x2156d0 - g_ps2RecompiledFunctionTable[284083] = bhEne30_Die_0x2156c0; // 0x2156d4 - g_ps2RecompiledFunctionTable[284084] = bhEne30_Die_0x2156c0; // 0x2156d8 - g_ps2RecompiledFunctionTable[284085] = bhEne30_Die_0x2156c0; // 0x2156dc - g_ps2RecompiledFunctionTable[284086] = bhEne30_DD00_0x2156e0; // 0x2156e0 - g_ps2RecompiledFunctionTable[284148] = bhEne30_DD00_0x2156e0; // 0x2157d8 - g_ps2RecompiledFunctionTable[284179] = bhEne30_DD00_0x2156e0; // 0x215854 - g_ps2RecompiledFunctionTable[284210] = bhEne30_DD00_0x2156e0; // 0x2158d0 - g_ps2RecompiledFunctionTable[284216] = bhEne30_DD00_0x2156e0; // 0x2158e8 - g_ps2RecompiledFunctionTable[284218] = bhEne30_DD00_0x2156e0; // 0x2158f0 - g_ps2RecompiledFunctionTable[284231] = bhEne30_DD00_0x2156e0; // 0x215924 - g_ps2RecompiledFunctionTable[284241] = bhEne30_DD00_0x2156e0; // 0x21594c - g_ps2RecompiledFunctionTable[284258] = bhEne30_DD01_0x215990; // 0x215990 - g_ps2RecompiledFunctionTable[284285] = bhEne30_DD01_0x215990; // 0x2159fc - g_ps2RecompiledFunctionTable[284306] = bhEne30_CheckEnemies_0x215a50; // 0x215a50 - g_ps2RecompiledFunctionTable[284318] = bhEne30_CheckEnemies_0x215a50; // 0x215a80 - g_ps2RecompiledFunctionTable[284342] = bhEne30_CheckEnemies_0x215a50; // 0x215ae0 - g_ps2RecompiledFunctionTable[284386] = bhEne30_DamageInit_0x215b90; // 0x215b90 - g_ps2RecompiledFunctionTable[284394] = bhEne30_DamageInit_0x215b90; // 0x215bb0 - g_ps2RecompiledFunctionTable[284418] = bhEne30_DamageInit_0x215b90; // 0x215c10 - g_ps2RecompiledFunctionTable[284439] = bhEne30_DamageInit_0x215b90; // 0x215c64 - g_ps2RecompiledFunctionTable[284447] = bhEne30_DamageInit_0x215b90; // 0x215c84 - g_ps2RecompiledFunctionTable[284451] = bhEne30_DamageInit_0x215b90; // 0x215c94 - g_ps2RecompiledFunctionTable[284482] = bhEne30_CollisionLine_0x215d10; // 0x215d10 - g_ps2RecompiledFunctionTable[284489] = bhEne30_CollisionLine_0x215d10; // 0x215d2c - g_ps2RecompiledFunctionTable[284498] = bhEne30_CollisionLine_0x215d10; // 0x215d50 - g_ps2RecompiledFunctionTable[284500] = bhEne30_CollisionLine_0x215d10; // 0x215d58 - g_ps2RecompiledFunctionTable[284518] = bhEne30_SetFluidEffect_0x215da0; // 0x215da0 - g_ps2RecompiledFunctionTable[284581] = bhEne30_SetFluidEffect_0x215da0; // 0x215e9c - g_ps2RecompiledFunctionTable[284610] = ikou_0x215f10; // 0x215f10 - g_ps2RecompiledFunctionTable[284624] = ikou_0x215f10; // 0x215f48 - g_ps2RecompiledFunctionTable[284658] = ikou3_0x215fd0; // 0x215fd0 - g_ps2RecompiledFunctionTable[284674] = ikou3_0x215fd0; // 0x216010 - g_ps2RecompiledFunctionTable[284698] = NitenDir_ck_0x216070; // 0x216070 - g_ps2RecompiledFunctionTable[284703] = NitenDir_ck_0x216070; // 0x216084 - g_ps2RecompiledFunctionTable[284708] = NitenDir_ck_0x216070; // 0x216098 - g_ps2RecompiledFunctionTable[284714] = bhCdirCheck_0x2160b0; // 0x2160b0 - g_ps2RecompiledFunctionTable[284722] = bhEne_LeverCheck_0x2160d0; // 0x2160d0 - g_ps2RecompiledFunctionTable[284738] = bhDGCdirCheck_0x216110; // 0x216110 - g_ps2RecompiledFunctionTable[284746] = bhDGCdirCheck_0x216110; // 0x216130 - g_ps2RecompiledFunctionTable[284750] = bhDGCdirCheck_0x216110; // 0x216140 - g_ps2RecompiledFunctionTable[284761] = bhDGCdirCheck_0x216110; // 0x21616c - g_ps2RecompiledFunctionTable[284764] = bhDGCdirCheck_0x216110; // 0x216178 - g_ps2RecompiledFunctionTable[284778] = bhDGCdirCheck2_0x2161b0; // 0x2161b0 - g_ps2RecompiledFunctionTable[284794] = bhDGCdirCheck2_0x2161b0; // 0x2161f0 - g_ps2RecompiledFunctionTable[284802] = bhDGCdirCheck2_0x2161b0; // 0x216210 - g_ps2RecompiledFunctionTable[284805] = bhDGCdirCheck2_0x2161b0; // 0x21621c - g_ps2RecompiledFunctionTable[284822] = bhDGCdirCheck3_0x216260; // 0x216260 - g_ps2RecompiledFunctionTable[284829] = bhDGCdirCheck3_0x216260; // 0x21627c - g_ps2RecompiledFunctionTable[284834] = bhDGCdirCheck3_0x216260; // 0x216290 - g_ps2RecompiledFunctionTable[284878] = bhEne_AngleCheck_0x216340; // 0x216340 - g_ps2RecompiledFunctionTable[284893] = bhEne_AngleCheck_0x216340; // 0x21637c - g_ps2RecompiledFunctionTable[284896] = bhEne_AngleCheck_0x216340; // 0x216388 - g_ps2RecompiledFunctionTable[284900] = bhEne_AngleCheck_0x216340; // 0x216398 - g_ps2RecompiledFunctionTable[284902] = bhEne_AngleCheck_0x216340; // 0x2163a0 - g_ps2RecompiledFunctionTable[284906] = bhEne_AngleCheck_0x216340; // 0x2163b0 - g_ps2RecompiledFunctionTable[284910] = bhEne_AngleCheck_0x216340; // 0x2163c0 - g_ps2RecompiledFunctionTable[284912] = bhEne_AngleCheck_0x216340; // 0x2163c8 - g_ps2RecompiledFunctionTable[284915] = bhEne_AngleCheck_0x216340; // 0x2163d4 - g_ps2RecompiledFunctionTable[284919] = bhEne_AngleCheck_0x216340; // 0x2163e4 - g_ps2RecompiledFunctionTable[284934] = bhEne_GetTranslateMtn_0x216420; // 0x216420 - g_ps2RecompiledFunctionTable[284983] = bhEne_GetTranslateMtn_0x216420; // 0x2164e4 - g_ps2RecompiledFunctionTable[284988] = bhEne_GetTranslateMtn_0x216420; // 0x2164f8 - g_ps2RecompiledFunctionTable[284993] = bhEne_GetTranslateMtn_0x216420; // 0x21650c - g_ps2RecompiledFunctionTable[284997] = bhEne_GetTranslateMtn_0x216420; // 0x21651c - g_ps2RecompiledFunctionTable[285006] = bhEne_GetTranslateMtn_0x216420; // 0x216540 - g_ps2RecompiledFunctionTable[285018] = bhEne_GetTranslateMtn2_0x216570; // 0x216570 - g_ps2RecompiledFunctionTable[285067] = bhEne_GetTranslateMtn2_0x216570; // 0x216634 - g_ps2RecompiledFunctionTable[285074] = bhEne_CalcPartsPos_0x216650; // 0x216650 - g_ps2RecompiledFunctionTable[285091] = bhEne_CalcPartsPos_0x216650; // 0x216694 - g_ps2RecompiledFunctionTable[285096] = bhEne_CalcPartsPos_0x216650; // 0x2166a8 - g_ps2RecompiledFunctionTable[285101] = bhEne_CalcPartsPos_0x216650; // 0x2166bc - g_ps2RecompiledFunctionTable[285104] = bhEne_CalcPartsPos_0x216650; // 0x2166c8 - g_ps2RecompiledFunctionTable[285118] = bhEne_CalcPartsPos_0x216650; // 0x216700 - g_ps2RecompiledFunctionTable[285123] = bhEne_CalcPartsPos_0x216650; // 0x216714 - g_ps2RecompiledFunctionTable[285131] = bhEne_CalcPartsPos_0x216650; // 0x216734 - g_ps2RecompiledFunctionTable[285142] = bhKaidanAtrCheck_0x216760; // 0x216760 - g_ps2RecompiledFunctionTable[285153] = bhKaidanAtrCheck_0x216760; // 0x21678c - g_ps2RecompiledFunctionTable[285158] = bhKaidanAtrCheck_0x216760; // 0x2167a0 - g_ps2RecompiledFunctionTable[285179] = bhKaidanAtrCheck_0x216760; // 0x2167f4 - g_ps2RecompiledFunctionTable[285278] = bhEne_EnemyAtariCheck_0x216980; // 0x216980 - g_ps2RecompiledFunctionTable[285305] = bhEne_EnemyAtariCheck_0x216980; // 0x2169ec - g_ps2RecompiledFunctionTable[285339] = bhEne_EnemyAtariCheck_0x216980; // 0x216a74 - g_ps2RecompiledFunctionTable[285370] = bhEne_PosCheck_0x216af0; // 0x216af0 - g_ps2RecompiledFunctionTable[285394] = bhEne_SetBlood_0x216b50; // 0x216b50 - g_ps2RecompiledFunctionTable[285435] = bhEne_SetBlood_0x216b50; // 0x216bf4 - g_ps2RecompiledFunctionTable[285437] = bhEne_SetBlood_0x216b50; // 0x216bfc - g_ps2RecompiledFunctionTable[285441] = bhEne_SetBlood_0x216b50; // 0x216c0c - g_ps2RecompiledFunctionTable[285446] = bhEne_SetBlood_0x216b50; // 0x216c20 - g_ps2RecompiledFunctionTable[285454] = bhEne_SetBlood_0x216b50; // 0x216c40 - g_ps2RecompiledFunctionTable[285470] = bhEne_SetBlood_0x216b50; // 0x216c80 - g_ps2RecompiledFunctionTable[285500] = bhEne_SetBlood_0x216b50; // 0x216cf8 - g_ps2RecompiledFunctionTable[285510] = bhEne_SetBlood2_0x216d20; // 0x216d20 - g_ps2RecompiledFunctionTable[285511] = bhEne_SetBlood2_0x216d20; // 0x216d24 - g_ps2RecompiledFunctionTable[285512] = bhEne_SetBlood2_0x216d20; // 0x216d28 - g_ps2RecompiledFunctionTable[285513] = bhEne_SetBlood2_0x216d20; // 0x216d2c - g_ps2RecompiledFunctionTable[285514] = bhEne_SetBlood2_0x216d20; // 0x216d30 - g_ps2RecompiledFunctionTable[285515] = bhEne_SetBlood2_0x216d20; // 0x216d34 - g_ps2RecompiledFunctionTable[285516] = bhEne_SetBlood2_0x216d20; // 0x216d38 - g_ps2RecompiledFunctionTable[285517] = bhEne_SetBlood2_0x216d20; // 0x216d3c - g_ps2RecompiledFunctionTable[285518] = bhEne_SetBlood2_0x216d20; // 0x216d40 - g_ps2RecompiledFunctionTable[285519] = bhEne_SetBlood2_0x216d20; // 0x216d44 - g_ps2RecompiledFunctionTable[285520] = bhEne_SetBlood2_0x216d20; // 0x216d48 - g_ps2RecompiledFunctionTable[285521] = bhEne_SetBlood2_0x216d20; // 0x216d4c - g_ps2RecompiledFunctionTable[285522] = bhEne_SetBlood2_0x216d20; // 0x216d50 - g_ps2RecompiledFunctionTable[285523] = bhEne_SetBlood2_0x216d20; // 0x216d54 - g_ps2RecompiledFunctionTable[285524] = bhEne_SetBlood2_0x216d20; // 0x216d58 - g_ps2RecompiledFunctionTable[285525] = bhEne_SetBlood2_0x216d20; // 0x216d5c - g_ps2RecompiledFunctionTable[285526] = bhEne_SetBlood2_0x216d20; // 0x216d60 - g_ps2RecompiledFunctionTable[285527] = bhEne_SetBlood2_0x216d20; // 0x216d64 - g_ps2RecompiledFunctionTable[285528] = bhEne_SetBlood2_0x216d20; // 0x216d68 - g_ps2RecompiledFunctionTable[285529] = bhEne_SetBlood2_0x216d20; // 0x216d6c - g_ps2RecompiledFunctionTable[285530] = bhEne_SetBlood2_0x216d20; // 0x216d70 - g_ps2RecompiledFunctionTable[285531] = bhEne_SetBlood2_0x216d20; // 0x216d74 - g_ps2RecompiledFunctionTable[285532] = bhEne_SetBlood2_0x216d20; // 0x216d78 - g_ps2RecompiledFunctionTable[285533] = bhEne_SetBlood2_0x216d20; // 0x216d7c - g_ps2RecompiledFunctionTable[285534] = bhEne_SetBlood2_0x216d20; // 0x216d80 - g_ps2RecompiledFunctionTable[285535] = bhEne_SetBlood2_0x216d20; // 0x216d84 - g_ps2RecompiledFunctionTable[285536] = bhEne_SetBlood2_0x216d20; // 0x216d88 - g_ps2RecompiledFunctionTable[285537] = bhEne_SetBlood2_0x216d20; // 0x216d8c - g_ps2RecompiledFunctionTable[285538] = bhEne_SetBlood2_0x216d20; // 0x216d90 - g_ps2RecompiledFunctionTable[285539] = bhEne_SetBlood2_0x216d20; // 0x216d94 - g_ps2RecompiledFunctionTable[285540] = bhEne_SetBlood2_0x216d20; // 0x216d98 - g_ps2RecompiledFunctionTable[285541] = bhEne_SetBlood2_0x216d20; // 0x216d9c - g_ps2RecompiledFunctionTable[285542] = bhEne_SetBlood2_0x216d20; // 0x216da0 - g_ps2RecompiledFunctionTable[285543] = bhEne_SetBlood2_0x216d20; // 0x216da4 - g_ps2RecompiledFunctionTable[285544] = bhEne_SetBlood2_0x216d20; // 0x216da8 - g_ps2RecompiledFunctionTable[285545] = bhEne_SetBlood2_0x216d20; // 0x216dac - g_ps2RecompiledFunctionTable[285546] = bhEne_SetBlood2_0x216d20; // 0x216db0 - g_ps2RecompiledFunctionTable[285547] = bhEne_SetBlood2_0x216d20; // 0x216db4 - g_ps2RecompiledFunctionTable[285548] = bhEne_SetBlood2_0x216d20; // 0x216db8 - g_ps2RecompiledFunctionTable[285549] = bhEne_SetBlood2_0x216d20; // 0x216dbc - g_ps2RecompiledFunctionTable[285550] = bhEne_SetBlood2_0x216d20; // 0x216dc0 - g_ps2RecompiledFunctionTable[285551] = bhEne_SetBlood2_0x216d20; // 0x216dc4 - g_ps2RecompiledFunctionTable[285552] = bhEne_SetBlood2_0x216d20; // 0x216dc8 - g_ps2RecompiledFunctionTable[285553] = bhEne_SetBlood2_0x216d20; // 0x216dcc - g_ps2RecompiledFunctionTable[285554] = bhEne_SetBlood2_0x216d20; // 0x216dd0 - g_ps2RecompiledFunctionTable[285555] = bhEne_SetBlood2_0x216d20; // 0x216dd4 - g_ps2RecompiledFunctionTable[285556] = bhEne_SetBlood2_0x216d20; // 0x216dd8 - g_ps2RecompiledFunctionTable[285557] = bhEne_SetBlood2_0x216d20; // 0x216ddc - g_ps2RecompiledFunctionTable[285558] = bhEne_SetBlood2_0x216d20; // 0x216de0 - g_ps2RecompiledFunctionTable[285559] = bhEne_SetBlood2_0x216d20; // 0x216de4 - g_ps2RecompiledFunctionTable[285560] = bhEne_SetBlood2_0x216d20; // 0x216de8 - g_ps2RecompiledFunctionTable[285561] = bhEne_SetBlood2_0x216d20; // 0x216dec - g_ps2RecompiledFunctionTable[285562] = bhEne_SetBlood2_0x216d20; // 0x216df0 - g_ps2RecompiledFunctionTable[285563] = bhEne_SetBlood2_0x216d20; // 0x216df4 - g_ps2RecompiledFunctionTable[285564] = bhEne_SetBlood2_0x216d20; // 0x216df8 - g_ps2RecompiledFunctionTable[285565] = bhEne_SetBlood2_0x216d20; // 0x216dfc - g_ps2RecompiledFunctionTable[285566] = bhEne_SetBlood2_0x216d20; // 0x216e00 - g_ps2RecompiledFunctionTable[285567] = bhEne_SetBlood2_0x216d20; // 0x216e04 - g_ps2RecompiledFunctionTable[285568] = bhEne_SetBlood2_0x216d20; // 0x216e08 - g_ps2RecompiledFunctionTable[285569] = bhEne_SetBlood2_0x216d20; // 0x216e0c - g_ps2RecompiledFunctionTable[285570] = bhEne_SetBlood2_0x216d20; // 0x216e10 - g_ps2RecompiledFunctionTable[285571] = bhEne_SetBlood2_0x216d20; // 0x216e14 - g_ps2RecompiledFunctionTable[285572] = bhEne_SetBlood2_0x216d20; // 0x216e18 - g_ps2RecompiledFunctionTable[285573] = bhEne_SetBlood2_0x216d20; // 0x216e1c - g_ps2RecompiledFunctionTable[285574] = bhEne_SetBlood2_0x216d20; // 0x216e20 - g_ps2RecompiledFunctionTable[285575] = bhEne_SetBlood2_0x216d20; // 0x216e24 - g_ps2RecompiledFunctionTable[285576] = bhEne_SetBlood2_0x216d20; // 0x216e28 - g_ps2RecompiledFunctionTable[285577] = bhEne_SetBlood2_0x216d20; // 0x216e2c - g_ps2RecompiledFunctionTable[285578] = bhEne_SetBlood2_0x216d20; // 0x216e30 - g_ps2RecompiledFunctionTable[285579] = bhEne_SetBlood2_0x216d20; // 0x216e34 - g_ps2RecompiledFunctionTable[285580] = bhEne_SetBlood2_0x216d20; // 0x216e38 - g_ps2RecompiledFunctionTable[285581] = bhEne_SetBlood2_0x216d20; // 0x216e3c - g_ps2RecompiledFunctionTable[285582] = bhEne_SetBlood2_0x216d20; // 0x216e40 - g_ps2RecompiledFunctionTable[285583] = bhEne_SetBlood2_0x216d20; // 0x216e44 - g_ps2RecompiledFunctionTable[285584] = bhEne_SetBlood2_0x216d20; // 0x216e48 - g_ps2RecompiledFunctionTable[285585] = bhEne_SetBlood2_0x216d20; // 0x216e4c - g_ps2RecompiledFunctionTable[285586] = bhEne_SetBlood2_0x216d20; // 0x216e50 - g_ps2RecompiledFunctionTable[285587] = bhEne_SetBlood2_0x216d20; // 0x216e54 - g_ps2RecompiledFunctionTable[285588] = bhEne_SetBlood2_0x216d20; // 0x216e58 - g_ps2RecompiledFunctionTable[285589] = bhEne_SetBlood2_0x216d20; // 0x216e5c - g_ps2RecompiledFunctionTable[285590] = bhEne_SetBlood2_0x216d20; // 0x216e60 - g_ps2RecompiledFunctionTable[285591] = bhEne_SetBlood2_0x216d20; // 0x216e64 - g_ps2RecompiledFunctionTable[285592] = bhEne_SetBlood2_0x216d20; // 0x216e68 - g_ps2RecompiledFunctionTable[285593] = bhEne_SetBlood2_0x216d20; // 0x216e6c - g_ps2RecompiledFunctionTable[285594] = bhEne_SetBlood2_0x216d20; // 0x216e70 - g_ps2RecompiledFunctionTable[285595] = bhEne_SetBlood2_0x216d20; // 0x216e74 - g_ps2RecompiledFunctionTable[285596] = bhEne_SetBlood2_0x216d20; // 0x216e78 - g_ps2RecompiledFunctionTable[285597] = bhEne_SetBlood2_0x216d20; // 0x216e7c - g_ps2RecompiledFunctionTable[285598] = bhEne_SetBlood2_0x216d20; // 0x216e80 - g_ps2RecompiledFunctionTable[285599] = bhEne_SetBlood2_0x216d20; // 0x216e84 - g_ps2RecompiledFunctionTable[285600] = bhEne_SetBlood2_0x216d20; // 0x216e88 - g_ps2RecompiledFunctionTable[285601] = bhEne_SetBlood2_0x216d20; // 0x216e8c - g_ps2RecompiledFunctionTable[285602] = bhEne_SetBlood2_0x216d20; // 0x216e90 - g_ps2RecompiledFunctionTable[285603] = bhEne_SetBlood2_0x216d20; // 0x216e94 - g_ps2RecompiledFunctionTable[285604] = bhEne_SetBlood2_0x216d20; // 0x216e98 - g_ps2RecompiledFunctionTable[285605] = bhEne_SetBlood2_0x216d20; // 0x216e9c - g_ps2RecompiledFunctionTable[285606] = bhEne_SetBlood2_0x216d20; // 0x216ea0 - g_ps2RecompiledFunctionTable[285607] = bhEne_SetBlood2_0x216d20; // 0x216ea4 - g_ps2RecompiledFunctionTable[285608] = bhEne_SetBlood2_0x216d20; // 0x216ea8 - g_ps2RecompiledFunctionTable[285609] = bhEne_SetBlood2_0x216d20; // 0x216eac - g_ps2RecompiledFunctionTable[285610] = bhEne_SetBlood2_0x216d20; // 0x216eb0 - g_ps2RecompiledFunctionTable[285611] = bhEne_SetBlood2_0x216d20; // 0x216eb4 - g_ps2RecompiledFunctionTable[285612] = bhEne_SetBlood2_0x216d20; // 0x216eb8 - g_ps2RecompiledFunctionTable[285613] = bhEne_SetBlood2_0x216d20; // 0x216ebc - g_ps2RecompiledFunctionTable[285614] = bhEne_SetBlood2_0x216d20; // 0x216ec0 - g_ps2RecompiledFunctionTable[285615] = bhEne_SetBlood2_0x216d20; // 0x216ec4 - g_ps2RecompiledFunctionTable[285616] = bhEne_SetBlood2_0x216d20; // 0x216ec8 - g_ps2RecompiledFunctionTable[285617] = bhEne_SetBlood2_0x216d20; // 0x216ecc - g_ps2RecompiledFunctionTable[285618] = bhEne_SetBlood2_0x216d20; // 0x216ed0 - g_ps2RecompiledFunctionTable[285619] = bhEne_SetBlood2_0x216d20; // 0x216ed4 - g_ps2RecompiledFunctionTable[285620] = bhEne_SetBlood2_0x216d20; // 0x216ed8 - g_ps2RecompiledFunctionTable[285621] = bhEne_SetBlood2_0x216d20; // 0x216edc - g_ps2RecompiledFunctionTable[285622] = bhEne_SetBlood2_0x216d20; // 0x216ee0 - g_ps2RecompiledFunctionTable[285623] = bhEne_SetBlood2_0x216d20; // 0x216ee4 - g_ps2RecompiledFunctionTable[285624] = bhEne_SetBlood2_0x216d20; // 0x216ee8 - g_ps2RecompiledFunctionTable[285625] = bhEne_SetBlood2_0x216d20; // 0x216eec - g_ps2RecompiledFunctionTable[285626] = bhEne_SetBlood2_0x216d20; // 0x216ef0 - g_ps2RecompiledFunctionTable[285627] = bhEne_SetBlood2_0x216d20; // 0x216ef4 - g_ps2RecompiledFunctionTable[285628] = bhEne_SetBlood2_0x216d20; // 0x216ef8 - g_ps2RecompiledFunctionTable[285629] = bhEne_SetBlood2_0x216d20; // 0x216efc - g_ps2RecompiledFunctionTable[285630] = bhEne_SetBlood2_0x216d20; // 0x216f00 - g_ps2RecompiledFunctionTable[285631] = bhEne_SetBlood2_0x216d20; // 0x216f04 - g_ps2RecompiledFunctionTable[285632] = bhEne_SetBlood2_0x216d20; // 0x216f08 - g_ps2RecompiledFunctionTable[285633] = bhEne_SetBlood2_0x216d20; // 0x216f0c - g_ps2RecompiledFunctionTable[285634] = bhEne_SetBlood2_0x216d20; // 0x216f10 - g_ps2RecompiledFunctionTable[285635] = bhEne_SetBlood2_0x216d20; // 0x216f14 - g_ps2RecompiledFunctionTable[285636] = bhEne_SetBlood2_0x216d20; // 0x216f18 - g_ps2RecompiledFunctionTable[285637] = bhEne_SetBlood2_0x216d20; // 0x216f1c - g_ps2RecompiledFunctionTable[285638] = bhEne_SetBlood2_0x216d20; // 0x216f20 - g_ps2RecompiledFunctionTable[285639] = bhEne_SetBlood2_0x216d20; // 0x216f24 - g_ps2RecompiledFunctionTable[285640] = bhEne_SetBlood2_0x216d20; // 0x216f28 - g_ps2RecompiledFunctionTable[285641] = bhEne_SetBlood2_0x216d20; // 0x216f2c - g_ps2RecompiledFunctionTable[285642] = bhEne_SetBlood2_0x216d20; // 0x216f30 - g_ps2RecompiledFunctionTable[285643] = bhEne_SetBlood2_0x216d20; // 0x216f34 - g_ps2RecompiledFunctionTable[285644] = bhEne_SetBlood2_0x216d20; // 0x216f38 - g_ps2RecompiledFunctionTable[285645] = bhEne_SetBlood2_0x216d20; // 0x216f3c - g_ps2RecompiledFunctionTable[285646] = bhEne_SetBlood2_0x216d20; // 0x216f40 - g_ps2RecompiledFunctionTable[285647] = bhEne_SetBlood2_0x216d20; // 0x216f44 - g_ps2RecompiledFunctionTable[285648] = bhEne_SetBlood2_0x216d20; // 0x216f48 - g_ps2RecompiledFunctionTable[285649] = bhEne_SetBlood2_0x216d20; // 0x216f4c - g_ps2RecompiledFunctionTable[285650] = bhEne_SetBlood2_0x216d20; // 0x216f50 - g_ps2RecompiledFunctionTable[285651] = bhEne_SetBlood2_0x216d20; // 0x216f54 - g_ps2RecompiledFunctionTable[285652] = bhEne_SetBlood2_0x216d20; // 0x216f58 - g_ps2RecompiledFunctionTable[285653] = bhEne_SetBlood2_0x216d20; // 0x216f5c - g_ps2RecompiledFunctionTable[285654] = bhEne_SetBlood2_0x216d20; // 0x216f60 - g_ps2RecompiledFunctionTable[285655] = bhEne_SetBlood2_0x216d20; // 0x216f64 - g_ps2RecompiledFunctionTable[285656] = bhEne_SetBlood2_0x216d20; // 0x216f68 - g_ps2RecompiledFunctionTable[285657] = bhEne_SetBlood2_0x216d20; // 0x216f6c - g_ps2RecompiledFunctionTable[285658] = bhEne_SetBlood2_0x216d20; // 0x216f70 - g_ps2RecompiledFunctionTable[285659] = bhEne_SetBlood2_0x216d20; // 0x216f74 - g_ps2RecompiledFunctionTable[285660] = bhEne_SetBlood2_0x216d20; // 0x216f78 - g_ps2RecompiledFunctionTable[285661] = bhEne_SetBlood2_0x216d20; // 0x216f7c - g_ps2RecompiledFunctionTable[285662] = bhEne_SetBlood2_0x216d20; // 0x216f80 - g_ps2RecompiledFunctionTable[285663] = bhEne_SetBlood2_0x216d20; // 0x216f84 - g_ps2RecompiledFunctionTable[285664] = bhEne_SetBlood2_0x216d20; // 0x216f88 - g_ps2RecompiledFunctionTable[285665] = bhEne_SetBlood2_0x216d20; // 0x216f8c - g_ps2RecompiledFunctionTable[285666] = bhEne_SetBlood2_0x216d20; // 0x216f90 - g_ps2RecompiledFunctionTable[285667] = bhEne_SetBlood2_0x216d20; // 0x216f94 - g_ps2RecompiledFunctionTable[285668] = bhEne_SetBlood2_0x216d20; // 0x216f98 - g_ps2RecompiledFunctionTable[285669] = bhEne_SetBlood2_0x216d20; // 0x216f9c - g_ps2RecompiledFunctionTable[285670] = bhEne_SetBlood2_0x216d20; // 0x216fa0 - g_ps2RecompiledFunctionTable[285671] = bhEne_SetBlood2_0x216d20; // 0x216fa4 - g_ps2RecompiledFunctionTable[285672] = bhEne_SetBlood2_0x216d20; // 0x216fa8 - g_ps2RecompiledFunctionTable[285673] = bhEne_SetBlood2_0x216d20; // 0x216fac - g_ps2RecompiledFunctionTable[285674] = bhEne_SetBlood2_0x216d20; // 0x216fb0 - g_ps2RecompiledFunctionTable[285675] = bhEne_SetBlood2_0x216d20; // 0x216fb4 - g_ps2RecompiledFunctionTable[285676] = bhEne_SetBlood2_0x216d20; // 0x216fb8 - g_ps2RecompiledFunctionTable[285677] = bhEne_SetBlood2_0x216d20; // 0x216fbc - g_ps2RecompiledFunctionTable[285678] = bhEne_SetBlood2_0x216d20; // 0x216fc0 - g_ps2RecompiledFunctionTable[285679] = bhEne_SetBlood2_0x216d20; // 0x216fc4 - g_ps2RecompiledFunctionTable[285680] = bhEne_SetBlood2_0x216d20; // 0x216fc8 - g_ps2RecompiledFunctionTable[285681] = bhEne_SetBlood2_0x216d20; // 0x216fcc - g_ps2RecompiledFunctionTable[285682] = bhEne_SetBlood2_0x216d20; // 0x216fd0 - g_ps2RecompiledFunctionTable[285683] = bhEne_SetBlood2_0x216d20; // 0x216fd4 - g_ps2RecompiledFunctionTable[285684] = bhEne_SetBlood2_0x216d20; // 0x216fd8 - g_ps2RecompiledFunctionTable[285685] = bhEne_SetBlood2_0x216d20; // 0x216fdc - g_ps2RecompiledFunctionTable[285686] = bhEne_SetBlood2_0x216d20; // 0x216fe0 - g_ps2RecompiledFunctionTable[285687] = bhEne_SetBlood2_0x216d20; // 0x216fe4 - g_ps2RecompiledFunctionTable[285688] = bhEne_SetBlood2_0x216d20; // 0x216fe8 - g_ps2RecompiledFunctionTable[285689] = bhEne_SetBlood2_0x216d20; // 0x216fec - g_ps2RecompiledFunctionTable[285690] = bhEne_SetBlood2_0x216d20; // 0x216ff0 - g_ps2RecompiledFunctionTable[285691] = bhEne_SetBlood2_0x216d20; // 0x216ff4 - g_ps2RecompiledFunctionTable[285692] = bhEne_SetBlood2_0x216d20; // 0x216ff8 - g_ps2RecompiledFunctionTable[285693] = bhEne_SetBlood2_0x216d20; // 0x216ffc - g_ps2RecompiledFunctionTable[285694] = bhEne_SetBlood2_0x216d20; // 0x217000 - g_ps2RecompiledFunctionTable[285695] = bhEne_SetBlood2_0x216d20; // 0x217004 - g_ps2RecompiledFunctionTable[285696] = bhEne_SetBlood2_0x216d20; // 0x217008 - g_ps2RecompiledFunctionTable[285697] = bhEne_SetBlood2_0x216d20; // 0x21700c - g_ps2RecompiledFunctionTable[285698] = bhEne_SetBlood2_0x216d20; // 0x217010 - g_ps2RecompiledFunctionTable[285699] = bhEne_SetBlood2_0x216d20; // 0x217014 - g_ps2RecompiledFunctionTable[285700] = bhEne_SetBlood2_0x216d20; // 0x217018 - g_ps2RecompiledFunctionTable[285701] = bhEne_SetBlood2_0x216d20; // 0x21701c - g_ps2RecompiledFunctionTable[285702] = bhEne_SetBlood2_0x216d20; // 0x217020 - g_ps2RecompiledFunctionTable[285703] = bhEne_SetBlood2_0x216d20; // 0x217024 - g_ps2RecompiledFunctionTable[285704] = bhEne_SetBlood2_0x216d20; // 0x217028 - g_ps2RecompiledFunctionTable[285705] = bhEne_SetBlood2_0x216d20; // 0x21702c - g_ps2RecompiledFunctionTable[285706] = bhEne_SetBlood2_0x216d20; // 0x217030 - g_ps2RecompiledFunctionTable[285707] = bhEne_SetBlood2_0x216d20; // 0x217034 - g_ps2RecompiledFunctionTable[285708] = bhEne_SetBlood2_0x216d20; // 0x217038 - g_ps2RecompiledFunctionTable[285709] = bhEne_SetBlood2_0x216d20; // 0x21703c - g_ps2RecompiledFunctionTable[285710] = bhEne_SetBlood2_0x216d20; // 0x217040 - g_ps2RecompiledFunctionTable[285711] = bhEne_SetBlood2_0x216d20; // 0x217044 - g_ps2RecompiledFunctionTable[285712] = bhEne_SetBlood2_0x216d20; // 0x217048 - g_ps2RecompiledFunctionTable[285713] = bhEne_SetBlood2_0x216d20; // 0x21704c - g_ps2RecompiledFunctionTable[285714] = bhEne_SetBlood2_0x216d20; // 0x217050 - g_ps2RecompiledFunctionTable[285715] = bhEne_SetBlood2_0x216d20; // 0x217054 - g_ps2RecompiledFunctionTable[285716] = bhEne_SetBlood2_0x216d20; // 0x217058 - g_ps2RecompiledFunctionTable[285717] = bhEne_SetBlood2_0x216d20; // 0x21705c - g_ps2RecompiledFunctionTable[285718] = bhEne_SetBlood2_0x216d20; // 0x217060 - g_ps2RecompiledFunctionTable[285719] = bhEne_SetBlood2_0x216d20; // 0x217064 - g_ps2RecompiledFunctionTable[285720] = bhEne_SetBlood2_0x216d20; // 0x217068 - g_ps2RecompiledFunctionTable[285721] = bhEne_SetBlood2_0x216d20; // 0x21706c - g_ps2RecompiledFunctionTable[285722] = bhEne_SetBlood2_0x216d20; // 0x217070 - g_ps2RecompiledFunctionTable[285723] = bhEne_SetBlood2_0x216d20; // 0x217074 - g_ps2RecompiledFunctionTable[285724] = bhEne_SetBlood2_0x216d20; // 0x217078 - g_ps2RecompiledFunctionTable[285725] = bhEne_SetBlood2_0x216d20; // 0x21707c - g_ps2RecompiledFunctionTable[285726] = bhEne_SetBlood2_0x216d20; // 0x217080 - g_ps2RecompiledFunctionTable[285727] = bhEne_SetBlood2_0x216d20; // 0x217084 - g_ps2RecompiledFunctionTable[285728] = bhEne_SetBlood2_0x216d20; // 0x217088 - g_ps2RecompiledFunctionTable[285729] = bhEne_SetBlood2_0x216d20; // 0x21708c - g_ps2RecompiledFunctionTable[285730] = bhEne_SetBlood2_0x216d20; // 0x217090 - g_ps2RecompiledFunctionTable[285731] = bhEne_SetBlood2_0x216d20; // 0x217094 - g_ps2RecompiledFunctionTable[285732] = bhEne_SetBlood2_0x216d20; // 0x217098 - g_ps2RecompiledFunctionTable[285733] = bhEne_SetBlood2_0x216d20; // 0x21709c - g_ps2RecompiledFunctionTable[285734] = bhEne_SetBlood2_0x216d20; // 0x2170a0 - g_ps2RecompiledFunctionTable[285735] = bhEne_SetBlood2_0x216d20; // 0x2170a4 - g_ps2RecompiledFunctionTable[285736] = bhEne_SetBlood2_0x216d20; // 0x2170a8 - g_ps2RecompiledFunctionTable[285737] = bhEne_SetBlood2_0x216d20; // 0x2170ac - g_ps2RecompiledFunctionTable[285738] = bhEne_SetBlood2_0x216d20; // 0x2170b0 - g_ps2RecompiledFunctionTable[285739] = bhEne_SetBlood2_0x216d20; // 0x2170b4 - g_ps2RecompiledFunctionTable[285740] = bhEne_SetBlood2_0x216d20; // 0x2170b8 - g_ps2RecompiledFunctionTable[285741] = bhEne_SetBlood2_0x216d20; // 0x2170bc - g_ps2RecompiledFunctionTable[285742] = bhEne_SetBlood2_0x216d20; // 0x2170c0 - g_ps2RecompiledFunctionTable[285743] = bhEne_SetBlood2_0x216d20; // 0x2170c4 - g_ps2RecompiledFunctionTable[285744] = bhEne_SetBlood2_0x216d20; // 0x2170c8 - g_ps2RecompiledFunctionTable[285745] = bhEne_SetBlood2_0x216d20; // 0x2170cc - g_ps2RecompiledFunctionTable[285746] = bhEne_SetBlood2_0x216d20; // 0x2170d0 - g_ps2RecompiledFunctionTable[285747] = bhEne_SetBlood2_0x216d20; // 0x2170d4 - g_ps2RecompiledFunctionTable[285748] = bhEne_SetBlood2_0x216d20; // 0x2170d8 - g_ps2RecompiledFunctionTable[285749] = bhEne_SetBlood2_0x216d20; // 0x2170dc - g_ps2RecompiledFunctionTable[285750] = bhEne_SetBlood2_0x216d20; // 0x2170e0 - g_ps2RecompiledFunctionTable[285751] = bhEne_SetBlood2_0x216d20; // 0x2170e4 - g_ps2RecompiledFunctionTable[285752] = bhEne_SetBlood2_0x216d20; // 0x2170e8 - g_ps2RecompiledFunctionTable[285753] = bhEne_SetBlood2_0x216d20; // 0x2170ec - g_ps2RecompiledFunctionTable[285754] = bhEne_SetBlood2_0x216d20; // 0x2170f0 - g_ps2RecompiledFunctionTable[285755] = bhEne_SetBlood2_0x216d20; // 0x2170f4 - g_ps2RecompiledFunctionTable[285756] = bhEne_SetBlood2_0x216d20; // 0x2170f8 - g_ps2RecompiledFunctionTable[285757] = bhEne_SetBlood2_0x216d20; // 0x2170fc - g_ps2RecompiledFunctionTable[285758] = bhEne_SetBlood2_0x216d20; // 0x217100 - g_ps2RecompiledFunctionTable[285759] = bhEne_SetBlood2_0x216d20; // 0x217104 - g_ps2RecompiledFunctionTable[285760] = bhEne_SetBlood2_0x216d20; // 0x217108 - g_ps2RecompiledFunctionTable[285761] = bhEne_SetBlood2_0x216d20; // 0x21710c - g_ps2RecompiledFunctionTable[285762] = bhEne_SetBlood2_0x216d20; // 0x217110 - g_ps2RecompiledFunctionTable[285763] = bhEne_SetBlood2_0x216d20; // 0x217114 - g_ps2RecompiledFunctionTable[285764] = bhEne_SetBlood2_0x216d20; // 0x217118 - g_ps2RecompiledFunctionTable[285765] = bhEne_SetBlood2_0x216d20; // 0x21711c - g_ps2RecompiledFunctionTable[285766] = bhEne_SetBlood2_0x216d20; // 0x217120 - g_ps2RecompiledFunctionTable[285767] = bhEne_SetBlood2_0x216d20; // 0x217124 - g_ps2RecompiledFunctionTable[285768] = bhEne_SetBlood2_0x216d20; // 0x217128 - g_ps2RecompiledFunctionTable[285769] = bhEne_SetBlood2_0x216d20; // 0x21712c - g_ps2RecompiledFunctionTable[285770] = bhEne_SetBlood2_0x216d20; // 0x217130 - g_ps2RecompiledFunctionTable[285771] = bhEne_SetBlood2_0x216d20; // 0x217134 - g_ps2RecompiledFunctionTable[285772] = bhEne_SetBlood2_0x216d20; // 0x217138 - g_ps2RecompiledFunctionTable[285773] = bhEne_SetBlood2_0x216d20; // 0x21713c - g_ps2RecompiledFunctionTable[285774] = bhEne_SetBlood2_0x216d20; // 0x217140 - g_ps2RecompiledFunctionTable[285775] = bhEne_SetBlood2_0x216d20; // 0x217144 - g_ps2RecompiledFunctionTable[285776] = bhEne_SetBlood2_0x216d20; // 0x217148 - g_ps2RecompiledFunctionTable[285777] = bhEne_SetBlood2_0x216d20; // 0x21714c - g_ps2RecompiledFunctionTable[285778] = bhEne_SetBlood2_0x216d20; // 0x217150 - g_ps2RecompiledFunctionTable[285779] = bhEne_SetBlood2_0x216d20; // 0x217154 - g_ps2RecompiledFunctionTable[285780] = bhEne_SetBlood2_0x216d20; // 0x217158 - g_ps2RecompiledFunctionTable[285781] = bhEne_SetBlood2_0x216d20; // 0x21715c - g_ps2RecompiledFunctionTable[285782] = bhEne_SetBlood2_0x216d20; // 0x217160 - g_ps2RecompiledFunctionTable[285783] = bhEne_SetBlood2_0x216d20; // 0x217164 - g_ps2RecompiledFunctionTable[285784] = bhEne_SetBlood2_0x216d20; // 0x217168 - g_ps2RecompiledFunctionTable[285785] = bhEne_SetBlood2_0x216d20; // 0x21716c - g_ps2RecompiledFunctionTable[285786] = bhEne_SetBlood2_0x216d20; // 0x217170 - g_ps2RecompiledFunctionTable[285787] = bhEne_SetBlood2_0x216d20; // 0x217174 - g_ps2RecompiledFunctionTable[285788] = bhEne_SetBlood2_0x216d20; // 0x217178 - g_ps2RecompiledFunctionTable[285789] = bhEne_SetBlood2_0x216d20; // 0x21717c - g_ps2RecompiledFunctionTable[285790] = bhEne_SetBlood2_0x216d20; // 0x217180 - g_ps2RecompiledFunctionTable[285791] = bhEne_SetBlood2_0x216d20; // 0x217184 - g_ps2RecompiledFunctionTable[285792] = bhEne_SetBlood2_0x216d20; // 0x217188 - g_ps2RecompiledFunctionTable[285793] = bhEne_SetBlood2_0x216d20; // 0x21718c - g_ps2RecompiledFunctionTable[285794] = bhEne_SetBlood2_0x216d20; // 0x217190 - g_ps2RecompiledFunctionTable[285795] = bhEne_SetBlood2_0x216d20; // 0x217194 - g_ps2RecompiledFunctionTable[285796] = bhEne_SetBlood2_0x216d20; // 0x217198 - g_ps2RecompiledFunctionTable[285797] = bhEne_SetBlood2_0x216d20; // 0x21719c - g_ps2RecompiledFunctionTable[285798] = bhEne_SetBlood2_0x216d20; // 0x2171a0 - g_ps2RecompiledFunctionTable[285799] = bhEne_SetBlood2_0x216d20; // 0x2171a4 - g_ps2RecompiledFunctionTable[285800] = bhEne_SetBlood2_0x216d20; // 0x2171a8 - g_ps2RecompiledFunctionTable[285801] = bhEne_SetBlood2_0x216d20; // 0x2171ac - g_ps2RecompiledFunctionTable[285802] = bhEne_SetBlood2_0x216d20; // 0x2171b0 - g_ps2RecompiledFunctionTable[285803] = bhEne_SetBlood2_0x216d20; // 0x2171b4 - g_ps2RecompiledFunctionTable[285804] = bhEne_SetBlood2_0x216d20; // 0x2171b8 - g_ps2RecompiledFunctionTable[285805] = bhEne_SetBlood2_0x216d20; // 0x2171bc - g_ps2RecompiledFunctionTable[285806] = bhEne_SetBlood2_0x216d20; // 0x2171c0 - g_ps2RecompiledFunctionTable[285807] = bhEne_SetBlood2_0x216d20; // 0x2171c4 - g_ps2RecompiledFunctionTable[285808] = bhEne_SetBlood2_0x216d20; // 0x2171c8 - g_ps2RecompiledFunctionTable[285809] = bhEne_SetBlood2_0x216d20; // 0x2171cc - g_ps2RecompiledFunctionTable[285810] = bhEne_SetBlood2_0x216d20; // 0x2171d0 - g_ps2RecompiledFunctionTable[285811] = bhEne_SetBlood2_0x216d20; // 0x2171d4 - g_ps2RecompiledFunctionTable[285812] = bhEne_SetBlood2_0x216d20; // 0x2171d8 - g_ps2RecompiledFunctionTable[285813] = bhEne_SetBlood2_0x216d20; // 0x2171dc - g_ps2RecompiledFunctionTable[285814] = bhEne_SetBlood2_0x216d20; // 0x2171e0 - g_ps2RecompiledFunctionTable[285815] = bhEne_SetBlood2_0x216d20; // 0x2171e4 - g_ps2RecompiledFunctionTable[285816] = bhEne_SetBlood2_0x216d20; // 0x2171e8 - g_ps2RecompiledFunctionTable[285817] = bhEne_SetBlood2_0x216d20; // 0x2171ec - g_ps2RecompiledFunctionTable[285818] = bhEne_SetBlood2_0x216d20; // 0x2171f0 - g_ps2RecompiledFunctionTable[285819] = bhEne_SetBlood2_0x216d20; // 0x2171f4 - g_ps2RecompiledFunctionTable[285820] = bhEne_SetBlood2_0x216d20; // 0x2171f8 - g_ps2RecompiledFunctionTable[285821] = bhEne_SetBlood2_0x216d20; // 0x2171fc - g_ps2RecompiledFunctionTable[285822] = bhEne_SetBlood2_0x216d20; // 0x217200 - g_ps2RecompiledFunctionTable[285823] = bhEne_SetBlood2_0x216d20; // 0x217204 - g_ps2RecompiledFunctionTable[285824] = bhEne_SetBlood2_0x216d20; // 0x217208 - g_ps2RecompiledFunctionTable[285825] = bhEne_SetBlood2_0x216d20; // 0x21720c - g_ps2RecompiledFunctionTable[285826] = bhEne_SetBlood2_0x216d20; // 0x217210 - g_ps2RecompiledFunctionTable[285827] = bhEne_SetBlood2_0x216d20; // 0x217214 - g_ps2RecompiledFunctionTable[285828] = bhEne_SetBlood2_0x216d20; // 0x217218 - g_ps2RecompiledFunctionTable[285829] = bhEne_SetBlood2_0x216d20; // 0x21721c - g_ps2RecompiledFunctionTable[285830] = bhEne_SetBlood2_0x216d20; // 0x217220 - g_ps2RecompiledFunctionTable[285831] = bhEne_SetBlood2_0x216d20; // 0x217224 - g_ps2RecompiledFunctionTable[285832] = bhEne_SetBlood2_0x216d20; // 0x217228 - g_ps2RecompiledFunctionTable[285833] = bhEne_SetBlood2_0x216d20; // 0x21722c - g_ps2RecompiledFunctionTable[285834] = bhEne_SetBlood2_0x216d20; // 0x217230 - g_ps2RecompiledFunctionTable[285835] = bhEne_SetBlood2_0x216d20; // 0x217234 - g_ps2RecompiledFunctionTable[285836] = bhEne_SetBlood2_0x216d20; // 0x217238 - g_ps2RecompiledFunctionTable[285837] = bhEne_SetBlood2_0x216d20; // 0x21723c - g_ps2RecompiledFunctionTable[285838] = bhEne_SetBlood2_0x216d20; // 0x217240 - g_ps2RecompiledFunctionTable[285839] = bhEne_SetBlood2_0x216d20; // 0x217244 - g_ps2RecompiledFunctionTable[285840] = bhEne_SetBlood2_0x216d20; // 0x217248 - g_ps2RecompiledFunctionTable[285841] = bhEne_SetBlood2_0x216d20; // 0x21724c - g_ps2RecompiledFunctionTable[285842] = bhEne_SetBlood2_0x216d20; // 0x217250 - g_ps2RecompiledFunctionTable[285843] = bhEne_SetBlood2_0x216d20; // 0x217254 - g_ps2RecompiledFunctionTable[285844] = bhEne_SetBlood2_0x216d20; // 0x217258 - g_ps2RecompiledFunctionTable[285845] = bhEne_SetBlood2_0x216d20; // 0x21725c - g_ps2RecompiledFunctionTable[285846] = bhEne_SetBlood2_0x216d20; // 0x217260 - g_ps2RecompiledFunctionTable[285847] = bhEne_SetBlood2_0x216d20; // 0x217264 - g_ps2RecompiledFunctionTable[285848] = bhEne_SetBlood2_0x216d20; // 0x217268 - g_ps2RecompiledFunctionTable[285849] = bhEne_SetBlood2_0x216d20; // 0x21726c - g_ps2RecompiledFunctionTable[285850] = bhEne_SetBlood2_0x216d20; // 0x217270 - g_ps2RecompiledFunctionTable[285851] = bhEne_SetBlood2_0x216d20; // 0x217274 - g_ps2RecompiledFunctionTable[285852] = bhEne_SetBlood2_0x216d20; // 0x217278 - g_ps2RecompiledFunctionTable[285853] = bhEne_SetBlood2_0x216d20; // 0x21727c - g_ps2RecompiledFunctionTable[285854] = bhEne_SetBlood2_0x216d20; // 0x217280 - g_ps2RecompiledFunctionTable[285855] = bhEne_SetBlood2_0x216d20; // 0x217284 - g_ps2RecompiledFunctionTable[285856] = bhEne_SetBlood2_0x216d20; // 0x217288 - g_ps2RecompiledFunctionTable[285857] = bhEne_SetBlood2_0x216d20; // 0x21728c - g_ps2RecompiledFunctionTable[285858] = bhEne_SetBlood2_0x216d20; // 0x217290 - g_ps2RecompiledFunctionTable[285859] = bhEne_SetBlood2_0x216d20; // 0x217294 - g_ps2RecompiledFunctionTable[285860] = bhEne_SetBlood2_0x216d20; // 0x217298 - g_ps2RecompiledFunctionTable[285861] = bhEne_SetBlood2_0x216d20; // 0x21729c - g_ps2RecompiledFunctionTable[285862] = bhEne_SetBlood2_0x216d20; // 0x2172a0 - g_ps2RecompiledFunctionTable[285863] = bhEne_SetBlood2_0x216d20; // 0x2172a4 - g_ps2RecompiledFunctionTable[285864] = bhEne_SetBlood2_0x216d20; // 0x2172a8 - g_ps2RecompiledFunctionTable[285865] = bhEne_SetBlood2_0x216d20; // 0x2172ac - g_ps2RecompiledFunctionTable[285866] = bhEne_SetBlood2_0x216d20; // 0x2172b0 - g_ps2RecompiledFunctionTable[285867] = bhEne_SetBlood2_0x216d20; // 0x2172b4 - g_ps2RecompiledFunctionTable[285868] = bhEne_SetBlood2_0x216d20; // 0x2172b8 - g_ps2RecompiledFunctionTable[285869] = bhEne_SetBlood2_0x216d20; // 0x2172bc - g_ps2RecompiledFunctionTable[285870] = bhEne_SetBlood2_0x216d20; // 0x2172c0 - g_ps2RecompiledFunctionTable[285871] = bhEne_SetBlood2_0x216d20; // 0x2172c4 - g_ps2RecompiledFunctionTable[285872] = bhEne_SetBlood2_0x216d20; // 0x2172c8 - g_ps2RecompiledFunctionTable[285873] = bhEne_SetBlood2_0x216d20; // 0x2172cc - g_ps2RecompiledFunctionTable[285874] = bhEne_SetBlood2_0x216d20; // 0x2172d0 - g_ps2RecompiledFunctionTable[285875] = bhEne_SetBlood2_0x216d20; // 0x2172d4 - g_ps2RecompiledFunctionTable[285876] = bhEne_SetBlood2_0x216d20; // 0x2172d8 - g_ps2RecompiledFunctionTable[285877] = bhEne_SetBlood2_0x216d20; // 0x2172dc - g_ps2RecompiledFunctionTable[285878] = bhEne_SetBlood2_0x216d20; // 0x2172e0 - g_ps2RecompiledFunctionTable[285879] = bhEne_SetBlood2_0x216d20; // 0x2172e4 - g_ps2RecompiledFunctionTable[285880] = bhEne_SetBlood2_0x216d20; // 0x2172e8 - g_ps2RecompiledFunctionTable[285881] = bhEne_SetBlood2_0x216d20; // 0x2172ec - g_ps2RecompiledFunctionTable[285882] = bhEne_SetBlood2_0x216d20; // 0x2172f0 - g_ps2RecompiledFunctionTable[285883] = bhEne_SetBlood2_0x216d20; // 0x2172f4 - g_ps2RecompiledFunctionTable[285884] = bhEne_SetBlood2_0x216d20; // 0x2172f8 - g_ps2RecompiledFunctionTable[285885] = bhEne_SetBlood2_0x216d20; // 0x2172fc - g_ps2RecompiledFunctionTable[285886] = bhEne_SetBlood2_0x216d20; // 0x217300 - g_ps2RecompiledFunctionTable[285887] = bhEne_SetBlood2_0x216d20; // 0x217304 - g_ps2RecompiledFunctionTable[285888] = bhEne_SetBlood2_0x216d20; // 0x217308 - g_ps2RecompiledFunctionTable[285889] = bhEne_SetBlood2_0x216d20; // 0x21730c - g_ps2RecompiledFunctionTable[285890] = bhEne_SetBlood2_0x216d20; // 0x217310 - g_ps2RecompiledFunctionTable[285891] = bhEne_SetBlood2_0x216d20; // 0x217314 - g_ps2RecompiledFunctionTable[285892] = bhEne_SetBlood2_0x216d20; // 0x217318 - g_ps2RecompiledFunctionTable[285893] = bhEne_SetBlood2_0x216d20; // 0x21731c - g_ps2RecompiledFunctionTable[285894] = bhEne_SetBlood2_0x216d20; // 0x217320 - g_ps2RecompiledFunctionTable[285895] = bhEne_SetBlood2_0x216d20; // 0x217324 - g_ps2RecompiledFunctionTable[285896] = bhEne_SetBlood2_0x216d20; // 0x217328 - g_ps2RecompiledFunctionTable[285897] = bhEne_SetBlood2_0x216d20; // 0x21732c - g_ps2RecompiledFunctionTable[285898] = bhEne_SetBlood2_0x216d20; // 0x217330 - g_ps2RecompiledFunctionTable[285899] = bhEne_SetBlood2_0x216d20; // 0x217334 - g_ps2RecompiledFunctionTable[285900] = bhEne_SetBlood2_0x216d20; // 0x217338 - g_ps2RecompiledFunctionTable[285901] = bhEne_SetBlood2_0x216d20; // 0x21733c - g_ps2RecompiledFunctionTable[285902] = bhEne_SetBlood2_0x216d20; // 0x217340 - g_ps2RecompiledFunctionTable[285903] = bhEne_SetBlood2_0x216d20; // 0x217344 - g_ps2RecompiledFunctionTable[285904] = bhEne_SetBlood2_0x216d20; // 0x217348 - g_ps2RecompiledFunctionTable[285905] = bhEne_SetBlood2_0x216d20; // 0x21734c - g_ps2RecompiledFunctionTable[285906] = bhEne_SetBlood2_0x216d20; // 0x217350 - g_ps2RecompiledFunctionTable[285907] = bhEne_SetBlood2_0x216d20; // 0x217354 - g_ps2RecompiledFunctionTable[285908] = bhEne_SetBlood2_0x216d20; // 0x217358 - g_ps2RecompiledFunctionTable[285909] = bhEne_SetBlood2_0x216d20; // 0x21735c - g_ps2RecompiledFunctionTable[285910] = bhEne_SetBlood2_0x216d20; // 0x217360 - g_ps2RecompiledFunctionTable[285911] = bhEne_SetBlood2_0x216d20; // 0x217364 - g_ps2RecompiledFunctionTable[285912] = bhEne_SetBlood2_0x216d20; // 0x217368 - g_ps2RecompiledFunctionTable[285913] = bhEne_SetBlood2_0x216d20; // 0x21736c - g_ps2RecompiledFunctionTable[285914] = bhEne_SetBlood2_0x216d20; // 0x217370 - g_ps2RecompiledFunctionTable[285915] = bhEne_SetBlood2_0x216d20; // 0x217374 - g_ps2RecompiledFunctionTable[285916] = bhEne_SetBlood2_0x216d20; // 0x217378 - g_ps2RecompiledFunctionTable[285917] = bhEne_SetBlood2_0x216d20; // 0x21737c - g_ps2RecompiledFunctionTable[285918] = bhEne_SetBlood2_0x216d20; // 0x217380 - g_ps2RecompiledFunctionTable[285919] = bhEne_SetBlood2_0x216d20; // 0x217384 - g_ps2RecompiledFunctionTable[285920] = bhEne_SetBlood2_0x216d20; // 0x217388 - g_ps2RecompiledFunctionTable[285921] = bhEne_SetBlood2_0x216d20; // 0x21738c - g_ps2RecompiledFunctionTable[285922] = bhEne_SetBlood2_0x216d20; // 0x217390 - g_ps2RecompiledFunctionTable[285923] = bhEne_SetBlood2_0x216d20; // 0x217394 - g_ps2RecompiledFunctionTable[285924] = bhEne_SetBlood2_0x216d20; // 0x217398 - g_ps2RecompiledFunctionTable[285925] = bhEne_SetBlood2_0x216d20; // 0x21739c - g_ps2RecompiledFunctionTable[285926] = bhEne_SetBlood2_0x216d20; // 0x2173a0 - g_ps2RecompiledFunctionTable[285927] = bhEne_SetBlood2_0x216d20; // 0x2173a4 - g_ps2RecompiledFunctionTable[285928] = bhEne_SetBlood2_0x216d20; // 0x2173a8 - g_ps2RecompiledFunctionTable[285929] = bhEne_SetBlood2_0x216d20; // 0x2173ac - g_ps2RecompiledFunctionTable[285930] = bhEne_SetBlood2_0x216d20; // 0x2173b0 - g_ps2RecompiledFunctionTable[285931] = bhEne_SetBlood2_0x216d20; // 0x2173b4 - g_ps2RecompiledFunctionTable[285934] = bhEne_SetBlood3_0x2173c0; // 0x2173c0 - g_ps2RecompiledFunctionTable[286005] = bhEne_SetBlood3_0x2173c0; // 0x2174dc - g_ps2RecompiledFunctionTable[286034] = bhEne_SetBlood3_0x2173c0; // 0x217550 - g_ps2RecompiledFunctionTable[286090] = bhEne_SetBlood4_0x217630; // 0x217630 - g_ps2RecompiledFunctionTable[286120] = bhEne_SetBlood4_0x217630; // 0x2176a8 - g_ps2RecompiledFunctionTable[286138] = bhEne_SetBlood4_0x217630; // 0x2176f0 - g_ps2RecompiledFunctionTable[286147] = bhEne_SetBlood4_0x217630; // 0x217714 - g_ps2RecompiledFunctionTable[286158] = bhEne_SetBlood4_0x217630; // 0x217740 - g_ps2RecompiledFunctionTable[286167] = bhEne_SetBlood4_0x217630; // 0x217764 - g_ps2RecompiledFunctionTable[286170] = bhEne_SetBlood4_0x217630; // 0x217770 - g_ps2RecompiledFunctionTable[286175] = bhEne_SetBlood4_0x217630; // 0x217784 - g_ps2RecompiledFunctionTable[286178] = bhEne_SetBlood4_0x217630; // 0x217790 - g_ps2RecompiledFunctionTable[286181] = bhEne_SetBlood4_0x217630; // 0x21779c - g_ps2RecompiledFunctionTable[286205] = bhEne_SetBlood4_0x217630; // 0x2177fc - g_ps2RecompiledFunctionTable[286226] = bhEne_SetNikuhenEffect_0x217850; // 0x217850 - g_ps2RecompiledFunctionTable[286270] = bhEne_SetNikuhenEffect_0x217850; // 0x217900 - g_ps2RecompiledFunctionTable[286307] = bhEne_SetNikuhenEffect_0x217850; // 0x217994 - g_ps2RecompiledFunctionTable[286354] = bhEne_SetNikuhenEffect2_0x217a50; // 0x217a50 - g_ps2RecompiledFunctionTable[286371] = bhEne_SetNikuhenEffect2_0x217a50; // 0x217a94 - g_ps2RecompiledFunctionTable[286373] = bhEne_SetNikuhenEffect2_0x217a50; // 0x217a9c - g_ps2RecompiledFunctionTable[286375] = bhEne_SetNikuhenEffect2_0x217a50; // 0x217aa4 - g_ps2RecompiledFunctionTable[286382] = bhEne_SetNikuhenEffect2_0x217a50; // 0x217ac0 - g_ps2RecompiledFunctionTable[286390] = bhEne_SetNikuhenEffect2_0x217a50; // 0x217ae0 - g_ps2RecompiledFunctionTable[286401] = bhEne_SetNikuhenEffect2_0x217a50; // 0x217b0c - g_ps2RecompiledFunctionTable[286405] = bhEne_SetNikuhenEffect2_0x217a50; // 0x217b1c - g_ps2RecompiledFunctionTable[286411] = bhEne_SetNikuhenEffect2_0x217a50; // 0x217b34 - g_ps2RecompiledFunctionTable[286426] = bhEne_SetDFireEffect_0x217b70; // 0x217b70 - g_ps2RecompiledFunctionTable[286448] = bhEne_SetDFireEffect_0x217b70; // 0x217bc8 - g_ps2RecompiledFunctionTable[286464] = bhEne_SetDFireEffect_0x217b70; // 0x217c08 - g_ps2RecompiledFunctionTable[286470] = bhEne_SetDFireEffect_0x217b70; // 0x217c20 - g_ps2RecompiledFunctionTable[286488] = bhEne_SetDFireEffect_0x217b70; // 0x217c68 - g_ps2RecompiledFunctionTable[286504] = bhEne_SetDFireEffect_0x217b70; // 0x217ca8 - g_ps2RecompiledFunctionTable[286514] = bhEne_SetDFireEffect_0x217b70; // 0x217cd0 - g_ps2RecompiledFunctionTable[286518] = bhEne_SetDFireEffect_0x217b70; // 0x217ce0 - g_ps2RecompiledFunctionTable[286523] = bhEne_SetDFireEffect_0x217b70; // 0x217cf4 - g_ps2RecompiledFunctionTable[286542] = bhEne_SetDFireEffect2_0x217d40; // 0x217d40 - g_ps2RecompiledFunctionTable[286570] = bhEne_SetDFireEffect2_0x217d40; // 0x217db0 - g_ps2RecompiledFunctionTable[286617] = bhEne_SetDFireEffect2_0x217d40; // 0x217e6c - g_ps2RecompiledFunctionTable[286624] = bhEne_SetDFireEffect2_0x217d40; // 0x217e88 - g_ps2RecompiledFunctionTable[286652] = bhEne_SetDFireEffect2_0x217d40; // 0x217ef8 - g_ps2RecompiledFunctionTable[286668] = bhEne_SetDFireEffect2_0x217d40; // 0x217f38 - g_ps2RecompiledFunctionTable[286691] = bhEne_SetDFireEffect2_0x217d40; // 0x217f94 - g_ps2RecompiledFunctionTable[286715] = bhEne_SetDFireEffect2_0x217d40; // 0x217ff4 - g_ps2RecompiledFunctionTable[286752] = bhEne_SetDFireEffect2_0x217d40; // 0x218088 - g_ps2RecompiledFunctionTable[286782] = bhEne_SetSanEffect_0x218100; // 0x218100 - g_ps2RecompiledFunctionTable[286802] = bhEne_SetSanEffect_0x218100; // 0x218150 - g_ps2RecompiledFunctionTable[286818] = bhEne_SetSanEffect_0x218100; // 0x218190 - g_ps2RecompiledFunctionTable[286824] = bhEne_SetSanEffect_0x218100; // 0x2181a8 - g_ps2RecompiledFunctionTable[286842] = bhEne_SetSanEffect_0x218100; // 0x2181f0 - g_ps2RecompiledFunctionTable[286858] = bhEne_SetSanEffect_0x218100; // 0x218230 - g_ps2RecompiledFunctionTable[286862] = bhEne_SetSanEffect_0x218100; // 0x218240 - g_ps2RecompiledFunctionTable[286864] = bhEne_SetSanEffect_0x218100; // 0x218248 - g_ps2RecompiledFunctionTable[286868] = bhEne_SetSanEffect_0x218100; // 0x218258 - g_ps2RecompiledFunctionTable[286886] = bhEne_SetSanEffect2_0x2182a0; // 0x2182a0 - g_ps2RecompiledFunctionTable[286928] = bhEne_SetSanEffect2_0x2182a0; // 0x218348 - g_ps2RecompiledFunctionTable[286949] = bhEne_SetSanEffect2_0x2182a0; // 0x21839c - g_ps2RecompiledFunctionTable[286977] = bhEne_SetSanEffect2_0x2182a0; // 0x21840c - g_ps2RecompiledFunctionTable[286993] = bhEne_SetSanEffect2_0x2182a0; // 0x21844c - g_ps2RecompiledFunctionTable[287012] = bhEne_SetSanEffect2_0x2182a0; // 0x218498 - g_ps2RecompiledFunctionTable[287029] = bhEne_SetSanEffect2_0x2182a0; // 0x2184dc - g_ps2RecompiledFunctionTable[287038] = bhEne_QuickSort_0x218500; // 0x218500 - g_ps2RecompiledFunctionTable[287054] = bhEne_QuickSort_0x218500; // 0x218540 - g_ps2RecompiledFunctionTable[287057] = bhEne_QuickSort_0x218500; // 0x21854c - g_ps2RecompiledFunctionTable[287068] = bhEne_QuickSort_0x218500; // 0x218578 - g_ps2RecompiledFunctionTable[287099] = bhEne_QuickSort_0x218500; // 0x2185f4 - g_ps2RecompiledFunctionTable[287106] = bhEne_QuickSort_0x218500; // 0x218610 - g_ps2RecompiledFunctionTable[287114] = bhEne_ChgMtn_0x218630; // 0x218630 - g_ps2RecompiledFunctionTable[287142] = bhEne_CollisionCheckWall_0x2186a0; // 0x2186a0 - g_ps2RecompiledFunctionTable[287174] = bhEne_CollisionCheckWall_0x2186a0; // 0x218720 - g_ps2RecompiledFunctionTable[287176] = bhEne_CollisionCheckWall_0x2186a0; // 0x218728 - g_ps2RecompiledFunctionTable[287222] = bhEne_CollisionCheckWall2_0x2187e0; // 0x2187e0 - g_ps2RecompiledFunctionTable[287254] = bhEne_CollisionCheckWall2_0x2187e0; // 0x218860 - g_ps2RecompiledFunctionTable[287260] = bhEne_CollisionCheckWall2_0x2187e0; // 0x218878 - g_ps2RecompiledFunctionTable[287267] = bhEne_CollisionCheckWall2_0x2187e0; // 0x218894 - g_ps2RecompiledFunctionTable[287298] = bhEne_CheckDirWall_0x218910; // 0x218910 - g_ps2RecompiledFunctionTable[287302] = bhEne_CheckDirWall2_0x218920; // 0x218920 - g_ps2RecompiledFunctionTable[287317] = bhEne_CheckDirWall2_0x218920; // 0x21895c - g_ps2RecompiledFunctionTable[287322] = bhEne_CheckDirWall3_0x218970; // 0x218970 - g_ps2RecompiledFunctionTable[287336] = bhEne_CheckDirWall3_0x218970; // 0x2189a8 - g_ps2RecompiledFunctionTable[287342] = bhEne_CheckDirWall3_0x218970; // 0x2189c0 - g_ps2RecompiledFunctionTable[287353] = bhEne_CheckDirWall3_0x218970; // 0x2189ec - g_ps2RecompiledFunctionTable[287362] = bhEne_CheckSideWall_0x218a10; // 0x218a10 - g_ps2RecompiledFunctionTable[287366] = bhEne_CheckSideWall2_0x218a20; // 0x218a20 - g_ps2RecompiledFunctionTable[287381] = bhEne_CheckSideWall2_0x218a20; // 0x218a5c - g_ps2RecompiledFunctionTable[287386] = bhEne_CheckSideWall3_0x218a70; // 0x218a70 - g_ps2RecompiledFunctionTable[287402] = bhEne_CheckSideWall3_0x218a70; // 0x218ab0 - g_ps2RecompiledFunctionTable[287410] = bhEne_CheckSideWall3_0x218a70; // 0x218ad0 - g_ps2RecompiledFunctionTable[287430] = bhEne_SetVibration_0x218b20; // 0x218b20 - g_ps2RecompiledFunctionTable[287444] = bhEne_SetVibration_0x218b20; // 0x218b58 - g_ps2RecompiledFunctionTable[287449] = bhEne_SetVibration_0x218b20; // 0x218b6c - g_ps2RecompiledFunctionTable[287454] = bhEne_SetVibration_0x218b20; // 0x218b80 - g_ps2RecompiledFunctionTable[287458] = bhEne_PlayerSePlay_0x218b90; // 0x218b90 - g_ps2RecompiledFunctionTable[287467] = bhEne_PlayerSePlay_0x218b90; // 0x218bb4 - g_ps2RecompiledFunctionTable[287470] = bhEne_HitCheckParts_0x218bc0; // 0x218bc0 - g_ps2RecompiledFunctionTable[287488] = bhEne_HitCheckParts_0x218bc0; // 0x218c08 - g_ps2RecompiledFunctionTable[287504] = bhEne_HitCheckParts_0x218bc0; // 0x218c48 - g_ps2RecompiledFunctionTable[287554] = bhEne_SetMinceEffect_0x218d10; // 0x218d10 - g_ps2RecompiledFunctionTable[287598] = bhEne_SetMinceEffect_0x218d10; // 0x218dc0 - g_ps2RecompiledFunctionTable[287650] = bhEne_SetMinceEffect_0x218d10; // 0x218e90 - g_ps2RecompiledFunctionTable[287654] = bhEne_SetMinceEffect_0x218d10; // 0x218ea0 - g_ps2RecompiledFunctionTable[287656] = bhEne_SetMinceEffect_0x218d10; // 0x218ea8 - g_ps2RecompiledFunctionTable[287672] = bhEne_SetMinceEffect_0x218d10; // 0x218ee8 - g_ps2RecompiledFunctionTable[287687] = bhEne_SetMinceEffect_0x218d10; // 0x218f24 - g_ps2RecompiledFunctionTable[287734] = bhEne_SetMinceEffect2_0x218fe0; // 0x218fe0 - g_ps2RecompiledFunctionTable[287813] = bhEne_SetMinceEffect2_0x218fe0; // 0x21911c - g_ps2RecompiledFunctionTable[287817] = bhEne_SetMinceEffect2_0x218fe0; // 0x21912c - g_ps2RecompiledFunctionTable[287819] = bhEne_SetMinceEffect2_0x218fe0; // 0x219134 - g_ps2RecompiledFunctionTable[287835] = bhEne_SetMinceEffect2_0x218fe0; // 0x219174 - g_ps2RecompiledFunctionTable[287850] = bhEne_SetMinceEffect2_0x218fe0; // 0x2191b0 - g_ps2RecompiledFunctionTable[287898] = bhEne_SetBloodEffect_0x219270; // 0x219270 - g_ps2RecompiledFunctionTable[287902] = bhEne_SetBloodEffect2_0x219280; // 0x219280 - g_ps2RecompiledFunctionTable[287952] = bhEne_SetBloodEffect2_0x219280; // 0x219348 - g_ps2RecompiledFunctionTable[288029] = bhEne_SetBloodEffect2_0x219280; // 0x21947c - g_ps2RecompiledFunctionTable[288038] = bhEne_SetBloodEffect4_0x2194a0; // 0x2194a0 - g_ps2RecompiledFunctionTable[288061] = bhEne_SetBloodEffect4_0x2194a0; // 0x2194fc - g_ps2RecompiledFunctionTable[288132] = bhEne_SetBloodEffect4_0x2194a0; // 0x219618 - g_ps2RecompiledFunctionTable[288138] = bhEne_SetBloodEffect5_0x219630; // 0x219630 - g_ps2RecompiledFunctionTable[288189] = bhEne_SetBloodEffect5_0x219630; // 0x2196fc - g_ps2RecompiledFunctionTable[288191] = bhEne_SetBloodEffect5_0x219630; // 0x219704 - g_ps2RecompiledFunctionTable[288195] = bhEne_SetBloodEffect5_0x219630; // 0x219714 - g_ps2RecompiledFunctionTable[288226] = bhEne_SetBloodEffect5_0x219630; // 0x219790 - g_ps2RecompiledFunctionTable[288300] = bhEne_SetBloodEffect5_0x219630; // 0x2198b8 - g_ps2RecompiledFunctionTable[288306] = bhEne_SetBloodEffectBurst_0x2198d0; // 0x2198d0 - g_ps2RecompiledFunctionTable[288338] = bhEne_SetBloodEffectBurst_0x2198d0; // 0x219950 - g_ps2RecompiledFunctionTable[288344] = bhEne_SetBloodEffectBurst_0x2198d0; // 0x219968 - g_ps2RecompiledFunctionTable[288346] = bhEne_SetBloodEffectBurst_0x2198d0; // 0x219970 - g_ps2RecompiledFunctionTable[288350] = bhEne_SetBloodEffectBurst_0x2198d0; // 0x219980 - g_ps2RecompiledFunctionTable[288424] = bhEne_SetBloodEffectBurst_0x2198d0; // 0x219aa8 - g_ps2RecompiledFunctionTable[288454] = bhEne_SetBloodstain_0x219b20; // 0x219b20 - g_ps2RecompiledFunctionTable[288492] = bhEne_SetBloodstain_0x219b20; // 0x219bb8 - g_ps2RecompiledFunctionTable[288496] = bhEne_SetBloodstain_0x219b20; // 0x219bc8 - g_ps2RecompiledFunctionTable[288579] = bhEne_SetBloodstain_0x219b20; // 0x219d14 - g_ps2RecompiledFunctionTable[288582] = bhEne_SetBloodstain_0x219b20; // 0x219d20 - g_ps2RecompiledFunctionTable[288592] = bhEne_SetBloodstain_0x219b20; // 0x219d48 - g_ps2RecompiledFunctionTable[288606] = bhEne_SetBloodstain_0x219b20; // 0x219d80 - g_ps2RecompiledFunctionTable[288615] = bhEne_SetBloodstain_0x219b20; // 0x219da4 - g_ps2RecompiledFunctionTable[288624] = bhEne_SetBloodstain_0x219b20; // 0x219dc8 - g_ps2RecompiledFunctionTable[288633] = bhEne_SetBloodstain_0x219b20; // 0x219dec - g_ps2RecompiledFunctionTable[288642] = bhEne_SetFireEffect_0x219e10; // 0x219e10 - g_ps2RecompiledFunctionTable[288722] = bhEne_SetFireEffect_0x219e10; // 0x219f50 - g_ps2RecompiledFunctionTable[288738] = bhEne_BloodPool_0x219f90; // 0x219f90 - g_ps2RecompiledFunctionTable[288746] = bhEne_SetAcidEffect_0x219fb0; // 0x219fb0 - g_ps2RecompiledFunctionTable[288827] = bhEne_SetAcidEffect_0x219fb0; // 0x21a0f4 - g_ps2RecompiledFunctionTable[288830] = bhEne_DirTarget_0x21a100; // 0x21a100 - g_ps2RecompiledFunctionTable[288841] = bhEne_DirTarget_0x21a100; // 0x21a12c - g_ps2RecompiledFunctionTable[288847] = bhEne_DirTarget_0x21a100; // 0x21a144 - g_ps2RecompiledFunctionTable[288862] = bhEne_CheckDirTarget_0x21a180; // 0x21a180 - g_ps2RecompiledFunctionTable[288873] = bhEne_CheckDirTarget_0x21a180; // 0x21a1ac - g_ps2RecompiledFunctionTable[288894] = bhEne_GetPartsPos_0x21a200; // 0x21a200 - g_ps2RecompiledFunctionTable[288905] = bhEne_GetPartsPos_0x21a200; // 0x21a22c - g_ps2RecompiledFunctionTable[288907] = bhEne_GetPartsPos_0x21a200; // 0x21a234 - g_ps2RecompiledFunctionTable[288909] = bhEne_GetPartsPos_0x21a200; // 0x21a23c - g_ps2RecompiledFunctionTable[288912] = bhEne_GetPartsPos_0x21a200; // 0x21a248 - g_ps2RecompiledFunctionTable[288915] = bhEne_GetPartsPos_0x21a200; // 0x21a254 - g_ps2RecompiledFunctionTable[288924] = bhEne_GetPartsPos_0x21a200; // 0x21a278 - g_ps2RecompiledFunctionTable[288927] = bhEne_GetPartsPos_0x21a200; // 0x21a284 - g_ps2RecompiledFunctionTable[288935] = bhEne_GetPartsPos_0x21a200; // 0x21a2a4 - g_ps2RecompiledFunctionTable[288937] = bhEne_GetPartsPos_0x21a200; // 0x21a2ac - g_ps2RecompiledFunctionTable[288946] = bhEne_DirCheck_0x21a2d0; // 0x21a2d0 - g_ps2RecompiledFunctionTable[288954] = bhEne_DirCheck_0x21a2d0; // 0x21a2f0 - g_ps2RecompiledFunctionTable[288957] = bhEne_DirCheck_0x21a2d0; // 0x21a2fc - g_ps2RecompiledFunctionTable[288961] = bhEne_DirCheck_0x21a2d0; // 0x21a30c - g_ps2RecompiledFunctionTable[288974] = bhEne_DGDirCheck_0x21a340; // 0x21a340 - g_ps2RecompiledFunctionTable[288978] = bhEne_CallPlayerVoice_0x21a350; // 0x21a350 - g_ps2RecompiledFunctionTable[288982] = bhEne_CheckEnemiesBall_0x21a360; // 0x21a360 - g_ps2RecompiledFunctionTable[289010] = bhEne_CheckEnemiesBall_0x21a360; // 0x21a3d0 - g_ps2RecompiledFunctionTable[289043] = bhEne_CheckEnemiesBall_0x21a360; // 0x21a454 - g_ps2RecompiledFunctionTable[289106] = bhEne_SetWeponAtr_0x21a550; // 0x21a550 - g_ps2RecompiledFunctionTable[289138] = bhEne_AttackHitCheck_0x21a5d0; // 0x21a5d0 - g_ps2RecompiledFunctionTable[289162] = bhEne_AttackHitCheck_0x21a5d0; // 0x21a630 - g_ps2RecompiledFunctionTable[289168] = bhEne_AttackHitCheck_0x21a5d0; // 0x21a648 - g_ps2RecompiledFunctionTable[289192] = bhEne_AttackHitCheck_0x21a5d0; // 0x21a6a8 - g_ps2RecompiledFunctionTable[289242] = bhEne_AddNullTrans_0x21a770; // 0x21a770 - g_ps2RecompiledFunctionTable[289250] = bhEne_AddNullTrans_0x21a770; // 0x21a790 - g_ps2RecompiledFunctionTable[289253] = bhEne_AddNullTrans_0x21a770; // 0x21a79c - g_ps2RecompiledFunctionTable[289262] = bhEne_AddNullTrans_0x21a770; // 0x21a7c0 - g_ps2RecompiledFunctionTable[289278] = bhEne_AddNullTransDir_0x21a800; // 0x21a800 - g_ps2RecompiledFunctionTable[289288] = bhEne_AddNullTransDir_0x21a800; // 0x21a828 - g_ps2RecompiledFunctionTable[289291] = bhEne_AddNullTransDir_0x21a800; // 0x21a834 - g_ps2RecompiledFunctionTable[289300] = bhEne_AddNullTransDir_0x21a800; // 0x21a858 - g_ps2RecompiledFunctionTable[289314] = bhEne_GetShapeCnt_0x21a890; // 0x21a890 - g_ps2RecompiledFunctionTable[289342] = bhEne_CalcDamage_0x21a900; // 0x21a900 - g_ps2RecompiledFunctionTable[289361] = bhEne_CalcDamage_0x21a900; // 0x21a94c - g_ps2RecompiledFunctionTable[289465] = bhEne_CalcDamage_0x21a900; // 0x21aaec - g_ps2RecompiledFunctionTable[289478] = bhEne_InitDamage_0x21ab20; // 0x21ab20 - g_ps2RecompiledFunctionTable[289484] = bhEne_InitDamage_0x21ab20; // 0x21ab38 - g_ps2RecompiledFunctionTable[289510] = bhEne_CallSE_0x21aba0; // 0x21aba0 - g_ps2RecompiledFunctionTable[289523] = bhEne_CallSE_0x21aba0; // 0x21abd4 - g_ps2RecompiledFunctionTable[289526] = bhEne_CallSE_EX_0x21abe0; // 0x21abe0 - g_ps2RecompiledFunctionTable[289539] = bhEne_CallSE_EX_0x21abe0; // 0x21ac14 - g_ps2RecompiledFunctionTable[289542] = bhEne_CallEffectSE_0x21ac20; // 0x21ac20 - g_ps2RecompiledFunctionTable[289546] = bhEne_SetSEPan_0x21ac30; // 0x21ac30 - g_ps2RecompiledFunctionTable[289554] = bhEne_CheckPlayEffectSE_0x21ac50; // 0x21ac50 - g_ps2RecompiledFunctionTable[289558] = bhArcTan2_0x21ac60; // 0x21ac60 - g_ps2RecompiledFunctionTable[289567] = bhArcTan2_0x21ac60; // 0x21ac84 - g_ps2RecompiledFunctionTable[289582] = bhArcTan2_0x21ac60; // 0x21acc0 - g_ps2RecompiledFunctionTable[289587] = bhArcTan2_0x21ac60; // 0x21acd4 - g_ps2RecompiledFunctionTable[289602] = bhEne_CheckEventAtr_0x21ad10; // 0x21ad10 - g_ps2RecompiledFunctionTable[289616] = bhEne_CheckEventAtr_0x21ad10; // 0x21ad48 - g_ps2RecompiledFunctionTable[289686] = bhEne_EraseArrow_0x21ae60; // 0x21ae60 - g_ps2RecompiledFunctionTable[289690] = bhEne_EraseArrow_0x21ae60; // 0x21ae70 - g_ps2RecompiledFunctionTable[289714] = bhEne54_0x21aed0; // 0x21aed0 - g_ps2RecompiledFunctionTable[289719] = bhEne54_0x21aed0; // 0x21aee4 - g_ps2RecompiledFunctionTable[289725] = bhEne54_0x21aed0; // 0x21aefc - g_ps2RecompiledFunctionTable[289739] = bhEne54_0x21aed0; // 0x21af34 - g_ps2RecompiledFunctionTable[289741] = bhEne54_0x21aed0; // 0x21af3c - g_ps2RecompiledFunctionTable[289746] = bhEne54_MainLoop_0x21af50; // 0x21af50 - g_ps2RecompiledFunctionTable[289747] = bhEne54_MainLoop_0x21af50; // 0x21af54 - g_ps2RecompiledFunctionTable[289748] = bhEne54_MainLoop_0x21af50; // 0x21af58 - g_ps2RecompiledFunctionTable[289749] = bhEne54_MainLoop_0x21af50; // 0x21af5c - g_ps2RecompiledFunctionTable[289750] = bhEne54_MainLoop_0x21af50; // 0x21af60 - g_ps2RecompiledFunctionTable[289751] = bhEne54_MainLoop_0x21af50; // 0x21af64 - g_ps2RecompiledFunctionTable[289752] = bhEne54_MainLoop_0x21af50; // 0x21af68 - g_ps2RecompiledFunctionTable[289753] = bhEne54_MainLoop_0x21af50; // 0x21af6c - g_ps2RecompiledFunctionTable[289754] = bhEne54_MainLoop_0x21af50; // 0x21af70 - g_ps2RecompiledFunctionTable[289755] = bhEne54_MainLoop_0x21af50; // 0x21af74 - g_ps2RecompiledFunctionTable[289756] = bhEne54_MainLoop_0x21af50; // 0x21af78 - g_ps2RecompiledFunctionTable[289757] = bhEne54_MainLoop_0x21af50; // 0x21af7c - g_ps2RecompiledFunctionTable[289758] = bhEne54_MainLoop_0x21af50; // 0x21af80 - g_ps2RecompiledFunctionTable[289759] = bhEne54_MainLoop_0x21af50; // 0x21af84 - g_ps2RecompiledFunctionTable[289760] = bhEne54_MainLoop_0x21af50; // 0x21af88 - g_ps2RecompiledFunctionTable[289761] = bhEne54_MainLoop_0x21af50; // 0x21af8c - g_ps2RecompiledFunctionTable[289762] = bhEne54_MainLoop_0x21af50; // 0x21af90 - g_ps2RecompiledFunctionTable[289763] = bhEne54_MainLoop_0x21af50; // 0x21af94 - g_ps2RecompiledFunctionTable[289766] = bhEne54_SetMtn_0x21afa0; // 0x21afa0 - g_ps2RecompiledFunctionTable[289774] = bhEne54_SetMtn_0x21afa0; // 0x21afc0 - g_ps2RecompiledFunctionTable[289790] = bhEne54_CollCheck_0x21b000; // 0x21b000 - g_ps2RecompiledFunctionTable[289806] = bhEne54_CollCheck_0x21b000; // 0x21b040 - g_ps2RecompiledFunctionTable[289824] = bhEne54_CollCheck_0x21b000; // 0x21b088 - g_ps2RecompiledFunctionTable[289829] = bhEne54_CollCheck_0x21b000; // 0x21b09c - g_ps2RecompiledFunctionTable[289854] = bhEne54_CalcEnemy_0x21b100; // 0x21b100 - g_ps2RecompiledFunctionTable[289859] = bhEne54_CalcEnemy_0x21b100; // 0x21b114 - g_ps2RecompiledFunctionTable[289890] = bhEne54_Init_0x21b190; // 0x21b190 - g_ps2RecompiledFunctionTable[289903] = bhEne54_Init_0x21b190; // 0x21b1c4 - g_ps2RecompiledFunctionTable[289938] = bhEne54_Move_0x21b250; // 0x21b250 - g_ps2RecompiledFunctionTable[289939] = bhEne54_Move_0x21b250; // 0x21b254 - g_ps2RecompiledFunctionTable[289940] = bhEne54_Move_0x21b250; // 0x21b258 - g_ps2RecompiledFunctionTable[289941] = bhEne54_Move_0x21b250; // 0x21b25c - g_ps2RecompiledFunctionTable[289942] = bhEne54_Move_0x21b250; // 0x21b260 - g_ps2RecompiledFunctionTable[289943] = bhEne54_Move_0x21b250; // 0x21b264 - g_ps2RecompiledFunctionTable[289944] = bhEne54_Move_0x21b250; // 0x21b268 - g_ps2RecompiledFunctionTable[289945] = bhEne54_Move_0x21b250; // 0x21b26c - g_ps2RecompiledFunctionTable[289946] = bhEne54_Damage_0x21b270; // 0x21b270 - g_ps2RecompiledFunctionTable[289947] = bhEne54_Damage_0x21b270; // 0x21b274 - g_ps2RecompiledFunctionTable[289948] = bhEne54_Damage_0x21b270; // 0x21b278 - g_ps2RecompiledFunctionTable[289949] = bhEne54_Damage_0x21b270; // 0x21b27c - g_ps2RecompiledFunctionTable[289950] = bhEne54_Damage_0x21b270; // 0x21b280 - g_ps2RecompiledFunctionTable[289951] = bhEne54_Damage_0x21b270; // 0x21b284 - g_ps2RecompiledFunctionTable[289952] = bhEne54_Damage_0x21b270; // 0x21b288 - g_ps2RecompiledFunctionTable[289953] = bhEne54_Damage_0x21b270; // 0x21b28c - g_ps2RecompiledFunctionTable[289954] = bhEne54_MVType00_0x21b290; // 0x21b290 - g_ps2RecompiledFunctionTable[289955] = bhEne54_MVType00_0x21b290; // 0x21b294 - g_ps2RecompiledFunctionTable[289956] = bhEne54_MVType00_0x21b290; // 0x21b298 - g_ps2RecompiledFunctionTable[289957] = bhEne54_MVType00_0x21b290; // 0x21b29c - g_ps2RecompiledFunctionTable[289958] = bhEne54_MVType00_0x21b290; // 0x21b2a0 - g_ps2RecompiledFunctionTable[289959] = bhEne54_MVType00_0x21b290; // 0x21b2a4 - g_ps2RecompiledFunctionTable[289960] = bhEne54_MVType00_0x21b290; // 0x21b2a8 - g_ps2RecompiledFunctionTable[289961] = bhEne54_MVType00_0x21b290; // 0x21b2ac - g_ps2RecompiledFunctionTable[289962] = bhEne54_MV00_0x21b2b0; // 0x21b2b0 - g_ps2RecompiledFunctionTable[289977] = bhEne54_MV00_0x21b2b0; // 0x21b2ec - g_ps2RecompiledFunctionTable[289986] = bhEne54_DGType00_0x21b310; // 0x21b310 - g_ps2RecompiledFunctionTable[289987] = bhEne54_DGType00_0x21b310; // 0x21b314 - g_ps2RecompiledFunctionTable[289988] = bhEne54_DGType00_0x21b310; // 0x21b318 - g_ps2RecompiledFunctionTable[289989] = bhEne54_DGType00_0x21b310; // 0x21b31c - g_ps2RecompiledFunctionTable[289990] = bhEne54_DGType00_0x21b310; // 0x21b320 - g_ps2RecompiledFunctionTable[289991] = bhEne54_DGType00_0x21b310; // 0x21b324 - g_ps2RecompiledFunctionTable[289992] = bhEne54_DGType00_0x21b310; // 0x21b328 - g_ps2RecompiledFunctionTable[289993] = bhEne54_DGType00_0x21b310; // 0x21b32c - g_ps2RecompiledFunctionTable[289994] = bhEne54_DG00_0x21b330; // 0x21b330 - g_ps2RecompiledFunctionTable[290019] = bhEne54_DG00_0x21b330; // 0x21b394 - g_ps2RecompiledFunctionTable[290025] = bhEne54_DG00_0x21b330; // 0x21b3ac - g_ps2RecompiledFunctionTable[290050] = bhEne55_0x21b410; // 0x21b410 - g_ps2RecompiledFunctionTable[290055] = bhEne55_0x21b410; // 0x21b424 - g_ps2RecompiledFunctionTable[290061] = bhEne55_0x21b410; // 0x21b43c - g_ps2RecompiledFunctionTable[290075] = bhEne55_0x21b410; // 0x21b474 - g_ps2RecompiledFunctionTable[290077] = bhEne55_0x21b410; // 0x21b47c - g_ps2RecompiledFunctionTable[290082] = bhEne55_MainLoop_0x21b490; // 0x21b490 - g_ps2RecompiledFunctionTable[290083] = bhEne55_MainLoop_0x21b490; // 0x21b494 - g_ps2RecompiledFunctionTable[290084] = bhEne55_MainLoop_0x21b490; // 0x21b498 - g_ps2RecompiledFunctionTable[290085] = bhEne55_MainLoop_0x21b490; // 0x21b49c - g_ps2RecompiledFunctionTable[290086] = bhEne55_MainLoop_0x21b490; // 0x21b4a0 - g_ps2RecompiledFunctionTable[290087] = bhEne55_MainLoop_0x21b490; // 0x21b4a4 - g_ps2RecompiledFunctionTable[290088] = bhEne55_MainLoop_0x21b490; // 0x21b4a8 - g_ps2RecompiledFunctionTable[290089] = bhEne55_MainLoop_0x21b490; // 0x21b4ac - g_ps2RecompiledFunctionTable[290090] = bhEne55_MainLoop_0x21b490; // 0x21b4b0 - g_ps2RecompiledFunctionTable[290091] = bhEne55_MainLoop_0x21b490; // 0x21b4b4 - g_ps2RecompiledFunctionTable[290092] = bhEne55_MainLoop_0x21b490; // 0x21b4b8 - g_ps2RecompiledFunctionTable[290093] = bhEne55_MainLoop_0x21b490; // 0x21b4bc - g_ps2RecompiledFunctionTable[290094] = bhEne55_MainLoop_0x21b490; // 0x21b4c0 - g_ps2RecompiledFunctionTable[290095] = bhEne55_MainLoop_0x21b490; // 0x21b4c4 - g_ps2RecompiledFunctionTable[290096] = bhEne55_MainLoop_0x21b490; // 0x21b4c8 - g_ps2RecompiledFunctionTable[290097] = bhEne55_MainLoop_0x21b490; // 0x21b4cc - g_ps2RecompiledFunctionTable[290098] = bhEne55_MainLoop_0x21b490; // 0x21b4d0 - g_ps2RecompiledFunctionTable[290099] = bhEne55_MainLoop_0x21b490; // 0x21b4d4 - g_ps2RecompiledFunctionTable[290102] = bhEne55_SetMtn_0x21b4e0; // 0x21b4e0 - g_ps2RecompiledFunctionTable[290110] = bhEne55_SetMtn_0x21b4e0; // 0x21b500 - g_ps2RecompiledFunctionTable[290126] = bhEne55_CollCheck_0x21b540; // 0x21b540 - g_ps2RecompiledFunctionTable[290142] = bhEne55_CollCheck_0x21b540; // 0x21b580 - g_ps2RecompiledFunctionTable[290160] = bhEne55_CollCheck_0x21b540; // 0x21b5c8 - g_ps2RecompiledFunctionTable[290165] = bhEne55_CollCheck_0x21b540; // 0x21b5dc - g_ps2RecompiledFunctionTable[290190] = bhEne55_CalcEnemy_0x21b640; // 0x21b640 - g_ps2RecompiledFunctionTable[290195] = bhEne55_CalcEnemy_0x21b640; // 0x21b654 - g_ps2RecompiledFunctionTable[290226] = bhEne55_Init_0x21b6d0; // 0x21b6d0 - g_ps2RecompiledFunctionTable[290239] = bhEne55_Init_0x21b6d0; // 0x21b704 - g_ps2RecompiledFunctionTable[290274] = bhEne55_Move_0x21b790; // 0x21b790 - g_ps2RecompiledFunctionTable[290275] = bhEne55_Move_0x21b790; // 0x21b794 - g_ps2RecompiledFunctionTable[290276] = bhEne55_Move_0x21b790; // 0x21b798 - g_ps2RecompiledFunctionTable[290277] = bhEne55_Move_0x21b790; // 0x21b79c - g_ps2RecompiledFunctionTable[290278] = bhEne55_Move_0x21b790; // 0x21b7a0 - g_ps2RecompiledFunctionTable[290279] = bhEne55_Move_0x21b790; // 0x21b7a4 - g_ps2RecompiledFunctionTable[290280] = bhEne55_Move_0x21b790; // 0x21b7a8 - g_ps2RecompiledFunctionTable[290281] = bhEne55_Move_0x21b790; // 0x21b7ac - g_ps2RecompiledFunctionTable[290282] = bhEne55_Damage_0x21b7b0; // 0x21b7b0 - g_ps2RecompiledFunctionTable[290283] = bhEne55_Damage_0x21b7b0; // 0x21b7b4 - g_ps2RecompiledFunctionTable[290284] = bhEne55_Damage_0x21b7b0; // 0x21b7b8 - g_ps2RecompiledFunctionTable[290285] = bhEne55_Damage_0x21b7b0; // 0x21b7bc - g_ps2RecompiledFunctionTable[290286] = bhEne55_Damage_0x21b7b0; // 0x21b7c0 - g_ps2RecompiledFunctionTable[290287] = bhEne55_Damage_0x21b7b0; // 0x21b7c4 - g_ps2RecompiledFunctionTable[290288] = bhEne55_Damage_0x21b7b0; // 0x21b7c8 - g_ps2RecompiledFunctionTable[290289] = bhEne55_Damage_0x21b7b0; // 0x21b7cc - g_ps2RecompiledFunctionTable[290290] = bhEne55_MVType00_0x21b7d0; // 0x21b7d0 - g_ps2RecompiledFunctionTable[290291] = bhEne55_MVType00_0x21b7d0; // 0x21b7d4 - g_ps2RecompiledFunctionTable[290292] = bhEne55_MVType00_0x21b7d0; // 0x21b7d8 - g_ps2RecompiledFunctionTable[290293] = bhEne55_MVType00_0x21b7d0; // 0x21b7dc - g_ps2RecompiledFunctionTable[290294] = bhEne55_MVType00_0x21b7d0; // 0x21b7e0 - g_ps2RecompiledFunctionTable[290295] = bhEne55_MVType00_0x21b7d0; // 0x21b7e4 - g_ps2RecompiledFunctionTable[290296] = bhEne55_MVType00_0x21b7d0; // 0x21b7e8 - g_ps2RecompiledFunctionTable[290297] = bhEne55_MVType00_0x21b7d0; // 0x21b7ec - g_ps2RecompiledFunctionTable[290298] = bhEne55_MV00_0x21b7f0; // 0x21b7f0 - g_ps2RecompiledFunctionTable[290313] = bhEne55_MV00_0x21b7f0; // 0x21b82c - g_ps2RecompiledFunctionTable[290322] = bhEne55_DGType00_0x21b850; // 0x21b850 - g_ps2RecompiledFunctionTable[290323] = bhEne55_DGType00_0x21b850; // 0x21b854 - g_ps2RecompiledFunctionTable[290324] = bhEne55_DGType00_0x21b850; // 0x21b858 - g_ps2RecompiledFunctionTable[290325] = bhEne55_DGType00_0x21b850; // 0x21b85c - g_ps2RecompiledFunctionTable[290326] = bhEne55_DGType00_0x21b850; // 0x21b860 - g_ps2RecompiledFunctionTable[290327] = bhEne55_DGType00_0x21b850; // 0x21b864 - g_ps2RecompiledFunctionTable[290328] = bhEne55_DGType00_0x21b850; // 0x21b868 - g_ps2RecompiledFunctionTable[290329] = bhEne55_DGType00_0x21b850; // 0x21b86c - g_ps2RecompiledFunctionTable[290330] = bhEne55_DG00_0x21b870; // 0x21b870 - g_ps2RecompiledFunctionTable[290355] = bhEne55_DG00_0x21b870; // 0x21b8d4 - g_ps2RecompiledFunctionTable[290361] = bhEne55_DG00_0x21b870; // 0x21b8ec - g_ps2RecompiledFunctionTable[290386] = bhEne71_0x21b950; // 0x21b950 - g_ps2RecompiledFunctionTable[290387] = bhEne71_0x21b950; // 0x21b954 - g_ps2RecompiledFunctionTable[290388] = bhEne71_0x21b950; // 0x21b958 - g_ps2RecompiledFunctionTable[290389] = bhEne71_0x21b950; // 0x21b95c - g_ps2RecompiledFunctionTable[290390] = bhEne71_0x21b950; // 0x21b960 - g_ps2RecompiledFunctionTable[290391] = bhEne71_0x21b950; // 0x21b964 - g_ps2RecompiledFunctionTable[290392] = bhEne71_0x21b950; // 0x21b968 - g_ps2RecompiledFunctionTable[290393] = bhEne71_0x21b950; // 0x21b96c - g_ps2RecompiledFunctionTable[290394] = bhEne71_0x21b950; // 0x21b970 - g_ps2RecompiledFunctionTable[290395] = bhEne71_0x21b950; // 0x21b974 - g_ps2RecompiledFunctionTable[290396] = bhEne71_0x21b950; // 0x21b978 - g_ps2RecompiledFunctionTable[290397] = bhEne71_0x21b950; // 0x21b97c - g_ps2RecompiledFunctionTable[290398] = bhEne71_0x21b950; // 0x21b980 - g_ps2RecompiledFunctionTable[290399] = bhEne71_0x21b950; // 0x21b984 - g_ps2RecompiledFunctionTable[290400] = bhEne71_0x21b950; // 0x21b988 - g_ps2RecompiledFunctionTable[290401] = bhEne71_0x21b950; // 0x21b98c - g_ps2RecompiledFunctionTable[290402] = bhEne71_0x21b950; // 0x21b990 - g_ps2RecompiledFunctionTable[290403] = bhEne71_0x21b950; // 0x21b994 - g_ps2RecompiledFunctionTable[290404] = bhEne71_0x21b950; // 0x21b998 - g_ps2RecompiledFunctionTable[290405] = bhEne71_0x21b950; // 0x21b99c - g_ps2RecompiledFunctionTable[290406] = bhEne71_0x21b950; // 0x21b9a0 - g_ps2RecompiledFunctionTable[290407] = bhEne71_0x21b950; // 0x21b9a4 - g_ps2RecompiledFunctionTable[290408] = bhEne71_0x21b950; // 0x21b9a8 - g_ps2RecompiledFunctionTable[290409] = bhEne71_0x21b950; // 0x21b9ac - g_ps2RecompiledFunctionTable[290410] = bhEne71_0x21b950; // 0x21b9b0 - g_ps2RecompiledFunctionTable[290411] = bhEne71_0x21b950; // 0x21b9b4 - g_ps2RecompiledFunctionTable[290412] = bhEne71_0x21b950; // 0x21b9b8 - g_ps2RecompiledFunctionTable[290413] = bhEne71_0x21b950; // 0x21b9bc - g_ps2RecompiledFunctionTable[290414] = bhEne71_0x21b950; // 0x21b9c0 - g_ps2RecompiledFunctionTable[290415] = bhEne71_0x21b950; // 0x21b9c4 - g_ps2RecompiledFunctionTable[290416] = bhEne71_0x21b950; // 0x21b9c8 - g_ps2RecompiledFunctionTable[290417] = bhEne71_0x21b950; // 0x21b9cc - g_ps2RecompiledFunctionTable[290418] = bhEne71_0x21b950; // 0x21b9d0 - g_ps2RecompiledFunctionTable[290419] = bhEne71_0x21b950; // 0x21b9d4 - g_ps2RecompiledFunctionTable[290420] = bhEne71_0x21b950; // 0x21b9d8 - g_ps2RecompiledFunctionTable[290421] = bhEne71_0x21b950; // 0x21b9dc - g_ps2RecompiledFunctionTable[290422] = bhEne71_0x21b950; // 0x21b9e0 - g_ps2RecompiledFunctionTable[290423] = bhEne71_0x21b950; // 0x21b9e4 - g_ps2RecompiledFunctionTable[290424] = bhEne71_0x21b950; // 0x21b9e8 - g_ps2RecompiledFunctionTable[290425] = bhEne71_0x21b950; // 0x21b9ec - g_ps2RecompiledFunctionTable[290426] = bhEne71_0x21b950; // 0x21b9f0 - g_ps2RecompiledFunctionTable[290427] = bhEne71_0x21b950; // 0x21b9f4 - g_ps2RecompiledFunctionTable[290428] = bhEne71_0x21b950; // 0x21b9f8 - g_ps2RecompiledFunctionTable[290429] = bhEne71_0x21b950; // 0x21b9fc - g_ps2RecompiledFunctionTable[290430] = bhEne71_0x21b950; // 0x21ba00 - g_ps2RecompiledFunctionTable[290431] = bhEne71_0x21b950; // 0x21ba04 - g_ps2RecompiledFunctionTable[290434] = bhEne71_Init_0x21ba10; // 0x21ba10 - g_ps2RecompiledFunctionTable[290443] = bhEne71_Init_0x21ba10; // 0x21ba34 - g_ps2RecompiledFunctionTable[290502] = bhEne71_Move_0x21bb20; // 0x21bb20 - g_ps2RecompiledFunctionTable[290506] = bhEne71_Nage_0x21bb30; // 0x21bb30 - g_ps2RecompiledFunctionTable[290510] = bhEne71_Damage_0x21bb40; // 0x21bb40 - g_ps2RecompiledFunctionTable[290514] = bhEne71_Die_0x21bb50; // 0x21bb50 - g_ps2RecompiledFunctionTable[290518] = bhInitEffect_0x21bb60; // 0x21bb60 - g_ps2RecompiledFunctionTable[290535] = bhInitEffect_0x21bb60; // 0x21bba4 - g_ps2RecompiledFunctionTable[290571] = bhInitEffect_0x21bb60; // 0x21bc34 - g_ps2RecompiledFunctionTable[290602] = bhInitEffect_0x21bb60; // 0x21bcb0 - g_ps2RecompiledFunctionTable[290639] = bhInitEffect_0x21bb60; // 0x21bd44 - g_ps2RecompiledFunctionTable[290667] = bhInitEffect_0x21bb60; // 0x21bdb4 - g_ps2RecompiledFunctionTable[290681] = bhInitEffect_0x21bb60; // 0x21bdec - g_ps2RecompiledFunctionTable[290696] = bhInitEffect_0x21bb60; // 0x21be28 - g_ps2RecompiledFunctionTable[290699] = bhInitEffect_0x21bb60; // 0x21be34 - g_ps2RecompiledFunctionTable[290701] = bhInitEffect_0x21bb60; // 0x21be3c - g_ps2RecompiledFunctionTable[290742] = bhSetFontTexture_0x21bee0; // 0x21bee0 - g_ps2RecompiledFunctionTable[290758] = bhSetFontTexture_0x21bee0; // 0x21bf20 - g_ps2RecompiledFunctionTable[290790] = bhSetFontTexture_0x21bee0; // 0x21bfa0 - g_ps2RecompiledFunctionTable[290810] = bhClearEffect_0x21bff0; // 0x21bff0 - g_ps2RecompiledFunctionTable[290818] = bhClearEventEffect_0x21c010; // 0x21c010 - g_ps2RecompiledFunctionTable[290822] = bhClearEventEffect_0x21c010; // 0x21c020 - g_ps2RecompiledFunctionTable[290824] = bhClearEventEffect_0x21c010; // 0x21c028 - g_ps2RecompiledFunctionTable[290826] = bhClearEventEffect_0x21c010; // 0x21c030 - g_ps2RecompiledFunctionTable[290830] = bhClrEff_YT_0x21c040; // 0x21c040 - g_ps2RecompiledFunctionTable[290845] = bhClrEff_YT_0x21c040; // 0x21c07c - g_ps2RecompiledFunctionTable[290890] = bhPushEffectWork_0x21c130; // 0x21c130 - g_ps2RecompiledFunctionTable[290935] = bhPushEffectWork_0x21c130; // 0x21c1e4 - g_ps2RecompiledFunctionTable[290952] = bhPushEffectWork_0x21c130; // 0x21c228 - g_ps2RecompiledFunctionTable[290958] = bhPopEffectWork_0x21c240; // 0x21c240 - g_ps2RecompiledFunctionTable[290972] = bhPopEffectWork_0x21c240; // 0x21c278 - g_ps2RecompiledFunctionTable[290989] = bhPopEffectWork_0x21c240; // 0x21c2bc - g_ps2RecompiledFunctionTable[290994] = bhGetGidx_0x21c2d0; // 0x21c2d0 - g_ps2RecompiledFunctionTable[291030] = bhSetExtraEffectWork_0x21c360; // 0x21c360 - g_ps2RecompiledFunctionTable[291036] = bhSetExtraEffectWork_0x21c360; // 0x21c378 - g_ps2RecompiledFunctionTable[291044] = bhSetExtraEffectWork_0x21c360; // 0x21c398 - g_ps2RecompiledFunctionTable[291058] = bhDeleteYakkyou_0x21c3d0; // 0x21c3d0 - g_ps2RecompiledFunctionTable[291062] = bhDeleteYakkyou_0x21c3d0; // 0x21c3e0 - g_ps2RecompiledFunctionTable[291086] = bhDrawPARAM2D_0x21c440; // 0x21c440 - g_ps2RecompiledFunctionTable[291134] = bhSetEffect_0x21c500; // 0x21c500 - g_ps2RecompiledFunctionTable[291149] = bhSetEffect_0x21c500; // 0x21c53c - g_ps2RecompiledFunctionTable[291157] = bhSetEffect_0x21c500; // 0x21c55c - g_ps2RecompiledFunctionTable[291250] = bhSetEffectTb_0x21c6d0; // 0x21c6d0 - g_ps2RecompiledFunctionTable[291265] = bhSetEffectTb_0x21c6d0; // 0x21c70c - g_ps2RecompiledFunctionTable[291273] = bhSetEffectTb_0x21c6d0; // 0x21c72c - g_ps2RecompiledFunctionTable[291382] = bhSetEffectEvt_0x21c8e0; // 0x21c8e0 - g_ps2RecompiledFunctionTable[291399] = bhSetEffectEvt_0x21c8e0; // 0x21c924 - g_ps2RecompiledFunctionTable[291407] = bhSetEffectEvt_0x21c8e0; // 0x21c944 - g_ps2RecompiledFunctionTable[291494] = bhSetShadow_0x21caa0; // 0x21caa0 - g_ps2RecompiledFunctionTable[291513] = bhSetShadow_0x21caa0; // 0x21caec - g_ps2RecompiledFunctionTable[291521] = bhSetShadow_0x21caa0; // 0x21cb0c - g_ps2RecompiledFunctionTable[291576] = bhSetShadow_0x21caa0; // 0x21cbe8 - g_ps2RecompiledFunctionTable[291606] = bhLinkBlood_0x21cc60; // 0x21cc60 - g_ps2RecompiledFunctionTable[291610] = bhControlEffect_0x21cc70; // 0x21cc70 - g_ps2RecompiledFunctionTable[291611] = bhControlEffect_0x21cc70; // 0x21cc74 - g_ps2RecompiledFunctionTable[291612] = bhControlEffect_0x21cc70; // 0x21cc78 - g_ps2RecompiledFunctionTable[291613] = bhControlEffect_0x21cc70; // 0x21cc7c - g_ps2RecompiledFunctionTable[291614] = bhControlEffect_0x21cc70; // 0x21cc80 - g_ps2RecompiledFunctionTable[291615] = bhControlEffect_0x21cc70; // 0x21cc84 - g_ps2RecompiledFunctionTable[291616] = bhControlEffect_0x21cc70; // 0x21cc88 - g_ps2RecompiledFunctionTable[291617] = bhControlEffect_0x21cc70; // 0x21cc8c - g_ps2RecompiledFunctionTable[291618] = bhControlEffect_0x21cc70; // 0x21cc90 - g_ps2RecompiledFunctionTable[291619] = bhControlEffect_0x21cc70; // 0x21cc94 - g_ps2RecompiledFunctionTable[291620] = bhControlEffect_0x21cc70; // 0x21cc98 - g_ps2RecompiledFunctionTable[291621] = bhControlEffect_0x21cc70; // 0x21cc9c - g_ps2RecompiledFunctionTable[291622] = bhControlEffect_0x21cc70; // 0x21cca0 - g_ps2RecompiledFunctionTable[291623] = bhControlEffect_0x21cc70; // 0x21cca4 - g_ps2RecompiledFunctionTable[291624] = bhControlEffect_0x21cc70; // 0x21cca8 - g_ps2RecompiledFunctionTable[291625] = bhControlEffect_0x21cc70; // 0x21ccac - g_ps2RecompiledFunctionTable[291626] = bhControlEffect_0x21cc70; // 0x21ccb0 - g_ps2RecompiledFunctionTable[291627] = bhControlEffect_0x21cc70; // 0x21ccb4 - g_ps2RecompiledFunctionTable[291628] = bhControlEffect_0x21cc70; // 0x21ccb8 - g_ps2RecompiledFunctionTable[291629] = bhControlEffect_0x21cc70; // 0x21ccbc - g_ps2RecompiledFunctionTable[291630] = bhControlEffect_0x21cc70; // 0x21ccc0 - g_ps2RecompiledFunctionTable[291631] = bhControlEffect_0x21cc70; // 0x21ccc4 - g_ps2RecompiledFunctionTable[291632] = bhControlEffect_0x21cc70; // 0x21ccc8 - g_ps2RecompiledFunctionTable[291633] = bhControlEffect_0x21cc70; // 0x21cccc - g_ps2RecompiledFunctionTable[291634] = bhControlEffect_0x21cc70; // 0x21ccd0 - g_ps2RecompiledFunctionTable[291635] = bhControlEffect_0x21cc70; // 0x21ccd4 - g_ps2RecompiledFunctionTable[291636] = bhControlEffect_0x21cc70; // 0x21ccd8 - g_ps2RecompiledFunctionTable[291637] = bhControlEffect_0x21cc70; // 0x21ccdc - g_ps2RecompiledFunctionTable[291638] = bhControlEffect_0x21cc70; // 0x21cce0 - g_ps2RecompiledFunctionTable[291639] = bhControlEffect_0x21cc70; // 0x21cce4 - g_ps2RecompiledFunctionTable[291640] = bhControlEffect_0x21cc70; // 0x21cce8 - g_ps2RecompiledFunctionTable[291641] = bhControlEffect_0x21cc70; // 0x21ccec - g_ps2RecompiledFunctionTable[291642] = bhControlEffect_0x21cc70; // 0x21ccf0 - g_ps2RecompiledFunctionTable[291643] = bhControlEffect_0x21cc70; // 0x21ccf4 - g_ps2RecompiledFunctionTable[291644] = bhControlEffect_0x21cc70; // 0x21ccf8 - g_ps2RecompiledFunctionTable[291645] = bhControlEffect_0x21cc70; // 0x21ccfc - g_ps2RecompiledFunctionTable[291646] = bhControlEffect_0x21cc70; // 0x21cd00 - g_ps2RecompiledFunctionTable[291647] = bhControlEffect_0x21cc70; // 0x21cd04 - g_ps2RecompiledFunctionTable[291648] = bhControlEffect_0x21cc70; // 0x21cd08 - g_ps2RecompiledFunctionTable[291649] = bhControlEffect_0x21cc70; // 0x21cd0c - g_ps2RecompiledFunctionTable[291650] = bhControlEffect_0x21cc70; // 0x21cd10 - g_ps2RecompiledFunctionTable[291651] = bhControlEffect_0x21cc70; // 0x21cd14 - g_ps2RecompiledFunctionTable[291652] = bhControlEffect_0x21cc70; // 0x21cd18 - g_ps2RecompiledFunctionTable[291653] = bhControlEffect_0x21cc70; // 0x21cd1c - g_ps2RecompiledFunctionTable[291654] = bhControlEffect_0x21cc70; // 0x21cd20 - g_ps2RecompiledFunctionTable[291655] = bhControlEffect_0x21cc70; // 0x21cd24 - g_ps2RecompiledFunctionTable[291656] = bhControlEffect_0x21cc70; // 0x21cd28 - g_ps2RecompiledFunctionTable[291657] = bhControlEffect_0x21cc70; // 0x21cd2c - g_ps2RecompiledFunctionTable[291658] = bhControlEffect_0x21cc70; // 0x21cd30 - g_ps2RecompiledFunctionTable[291659] = bhControlEffect_0x21cc70; // 0x21cd34 - g_ps2RecompiledFunctionTable[291660] = bhControlEffect_0x21cc70; // 0x21cd38 - g_ps2RecompiledFunctionTable[291661] = bhControlEffect_0x21cc70; // 0x21cd3c - g_ps2RecompiledFunctionTable[291662] = bhControlEffect_0x21cc70; // 0x21cd40 - g_ps2RecompiledFunctionTable[291663] = bhControlEffect_0x21cc70; // 0x21cd44 - g_ps2RecompiledFunctionTable[291664] = bhControlEffect_0x21cc70; // 0x21cd48 - g_ps2RecompiledFunctionTable[291665] = bhControlEffect_0x21cc70; // 0x21cd4c - g_ps2RecompiledFunctionTable[291666] = bhControlEffect_0x21cc70; // 0x21cd50 - g_ps2RecompiledFunctionTable[291667] = bhControlEffect_0x21cc70; // 0x21cd54 - g_ps2RecompiledFunctionTable[291668] = bhControlEffect_0x21cc70; // 0x21cd58 - g_ps2RecompiledFunctionTable[291669] = bhControlEffect_0x21cc70; // 0x21cd5c - g_ps2RecompiledFunctionTable[291670] = bhControlEffect_0x21cc70; // 0x21cd60 - g_ps2RecompiledFunctionTable[291671] = bhControlEffect_0x21cc70; // 0x21cd64 - g_ps2RecompiledFunctionTable[291672] = bhControlEffect_0x21cc70; // 0x21cd68 - g_ps2RecompiledFunctionTable[291673] = bhControlEffect_0x21cc70; // 0x21cd6c - g_ps2RecompiledFunctionTable[291674] = bhControlEffect_0x21cc70; // 0x21cd70 - g_ps2RecompiledFunctionTable[291675] = bhControlEffect_0x21cc70; // 0x21cd74 - g_ps2RecompiledFunctionTable[291676] = bhControlEffect_0x21cc70; // 0x21cd78 - g_ps2RecompiledFunctionTable[291677] = bhControlEffect_0x21cc70; // 0x21cd7c - g_ps2RecompiledFunctionTable[291678] = bhControlEffect_0x21cc70; // 0x21cd80 - g_ps2RecompiledFunctionTable[291679] = bhControlEffect_0x21cc70; // 0x21cd84 - g_ps2RecompiledFunctionTable[291680] = bhControlEffect_0x21cc70; // 0x21cd88 - g_ps2RecompiledFunctionTable[291681] = bhControlEffect_0x21cc70; // 0x21cd8c - g_ps2RecompiledFunctionTable[291682] = bhControlEffect_0x21cc70; // 0x21cd90 - g_ps2RecompiledFunctionTable[291683] = bhControlEffect_0x21cc70; // 0x21cd94 - g_ps2RecompiledFunctionTable[291684] = bhControlEffect_0x21cc70; // 0x21cd98 - g_ps2RecompiledFunctionTable[291685] = bhControlEffect_0x21cc70; // 0x21cd9c - g_ps2RecompiledFunctionTable[291686] = bhControlEffect_0x21cc70; // 0x21cda0 - g_ps2RecompiledFunctionTable[291687] = bhControlEffect_0x21cc70; // 0x21cda4 - g_ps2RecompiledFunctionTable[291688] = bhControlEffect_0x21cc70; // 0x21cda8 - g_ps2RecompiledFunctionTable[291689] = bhControlEffect_0x21cc70; // 0x21cdac - g_ps2RecompiledFunctionTable[291690] = bhControlEffect_0x21cc70; // 0x21cdb0 - g_ps2RecompiledFunctionTable[291691] = bhControlEffect_0x21cc70; // 0x21cdb4 - g_ps2RecompiledFunctionTable[291692] = bhControlEffect_0x21cc70; // 0x21cdb8 - g_ps2RecompiledFunctionTable[291693] = bhControlEffect_0x21cc70; // 0x21cdbc - g_ps2RecompiledFunctionTable[291694] = bhControlEffect_0x21cc70; // 0x21cdc0 - g_ps2RecompiledFunctionTable[291695] = bhControlEffect_0x21cc70; // 0x21cdc4 - g_ps2RecompiledFunctionTable[291696] = bhControlEffect_0x21cc70; // 0x21cdc8 - g_ps2RecompiledFunctionTable[291697] = bhControlEffect_0x21cc70; // 0x21cdcc - g_ps2RecompiledFunctionTable[291698] = bhControlEffect_0x21cc70; // 0x21cdd0 - g_ps2RecompiledFunctionTable[291699] = bhControlEffect_0x21cc70; // 0x21cdd4 - g_ps2RecompiledFunctionTable[291700] = bhControlEffect_0x21cc70; // 0x21cdd8 - g_ps2RecompiledFunctionTable[291701] = bhControlEffect_0x21cc70; // 0x21cddc - g_ps2RecompiledFunctionTable[291702] = bhControlEffect_0x21cc70; // 0x21cde0 - g_ps2RecompiledFunctionTable[291703] = bhControlEffect_0x21cc70; // 0x21cde4 - g_ps2RecompiledFunctionTable[291704] = bhControlEffect_0x21cc70; // 0x21cde8 - g_ps2RecompiledFunctionTable[291705] = bhControlEffect_0x21cc70; // 0x21cdec - g_ps2RecompiledFunctionTable[291706] = bhControlEffect_0x21cc70; // 0x21cdf0 - g_ps2RecompiledFunctionTable[291707] = bhControlEffect_0x21cc70; // 0x21cdf4 - g_ps2RecompiledFunctionTable[291708] = bhControlEffect_0x21cc70; // 0x21cdf8 - g_ps2RecompiledFunctionTable[291709] = bhControlEffect_0x21cc70; // 0x21cdfc - g_ps2RecompiledFunctionTable[291710] = bhControlEffect_0x21cc70; // 0x21ce00 - g_ps2RecompiledFunctionTable[291711] = bhControlEffect_0x21cc70; // 0x21ce04 - g_ps2RecompiledFunctionTable[291712] = bhControlEffect_0x21cc70; // 0x21ce08 - g_ps2RecompiledFunctionTable[291713] = bhControlEffect_0x21cc70; // 0x21ce0c - g_ps2RecompiledFunctionTable[291714] = bhControlEffect_0x21cc70; // 0x21ce10 - g_ps2RecompiledFunctionTable[291715] = bhControlEffect_0x21cc70; // 0x21ce14 - g_ps2RecompiledFunctionTable[291716] = bhControlEffect_0x21cc70; // 0x21ce18 - g_ps2RecompiledFunctionTable[291717] = bhControlEffect_0x21cc70; // 0x21ce1c - g_ps2RecompiledFunctionTable[291718] = bhControlEffect_0x21cc70; // 0x21ce20 - g_ps2RecompiledFunctionTable[291719] = bhControlEffect_0x21cc70; // 0x21ce24 - g_ps2RecompiledFunctionTable[291720] = bhControlEffect_0x21cc70; // 0x21ce28 - g_ps2RecompiledFunctionTable[291721] = bhControlEffect_0x21cc70; // 0x21ce2c - g_ps2RecompiledFunctionTable[291722] = bhControlEffect_0x21cc70; // 0x21ce30 - g_ps2RecompiledFunctionTable[291723] = bhControlEffect_0x21cc70; // 0x21ce34 - g_ps2RecompiledFunctionTable[291724] = bhControlEffect_0x21cc70; // 0x21ce38 - g_ps2RecompiledFunctionTable[291725] = bhControlEffect_0x21cc70; // 0x21ce3c - g_ps2RecompiledFunctionTable[291726] = bhControlEffect_0x21cc70; // 0x21ce40 - g_ps2RecompiledFunctionTable[291727] = bhControlEffect_0x21cc70; // 0x21ce44 - g_ps2RecompiledFunctionTable[291728] = bhControlEffect_0x21cc70; // 0x21ce48 - g_ps2RecompiledFunctionTable[291729] = bhControlEffect_0x21cc70; // 0x21ce4c - g_ps2RecompiledFunctionTable[291730] = bhControlEffect_0x21cc70; // 0x21ce50 - g_ps2RecompiledFunctionTable[291731] = bhControlEffect_0x21cc70; // 0x21ce54 - g_ps2RecompiledFunctionTable[291732] = bhControlEffect_0x21cc70; // 0x21ce58 - g_ps2RecompiledFunctionTable[291733] = bhControlEffect_0x21cc70; // 0x21ce5c - g_ps2RecompiledFunctionTable[291734] = bhControlEffect_0x21cc70; // 0x21ce60 - g_ps2RecompiledFunctionTable[291735] = bhControlEffect_0x21cc70; // 0x21ce64 - g_ps2RecompiledFunctionTable[291736] = bhControlEffect_0x21cc70; // 0x21ce68 - g_ps2RecompiledFunctionTable[291737] = bhControlEffect_0x21cc70; // 0x21ce6c - g_ps2RecompiledFunctionTable[291738] = bhControlEffect_0x21cc70; // 0x21ce70 - g_ps2RecompiledFunctionTable[291739] = bhControlEffect_0x21cc70; // 0x21ce74 - g_ps2RecompiledFunctionTable[291740] = bhControlEffect_0x21cc70; // 0x21ce78 - g_ps2RecompiledFunctionTable[291741] = bhControlEffect_0x21cc70; // 0x21ce7c - g_ps2RecompiledFunctionTable[291742] = bhControlEffect_0x21cc70; // 0x21ce80 - g_ps2RecompiledFunctionTable[291743] = bhControlEffect_0x21cc70; // 0x21ce84 - g_ps2RecompiledFunctionTable[291744] = bhControlEffect_0x21cc70; // 0x21ce88 - g_ps2RecompiledFunctionTable[291745] = bhControlEffect_0x21cc70; // 0x21ce8c - g_ps2RecompiledFunctionTable[291746] = bhControlEffect_0x21cc70; // 0x21ce90 - g_ps2RecompiledFunctionTable[291747] = bhControlEffect_0x21cc70; // 0x21ce94 - g_ps2RecompiledFunctionTable[291748] = bhControlEffect_0x21cc70; // 0x21ce98 - g_ps2RecompiledFunctionTable[291749] = bhControlEffect_0x21cc70; // 0x21ce9c - g_ps2RecompiledFunctionTable[291750] = bhControlEffect_0x21cc70; // 0x21cea0 - g_ps2RecompiledFunctionTable[291751] = bhControlEffect_0x21cc70; // 0x21cea4 - g_ps2RecompiledFunctionTable[291752] = bhControlEffect_0x21cc70; // 0x21cea8 - g_ps2RecompiledFunctionTable[291753] = bhControlEffect_0x21cc70; // 0x21ceac - g_ps2RecompiledFunctionTable[291754] = bhControlEffect_0x21cc70; // 0x21ceb0 - g_ps2RecompiledFunctionTable[291755] = bhControlEffect_0x21cc70; // 0x21ceb4 - g_ps2RecompiledFunctionTable[291756] = bhControlEffect_0x21cc70; // 0x21ceb8 - g_ps2RecompiledFunctionTable[291757] = bhControlEffect_0x21cc70; // 0x21cebc - g_ps2RecompiledFunctionTable[291758] = bhControlEffect_0x21cc70; // 0x21cec0 - g_ps2RecompiledFunctionTable[291759] = bhControlEffect_0x21cc70; // 0x21cec4 - g_ps2RecompiledFunctionTable[291760] = bhControlEffect_0x21cc70; // 0x21cec8 - g_ps2RecompiledFunctionTable[291761] = bhControlEffect_0x21cc70; // 0x21cecc - g_ps2RecompiledFunctionTable[291762] = bhControlEffect_0x21cc70; // 0x21ced0 - g_ps2RecompiledFunctionTable[291763] = bhControlEffect_0x21cc70; // 0x21ced4 - g_ps2RecompiledFunctionTable[291764] = bhControlEffect_0x21cc70; // 0x21ced8 - g_ps2RecompiledFunctionTable[291765] = bhControlEffect_0x21cc70; // 0x21cedc - g_ps2RecompiledFunctionTable[291766] = bhControlEffect_0x21cc70; // 0x21cee0 - g_ps2RecompiledFunctionTable[291767] = bhControlEffect_0x21cc70; // 0x21cee4 - g_ps2RecompiledFunctionTable[291768] = bhControlEffect_0x21cc70; // 0x21cee8 - g_ps2RecompiledFunctionTable[291769] = bhControlEffect_0x21cc70; // 0x21ceec - g_ps2RecompiledFunctionTable[291770] = bhControlEffect_0x21cc70; // 0x21cef0 - g_ps2RecompiledFunctionTable[291771] = bhControlEffect_0x21cc70; // 0x21cef4 - g_ps2RecompiledFunctionTable[291772] = bhControlEffect_0x21cc70; // 0x21cef8 - g_ps2RecompiledFunctionTable[291773] = bhControlEffect_0x21cc70; // 0x21cefc - g_ps2RecompiledFunctionTable[291774] = bhControlEffect_0x21cc70; // 0x21cf00 - g_ps2RecompiledFunctionTable[291775] = bhControlEffect_0x21cc70; // 0x21cf04 - g_ps2RecompiledFunctionTable[291776] = bhControlEffect_0x21cc70; // 0x21cf08 - g_ps2RecompiledFunctionTable[291777] = bhControlEffect_0x21cc70; // 0x21cf0c - g_ps2RecompiledFunctionTable[291778] = bhControlEffect_0x21cc70; // 0x21cf10 - g_ps2RecompiledFunctionTable[291779] = bhControlEffect_0x21cc70; // 0x21cf14 - g_ps2RecompiledFunctionTable[291780] = bhControlEffect_0x21cc70; // 0x21cf18 - g_ps2RecompiledFunctionTable[291781] = bhControlEffect_0x21cc70; // 0x21cf1c - g_ps2RecompiledFunctionTable[291782] = bhControlEffect_0x21cc70; // 0x21cf20 - g_ps2RecompiledFunctionTable[291783] = bhControlEffect_0x21cc70; // 0x21cf24 - g_ps2RecompiledFunctionTable[291784] = bhControlEffect_0x21cc70; // 0x21cf28 - g_ps2RecompiledFunctionTable[291785] = bhControlEffect_0x21cc70; // 0x21cf2c - g_ps2RecompiledFunctionTable[291786] = bhControlEffect_0x21cc70; // 0x21cf30 - g_ps2RecompiledFunctionTable[291787] = bhControlEffect_0x21cc70; // 0x21cf34 - g_ps2RecompiledFunctionTable[291788] = bhControlEffect_0x21cc70; // 0x21cf38 - g_ps2RecompiledFunctionTable[291789] = bhControlEffect_0x21cc70; // 0x21cf3c - g_ps2RecompiledFunctionTable[291790] = bhControlEffect_0x21cc70; // 0x21cf40 - g_ps2RecompiledFunctionTable[291791] = bhControlEffect_0x21cc70; // 0x21cf44 - g_ps2RecompiledFunctionTable[291792] = bhControlEffect_0x21cc70; // 0x21cf48 - g_ps2RecompiledFunctionTable[291793] = bhControlEffect_0x21cc70; // 0x21cf4c - g_ps2RecompiledFunctionTable[291794] = bhControlEffect_0x21cc70; // 0x21cf50 - g_ps2RecompiledFunctionTable[291795] = bhControlEffect_0x21cc70; // 0x21cf54 - g_ps2RecompiledFunctionTable[291796] = bhControlEffect_0x21cc70; // 0x21cf58 - g_ps2RecompiledFunctionTable[291797] = bhControlEffect_0x21cc70; // 0x21cf5c - g_ps2RecompiledFunctionTable[291798] = bhControlEffect_0x21cc70; // 0x21cf60 - g_ps2RecompiledFunctionTable[291802] = bhDrawEffect_0x21cf70; // 0x21cf70 - g_ps2RecompiledFunctionTable[291803] = bhDrawEffect_0x21cf70; // 0x21cf74 - g_ps2RecompiledFunctionTable[291804] = bhDrawEffect_0x21cf70; // 0x21cf78 - g_ps2RecompiledFunctionTable[291805] = bhDrawEffect_0x21cf70; // 0x21cf7c - g_ps2RecompiledFunctionTable[291806] = bhDrawEffect_0x21cf70; // 0x21cf80 - g_ps2RecompiledFunctionTable[291807] = bhDrawEffect_0x21cf70; // 0x21cf84 - g_ps2RecompiledFunctionTable[291808] = bhDrawEffect_0x21cf70; // 0x21cf88 - g_ps2RecompiledFunctionTable[291809] = bhDrawEffect_0x21cf70; // 0x21cf8c - g_ps2RecompiledFunctionTable[291810] = bhDrawEffect_0x21cf70; // 0x21cf90 - g_ps2RecompiledFunctionTable[291811] = bhDrawEffect_0x21cf70; // 0x21cf94 - g_ps2RecompiledFunctionTable[291812] = bhDrawEffect_0x21cf70; // 0x21cf98 - g_ps2RecompiledFunctionTable[291813] = bhDrawEffect_0x21cf70; // 0x21cf9c - g_ps2RecompiledFunctionTable[291814] = bhDrawEffect_0x21cf70; // 0x21cfa0 - g_ps2RecompiledFunctionTable[291815] = bhDrawEffect_0x21cf70; // 0x21cfa4 - g_ps2RecompiledFunctionTable[291816] = bhDrawEffect_0x21cf70; // 0x21cfa8 - g_ps2RecompiledFunctionTable[291817] = bhDrawEffect_0x21cf70; // 0x21cfac - g_ps2RecompiledFunctionTable[291818] = bhDrawEffect_0x21cf70; // 0x21cfb0 - g_ps2RecompiledFunctionTable[291819] = bhDrawEffect_0x21cf70; // 0x21cfb4 - g_ps2RecompiledFunctionTable[291820] = bhDrawEffect_0x21cf70; // 0x21cfb8 - g_ps2RecompiledFunctionTable[291821] = bhDrawEffect_0x21cf70; // 0x21cfbc - g_ps2RecompiledFunctionTable[291822] = bhDrawEffect_0x21cf70; // 0x21cfc0 - g_ps2RecompiledFunctionTable[291823] = bhDrawEffect_0x21cf70; // 0x21cfc4 - g_ps2RecompiledFunctionTable[291824] = bhDrawEffect_0x21cf70; // 0x21cfc8 - g_ps2RecompiledFunctionTable[291825] = bhDrawEffect_0x21cf70; // 0x21cfcc - g_ps2RecompiledFunctionTable[291826] = bhDrawEffect_0x21cf70; // 0x21cfd0 - g_ps2RecompiledFunctionTable[291827] = bhDrawEffect_0x21cf70; // 0x21cfd4 - g_ps2RecompiledFunctionTable[291828] = bhDrawEffect_0x21cf70; // 0x21cfd8 - g_ps2RecompiledFunctionTable[291829] = bhDrawEffect_0x21cf70; // 0x21cfdc - g_ps2RecompiledFunctionTable[291830] = bhDrawEffect_0x21cf70; // 0x21cfe0 - g_ps2RecompiledFunctionTable[291831] = bhDrawEffect_0x21cf70; // 0x21cfe4 - g_ps2RecompiledFunctionTable[291832] = bhDrawEffect_0x21cf70; // 0x21cfe8 - g_ps2RecompiledFunctionTable[291833] = bhDrawEffect_0x21cf70; // 0x21cfec - g_ps2RecompiledFunctionTable[291834] = bhDrawEffect_0x21cf70; // 0x21cff0 - g_ps2RecompiledFunctionTable[291835] = bhDrawEffect_0x21cf70; // 0x21cff4 - g_ps2RecompiledFunctionTable[291836] = bhDrawEffect_0x21cf70; // 0x21cff8 - g_ps2RecompiledFunctionTable[291837] = bhDrawEffect_0x21cf70; // 0x21cffc - g_ps2RecompiledFunctionTable[291838] = bhDrawEffect_0x21cf70; // 0x21d000 - g_ps2RecompiledFunctionTable[291839] = bhDrawEffect_0x21cf70; // 0x21d004 - g_ps2RecompiledFunctionTable[291840] = bhDrawEffect_0x21cf70; // 0x21d008 - g_ps2RecompiledFunctionTable[291841] = bhDrawEffect_0x21cf70; // 0x21d00c - g_ps2RecompiledFunctionTable[291842] = bhDrawEffect_0x21cf70; // 0x21d010 - g_ps2RecompiledFunctionTable[291843] = bhDrawEffect_0x21cf70; // 0x21d014 - g_ps2RecompiledFunctionTable[291844] = bhDrawEffect_0x21cf70; // 0x21d018 - g_ps2RecompiledFunctionTable[291845] = bhDrawEffect_0x21cf70; // 0x21d01c - g_ps2RecompiledFunctionTable[291846] = bhDrawEffect_0x21cf70; // 0x21d020 - g_ps2RecompiledFunctionTable[291847] = bhDrawEffect_0x21cf70; // 0x21d024 - g_ps2RecompiledFunctionTable[291848] = bhDrawEffect_0x21cf70; // 0x21d028 - g_ps2RecompiledFunctionTable[291849] = bhDrawEffect_0x21cf70; // 0x21d02c - g_ps2RecompiledFunctionTable[291850] = bhDrawEffect_0x21cf70; // 0x21d030 - g_ps2RecompiledFunctionTable[291851] = bhDrawEffect_0x21cf70; // 0x21d034 - g_ps2RecompiledFunctionTable[291852] = bhDrawEffect_0x21cf70; // 0x21d038 - g_ps2RecompiledFunctionTable[291853] = bhDrawEffect_0x21cf70; // 0x21d03c - g_ps2RecompiledFunctionTable[291854] = bhDrawEffect_0x21cf70; // 0x21d040 - g_ps2RecompiledFunctionTable[291855] = bhDrawEffect_0x21cf70; // 0x21d044 - g_ps2RecompiledFunctionTable[291856] = bhDrawEffect_0x21cf70; // 0x21d048 - g_ps2RecompiledFunctionTable[291857] = bhDrawEffect_0x21cf70; // 0x21d04c - g_ps2RecompiledFunctionTable[291858] = bhDrawEffect_0x21cf70; // 0x21d050 - g_ps2RecompiledFunctionTable[291859] = bhDrawEffect_0x21cf70; // 0x21d054 - g_ps2RecompiledFunctionTable[291860] = bhDrawEffect_0x21cf70; // 0x21d058 - g_ps2RecompiledFunctionTable[291861] = bhDrawEffect_0x21cf70; // 0x21d05c - g_ps2RecompiledFunctionTable[291862] = bhDrawEffect_0x21cf70; // 0x21d060 - g_ps2RecompiledFunctionTable[291863] = bhDrawEffect_0x21cf70; // 0x21d064 - g_ps2RecompiledFunctionTable[291864] = bhDrawEffect_0x21cf70; // 0x21d068 - g_ps2RecompiledFunctionTable[291865] = bhDrawEffect_0x21cf70; // 0x21d06c - g_ps2RecompiledFunctionTable[291866] = bhDrawEffect_0x21cf70; // 0x21d070 - g_ps2RecompiledFunctionTable[291867] = bhDrawEffect_0x21cf70; // 0x21d074 - g_ps2RecompiledFunctionTable[291868] = bhDrawEffect_0x21cf70; // 0x21d078 - g_ps2RecompiledFunctionTable[291869] = bhDrawEffect_0x21cf70; // 0x21d07c - g_ps2RecompiledFunctionTable[291870] = bhDrawEffect_0x21cf70; // 0x21d080 - g_ps2RecompiledFunctionTable[291871] = bhDrawEffect_0x21cf70; // 0x21d084 - g_ps2RecompiledFunctionTable[291872] = bhDrawEffect_0x21cf70; // 0x21d088 - g_ps2RecompiledFunctionTable[291873] = bhDrawEffect_0x21cf70; // 0x21d08c - g_ps2RecompiledFunctionTable[291874] = bhDrawEffect_0x21cf70; // 0x21d090 - g_ps2RecompiledFunctionTable[291875] = bhDrawEffect_0x21cf70; // 0x21d094 - g_ps2RecompiledFunctionTable[291876] = bhDrawEffect_0x21cf70; // 0x21d098 - g_ps2RecompiledFunctionTable[291877] = bhDrawEffect_0x21cf70; // 0x21d09c - g_ps2RecompiledFunctionTable[291878] = bhDrawEffect_0x21cf70; // 0x21d0a0 - g_ps2RecompiledFunctionTable[291879] = bhDrawEffect_0x21cf70; // 0x21d0a4 - g_ps2RecompiledFunctionTable[291880] = bhDrawEffect_0x21cf70; // 0x21d0a8 - g_ps2RecompiledFunctionTable[291881] = bhDrawEffect_0x21cf70; // 0x21d0ac - g_ps2RecompiledFunctionTable[291882] = bhDrawEffect_0x21cf70; // 0x21d0b0 - g_ps2RecompiledFunctionTable[291883] = bhDrawEffect_0x21cf70; // 0x21d0b4 - g_ps2RecompiledFunctionTable[291884] = bhDrawEffect_0x21cf70; // 0x21d0b8 - g_ps2RecompiledFunctionTable[291885] = bhDrawEffect_0x21cf70; // 0x21d0bc - g_ps2RecompiledFunctionTable[291886] = bhDrawEffect_0x21cf70; // 0x21d0c0 - g_ps2RecompiledFunctionTable[291887] = bhDrawEffect_0x21cf70; // 0x21d0c4 - g_ps2RecompiledFunctionTable[291888] = bhDrawEffect_0x21cf70; // 0x21d0c8 - g_ps2RecompiledFunctionTable[291889] = bhDrawEffect_0x21cf70; // 0x21d0cc - g_ps2RecompiledFunctionTable[291890] = bhDrawEffect_0x21cf70; // 0x21d0d0 - g_ps2RecompiledFunctionTable[291891] = bhDrawEffect_0x21cf70; // 0x21d0d4 - g_ps2RecompiledFunctionTable[291892] = bhDrawEffect_0x21cf70; // 0x21d0d8 - g_ps2RecompiledFunctionTable[291893] = bhDrawEffect_0x21cf70; // 0x21d0dc - g_ps2RecompiledFunctionTable[291894] = bhDrawEffect_0x21cf70; // 0x21d0e0 - g_ps2RecompiledFunctionTable[291895] = bhDrawEffect_0x21cf70; // 0x21d0e4 - g_ps2RecompiledFunctionTable[291896] = bhDrawEffect_0x21cf70; // 0x21d0e8 - g_ps2RecompiledFunctionTable[291897] = bhDrawEffect_0x21cf70; // 0x21d0ec - g_ps2RecompiledFunctionTable[291898] = bhDrawEffect_0x21cf70; // 0x21d0f0 - g_ps2RecompiledFunctionTable[291899] = bhDrawEffect_0x21cf70; // 0x21d0f4 - g_ps2RecompiledFunctionTable[291900] = bhDrawEffect_0x21cf70; // 0x21d0f8 - g_ps2RecompiledFunctionTable[291901] = bhDrawEffect_0x21cf70; // 0x21d0fc - g_ps2RecompiledFunctionTable[291902] = bhDrawEffect_0x21cf70; // 0x21d100 - g_ps2RecompiledFunctionTable[291903] = bhDrawEffect_0x21cf70; // 0x21d104 - g_ps2RecompiledFunctionTable[291904] = bhDrawEffect_0x21cf70; // 0x21d108 - g_ps2RecompiledFunctionTable[291905] = bhDrawEffect_0x21cf70; // 0x21d10c - g_ps2RecompiledFunctionTable[291906] = bhDrawEffect_0x21cf70; // 0x21d110 - g_ps2RecompiledFunctionTable[291907] = bhDrawEffect_0x21cf70; // 0x21d114 - g_ps2RecompiledFunctionTable[291908] = bhDrawEffect_0x21cf70; // 0x21d118 - g_ps2RecompiledFunctionTable[291909] = bhDrawEffect_0x21cf70; // 0x21d11c - g_ps2RecompiledFunctionTable[291910] = bhDrawEffect_0x21cf70; // 0x21d120 - g_ps2RecompiledFunctionTable[291911] = bhDrawEffect_0x21cf70; // 0x21d124 - g_ps2RecompiledFunctionTable[291912] = bhDrawEffect_0x21cf70; // 0x21d128 - g_ps2RecompiledFunctionTable[291913] = bhDrawEffect_0x21cf70; // 0x21d12c - g_ps2RecompiledFunctionTable[291914] = bhDrawEffect_0x21cf70; // 0x21d130 - g_ps2RecompiledFunctionTable[291915] = bhDrawEffect_0x21cf70; // 0x21d134 - g_ps2RecompiledFunctionTable[291916] = bhDrawEffect_0x21cf70; // 0x21d138 - g_ps2RecompiledFunctionTable[291917] = bhDrawEffect_0x21cf70; // 0x21d13c - g_ps2RecompiledFunctionTable[291918] = bhDrawEffect_0x21cf70; // 0x21d140 - g_ps2RecompiledFunctionTable[291919] = bhDrawEffect_0x21cf70; // 0x21d144 - g_ps2RecompiledFunctionTable[291920] = bhDrawEffect_0x21cf70; // 0x21d148 - g_ps2RecompiledFunctionTable[291921] = bhDrawEffect_0x21cf70; // 0x21d14c - g_ps2RecompiledFunctionTable[291922] = bhDrawEffect_0x21cf70; // 0x21d150 - g_ps2RecompiledFunctionTable[291923] = bhDrawEffect_0x21cf70; // 0x21d154 - g_ps2RecompiledFunctionTable[291924] = bhDrawEffect_0x21cf70; // 0x21d158 - g_ps2RecompiledFunctionTable[291925] = bhDrawEffect_0x21cf70; // 0x21d15c - g_ps2RecompiledFunctionTable[291926] = bhDrawEffect_0x21cf70; // 0x21d160 - g_ps2RecompiledFunctionTable[291927] = bhDrawEffect_0x21cf70; // 0x21d164 - g_ps2RecompiledFunctionTable[291928] = bhDrawEffect_0x21cf70; // 0x21d168 - g_ps2RecompiledFunctionTable[291929] = bhDrawEffect_0x21cf70; // 0x21d16c - g_ps2RecompiledFunctionTable[291930] = bhDrawEffect_0x21cf70; // 0x21d170 - g_ps2RecompiledFunctionTable[291931] = bhDrawEffect_0x21cf70; // 0x21d174 - g_ps2RecompiledFunctionTable[291932] = bhDrawEffect_0x21cf70; // 0x21d178 - g_ps2RecompiledFunctionTable[291933] = bhDrawEffect_0x21cf70; // 0x21d17c - g_ps2RecompiledFunctionTable[291934] = bhDrawEffect_0x21cf70; // 0x21d180 - g_ps2RecompiledFunctionTable[291935] = bhDrawEffect_0x21cf70; // 0x21d184 - g_ps2RecompiledFunctionTable[291936] = bhDrawEffect_0x21cf70; // 0x21d188 - g_ps2RecompiledFunctionTable[291937] = bhDrawEffect_0x21cf70; // 0x21d18c - g_ps2RecompiledFunctionTable[291938] = bhDrawEffect_0x21cf70; // 0x21d190 - g_ps2RecompiledFunctionTable[291939] = bhDrawEffect_0x21cf70; // 0x21d194 - g_ps2RecompiledFunctionTable[291940] = bhDrawEffect_0x21cf70; // 0x21d198 - g_ps2RecompiledFunctionTable[291941] = bhDrawEffect_0x21cf70; // 0x21d19c - g_ps2RecompiledFunctionTable[291942] = bhDrawEffect_0x21cf70; // 0x21d1a0 - g_ps2RecompiledFunctionTable[291943] = bhDrawEffect_0x21cf70; // 0x21d1a4 - g_ps2RecompiledFunctionTable[291944] = bhDrawEffect_0x21cf70; // 0x21d1a8 - g_ps2RecompiledFunctionTable[291945] = bhDrawEffect_0x21cf70; // 0x21d1ac - g_ps2RecompiledFunctionTable[291946] = bhDrawEffect_0x21cf70; // 0x21d1b0 - g_ps2RecompiledFunctionTable[291947] = bhDrawEffect_0x21cf70; // 0x21d1b4 - g_ps2RecompiledFunctionTable[291948] = bhDrawEffect_0x21cf70; // 0x21d1b8 - g_ps2RecompiledFunctionTable[291949] = bhDrawEffect_0x21cf70; // 0x21d1bc - g_ps2RecompiledFunctionTable[291950] = bhDrawEffect_0x21cf70; // 0x21d1c0 - g_ps2RecompiledFunctionTable[291951] = bhDrawEffect_0x21cf70; // 0x21d1c4 - g_ps2RecompiledFunctionTable[291952] = bhDrawEffect_0x21cf70; // 0x21d1c8 - g_ps2RecompiledFunctionTable[291953] = bhDrawEffect_0x21cf70; // 0x21d1cc - g_ps2RecompiledFunctionTable[291954] = bhDrawEffect_0x21cf70; // 0x21d1d0 - g_ps2RecompiledFunctionTable[291955] = bhDrawEffect_0x21cf70; // 0x21d1d4 - g_ps2RecompiledFunctionTable[291956] = bhDrawEffect_0x21cf70; // 0x21d1d8 - g_ps2RecompiledFunctionTable[291957] = bhDrawEffect_0x21cf70; // 0x21d1dc - g_ps2RecompiledFunctionTable[291958] = bhDrawEffect_0x21cf70; // 0x21d1e0 - g_ps2RecompiledFunctionTable[291959] = bhDrawEffect_0x21cf70; // 0x21d1e4 - g_ps2RecompiledFunctionTable[291960] = bhDrawEffect_0x21cf70; // 0x21d1e8 - g_ps2RecompiledFunctionTable[291961] = bhDrawEffect_0x21cf70; // 0x21d1ec - g_ps2RecompiledFunctionTable[291962] = bhDrawEffect_0x21cf70; // 0x21d1f0 - g_ps2RecompiledFunctionTable[291963] = bhDrawEffect_0x21cf70; // 0x21d1f4 - g_ps2RecompiledFunctionTable[291964] = bhDrawEffect_0x21cf70; // 0x21d1f8 - g_ps2RecompiledFunctionTable[291965] = bhDrawEffect_0x21cf70; // 0x21d1fc - g_ps2RecompiledFunctionTable[291966] = bhDrawEffect_0x21cf70; // 0x21d200 - g_ps2RecompiledFunctionTable[291967] = bhDrawEffect_0x21cf70; // 0x21d204 - g_ps2RecompiledFunctionTable[291968] = bhDrawEffect_0x21cf70; // 0x21d208 - g_ps2RecompiledFunctionTable[291969] = bhDrawEffect_0x21cf70; // 0x21d20c - g_ps2RecompiledFunctionTable[291970] = bhDrawEffect_0x21cf70; // 0x21d210 - g_ps2RecompiledFunctionTable[291971] = bhDrawEffect_0x21cf70; // 0x21d214 - g_ps2RecompiledFunctionTable[291972] = bhDrawEffect_0x21cf70; // 0x21d218 - g_ps2RecompiledFunctionTable[291973] = bhDrawEffect_0x21cf70; // 0x21d21c - g_ps2RecompiledFunctionTable[291974] = bhDrawEffect_0x21cf70; // 0x21d220 - g_ps2RecompiledFunctionTable[291975] = bhDrawEffect_0x21cf70; // 0x21d224 - g_ps2RecompiledFunctionTable[291976] = bhDrawEffect_0x21cf70; // 0x21d228 - g_ps2RecompiledFunctionTable[291977] = bhDrawEffect_0x21cf70; // 0x21d22c - g_ps2RecompiledFunctionTable[291978] = bhDrawEffect_0x21cf70; // 0x21d230 - g_ps2RecompiledFunctionTable[291979] = bhDrawEffect_0x21cf70; // 0x21d234 - g_ps2RecompiledFunctionTable[291980] = bhDrawEffect_0x21cf70; // 0x21d238 - g_ps2RecompiledFunctionTable[291981] = bhDrawEffect_0x21cf70; // 0x21d23c - g_ps2RecompiledFunctionTable[291982] = bhDrawEffect_0x21cf70; // 0x21d240 - g_ps2RecompiledFunctionTable[291983] = bhDrawEffect_0x21cf70; // 0x21d244 - g_ps2RecompiledFunctionTable[291984] = bhDrawEffect_0x21cf70; // 0x21d248 - g_ps2RecompiledFunctionTable[291985] = bhDrawEffect_0x21cf70; // 0x21d24c - g_ps2RecompiledFunctionTable[291986] = bhDrawEffect_0x21cf70; // 0x21d250 - g_ps2RecompiledFunctionTable[291987] = bhDrawEffect_0x21cf70; // 0x21d254 - g_ps2RecompiledFunctionTable[291988] = bhDrawEffect_0x21cf70; // 0x21d258 - g_ps2RecompiledFunctionTable[291989] = bhDrawEffect_0x21cf70; // 0x21d25c - g_ps2RecompiledFunctionTable[291990] = bhDrawEffect_0x21cf70; // 0x21d260 - g_ps2RecompiledFunctionTable[291991] = bhDrawEffect_0x21cf70; // 0x21d264 - g_ps2RecompiledFunctionTable[291992] = bhDrawEffect_0x21cf70; // 0x21d268 - g_ps2RecompiledFunctionTable[291993] = bhDrawEffect_0x21cf70; // 0x21d26c - g_ps2RecompiledFunctionTable[291994] = bhDrawEffect_0x21cf70; // 0x21d270 - g_ps2RecompiledFunctionTable[291995] = bhDrawEffect_0x21cf70; // 0x21d274 - g_ps2RecompiledFunctionTable[291996] = bhDrawEffect_0x21cf70; // 0x21d278 - g_ps2RecompiledFunctionTable[291997] = bhDrawEffect_0x21cf70; // 0x21d27c - g_ps2RecompiledFunctionTable[291998] = bhDrawEffect_0x21cf70; // 0x21d280 - g_ps2RecompiledFunctionTable[291999] = bhDrawEffect_0x21cf70; // 0x21d284 - g_ps2RecompiledFunctionTable[292000] = bhDrawEffect_0x21cf70; // 0x21d288 - g_ps2RecompiledFunctionTable[292001] = bhDrawEffect_0x21cf70; // 0x21d28c - g_ps2RecompiledFunctionTable[292002] = bhDrawEffect_0x21cf70; // 0x21d290 - g_ps2RecompiledFunctionTable[292003] = bhDrawEffect_0x21cf70; // 0x21d294 - g_ps2RecompiledFunctionTable[292004] = bhDrawEffect_0x21cf70; // 0x21d298 - g_ps2RecompiledFunctionTable[292005] = bhDrawEffect_0x21cf70; // 0x21d29c - g_ps2RecompiledFunctionTable[292006] = bhDrawEffect_0x21cf70; // 0x21d2a0 - g_ps2RecompiledFunctionTable[292007] = bhDrawEffect_0x21cf70; // 0x21d2a4 - g_ps2RecompiledFunctionTable[292008] = bhDrawEffect_0x21cf70; // 0x21d2a8 - g_ps2RecompiledFunctionTable[292009] = bhDrawEffect_0x21cf70; // 0x21d2ac - g_ps2RecompiledFunctionTable[292010] = bhDrawEffect_0x21cf70; // 0x21d2b0 - g_ps2RecompiledFunctionTable[292014] = bhDrawPolEffect_0x21d2c0; // 0x21d2c0 - g_ps2RecompiledFunctionTable[292028] = bhDrawPolEffect_0x21d2c0; // 0x21d2f8 - g_ps2RecompiledFunctionTable[292036] = bhDrawPolEffect_0x21d2c0; // 0x21d318 - g_ps2RecompiledFunctionTable[292045] = bhDrawPolEffect_0x21d2c0; // 0x21d33c - g_ps2RecompiledFunctionTable[292048] = bhDrawPolEffect_0x21d2c0; // 0x21d348 - g_ps2RecompiledFunctionTable[292050] = bhDrawPolEffect_0x21d2c0; // 0x21d350 - g_ps2RecompiledFunctionTable[292072] = bhDrawPolEffect_0x21d2c0; // 0x21d3a8 - g_ps2RecompiledFunctionTable[292080] = bhDrawPolEffect_0x21d2c0; // 0x21d3c8 - g_ps2RecompiledFunctionTable[292085] = bhDrawPolEffect_0x21d2c0; // 0x21d3dc - g_ps2RecompiledFunctionTable[292110] = bhDrawPolEffect_0x21d2c0; // 0x21d440 - g_ps2RecompiledFunctionTable[292112] = bhDrawPolEffect_0x21d2c0; // 0x21d448 - g_ps2RecompiledFunctionTable[292116] = bhDrawPolEffect_0x21d2c0; // 0x21d458 - g_ps2RecompiledFunctionTable[292118] = bhDrawPolEffect_0x21d2c0; // 0x21d460 - g_ps2RecompiledFunctionTable[292120] = bhDrawPolEffect_0x21d2c0; // 0x21d468 - g_ps2RecompiledFunctionTable[292131] = bhDrawPolEffect_0x21d2c0; // 0x21d494 - g_ps2RecompiledFunctionTable[292133] = bhDrawPolEffect_0x21d2c0; // 0x21d49c - g_ps2RecompiledFunctionTable[292136] = bhDrawPolEffect_0x21d2c0; // 0x21d4a8 - g_ps2RecompiledFunctionTable[292138] = bhDrawPolEffect_0x21d2c0; // 0x21d4b0 - g_ps2RecompiledFunctionTable[292151] = bhDrawPolEffect_0x21d2c0; // 0x21d4e4 - g_ps2RecompiledFunctionTable[292156] = bhDrawPolEffect_0x21d2c0; // 0x21d4f8 - g_ps2RecompiledFunctionTable[292161] = bhDrawPolEffect_0x21d2c0; // 0x21d50c - g_ps2RecompiledFunctionTable[292164] = bhDrawPolEffect_0x21d2c0; // 0x21d518 - g_ps2RecompiledFunctionTable[292167] = bhDrawPolEffect_0x21d2c0; // 0x21d524 - g_ps2RecompiledFunctionTable[292169] = bhDrawPolEffect_0x21d2c0; // 0x21d52c - g_ps2RecompiledFunctionTable[292179] = bhDrawPolEffect_0x21d2c0; // 0x21d554 - g_ps2RecompiledFunctionTable[292190] = bhDrawPolEffect_0x21d2c0; // 0x21d580 - g_ps2RecompiledFunctionTable[292202] = bhDrawMdfEffect_0x21d5b0; // 0x21d5b0 - g_ps2RecompiledFunctionTable[292211] = bhDrawMdfEffect_0x21d5b0; // 0x21d5d4 - g_ps2RecompiledFunctionTable[292214] = bhDrawMdfEffect_0x21d5b0; // 0x21d5e0 - g_ps2RecompiledFunctionTable[292216] = bhDrawMdfEffect_0x21d5b0; // 0x21d5e8 - g_ps2RecompiledFunctionTable[292238] = bhDrawMdfEffect_0x21d5b0; // 0x21d640 - g_ps2RecompiledFunctionTable[292242] = bhDrawMdfEffect_0x21d5b0; // 0x21d650 - g_ps2RecompiledFunctionTable[292253] = bhDrawMdfEffect_0x21d5b0; // 0x21d67c - g_ps2RecompiledFunctionTable[292255] = bhDrawMdfEffect_0x21d5b0; // 0x21d684 - g_ps2RecompiledFunctionTable[292258] = bhDrawMdfEffect_0x21d5b0; // 0x21d690 - g_ps2RecompiledFunctionTable[292260] = bhDrawMdfEffect_0x21d5b0; // 0x21d698 - g_ps2RecompiledFunctionTable[292273] = bhDrawMdfEffect_0x21d5b0; // 0x21d6cc - g_ps2RecompiledFunctionTable[292278] = bhDrawMdfEffect_0x21d5b0; // 0x21d6e0 - g_ps2RecompiledFunctionTable[292283] = bhDrawMdfEffect_0x21d5b0; // 0x21d6f4 - g_ps2RecompiledFunctionTable[292286] = bhDrawMdfEffect_0x21d5b0; // 0x21d700 - g_ps2RecompiledFunctionTable[292289] = bhDrawMdfEffect_0x21d5b0; // 0x21d70c - g_ps2RecompiledFunctionTable[292291] = bhDrawMdfEffect_0x21d5b0; // 0x21d714 - g_ps2RecompiledFunctionTable[292293] = bhDrawMdfEffect_0x21d5b0; // 0x21d71c - g_ps2RecompiledFunctionTable[292305] = bhDrawMdfEffect_0x21d5b0; // 0x21d74c - g_ps2RecompiledFunctionTable[292307] = bhDrawMdfEffect_0x21d5b0; // 0x21d754 - g_ps2RecompiledFunctionTable[292320] = bhDrawMdfEffect_0x21d5b0; // 0x21d788 - g_ps2RecompiledFunctionTable[292322] = bhDrawMdfEffect_0x21d5b0; // 0x21d790 - g_ps2RecompiledFunctionTable[292324] = bhDrawMdfEffect_0x21d5b0; // 0x21d798 - g_ps2RecompiledFunctionTable[292330] = bhDrawMdfEffect_0x21d5b0; // 0x21d7b0 - g_ps2RecompiledFunctionTable[292338] = bhDrawLinEffect_0x21d7d0; // 0x21d7d0 - g_ps2RecompiledFunctionTable[292348] = bhDrawLinEffect_0x21d7d0; // 0x21d7f8 - g_ps2RecompiledFunctionTable[292350] = bhDrawLinEffect_0x21d7d0; // 0x21d800 - g_ps2RecompiledFunctionTable[292372] = bhDrawLinEffect_0x21d7d0; // 0x21d858 - g_ps2RecompiledFunctionTable[292398] = bhDrawLinEffect_0x21d7d0; // 0x21d8c0 - g_ps2RecompiledFunctionTable[292400] = bhDrawLinEffect_0x21d7d0; // 0x21d8c8 - g_ps2RecompiledFunctionTable[292402] = bhDrawLinEffect_0x21d7d0; // 0x21d8d0 - g_ps2RecompiledFunctionTable[292405] = bhDrawLinEffect_0x21d7d0; // 0x21d8dc - g_ps2RecompiledFunctionTable[292407] = bhDrawLinEffect_0x21d7d0; // 0x21d8e4 - g_ps2RecompiledFunctionTable[292409] = bhDrawLinEffect_0x21d7d0; // 0x21d8ec - g_ps2RecompiledFunctionTable[292412] = bhDrawLinEffect_0x21d7d0; // 0x21d8f8 - g_ps2RecompiledFunctionTable[292414] = bhDrawLinEffect_0x21d7d0; // 0x21d900 - g_ps2RecompiledFunctionTable[292417] = bhDrawLinEffect_0x21d7d0; // 0x21d90c - g_ps2RecompiledFunctionTable[292420] = bhDrawLinEffect_0x21d7d0; // 0x21d918 - g_ps2RecompiledFunctionTable[292424] = bhDrawLinEffect_0x21d7d0; // 0x21d928 - g_ps2RecompiledFunctionTable[292427] = bhDrawLinEffect_0x21d7d0; // 0x21d934 - g_ps2RecompiledFunctionTable[292430] = bhDrawLinEffect_0x21d7d0; // 0x21d940 - g_ps2RecompiledFunctionTable[292432] = bhDrawLinEffect_0x21d7d0; // 0x21d948 - g_ps2RecompiledFunctionTable[292442] = bhDrawNtxEffect3D_0x21d970; // 0x21d970 - g_ps2RecompiledFunctionTable[292451] = bhDrawNtxEffect3D_0x21d970; // 0x21d994 - g_ps2RecompiledFunctionTable[292454] = bhDrawNtxEffect3D_0x21d970; // 0x21d9a0 - g_ps2RecompiledFunctionTable[292456] = bhDrawNtxEffect3D_0x21d970; // 0x21d9a8 - g_ps2RecompiledFunctionTable[292478] = bhDrawNtxEffect3D_0x21d970; // 0x21da00 - g_ps2RecompiledFunctionTable[292486] = bhDrawNtxEffect3D_0x21d970; // 0x21da20 - g_ps2RecompiledFunctionTable[292491] = bhDrawNtxEffect3D_0x21d970; // 0x21da34 - g_ps2RecompiledFunctionTable[292494] = bhDrawNtxEffect3D_0x21d970; // 0x21da40 - g_ps2RecompiledFunctionTable[292505] = bhDrawNtxEffect3D_0x21d970; // 0x21da6c - g_ps2RecompiledFunctionTable[292507] = bhDrawNtxEffect3D_0x21d970; // 0x21da74 - g_ps2RecompiledFunctionTable[292510] = bhDrawNtxEffect3D_0x21d970; // 0x21da80 - g_ps2RecompiledFunctionTable[292512] = bhDrawNtxEffect3D_0x21d970; // 0x21da88 - g_ps2RecompiledFunctionTable[292525] = bhDrawNtxEffect3D_0x21d970; // 0x21dabc - g_ps2RecompiledFunctionTable[292530] = bhDrawNtxEffect3D_0x21d970; // 0x21dad0 - g_ps2RecompiledFunctionTable[292535] = bhDrawNtxEffect3D_0x21d970; // 0x21dae4 - g_ps2RecompiledFunctionTable[292538] = bhDrawNtxEffect3D_0x21d970; // 0x21daf0 - g_ps2RecompiledFunctionTable[292541] = bhDrawNtxEffect3D_0x21d970; // 0x21dafc - g_ps2RecompiledFunctionTable[292548] = bhDrawNtxEffect3D_0x21d970; // 0x21db18 - g_ps2RecompiledFunctionTable[292551] = bhDrawNtxEffect3D_0x21d970; // 0x21db24 - g_ps2RecompiledFunctionTable[292568] = bhDrawNtxEffect3D_0x21d970; // 0x21db68 - g_ps2RecompiledFunctionTable[292581] = bhDrawNtxEffect3D_0x21d970; // 0x21db9c - g_ps2RecompiledFunctionTable[292585] = bhDrawNtxEffect3D_0x21d970; // 0x21dbac - g_ps2RecompiledFunctionTable[292594] = bhDrawNtxEffect3D_0x21d970; // 0x21dbd0 - g_ps2RecompiledFunctionTable[292599] = bhDrawNtxEffect3D_0x21d970; // 0x21dbe4 - g_ps2RecompiledFunctionTable[292604] = bhDrawNtxEffect3D_0x21d970; // 0x21dbf8 - g_ps2RecompiledFunctionTable[292608] = bhDrawNtxEffect3D_0x21d970; // 0x21dc08 - g_ps2RecompiledFunctionTable[292613] = bhDrawNtxEffect3D_0x21d970; // 0x21dc1c - g_ps2RecompiledFunctionTable[292618] = bhDrawNtxEffect3D_0x21d970; // 0x21dc30 - g_ps2RecompiledFunctionTable[292623] = bhDrawNtxEffect3D_0x21d970; // 0x21dc44 - g_ps2RecompiledFunctionTable[292625] = bhDrawNtxEffect3D_0x21d970; // 0x21dc4c - g_ps2RecompiledFunctionTable[292636] = bhDrawNtxEffect3D_0x21d970; // 0x21dc78 - g_ps2RecompiledFunctionTable[292645] = bhDrawNtxEffect3D_0x21d970; // 0x21dc9c - g_ps2RecompiledFunctionTable[292648] = bhDrawNtxEffect3D_0x21d970; // 0x21dca8 - g_ps2RecompiledFunctionTable[292651] = bhDrawNtxEffect3D_0x21d970; // 0x21dcb4 - g_ps2RecompiledFunctionTable[292654] = bhDrawNtxEffect3D_0x21d970; // 0x21dcc0 - g_ps2RecompiledFunctionTable[292657] = bhDrawNtxEffect3D_0x21d970; // 0x21dccc - g_ps2RecompiledFunctionTable[292659] = bhDrawNtxEffect3D_0x21d970; // 0x21dcd4 - g_ps2RecompiledFunctionTable[292666] = bhDrawNtxEffect3D_0x21d970; // 0x21dcf0 - g_ps2RecompiledFunctionTable[292674] = bhDrawTrsEffect3D_0x21dd10; // 0x21dd10 - g_ps2RecompiledFunctionTable[292684] = bhDrawTrsEffect3D_0x21dd10; // 0x21dd38 - g_ps2RecompiledFunctionTable[292686] = bhDrawTrsEffect3D_0x21dd10; // 0x21dd40 - g_ps2RecompiledFunctionTable[292748] = bhDrawTrsEffect3D_0x21dd10; // 0x21de38 - g_ps2RecompiledFunctionTable[292756] = bhDrawTrsEffect3D_0x21dd10; // 0x21de58 - g_ps2RecompiledFunctionTable[292761] = bhDrawTrsEffect3D_0x21dd10; // 0x21de6c - g_ps2RecompiledFunctionTable[292769] = bhDrawTrsEffect3D_0x21dd10; // 0x21de8c - g_ps2RecompiledFunctionTable[292781] = bhDrawTrsEffect3D_0x21dd10; // 0x21debc - g_ps2RecompiledFunctionTable[292792] = bhDrawTrsEffect3D_0x21dd10; // 0x21dee8 - g_ps2RecompiledFunctionTable[292796] = bhDrawTrsEffect3D_0x21dd10; // 0x21def8 - g_ps2RecompiledFunctionTable[292800] = bhDrawTrsEffect3D_0x21dd10; // 0x21df08 - g_ps2RecompiledFunctionTable[292802] = bhDrawTrsEffect3D_0x21dd10; // 0x21df10 - g_ps2RecompiledFunctionTable[292813] = bhDrawTrsEffect3D_0x21dd10; // 0x21df3c - g_ps2RecompiledFunctionTable[292815] = bhDrawTrsEffect3D_0x21dd10; // 0x21df44 - g_ps2RecompiledFunctionTable[292818] = bhDrawTrsEffect3D_0x21dd10; // 0x21df50 - g_ps2RecompiledFunctionTable[292820] = bhDrawTrsEffect3D_0x21dd10; // 0x21df58 - g_ps2RecompiledFunctionTable[292833] = bhDrawTrsEffect3D_0x21dd10; // 0x21df8c - g_ps2RecompiledFunctionTable[292838] = bhDrawTrsEffect3D_0x21dd10; // 0x21dfa0 - g_ps2RecompiledFunctionTable[292843] = bhDrawTrsEffect3D_0x21dd10; // 0x21dfb4 - g_ps2RecompiledFunctionTable[292846] = bhDrawTrsEffect3D_0x21dd10; // 0x21dfc0 - g_ps2RecompiledFunctionTable[292849] = bhDrawTrsEffect3D_0x21dd10; // 0x21dfcc - g_ps2RecompiledFunctionTable[292856] = bhDrawTrsEffect3D_0x21dd10; // 0x21dfe8 - g_ps2RecompiledFunctionTable[292859] = bhDrawTrsEffect3D_0x21dd10; // 0x21dff4 - g_ps2RecompiledFunctionTable[292876] = bhDrawTrsEffect3D_0x21dd10; // 0x21e038 - g_ps2RecompiledFunctionTable[292889] = bhDrawTrsEffect3D_0x21dd10; // 0x21e06c - g_ps2RecompiledFunctionTable[292893] = bhDrawTrsEffect3D_0x21dd10; // 0x21e07c - g_ps2RecompiledFunctionTable[292902] = bhDrawTrsEffect3D_0x21dd10; // 0x21e0a0 - g_ps2RecompiledFunctionTable[292907] = bhDrawTrsEffect3D_0x21dd10; // 0x21e0b4 - g_ps2RecompiledFunctionTable[292912] = bhDrawTrsEffect3D_0x21dd10; // 0x21e0c8 - g_ps2RecompiledFunctionTable[292916] = bhDrawTrsEffect3D_0x21dd10; // 0x21e0d8 - g_ps2RecompiledFunctionTable[292921] = bhDrawTrsEffect3D_0x21dd10; // 0x21e0ec - g_ps2RecompiledFunctionTable[292926] = bhDrawTrsEffect3D_0x21dd10; // 0x21e100 - g_ps2RecompiledFunctionTable[292931] = bhDrawTrsEffect3D_0x21dd10; // 0x21e114 - g_ps2RecompiledFunctionTable[292933] = bhDrawTrsEffect3D_0x21dd10; // 0x21e11c - g_ps2RecompiledFunctionTable[292944] = bhDrawTrsEffect3D_0x21dd10; // 0x21e148 - g_ps2RecompiledFunctionTable[292953] = bhDrawTrsEffect3D_0x21dd10; // 0x21e16c - g_ps2RecompiledFunctionTable[292956] = bhDrawTrsEffect3D_0x21dd10; // 0x21e178 - g_ps2RecompiledFunctionTable[292970] = bhDrawTrsEffect3D_0x21dd10; // 0x21e1b0 - g_ps2RecompiledFunctionTable[292976] = bhDrawTrsEffect3D_0x21dd10; // 0x21e1c8 - g_ps2RecompiledFunctionTable[292979] = bhDrawTrsEffect3D_0x21dd10; // 0x21e1d4 - g_ps2RecompiledFunctionTable[292982] = bhDrawTrsEffect3D_0x21dd10; // 0x21e1e0 - g_ps2RecompiledFunctionTable[292984] = bhDrawTrsEffect3D_0x21dd10; // 0x21e1e8 - g_ps2RecompiledFunctionTable[292994] = bhDrawOpqEffect3D_0x21e210; // 0x21e210 - g_ps2RecompiledFunctionTable[293004] = bhDrawOpqEffect3D_0x21e210; // 0x21e238 - g_ps2RecompiledFunctionTable[293007] = bhDrawOpqEffect3D_0x21e210; // 0x21e244 - g_ps2RecompiledFunctionTable[293010] = bhDrawOpqEffect3D_0x21e210; // 0x21e250 - g_ps2RecompiledFunctionTable[293012] = bhDrawOpqEffect3D_0x21e210; // 0x21e258 - g_ps2RecompiledFunctionTable[293038] = bhDrawOpqEffect3D_0x21e210; // 0x21e2c0 - g_ps2RecompiledFunctionTable[293046] = bhDrawOpqEffect3D_0x21e210; // 0x21e2e0 - g_ps2RecompiledFunctionTable[293051] = bhDrawOpqEffect3D_0x21e210; // 0x21e2f4 - g_ps2RecompiledFunctionTable[293059] = bhDrawOpqEffect3D_0x21e210; // 0x21e314 - g_ps2RecompiledFunctionTable[293071] = bhDrawOpqEffect3D_0x21e210; // 0x21e344 - g_ps2RecompiledFunctionTable[293082] = bhDrawOpqEffect3D_0x21e210; // 0x21e370 - g_ps2RecompiledFunctionTable[293086] = bhDrawOpqEffect3D_0x21e210; // 0x21e380 - g_ps2RecompiledFunctionTable[293090] = bhDrawOpqEffect3D_0x21e210; // 0x21e390 - g_ps2RecompiledFunctionTable[293092] = bhDrawOpqEffect3D_0x21e210; // 0x21e398 - g_ps2RecompiledFunctionTable[293103] = bhDrawOpqEffect3D_0x21e210; // 0x21e3c4 - g_ps2RecompiledFunctionTable[293105] = bhDrawOpqEffect3D_0x21e210; // 0x21e3cc - g_ps2RecompiledFunctionTable[293108] = bhDrawOpqEffect3D_0x21e210; // 0x21e3d8 - g_ps2RecompiledFunctionTable[293110] = bhDrawOpqEffect3D_0x21e210; // 0x21e3e0 - g_ps2RecompiledFunctionTable[293123] = bhDrawOpqEffect3D_0x21e210; // 0x21e414 - g_ps2RecompiledFunctionTable[293128] = bhDrawOpqEffect3D_0x21e210; // 0x21e428 - g_ps2RecompiledFunctionTable[293133] = bhDrawOpqEffect3D_0x21e210; // 0x21e43c - g_ps2RecompiledFunctionTable[293136] = bhDrawOpqEffect3D_0x21e210; // 0x21e448 - g_ps2RecompiledFunctionTable[293139] = bhDrawOpqEffect3D_0x21e210; // 0x21e454 - g_ps2RecompiledFunctionTable[293146] = bhDrawOpqEffect3D_0x21e210; // 0x21e470 - g_ps2RecompiledFunctionTable[293149] = bhDrawOpqEffect3D_0x21e210; // 0x21e47c - g_ps2RecompiledFunctionTable[293166] = bhDrawOpqEffect3D_0x21e210; // 0x21e4c0 - g_ps2RecompiledFunctionTable[293179] = bhDrawOpqEffect3D_0x21e210; // 0x21e4f4 - g_ps2RecompiledFunctionTable[293183] = bhDrawOpqEffect3D_0x21e210; // 0x21e504 - g_ps2RecompiledFunctionTable[293192] = bhDrawOpqEffect3D_0x21e210; // 0x21e528 - g_ps2RecompiledFunctionTable[293197] = bhDrawOpqEffect3D_0x21e210; // 0x21e53c - g_ps2RecompiledFunctionTable[293202] = bhDrawOpqEffect3D_0x21e210; // 0x21e550 - g_ps2RecompiledFunctionTable[293206] = bhDrawOpqEffect3D_0x21e210; // 0x21e560 - g_ps2RecompiledFunctionTable[293211] = bhDrawOpqEffect3D_0x21e210; // 0x21e574 - g_ps2RecompiledFunctionTable[293216] = bhDrawOpqEffect3D_0x21e210; // 0x21e588 - g_ps2RecompiledFunctionTable[293221] = bhDrawOpqEffect3D_0x21e210; // 0x21e59c - g_ps2RecompiledFunctionTable[293223] = bhDrawOpqEffect3D_0x21e210; // 0x21e5a4 - g_ps2RecompiledFunctionTable[293234] = bhDrawOpqEffect3D_0x21e210; // 0x21e5d0 - g_ps2RecompiledFunctionTable[293248] = bhDrawOpqEffect3D_0x21e210; // 0x21e608 - g_ps2RecompiledFunctionTable[293254] = bhDrawOpqEffect3D_0x21e210; // 0x21e620 - g_ps2RecompiledFunctionTable[293256] = bhDrawOpqEffect3D_0x21e210; // 0x21e628 - g_ps2RecompiledFunctionTable[293266] = bhDrawThlEffect3D_0x21e650; // 0x21e650 - g_ps2RecompiledFunctionTable[293277] = bhDrawThlEffect3D_0x21e650; // 0x21e67c - g_ps2RecompiledFunctionTable[293279] = bhDrawThlEffect3D_0x21e650; // 0x21e684 - g_ps2RecompiledFunctionTable[293304] = bhDrawThlEffect3D_0x21e650; // 0x21e6e8 - g_ps2RecompiledFunctionTable[293312] = bhDrawThlEffect3D_0x21e650; // 0x21e708 - g_ps2RecompiledFunctionTable[293317] = bhDrawThlEffect3D_0x21e650; // 0x21e71c - g_ps2RecompiledFunctionTable[293328] = bhDrawThlEffect3D_0x21e650; // 0x21e748 - g_ps2RecompiledFunctionTable[293339] = bhDrawThlEffect3D_0x21e650; // 0x21e774 - g_ps2RecompiledFunctionTable[293343] = bhDrawThlEffect3D_0x21e650; // 0x21e784 - g_ps2RecompiledFunctionTable[293347] = bhDrawThlEffect3D_0x21e650; // 0x21e794 - g_ps2RecompiledFunctionTable[293350] = bhDrawThlEffect3D_0x21e650; // 0x21e7a0 - g_ps2RecompiledFunctionTable[293361] = bhDrawThlEffect3D_0x21e650; // 0x21e7cc - g_ps2RecompiledFunctionTable[293363] = bhDrawThlEffect3D_0x21e650; // 0x21e7d4 - g_ps2RecompiledFunctionTable[293366] = bhDrawThlEffect3D_0x21e650; // 0x21e7e0 - g_ps2RecompiledFunctionTable[293368] = bhDrawThlEffect3D_0x21e650; // 0x21e7e8 - g_ps2RecompiledFunctionTable[293381] = bhDrawThlEffect3D_0x21e650; // 0x21e81c - g_ps2RecompiledFunctionTable[293386] = bhDrawThlEffect3D_0x21e650; // 0x21e830 - g_ps2RecompiledFunctionTable[293391] = bhDrawThlEffect3D_0x21e650; // 0x21e844 - g_ps2RecompiledFunctionTable[293394] = bhDrawThlEffect3D_0x21e650; // 0x21e850 - g_ps2RecompiledFunctionTable[293397] = bhDrawThlEffect3D_0x21e650; // 0x21e85c - g_ps2RecompiledFunctionTable[293404] = bhDrawThlEffect3D_0x21e650; // 0x21e878 - g_ps2RecompiledFunctionTable[293407] = bhDrawThlEffect3D_0x21e650; // 0x21e884 - g_ps2RecompiledFunctionTable[293424] = bhDrawThlEffect3D_0x21e650; // 0x21e8c8 - g_ps2RecompiledFunctionTable[293437] = bhDrawThlEffect3D_0x21e650; // 0x21e8fc - g_ps2RecompiledFunctionTable[293441] = bhDrawThlEffect3D_0x21e650; // 0x21e90c - g_ps2RecompiledFunctionTable[293450] = bhDrawThlEffect3D_0x21e650; // 0x21e930 - g_ps2RecompiledFunctionTable[293454] = bhDrawThlEffect3D_0x21e650; // 0x21e940 - g_ps2RecompiledFunctionTable[293458] = bhDrawThlEffect3D_0x21e650; // 0x21e950 - g_ps2RecompiledFunctionTable[293462] = bhDrawThlEffect3D_0x21e650; // 0x21e960 - g_ps2RecompiledFunctionTable[293466] = bhDrawThlEffect3D_0x21e650; // 0x21e970 - g_ps2RecompiledFunctionTable[293470] = bhDrawThlEffect3D_0x21e650; // 0x21e980 - g_ps2RecompiledFunctionTable[293475] = bhDrawThlEffect3D_0x21e650; // 0x21e994 - g_ps2RecompiledFunctionTable[293477] = bhDrawThlEffect3D_0x21e650; // 0x21e99c - g_ps2RecompiledFunctionTable[293488] = bhDrawThlEffect3D_0x21e650; // 0x21e9c8 - g_ps2RecompiledFunctionTable[293501] = bhDrawThlEffect3D_0x21e650; // 0x21e9fc - g_ps2RecompiledFunctionTable[293507] = bhDrawThlEffect3D_0x21e650; // 0x21ea14 - g_ps2RecompiledFunctionTable[293512] = bhDrawThlEffect3D_0x21e650; // 0x21ea28 - g_ps2RecompiledFunctionTable[293516] = bhDrawThlEffect3D_0x21e650; // 0x21ea38 - g_ps2RecompiledFunctionTable[293520] = bhDrawThlEffect3D_0x21e650; // 0x21ea48 - g_ps2RecompiledFunctionTable[293522] = bhDrawThlEffect3D_0x21e650; // 0x21ea50 - g_ps2RecompiledFunctionTable[293531] = bhDrawThlEffect3D_0x21e650; // 0x21ea74 - g_ps2RecompiledFunctionTable[293533] = bhDrawThlEffect3D_0x21e650; // 0x21ea7c - g_ps2RecompiledFunctionTable[293537] = bhDrawThlEffect3D_0x21e650; // 0x21ea8c - g_ps2RecompiledFunctionTable[293549] = bhDrawThlEffect3D_0x21e650; // 0x21eabc - g_ps2RecompiledFunctionTable[293559] = bhDrawThlEffect3D_0x21e650; // 0x21eae4 - g_ps2RecompiledFunctionTable[293562] = bhDrawThlEffect3D_0x21e650; // 0x21eaf0 - g_ps2RecompiledFunctionTable[293566] = bhDrawThlEffect3D_0x21e650; // 0x21eb00 - g_ps2RecompiledFunctionTable[293571] = bhDrawThlEffect3D_0x21e650; // 0x21eb14 - g_ps2RecompiledFunctionTable[293574] = bhDrawThlEffect3D_0x21e650; // 0x21eb20 - g_ps2RecompiledFunctionTable[293578] = bhDrawThlEffect3D_0x21e650; // 0x21eb30 - g_ps2RecompiledFunctionTable[293581] = bhDrawThlEffect3D_0x21e650; // 0x21eb3c - g_ps2RecompiledFunctionTable[293584] = bhDrawThlEffect3D_0x21e650; // 0x21eb48 - g_ps2RecompiledFunctionTable[293586] = bhDrawThlEffect3D_0x21e650; // 0x21eb50 - g_ps2RecompiledFunctionTable[293598] = bhDrawNtxEffect2D_0x21eb80; // 0x21eb80 - g_ps2RecompiledFunctionTable[293607] = bhDrawNtxEffect2D_0x21eb80; // 0x21eba4 - g_ps2RecompiledFunctionTable[293632] = bhDrawNtxEffect2D_0x21eb80; // 0x21ec08 - g_ps2RecompiledFunctionTable[293642] = bhDrawTrsEffect2D_0x21ec30; // 0x21ec30 - g_ps2RecompiledFunctionTable[293652] = bhDrawTrsEffect2D_0x21ec30; // 0x21ec58 - g_ps2RecompiledFunctionTable[293682] = bhDrawTrsEffect2D_0x21ec30; // 0x21ecd0 - g_ps2RecompiledFunctionTable[293687] = bhDrawTrsEffect2D_0x21ec30; // 0x21ece4 - g_ps2RecompiledFunctionTable[293691] = bhDrawTrsEffect2D_0x21ec30; // 0x21ecf4 - g_ps2RecompiledFunctionTable[293694] = bhDrawTrsEffect2D_0x21ec30; // 0x21ed00 - g_ps2RecompiledFunctionTable[293699] = bhDrawTrsEffect2D_0x21ec30; // 0x21ed14 - g_ps2RecompiledFunctionTable[293702] = bhDrawTrsEffect2D_0x21ec30; // 0x21ed20 - g_ps2RecompiledFunctionTable[293705] = bhDrawTrsEffect2D_0x21ec30; // 0x21ed2c - g_ps2RecompiledFunctionTable[293718] = bhDrawThunder_0x21ed60; // 0x21ed60 - g_ps2RecompiledFunctionTable[293733] = bhDrawThunder_0x21ed60; // 0x21ed9c - g_ps2RecompiledFunctionTable[293752] = bhDrawThunder_0x21ed60; // 0x21ede8 - g_ps2RecompiledFunctionTable[293755] = bhDrawThunder_0x21ed60; // 0x21edf4 - g_ps2RecompiledFunctionTable[293759] = bhDrawThunder_0x21ed60; // 0x21ee04 - g_ps2RecompiledFunctionTable[293766] = setentry_0x21ee20; // 0x21ee20 - g_ps2RecompiledFunctionTable[293850] = effinit_0x21ef70; // 0x21ef70 - g_ps2RecompiledFunctionTable[293898] = effset_0x21f030; // 0x21f030 - g_ps2RecompiledFunctionTable[293958] = getuv_0x21f120; // 0x21f120 - g_ps2RecompiledFunctionTable[293987] = getuv_0x21f120; // 0x21f194 - g_ps2RecompiledFunctionTable[293997] = getuv_0x21f120; // 0x21f1bc - g_ps2RecompiledFunctionTable[294018] = bhEff150_0x21f210; // 0x21f210 - g_ps2RecompiledFunctionTable[294042] = bhEff150_0x21f210; // 0x21f270 - g_ps2RecompiledFunctionTable[294050] = bhEff151_0x21f290; // 0x21f290 - g_ps2RecompiledFunctionTable[294061] = bhEff151_0x21f290; // 0x21f2bc - g_ps2RecompiledFunctionTable[294145] = bhEff151_0x21f290; // 0x21f40c - g_ps2RecompiledFunctionTable[294166] = bhEff152_0x21f460; // 0x21f460 - g_ps2RecompiledFunctionTable[294196] = bhEff152_0x21f460; // 0x21f4d8 - g_ps2RecompiledFunctionTable[294201] = bhEff152_0x21f460; // 0x21f4ec - g_ps2RecompiledFunctionTable[294205] = bhEff152_0x21f460; // 0x21f4fc - g_ps2RecompiledFunctionTable[294220] = bhEff152_0x21f460; // 0x21f538 - g_ps2RecompiledFunctionTable[294222] = bhEff152_0x21f460; // 0x21f540 - g_ps2RecompiledFunctionTable[294234] = bhEff152_0x21f460; // 0x21f570 - g_ps2RecompiledFunctionTable[294263] = bhEff152_0x21f460; // 0x21f5e4 - g_ps2RecompiledFunctionTable[294275] = bhEff152_0x21f460; // 0x21f614 - g_ps2RecompiledFunctionTable[294304] = bhEff152_0x21f460; // 0x21f688 - g_ps2RecompiledFunctionTable[294316] = bhEff152_0x21f460; // 0x21f6b8 - g_ps2RecompiledFunctionTable[294430] = bhEff152_0x21f460; // 0x21f880 - g_ps2RecompiledFunctionTable[294462] = bhEff153_0x21f900; // 0x21f900 - g_ps2RecompiledFunctionTable[294479] = bhEff153_0x21f900; // 0x21f944 - g_ps2RecompiledFunctionTable[294496] = bhEff153_0x21f900; // 0x21f988 - g_ps2RecompiledFunctionTable[294542] = bhEff154_0x21fa40; // 0x21fa40 - g_ps2RecompiledFunctionTable[294577] = bhEff154_0x21fa40; // 0x21facc - g_ps2RecompiledFunctionTable[294599] = bhEff154_0x21fa40; // 0x21fb24 - g_ps2RecompiledFunctionTable[294621] = bhEff154_0x21fa40; // 0x21fb7c - g_ps2RecompiledFunctionTable[294644] = bhEff154_0x21fa40; // 0x21fbd8 - g_ps2RecompiledFunctionTable[294654] = bhEff155_0x21fc00; // 0x21fc00 - g_ps2RecompiledFunctionTable[294665] = bhEff155_0x21fc00; // 0x21fc2c - g_ps2RecompiledFunctionTable[294703] = bhEff155_0x21fc00; // 0x21fcc4 - g_ps2RecompiledFunctionTable[294726] = bhEff156_0x21fd20; // 0x21fd20 - g_ps2RecompiledFunctionTable[294747] = bhEff156_0x21fd20; // 0x21fd74 - g_ps2RecompiledFunctionTable[294754] = bhEff157_0x21fd90; // 0x21fd90 - g_ps2RecompiledFunctionTable[294765] = bhEff157_0x21fd90; // 0x21fdbc - g_ps2RecompiledFunctionTable[294771] = bhEff157_0x21fd90; // 0x21fdd4 - g_ps2RecompiledFunctionTable[294776] = bhEff157_0x21fd90; // 0x21fde8 - g_ps2RecompiledFunctionTable[294780] = bhEff157_0x21fd90; // 0x21fdf8 - g_ps2RecompiledFunctionTable[294820] = bhEff157_0x21fd90; // 0x21fe98 - g_ps2RecompiledFunctionTable[294842] = bhEff158_0x21fef0; // 0x21fef0 - g_ps2RecompiledFunctionTable[294871] = bhEff158_0x21fef0; // 0x21ff64 - g_ps2RecompiledFunctionTable[294878] = bhEff159_0x21ff80; // 0x21ff80 - g_ps2RecompiledFunctionTable[294901] = bhEff159_0x21ff80; // 0x21ffdc - g_ps2RecompiledFunctionTable[294920] = bhEff159_0x21ff80; // 0x220028 - g_ps2RecompiledFunctionTable[294940] = bhEff159_0x21ff80; // 0x220078 - g_ps2RecompiledFunctionTable[294960] = bhEff159_0x21ff80; // 0x2200c8 - g_ps2RecompiledFunctionTable[294980] = bhEff159_0x21ff80; // 0x220118 - g_ps2RecompiledFunctionTable[295049] = bhEff159_0x21ff80; // 0x22022c - g_ps2RecompiledFunctionTable[295070] = bhEff160_0x220280; // 0x220280 - g_ps2RecompiledFunctionTable[295094] = bhEff160_0x220280; // 0x2202e0 - g_ps2RecompiledFunctionTable[295102] = bhEff161_0x220300; // 0x220300 - g_ps2RecompiledFunctionTable[295113] = bhEff161_0x220300; // 0x22032c - g_ps2RecompiledFunctionTable[295119] = bhEff161_0x220300; // 0x220344 - g_ps2RecompiledFunctionTable[295124] = bhEff161_0x220300; // 0x220358 - g_ps2RecompiledFunctionTable[295128] = bhEff161_0x220300; // 0x220368 - g_ps2RecompiledFunctionTable[295221] = bhEff161_0x220300; // 0x2204dc - g_ps2RecompiledFunctionTable[295242] = bhEff162_0x220530; // 0x220530 - g_ps2RecompiledFunctionTable[295266] = bhEff162_0x220530; // 0x220590 - g_ps2RecompiledFunctionTable[295274] = bhEff163_0x2205b0; // 0x2205b0 - g_ps2RecompiledFunctionTable[295285] = bhEff163_0x2205b0; // 0x2205dc - g_ps2RecompiledFunctionTable[295296] = bhEff163_0x2205b0; // 0x220608 - g_ps2RecompiledFunctionTable[295302] = bhEff163_0x2205b0; // 0x220620 - g_ps2RecompiledFunctionTable[295305] = bhEff163_0x2205b0; // 0x22062c - g_ps2RecompiledFunctionTable[295317] = bhEff163_0x2205b0; // 0x22065c - g_ps2RecompiledFunctionTable[295322] = bhEff163_0x2205b0; // 0x220670 - g_ps2RecompiledFunctionTable[295326] = bhEff163_0x2205b0; // 0x220680 - g_ps2RecompiledFunctionTable[295335] = bhEff163_0x2205b0; // 0x2206a4 - g_ps2RecompiledFunctionTable[295392] = bhEff163_0x2205b0; // 0x220788 - g_ps2RecompiledFunctionTable[295415] = bhEff163_0x2205b0; // 0x2207e4 - g_ps2RecompiledFunctionTable[295438] = bhEff164_0x220840; // 0x220840 - g_ps2RecompiledFunctionTable[295469] = bhEff164_0x220840; // 0x2208bc - g_ps2RecompiledFunctionTable[295482] = bhEff165_0x2208f0; // 0x2208f0 - g_ps2RecompiledFunctionTable[295513] = bhEff165_0x2208f0; // 0x22096c - g_ps2RecompiledFunctionTable[295518] = bhEff165_0x2208f0; // 0x220980 - g_ps2RecompiledFunctionTable[295522] = bhEff165_0x2208f0; // 0x220990 - g_ps2RecompiledFunctionTable[295551] = bhEff165_0x2208f0; // 0x220a04 - g_ps2RecompiledFunctionTable[295581] = bhEff165_0x2208f0; // 0x220a7c - g_ps2RecompiledFunctionTable[295587] = bhEff165_0x2208f0; // 0x220a94 - g_ps2RecompiledFunctionTable[295592] = bhEff165_0x2208f0; // 0x220aa8 - g_ps2RecompiledFunctionTable[295596] = bhEff165_0x2208f0; // 0x220ab8 - g_ps2RecompiledFunctionTable[295604] = bhEff165_0x2208f0; // 0x220ad8 - g_ps2RecompiledFunctionTable[295654] = bhEff166_0x220ba0; // 0x220ba0 - g_ps2RecompiledFunctionTable[295682] = bhEff166_0x220ba0; // 0x220c10 - g_ps2RecompiledFunctionTable[295694] = bhEff167_0x220c40; // 0x220c40 - g_ps2RecompiledFunctionTable[295705] = bhEff167_0x220c40; // 0x220c6c - g_ps2RecompiledFunctionTable[295707] = bhEff167_0x220c40; // 0x220c74 - g_ps2RecompiledFunctionTable[295713] = bhEff167_0x220c40; // 0x220c8c - g_ps2RecompiledFunctionTable[295716] = bhEff167_0x220c40; // 0x220c98 - g_ps2RecompiledFunctionTable[295737] = bhEff167_0x220c40; // 0x220cec - g_ps2RecompiledFunctionTable[295758] = bhEff168_0x220d40; // 0x220d40 - g_ps2RecompiledFunctionTable[295782] = bhEff168_0x220d40; // 0x220da0 - g_ps2RecompiledFunctionTable[295790] = bhEff169_0x220dc0; // 0x220dc0 - g_ps2RecompiledFunctionTable[295801] = bhEff169_0x220dc0; // 0x220dec - g_ps2RecompiledFunctionTable[295803] = bhEff169_0x220dc0; // 0x220df4 - g_ps2RecompiledFunctionTable[295809] = bhEff169_0x220dc0; // 0x220e0c - g_ps2RecompiledFunctionTable[295824] = bhEff169_0x220dc0; // 0x220e48 - g_ps2RecompiledFunctionTable[295832] = bhEff169_0x220dc0; // 0x220e68 - g_ps2RecompiledFunctionTable[295841] = bhEff169_0x220dc0; // 0x220e8c - g_ps2RecompiledFunctionTable[295859] = bhEff169_0x220dc0; // 0x220ed4 - g_ps2RecompiledFunctionTable[295882] = bhEff170_0x220f30; // 0x220f30 - g_ps2RecompiledFunctionTable[295913] = bhEff170_0x220f30; // 0x220fac - g_ps2RecompiledFunctionTable[295918] = bhEff170_0x220f30; // 0x220fc0 - g_ps2RecompiledFunctionTable[295922] = bhEff170_0x220f30; // 0x220fd0 - g_ps2RecompiledFunctionTable[295954] = bhEff170_0x220f30; // 0x221050 - g_ps2RecompiledFunctionTable[295994] = bhEff170_0x220f30; // 0x2210f0 - g_ps2RecompiledFunctionTable[296000] = bhEff170_0x220f30; // 0x221108 - g_ps2RecompiledFunctionTable[296005] = bhEff170_0x220f30; // 0x22111c - g_ps2RecompiledFunctionTable[296009] = bhEff170_0x220f30; // 0x22112c - g_ps2RecompiledFunctionTable[296017] = bhEff170_0x220f30; // 0x22114c - g_ps2RecompiledFunctionTable[296074] = bhEff171_0x221230; // 0x221230 - g_ps2RecompiledFunctionTable[296085] = bhEff171_0x221230; // 0x22125c - g_ps2RecompiledFunctionTable[296120] = bhEff171_0x221230; // 0x2212e8 - g_ps2RecompiledFunctionTable[296142] = bhEff172_0x221340; // 0x221340 - g_ps2RecompiledFunctionTable[296166] = bhEff172_0x221340; // 0x2213a0 - g_ps2RecompiledFunctionTable[296174] = bhEff173_0x2213c0; // 0x2213c0 - g_ps2RecompiledFunctionTable[296185] = bhEff173_0x2213c0; // 0x2213ec - g_ps2RecompiledFunctionTable[296238] = bhEff173_0x2213c0; // 0x2214c0 - g_ps2RecompiledFunctionTable[296262] = bhEff174_0x221520; // 0x221520 - g_ps2RecompiledFunctionTable[296266] = bhEff175_0x221530; // 0x221530 - g_ps2RecompiledFunctionTable[296288] = bhEff175_0x221530; // 0x221588 - g_ps2RecompiledFunctionTable[296294] = bhEff176_0x2215a0; // 0x2215a0 - g_ps2RecompiledFunctionTable[296305] = bhEff176_0x2215a0; // 0x2215cc - g_ps2RecompiledFunctionTable[296317] = bhEff176_0x2215a0; // 0x2215fc - g_ps2RecompiledFunctionTable[296338] = bhEff177_0x221650; // 0x221650 - g_ps2RecompiledFunctionTable[296362] = bhEff177_0x221650; // 0x2216b0 - g_ps2RecompiledFunctionTable[296382] = bhEff178_0x221700; // 0x221700 - g_ps2RecompiledFunctionTable[296393] = bhEff178_0x221700; // 0x22172c - g_ps2RecompiledFunctionTable[296423] = bhEff178_0x221700; // 0x2217a4 - g_ps2RecompiledFunctionTable[296428] = bhEff178_0x221700; // 0x2217b8 - g_ps2RecompiledFunctionTable[296432] = bhEff178_0x221700; // 0x2217c8 - g_ps2RecompiledFunctionTable[296464] = bhEff178_0x221700; // 0x221848 - g_ps2RecompiledFunctionTable[296486] = bhEff179_0x2218a0; // 0x2218a0 - g_ps2RecompiledFunctionTable[296517] = bhEff179_0x2218a0; // 0x22191c - g_ps2RecompiledFunctionTable[296529] = bhEff179_0x2218a0; // 0x22194c - g_ps2RecompiledFunctionTable[296531] = bhEff179_0x2218a0; // 0x221954 - g_ps2RecompiledFunctionTable[296542] = bhEff180_0x221980; // 0x221980 - g_ps2RecompiledFunctionTable[296553] = bhEff180_0x221980; // 0x2219ac - g_ps2RecompiledFunctionTable[296585] = bhEff180_0x221980; // 0x221a2c - g_ps2RecompiledFunctionTable[296606] = bhEff181_0x221a80; // 0x221a80 - g_ps2RecompiledFunctionTable[296629] = bhEff181_0x221a80; // 0x221adc - g_ps2RecompiledFunctionTable[296639] = bhEff181_0x221a80; // 0x221b04 - g_ps2RecompiledFunctionTable[296649] = bhEff181_0x221a80; // 0x221b2c - g_ps2RecompiledFunctionTable[296651] = bhEff181_0x221a80; // 0x221b34 - g_ps2RecompiledFunctionTable[296653] = bhEff181_0x221a80; // 0x221b3c - g_ps2RecompiledFunctionTable[296662] = bhEff182_0x221b60; // 0x221b60 - g_ps2RecompiledFunctionTable[296696] = bhEff182_0x221b60; // 0x221be8 - g_ps2RecompiledFunctionTable[296707] = bhEff182_0x221b60; // 0x221c14 - g_ps2RecompiledFunctionTable[296710] = bhEff182_0x221b60; // 0x221c20 - g_ps2RecompiledFunctionTable[296715] = bhEff182_0x221b60; // 0x221c34 - g_ps2RecompiledFunctionTable[296719] = bhEff182_0x221b60; // 0x221c44 - g_ps2RecompiledFunctionTable[296748] = bhEff182_0x221b60; // 0x221cb8 - g_ps2RecompiledFunctionTable[296774] = bhEff183_0x221d20; // 0x221d20 - g_ps2RecompiledFunctionTable[296796] = bhEff183_0x221d20; // 0x221d78 - g_ps2RecompiledFunctionTable[296802] = bhEff184_0x221d90; // 0x221d90 - g_ps2RecompiledFunctionTable[296814] = bhEff184_0x221d90; // 0x221dc0 - g_ps2RecompiledFunctionTable[296828] = bhEff184_0x221d90; // 0x221df8 - g_ps2RecompiledFunctionTable[296833] = bhEff184_0x221d90; // 0x221e0c - g_ps2RecompiledFunctionTable[296837] = bhEff184_0x221d90; // 0x221e1c - g_ps2RecompiledFunctionTable[296856] = bhEff184_0x221d90; // 0x221e68 - g_ps2RecompiledFunctionTable[296868] = bhEff184_0x221d90; // 0x221e98 - g_ps2RecompiledFunctionTable[296885] = bhEff184_0x221d90; // 0x221edc - g_ps2RecompiledFunctionTable[296897] = bhEff184_0x221d90; // 0x221f0c - g_ps2RecompiledFunctionTable[296914] = bhEff184_0x221d90; // 0x221f50 - g_ps2RecompiledFunctionTable[296926] = bhEff184_0x221d90; // 0x221f80 - g_ps2RecompiledFunctionTable[297034] = bhEff184_0x221d90; // 0x222130 - g_ps2RecompiledFunctionTable[297057] = bhEff184_0x221d90; // 0x22218c - g_ps2RecompiledFunctionTable[297082] = bhEff185_0x2221f0; // 0x2221f0 - g_ps2RecompiledFunctionTable[297194] = bhEff186_0x2223b0; // 0x2223b0 - g_ps2RecompiledFunctionTable[297206] = bhEff186_0x2223b0; // 0x2223e0 - g_ps2RecompiledFunctionTable[297214] = bhEff186_0x2223b0; // 0x222400 - g_ps2RecompiledFunctionTable[297220] = bhEff186_0x2223b0; // 0x222418 - g_ps2RecompiledFunctionTable[297246] = bhEff186_0x2223b0; // 0x222480 - g_ps2RecompiledFunctionTable[297251] = bhEff186_0x2223b0; // 0x222494 - g_ps2RecompiledFunctionTable[297254] = bhEff186_0x2223b0; // 0x2224a0 - g_ps2RecompiledFunctionTable[297258] = bhEff186_0x2223b0; // 0x2224b0 - g_ps2RecompiledFunctionTable[297282] = bhEff187_0x222510; // 0x222510 - g_ps2RecompiledFunctionTable[297330] = bhEff187_0x222510; // 0x2225d0 - g_ps2RecompiledFunctionTable[297340] = bhEff187_0x222510; // 0x2225f8 - g_ps2RecompiledFunctionTable[297342] = bhEff187_0x222510; // 0x222600 - g_ps2RecompiledFunctionTable[297355] = bhEff187_0x222510; // 0x222634 - g_ps2RecompiledFunctionTable[297370] = bhEff187_0x222510; // 0x222670 - g_ps2RecompiledFunctionTable[297372] = bhEff187_0x222510; // 0x222678 - g_ps2RecompiledFunctionTable[297385] = bhEff187_0x222510; // 0x2226ac - g_ps2RecompiledFunctionTable[297397] = bhEff187_0x222510; // 0x2226dc - g_ps2RecompiledFunctionTable[297406] = bhEff188_0x222700; // 0x222700 - g_ps2RecompiledFunctionTable[297417] = bhEff188_0x222700; // 0x22272c - g_ps2RecompiledFunctionTable[297448] = bhEff188_0x222700; // 0x2227a8 - g_ps2RecompiledFunctionTable[297470] = bhEff189_0x222800; // 0x222800 - g_ps2RecompiledFunctionTable[297559] = bhEff189_0x222800; // 0x222964 - g_ps2RecompiledFunctionTable[297561] = bhEff189_0x222800; // 0x22296c - g_ps2RecompiledFunctionTable[297566] = bhEff189_0x222800; // 0x222980 - g_ps2RecompiledFunctionTable[297570] = bhEff189_0x222800; // 0x222990 - g_ps2RecompiledFunctionTable[297572] = bhEff189_0x222800; // 0x222998 - g_ps2RecompiledFunctionTable[297706] = bhEff190_0x222bb0; // 0x222bb0 - g_ps2RecompiledFunctionTable[297778] = bhEff190_0x222bb0; // 0x222cd0 - g_ps2RecompiledFunctionTable[297786] = bhEff191_0x222cf0; // 0x222cf0 - g_ps2RecompiledFunctionTable[297821] = bhEff191_0x222cf0; // 0x222d7c - g_ps2RecompiledFunctionTable[297823] = bhEff191_0x222cf0; // 0x222d84 - g_ps2RecompiledFunctionTable[297825] = bhEff191_0x222cf0; // 0x222d8c - g_ps2RecompiledFunctionTable[297838] = bhEff191_0x222cf0; // 0x222dc0 - g_ps2RecompiledFunctionTable[297845] = bhEff191_0x222cf0; // 0x222ddc - g_ps2RecompiledFunctionTable[297847] = bhEff191_0x222cf0; // 0x222de4 - g_ps2RecompiledFunctionTable[297860] = bhEff191_0x222cf0; // 0x222e18 - g_ps2RecompiledFunctionTable[297867] = bhEff191_0x222cf0; // 0x222e34 - g_ps2RecompiledFunctionTable[297871] = bhEff191_0x222cf0; // 0x222e44 - g_ps2RecompiledFunctionTable[297873] = bhEff191_0x222cf0; // 0x222e4c - g_ps2RecompiledFunctionTable[298054] = bhEff192_0x223120; // 0x223120 - g_ps2RecompiledFunctionTable[298111] = bhEff192_0x223120; // 0x223204 - g_ps2RecompiledFunctionTable[298115] = bhEff192_0x223120; // 0x223214 - g_ps2RecompiledFunctionTable[298130] = bhEff193_0x223250; // 0x223250 - g_ps2RecompiledFunctionTable[298156] = bhEff193_0x223250; // 0x2232b8 - g_ps2RecompiledFunctionTable[298161] = bhEff193_0x223250; // 0x2232cc - g_ps2RecompiledFunctionTable[298164] = bhEff193_0x223250; // 0x2232d8 - g_ps2RecompiledFunctionTable[298169] = bhEff193_0x223250; // 0x2232ec - g_ps2RecompiledFunctionTable[298172] = bhEff193_0x223250; // 0x2232f8 - g_ps2RecompiledFunctionTable[298177] = bhEff193_0x223250; // 0x22330c - g_ps2RecompiledFunctionTable[298189] = bhEff193_0x223250; // 0x22333c - g_ps2RecompiledFunctionTable[298202] = bhEff193_0x223250; // 0x223370 - g_ps2RecompiledFunctionTable[298204] = bhEff193_0x223250; // 0x223378 - g_ps2RecompiledFunctionTable[298207] = bhEff193_0x223250; // 0x223384 - g_ps2RecompiledFunctionTable[298210] = bhEff193_0x223250; // 0x223390 - g_ps2RecompiledFunctionTable[298212] = bhEff193_0x223250; // 0x223398 - g_ps2RecompiledFunctionTable[298225] = bhEff193_0x223250; // 0x2233cc - g_ps2RecompiledFunctionTable[298228] = bhEff193_0x223250; // 0x2233d8 - g_ps2RecompiledFunctionTable[298230] = bhEff193_0x223250; // 0x2233e0 - g_ps2RecompiledFunctionTable[298243] = bhEff193_0x223250; // 0x223414 - g_ps2RecompiledFunctionTable[298246] = bhEff193_0x223250; // 0x223420 - g_ps2RecompiledFunctionTable[298250] = bhEff193_0x223250; // 0x223430 - g_ps2RecompiledFunctionTable[298252] = bhEff193_0x223250; // 0x223438 - g_ps2RecompiledFunctionTable[298265] = bhEff193_0x223250; // 0x22346c - g_ps2RecompiledFunctionTable[298277] = bhEff193_0x223250; // 0x22349c - g_ps2RecompiledFunctionTable[298298] = bhEff193_0x223250; // 0x2234f0 - g_ps2RecompiledFunctionTable[298398] = bhEff194_0x223680; // 0x223680 - g_ps2RecompiledFunctionTable[298461] = bhEff194_0x223680; // 0x22377c - g_ps2RecompiledFunctionTable[298470] = bhEff195_0x2237a0; // 0x2237a0 - g_ps2RecompiledFunctionTable[298543] = bhEff195_0x2237a0; // 0x2238c4 - g_ps2RecompiledFunctionTable[298682] = bhEff196_0x223af0; // 0x223af0 - g_ps2RecompiledFunctionTable[298830] = bhEff197_0x223d40; // 0x223d40 - g_ps2RecompiledFunctionTable[298834] = bhEff198_0x223d50; // 0x223d50 - g_ps2RecompiledFunctionTable[298886] = bhEff199_0x223e20; // 0x223e20 - g_ps2RecompiledFunctionTable[298892] = bhEff199_0x223e20; // 0x223e38 - g_ps2RecompiledFunctionTable[298906] = bhEff199_0x223e20; // 0x223e70 - g_ps2RecompiledFunctionTable[298909] = bhEff199_0x223e20; // 0x223e7c - g_ps2RecompiledFunctionTable[298914] = bhEff199_0x223e20; // 0x223e90 - g_ps2RecompiledFunctionTable[298919] = bhEff199_0x223e20; // 0x223ea4 - g_ps2RecompiledFunctionTable[298924] = bhEff199_0x223e20; // 0x223eb8 - g_ps2RecompiledFunctionTable[298929] = bhEff199_0x223e20; // 0x223ecc - g_ps2RecompiledFunctionTable[298934] = bhEff199_0x223e20; // 0x223ee0 - g_ps2RecompiledFunctionTable[298939] = bhEff199_0x223e20; // 0x223ef4 - g_ps2RecompiledFunctionTable[298944] = bhEff199_0x223e20; // 0x223f08 - g_ps2RecompiledFunctionTable[298949] = bhEff199_0x223e20; // 0x223f1c - g_ps2RecompiledFunctionTable[298954] = bhEff199_0x223e20; // 0x223f30 - g_ps2RecompiledFunctionTable[298959] = bhEff199_0x223e20; // 0x223f44 - g_ps2RecompiledFunctionTable[298964] = bhEff199_0x223e20; // 0x223f58 - g_ps2RecompiledFunctionTable[298966] = bhEff199_0x223e20; // 0x223f60 - g_ps2RecompiledFunctionTable[298970] = bhEffDmy_0x223f70; // 0x223f70 - g_ps2RecompiledFunctionTable[298974] = bhEffFil_0x223f80; // 0x223f80 - g_ps2RecompiledFunctionTable[298995] = bhEffFil_0x223f80; // 0x223fd4 - g_ps2RecompiledFunctionTable[299158] = bhEffBG_0x224260; // 0x224260 - g_ps2RecompiledFunctionTable[299210] = bhEff2D_0x224330; // 0x224330 - g_ps2RecompiledFunctionTable[299233] = bhEff2D_0x224330; // 0x22438c - g_ps2RecompiledFunctionTable[299342] = bhEff000_0x224540; // 0x224540 - g_ps2RecompiledFunctionTable[299402] = bhEff000_0x224540; // 0x224630 - g_ps2RecompiledFunctionTable[299425] = bhEff000_0x224540; // 0x22468c - g_ps2RecompiledFunctionTable[299439] = bhEff000_0x224540; // 0x2246c4 - g_ps2RecompiledFunctionTable[299457] = bhEff000_0x224540; // 0x22470c - g_ps2RecompiledFunctionTable[299479] = bhEff000_0x224540; // 0x224764 - g_ps2RecompiledFunctionTable[299486] = bhEff000_0x224540; // 0x224780 - g_ps2RecompiledFunctionTable[299504] = bhEff000_0x224540; // 0x2247c8 - g_ps2RecompiledFunctionTable[299526] = bhEff000_0x224540; // 0x224820 - g_ps2RecompiledFunctionTable[299533] = bhEff000_0x224540; // 0x22483c - g_ps2RecompiledFunctionTable[299547] = bhEff000_0x224540; // 0x224874 - g_ps2RecompiledFunctionTable[299565] = bhEff000_0x224540; // 0x2248bc - g_ps2RecompiledFunctionTable[299587] = bhEff000_0x224540; // 0x224914 - g_ps2RecompiledFunctionTable[299594] = bhEff000_0x224540; // 0x224930 - g_ps2RecompiledFunctionTable[299612] = bhEff000_0x224540; // 0x224978 - g_ps2RecompiledFunctionTable[299629] = bhEff000_0x224540; // 0x2249bc - g_ps2RecompiledFunctionTable[299651] = bhEff000_0x224540; // 0x224a14 - g_ps2RecompiledFunctionTable[299658] = bhEff000_0x224540; // 0x224a30 - g_ps2RecompiledFunctionTable[299677] = bhEff000_0x224540; // 0x224a7c - g_ps2RecompiledFunctionTable[299691] = bhEff000_0x224540; // 0x224ab4 - g_ps2RecompiledFunctionTable[299710] = bhEff000_0x224540; // 0x224b00 - g_ps2RecompiledFunctionTable[299736] = bhEff000_0x224540; // 0x224b68 - g_ps2RecompiledFunctionTable[299750] = bhEff000_0x224540; // 0x224ba0 - g_ps2RecompiledFunctionTable[299768] = bhEff000_0x224540; // 0x224be8 - g_ps2RecompiledFunctionTable[299790] = bhEff000_0x224540; // 0x224c40 - g_ps2RecompiledFunctionTable[299800] = bhEff000_0x224540; // 0x224c68 - g_ps2RecompiledFunctionTable[299807] = bhEff000_0x224540; // 0x224c84 - g_ps2RecompiledFunctionTable[299826] = bhEff000_0x224540; // 0x224cd0 - g_ps2RecompiledFunctionTable[299839] = bhEff000_0x224540; // 0x224d04 - g_ps2RecompiledFunctionTable[299906] = bhEff000_0x224540; // 0x224e10 - g_ps2RecompiledFunctionTable[299912] = bhEff000_0x224540; // 0x224e28 - g_ps2RecompiledFunctionTable[299919] = bhEff000_0x224540; // 0x224e44 - g_ps2RecompiledFunctionTable[299953] = bhEff000_0x224540; // 0x224ecc - g_ps2RecompiledFunctionTable[299997] = bhEff000_0x224540; // 0x224f7c - g_ps2RecompiledFunctionTable[300005] = bhEff000_0x224540; // 0x224f9c - g_ps2RecompiledFunctionTable[300052] = bhEff000_0x224540; // 0x225058 - g_ps2RecompiledFunctionTable[300060] = bhEff000_0x224540; // 0x225078 - g_ps2RecompiledFunctionTable[300079] = bhEff000_0x224540; // 0x2250c4 - g_ps2RecompiledFunctionTable[300171] = bhEff000_0x224540; // 0x225234 - g_ps2RecompiledFunctionTable[300257] = bhEff000_0x224540; // 0x22538c - g_ps2RecompiledFunctionTable[300264] = bhEff000_0x224540; // 0x2253a8 - g_ps2RecompiledFunctionTable[300275] = bhEff000_0x224540; // 0x2253d4 - g_ps2RecompiledFunctionTable[300330] = bhEff000_0x224540; // 0x2254b0 - g_ps2RecompiledFunctionTable[300358] = bhEff000_0x224540; // 0x225520 - g_ps2RecompiledFunctionTable[300372] = bhEff000_0x224540; // 0x225558 - g_ps2RecompiledFunctionTable[300387] = bhEff000_0x224540; // 0x225594 - g_ps2RecompiledFunctionTable[300398] = bhEff000_0x224540; // 0x2255c0 - g_ps2RecompiledFunctionTable[300434] = bhEff001_0x225650; // 0x225650 - g_ps2RecompiledFunctionTable[300471] = bhEff001_0x225650; // 0x2256e4 - g_ps2RecompiledFunctionTable[300489] = bhEff001_0x225650; // 0x22572c - g_ps2RecompiledFunctionTable[300510] = bhEff001_0x225650; // 0x225780 - g_ps2RecompiledFunctionTable[300514] = bhEff001_0x225650; // 0x225790 - g_ps2RecompiledFunctionTable[300518] = bhEff001_0x225650; // 0x2257a0 - g_ps2RecompiledFunctionTable[300658] = bhEff002_0x2259d0; // 0x2259d0 - g_ps2RecompiledFunctionTable[300700] = bhEff002_0x2259d0; // 0x225a78 - g_ps2RecompiledFunctionTable[300712] = bhEff002_0x2259d0; // 0x225aa8 - g_ps2RecompiledFunctionTable[300721] = bhEff002_0x2259d0; // 0x225acc - g_ps2RecompiledFunctionTable[300729] = bhEff002_0x2259d0; // 0x225aec - g_ps2RecompiledFunctionTable[300731] = bhEff002_0x2259d0; // 0x225af4 - g_ps2RecompiledFunctionTable[300733] = bhEff002_0x2259d0; // 0x225afc - g_ps2RecompiledFunctionTable[300745] = bhEff002_0x2259d0; // 0x225b2c - g_ps2RecompiledFunctionTable[300754] = bhEff002_0x2259d0; // 0x225b50 - g_ps2RecompiledFunctionTable[300762] = bhEff002_0x2259d0; // 0x225b70 - g_ps2RecompiledFunctionTable[300764] = bhEff002_0x2259d0; // 0x225b78 - g_ps2RecompiledFunctionTable[300766] = bhEff002_0x2259d0; // 0x225b80 - g_ps2RecompiledFunctionTable[300778] = bhEff002_0x2259d0; // 0x225bb0 - g_ps2RecompiledFunctionTable[300787] = bhEff002_0x2259d0; // 0x225bd4 - g_ps2RecompiledFunctionTable[300795] = bhEff002_0x2259d0; // 0x225bf4 - g_ps2RecompiledFunctionTable[300797] = bhEff002_0x2259d0; // 0x225bfc - g_ps2RecompiledFunctionTable[300868] = bhEff002_0x2259d0; // 0x225d18 - g_ps2RecompiledFunctionTable[300880] = bhEff002_0x2259d0; // 0x225d48 - g_ps2RecompiledFunctionTable[300889] = bhEff002_0x2259d0; // 0x225d6c - g_ps2RecompiledFunctionTable[300897] = bhEff002_0x2259d0; // 0x225d8c - g_ps2RecompiledFunctionTable[300899] = bhEff002_0x2259d0; // 0x225d94 - g_ps2RecompiledFunctionTable[300901] = bhEff002_0x2259d0; // 0x225d9c - g_ps2RecompiledFunctionTable[300913] = bhEff002_0x2259d0; // 0x225dcc - g_ps2RecompiledFunctionTable[300921] = bhEff002_0x2259d0; // 0x225dec - g_ps2RecompiledFunctionTable[300929] = bhEff002_0x2259d0; // 0x225e0c - g_ps2RecompiledFunctionTable[300931] = bhEff002_0x2259d0; // 0x225e14 - g_ps2RecompiledFunctionTable[300933] = bhEff002_0x2259d0; // 0x225e1c - g_ps2RecompiledFunctionTable[300945] = bhEff002_0x2259d0; // 0x225e4c - g_ps2RecompiledFunctionTable[300954] = bhEff002_0x2259d0; // 0x225e70 - g_ps2RecompiledFunctionTable[300962] = bhEff002_0x2259d0; // 0x225e90 - g_ps2RecompiledFunctionTable[300964] = bhEff002_0x2259d0; // 0x225e98 - g_ps2RecompiledFunctionTable[300970] = bhEff002_0x2259d0; // 0x225eb0 - g_ps2RecompiledFunctionTable[300982] = bhEff002_0x2259d0; // 0x225ee0 - g_ps2RecompiledFunctionTable[300991] = bhEff002_0x2259d0; // 0x225f04 - g_ps2RecompiledFunctionTable[300999] = bhEff002_0x2259d0; // 0x225f24 - g_ps2RecompiledFunctionTable[301001] = bhEff002_0x2259d0; // 0x225f2c - g_ps2RecompiledFunctionTable[301005] = bhEff002_0x2259d0; // 0x225f3c - g_ps2RecompiledFunctionTable[301017] = bhEff002_0x2259d0; // 0x225f6c - g_ps2RecompiledFunctionTable[301026] = bhEff002_0x2259d0; // 0x225f90 - g_ps2RecompiledFunctionTable[301034] = bhEff002_0x2259d0; // 0x225fb0 - g_ps2RecompiledFunctionTable[301036] = bhEff002_0x2259d0; // 0x225fb8 - g_ps2RecompiledFunctionTable[301209] = bhEff002_0x2259d0; // 0x22626c - g_ps2RecompiledFunctionTable[301355] = bhEff002_0x2259d0; // 0x2264b4 - g_ps2RecompiledFunctionTable[301471] = bhEff002_0x2259d0; // 0x226684 - g_ps2RecompiledFunctionTable[301519] = bhEff002_0x2259d0; // 0x226744 - g_ps2RecompiledFunctionTable[301526] = bhEff002_0x2259d0; // 0x226760 - g_ps2RecompiledFunctionTable[301533] = bhEff002_0x2259d0; // 0x22677c - g_ps2RecompiledFunctionTable[301540] = bhEff002_0x2259d0; // 0x226798 - g_ps2RecompiledFunctionTable[301654] = bhDrawWeaponEffect_0x226960; // 0x226960 - g_ps2RecompiledFunctionTable[301671] = bhDrawWeaponEffect_0x226960; // 0x2269a4 - g_ps2RecompiledFunctionTable[301697] = bhDrawWeaponEffect_0x226960; // 0x226a0c - g_ps2RecompiledFunctionTable[301701] = bhDrawWeaponEffect_0x226960; // 0x226a1c - g_ps2RecompiledFunctionTable[301707] = bhDrawWeaponEffect_0x226960; // 0x226a34 - g_ps2RecompiledFunctionTable[301718] = bhDrawWeaponEffect_0x226960; // 0x226a60 - g_ps2RecompiledFunctionTable[301733] = bhDrawWeaponEffect_0x226960; // 0x226a9c - g_ps2RecompiledFunctionTable[301738] = bhDrawWeaponEffect_0x226960; // 0x226ab0 - g_ps2RecompiledFunctionTable[301740] = bhDrawWeaponEffect_0x226960; // 0x226ab8 - g_ps2RecompiledFunctionTable[301753] = bhDrawWeaponEffect_0x226960; // 0x226aec - g_ps2RecompiledFunctionTable[301758] = bhDrawWeaponEffect_0x226960; // 0x226b00 - g_ps2RecompiledFunctionTable[301763] = bhDrawWeaponEffect_0x226960; // 0x226b14 - g_ps2RecompiledFunctionTable[301767] = bhDrawWeaponEffect_0x226960; // 0x226b24 - g_ps2RecompiledFunctionTable[301770] = bhDrawWeaponEffect_0x226960; // 0x226b30 - g_ps2RecompiledFunctionTable[301773] = bhDrawWeaponEffect_0x226960; // 0x226b3c - g_ps2RecompiledFunctionTable[301776] = bhDrawWeaponEffect_0x226960; // 0x226b48 - g_ps2RecompiledFunctionTable[301780] = bhDrawWeaponEffect_0x226960; // 0x226b58 - g_ps2RecompiledFunctionTable[301814] = bhDrawWeaponEffect_0x226960; // 0x226be0 - g_ps2RecompiledFunctionTable[301850] = bhDrawWeaponEffect_0x226960; // 0x226c70 - g_ps2RecompiledFunctionTable[301858] = bhDrawWeaponEffect_0x226960; // 0x226c90 - g_ps2RecompiledFunctionTable[301929] = bhDrawWeaponEffect_0x226960; // 0x226dac - g_ps2RecompiledFunctionTable[301998] = bhDrawWeaponEffect_0x226960; // 0x226ec0 - g_ps2RecompiledFunctionTable[302022] = bhDrawWeaponEffect_0x226960; // 0x226f20 - g_ps2RecompiledFunctionTable[302039] = bhDrawWeaponEffect_0x226960; // 0x226f64 - g_ps2RecompiledFunctionTable[302046] = bhDrawWeaponEffect_0x226960; // 0x226f80 - g_ps2RecompiledFunctionTable[302133] = bhDrawWeaponEffect_0x226960; // 0x2270dc - g_ps2RecompiledFunctionTable[302207] = bhDrawWeaponEffect_0x226960; // 0x227204 - g_ps2RecompiledFunctionTable[302229] = bhDrawWeaponEffect_0x226960; // 0x22725c - g_ps2RecompiledFunctionTable[302243] = bhDrawWeaponEffect_0x226960; // 0x227294 - g_ps2RecompiledFunctionTable[302246] = bhDrawWeaponEffect_0x226960; // 0x2272a0 - g_ps2RecompiledFunctionTable[302249] = bhDrawWeaponEffect_0x226960; // 0x2272ac - g_ps2RecompiledFunctionTable[302371] = bhDrawWeaponEffect_0x226960; // 0x227494 - g_ps2RecompiledFunctionTable[302375] = bhDrawWeaponEffect_0x226960; // 0x2274a4 - g_ps2RecompiledFunctionTable[302379] = bhDrawWeaponEffect_0x226960; // 0x2274b4 - g_ps2RecompiledFunctionTable[302382] = bhDrawWeaponEffect_0x226960; // 0x2274c0 - g_ps2RecompiledFunctionTable[302388] = bhDrawWeaponEffect_0x226960; // 0x2274d8 - g_ps2RecompiledFunctionTable[302392] = bhDrawWeaponEffect_0x226960; // 0x2274e8 - g_ps2RecompiledFunctionTable[302396] = bhDrawWeaponEffect_0x226960; // 0x2274f8 - g_ps2RecompiledFunctionTable[302399] = bhDrawWeaponEffect_0x226960; // 0x227504 - g_ps2RecompiledFunctionTable[302416] = bhDrawWeaponEffect_0x226960; // 0x227548 - g_ps2RecompiledFunctionTable[302421] = bhDrawWeaponEffect_0x226960; // 0x22755c - g_ps2RecompiledFunctionTable[302424] = bhDrawWeaponEffect_0x226960; // 0x227568 - g_ps2RecompiledFunctionTable[302496] = bhDrawWeaponEffect_0x226960; // 0x227688 - g_ps2RecompiledFunctionTable[302499] = bhDrawWeaponEffect_0x226960; // 0x227694 - g_ps2RecompiledFunctionTable[302501] = bhDrawWeaponEffect_0x226960; // 0x22769c - g_ps2RecompiledFunctionTable[302504] = bhDrawWeaponEffect_0x226960; // 0x2276a8 - g_ps2RecompiledFunctionTable[302506] = bhDrawWeaponEffect_0x226960; // 0x2276b0 - g_ps2RecompiledFunctionTable[302509] = bhDrawWeaponEffect_0x226960; // 0x2276bc - g_ps2RecompiledFunctionTable[302520] = bhDrawWeaponEffect_0x226960; // 0x2276e8 - g_ps2RecompiledFunctionTable[302522] = bhDrawWeaponEffect_0x226960; // 0x2276f0 - g_ps2RecompiledFunctionTable[302544] = bhDrawWeaponEffect_0x226960; // 0x227748 - g_ps2RecompiledFunctionTable[302618] = bhDrawWeaponEffect_0x226960; // 0x227870 - g_ps2RecompiledFunctionTable[302621] = bhDrawWeaponEffect_0x226960; // 0x22787c - g_ps2RecompiledFunctionTable[302624] = bhDrawWeaponEffect_0x226960; // 0x227888 - g_ps2RecompiledFunctionTable[302627] = bhDrawWeaponEffect_0x226960; // 0x227894 - g_ps2RecompiledFunctionTable[302630] = bhDrawWeaponEffect_0x226960; // 0x2278a0 - g_ps2RecompiledFunctionTable[302634] = bhDrawWeaponEffect_0x226960; // 0x2278b0 - g_ps2RecompiledFunctionTable[302638] = bhDrawWeaponEffect_0x226960; // 0x2278c0 - g_ps2RecompiledFunctionTable[302640] = bhDrawWeaponEffect_0x226960; // 0x2278c8 - g_ps2RecompiledFunctionTable[302661] = bhDrawWeaponEffect_0x226960; // 0x22791c - g_ps2RecompiledFunctionTable[302668] = bhDrawWeaponEffect_0x226960; // 0x227938 - g_ps2RecompiledFunctionTable[302755] = bhDrawWeaponEffect_0x226960; // 0x227a94 - g_ps2RecompiledFunctionTable[302830] = bhDrawWeaponEffect_0x226960; // 0x227bc0 - g_ps2RecompiledFunctionTable[302853] = bhDrawWeaponEffect_0x226960; // 0x227c1c - g_ps2RecompiledFunctionTable[302867] = bhDrawWeaponEffect_0x226960; // 0x227c54 - g_ps2RecompiledFunctionTable[302870] = bhDrawWeaponEffect_0x226960; // 0x227c60 - g_ps2RecompiledFunctionTable[302873] = bhDrawWeaponEffect_0x226960; // 0x227c6c - g_ps2RecompiledFunctionTable[302995] = bhDrawWeaponEffect_0x226960; // 0x227e54 - g_ps2RecompiledFunctionTable[302999] = bhDrawWeaponEffect_0x226960; // 0x227e64 - g_ps2RecompiledFunctionTable[303003] = bhDrawWeaponEffect_0x226960; // 0x227e74 - g_ps2RecompiledFunctionTable[303006] = bhDrawWeaponEffect_0x226960; // 0x227e80 - g_ps2RecompiledFunctionTable[303012] = bhDrawWeaponEffect_0x226960; // 0x227e98 - g_ps2RecompiledFunctionTable[303016] = bhDrawWeaponEffect_0x226960; // 0x227ea8 - g_ps2RecompiledFunctionTable[303020] = bhDrawWeaponEffect_0x226960; // 0x227eb8 - g_ps2RecompiledFunctionTable[303023] = bhDrawWeaponEffect_0x226960; // 0x227ec4 - g_ps2RecompiledFunctionTable[303031] = bhDrawWeaponEffect_0x226960; // 0x227ee4 - g_ps2RecompiledFunctionTable[303034] = bhDrawWeaponEffect_0x226960; // 0x227ef0 - g_ps2RecompiledFunctionTable[303050] = bhEff003_0x227f30; // 0x227f30 - g_ps2RecompiledFunctionTable[303100] = bhEff003_0x227f30; // 0x227ff8 - g_ps2RecompiledFunctionTable[303111] = bhEff003_0x227f30; // 0x228024 - g_ps2RecompiledFunctionTable[303117] = bhEff003_0x227f30; // 0x22803c - g_ps2RecompiledFunctionTable[303136] = bhEff003_0x227f30; // 0x228088 - g_ps2RecompiledFunctionTable[303242] = bhEff004_0x228230; // 0x228230 - g_ps2RecompiledFunctionTable[303246] = bhEff005_0x228240; // 0x228240 - g_ps2RecompiledFunctionTable[303366] = bhEff006_0x228420; // 0x228420 - g_ps2RecompiledFunctionTable[303530] = bhEff007_0x2286b0; // 0x2286b0 - g_ps2RecompiledFunctionTable[303560] = bhEff007_0x2286b0; // 0x228728 - g_ps2RecompiledFunctionTable[303562] = bhEff007_0x2286b0; // 0x228730 - g_ps2RecompiledFunctionTable[303603] = bhEff007_0x2286b0; // 0x2287d4 - g_ps2RecompiledFunctionTable[303689] = bhEff007_0x2286b0; // 0x22892c - g_ps2RecompiledFunctionTable[303752] = bhEff007_0x2286b0; // 0x228a28 - g_ps2RecompiledFunctionTable[303818] = bhEff008_0x228b30; // 0x228b30 - g_ps2RecompiledFunctionTable[303946] = bhEff009_0x228d30; // 0x228d30 - g_ps2RecompiledFunctionTable[304110] = bhEff010_0x228fc0; // 0x228fc0 - g_ps2RecompiledFunctionTable[304242] = bhEff011_0x2291d0; // 0x2291d0 - g_ps2RecompiledFunctionTable[304292] = bhEff011_0x2291d0; // 0x229298 - g_ps2RecompiledFunctionTable[304300] = bhEff011_0x2291d0; // 0x2292b8 - g_ps2RecompiledFunctionTable[304427] = bhEff011_0x2291d0; // 0x2294b4 - g_ps2RecompiledFunctionTable[304435] = bhEff011_0x2291d0; // 0x2294d4 - g_ps2RecompiledFunctionTable[304572] = bhEff011_0x2291d0; // 0x2296f8 - g_ps2RecompiledFunctionTable[304579] = bhEff011_0x2291d0; // 0x229714 - g_ps2RecompiledFunctionTable[304675] = bhEff011_0x2291d0; // 0x229894 - g_ps2RecompiledFunctionTable[304682] = bhEff011_0x2291d0; // 0x2298b0 - g_ps2RecompiledFunctionTable[304746] = bhEff012_0x2299b0; // 0x2299b0 - g_ps2RecompiledFunctionTable[304797] = bhEff012_0x2299b0; // 0x229a7c - g_ps2RecompiledFunctionTable[304814] = bhEff012_0x2299b0; // 0x229ac0 - g_ps2RecompiledFunctionTable[304829] = bhEff012_0x2299b0; // 0x229afc - g_ps2RecompiledFunctionTable[304843] = bhEff012_0x2299b0; // 0x229b34 - g_ps2RecompiledFunctionTable[304857] = bhEff012_0x2299b0; // 0x229b6c - g_ps2RecompiledFunctionTable[304870] = bhEff012_0x2299b0; // 0x229ba0 - g_ps2RecompiledFunctionTable[304877] = bhEff012_0x2299b0; // 0x229bbc - g_ps2RecompiledFunctionTable[304884] = bhEff012_0x2299b0; // 0x229bd8 - g_ps2RecompiledFunctionTable[304978] = bhEff013_0x229d50; // 0x229d50 - g_ps2RecompiledFunctionTable[305021] = bhEff013_0x229d50; // 0x229dfc - g_ps2RecompiledFunctionTable[305029] = bhEff013_0x229d50; // 0x229e1c - g_ps2RecompiledFunctionTable[305043] = bhEff013_0x229d50; // 0x229e54 - g_ps2RecompiledFunctionTable[305072] = bhEff013_0x229d50; // 0x229ec8 - g_ps2RecompiledFunctionTable[305133] = bhEff013_0x229d50; // 0x229fbc - g_ps2RecompiledFunctionTable[305171] = bhEff013_0x229d50; // 0x22a054 - g_ps2RecompiledFunctionTable[305183] = bhEff013_0x229d50; // 0x22a084 - g_ps2RecompiledFunctionTable[305188] = bhEff013_0x229d50; // 0x22a098 - g_ps2RecompiledFunctionTable[305191] = bhEff013_0x229d50; // 0x22a0a4 - g_ps2RecompiledFunctionTable[305196] = bhEff013_0x229d50; // 0x22a0b8 - g_ps2RecompiledFunctionTable[305233] = bhEff013_0x229d50; // 0x22a14c - g_ps2RecompiledFunctionTable[305239] = bhEff013_0x229d50; // 0x22a164 - g_ps2RecompiledFunctionTable[305280] = bhEff013_0x229d50; // 0x22a208 - g_ps2RecompiledFunctionTable[305288] = bhEff013_0x229d50; // 0x22a228 - g_ps2RecompiledFunctionTable[305314] = bhEff013_0x229d50; // 0x22a290 - g_ps2RecompiledFunctionTable[305399] = bhEff013_0x229d50; // 0x22a3e4 - g_ps2RecompiledFunctionTable[305432] = bhEff013_0x229d50; // 0x22a468 - g_ps2RecompiledFunctionTable[305451] = bhEff013_0x229d50; // 0x22a4b4 - g_ps2RecompiledFunctionTable[305469] = bhEff013_0x229d50; // 0x22a4fc - g_ps2RecompiledFunctionTable[305475] = bhEff013_0x229d50; // 0x22a514 - g_ps2RecompiledFunctionTable[305480] = bhEff013_0x229d50; // 0x22a528 - g_ps2RecompiledFunctionTable[305509] = bhEff013_0x229d50; // 0x22a59c - g_ps2RecompiledFunctionTable[305530] = bhEff013_0x229d50; // 0x22a5f0 - g_ps2RecompiledFunctionTable[305571] = bhEff013_0x229d50; // 0x22a694 - g_ps2RecompiledFunctionTable[305606] = bhEff013_0x229d50; // 0x22a720 - g_ps2RecompiledFunctionTable[305619] = bhEff013_0x229d50; // 0x22a754 - g_ps2RecompiledFunctionTable[305628] = bhEff013_0x229d50; // 0x22a778 - g_ps2RecompiledFunctionTable[305703] = bhEff013_0x229d50; // 0x22a8a4 - g_ps2RecompiledFunctionTable[305779] = bhEff013_0x229d50; // 0x22a9d4 - g_ps2RecompiledFunctionTable[305856] = bhEff013_0x229d50; // 0x22ab08 - g_ps2RecompiledFunctionTable[305954] = bhEff013_0x229d50; // 0x22ac90 - g_ps2RecompiledFunctionTable[305990] = bhEff014_0x22ad20; // 0x22ad20 - g_ps2RecompiledFunctionTable[306194] = bhEff015_0x22b050; // 0x22b050 - g_ps2RecompiledFunctionTable[306409] = bhEff015_0x22b050; // 0x22b3ac - g_ps2RecompiledFunctionTable[306436] = bhEff015_0x22b050; // 0x22b418 - g_ps2RecompiledFunctionTable[306470] = bhEff015_0x22b050; // 0x22b4a0 - g_ps2RecompiledFunctionTable[306536] = bhEff015_0x22b050; // 0x22b5a8 - g_ps2RecompiledFunctionTable[306543] = bhEff015_0x22b050; // 0x22b5c4 - g_ps2RecompiledFunctionTable[306568] = bhEff015_0x22b050; // 0x22b628 - g_ps2RecompiledFunctionTable[306573] = bhEff015_0x22b050; // 0x22b63c - g_ps2RecompiledFunctionTable[306579] = bhEff015_0x22b050; // 0x22b654 - g_ps2RecompiledFunctionTable[306585] = bhEff015_0x22b050; // 0x22b66c - g_ps2RecompiledFunctionTable[306655] = bhEff015_0x22b050; // 0x22b784 - g_ps2RecompiledFunctionTable[306679] = bhEff015_0x22b050; // 0x22b7e4 - g_ps2RecompiledFunctionTable[306709] = bhEff015_0x22b050; // 0x22b85c - g_ps2RecompiledFunctionTable[306734] = bhEff016_0x22b8c0; // 0x22b8c0 - g_ps2RecompiledFunctionTable[306751] = bhEff016_0x22b8c0; // 0x22b904 - g_ps2RecompiledFunctionTable[306758] = bhEff017_0x22b920; // 0x22b920 - g_ps2RecompiledFunctionTable[306782] = bhEff018_0x22b980; // 0x22b980 - g_ps2RecompiledFunctionTable[306888] = bhEff018_0x22b980; // 0x22bb28 - g_ps2RecompiledFunctionTable[306901] = bhEff018_0x22b980; // 0x22bb5c - g_ps2RecompiledFunctionTable[306916] = bhEff018_0x22b980; // 0x22bb98 - g_ps2RecompiledFunctionTable[306919] = bhEff018_0x22b980; // 0x22bba4 - g_ps2RecompiledFunctionTable[307104] = bhEff018_0x22b980; // 0x22be88 - g_ps2RecompiledFunctionTable[307270] = bhEff019_0x22c120; // 0x22c120 - g_ps2RecompiledFunctionTable[307534] = bhDraw021_0x22c540; // 0x22c540 - g_ps2RecompiledFunctionTable[307544] = bhDraw021_0x22c540; // 0x22c568 - g_ps2RecompiledFunctionTable[307547] = bhDraw021_0x22c540; // 0x22c574 - g_ps2RecompiledFunctionTable[307586] = bhDraw021_0x22c540; // 0x22c610 - g_ps2RecompiledFunctionTable[307608] = bhDraw021_0x22c540; // 0x22c668 - g_ps2RecompiledFunctionTable[307630] = bhDraw021_0x22c540; // 0x22c6c0 - g_ps2RecompiledFunctionTable[307652] = bhDraw021_0x22c540; // 0x22c718 - g_ps2RecompiledFunctionTable[307662] = bhEff021_0x22c740; // 0x22c740 - g_ps2RecompiledFunctionTable[307702] = bhDraw022_0x22c7e0; // 0x22c7e0 - g_ps2RecompiledFunctionTable[307709] = bhDraw022_0x22c7e0; // 0x22c7fc - g_ps2RecompiledFunctionTable[307739] = bhDraw022_0x22c7e0; // 0x22c874 - g_ps2RecompiledFunctionTable[307747] = bhDraw022_0x22c7e0; // 0x22c894 - g_ps2RecompiledFunctionTable[307749] = bhDraw022_0x22c7e0; // 0x22c89c - g_ps2RecompiledFunctionTable[307751] = bhDraw022_0x22c7e0; // 0x22c8a4 - g_ps2RecompiledFunctionTable[307754] = bhDraw022_0x22c7e0; // 0x22c8b0 - g_ps2RecompiledFunctionTable[307757] = bhDraw022_0x22c7e0; // 0x22c8bc - g_ps2RecompiledFunctionTable[307761] = bhDraw022_0x22c7e0; // 0x22c8cc - g_ps2RecompiledFunctionTable[307817] = bhDraw022_0x22c7e0; // 0x22c9ac - g_ps2RecompiledFunctionTable[307819] = bhDraw022_0x22c7e0; // 0x22c9b4 - g_ps2RecompiledFunctionTable[307821] = bhDraw022_0x22c7e0; // 0x22c9bc - g_ps2RecompiledFunctionTable[307823] = bhDraw022_0x22c7e0; // 0x22c9c4 - g_ps2RecompiledFunctionTable[307828] = bhDraw022_0x22c7e0; // 0x22c9d8 - g_ps2RecompiledFunctionTable[307849] = bhDraw022_0x22c7e0; // 0x22ca2c - g_ps2RecompiledFunctionTable[307852] = bhDraw022_0x22c7e0; // 0x22ca38 - g_ps2RecompiledFunctionTable[307854] = bhDraw022_0x22c7e0; // 0x22ca40 - g_ps2RecompiledFunctionTable[307862] = bhEff022_0x22ca60; // 0x22ca60 - g_ps2RecompiledFunctionTable[307875] = bhEff022_0x22ca60; // 0x22ca94 - g_ps2RecompiledFunctionTable[307986] = bhEff022_0x22ca60; // 0x22cc50 - g_ps2RecompiledFunctionTable[307989] = bhEff022_0x22ca60; // 0x22cc5c - g_ps2RecompiledFunctionTable[307992] = bhEff022_0x22ca60; // 0x22cc68 - g_ps2RecompiledFunctionTable[307993] = bhEff022_0x22ca60; // 0x22cc6c - g_ps2RecompiledFunctionTable[307995] = bhEff022_0x22ca60; // 0x22cc74 - g_ps2RecompiledFunctionTable[307997] = bhEff022_0x22ca60; // 0x22cc7c - g_ps2RecompiledFunctionTable[308012] = bhEff022_0x22ca60; // 0x22ccb8 - g_ps2RecompiledFunctionTable[308015] = bhEff022_0x22ca60; // 0x22ccc4 - g_ps2RecompiledFunctionTable[308019] = bhEff022_0x22ca60; // 0x22ccd4 - g_ps2RecompiledFunctionTable[308028] = bhEff022_0x22ca60; // 0x22ccf8 - g_ps2RecompiledFunctionTable[308030] = bhEff022_0x22ca60; // 0x22cd00 - g_ps2RecompiledFunctionTable[308054] = bhEff023_0x22cd60; // 0x22cd60 - g_ps2RecompiledFunctionTable[308194] = bhEff023_0x22cd60; // 0x22cf90 - g_ps2RecompiledFunctionTable[308210] = bhEff023_0x22cd60; // 0x22cfd0 - g_ps2RecompiledFunctionTable[308226] = bhEff023_0x22cd60; // 0x22d010 - g_ps2RecompiledFunctionTable[308260] = bhEff023_0x22cd60; // 0x22d098 - g_ps2RecompiledFunctionTable[308295] = bhEff023_0x22cd60; // 0x22d124 - g_ps2RecompiledFunctionTable[308324] = bhEff023_0x22cd60; // 0x22d198 - g_ps2RecompiledFunctionTable[308339] = bhEff023_0x22cd60; // 0x22d1d4 - g_ps2RecompiledFunctionTable[308345] = bhEff023_0x22cd60; // 0x22d1ec - g_ps2RecompiledFunctionTable[308360] = bhEff023_0x22cd60; // 0x22d228 - g_ps2RecompiledFunctionTable[308367] = bhEff023_0x22cd60; // 0x22d244 - g_ps2RecompiledFunctionTable[308378] = bhEff023_0x22cd60; // 0x22d270 - g_ps2RecompiledFunctionTable[308382] = bhEff023_0x22cd60; // 0x22d280 - g_ps2RecompiledFunctionTable[308391] = bhEff023_0x22cd60; // 0x22d2a4 - g_ps2RecompiledFunctionTable[308490] = bhDraw024_0x22d430; // 0x22d430 - g_ps2RecompiledFunctionTable[308498] = bhDraw024_0x22d430; // 0x22d450 - g_ps2RecompiledFunctionTable[308546] = bhDraw024_0x22d430; // 0x22d510 - g_ps2RecompiledFunctionTable[308548] = bhDraw024_0x22d430; // 0x22d518 - g_ps2RecompiledFunctionTable[308550] = bhDraw024_0x22d430; // 0x22d520 - g_ps2RecompiledFunctionTable[308556] = bhDraw024_0x22d430; // 0x22d538 - g_ps2RecompiledFunctionTable[308560] = bhDraw024_0x22d430; // 0x22d548 - g_ps2RecompiledFunctionTable[308570] = bhDraw024_0x22d430; // 0x22d570 - g_ps2RecompiledFunctionTable[308573] = bhDraw024_0x22d430; // 0x22d57c - g_ps2RecompiledFunctionTable[308597] = bhDraw024_0x22d430; // 0x22d5dc - g_ps2RecompiledFunctionTable[308600] = bhDraw024_0x22d430; // 0x22d5e8 - g_ps2RecompiledFunctionTable[308648] = bhDraw024_0x22d430; // 0x22d6a8 - g_ps2RecompiledFunctionTable[308650] = bhDraw024_0x22d430; // 0x22d6b0 - g_ps2RecompiledFunctionTable[308652] = bhDraw024_0x22d430; // 0x22d6b8 - g_ps2RecompiledFunctionTable[308654] = bhDraw024_0x22d430; // 0x22d6c0 - g_ps2RecompiledFunctionTable[308658] = bhDraw024_0x22d430; // 0x22d6d0 - g_ps2RecompiledFunctionTable[308681] = bhDraw024_0x22d430; // 0x22d72c - g_ps2RecompiledFunctionTable[308684] = bhDraw024_0x22d430; // 0x22d738 - g_ps2RecompiledFunctionTable[308690] = bhDraw024_0x22d430; // 0x22d750 - g_ps2RecompiledFunctionTable[308698] = bhEff024_0x22d770; // 0x22d770 - g_ps2RecompiledFunctionTable[308713] = bhEff024_0x22d770; // 0x22d7ac - g_ps2RecompiledFunctionTable[308762] = bhEff024_0x22d770; // 0x22d870 - g_ps2RecompiledFunctionTable[308772] = bhEff024_0x22d770; // 0x22d898 - g_ps2RecompiledFunctionTable[308796] = bhEff024_0x22d770; // 0x22d8f8 - g_ps2RecompiledFunctionTable[308804] = bhEff024_0x22d770; // 0x22d918 - g_ps2RecompiledFunctionTable[308809] = bhEff024_0x22d770; // 0x22d92c - g_ps2RecompiledFunctionTable[308813] = bhEff024_0x22d770; // 0x22d93c - g_ps2RecompiledFunctionTable[308918] = bhEff024_0x22d770; // 0x22dae0 - g_ps2RecompiledFunctionTable[308942] = bhDraw025_0x22db40; // 0x22db40 - g_ps2RecompiledFunctionTable[308948] = bhDraw025_0x22db40; // 0x22db58 - g_ps2RecompiledFunctionTable[308954] = bhDraw025_0x22db40; // 0x22db70 - g_ps2RecompiledFunctionTable[308960] = bhDraw025_0x22db40; // 0x22db88 - g_ps2RecompiledFunctionTable[308962] = bhDraw025_0x22db40; // 0x22db90 - g_ps2RecompiledFunctionTable[308964] = bhDraw025_0x22db40; // 0x22db98 - g_ps2RecompiledFunctionTable[308967] = bhDraw025_0x22db40; // 0x22dba4 - g_ps2RecompiledFunctionTable[308970] = bhDraw025_0x22db40; // 0x22dbb0 - g_ps2RecompiledFunctionTable[308973] = bhDraw025_0x22db40; // 0x22dbbc - g_ps2RecompiledFunctionTable[309021] = bhDraw025_0x22db40; // 0x22dc7c - g_ps2RecompiledFunctionTable[309023] = bhDraw025_0x22db40; // 0x22dc84 - g_ps2RecompiledFunctionTable[309025] = bhDraw025_0x22db40; // 0x22dc8c - g_ps2RecompiledFunctionTable[309027] = bhDraw025_0x22db40; // 0x22dc94 - g_ps2RecompiledFunctionTable[309032] = bhDraw025_0x22db40; // 0x22dca8 - g_ps2RecompiledFunctionTable[309081] = bhDraw025_0x22db40; // 0x22dd6c - g_ps2RecompiledFunctionTable[309084] = bhDraw025_0x22db40; // 0x22dd78 - g_ps2RecompiledFunctionTable[309086] = bhDraw025_0x22db40; // 0x22dd80 - g_ps2RecompiledFunctionTable[309094] = bhEff025_0x22dda0; // 0x22dda0 - g_ps2RecompiledFunctionTable[309108] = bhEff025_0x22dda0; // 0x22ddd8 - g_ps2RecompiledFunctionTable[309115] = bhEff025_0x22dda0; // 0x22ddf4 - g_ps2RecompiledFunctionTable[309121] = bhEff025_0x22dda0; // 0x22de0c - g_ps2RecompiledFunctionTable[309138] = bhEff025_0x22dda0; // 0x22de50 - g_ps2RecompiledFunctionTable[309155] = bhEff025_0x22dda0; // 0x22de94 - g_ps2RecompiledFunctionTable[309172] = bhEff025_0x22dda0; // 0x22ded8 - g_ps2RecompiledFunctionTable[309185] = bhEff025_0x22dda0; // 0x22df0c - g_ps2RecompiledFunctionTable[309198] = bhEff025_0x22dda0; // 0x22df40 - g_ps2RecompiledFunctionTable[309212] = bhEff025_0x22dda0; // 0x22df78 - g_ps2RecompiledFunctionTable[309258] = bhEff026_0x22e030; // 0x22e030 - g_ps2RecompiledFunctionTable[309268] = bhEff026_0x22e030; // 0x22e058 - g_ps2RecompiledFunctionTable[309285] = bhEff026_0x22e030; // 0x22e09c - g_ps2RecompiledFunctionTable[309301] = bhEff026_0x22e030; // 0x22e0dc - g_ps2RecompiledFunctionTable[309321] = bhEff026_0x22e030; // 0x22e12c - g_ps2RecompiledFunctionTable[309338] = bhEff026_0x22e030; // 0x22e170 - g_ps2RecompiledFunctionTable[309367] = bhEff026_0x22e030; // 0x22e1e4 - g_ps2RecompiledFunctionTable[309373] = bhEff026_0x22e030; // 0x22e1fc - g_ps2RecompiledFunctionTable[309388] = bhEff026_0x22e030; // 0x22e238 - g_ps2RecompiledFunctionTable[309392] = bhEff026_0x22e030; // 0x22e248 - g_ps2RecompiledFunctionTable[309403] = bhEff026_0x22e030; // 0x22e274 - g_ps2RecompiledFunctionTable[309411] = bhEff026_0x22e030; // 0x22e294 - g_ps2RecompiledFunctionTable[309425] = bhEff026_0x22e030; // 0x22e2cc - g_ps2RecompiledFunctionTable[309436] = bhEff026_0x22e030; // 0x22e2f8 - g_ps2RecompiledFunctionTable[309438] = bhEff026_0x22e030; // 0x22e300 - g_ps2RecompiledFunctionTable[309452] = bhEff026_0x22e030; // 0x22e338 - g_ps2RecompiledFunctionTable[309460] = bhEff026_0x22e030; // 0x22e358 - g_ps2RecompiledFunctionTable[309474] = bhEff026_0x22e030; // 0x22e390 - g_ps2RecompiledFunctionTable[309485] = bhEff026_0x22e030; // 0x22e3bc - g_ps2RecompiledFunctionTable[309487] = bhEff026_0x22e030; // 0x22e3c4 - g_ps2RecompiledFunctionTable[309518] = bhDraw027_0x22e440; // 0x22e440 - g_ps2RecompiledFunctionTable[309524] = bhDraw027_0x22e440; // 0x22e458 - g_ps2RecompiledFunctionTable[309530] = bhDraw027_0x22e440; // 0x22e470 - g_ps2RecompiledFunctionTable[309536] = bhDraw027_0x22e440; // 0x22e488 - g_ps2RecompiledFunctionTable[309538] = bhDraw027_0x22e440; // 0x22e490 - g_ps2RecompiledFunctionTable[309540] = bhDraw027_0x22e440; // 0x22e498 - g_ps2RecompiledFunctionTable[309543] = bhDraw027_0x22e440; // 0x22e4a4 - g_ps2RecompiledFunctionTable[309546] = bhDraw027_0x22e440; // 0x22e4b0 - g_ps2RecompiledFunctionTable[309549] = bhDraw027_0x22e440; // 0x22e4bc - g_ps2RecompiledFunctionTable[309597] = bhDraw027_0x22e440; // 0x22e57c - g_ps2RecompiledFunctionTable[309599] = bhDraw027_0x22e440; // 0x22e584 - g_ps2RecompiledFunctionTable[309601] = bhDraw027_0x22e440; // 0x22e58c - g_ps2RecompiledFunctionTable[309603] = bhDraw027_0x22e440; // 0x22e594 - g_ps2RecompiledFunctionTable[309608] = bhDraw027_0x22e440; // 0x22e5a8 - g_ps2RecompiledFunctionTable[309663] = bhDraw027_0x22e440; // 0x22e684 - g_ps2RecompiledFunctionTable[309666] = bhDraw027_0x22e440; // 0x22e690 - g_ps2RecompiledFunctionTable[309668] = bhDraw027_0x22e440; // 0x22e698 - g_ps2RecompiledFunctionTable[309674] = bhEff027_0x22e6b0; // 0x22e6b0 - g_ps2RecompiledFunctionTable[309688] = bhEff027_0x22e6b0; // 0x22e6e8 - g_ps2RecompiledFunctionTable[309701] = bhEff027_0x22e6b0; // 0x22e71c - g_ps2RecompiledFunctionTable[309704] = bhEff027_0x22e6b0; // 0x22e728 - g_ps2RecompiledFunctionTable[309710] = bhEff027_0x22e6b0; // 0x22e740 - g_ps2RecompiledFunctionTable[309724] = bhEff027_0x22e6b0; // 0x22e778 - g_ps2RecompiledFunctionTable[309738] = bhEff027_0x22e6b0; // 0x22e7b0 - g_ps2RecompiledFunctionTable[309758] = bhEff027_0x22e6b0; // 0x22e800 - g_ps2RecompiledFunctionTable[309760] = bhEff027_0x22e6b0; // 0x22e808 - g_ps2RecompiledFunctionTable[309773] = bhEff027_0x22e6b0; // 0x22e83c - g_ps2RecompiledFunctionTable[309786] = bhEff027_0x22e6b0; // 0x22e870 - g_ps2RecompiledFunctionTable[309802] = bhEff027_0x22e6b0; // 0x22e8b0 - g_ps2RecompiledFunctionTable[309902] = bhEff027_0x22e6b0; // 0x22ea40 - g_ps2RecompiledFunctionTable[309911] = bhEff027_0x22e6b0; // 0x22ea64 - g_ps2RecompiledFunctionTable[309942] = bhEff028_0x22eae0; // 0x22eae0 - g_ps2RecompiledFunctionTable[309946] = bhEff029_0x22eaf0; // 0x22eaf0 - g_ps2RecompiledFunctionTable[309962] = bhEff100_0x22eb30; // 0x22eb30 - g_ps2RecompiledFunctionTable[309982] = bhEff100_0x22eb30; // 0x22eb80 - g_ps2RecompiledFunctionTable[309995] = bhEff100_0x22eb30; // 0x22ebb4 - g_ps2RecompiledFunctionTable[309997] = bhEff100_0x22eb30; // 0x22ebbc - g_ps2RecompiledFunctionTable[310020] = bhEff100_0x22eb30; // 0x22ec18 - g_ps2RecompiledFunctionTable[310033] = bhEff100_0x22eb30; // 0x22ec4c - g_ps2RecompiledFunctionTable[310086] = bhEff101_0x22ed20; // 0x22ed20 - g_ps2RecompiledFunctionTable[310162] = bhEff101_0x22ed20; // 0x22ee50 - g_ps2RecompiledFunctionTable[310166] = bhEff102_0x22ee60; // 0x22ee60 - g_ps2RecompiledFunctionTable[310195] = bhEff102_0x22ee60; // 0x22eed4 - g_ps2RecompiledFunctionTable[310211] = bhEff102_0x22ee60; // 0x22ef14 - g_ps2RecompiledFunctionTable[310224] = bhEff102_0x22ee60; // 0x22ef48 - g_ps2RecompiledFunctionTable[310233] = bhEff102_0x22ee60; // 0x22ef6c - g_ps2RecompiledFunctionTable[310243] = bhEff102_0x22ee60; // 0x22ef94 - g_ps2RecompiledFunctionTable[310266] = bhEff103_0x22eff0; // 0x22eff0 - g_ps2RecompiledFunctionTable[310287] = bhEff103_0x22eff0; // 0x22f044 - g_ps2RecompiledFunctionTable[310323] = bhEff103_0x22eff0; // 0x22f0d4 - g_ps2RecompiledFunctionTable[310344] = bhEff103_0x22eff0; // 0x22f128 - g_ps2RecompiledFunctionTable[310365] = bhEff103_0x22eff0; // 0x22f17c - g_ps2RecompiledFunctionTable[310417] = bhEff103_0x22eff0; // 0x22f24c - g_ps2RecompiledFunctionTable[310482] = bhEff103_0x22eff0; // 0x22f350 - g_ps2RecompiledFunctionTable[310486] = bhEff103_0x22eff0; // 0x22f360 - g_ps2RecompiledFunctionTable[310505] = bhEff103_0x22eff0; // 0x22f3ac - g_ps2RecompiledFunctionTable[310583] = bhEff103_0x22eff0; // 0x22f4e4 - g_ps2RecompiledFunctionTable[310590] = bhEff104_0x22f500; // 0x22f500 - g_ps2RecompiledFunctionTable[310604] = bhEff104_0x22f500; // 0x22f538 - g_ps2RecompiledFunctionTable[310640] = bhEff104_0x22f500; // 0x22f5c8 - g_ps2RecompiledFunctionTable[310661] = bhEff104_0x22f500; // 0x22f61c - g_ps2RecompiledFunctionTable[310682] = bhEff104_0x22f500; // 0x22f670 - g_ps2RecompiledFunctionTable[310720] = bhEff104_0x22f500; // 0x22f708 - g_ps2RecompiledFunctionTable[310739] = bhEff104_0x22f500; // 0x22f754 - g_ps2RecompiledFunctionTable[310756] = bhEff104_0x22f500; // 0x22f798 - g_ps2RecompiledFunctionTable[310778] = bhEff105_0x22f7f0; // 0x22f7f0 - g_ps2RecompiledFunctionTable[310802] = bhEff105_0x22f7f0; // 0x22f850 - g_ps2RecompiledFunctionTable[310822] = bhEff105_0x22f7f0; // 0x22f8a0 - g_ps2RecompiledFunctionTable[310844] = bhEff105_0x22f7f0; // 0x22f8f8 - g_ps2RecompiledFunctionTable[310869] = bhEff105_0x22f7f0; // 0x22f95c - g_ps2RecompiledFunctionTable[310887] = bhEff105_0x22f7f0; // 0x22f9a4 - g_ps2RecompiledFunctionTable[310900] = bhEff105_0x22f7f0; // 0x22f9d8 - g_ps2RecompiledFunctionTable[310912] = bhEff105_0x22f7f0; // 0x22fa08 - g_ps2RecompiledFunctionTable[310929] = bhEff105_0x22f7f0; // 0x22fa4c - g_ps2RecompiledFunctionTable[310933] = bhEff105_0x22f7f0; // 0x22fa5c - g_ps2RecompiledFunctionTable[310935] = bhEff105_0x22f7f0; // 0x22fa64 - g_ps2RecompiledFunctionTable[310946] = bhEff106_0x22fa90; // 0x22fa90 - g_ps2RecompiledFunctionTable[310952] = bhEff106_0x22fa90; // 0x22faa8 - g_ps2RecompiledFunctionTable[310955] = bhEff106_0x22fa90; // 0x22fab4 - g_ps2RecompiledFunctionTable[310958] = bhEff106_0x22fa90; // 0x22fac0 - g_ps2RecompiledFunctionTable[310973] = bhEff106_0x22fa90; // 0x22fafc - g_ps2RecompiledFunctionTable[310990] = bhEff106_0x22fa90; // 0x22fb40 - g_ps2RecompiledFunctionTable[310993] = bhEff106_0x22fa90; // 0x22fb4c - g_ps2RecompiledFunctionTable[311004] = bhEff106_0x22fa90; // 0x22fb78 - g_ps2RecompiledFunctionTable[311029] = bhEff106_0x22fa90; // 0x22fbdc - g_ps2RecompiledFunctionTable[311053] = bhEff106_0x22fa90; // 0x22fc3c - g_ps2RecompiledFunctionTable[311080] = bhEff106_0x22fa90; // 0x22fca8 - g_ps2RecompiledFunctionTable[311082] = bhEff106_0x22fa90; // 0x22fcb0 - g_ps2RecompiledFunctionTable[311090] = bhEff106_0x22fa90; // 0x22fcd0 - g_ps2RecompiledFunctionTable[311094] = bhEff106_0x22fa90; // 0x22fce0 - g_ps2RecompiledFunctionTable[311100] = bhEff106_0x22fa90; // 0x22fcf8 - g_ps2RecompiledFunctionTable[311106] = bhDraw107_0x22fd10; // 0x22fd10 - g_ps2RecompiledFunctionTable[311112] = bhDraw107_0x22fd10; // 0x22fd28 - g_ps2RecompiledFunctionTable[311118] = bhDraw107_0x22fd10; // 0x22fd40 - g_ps2RecompiledFunctionTable[311124] = bhDraw107_0x22fd10; // 0x22fd58 - g_ps2RecompiledFunctionTable[311127] = bhDraw107_0x22fd10; // 0x22fd64 - g_ps2RecompiledFunctionTable[311130] = bhDraw107_0x22fd10; // 0x22fd70 - g_ps2RecompiledFunctionTable[311132] = bhDraw107_0x22fd10; // 0x22fd78 - g_ps2RecompiledFunctionTable[311138] = bhDraw107_0x22fd10; // 0x22fd90 - g_ps2RecompiledFunctionTable[311195] = bhDraw107_0x22fd10; // 0x22fe74 - g_ps2RecompiledFunctionTable[311197] = bhDraw107_0x22fd10; // 0x22fe7c - g_ps2RecompiledFunctionTable[311199] = bhDraw107_0x22fd10; // 0x22fe84 - g_ps2RecompiledFunctionTable[311204] = bhDraw107_0x22fd10; // 0x22fe98 - g_ps2RecompiledFunctionTable[311210] = bhDraw107_0x22fd10; // 0x22feb0 - g_ps2RecompiledFunctionTable[311218] = bhEff107_0x22fed0; // 0x22fed0 - g_ps2RecompiledFunctionTable[311228] = bhEff107_0x22fed0; // 0x22fef8 - g_ps2RecompiledFunctionTable[311241] = bhEff107_0x22fed0; // 0x22ff2c - g_ps2RecompiledFunctionTable[311243] = bhEff107_0x22fed0; // 0x22ff34 - g_ps2RecompiledFunctionTable[311266] = bhEff107_0x22fed0; // 0x22ff90 - g_ps2RecompiledFunctionTable[311292] = bhEff107_0x22fed0; // 0x22fff8 - g_ps2RecompiledFunctionTable[311350] = bhEff108_0x2300e0; // 0x2300e0 - g_ps2RecompiledFunctionTable[311412] = bhEff108_0x2300e0; // 0x2301d8 - g_ps2RecompiledFunctionTable[311415] = bhEff108_0x2300e0; // 0x2301e4 - g_ps2RecompiledFunctionTable[311418] = bhEff108_0x2300e0; // 0x2301f0 - g_ps2RecompiledFunctionTable[311426] = bhEff108_0x2300e0; // 0x230210 - g_ps2RecompiledFunctionTable[311750] = bhEff109_0x230720; // 0x230720 - g_ps2RecompiledFunctionTable[311783] = bhEff109_0x230720; // 0x2307a4 - g_ps2RecompiledFunctionTable[311805] = bhEff109_0x230720; // 0x2307fc - g_ps2RecompiledFunctionTable[311810] = bhEff110_0x230810; // 0x230810 - g_ps2RecompiledFunctionTable[311866] = bhEff110_0x230810; // 0x2308f0 - g_ps2RecompiledFunctionTable[311883] = bhEff110_0x230810; // 0x230934 - g_ps2RecompiledFunctionTable[311923] = bhEff110_0x230810; // 0x2309d4 - g_ps2RecompiledFunctionTable[311974] = bhEff110_0x230810; // 0x230aa0 - g_ps2RecompiledFunctionTable[311985] = bhEff110_0x230810; // 0x230acc - g_ps2RecompiledFunctionTable[312005] = bhEff110_0x230810; // 0x230b1c - g_ps2RecompiledFunctionTable[312010] = bhEff110_0x230810; // 0x230b30 - g_ps2RecompiledFunctionTable[312061] = bhEff110_0x230810; // 0x230bfc - g_ps2RecompiledFunctionTable[312070] = bhEff110_0x230810; // 0x230c20 - g_ps2RecompiledFunctionTable[312147] = bhEff110_0x230810; // 0x230d54 - g_ps2RecompiledFunctionTable[312168] = bhEff110_0x230810; // 0x230da8 - g_ps2RecompiledFunctionTable[312183] = bhEff110_0x230810; // 0x230de4 - g_ps2RecompiledFunctionTable[312187] = bhEff110_0x230810; // 0x230df4 - g_ps2RecompiledFunctionTable[312190] = bhEff110_0x230810; // 0x230e00 - g_ps2RecompiledFunctionTable[312200] = bhEff110_0x230810; // 0x230e28 - g_ps2RecompiledFunctionTable[312202] = bhEff110_0x230810; // 0x230e30 - g_ps2RecompiledFunctionTable[312205] = bhEff110_0x230810; // 0x230e3c - g_ps2RecompiledFunctionTable[312282] = bhEff110_0x230810; // 0x230f70 - g_ps2RecompiledFunctionTable[312284] = bhEff110_0x230810; // 0x230f78 - g_ps2RecompiledFunctionTable[312319] = bhEff110_0x230810; // 0x231004 - g_ps2RecompiledFunctionTable[312321] = bhEff110_0x230810; // 0x23100c - g_ps2RecompiledFunctionTable[312346] = bhEff110_0x230810; // 0x231070 - g_ps2RecompiledFunctionTable[312350] = bhEff110_0x230810; // 0x231080 - g_ps2RecompiledFunctionTable[312353] = bhEff110_0x230810; // 0x23108c - g_ps2RecompiledFunctionTable[312362] = bhEff110_0x230810; // 0x2310b0 - g_ps2RecompiledFunctionTable[312364] = bhEff110_0x230810; // 0x2310b8 - g_ps2RecompiledFunctionTable[312367] = bhEff110_0x230810; // 0x2310c4 - g_ps2RecompiledFunctionTable[312434] = bhEff111_0x2311d0; // 0x2311d0 - g_ps2RecompiledFunctionTable[312480] = bhEff111_0x2311d0; // 0x231288 - g_ps2RecompiledFunctionTable[312502] = bhEff111_0x2311d0; // 0x2312e0 - g_ps2RecompiledFunctionTable[312522] = bhEff111_0x2311d0; // 0x231330 - g_ps2RecompiledFunctionTable[312549] = bhEff111_0x2311d0; // 0x23139c - g_ps2RecompiledFunctionTable[312729] = bhEff111_0x2311d0; // 0x23166c - g_ps2RecompiledFunctionTable[312735] = bhEff111_0x2311d0; // 0x231684 - g_ps2RecompiledFunctionTable[312938] = bhEff112_0x2319b0; // 0x2319b0 - g_ps2RecompiledFunctionTable[312982] = bhEff112_0x2319b0; // 0x231a60 - g_ps2RecompiledFunctionTable[312987] = bhEff112_0x2319b0; // 0x231a74 - g_ps2RecompiledFunctionTable[312995] = bhEff112_0x2319b0; // 0x231a94 - g_ps2RecompiledFunctionTable[313014] = bhEff113_0x231ae0; // 0x231ae0 - g_ps2RecompiledFunctionTable[313142] = bhEff113_0x231ae0; // 0x231ce0 - g_ps2RecompiledFunctionTable[313144] = bhEff113_0x231ae0; // 0x231ce8 - g_ps2RecompiledFunctionTable[313157] = bhEff113_0x231ae0; // 0x231d1c - g_ps2RecompiledFunctionTable[313162] = bhEff113_0x231ae0; // 0x231d30 - g_ps2RecompiledFunctionTable[313164] = bhEff113_0x231ae0; // 0x231d38 - g_ps2RecompiledFunctionTable[313194] = bhEff113_0x231ae0; // 0x231db0 - g_ps2RecompiledFunctionTable[313203] = bhEff113_0x231ae0; // 0x231dd4 - g_ps2RecompiledFunctionTable[313233] = bhEff113_0x231ae0; // 0x231e4c - g_ps2RecompiledFunctionTable[313252] = bhEff113_0x231ae0; // 0x231e98 - g_ps2RecompiledFunctionTable[313263] = bhEff113_0x231ae0; // 0x231ec4 - g_ps2RecompiledFunctionTable[313267] = bhEff113_0x231ae0; // 0x231ed4 - g_ps2RecompiledFunctionTable[313314] = bhEff113_0x231ae0; // 0x231f90 - g_ps2RecompiledFunctionTable[313334] = bhDraw114_0x231fe0; // 0x231fe0 - g_ps2RecompiledFunctionTable[313341] = bhDraw114_0x231fe0; // 0x231ffc - g_ps2RecompiledFunctionTable[313347] = bhDraw114_0x231fe0; // 0x232014 - g_ps2RecompiledFunctionTable[313352] = bhDraw114_0x231fe0; // 0x232028 - g_ps2RecompiledFunctionTable[313356] = bhDraw114_0x231fe0; // 0x232038 - g_ps2RecompiledFunctionTable[313360] = bhDraw114_0x231fe0; // 0x232048 - g_ps2RecompiledFunctionTable[313362] = bhDraw114_0x231fe0; // 0x232050 - g_ps2RecompiledFunctionTable[313371] = bhDraw114_0x231fe0; // 0x232074 - g_ps2RecompiledFunctionTable[313373] = bhDraw114_0x231fe0; // 0x23207c - g_ps2RecompiledFunctionTable[313377] = bhDraw114_0x231fe0; // 0x23208c - g_ps2RecompiledFunctionTable[313380] = bhDraw114_0x231fe0; // 0x232098 - g_ps2RecompiledFunctionTable[313386] = bhDraw114_0x231fe0; // 0x2320b0 - g_ps2RecompiledFunctionTable[313395] = bhDraw114_0x231fe0; // 0x2320d4 - g_ps2RecompiledFunctionTable[313399] = bhDraw114_0x231fe0; // 0x2320e4 - g_ps2RecompiledFunctionTable[313401] = bhDraw114_0x231fe0; // 0x2320ec - g_ps2RecompiledFunctionTable[313404] = bhDraw114_0x231fe0; // 0x2320f8 - g_ps2RecompiledFunctionTable[313406] = bhDraw114_0x231fe0; // 0x232100 - g_ps2RecompiledFunctionTable[313420] = bhDraw114_0x231fe0; // 0x232138 - g_ps2RecompiledFunctionTable[313423] = bhDraw114_0x231fe0; // 0x232144 - g_ps2RecompiledFunctionTable[313427] = bhDraw114_0x231fe0; // 0x232154 - g_ps2RecompiledFunctionTable[313430] = bhDraw114_0x231fe0; // 0x232160 - g_ps2RecompiledFunctionTable[313433] = bhDraw114_0x231fe0; // 0x23216c - g_ps2RecompiledFunctionTable[313435] = bhDraw114_0x231fe0; // 0x232174 - g_ps2RecompiledFunctionTable[313442] = bhEff114_0x232190; // 0x232190 - g_ps2RecompiledFunctionTable[313651] = bhEff114_0x232190; // 0x2324d4 - g_ps2RecompiledFunctionTable[313653] = bhEff114_0x232190; // 0x2324dc - g_ps2RecompiledFunctionTable[313669] = bhEff114_0x232190; // 0x23251c - g_ps2RecompiledFunctionTable[313672] = bhEff114_0x232190; // 0x232528 - g_ps2RecompiledFunctionTable[313688] = bhEff114_0x232190; // 0x232568 - g_ps2RecompiledFunctionTable[313850] = bhEff115_0x2327f0; // 0x2327f0 - g_ps2RecompiledFunctionTable[313898] = bhEff115_0x2327f0; // 0x2328b0 - g_ps2RecompiledFunctionTable[313965] = bhEff115_0x2327f0; // 0x2329bc - g_ps2RecompiledFunctionTable[313967] = bhEff115_0x2327f0; // 0x2329c4 - g_ps2RecompiledFunctionTable[313987] = bhEff115_0x2327f0; // 0x232a14 - g_ps2RecompiledFunctionTable[314007] = bhEff115_0x2327f0; // 0x232a64 - g_ps2RecompiledFunctionTable[314027] = bhEff115_0x2327f0; // 0x232ab4 - g_ps2RecompiledFunctionTable[314046] = bhEff115_0x2327f0; // 0x232b00 - g_ps2RecompiledFunctionTable[314063] = bhEff115_0x2327f0; // 0x232b44 - g_ps2RecompiledFunctionTable[314143] = bhEff115_0x2327f0; // 0x232c84 - g_ps2RecompiledFunctionTable[314229] = bhEff115_0x2327f0; // 0x232ddc - g_ps2RecompiledFunctionTable[314234] = bhEff116_0x232df0; // 0x232df0 - g_ps2RecompiledFunctionTable[314329] = bhEff116_0x232df0; // 0x232f6c - g_ps2RecompiledFunctionTable[314334] = bhEff117_0x232f80; // 0x232f80 - g_ps2RecompiledFunctionTable[314364] = bhEff117_0x232f80; // 0x232ff8 - g_ps2RecompiledFunctionTable[314377] = bhEff117_0x232f80; // 0x23302c - g_ps2RecompiledFunctionTable[314458] = bhEff118_0x233170; // 0x233170 - g_ps2RecompiledFunctionTable[314487] = bhEff118_0x233170; // 0x2331e4 - g_ps2RecompiledFunctionTable[314506] = bhEff118_0x233170; // 0x233230 - g_ps2RecompiledFunctionTable[314519] = bhEff118_0x233170; // 0x233264 - g_ps2RecompiledFunctionTable[314553] = bhEff118_0x233170; // 0x2332ec - g_ps2RecompiledFunctionTable[314568] = bhEff118_0x233170; // 0x233328 - g_ps2RecompiledFunctionTable[314571] = bhEff118_0x233170; // 0x233334 - g_ps2RecompiledFunctionTable[314575] = bhEff118_0x233170; // 0x233344 - g_ps2RecompiledFunctionTable[314608] = bhEff118_0x233170; // 0x2333c8 - g_ps2RecompiledFunctionTable[314630] = bhEff118_0x233170; // 0x233420 - g_ps2RecompiledFunctionTable[314710] = bhEff119_0x233560; // 0x233560 - g_ps2RecompiledFunctionTable[314739] = bhEff119_0x233560; // 0x2335d4 - g_ps2RecompiledFunctionTable[314757] = bhEff119_0x233560; // 0x23361c - g_ps2RecompiledFunctionTable[314853] = bhEff119_0x233560; // 0x23379c - g_ps2RecompiledFunctionTable[314860] = bhEff119_0x233560; // 0x2337b8 - g_ps2RecompiledFunctionTable[314886] = bhEff119_0x233560; // 0x233820 - g_ps2RecompiledFunctionTable[314950] = bhEff120_0x233920; // 0x233920 - g_ps2RecompiledFunctionTable[314983] = bhEff120_0x233920; // 0x2339a4 - g_ps2RecompiledFunctionTable[314989] = bhEff120_0x233920; // 0x2339bc - g_ps2RecompiledFunctionTable[315008] = bhEff120_0x233920; // 0x233a08 - g_ps2RecompiledFunctionTable[315017] = bhEff120_0x233920; // 0x233a2c - g_ps2RecompiledFunctionTable[315037] = bhEff120_0x233920; // 0x233a7c - g_ps2RecompiledFunctionTable[315043] = bhEff120_0x233920; // 0x233a94 - g_ps2RecompiledFunctionTable[315058] = bhEff120_0x233920; // 0x233ad0 - g_ps2RecompiledFunctionTable[315064] = bhEff120_0x233920; // 0x233ae8 - g_ps2RecompiledFunctionTable[315070] = bhEff121_0x233b00; // 0x233b00 - g_ps2RecompiledFunctionTable[315170] = bhEff122_0x233c90; // 0x233c90 - g_ps2RecompiledFunctionTable[315242] = bhEff123_0x233db0; // 0x233db0 - g_ps2RecompiledFunctionTable[315283] = bhEff123_0x233db0; // 0x233e54 - g_ps2RecompiledFunctionTable[315297] = bhEff123_0x233db0; // 0x233e8c - g_ps2RecompiledFunctionTable[315410] = bhEff124_0x234050; // 0x234050 - g_ps2RecompiledFunctionTable[315469] = bhEff124_0x234050; // 0x23413c - g_ps2RecompiledFunctionTable[315586] = bhEff125_0x234310; // 0x234310 - g_ps2RecompiledFunctionTable[315655] = bhEff125_0x234310; // 0x234424 - g_ps2RecompiledFunctionTable[315679] = bhEff125_0x234310; // 0x234484 - g_ps2RecompiledFunctionTable[315711] = bhEff125_0x234310; // 0x234504 - g_ps2RecompiledFunctionTable[315718] = bhEff126_0x234520; // 0x234520 - g_ps2RecompiledFunctionTable[315770] = bhEff126_0x234520; // 0x2345f0 - g_ps2RecompiledFunctionTable[315978] = bhEff127_0x234930; // 0x234930 - g_ps2RecompiledFunctionTable[315994] = bhEff127_0x234930; // 0x234970 - g_ps2RecompiledFunctionTable[316018] = bhEff127_0x234930; // 0x2349d0 - g_ps2RecompiledFunctionTable[316123] = bhEff127_0x234930; // 0x234b74 - g_ps2RecompiledFunctionTable[316188] = bhEff127_0x234930; // 0x234c78 - g_ps2RecompiledFunctionTable[316213] = bhEff127_0x234930; // 0x234cdc - g_ps2RecompiledFunctionTable[316226] = bhEff127_0x234930; // 0x234d10 - g_ps2RecompiledFunctionTable[316234] = bhEff127_0x234930; // 0x234d30 - g_ps2RecompiledFunctionTable[316255] = bhEff127_0x234930; // 0x234d84 - g_ps2RecompiledFunctionTable[316306] = bhEff127_0x234930; // 0x234e50 - g_ps2RecompiledFunctionTable[316344] = bhEff127_0x234930; // 0x234ee8 - g_ps2RecompiledFunctionTable[316426] = bhEff127_0x234930; // 0x235030 - g_ps2RecompiledFunctionTable[316454] = bhEff127_0x234930; // 0x2350a0 - g_ps2RecompiledFunctionTable[316467] = bhEff127_0x234930; // 0x2350d4 - g_ps2RecompiledFunctionTable[316475] = bhEff127_0x234930; // 0x2350f4 - g_ps2RecompiledFunctionTable[316496] = bhEff127_0x234930; // 0x235148 - g_ps2RecompiledFunctionTable[316547] = bhEff127_0x234930; // 0x235214 - g_ps2RecompiledFunctionTable[316585] = bhEff127_0x234930; // 0x2352ac - g_ps2RecompiledFunctionTable[316590] = bhEff128_0x2352c0; // 0x2352c0 - g_ps2RecompiledFunctionTable[316704] = bhEff128_0x2352c0; // 0x235488 - g_ps2RecompiledFunctionTable[316710] = bhEff128_0x2352c0; // 0x2354a0 - g_ps2RecompiledFunctionTable[316714] = bhEff128_0x2352c0; // 0x2354b0 - g_ps2RecompiledFunctionTable[316766] = bhEff129_0x235580; // 0x235580 - g_ps2RecompiledFunctionTable[316770] = bhEff130_0x235590; // 0x235590 - g_ps2RecompiledFunctionTable[316899] = bhEff130_0x235590; // 0x235794 - g_ps2RecompiledFunctionTable[316914] = bhEff130_0x235590; // 0x2357d0 - g_ps2RecompiledFunctionTable[317019] = bhEff130_0x235590; // 0x235974 - g_ps2RecompiledFunctionTable[317035] = bhEff130_0x235590; // 0x2359b4 - g_ps2RecompiledFunctionTable[317092] = bhEff130_0x235590; // 0x235a98 - g_ps2RecompiledFunctionTable[317197] = bhEff130_0x235590; // 0x235c3c - g_ps2RecompiledFunctionTable[317220] = bhEff130_0x235590; // 0x235c98 - g_ps2RecompiledFunctionTable[317223] = bhEff130_0x235590; // 0x235ca4 - g_ps2RecompiledFunctionTable[317226] = bhEff130_0x235590; // 0x235cb0 - g_ps2RecompiledFunctionTable[317227] = bhEff130_0x235590; // 0x235cb4 - g_ps2RecompiledFunctionTable[317229] = bhEff130_0x235590; // 0x235cbc - g_ps2RecompiledFunctionTable[317231] = bhEff130_0x235590; // 0x235cc4 - g_ps2RecompiledFunctionTable[317246] = bhEff130_0x235590; // 0x235d00 - g_ps2RecompiledFunctionTable[317249] = bhEff130_0x235590; // 0x235d0c - g_ps2RecompiledFunctionTable[317253] = bhEff130_0x235590; // 0x235d1c - g_ps2RecompiledFunctionTable[317262] = bhEff130_0x235590; // 0x235d40 - g_ps2RecompiledFunctionTable[317264] = bhEff130_0x235590; // 0x235d48 - g_ps2RecompiledFunctionTable[317330] = bhEff130_0x235590; // 0x235e50 - g_ps2RecompiledFunctionTable[317350] = bhEff130_0x235590; // 0x235ea0 - g_ps2RecompiledFunctionTable[317410] = bhEff130_0x235590; // 0x235f90 - g_ps2RecompiledFunctionTable[317444] = bhEff130_0x235590; // 0x236018 - g_ps2RecompiledFunctionTable[317503] = bhEff130_0x235590; // 0x236104 - g_ps2RecompiledFunctionTable[317546] = bhEff130_0x235590; // 0x2361b0 - g_ps2RecompiledFunctionTable[317563] = bhEff130_0x235590; // 0x2361f4 - g_ps2RecompiledFunctionTable[317592] = bhEff130_0x235590; // 0x236268 - g_ps2RecompiledFunctionTable[317613] = bhEff130_0x235590; // 0x2362bc - g_ps2RecompiledFunctionTable[317654] = bhEff130_0x235590; // 0x236360 - g_ps2RecompiledFunctionTable[317689] = bhEff130_0x235590; // 0x2363ec - g_ps2RecompiledFunctionTable[317702] = bhEff130_0x235590; // 0x236420 - g_ps2RecompiledFunctionTable[317760] = bhEff130_0x235590; // 0x236508 - g_ps2RecompiledFunctionTable[317821] = bhEff130_0x235590; // 0x2365fc - g_ps2RecompiledFunctionTable[317897] = bhEff130_0x235590; // 0x23672c - g_ps2RecompiledFunctionTable[317974] = bhEff130_0x235590; // 0x236860 - g_ps2RecompiledFunctionTable[318072] = bhEff130_0x235590; // 0x2369e8 - g_ps2RecompiledFunctionTable[318091] = bhEff130_0x235590; // 0x236a34 - g_ps2RecompiledFunctionTable[318152] = bhEff130_0x235590; // 0x236b28 - g_ps2RecompiledFunctionTable[318228] = bhEff130_0x235590; // 0x236c58 - g_ps2RecompiledFunctionTable[318310] = bhEff130_0x235590; // 0x236da0 - g_ps2RecompiledFunctionTable[318312] = bhEff130_0x235590; // 0x236da8 - g_ps2RecompiledFunctionTable[318314] = bhEff130_0x235590; // 0x236db0 - g_ps2RecompiledFunctionTable[318321] = bhEff130_0x235590; // 0x236dcc - g_ps2RecompiledFunctionTable[318324] = bhEff130_0x235590; // 0x236dd8 - g_ps2RecompiledFunctionTable[318328] = bhEff130_0x235590; // 0x236de8 - g_ps2RecompiledFunctionTable[318345] = bhEff130_0x235590; // 0x236e2c - g_ps2RecompiledFunctionTable[318447] = bhEff130_0x235590; // 0x236fc4 - g_ps2RecompiledFunctionTable[318466] = bhEff130_0x235590; // 0x237010 - g_ps2RecompiledFunctionTable[318527] = bhEff130_0x235590; // 0x237104 - g_ps2RecompiledFunctionTable[318606] = bhEff130_0x235590; // 0x237240 - g_ps2RecompiledFunctionTable[318616] = bhEff130_0x235590; // 0x237268 - g_ps2RecompiledFunctionTable[318618] = bhEff130_0x235590; // 0x237270 - g_ps2RecompiledFunctionTable[318629] = bhEff130_0x235590; // 0x23729c - g_ps2RecompiledFunctionTable[318632] = bhEff130_0x235590; // 0x2372a8 - g_ps2RecompiledFunctionTable[318636] = bhEff130_0x235590; // 0x2372b8 - g_ps2RecompiledFunctionTable[318638] = bhEff130_0x235590; // 0x2372c0 - g_ps2RecompiledFunctionTable[318658] = bhEff130_0x235590; // 0x237310 - g_ps2RecompiledFunctionTable[318688] = bhEff130_0x235590; // 0x237388 - g_ps2RecompiledFunctionTable[318701] = bhEff130_0x235590; // 0x2373bc - g_ps2RecompiledFunctionTable[318716] = bhEff130_0x235590; // 0x2373f8 - g_ps2RecompiledFunctionTable[318741] = bhEff130_0x235590; // 0x23745c - g_ps2RecompiledFunctionTable[318785] = bhEff130_0x235590; // 0x23750c - g_ps2RecompiledFunctionTable[318836] = bhEff130_0x235590; // 0x2375d8 - g_ps2RecompiledFunctionTable[318869] = bhEff130_0x235590; // 0x23765c - g_ps2RecompiledFunctionTable[318901] = bhEff130_0x235590; // 0x2376dc - g_ps2RecompiledFunctionTable[318977] = bhEff130_0x235590; // 0x23780c - g_ps2RecompiledFunctionTable[319091] = bhEff130_0x235590; // 0x2379d4 - g_ps2RecompiledFunctionTable[319141] = bhEff130_0x235590; // 0x237a9c - g_ps2RecompiledFunctionTable[319143] = bhEff130_0x235590; // 0x237aa4 - g_ps2RecompiledFunctionTable[319159] = bhEff130_0x235590; // 0x237ae4 - g_ps2RecompiledFunctionTable[319180] = bhEff130_0x235590; // 0x237b38 - g_ps2RecompiledFunctionTable[319195] = bhEff130_0x235590; // 0x237b74 - g_ps2RecompiledFunctionTable[319201] = bhEff130_0x235590; // 0x237b8c - g_ps2RecompiledFunctionTable[319216] = bhEff130_0x235590; // 0x237bc8 - g_ps2RecompiledFunctionTable[319223] = bhEff130_0x235590; // 0x237be4 - g_ps2RecompiledFunctionTable[319234] = bhEff130_0x235590; // 0x237c10 - g_ps2RecompiledFunctionTable[319238] = bhEff130_0x235590; // 0x237c20 - g_ps2RecompiledFunctionTable[319240] = bhEff130_0x235590; // 0x237c28 - g_ps2RecompiledFunctionTable[319254] = bhEff130_0x235590; // 0x237c60 - g_ps2RecompiledFunctionTable[319268] = bhEff130_0x235590; // 0x237c98 - g_ps2RecompiledFunctionTable[319290] = bhEff130_0x235590; // 0x237cf0 - g_ps2RecompiledFunctionTable[319301] = bhEff130_0x235590; // 0x237d1c - g_ps2RecompiledFunctionTable[319305] = bhEff130_0x235590; // 0x237d2c - g_ps2RecompiledFunctionTable[319336] = bhEff130_0x235590; // 0x237da8 - g_ps2RecompiledFunctionTable[319350] = bhEff130_0x235590; // 0x237de0 - g_ps2RecompiledFunctionTable[319354] = bhEff130_0x235590; // 0x237df0 - g_ps2RecompiledFunctionTable[319390] = bhEff130_0x235590; // 0x237e80 - g_ps2RecompiledFunctionTable[319427] = bhEff130_0x235590; // 0x237f14 - g_ps2RecompiledFunctionTable[319516] = bhEff130_0x235590; // 0x238078 - g_ps2RecompiledFunctionTable[319518] = bhEff130_0x235590; // 0x238080 - g_ps2RecompiledFunctionTable[319550] = bhEff130_0x235590; // 0x238100 - g_ps2RecompiledFunctionTable[319579] = bhEff130_0x235590; // 0x238174 - g_ps2RecompiledFunctionTable[319598] = bhEff130_0x235590; // 0x2381c0 - g_ps2RecompiledFunctionTable[319607] = bhEff130_0x235590; // 0x2381e4 - g_ps2RecompiledFunctionTable[319626] = bhEff130_0x235590; // 0x238230 - g_ps2RecompiledFunctionTable[319636] = bhEff130_0x235590; // 0x238258 - g_ps2RecompiledFunctionTable[319647] = bhEff130_0x235590; // 0x238284 - g_ps2RecompiledFunctionTable[319651] = bhEff130_0x235590; // 0x238294 - g_ps2RecompiledFunctionTable[319660] = bhEff130_0x235590; // 0x2382b8 - g_ps2RecompiledFunctionTable[319681] = bhEff130_0x235590; // 0x23830c - g_ps2RecompiledFunctionTable[319714] = bhEff130_0x235590; // 0x238390 - g_ps2RecompiledFunctionTable[319732] = bhEff130_0x235590; // 0x2383d8 - g_ps2RecompiledFunctionTable[319782] = bhEff131_0x2384a0; // 0x2384a0 - g_ps2RecompiledFunctionTable[319902] = bhEff132_0x238680; // 0x238680 - g_ps2RecompiledFunctionTable[320305] = bhEff132_0x238680; // 0x238ccc - g_ps2RecompiledFunctionTable[320430] = bhEff133_0x238ec0; // 0x238ec0 - g_ps2RecompiledFunctionTable[320526] = bhEff133_0x238ec0; // 0x239040 - g_ps2RecompiledFunctionTable[320561] = bhEff133_0x238ec0; // 0x2390cc - g_ps2RecompiledFunctionTable[320580] = bhEff133_0x238ec0; // 0x239118 - g_ps2RecompiledFunctionTable[320600] = bhEff133_0x238ec0; // 0x239168 - g_ps2RecompiledFunctionTable[320618] = bhEff133_0x238ec0; // 0x2391b0 - g_ps2RecompiledFunctionTable[320642] = bhEff133_0x238ec0; // 0x239210 - g_ps2RecompiledFunctionTable[320658] = bhDraw134_0x239250; // 0x239250 - g_ps2RecompiledFunctionTable[320671] = bhDraw134_0x239250; // 0x239284 - g_ps2RecompiledFunctionTable[320674] = bhDraw134_0x239250; // 0x239290 - g_ps2RecompiledFunctionTable[320677] = bhDraw134_0x239250; // 0x23929c - g_ps2RecompiledFunctionTable[320679] = bhDraw134_0x239250; // 0x2392a4 - g_ps2RecompiledFunctionTable[320685] = bhDraw134_0x239250; // 0x2392bc - g_ps2RecompiledFunctionTable[320691] = bhDraw134_0x239250; // 0x2392d4 - g_ps2RecompiledFunctionTable[320711] = bhDraw134_0x239250; // 0x239324 - g_ps2RecompiledFunctionTable[320714] = bhDraw134_0x239250; // 0x239330 - g_ps2RecompiledFunctionTable[320744] = bhDraw134_0x239250; // 0x2393a8 - g_ps2RecompiledFunctionTable[320746] = bhDraw134_0x239250; // 0x2393b0 - g_ps2RecompiledFunctionTable[320772] = bhDraw134_0x239250; // 0x239418 - g_ps2RecompiledFunctionTable[320800] = bhDraw134_0x239250; // 0x239488 - g_ps2RecompiledFunctionTable[320843] = bhDraw134_0x239250; // 0x239534 - g_ps2RecompiledFunctionTable[320850] = bhDraw134_0x239250; // 0x239550 - g_ps2RecompiledFunctionTable[320853] = bhDraw134_0x239250; // 0x23955c - g_ps2RecompiledFunctionTable[320855] = bhDraw134_0x239250; // 0x239564 - g_ps2RecompiledFunctionTable[320870] = bhEff134_0x2395a0; // 0x2395a0 - g_ps2RecompiledFunctionTable[320949] = bhEff134_0x2395a0; // 0x2396dc - g_ps2RecompiledFunctionTable[321019] = bhEff134_0x2395a0; // 0x2397f4 - g_ps2RecompiledFunctionTable[321030] = bhEff134_0x2395a0; // 0x239820 - g_ps2RecompiledFunctionTable[321055] = bhEff134_0x2395a0; // 0x239884 - g_ps2RecompiledFunctionTable[321100] = bhEff134_0x2395a0; // 0x239938 - g_ps2RecompiledFunctionTable[321118] = bhEff134_0x2395a0; // 0x239980 - g_ps2RecompiledFunctionTable[321141] = bhEff134_0x2395a0; // 0x2399dc - g_ps2RecompiledFunctionTable[321177] = bhEff134_0x2395a0; // 0x239a6c - g_ps2RecompiledFunctionTable[321218] = bhEff134_0x2395a0; // 0x239b10 - g_ps2RecompiledFunctionTable[321242] = bhEff134_0x2395a0; // 0x239b70 - g_ps2RecompiledFunctionTable[321275] = bhEff134_0x2395a0; // 0x239bf4 - g_ps2RecompiledFunctionTable[321310] = bhEff134_0x2395a0; // 0x239c80 - g_ps2RecompiledFunctionTable[321326] = bhEff134_0x2395a0; // 0x239cc0 - g_ps2RecompiledFunctionTable[321343] = bhEff134_0x2395a0; // 0x239d04 - g_ps2RecompiledFunctionTable[321377] = bhEff134_0x2395a0; // 0x239d8c - g_ps2RecompiledFunctionTable[321419] = bhEff134_0x2395a0; // 0x239e34 - g_ps2RecompiledFunctionTable[321425] = bhEff134_0x2395a0; // 0x239e4c - g_ps2RecompiledFunctionTable[321448] = bhEff134_0x2395a0; // 0x239ea8 - g_ps2RecompiledFunctionTable[321461] = bhEff134_0x2395a0; // 0x239edc - g_ps2RecompiledFunctionTable[321480] = bhEff134_0x2395a0; // 0x239f28 - g_ps2RecompiledFunctionTable[321492] = bhEff134_0x2395a0; // 0x239f58 - g_ps2RecompiledFunctionTable[321582] = bhEff134_0x2395a0; // 0x23a0c0 - g_ps2RecompiledFunctionTable[321618] = bhEff134_0x2395a0; // 0x23a150 - g_ps2RecompiledFunctionTable[321621] = bhEff134_0x2395a0; // 0x23a15c - g_ps2RecompiledFunctionTable[321640] = bhEff134_0x2395a0; // 0x23a1a8 - g_ps2RecompiledFunctionTable[321659] = bhEff134_0x2395a0; // 0x23a1f4 - g_ps2RecompiledFunctionTable[321766] = bhEff135_0x23a3a0; // 0x23a3a0 - g_ps2RecompiledFunctionTable[321786] = bhEff135_0x23a3a0; // 0x23a3f0 - g_ps2RecompiledFunctionTable[321949] = bhEff135_0x23a3a0; // 0x23a67c - g_ps2RecompiledFunctionTable[321978] = bhDraw136_0x23a6f0; // 0x23a6f0 - g_ps2RecompiledFunctionTable[321988] = bhDraw136_0x23a6f0; // 0x23a718 - g_ps2RecompiledFunctionTable[321990] = bhDraw136_0x23a6f0; // 0x23a720 - g_ps2RecompiledFunctionTable[321993] = bhDraw136_0x23a6f0; // 0x23a72c - g_ps2RecompiledFunctionTable[322016] = bhDraw136_0x23a6f0; // 0x23a788 - g_ps2RecompiledFunctionTable[322023] = bhDraw136_0x23a6f0; // 0x23a7a4 - g_ps2RecompiledFunctionTable[322032] = bhDraw136_0x23a6f0; // 0x23a7c8 - g_ps2RecompiledFunctionTable[322053] = bhDraw136_0x23a6f0; // 0x23a81c - g_ps2RecompiledFunctionTable[322057] = bhDraw136_0x23a6f0; // 0x23a82c - g_ps2RecompiledFunctionTable[322078] = bhDraw136_0x23a6f0; // 0x23a880 - g_ps2RecompiledFunctionTable[322085] = bhDraw136_0x23a6f0; // 0x23a89c - g_ps2RecompiledFunctionTable[322092] = bhDraw136_0x23a6f0; // 0x23a8b8 - g_ps2RecompiledFunctionTable[322107] = bhDraw136_0x23a6f0; // 0x23a8f4 - g_ps2RecompiledFunctionTable[322123] = bhDraw136_0x23a6f0; // 0x23a934 - g_ps2RecompiledFunctionTable[322130] = bhEff136_0x23a950; // 0x23a950 - g_ps2RecompiledFunctionTable[322157] = bhEff136_0x23a950; // 0x23a9bc - g_ps2RecompiledFunctionTable[322202] = bhEff136_0x23a950; // 0x23aa70 - g_ps2RecompiledFunctionTable[322221] = bhEff136_0x23a950; // 0x23aabc - g_ps2RecompiledFunctionTable[322230] = bhEff136_0x23a950; // 0x23aae0 - g_ps2RecompiledFunctionTable[322243] = bhEff136_0x23a950; // 0x23ab14 - g_ps2RecompiledFunctionTable[322246] = bhEff136_0x23a950; // 0x23ab20 - g_ps2RecompiledFunctionTable[322260] = bhEff136_0x23a950; // 0x23ab58 - g_ps2RecompiledFunctionTable[322334] = bhDraw137_0x23ac80; // 0x23ac80 - g_ps2RecompiledFunctionTable[322350] = bhDraw137_0x23ac80; // 0x23acc0 - g_ps2RecompiledFunctionTable[322353] = bhDraw137_0x23ac80; // 0x23accc - g_ps2RecompiledFunctionTable[322356] = bhDraw137_0x23ac80; // 0x23acd8 - g_ps2RecompiledFunctionTable[322358] = bhDraw137_0x23ac80; // 0x23ace0 - g_ps2RecompiledFunctionTable[322364] = bhDraw137_0x23ac80; // 0x23acf8 - g_ps2RecompiledFunctionTable[322370] = bhDraw137_0x23ac80; // 0x23ad10 - g_ps2RecompiledFunctionTable[322422] = bhDraw137_0x23ac80; // 0x23ade0 - g_ps2RecompiledFunctionTable[322430] = bhDraw137_0x23ac80; // 0x23ae00 - g_ps2RecompiledFunctionTable[322459] = bhDraw137_0x23ac80; // 0x23ae74 - g_ps2RecompiledFunctionTable[322462] = bhDraw137_0x23ac80; // 0x23ae80 - g_ps2RecompiledFunctionTable[322467] = bhDraw137_0x23ac80; // 0x23ae94 - g_ps2RecompiledFunctionTable[322474] = bhDraw137_0x23ac80; // 0x23aeb0 - g_ps2RecompiledFunctionTable[322491] = bhDraw137_0x23ac80; // 0x23aef4 - g_ps2RecompiledFunctionTable[322518] = bhDraw137_0x23ac80; // 0x23af60 - g_ps2RecompiledFunctionTable[322526] = bhDraw137_0x23ac80; // 0x23af80 - g_ps2RecompiledFunctionTable[322534] = bhDraw137_0x23ac80; // 0x23afa0 - g_ps2RecompiledFunctionTable[322546] = bhDraw137_0x23ac80; // 0x23afd0 - g_ps2RecompiledFunctionTable[322550] = bhDraw137_0x23ac80; // 0x23afe0 - g_ps2RecompiledFunctionTable[322562] = bhDraw137_0x23ac80; // 0x23b010 - g_ps2RecompiledFunctionTable[322570] = bhDraw137_0x23ac80; // 0x23b030 - g_ps2RecompiledFunctionTable[322577] = bhDraw137_0x23ac80; // 0x23b04c - g_ps2RecompiledFunctionTable[322585] = bhDraw137_0x23ac80; // 0x23b06c - g_ps2RecompiledFunctionTable[322596] = bhDraw137_0x23ac80; // 0x23b098 - g_ps2RecompiledFunctionTable[322604] = bhDraw137_0x23ac80; // 0x23b0b8 - g_ps2RecompiledFunctionTable[322612] = bhDraw137_0x23ac80; // 0x23b0d8 - g_ps2RecompiledFunctionTable[322625] = bhDraw137_0x23ac80; // 0x23b10c - g_ps2RecompiledFunctionTable[322638] = bhDraw137_0x23ac80; // 0x23b140 - g_ps2RecompiledFunctionTable[322642] = bhDraw137_0x23ac80; // 0x23b150 - g_ps2RecompiledFunctionTable[322654] = bhDraw137_0x23ac80; // 0x23b180 - g_ps2RecompiledFunctionTable[322662] = bhDraw137_0x23ac80; // 0x23b1a0 - g_ps2RecompiledFunctionTable[322669] = bhDraw137_0x23ac80; // 0x23b1bc - g_ps2RecompiledFunctionTable[322677] = bhDraw137_0x23ac80; // 0x23b1dc - g_ps2RecompiledFunctionTable[322688] = bhDraw137_0x23ac80; // 0x23b208 - g_ps2RecompiledFunctionTable[322696] = bhDraw137_0x23ac80; // 0x23b228 - g_ps2RecompiledFunctionTable[322704] = bhDraw137_0x23ac80; // 0x23b248 - g_ps2RecompiledFunctionTable[322717] = bhDraw137_0x23ac80; // 0x23b27c - g_ps2RecompiledFunctionTable[322730] = bhDraw137_0x23ac80; // 0x23b2b0 - g_ps2RecompiledFunctionTable[322735] = bhDraw137_0x23ac80; // 0x23b2c4 - g_ps2RecompiledFunctionTable[322747] = bhDraw137_0x23ac80; // 0x23b2f4 - g_ps2RecompiledFunctionTable[322755] = bhDraw137_0x23ac80; // 0x23b314 - g_ps2RecompiledFunctionTable[322760] = bhDraw137_0x23ac80; // 0x23b328 - g_ps2RecompiledFunctionTable[322768] = bhDraw137_0x23ac80; // 0x23b348 - g_ps2RecompiledFunctionTable[322771] = bhDraw137_0x23ac80; // 0x23b354 - g_ps2RecompiledFunctionTable[322774] = bhDraw137_0x23ac80; // 0x23b360 - g_ps2RecompiledFunctionTable[322776] = bhDraw137_0x23ac80; // 0x23b368 - g_ps2RecompiledFunctionTable[322794] = bhEff137_0x23b3b0; // 0x23b3b0 - g_ps2RecompiledFunctionTable[322828] = bhEff137_0x23b3b0; // 0x23b438 - g_ps2RecompiledFunctionTable[322857] = bhEff137_0x23b3b0; // 0x23b4ac - g_ps2RecompiledFunctionTable[322868] = bhEff137_0x23b3b0; // 0x23b4d8 - g_ps2RecompiledFunctionTable[322946] = bhEff137_0x23b3b0; // 0x23b610 - g_ps2RecompiledFunctionTable[322978] = bhEff137_0x23b3b0; // 0x23b690 - g_ps2RecompiledFunctionTable[323006] = bhEff137_0x23b3b0; // 0x23b700 - g_ps2RecompiledFunctionTable[323037] = bhEff137_0x23b3b0; // 0x23b77c - g_ps2RecompiledFunctionTable[323053] = bhEff137_0x23b3b0; // 0x23b7bc - g_ps2RecompiledFunctionTable[323068] = bhEff137_0x23b3b0; // 0x23b7f8 - g_ps2RecompiledFunctionTable[323117] = bhEff137_0x23b3b0; // 0x23b8bc - g_ps2RecompiledFunctionTable[323126] = bhEff137_0x23b3b0; // 0x23b8e0 - g_ps2RecompiledFunctionTable[323209] = bhEff137_0x23b3b0; // 0x23ba2c - g_ps2RecompiledFunctionTable[323245] = bhEff137_0x23b3b0; // 0x23babc - g_ps2RecompiledFunctionTable[323252] = bhEff137_0x23b3b0; // 0x23bad8 - g_ps2RecompiledFunctionTable[323262] = bhEff137_0x23b3b0; // 0x23bb00 - g_ps2RecompiledFunctionTable[323274] = bhEff137_0x23b3b0; // 0x23bb30 - g_ps2RecompiledFunctionTable[323321] = bhEff137_0x23b3b0; // 0x23bbec - g_ps2RecompiledFunctionTable[323326] = bhEff137_0x23b3b0; // 0x23bc00 - g_ps2RecompiledFunctionTable[323331] = bhEff137_0x23b3b0; // 0x23bc14 - g_ps2RecompiledFunctionTable[323402] = bhDraw138_0x23bd30; // 0x23bd30 - g_ps2RecompiledFunctionTable[323415] = bhDraw138_0x23bd30; // 0x23bd64 - g_ps2RecompiledFunctionTable[323418] = bhDraw138_0x23bd30; // 0x23bd70 - g_ps2RecompiledFunctionTable[323421] = bhDraw138_0x23bd30; // 0x23bd7c - g_ps2RecompiledFunctionTable[323423] = bhDraw138_0x23bd30; // 0x23bd84 - g_ps2RecompiledFunctionTable[323429] = bhDraw138_0x23bd30; // 0x23bd9c - g_ps2RecompiledFunctionTable[323445] = bhDraw138_0x23bd30; // 0x23bddc - g_ps2RecompiledFunctionTable[323502] = bhDraw138_0x23bd30; // 0x23bec0 - g_ps2RecompiledFunctionTable[323504] = bhDraw138_0x23bd30; // 0x23bec8 - g_ps2RecompiledFunctionTable[323510] = bhDraw138_0x23bd30; // 0x23bee0 - g_ps2RecompiledFunctionTable[323513] = bhDraw138_0x23bd30; // 0x23beec - g_ps2RecompiledFunctionTable[323519] = bhDraw138_0x23bd30; // 0x23bf04 - g_ps2RecompiledFunctionTable[323593] = bhDraw138_0x23bd30; // 0x23c02c - g_ps2RecompiledFunctionTable[323634] = bhDraw138_0x23bd30; // 0x23c0d0 - g_ps2RecompiledFunctionTable[323689] = bhDraw138_0x23bd30; // 0x23c1ac - g_ps2RecompiledFunctionTable[323730] = bhDraw138_0x23bd30; // 0x23c250 - g_ps2RecompiledFunctionTable[323766] = bhDraw138_0x23bd30; // 0x23c2e0 - g_ps2RecompiledFunctionTable[323798] = bhDraw138_0x23bd30; // 0x23c360 - g_ps2RecompiledFunctionTable[323849] = bhDraw138_0x23bd30; // 0x23c42c - g_ps2RecompiledFunctionTable[323856] = bhDraw138_0x23bd30; // 0x23c448 - g_ps2RecompiledFunctionTable[323859] = bhDraw138_0x23bd30; // 0x23c454 - g_ps2RecompiledFunctionTable[323865] = bhDraw138_0x23bd30; // 0x23c46c - g_ps2RecompiledFunctionTable[323876] = bhDraw138_0x23bd30; // 0x23c498 - g_ps2RecompiledFunctionTable[323909] = bhDraw138_0x23bd30; // 0x23c51c - g_ps2RecompiledFunctionTable[323942] = bhDraw138_0x23bd30; // 0x23c5a0 - g_ps2RecompiledFunctionTable[323975] = bhDraw138_0x23bd30; // 0x23c624 - g_ps2RecompiledFunctionTable[324009] = bhDraw138_0x23bd30; // 0x23c6ac - g_ps2RecompiledFunctionTable[324015] = bhDraw138_0x23bd30; // 0x23c6c4 - g_ps2RecompiledFunctionTable[324023] = bhDraw138_0x23bd30; // 0x23c6e4 - g_ps2RecompiledFunctionTable[324046] = bhDraw138_0x23bd30; // 0x23c740 - g_ps2RecompiledFunctionTable[324049] = bhDraw138_0x23bd30; // 0x23c74c - g_ps2RecompiledFunctionTable[324052] = bhDraw138_0x23bd30; // 0x23c758 - g_ps2RecompiledFunctionTable[324054] = bhDraw138_0x23bd30; // 0x23c760 - g_ps2RecompiledFunctionTable[324066] = bhEff138_0x23c790; // 0x23c790 - g_ps2RecompiledFunctionTable[324188] = bhEff138_0x23c790; // 0x23c978 - g_ps2RecompiledFunctionTable[324205] = bhEff138_0x23c790; // 0x23c9bc - g_ps2RecompiledFunctionTable[324222] = bhEff138_0x23c790; // 0x23ca00 - g_ps2RecompiledFunctionTable[324235] = bhEff138_0x23c790; // 0x23ca34 - g_ps2RecompiledFunctionTable[324291] = bhEff138_0x23c790; // 0x23cb14 - g_ps2RecompiledFunctionTable[324295] = bhEff138_0x23c790; // 0x23cb24 - g_ps2RecompiledFunctionTable[324305] = bhEff138_0x23c790; // 0x23cb4c - g_ps2RecompiledFunctionTable[324309] = bhEff138_0x23c790; // 0x23cb5c - g_ps2RecompiledFunctionTable[324517] = bhEff138_0x23c790; // 0x23ce9c - g_ps2RecompiledFunctionTable[324524] = bhEff138_0x23c790; // 0x23ceb8 - g_ps2RecompiledFunctionTable[324557] = bhEff138_0x23c790; // 0x23cf3c - g_ps2RecompiledFunctionTable[324564] = bhEff138_0x23c790; // 0x23cf58 - g_ps2RecompiledFunctionTable[324575] = bhEff138_0x23c790; // 0x23cf84 - g_ps2RecompiledFunctionTable[324621] = bhEff138_0x23c790; // 0x23d03c - g_ps2RecompiledFunctionTable[324670] = bhEff138_0x23c790; // 0x23d100 - g_ps2RecompiledFunctionTable[324710] = bhEff138_0x23c790; // 0x23d1a0 - g_ps2RecompiledFunctionTable[324751] = bhEff138_0x23c790; // 0x23d244 - g_ps2RecompiledFunctionTable[324761] = bhEff138_0x23c790; // 0x23d26c - g_ps2RecompiledFunctionTable[324844] = bhEff138_0x23c790; // 0x23d3b8 - g_ps2RecompiledFunctionTable[324852] = bhEff138_0x23c790; // 0x23d3d8 - g_ps2RecompiledFunctionTable[324854] = bhEff138_0x23c790; // 0x23d3e0 - g_ps2RecompiledFunctionTable[324906] = bhEff_E00_Mince_0x23d4b0; // 0x23d4b0 - g_ps2RecompiledFunctionTable[324932] = bhEff_E00_Mince_0x23d4b0; // 0x23d518 - g_ps2RecompiledFunctionTable[324940] = bhEff_E00_Mince_0x23d4b0; // 0x23d538 - g_ps2RecompiledFunctionTable[324953] = bhEff_E00_Mince_0x23d4b0; // 0x23d56c - g_ps2RecompiledFunctionTable[324959] = bhEff_E00_Mince_0x23d4b0; // 0x23d584 - g_ps2RecompiledFunctionTable[324975] = bhEff_E00_Mince_0x23d4b0; // 0x23d5c4 - g_ps2RecompiledFunctionTable[324980] = bhEff_E00_Mince_0x23d4b0; // 0x23d5d8 - g_ps2RecompiledFunctionTable[324984] = bhEff_E00_Mince_0x23d4b0; // 0x23d5e8 - g_ps2RecompiledFunctionTable[325003] = bhEff_E00_Mince_0x23d4b0; // 0x23d634 - g_ps2RecompiledFunctionTable[325016] = bhEff_E00_Mince_0x23d4b0; // 0x23d668 - g_ps2RecompiledFunctionTable[325027] = bhEff_E00_Mince_0x23d4b0; // 0x23d694 - g_ps2RecompiledFunctionTable[325041] = bhEff_E00_Mince_0x23d4b0; // 0x23d6cc - g_ps2RecompiledFunctionTable[325045] = bhEff_E00_Mince_0x23d4b0; // 0x23d6dc - g_ps2RecompiledFunctionTable[325059] = bhEff_E00_Mince_0x23d4b0; // 0x23d714 - g_ps2RecompiledFunctionTable[325129] = bhEff_E00_Mince_0x23d4b0; // 0x23d82c - g_ps2RecompiledFunctionTable[325185] = bhEff_E00_Mince_0x23d4b0; // 0x23d90c - g_ps2RecompiledFunctionTable[325187] = bhEff_E00_Mince_0x23d4b0; // 0x23d914 - g_ps2RecompiledFunctionTable[325200] = bhEff_E00_Mince_0x23d4b0; // 0x23d948 - g_ps2RecompiledFunctionTable[325219] = bhEff_E00_Mince_0x23d4b0; // 0x23d994 - g_ps2RecompiledFunctionTable[325282] = bhEff_E00_Mince_0x23d4b0; // 0x23da90 - g_ps2RecompiledFunctionTable[325286] = bhEff_E00_Mince_0x23d4b0; // 0x23daa0 - g_ps2RecompiledFunctionTable[325288] = bhEff_E00_Mince_0x23d4b0; // 0x23daa8 - g_ps2RecompiledFunctionTable[325325] = bhEff_E00_Mince_0x23d4b0; // 0x23db3c - g_ps2RecompiledFunctionTable[325354] = bhEff_E00_DrawParticleSpr_0x23dbb0; // 0x23dbb0 - g_ps2RecompiledFunctionTable[325369] = bhEff_E00_DrawParticleSpr_0x23dbb0; // 0x23dbec - g_ps2RecompiledFunctionTable[325373] = bhEff_E00_DrawParticleSpr_0x23dbb0; // 0x23dbfc - g_ps2RecompiledFunctionTable[325380] = bhEff_E00_DrawParticleSpr_0x23dbb0; // 0x23dc18 - g_ps2RecompiledFunctionTable[325385] = bhEff_E00_DrawParticleSpr_0x23dbb0; // 0x23dc2c - g_ps2RecompiledFunctionTable[325388] = bhEff_E00_DrawParticleSpr_0x23dbb0; // 0x23dc38 - g_ps2RecompiledFunctionTable[325391] = bhEff_E00_DrawParticleSpr_0x23dbb0; // 0x23dc44 - g_ps2RecompiledFunctionTable[325395] = bhEff_E00_DrawParticleSpr_0x23dbb0; // 0x23dc54 - g_ps2RecompiledFunctionTable[325399] = bhEff_E00_DrawParticleSpr_0x23dbb0; // 0x23dc64 - g_ps2RecompiledFunctionTable[325404] = bhEff_E00_DrawParticleSpr_0x23dbb0; // 0x23dc78 - g_ps2RecompiledFunctionTable[325406] = bhEff_E00_DrawParticleSpr_0x23dbb0; // 0x23dc80 - g_ps2RecompiledFunctionTable[325409] = bhEff_E00_DrawParticleSpr_0x23dbb0; // 0x23dc8c - g_ps2RecompiledFunctionTable[325412] = bhEff_E00_DrawParticleSpr_0x23dbb0; // 0x23dc98 - g_ps2RecompiledFunctionTable[325418] = bhEff_E00_DrawParticlePly_0x23dcb0; // 0x23dcb0 - g_ps2RecompiledFunctionTable[325426] = bhEff_E00_DrawParticlePly_0x23dcb0; // 0x23dcd0 - g_ps2RecompiledFunctionTable[325428] = bhEff_E00_DrawParticlePly_0x23dcb0; // 0x23dcd8 - g_ps2RecompiledFunctionTable[325432] = bhEff_E00_DrawParticlePly_0x23dcb0; // 0x23dce8 - g_ps2RecompiledFunctionTable[325434] = bhEff_E00_DrawParticlePly_0x23dcb0; // 0x23dcf0 - g_ps2RecompiledFunctionTable[325438] = bhEff_E00_DropBlood_0x23dd00; // 0x23dd00 - g_ps2RecompiledFunctionTable[325456] = bhEff_E00_DropBlood_0x23dd00; // 0x23dd48 - g_ps2RecompiledFunctionTable[325472] = bhEff_E00_DropBlood_0x23dd00; // 0x23dd88 - g_ps2RecompiledFunctionTable[325552] = bhEff_E00_DropBlood_0x23dd00; // 0x23dec8 - g_ps2RecompiledFunctionTable[325578] = bhEff_E00_Fire_0x23df30; // 0x23df30 - g_ps2RecompiledFunctionTable[325613] = bhEff_E00_Fire_0x23df30; // 0x23dfbc - g_ps2RecompiledFunctionTable[325638] = bhEff_E00_Fire_0x23df30; // 0x23e020 - g_ps2RecompiledFunctionTable[325651] = bhEff_E00_Fire_0x23df30; // 0x23e054 - g_ps2RecompiledFunctionTable[325739] = bhEff_E00_Fire_0x23df30; // 0x23e1b4 - g_ps2RecompiledFunctionTable[325766] = bhEff_E00_Acid_0x23e220; // 0x23e220 - g_ps2RecompiledFunctionTable[325798] = bhEff_E00_Acid_0x23e220; // 0x23e2a0 - g_ps2RecompiledFunctionTable[325816] = bhEff_E00_Acid_0x23e220; // 0x23e2e8 - g_ps2RecompiledFunctionTable[325829] = bhEff_E00_Acid_0x23e220; // 0x23e31c - g_ps2RecompiledFunctionTable[325876] = bhEff_E00_Acid_0x23e220; // 0x23e3d8 - g_ps2RecompiledFunctionTable[325881] = bhEff_E00_Acid_0x23e220; // 0x23e3ec - g_ps2RecompiledFunctionTable[325907] = bhEff_E00_Acid_0x23e220; // 0x23e454 - g_ps2RecompiledFunctionTable[325926] = bhEff_E00_Acid_0x23e220; // 0x23e4a0 - g_ps2RecompiledFunctionTable[325974] = bhEff_E00_AcidGenerator_0x23e560; // 0x23e560 - g_ps2RecompiledFunctionTable[326081] = bhEff_E00_AcidGenerator_0x23e560; // 0x23e70c - g_ps2RecompiledFunctionTable[326083] = bhEff_E00_AcidGenerator_0x23e560; // 0x23e714 - g_ps2RecompiledFunctionTable[326104] = bhEff_E00_AcidGenerator_0x23e560; // 0x23e768 - g_ps2RecompiledFunctionTable[326125] = bhEff_E00_AcidGenerator_0x23e560; // 0x23e7bc - g_ps2RecompiledFunctionTable[326188] = bhEff_E00_AcidGenerator_0x23e560; // 0x23e8b8 - g_ps2RecompiledFunctionTable[326202] = bhEff_E00_BloodBurst_0x23e8f0; // 0x23e8f0 - g_ps2RecompiledFunctionTable[326228] = bhEff_E00_BloodBurst_0x23e8f0; // 0x23e958 - g_ps2RecompiledFunctionTable[326232] = bhEff_E00_BloodBurst_0x23e8f0; // 0x23e968 - g_ps2RecompiledFunctionTable[326263] = bhEff_E00_BloodBurst_0x23e8f0; // 0x23e9e4 - g_ps2RecompiledFunctionTable[326287] = bhEff_E00_BloodBurst_0x23e8f0; // 0x23ea44 - g_ps2RecompiledFunctionTable[326363] = bhEff_E00_BloodBurst_0x23e8f0; // 0x23eb74 - g_ps2RecompiledFunctionTable[326372] = bhEff_E00_BloodBurst_0x23e8f0; // 0x23eb98 - g_ps2RecompiledFunctionTable[326430] = bhEff_E00_Blood_0x23ec80; // 0x23ec80 - g_ps2RecompiledFunctionTable[326449] = bhEff_E00_Blood_0x23ec80; // 0x23eccc - g_ps2RecompiledFunctionTable[326533] = bhEff_E00_Blood_0x23ec80; // 0x23ee1c - g_ps2RecompiledFunctionTable[326562] = bhEff_E00_Dust_0x23ee90; // 0x23ee90 - g_ps2RecompiledFunctionTable[326576] = bhEff_E00_Dust_0x23ee90; // 0x23eec8 - g_ps2RecompiledFunctionTable[326600] = bhEff_E00_Dust_0x23ee90; // 0x23ef28 - g_ps2RecompiledFunctionTable[326622] = bhEff_E00_Dust_0x23ee90; // 0x23ef80 - g_ps2RecompiledFunctionTable[326674] = bhEff_E02_SandDust_0x23f050; // 0x23f050 - g_ps2RecompiledFunctionTable[326688] = bhEff_E02_SandDust_0x23f050; // 0x23f088 - g_ps2RecompiledFunctionTable[326692] = bhEff_E02_SandDust_0x23f050; // 0x23f098 - g_ps2RecompiledFunctionTable[326778] = bhEff_E02_SandDust_0x23f050; // 0x23f1f0 - g_ps2RecompiledFunctionTable[326806] = bhEff_E02_SandParticle_0x23f260; // 0x23f260 - g_ps2RecompiledFunctionTable[326832] = bhEff_E02_SandParticle_0x23f260; // 0x23f2c8 - g_ps2RecompiledFunctionTable[326844] = bhEff_E02_SandParticle_0x23f260; // 0x23f2f8 - g_ps2RecompiledFunctionTable[326846] = bhEff_E02_SandParticle_0x23f260; // 0x23f300 - g_ps2RecompiledFunctionTable[326858] = bhEff_E02_SandParticle_0x23f260; // 0x23f330 - g_ps2RecompiledFunctionTable[326870] = bhEff_E02_SandParticle_0x23f260; // 0x23f360 - g_ps2RecompiledFunctionTable[326882] = bhEff_E02_SandParticle_0x23f260; // 0x23f390 - g_ps2RecompiledFunctionTable[326894] = bhEff_E02_SandParticle_0x23f260; // 0x23f3c0 - g_ps2RecompiledFunctionTable[326906] = bhEff_E02_SandParticle_0x23f260; // 0x23f3f0 - g_ps2RecompiledFunctionTable[326918] = bhEff_E02_SandParticle_0x23f260; // 0x23f420 - g_ps2RecompiledFunctionTable[326930] = bhEff_E02_SandParticle_0x23f260; // 0x23f450 - g_ps2RecompiledFunctionTable[326942] = bhEff_E02_SandParticle_0x23f260; // 0x23f480 - g_ps2RecompiledFunctionTable[326954] = bhEff_E02_SandParticle_0x23f260; // 0x23f4b0 - g_ps2RecompiledFunctionTable[326966] = bhEff_E02_SandParticle_0x23f260; // 0x23f4e0 - g_ps2RecompiledFunctionTable[326978] = bhEff_E02_SandParticle_0x23f260; // 0x23f510 - g_ps2RecompiledFunctionTable[327005] = bhEff_E02_SandParticle_0x23f260; // 0x23f57c - g_ps2RecompiledFunctionTable[327018] = bhEff_E02_SandParticle_0x23f260; // 0x23f5b0 - g_ps2RecompiledFunctionTable[327041] = bhEff_E02_SandParticle_0x23f260; // 0x23f60c - g_ps2RecompiledFunctionTable[327110] = bhEff_E02_SandParticle2_0x23f720; // 0x23f720 - g_ps2RecompiledFunctionTable[327124] = bhEff_E02_SandParticle2_0x23f720; // 0x23f758 - g_ps2RecompiledFunctionTable[327138] = bhEff_E02_SandParticle2_0x23f720; // 0x23f790 - g_ps2RecompiledFunctionTable[327149] = bhEff_E02_SandParticle2_0x23f720; // 0x23f7bc - g_ps2RecompiledFunctionTable[327219] = bhEff_E02_SandParticle2_0x23f720; // 0x23f8d4 - g_ps2RecompiledFunctionTable[327246] = bhEff_E03_Acid_0x23f940; // 0x23f940 - g_ps2RecompiledFunctionTable[327281] = bhEff_E03_Acid_0x23f940; // 0x23f9cc - g_ps2RecompiledFunctionTable[327289] = bhEff_E03_Acid_0x23f940; // 0x23f9ec - g_ps2RecompiledFunctionTable[327298] = bhEff_E03_Acid_0x23f940; // 0x23fa10 - g_ps2RecompiledFunctionTable[327340] = bhEff_E03_Acid_0x23f940; // 0x23fab8 - g_ps2RecompiledFunctionTable[327353] = bhEff_E03_Acid_0x23f940; // 0x23faec - g_ps2RecompiledFunctionTable[327429] = bhEff_E03_Acid_0x23f940; // 0x23fc1c - g_ps2RecompiledFunctionTable[327450] = bhEff_E03_Acid_0x23f940; // 0x23fc70 - g_ps2RecompiledFunctionTable[327460] = bhEff_E03_Acid_0x23f940; // 0x23fc98 - g_ps2RecompiledFunctionTable[327500] = bhEff_E03_Acid_0x23f940; // 0x23fd38 - g_ps2RecompiledFunctionTable[327595] = bhEff_E03_Acid_0x23f940; // 0x23feb4 - g_ps2RecompiledFunctionTable[327606] = bhEff_E03_Acid_0x23f940; // 0x23fee0 - g_ps2RecompiledFunctionTable[327610] = bhEff_E03_Acid_0x23f940; // 0x23fef0 - g_ps2RecompiledFunctionTable[327612] = bhEff_E03_Acid_0x23f940; // 0x23fef8 - g_ps2RecompiledFunctionTable[327615] = bhEff_E03_Acid_0x23f940; // 0x23ff04 - g_ps2RecompiledFunctionTable[327624] = bhEff_E03_Acid_0x23f940; // 0x23ff28 - g_ps2RecompiledFunctionTable[327723] = bhEff_E03_Acid_0x23f940; // 0x2400b4 - g_ps2RecompiledFunctionTable[327796] = bhEff_E03_Acid_0x23f940; // 0x2401d8 - g_ps2RecompiledFunctionTable[327806] = bhEff_E03_Acid_0x23f940; // 0x240200 - g_ps2RecompiledFunctionTable[327815] = bhEff_E03_Acid_0x23f940; // 0x240224 - g_ps2RecompiledFunctionTable[327902] = bhEff_E03_Acid_0x23f940; // 0x240380 - g_ps2RecompiledFunctionTable[327910] = bhEff_E03_Acid_0x23f940; // 0x2403a0 - g_ps2RecompiledFunctionTable[327920] = bhEff_E03_Acid_0x23f940; // 0x2403c8 - g_ps2RecompiledFunctionTable[327951] = bhEff_E03_Acid_0x23f940; // 0x240444 - g_ps2RecompiledFunctionTable[327978] = bhEff_E03_Shadow_0x2404b0; // 0x2404b0 - g_ps2RecompiledFunctionTable[328046] = bhEff_E05_Blood_0x2405c0; // 0x2405c0 - g_ps2RecompiledFunctionTable[328060] = bhEff_E05_Blood_0x2405c0; // 0x2405f8 - g_ps2RecompiledFunctionTable[328104] = bhEff_E05_Blood_0x2405c0; // 0x2406a8 - g_ps2RecompiledFunctionTable[328134] = bhEff_E06_Rinpun_0x240720; // 0x240720 - g_ps2RecompiledFunctionTable[328162] = bhEff_E06_Rinpun_0x240720; // 0x240790 - g_ps2RecompiledFunctionTable[328174] = bhEff_E06_Rinpun_0x240720; // 0x2407c0 - g_ps2RecompiledFunctionTable[328176] = bhEff_E06_Rinpun_0x240720; // 0x2407c8 - g_ps2RecompiledFunctionTable[328193] = bhEff_E06_Rinpun_0x240720; // 0x24080c - g_ps2RecompiledFunctionTable[328210] = bhEff_E06_Rinpun_0x240720; // 0x240850 - g_ps2RecompiledFunctionTable[328227] = bhEff_E06_Rinpun_0x240720; // 0x240894 - g_ps2RecompiledFunctionTable[328246] = bhEff_E06_Rinpun_0x240720; // 0x2408e0 - g_ps2RecompiledFunctionTable[328252] = bhEff_E06_Rinpun_0x240720; // 0x2408f8 - g_ps2RecompiledFunctionTable[328261] = bhEff_E06_Rinpun_0x240720; // 0x24091c - g_ps2RecompiledFunctionTable[328281] = bhEff_E06_Rinpun_0x240720; // 0x24096c - g_ps2RecompiledFunctionTable[328311] = bhEff_E06_Rinpun_0x240720; // 0x2409e4 - g_ps2RecompiledFunctionTable[328324] = bhEff_E06_Rinpun_0x240720; // 0x240a18 - g_ps2RecompiledFunctionTable[328336] = bhEff_E06_Rinpun_0x240720; // 0x240a48 - g_ps2RecompiledFunctionTable[328349] = bhEff_E06_Rinpun_0x240720; // 0x240a7c - g_ps2RecompiledFunctionTable[328374] = bhEff_E06_Rinpun_0x240720; // 0x240ae0 - g_ps2RecompiledFunctionTable[328376] = bhEff_E06_Rinpun_0x240720; // 0x240ae8 - g_ps2RecompiledFunctionTable[328398] = bhEff_E06_Rinpun_0x240720; // 0x240b40 - g_ps2RecompiledFunctionTable[328420] = bhEff_E06_Rinpun_0x240720; // 0x240b98 - g_ps2RecompiledFunctionTable[328491] = bhEff_E06_Rinpun_0x240720; // 0x240cb4 - g_ps2RecompiledFunctionTable[328523] = bhEff_E06_Rinpun_0x240720; // 0x240d34 - g_ps2RecompiledFunctionTable[328548] = bhEff_E06_Rinpun_0x240720; // 0x240d98 - g_ps2RecompiledFunctionTable[328564] = bhEff_E06_Rinpun_0x240720; // 0x240dd8 - g_ps2RecompiledFunctionTable[328577] = bhEff_E06_Rinpun_0x240720; // 0x240e0c - g_ps2RecompiledFunctionTable[328587] = bhEff_E06_Rinpun_0x240720; // 0x240e34 - g_ps2RecompiledFunctionTable[328600] = bhEff_E06_Rinpun_0x240720; // 0x240e68 - g_ps2RecompiledFunctionTable[328662] = bhEff_E11_SearchLight_0x240f60; // 0x240f60 - g_ps2RecompiledFunctionTable[328694] = bhEff_E11_SearchLight_0x240f60; // 0x240fe0 - g_ps2RecompiledFunctionTable[328748] = bhEff_E11_SearchLight_0x240f60; // 0x2410b8 - g_ps2RecompiledFunctionTable[328760] = bhEff_E11_SearchLight_0x240f60; // 0x2410e8 - g_ps2RecompiledFunctionTable[328772] = bhEff_E11_SearchLight_0x240f60; // 0x241118 - g_ps2RecompiledFunctionTable[328806] = bhEff_E11_SearchLightDraw_0x2411a0; // 0x2411a0 - g_ps2RecompiledFunctionTable[328839] = bhEff_E11_SearchLightDraw_0x2411a0; // 0x241224 - g_ps2RecompiledFunctionTable[328850] = bhEff_E11_SearchLightDraw_0x2411a0; // 0x241250 - g_ps2RecompiledFunctionTable[328852] = bhEff_E11_SearchLightDraw_0x2411a0; // 0x241258 - g_ps2RecompiledFunctionTable[328862] = bhEff_E11_SearchLightDraw_0x2411a0; // 0x241280 - g_ps2RecompiledFunctionTable[328872] = bhEff_E11_SearchLightDraw_0x2411a0; // 0x2412a8 - g_ps2RecompiledFunctionTable[328875] = bhEff_E11_SearchLightDraw_0x2411a0; // 0x2412b4 - g_ps2RecompiledFunctionTable[328877] = bhEff_E11_SearchLightDraw_0x2411a0; // 0x2412bc - g_ps2RecompiledFunctionTable[328893] = bhEff_E11_SearchLightDraw_0x2411a0; // 0x2412fc - g_ps2RecompiledFunctionTable[328897] = bhEff_E11_SearchLightDraw_0x2411a0; // 0x24130c - g_ps2RecompiledFunctionTable[328902] = bhEff_E11_SearchLightDraw_0x2411a0; // 0x241320 - g_ps2RecompiledFunctionTable[328974] = bhEff_E11_SearchLightDraw_0x2411a0; // 0x241440 - g_ps2RecompiledFunctionTable[328979] = bhEff_E11_SearchLightDraw_0x2411a0; // 0x241454 - g_ps2RecompiledFunctionTable[328982] = bhEff_E11_SearchLightDraw_0x2411a0; // 0x241460 - g_ps2RecompiledFunctionTable[329000] = bhEff_E11_SearchLightDraw_0x2411a0; // 0x2414a8 - g_ps2RecompiledFunctionTable[329003] = bhEff_E11_SearchLightDraw_0x2411a0; // 0x2414b4 - g_ps2RecompiledFunctionTable[329006] = bhEff_E11_SearchLightDraw_0x2411a0; // 0x2414c0 - g_ps2RecompiledFunctionTable[329008] = bhEff_E11_SearchLightDraw_0x2411a0; // 0x2414c8 - g_ps2RecompiledFunctionTable[329012] = bhEff_E11_SearchLightDraw_0x2411a0; // 0x2414d8 - g_ps2RecompiledFunctionTable[329031] = bhEff_E11_SearchLightDraw_0x2411a0; // 0x241524 - g_ps2RecompiledFunctionTable[329053] = bhEff_E11_SearchLightDraw_0x2411a0; // 0x24157c - g_ps2RecompiledFunctionTable[329062] = bhEff_E11_SearchLightDraw_0x2411a0; // 0x2415a0 - g_ps2RecompiledFunctionTable[329071] = bhEff_E11_SearchLightDraw_0x2411a0; // 0x2415c4 - g_ps2RecompiledFunctionTable[329081] = bhEff_E11_SearchLightDraw_0x2411a0; // 0x2415ec - g_ps2RecompiledFunctionTable[329090] = bhEff_E11_SearchLightDraw_0x2411a0; // 0x241610 - g_ps2RecompiledFunctionTable[329107] = bhEff_E11_SearchLightDraw_0x2411a0; // 0x241654 - g_ps2RecompiledFunctionTable[329131] = bhEff_E11_SearchLightDraw_0x2411a0; // 0x2416b4 - g_ps2RecompiledFunctionTable[329143] = bhEff_E11_SearchLightDraw_0x2411a0; // 0x2416e4 - g_ps2RecompiledFunctionTable[329149] = bhEff_E11_SearchLightDraw_0x2411a0; // 0x2416fc - g_ps2RecompiledFunctionTable[329182] = bhEff_E11_SearchLightDraw_0x2411a0; // 0x241780 - g_ps2RecompiledFunctionTable[329193] = bhEff_E11_SearchLightDraw_0x2411a0; // 0x2417ac - g_ps2RecompiledFunctionTable[329198] = bhEff_E11_SearchLightDraw_0x2411a0; // 0x2417c0 - g_ps2RecompiledFunctionTable[329258] = bhEff_E11_SearchLightDraw_0x2411a0; // 0x2418b0 - g_ps2RecompiledFunctionTable[329273] = bhEff_E11_SearchLightDraw_0x2411a0; // 0x2418ec - g_ps2RecompiledFunctionTable[329286] = bhEff_E11_SearchLightDraw_0x2411a0; // 0x241920 - g_ps2RecompiledFunctionTable[329319] = bhEff_E11_SearchLightDraw_0x2411a0; // 0x2419a4 - g_ps2RecompiledFunctionTable[329321] = bhEff_E11_SearchLightDraw_0x2411a0; // 0x2419ac - g_ps2RecompiledFunctionTable[329329] = bhEff_E11_SearchLightDraw_0x2411a0; // 0x2419cc - g_ps2RecompiledFunctionTable[329346] = bhEff_E11_CheckCollisionPlayer_0x241a10; // 0x241a10 - g_ps2RecompiledFunctionTable[329370] = bhEff_E11_CheckCollisionPlayer_0x241a10; // 0x241a70 - g_ps2RecompiledFunctionTable[329377] = bhEff_E11_CheckCollisionPlayer_0x241a10; // 0x241a8c - g_ps2RecompiledFunctionTable[329390] = bhEff_E11_CheckCollisionPlayer_0x241a10; // 0x241ac0 - g_ps2RecompiledFunctionTable[329416] = bhEff_E11_CheckCollisionPlayer_0x241a10; // 0x241b28 - g_ps2RecompiledFunctionTable[329423] = bhEff_E11_CheckCollisionPlayer_0x241a10; // 0x241b44 - g_ps2RecompiledFunctionTable[329458] = bhEff_E16_LaserSight_0x241bd0; // 0x241bd0 - g_ps2RecompiledFunctionTable[329510] = bhEff_E16_LaserSightDraw_0x241ca0; // 0x241ca0 - g_ps2RecompiledFunctionTable[329552] = bhEff_E16_LaserSightDraw_0x241ca0; // 0x241d48 - g_ps2RecompiledFunctionTable[329563] = bhEff_E16_LaserSightDraw_0x241ca0; // 0x241d74 - g_ps2RecompiledFunctionTable[329575] = bhEff_E16_LaserSightDraw_0x241ca0; // 0x241da4 - g_ps2RecompiledFunctionTable[329587] = bhEff_E16_LaserSightDraw_0x241ca0; // 0x241dd4 - g_ps2RecompiledFunctionTable[329600] = bhEff_E16_LaserSightDraw_0x241ca0; // 0x241e08 - g_ps2RecompiledFunctionTable[329607] = bhEff_E16_LaserSightDraw_0x241ca0; // 0x241e24 - g_ps2RecompiledFunctionTable[329618] = bhEff_E16_LaserSightDraw_0x241ca0; // 0x241e50 - g_ps2RecompiledFunctionTable[329620] = bhEff_E16_LaserSightDraw_0x241ca0; // 0x241e58 - g_ps2RecompiledFunctionTable[329627] = bhEff_E16_LaserSightDraw_0x241ca0; // 0x241e74 - g_ps2RecompiledFunctionTable[329629] = bhEff_E16_LaserSightDraw_0x241ca0; // 0x241e7c - g_ps2RecompiledFunctionTable[329640] = bhEff_E16_LaserSightDraw_0x241ca0; // 0x241ea8 - g_ps2RecompiledFunctionTable[329647] = bhEff_E16_LaserSightDraw_0x241ca0; // 0x241ec4 - g_ps2RecompiledFunctionTable[329651] = bhEff_E16_LaserSightDraw_0x241ca0; // 0x241ed4 - g_ps2RecompiledFunctionTable[329656] = bhEff_E16_LaserSightDraw_0x241ca0; // 0x241ee8 - g_ps2RecompiledFunctionTable[329705] = bhEff_E16_LaserSightDraw_0x241ca0; // 0x241fac - g_ps2RecompiledFunctionTable[329708] = bhEff_E16_LaserSightDraw_0x241ca0; // 0x241fb8 - g_ps2RecompiledFunctionTable[329711] = bhEff_E16_LaserSightDraw_0x241ca0; // 0x241fc4 - g_ps2RecompiledFunctionTable[329713] = bhEff_E16_LaserSightDraw_0x241ca0; // 0x241fcc - g_ps2RecompiledFunctionTable[329717] = bhEff_E16_LaserSightDraw_0x241ca0; // 0x241fdc - g_ps2RecompiledFunctionTable[329758] = bhEff_E16_LaserSightDraw_0x241ca0; // 0x242080 - g_ps2RecompiledFunctionTable[329764] = bhEff_E16_LaserSightDraw_0x241ca0; // 0x242098 - g_ps2RecompiledFunctionTable[329767] = bhEff_E16_LaserSightDraw_0x241ca0; // 0x2420a4 - g_ps2RecompiledFunctionTable[329773] = bhEff_E16_LaserSightDraw_0x241ca0; // 0x2420bc - g_ps2RecompiledFunctionTable[329789] = bhEff_E16_LaserSightDraw_0x241ca0; // 0x2420fc - g_ps2RecompiledFunctionTable[329825] = bhEff_E16_LaserSightDraw_0x241ca0; // 0x24218c - g_ps2RecompiledFunctionTable[329848] = bhEff_E16_LaserSightDraw_0x241ca0; // 0x2421e8 - g_ps2RecompiledFunctionTable[329855] = bhEff_E16_LaserSightDraw_0x241ca0; // 0x242204 - g_ps2RecompiledFunctionTable[329861] = bhEff_E16_LaserSightDraw_0x241ca0; // 0x24221c - g_ps2RecompiledFunctionTable[329889] = bhEff_E16_LaserSightDraw_0x241ca0; // 0x24228c - g_ps2RecompiledFunctionTable[329895] = bhEff_E16_LaserSightDraw_0x241ca0; // 0x2422a4 - g_ps2RecompiledFunctionTable[329900] = bhEff_E16_LaserSightDraw_0x241ca0; // 0x2422b8 - g_ps2RecompiledFunctionTable[329902] = bhEff_E16_LaserSightDraw_0x241ca0; // 0x2422c0 - g_ps2RecompiledFunctionTable[329910] = bhEff_E16_LaserSightDraw_0x241ca0; // 0x2422e0 - g_ps2RecompiledFunctionTable[329926] = bhEff_E12_Fire_0x242320; // 0x242320 - g_ps2RecompiledFunctionTable[329927] = bhEff_E12_Fire_0x242320; // 0x242324 - g_ps2RecompiledFunctionTable[329928] = bhEff_E12_Fire_0x242320; // 0x242328 - g_ps2RecompiledFunctionTable[329929] = bhEff_E12_Fire_0x242320; // 0x24232c - g_ps2RecompiledFunctionTable[329930] = bhEff_E12_Fire_0x242320; // 0x242330 - g_ps2RecompiledFunctionTable[329931] = bhEff_E12_Fire_0x242320; // 0x242334 - g_ps2RecompiledFunctionTable[329932] = bhEff_E12_Fire_0x242320; // 0x242338 - g_ps2RecompiledFunctionTable[329933] = bhEff_E12_Fire_0x242320; // 0x24233c - g_ps2RecompiledFunctionTable[329934] = bhEff_E12_Fire_0x242320; // 0x242340 - g_ps2RecompiledFunctionTable[329935] = bhEff_E12_Fire_0x242320; // 0x242344 - g_ps2RecompiledFunctionTable[329936] = bhEff_E12_Fire_0x242320; // 0x242348 - g_ps2RecompiledFunctionTable[329937] = bhEff_E12_Fire_0x242320; // 0x24234c - g_ps2RecompiledFunctionTable[329938] = bhEff_E12_Fire_0x242320; // 0x242350 - g_ps2RecompiledFunctionTable[329939] = bhEff_E12_Fire_0x242320; // 0x242354 - g_ps2RecompiledFunctionTable[329940] = bhEff_E12_Fire_0x242320; // 0x242358 - g_ps2RecompiledFunctionTable[329941] = bhEff_E12_Fire_0x242320; // 0x24235c - g_ps2RecompiledFunctionTable[329942] = bhEff_E12_Fire_0x242320; // 0x242360 - g_ps2RecompiledFunctionTable[329943] = bhEff_E12_Fire_0x242320; // 0x242364 - g_ps2RecompiledFunctionTable[329944] = bhEff_E12_Fire_0x242320; // 0x242368 - g_ps2RecompiledFunctionTable[329945] = bhEff_E12_Fire_0x242320; // 0x24236c - g_ps2RecompiledFunctionTable[329946] = bhEff_E12_Fire_0x242320; // 0x242370 - g_ps2RecompiledFunctionTable[329947] = bhEff_E12_Fire_0x242320; // 0x242374 - g_ps2RecompiledFunctionTable[329948] = bhEff_E12_Fire_0x242320; // 0x242378 - g_ps2RecompiledFunctionTable[329949] = bhEff_E12_Fire_0x242320; // 0x24237c - g_ps2RecompiledFunctionTable[329950] = bhEff_E12_Fire_0x242320; // 0x242380 - g_ps2RecompiledFunctionTable[329951] = bhEff_E12_Fire_0x242320; // 0x242384 - g_ps2RecompiledFunctionTable[329952] = bhEff_E12_Fire_0x242320; // 0x242388 - g_ps2RecompiledFunctionTable[329953] = bhEff_E12_Fire_0x242320; // 0x24238c - g_ps2RecompiledFunctionTable[329954] = bhEff_E12_Fire_0x242320; // 0x242390 - g_ps2RecompiledFunctionTable[329955] = bhEff_E12_Fire_0x242320; // 0x242394 - g_ps2RecompiledFunctionTable[329956] = bhEff_E12_Fire_0x242320; // 0x242398 - g_ps2RecompiledFunctionTable[329957] = bhEff_E12_Fire_0x242320; // 0x24239c - g_ps2RecompiledFunctionTable[329958] = bhEff_E12_Fire_0x242320; // 0x2423a0 - g_ps2RecompiledFunctionTable[329959] = bhEff_E12_Fire_0x242320; // 0x2423a4 - g_ps2RecompiledFunctionTable[329960] = bhEff_E12_Fire_0x242320; // 0x2423a8 - g_ps2RecompiledFunctionTable[329961] = bhEff_E12_Fire_0x242320; // 0x2423ac - g_ps2RecompiledFunctionTable[329962] = bhEff_E12_Fire_0x242320; // 0x2423b0 - g_ps2RecompiledFunctionTable[329963] = bhEff_E12_Fire_0x242320; // 0x2423b4 - g_ps2RecompiledFunctionTable[329964] = bhEff_E12_Fire_0x242320; // 0x2423b8 - g_ps2RecompiledFunctionTable[329965] = bhEff_E12_Fire_0x242320; // 0x2423bc - g_ps2RecompiledFunctionTable[329966] = bhEff_E12_Fire_0x242320; // 0x2423c0 - g_ps2RecompiledFunctionTable[329967] = bhEff_E12_Fire_0x242320; // 0x2423c4 - g_ps2RecompiledFunctionTable[329968] = bhEff_E12_Fire_0x242320; // 0x2423c8 - g_ps2RecompiledFunctionTable[329969] = bhEff_E12_Fire_0x242320; // 0x2423cc - g_ps2RecompiledFunctionTable[329970] = bhEff_E12_Fire_0x242320; // 0x2423d0 - g_ps2RecompiledFunctionTable[329971] = bhEff_E12_Fire_0x242320; // 0x2423d4 - g_ps2RecompiledFunctionTable[329972] = bhEff_E12_Fire_0x242320; // 0x2423d8 - g_ps2RecompiledFunctionTable[329973] = bhEff_E12_Fire_0x242320; // 0x2423dc - g_ps2RecompiledFunctionTable[329974] = bhEff_E12_Fire_0x242320; // 0x2423e0 - g_ps2RecompiledFunctionTable[329975] = bhEff_E12_Fire_0x242320; // 0x2423e4 - g_ps2RecompiledFunctionTable[329976] = bhEff_E12_Fire_0x242320; // 0x2423e8 - g_ps2RecompiledFunctionTable[329977] = bhEff_E12_Fire_0x242320; // 0x2423ec - g_ps2RecompiledFunctionTable[329978] = bhEff_E12_Fire_0x242320; // 0x2423f0 - g_ps2RecompiledFunctionTable[329979] = bhEff_E12_Fire_0x242320; // 0x2423f4 - g_ps2RecompiledFunctionTable[329980] = bhEff_E12_Fire_0x242320; // 0x2423f8 - g_ps2RecompiledFunctionTable[329981] = bhEff_E12_Fire_0x242320; // 0x2423fc - g_ps2RecompiledFunctionTable[329982] = bhEff_E12_Fire_0x242320; // 0x242400 - g_ps2RecompiledFunctionTable[329983] = bhEff_E12_Fire_0x242320; // 0x242404 - g_ps2RecompiledFunctionTable[329984] = bhEff_E12_Fire_0x242320; // 0x242408 - g_ps2RecompiledFunctionTable[329985] = bhEff_E12_Fire_0x242320; // 0x24240c - g_ps2RecompiledFunctionTable[329986] = bhEff_E12_Fire_0x242320; // 0x242410 - g_ps2RecompiledFunctionTable[329987] = bhEff_E12_Fire_0x242320; // 0x242414 - g_ps2RecompiledFunctionTable[329988] = bhEff_E12_Fire_0x242320; // 0x242418 - g_ps2RecompiledFunctionTable[329989] = bhEff_E12_Fire_0x242320; // 0x24241c - g_ps2RecompiledFunctionTable[329990] = bhEff_E12_Fire_0x242320; // 0x242420 - g_ps2RecompiledFunctionTable[329991] = bhEff_E12_Fire_0x242320; // 0x242424 - g_ps2RecompiledFunctionTable[329992] = bhEff_E12_Fire_0x242320; // 0x242428 - g_ps2RecompiledFunctionTable[329993] = bhEff_E12_Fire_0x242320; // 0x24242c - g_ps2RecompiledFunctionTable[329994] = bhEff_E12_Fire_0x242320; // 0x242430 - g_ps2RecompiledFunctionTable[329995] = bhEff_E12_Fire_0x242320; // 0x242434 - g_ps2RecompiledFunctionTable[329996] = bhEff_E12_Fire_0x242320; // 0x242438 - g_ps2RecompiledFunctionTable[329997] = bhEff_E12_Fire_0x242320; // 0x24243c - g_ps2RecompiledFunctionTable[329998] = bhEff_E12_Fire_0x242320; // 0x242440 - g_ps2RecompiledFunctionTable[329999] = bhEff_E12_Fire_0x242320; // 0x242444 - g_ps2RecompiledFunctionTable[330000] = bhEff_E12_Fire_0x242320; // 0x242448 - g_ps2RecompiledFunctionTable[330001] = bhEff_E12_Fire_0x242320; // 0x24244c - g_ps2RecompiledFunctionTable[330002] = bhEff_E12_Fire_0x242320; // 0x242450 - g_ps2RecompiledFunctionTable[330003] = bhEff_E12_Fire_0x242320; // 0x242454 - g_ps2RecompiledFunctionTable[330004] = bhEff_E12_Fire_0x242320; // 0x242458 - g_ps2RecompiledFunctionTable[330005] = bhEff_E12_Fire_0x242320; // 0x24245c - g_ps2RecompiledFunctionTable[330006] = bhEff_E12_Fire_0x242320; // 0x242460 - g_ps2RecompiledFunctionTable[330007] = bhEff_E12_Fire_0x242320; // 0x242464 - g_ps2RecompiledFunctionTable[330008] = bhEff_E12_Fire_0x242320; // 0x242468 - g_ps2RecompiledFunctionTable[330009] = bhEff_E12_Fire_0x242320; // 0x24246c - g_ps2RecompiledFunctionTable[330010] = bhEff_E12_Fire_0x242320; // 0x242470 - g_ps2RecompiledFunctionTable[330011] = bhEff_E12_Fire_0x242320; // 0x242474 - g_ps2RecompiledFunctionTable[330012] = bhEff_E12_Fire_0x242320; // 0x242478 - g_ps2RecompiledFunctionTable[330013] = bhEff_E12_Fire_0x242320; // 0x24247c - g_ps2RecompiledFunctionTable[330014] = bhEff_E12_Fire_0x242320; // 0x242480 - g_ps2RecompiledFunctionTable[330015] = bhEff_E12_Fire_0x242320; // 0x242484 - g_ps2RecompiledFunctionTable[330016] = bhEff_E12_Fire_0x242320; // 0x242488 - g_ps2RecompiledFunctionTable[330017] = bhEff_E12_Fire_0x242320; // 0x24248c - g_ps2RecompiledFunctionTable[330018] = bhEff_E12_Fire_0x242320; // 0x242490 - g_ps2RecompiledFunctionTable[330019] = bhEff_E12_Fire_0x242320; // 0x242494 - g_ps2RecompiledFunctionTable[330020] = bhEff_E12_Fire_0x242320; // 0x242498 - g_ps2RecompiledFunctionTable[330021] = bhEff_E12_Fire_0x242320; // 0x24249c - g_ps2RecompiledFunctionTable[330022] = bhEff_E12_Fire_0x242320; // 0x2424a0 - g_ps2RecompiledFunctionTable[330023] = bhEff_E12_Fire_0x242320; // 0x2424a4 - g_ps2RecompiledFunctionTable[330024] = bhEff_E12_Fire_0x242320; // 0x2424a8 - g_ps2RecompiledFunctionTable[330025] = bhEff_E12_Fire_0x242320; // 0x2424ac - g_ps2RecompiledFunctionTable[330026] = bhEff_E12_Fire_0x242320; // 0x2424b0 - g_ps2RecompiledFunctionTable[330027] = bhEff_E12_Fire_0x242320; // 0x2424b4 - g_ps2RecompiledFunctionTable[330028] = bhEff_E12_Fire_0x242320; // 0x2424b8 - g_ps2RecompiledFunctionTable[330029] = bhEff_E12_Fire_0x242320; // 0x2424bc - g_ps2RecompiledFunctionTable[330030] = bhEff_E12_Fire_0x242320; // 0x2424c0 - g_ps2RecompiledFunctionTable[330031] = bhEff_E12_Fire_0x242320; // 0x2424c4 - g_ps2RecompiledFunctionTable[330032] = bhEff_E12_Fire_0x242320; // 0x2424c8 - g_ps2RecompiledFunctionTable[330033] = bhEff_E12_Fire_0x242320; // 0x2424cc - g_ps2RecompiledFunctionTable[330034] = bhEff_E12_Fire_0x242320; // 0x2424d0 - g_ps2RecompiledFunctionTable[330035] = bhEff_E12_Fire_0x242320; // 0x2424d4 - g_ps2RecompiledFunctionTable[330036] = bhEff_E12_Fire_0x242320; // 0x2424d8 - g_ps2RecompiledFunctionTable[330037] = bhEff_E12_Fire_0x242320; // 0x2424dc - g_ps2RecompiledFunctionTable[330038] = bhEff_E12_Fire_0x242320; // 0x2424e0 - g_ps2RecompiledFunctionTable[330039] = bhEff_E12_Fire_0x242320; // 0x2424e4 - g_ps2RecompiledFunctionTable[330040] = bhEff_E12_Fire_0x242320; // 0x2424e8 - g_ps2RecompiledFunctionTable[330041] = bhEff_E12_Fire_0x242320; // 0x2424ec - g_ps2RecompiledFunctionTable[330042] = bhEff_E12_Fire_0x242320; // 0x2424f0 - g_ps2RecompiledFunctionTable[330043] = bhEff_E12_Fire_0x242320; // 0x2424f4 - g_ps2RecompiledFunctionTable[330044] = bhEff_E12_Fire_0x242320; // 0x2424f8 - g_ps2RecompiledFunctionTable[330045] = bhEff_E12_Fire_0x242320; // 0x2424fc - g_ps2RecompiledFunctionTable[330046] = bhEff_E12_Fire_0x242320; // 0x242500 - g_ps2RecompiledFunctionTable[330047] = bhEff_E12_Fire_0x242320; // 0x242504 - g_ps2RecompiledFunctionTable[330048] = bhEff_E12_Fire_0x242320; // 0x242508 - g_ps2RecompiledFunctionTable[330049] = bhEff_E12_Fire_0x242320; // 0x24250c - g_ps2RecompiledFunctionTable[330050] = bhEff_E12_Fire_0x242320; // 0x242510 - g_ps2RecompiledFunctionTable[330051] = bhEff_E12_Fire_0x242320; // 0x242514 - g_ps2RecompiledFunctionTable[330052] = bhEff_E12_Fire_0x242320; // 0x242518 - g_ps2RecompiledFunctionTable[330053] = bhEff_E12_Fire_0x242320; // 0x24251c - g_ps2RecompiledFunctionTable[330054] = bhEff_E12_Fire_0x242320; // 0x242520 - g_ps2RecompiledFunctionTable[330055] = bhEff_E12_Fire_0x242320; // 0x242524 - g_ps2RecompiledFunctionTable[330056] = bhEff_E12_Fire_0x242320; // 0x242528 - g_ps2RecompiledFunctionTable[330057] = bhEff_E12_Fire_0x242320; // 0x24252c - g_ps2RecompiledFunctionTable[330058] = bhEff_E12_Fire_0x242320; // 0x242530 - g_ps2RecompiledFunctionTable[330059] = bhEff_E12_Fire_0x242320; // 0x242534 - g_ps2RecompiledFunctionTable[330060] = bhEff_E12_Fire_0x242320; // 0x242538 - g_ps2RecompiledFunctionTable[330061] = bhEff_E12_Fire_0x242320; // 0x24253c - g_ps2RecompiledFunctionTable[330062] = bhEff_E12_Fire_0x242320; // 0x242540 - g_ps2RecompiledFunctionTable[330063] = bhEff_E12_Fire_0x242320; // 0x242544 - g_ps2RecompiledFunctionTable[330064] = bhEff_E12_Fire_0x242320; // 0x242548 - g_ps2RecompiledFunctionTable[330065] = bhEff_E12_Fire_0x242320; // 0x24254c - g_ps2RecompiledFunctionTable[330066] = bhEff_E12_Fire_0x242320; // 0x242550 - g_ps2RecompiledFunctionTable[330067] = bhEff_E12_Fire_0x242320; // 0x242554 - g_ps2RecompiledFunctionTable[330068] = bhEff_E12_Fire_0x242320; // 0x242558 - g_ps2RecompiledFunctionTable[330069] = bhEff_E12_Fire_0x242320; // 0x24255c - g_ps2RecompiledFunctionTable[330070] = bhEff_E12_Fire_0x242320; // 0x242560 - g_ps2RecompiledFunctionTable[330071] = bhEff_E12_Fire_0x242320; // 0x242564 - g_ps2RecompiledFunctionTable[330072] = bhEff_E12_Fire_0x242320; // 0x242568 - g_ps2RecompiledFunctionTable[330073] = bhEff_E12_Fire_0x242320; // 0x24256c - g_ps2RecompiledFunctionTable[330074] = bhEff_E12_Fire_0x242320; // 0x242570 - g_ps2RecompiledFunctionTable[330075] = bhEff_E12_Fire_0x242320; // 0x242574 - g_ps2RecompiledFunctionTable[330076] = bhEff_E12_Fire_0x242320; // 0x242578 - g_ps2RecompiledFunctionTable[330077] = bhEff_E12_Fire_0x242320; // 0x24257c - g_ps2RecompiledFunctionTable[330078] = bhEff_E12_Fire_0x242320; // 0x242580 - g_ps2RecompiledFunctionTable[330079] = bhEff_E12_Fire_0x242320; // 0x242584 - g_ps2RecompiledFunctionTable[330080] = bhEff_E12_Fire_0x242320; // 0x242588 - g_ps2RecompiledFunctionTable[330081] = bhEff_E12_Fire_0x242320; // 0x24258c - g_ps2RecompiledFunctionTable[330082] = bhEff_E12_Fire_0x242320; // 0x242590 - g_ps2RecompiledFunctionTable[330083] = bhEff_E12_Fire_0x242320; // 0x242594 - g_ps2RecompiledFunctionTable[330084] = bhEff_E12_Fire_0x242320; // 0x242598 - g_ps2RecompiledFunctionTable[330085] = bhEff_E12_Fire_0x242320; // 0x24259c - g_ps2RecompiledFunctionTable[330086] = bhEff_E12_Fire_0x242320; // 0x2425a0 - g_ps2RecompiledFunctionTable[330087] = bhEff_E12_Fire_0x242320; // 0x2425a4 - g_ps2RecompiledFunctionTable[330088] = bhEff_E12_Fire_0x242320; // 0x2425a8 - g_ps2RecompiledFunctionTable[330089] = bhEff_E12_Fire_0x242320; // 0x2425ac - g_ps2RecompiledFunctionTable[330090] = bhEff_E12_Fire_0x242320; // 0x2425b0 - g_ps2RecompiledFunctionTable[330091] = bhEff_E12_Fire_0x242320; // 0x2425b4 - g_ps2RecompiledFunctionTable[330092] = bhEff_E12_Fire_0x242320; // 0x2425b8 - g_ps2RecompiledFunctionTable[330093] = bhEff_E12_Fire_0x242320; // 0x2425bc - g_ps2RecompiledFunctionTable[330094] = bhEff_E12_Fire_0x242320; // 0x2425c0 - g_ps2RecompiledFunctionTable[330095] = bhEff_E12_Fire_0x242320; // 0x2425c4 - g_ps2RecompiledFunctionTable[330096] = bhEff_E12_Fire_0x242320; // 0x2425c8 - g_ps2RecompiledFunctionTable[330097] = bhEff_E12_Fire_0x242320; // 0x2425cc - g_ps2RecompiledFunctionTable[330098] = bhEff_E12_Fire_0x242320; // 0x2425d0 - g_ps2RecompiledFunctionTable[330099] = bhEff_E12_Fire_0x242320; // 0x2425d4 - g_ps2RecompiledFunctionTable[330100] = bhEff_E12_Fire_0x242320; // 0x2425d8 - g_ps2RecompiledFunctionTable[330101] = bhEff_E12_Fire_0x242320; // 0x2425dc - g_ps2RecompiledFunctionTable[330102] = bhEff_E12_Fire_0x242320; // 0x2425e0 - g_ps2RecompiledFunctionTable[330103] = bhEff_E12_Fire_0x242320; // 0x2425e4 - g_ps2RecompiledFunctionTable[330104] = bhEff_E12_Fire_0x242320; // 0x2425e8 - g_ps2RecompiledFunctionTable[330105] = bhEff_E12_Fire_0x242320; // 0x2425ec - g_ps2RecompiledFunctionTable[330106] = bhEff_E12_Fire_0x242320; // 0x2425f0 - g_ps2RecompiledFunctionTable[330107] = bhEff_E12_Fire_0x242320; // 0x2425f4 - g_ps2RecompiledFunctionTable[330108] = bhEff_E12_Fire_0x242320; // 0x2425f8 - g_ps2RecompiledFunctionTable[330109] = bhEff_E12_Fire_0x242320; // 0x2425fc - g_ps2RecompiledFunctionTable[330110] = bhEff_E12_Fire_0x242320; // 0x242600 - g_ps2RecompiledFunctionTable[330111] = bhEff_E12_Fire_0x242320; // 0x242604 - g_ps2RecompiledFunctionTable[330112] = bhEff_E12_Fire_0x242320; // 0x242608 - g_ps2RecompiledFunctionTable[330113] = bhEff_E12_Fire_0x242320; // 0x24260c - g_ps2RecompiledFunctionTable[330114] = bhEff_E12_Fire_0x242320; // 0x242610 - g_ps2RecompiledFunctionTable[330115] = bhEff_E12_Fire_0x242320; // 0x242614 - g_ps2RecompiledFunctionTable[330116] = bhEff_E12_Fire_0x242320; // 0x242618 - g_ps2RecompiledFunctionTable[330117] = bhEff_E12_Fire_0x242320; // 0x24261c - g_ps2RecompiledFunctionTable[330118] = bhEff_E12_Fire_0x242320; // 0x242620 - g_ps2RecompiledFunctionTable[330119] = bhEff_E12_Fire_0x242320; // 0x242624 - g_ps2RecompiledFunctionTable[330120] = bhEff_E12_Fire_0x242320; // 0x242628 - g_ps2RecompiledFunctionTable[330121] = bhEff_E12_Fire_0x242320; // 0x24262c - g_ps2RecompiledFunctionTable[330122] = bhEff_E12_Fire_0x242320; // 0x242630 - g_ps2RecompiledFunctionTable[330123] = bhEff_E12_Fire_0x242320; // 0x242634 - g_ps2RecompiledFunctionTable[330124] = bhEff_E12_Fire_0x242320; // 0x242638 - g_ps2RecompiledFunctionTable[330125] = bhEff_E12_Fire_0x242320; // 0x24263c - g_ps2RecompiledFunctionTable[330126] = bhEff_E12_Fire_0x242320; // 0x242640 - g_ps2RecompiledFunctionTable[330127] = bhEff_E12_Fire_0x242320; // 0x242644 - g_ps2RecompiledFunctionTable[330128] = bhEff_E12_Fire_0x242320; // 0x242648 - g_ps2RecompiledFunctionTable[330129] = bhEff_E12_Fire_0x242320; // 0x24264c - g_ps2RecompiledFunctionTable[330130] = bhEff_E12_Fire_0x242320; // 0x242650 - g_ps2RecompiledFunctionTable[330131] = bhEff_E12_Fire_0x242320; // 0x242654 - g_ps2RecompiledFunctionTable[330132] = bhEff_E12_Fire_0x242320; // 0x242658 - g_ps2RecompiledFunctionTable[330133] = bhEff_E12_Fire_0x242320; // 0x24265c - g_ps2RecompiledFunctionTable[330134] = bhEff_E12_Fire_0x242320; // 0x242660 - g_ps2RecompiledFunctionTable[330135] = bhEff_E12_Fire_0x242320; // 0x242664 - g_ps2RecompiledFunctionTable[330136] = bhEff_E12_Fire_0x242320; // 0x242668 - g_ps2RecompiledFunctionTable[330137] = bhEff_E12_Fire_0x242320; // 0x24266c - g_ps2RecompiledFunctionTable[330138] = bhEff_E12_Fire_0x242320; // 0x242670 - g_ps2RecompiledFunctionTable[330139] = bhEff_E12_Fire_0x242320; // 0x242674 - g_ps2RecompiledFunctionTable[330140] = bhEff_E12_Fire_0x242320; // 0x242678 - g_ps2RecompiledFunctionTable[330141] = bhEff_E12_Fire_0x242320; // 0x24267c - g_ps2RecompiledFunctionTable[330142] = bhEff_E12_Fire_0x242320; // 0x242680 - g_ps2RecompiledFunctionTable[330143] = bhEff_E12_Fire_0x242320; // 0x242684 - g_ps2RecompiledFunctionTable[330144] = bhEff_E12_Fire_0x242320; // 0x242688 - g_ps2RecompiledFunctionTable[330145] = bhEff_E12_Fire_0x242320; // 0x24268c - g_ps2RecompiledFunctionTable[330146] = bhEff_E12_Fire_0x242320; // 0x242690 - g_ps2RecompiledFunctionTable[330147] = bhEff_E12_Fire_0x242320; // 0x242694 - g_ps2RecompiledFunctionTable[330148] = bhEff_E12_Fire_0x242320; // 0x242698 - g_ps2RecompiledFunctionTable[330149] = bhEff_E12_Fire_0x242320; // 0x24269c - g_ps2RecompiledFunctionTable[330150] = bhEff_E12_Fire_0x242320; // 0x2426a0 - g_ps2RecompiledFunctionTable[330151] = bhEff_E12_Fire_0x242320; // 0x2426a4 - g_ps2RecompiledFunctionTable[330152] = bhEff_E12_Fire_0x242320; // 0x2426a8 - g_ps2RecompiledFunctionTable[330153] = bhEff_E12_Fire_0x242320; // 0x2426ac - g_ps2RecompiledFunctionTable[330154] = bhEff_E12_Fire_0x242320; // 0x2426b0 - g_ps2RecompiledFunctionTable[330155] = bhEff_E12_Fire_0x242320; // 0x2426b4 - g_ps2RecompiledFunctionTable[330156] = bhEff_E12_Fire_0x242320; // 0x2426b8 - g_ps2RecompiledFunctionTable[330157] = bhEff_E12_Fire_0x242320; // 0x2426bc - g_ps2RecompiledFunctionTable[330158] = bhEff_E12_Fire_0x242320; // 0x2426c0 - g_ps2RecompiledFunctionTable[330159] = bhEff_E12_Fire_0x242320; // 0x2426c4 - g_ps2RecompiledFunctionTable[330160] = bhEff_E12_Fire_0x242320; // 0x2426c8 - g_ps2RecompiledFunctionTable[330161] = bhEff_E12_Fire_0x242320; // 0x2426cc - g_ps2RecompiledFunctionTable[330162] = bhEff_E12_Fire_0x242320; // 0x2426d0 - g_ps2RecompiledFunctionTable[330163] = bhEff_E12_Fire_0x242320; // 0x2426d4 - g_ps2RecompiledFunctionTable[330164] = bhEff_E12_Fire_0x242320; // 0x2426d8 - g_ps2RecompiledFunctionTable[330165] = bhEff_E12_Fire_0x242320; // 0x2426dc - g_ps2RecompiledFunctionTable[330166] = bhEff_E12_Fire_0x242320; // 0x2426e0 - g_ps2RecompiledFunctionTable[330167] = bhEff_E12_Fire_0x242320; // 0x2426e4 - g_ps2RecompiledFunctionTable[330168] = bhEff_E12_Fire_0x242320; // 0x2426e8 - g_ps2RecompiledFunctionTable[330169] = bhEff_E12_Fire_0x242320; // 0x2426ec - g_ps2RecompiledFunctionTable[330170] = bhEff_E12_Fire_0x242320; // 0x2426f0 - g_ps2RecompiledFunctionTable[330171] = bhEff_E12_Fire_0x242320; // 0x2426f4 - g_ps2RecompiledFunctionTable[330172] = bhEff_E12_Fire_0x242320; // 0x2426f8 - g_ps2RecompiledFunctionTable[330173] = bhEff_E12_Fire_0x242320; // 0x2426fc - g_ps2RecompiledFunctionTable[330174] = bhEff_E12_Fire_0x242320; // 0x242700 - g_ps2RecompiledFunctionTable[330175] = bhEff_E12_Fire_0x242320; // 0x242704 - g_ps2RecompiledFunctionTable[330176] = bhEff_E12_Fire_0x242320; // 0x242708 - g_ps2RecompiledFunctionTable[330177] = bhEff_E12_Fire_0x242320; // 0x24270c - g_ps2RecompiledFunctionTable[330178] = bhEff_E12_Fire_0x242320; // 0x242710 - g_ps2RecompiledFunctionTable[330179] = bhEff_E12_Fire_0x242320; // 0x242714 - g_ps2RecompiledFunctionTable[330180] = bhEff_E12_Fire_0x242320; // 0x242718 - g_ps2RecompiledFunctionTable[330181] = bhEff_E12_Fire_0x242320; // 0x24271c - g_ps2RecompiledFunctionTable[330182] = bhEff_E12_Fire_0x242320; // 0x242720 - g_ps2RecompiledFunctionTable[330183] = bhEff_E12_Fire_0x242320; // 0x242724 - g_ps2RecompiledFunctionTable[330184] = bhEff_E12_Fire_0x242320; // 0x242728 - g_ps2RecompiledFunctionTable[330185] = bhEff_E12_Fire_0x242320; // 0x24272c - g_ps2RecompiledFunctionTable[330186] = bhEff_E12_Fire_0x242320; // 0x242730 - g_ps2RecompiledFunctionTable[330187] = bhEff_E12_Fire_0x242320; // 0x242734 - g_ps2RecompiledFunctionTable[330188] = bhEff_E12_Fire_0x242320; // 0x242738 - g_ps2RecompiledFunctionTable[330189] = bhEff_E12_Fire_0x242320; // 0x24273c - g_ps2RecompiledFunctionTable[330190] = bhEff_E12_Fire_0x242320; // 0x242740 - g_ps2RecompiledFunctionTable[330191] = bhEff_E12_Fire_0x242320; // 0x242744 - g_ps2RecompiledFunctionTable[330192] = bhEff_E12_Fire_0x242320; // 0x242748 - g_ps2RecompiledFunctionTable[330193] = bhEff_E12_Fire_0x242320; // 0x24274c - g_ps2RecompiledFunctionTable[330194] = bhEff_E12_Fire_0x242320; // 0x242750 - g_ps2RecompiledFunctionTable[330195] = bhEff_E12_Fire_0x242320; // 0x242754 - g_ps2RecompiledFunctionTable[330196] = bhEff_E12_Fire_0x242320; // 0x242758 - g_ps2RecompiledFunctionTable[330197] = bhEff_E12_Fire_0x242320; // 0x24275c - g_ps2RecompiledFunctionTable[330198] = bhEff_E12_Fire_0x242320; // 0x242760 - g_ps2RecompiledFunctionTable[330199] = bhEff_E12_Fire_0x242320; // 0x242764 - g_ps2RecompiledFunctionTable[330200] = bhEff_E12_Fire_0x242320; // 0x242768 - g_ps2RecompiledFunctionTable[330201] = bhEff_E12_Fire_0x242320; // 0x24276c - g_ps2RecompiledFunctionTable[330202] = bhEff_E12_Fire_0x242320; // 0x242770 - g_ps2RecompiledFunctionTable[330203] = bhEff_E12_Fire_0x242320; // 0x242774 - g_ps2RecompiledFunctionTable[330204] = bhEff_E12_Fire_0x242320; // 0x242778 - g_ps2RecompiledFunctionTable[330205] = bhEff_E12_Fire_0x242320; // 0x24277c - g_ps2RecompiledFunctionTable[330206] = bhEff_E12_Fire_0x242320; // 0x242780 - g_ps2RecompiledFunctionTable[330207] = bhEff_E12_Fire_0x242320; // 0x242784 - g_ps2RecompiledFunctionTable[330208] = bhEff_E12_Fire_0x242320; // 0x242788 - g_ps2RecompiledFunctionTable[330209] = bhEff_E12_Fire_0x242320; // 0x24278c - g_ps2RecompiledFunctionTable[330210] = bhEff_E12_Fire_0x242320; // 0x242790 - g_ps2RecompiledFunctionTable[330211] = bhEff_E12_Fire_0x242320; // 0x242794 - g_ps2RecompiledFunctionTable[330212] = bhEff_E12_Fire_0x242320; // 0x242798 - g_ps2RecompiledFunctionTable[330213] = bhEff_E12_Fire_0x242320; // 0x24279c - g_ps2RecompiledFunctionTable[330214] = bhEff_E12_Fire_0x242320; // 0x2427a0 - g_ps2RecompiledFunctionTable[330215] = bhEff_E12_Fire_0x242320; // 0x2427a4 - g_ps2RecompiledFunctionTable[330216] = bhEff_E12_Fire_0x242320; // 0x2427a8 - g_ps2RecompiledFunctionTable[330217] = bhEff_E12_Fire_0x242320; // 0x2427ac - g_ps2RecompiledFunctionTable[330218] = bhEff_E12_Fire_0x242320; // 0x2427b0 - g_ps2RecompiledFunctionTable[330219] = bhEff_E12_Fire_0x242320; // 0x2427b4 - g_ps2RecompiledFunctionTable[330220] = bhEff_E12_Fire_0x242320; // 0x2427b8 - g_ps2RecompiledFunctionTable[330221] = bhEff_E12_Fire_0x242320; // 0x2427bc - g_ps2RecompiledFunctionTable[330222] = bhEff_E12_Fire_0x242320; // 0x2427c0 - g_ps2RecompiledFunctionTable[330223] = bhEff_E12_Fire_0x242320; // 0x2427c4 - g_ps2RecompiledFunctionTable[330224] = bhEff_E12_Fire_0x242320; // 0x2427c8 - g_ps2RecompiledFunctionTable[330225] = bhEff_E12_Fire_0x242320; // 0x2427cc - g_ps2RecompiledFunctionTable[330226] = bhEff_E12_Fire_0x242320; // 0x2427d0 - g_ps2RecompiledFunctionTable[330227] = bhEff_E12_Fire_0x242320; // 0x2427d4 - g_ps2RecompiledFunctionTable[330228] = bhEff_E12_Fire_0x242320; // 0x2427d8 - g_ps2RecompiledFunctionTable[330229] = bhEff_E12_Fire_0x242320; // 0x2427dc - g_ps2RecompiledFunctionTable[330230] = bhEff_E12_Fire_0x242320; // 0x2427e0 - g_ps2RecompiledFunctionTable[330231] = bhEff_E12_Fire_0x242320; // 0x2427e4 - g_ps2RecompiledFunctionTable[330232] = bhEff_E12_Fire_0x242320; // 0x2427e8 - g_ps2RecompiledFunctionTable[330233] = bhEff_E12_Fire_0x242320; // 0x2427ec - g_ps2RecompiledFunctionTable[330234] = bhEff_E12_Fire_0x242320; // 0x2427f0 - g_ps2RecompiledFunctionTable[330235] = bhEff_E12_Fire_0x242320; // 0x2427f4 - g_ps2RecompiledFunctionTable[330236] = bhEff_E12_Fire_0x242320; // 0x2427f8 - g_ps2RecompiledFunctionTable[330237] = bhEff_E12_Fire_0x242320; // 0x2427fc - g_ps2RecompiledFunctionTable[330238] = bhEff_E12_Fire_0x242320; // 0x242800 - g_ps2RecompiledFunctionTable[330239] = bhEff_E12_Fire_0x242320; // 0x242804 - g_ps2RecompiledFunctionTable[330240] = bhEff_E12_Fire_0x242320; // 0x242808 - g_ps2RecompiledFunctionTable[330241] = bhEff_E12_Fire_0x242320; // 0x24280c - g_ps2RecompiledFunctionTable[330242] = bhEff_E12_Fire_0x242320; // 0x242810 - g_ps2RecompiledFunctionTable[330243] = bhEff_E12_Fire_0x242320; // 0x242814 - g_ps2RecompiledFunctionTable[330244] = bhEff_E12_Fire_0x242320; // 0x242818 - g_ps2RecompiledFunctionTable[330245] = bhEff_E12_Fire_0x242320; // 0x24281c - g_ps2RecompiledFunctionTable[330246] = bhEff_E12_Fire_0x242320; // 0x242820 - g_ps2RecompiledFunctionTable[330247] = bhEff_E12_Fire_0x242320; // 0x242824 - g_ps2RecompiledFunctionTable[330248] = bhEff_E12_Fire_0x242320; // 0x242828 - g_ps2RecompiledFunctionTable[330249] = bhEff_E12_Fire_0x242320; // 0x24282c - g_ps2RecompiledFunctionTable[330250] = bhEff_E12_Fire_0x242320; // 0x242830 - g_ps2RecompiledFunctionTable[330251] = bhEff_E12_Fire_0x242320; // 0x242834 - g_ps2RecompiledFunctionTable[330252] = bhEff_E12_Fire_0x242320; // 0x242838 - g_ps2RecompiledFunctionTable[330253] = bhEff_E12_Fire_0x242320; // 0x24283c - g_ps2RecompiledFunctionTable[330254] = bhEff_E12_Fire_0x242320; // 0x242840 - g_ps2RecompiledFunctionTable[330255] = bhEff_E12_Fire_0x242320; // 0x242844 - g_ps2RecompiledFunctionTable[330256] = bhEff_E12_Fire_0x242320; // 0x242848 - g_ps2RecompiledFunctionTable[330257] = bhEff_E12_Fire_0x242320; // 0x24284c - g_ps2RecompiledFunctionTable[330258] = bhEff_E12_Fire_0x242320; // 0x242850 - g_ps2RecompiledFunctionTable[330259] = bhEff_E12_Fire_0x242320; // 0x242854 - g_ps2RecompiledFunctionTable[330260] = bhEff_E12_Fire_0x242320; // 0x242858 - g_ps2RecompiledFunctionTable[330261] = bhEff_E12_Fire_0x242320; // 0x24285c - g_ps2RecompiledFunctionTable[330262] = bhEff_E12_Fire_0x242320; // 0x242860 - g_ps2RecompiledFunctionTable[330263] = bhEff_E12_Fire_0x242320; // 0x242864 - g_ps2RecompiledFunctionTable[330264] = bhEff_E12_Fire_0x242320; // 0x242868 - g_ps2RecompiledFunctionTable[330265] = bhEff_E12_Fire_0x242320; // 0x24286c - g_ps2RecompiledFunctionTable[330266] = bhEff_E12_Fire_0x242320; // 0x242870 - g_ps2RecompiledFunctionTable[330267] = bhEff_E12_Fire_0x242320; // 0x242874 - g_ps2RecompiledFunctionTable[330268] = bhEff_E12_Fire_0x242320; // 0x242878 - g_ps2RecompiledFunctionTable[330269] = bhEff_E12_Fire_0x242320; // 0x24287c - g_ps2RecompiledFunctionTable[330270] = bhEff_E12_Fire_0x242320; // 0x242880 - g_ps2RecompiledFunctionTable[330271] = bhEff_E12_Fire_0x242320; // 0x242884 - g_ps2RecompiledFunctionTable[330272] = bhEff_E12_Fire_0x242320; // 0x242888 - g_ps2RecompiledFunctionTable[330273] = bhEff_E12_Fire_0x242320; // 0x24288c - g_ps2RecompiledFunctionTable[330274] = bhEff_E12_Fire_0x242320; // 0x242890 - g_ps2RecompiledFunctionTable[330275] = bhEff_E12_Fire_0x242320; // 0x242894 - g_ps2RecompiledFunctionTable[330276] = bhEff_E12_Fire_0x242320; // 0x242898 - g_ps2RecompiledFunctionTable[330277] = bhEff_E12_Fire_0x242320; // 0x24289c - g_ps2RecompiledFunctionTable[330278] = bhEff_E12_Fire_0x242320; // 0x2428a0 - g_ps2RecompiledFunctionTable[330279] = bhEff_E12_Fire_0x242320; // 0x2428a4 - g_ps2RecompiledFunctionTable[330280] = bhEff_E12_Fire_0x242320; // 0x2428a8 - g_ps2RecompiledFunctionTable[330281] = bhEff_E12_Fire_0x242320; // 0x2428ac - g_ps2RecompiledFunctionTable[330282] = bhEff_E12_Fire_0x242320; // 0x2428b0 - g_ps2RecompiledFunctionTable[330283] = bhEff_E12_Fire_0x242320; // 0x2428b4 - g_ps2RecompiledFunctionTable[330284] = bhEff_E12_Fire_0x242320; // 0x2428b8 - g_ps2RecompiledFunctionTable[330285] = bhEff_E12_Fire_0x242320; // 0x2428bc - g_ps2RecompiledFunctionTable[330286] = bhEff_E12_Fire_0x242320; // 0x2428c0 - g_ps2RecompiledFunctionTable[330287] = bhEff_E12_Fire_0x242320; // 0x2428c4 - g_ps2RecompiledFunctionTable[330288] = bhEff_E12_Fire_0x242320; // 0x2428c8 - g_ps2RecompiledFunctionTable[330289] = bhEff_E12_Fire_0x242320; // 0x2428cc - g_ps2RecompiledFunctionTable[330290] = bhEff_E12_Fire_0x242320; // 0x2428d0 - g_ps2RecompiledFunctionTable[330291] = bhEff_E12_Fire_0x242320; // 0x2428d4 - g_ps2RecompiledFunctionTable[330292] = bhEff_E12_Fire_0x242320; // 0x2428d8 - g_ps2RecompiledFunctionTable[330293] = bhEff_E12_Fire_0x242320; // 0x2428dc - g_ps2RecompiledFunctionTable[330294] = bhEff_E12_Fire_0x242320; // 0x2428e0 - g_ps2RecompiledFunctionTable[330295] = bhEff_E12_Fire_0x242320; // 0x2428e4 - g_ps2RecompiledFunctionTable[330296] = bhEff_E12_Fire_0x242320; // 0x2428e8 - g_ps2RecompiledFunctionTable[330297] = bhEff_E12_Fire_0x242320; // 0x2428ec - g_ps2RecompiledFunctionTable[330298] = bhEff_E12_Fire_0x242320; // 0x2428f0 - g_ps2RecompiledFunctionTable[330299] = bhEff_E12_Fire_0x242320; // 0x2428f4 - g_ps2RecompiledFunctionTable[330300] = bhEff_E12_Fire_0x242320; // 0x2428f8 - g_ps2RecompiledFunctionTable[330301] = bhEff_E12_Fire_0x242320; // 0x2428fc - g_ps2RecompiledFunctionTable[330302] = bhEff_E12_Fire_0x242320; // 0x242900 - g_ps2RecompiledFunctionTable[330303] = bhEff_E12_Fire_0x242320; // 0x242904 - g_ps2RecompiledFunctionTable[330304] = bhEff_E12_Fire_0x242320; // 0x242908 - g_ps2RecompiledFunctionTable[330305] = bhEff_E12_Fire_0x242320; // 0x24290c - g_ps2RecompiledFunctionTable[330306] = bhEff_E12_Fire_0x242320; // 0x242910 - g_ps2RecompiledFunctionTable[330307] = bhEff_E12_Fire_0x242320; // 0x242914 - g_ps2RecompiledFunctionTable[330308] = bhEff_E12_Fire_0x242320; // 0x242918 - g_ps2RecompiledFunctionTable[330309] = bhEff_E12_Fire_0x242320; // 0x24291c - g_ps2RecompiledFunctionTable[330310] = bhEff_E12_Fire_0x242320; // 0x242920 - g_ps2RecompiledFunctionTable[330311] = bhEff_E12_Fire_0x242320; // 0x242924 - g_ps2RecompiledFunctionTable[330312] = bhEff_E12_Fire_0x242320; // 0x242928 - g_ps2RecompiledFunctionTable[330313] = bhEff_E12_Fire_0x242320; // 0x24292c - g_ps2RecompiledFunctionTable[330314] = bhEff_E12_Fire_0x242320; // 0x242930 - g_ps2RecompiledFunctionTable[330315] = bhEff_E12_Fire_0x242320; // 0x242934 - g_ps2RecompiledFunctionTable[330316] = bhEff_E12_Fire_0x242320; // 0x242938 - g_ps2RecompiledFunctionTable[330317] = bhEff_E12_Fire_0x242320; // 0x24293c - g_ps2RecompiledFunctionTable[330318] = bhEff_E12_Fire_0x242320; // 0x242940 - g_ps2RecompiledFunctionTable[330319] = bhEff_E12_Fire_0x242320; // 0x242944 - g_ps2RecompiledFunctionTable[330320] = bhEff_E12_Fire_0x242320; // 0x242948 - g_ps2RecompiledFunctionTable[330321] = bhEff_E12_Fire_0x242320; // 0x24294c - g_ps2RecompiledFunctionTable[330322] = bhEff_E12_Fire_0x242320; // 0x242950 - g_ps2RecompiledFunctionTable[330323] = bhEff_E12_Fire_0x242320; // 0x242954 - g_ps2RecompiledFunctionTable[330324] = bhEff_E12_Fire_0x242320; // 0x242958 - g_ps2RecompiledFunctionTable[330325] = bhEff_E12_Fire_0x242320; // 0x24295c - g_ps2RecompiledFunctionTable[330326] = bhEff_E12_Fire_0x242320; // 0x242960 - g_ps2RecompiledFunctionTable[330327] = bhEff_E12_Fire_0x242320; // 0x242964 - g_ps2RecompiledFunctionTable[330328] = bhEff_E12_Fire_0x242320; // 0x242968 - g_ps2RecompiledFunctionTable[330329] = bhEff_E12_Fire_0x242320; // 0x24296c - g_ps2RecompiledFunctionTable[330330] = bhEff_E12_Fire_0x242320; // 0x242970 - g_ps2RecompiledFunctionTable[330331] = bhEff_E12_Fire_0x242320; // 0x242974 - g_ps2RecompiledFunctionTable[330332] = bhEff_E12_Fire_0x242320; // 0x242978 - g_ps2RecompiledFunctionTable[330333] = bhEff_E12_Fire_0x242320; // 0x24297c - g_ps2RecompiledFunctionTable[330334] = bhEff_E12_Fire_0x242320; // 0x242980 - g_ps2RecompiledFunctionTable[330335] = bhEff_E12_Fire_0x242320; // 0x242984 - g_ps2RecompiledFunctionTable[330336] = bhEff_E12_Fire_0x242320; // 0x242988 - g_ps2RecompiledFunctionTable[330337] = bhEff_E12_Fire_0x242320; // 0x24298c - g_ps2RecompiledFunctionTable[330338] = bhEff_E12_Fire_0x242320; // 0x242990 - g_ps2RecompiledFunctionTable[330339] = bhEff_E12_Fire_0x242320; // 0x242994 - g_ps2RecompiledFunctionTable[330340] = bhEff_E12_Fire_0x242320; // 0x242998 - g_ps2RecompiledFunctionTable[330341] = bhEff_E12_Fire_0x242320; // 0x24299c - g_ps2RecompiledFunctionTable[330342] = bhEff_E12_Fire_0x242320; // 0x2429a0 - g_ps2RecompiledFunctionTable[330343] = bhEff_E12_Fire_0x242320; // 0x2429a4 - g_ps2RecompiledFunctionTable[330344] = bhEff_E12_Fire_0x242320; // 0x2429a8 - g_ps2RecompiledFunctionTable[330345] = bhEff_E12_Fire_0x242320; // 0x2429ac - g_ps2RecompiledFunctionTable[330346] = bhEff_E12_Fire_0x242320; // 0x2429b0 - g_ps2RecompiledFunctionTable[330347] = bhEff_E12_Fire_0x242320; // 0x2429b4 - g_ps2RecompiledFunctionTable[330348] = bhEff_E12_Fire_0x242320; // 0x2429b8 - g_ps2RecompiledFunctionTable[330349] = bhEff_E12_Fire_0x242320; // 0x2429bc - g_ps2RecompiledFunctionTable[330350] = bhEff_E12_Fire_0x242320; // 0x2429c0 - g_ps2RecompiledFunctionTable[330351] = bhEff_E12_Fire_0x242320; // 0x2429c4 - g_ps2RecompiledFunctionTable[330352] = bhEff_E12_Fire_0x242320; // 0x2429c8 - g_ps2RecompiledFunctionTable[330353] = bhEff_E12_Fire_0x242320; // 0x2429cc - g_ps2RecompiledFunctionTable[330354] = bhEff_E12_Fire_0x242320; // 0x2429d0 - g_ps2RecompiledFunctionTable[330355] = bhEff_E12_Fire_0x242320; // 0x2429d4 - g_ps2RecompiledFunctionTable[330356] = bhEff_E12_Fire_0x242320; // 0x2429d8 - g_ps2RecompiledFunctionTable[330357] = bhEff_E12_Fire_0x242320; // 0x2429dc - g_ps2RecompiledFunctionTable[330358] = bhEff_E12_Fire_0x242320; // 0x2429e0 - g_ps2RecompiledFunctionTable[330359] = bhEff_E12_Fire_0x242320; // 0x2429e4 - g_ps2RecompiledFunctionTable[330360] = bhEff_E12_Fire_0x242320; // 0x2429e8 - g_ps2RecompiledFunctionTable[330361] = bhEff_E12_Fire_0x242320; // 0x2429ec - g_ps2RecompiledFunctionTable[330362] = bhEff_E12_Fire_0x242320; // 0x2429f0 - g_ps2RecompiledFunctionTable[330363] = bhEff_E12_Fire_0x242320; // 0x2429f4 - g_ps2RecompiledFunctionTable[330364] = bhEff_E12_Fire_0x242320; // 0x2429f8 - g_ps2RecompiledFunctionTable[330365] = bhEff_E12_Fire_0x242320; // 0x2429fc - g_ps2RecompiledFunctionTable[330366] = bhEff_E12_Fire_0x242320; // 0x242a00 - g_ps2RecompiledFunctionTable[330367] = bhEff_E12_Fire_0x242320; // 0x242a04 - g_ps2RecompiledFunctionTable[330368] = bhEff_E12_Fire_0x242320; // 0x242a08 - g_ps2RecompiledFunctionTable[330369] = bhEff_E12_Fire_0x242320; // 0x242a0c - g_ps2RecompiledFunctionTable[330370] = bhEff_E12_Fire_0x242320; // 0x242a10 - g_ps2RecompiledFunctionTable[330371] = bhEff_E12_Fire_0x242320; // 0x242a14 - g_ps2RecompiledFunctionTable[330372] = bhEff_E12_Fire_0x242320; // 0x242a18 - g_ps2RecompiledFunctionTable[330373] = bhEff_E12_Fire_0x242320; // 0x242a1c - g_ps2RecompiledFunctionTable[330374] = bhEff_E12_Fire_0x242320; // 0x242a20 - g_ps2RecompiledFunctionTable[330375] = bhEff_E12_Fire_0x242320; // 0x242a24 - g_ps2RecompiledFunctionTable[330376] = bhEff_E12_Fire_0x242320; // 0x242a28 - g_ps2RecompiledFunctionTable[330377] = bhEff_E12_Fire_0x242320; // 0x242a2c - g_ps2RecompiledFunctionTable[330378] = bhEff_E12_Fire_0x242320; // 0x242a30 - g_ps2RecompiledFunctionTable[330379] = bhEff_E12_Fire_0x242320; // 0x242a34 - g_ps2RecompiledFunctionTable[330380] = bhEff_E12_Fire_0x242320; // 0x242a38 - g_ps2RecompiledFunctionTable[330381] = bhEff_E12_Fire_0x242320; // 0x242a3c - g_ps2RecompiledFunctionTable[330382] = bhEff_E12_Fire_0x242320; // 0x242a40 - g_ps2RecompiledFunctionTable[330383] = bhEff_E12_Fire_0x242320; // 0x242a44 - g_ps2RecompiledFunctionTable[330384] = bhEff_E12_Fire_0x242320; // 0x242a48 - g_ps2RecompiledFunctionTable[330385] = bhEff_E12_Fire_0x242320; // 0x242a4c - g_ps2RecompiledFunctionTable[330386] = bhEff_E12_Fire_0x242320; // 0x242a50 - g_ps2RecompiledFunctionTable[330387] = bhEff_E12_Fire_0x242320; // 0x242a54 - g_ps2RecompiledFunctionTable[330388] = bhEff_E12_Fire_0x242320; // 0x242a58 - g_ps2RecompiledFunctionTable[330389] = bhEff_E12_Fire_0x242320; // 0x242a5c - g_ps2RecompiledFunctionTable[330390] = bhEff_E12_Fire_0x242320; // 0x242a60 - g_ps2RecompiledFunctionTable[330391] = bhEff_E12_Fire_0x242320; // 0x242a64 - g_ps2RecompiledFunctionTable[330392] = bhEff_E12_Fire_0x242320; // 0x242a68 - g_ps2RecompiledFunctionTable[330393] = bhEff_E12_Fire_0x242320; // 0x242a6c - g_ps2RecompiledFunctionTable[330394] = bhEff_E12_Fire_0x242320; // 0x242a70 - g_ps2RecompiledFunctionTable[330395] = bhEff_E12_Fire_0x242320; // 0x242a74 - g_ps2RecompiledFunctionTable[330396] = bhEff_E12_Fire_0x242320; // 0x242a78 - g_ps2RecompiledFunctionTable[330397] = bhEff_E12_Fire_0x242320; // 0x242a7c - g_ps2RecompiledFunctionTable[330398] = bhEff_E12_Fire_0x242320; // 0x242a80 - g_ps2RecompiledFunctionTable[330399] = bhEff_E12_Fire_0x242320; // 0x242a84 - g_ps2RecompiledFunctionTable[330400] = bhEff_E12_Fire_0x242320; // 0x242a88 - g_ps2RecompiledFunctionTable[330401] = bhEff_E12_Fire_0x242320; // 0x242a8c - g_ps2RecompiledFunctionTable[330402] = bhEff_E12_Fire_0x242320; // 0x242a90 - g_ps2RecompiledFunctionTable[330403] = bhEff_E12_Fire_0x242320; // 0x242a94 - g_ps2RecompiledFunctionTable[330404] = bhEff_E12_Fire_0x242320; // 0x242a98 - g_ps2RecompiledFunctionTable[330405] = bhEff_E12_Fire_0x242320; // 0x242a9c - g_ps2RecompiledFunctionTable[330406] = bhEff_E12_Fire_0x242320; // 0x242aa0 - g_ps2RecompiledFunctionTable[330407] = bhEff_E12_Fire_0x242320; // 0x242aa4 - g_ps2RecompiledFunctionTable[330408] = bhEff_E12_Fire_0x242320; // 0x242aa8 - g_ps2RecompiledFunctionTable[330409] = bhEff_E12_Fire_0x242320; // 0x242aac - g_ps2RecompiledFunctionTable[330410] = bhEff_E12_Fire_0x242320; // 0x242ab0 - g_ps2RecompiledFunctionTable[330411] = bhEff_E12_Fire_0x242320; // 0x242ab4 - g_ps2RecompiledFunctionTable[330412] = bhEff_E12_Fire_0x242320; // 0x242ab8 - g_ps2RecompiledFunctionTable[330413] = bhEff_E12_Fire_0x242320; // 0x242abc - g_ps2RecompiledFunctionTable[330414] = bhEff_E12_Fire_0x242320; // 0x242ac0 - g_ps2RecompiledFunctionTable[330415] = bhEff_E12_Fire_0x242320; // 0x242ac4 - g_ps2RecompiledFunctionTable[330416] = bhEff_E12_Fire_0x242320; // 0x242ac8 - g_ps2RecompiledFunctionTable[330417] = bhEff_E12_Fire_0x242320; // 0x242acc - g_ps2RecompiledFunctionTable[330418] = bhEff_E12_Fire_0x242320; // 0x242ad0 - g_ps2RecompiledFunctionTable[330419] = bhEff_E12_Fire_0x242320; // 0x242ad4 - g_ps2RecompiledFunctionTable[330420] = bhEff_E12_Fire_0x242320; // 0x242ad8 - g_ps2RecompiledFunctionTable[330421] = bhEff_E12_Fire_0x242320; // 0x242adc - g_ps2RecompiledFunctionTable[330422] = bhEff_E12_Fire_0x242320; // 0x242ae0 - g_ps2RecompiledFunctionTable[330423] = bhEff_E12_Fire_0x242320; // 0x242ae4 - g_ps2RecompiledFunctionTable[330424] = bhEff_E12_Fire_0x242320; // 0x242ae8 - g_ps2RecompiledFunctionTable[330425] = bhEff_E12_Fire_0x242320; // 0x242aec - g_ps2RecompiledFunctionTable[330426] = bhEff_E12_Fire_0x242320; // 0x242af0 - g_ps2RecompiledFunctionTable[330427] = bhEff_E12_Fire_0x242320; // 0x242af4 - g_ps2RecompiledFunctionTable[330428] = bhEff_E12_Fire_0x242320; // 0x242af8 - g_ps2RecompiledFunctionTable[330429] = bhEff_E12_Fire_0x242320; // 0x242afc - g_ps2RecompiledFunctionTable[330430] = bhEff_E12_Fire_0x242320; // 0x242b00 - g_ps2RecompiledFunctionTable[330431] = bhEff_E12_Fire_0x242320; // 0x242b04 - g_ps2RecompiledFunctionTable[330432] = bhEff_E12_Fire_0x242320; // 0x242b08 - g_ps2RecompiledFunctionTable[330433] = bhEff_E12_Fire_0x242320; // 0x242b0c - g_ps2RecompiledFunctionTable[330434] = bhEff_E12_Fire_0x242320; // 0x242b10 - g_ps2RecompiledFunctionTable[330435] = bhEff_E12_Fire_0x242320; // 0x242b14 - g_ps2RecompiledFunctionTable[330436] = bhEff_E12_Fire_0x242320; // 0x242b18 - g_ps2RecompiledFunctionTable[330437] = bhEff_E12_Fire_0x242320; // 0x242b1c - g_ps2RecompiledFunctionTable[330438] = bhEff_E12_Fire_0x242320; // 0x242b20 - g_ps2RecompiledFunctionTable[330439] = bhEff_E12_Fire_0x242320; // 0x242b24 - g_ps2RecompiledFunctionTable[330440] = bhEff_E12_Fire_0x242320; // 0x242b28 - g_ps2RecompiledFunctionTable[330441] = bhEff_E12_Fire_0x242320; // 0x242b2c - g_ps2RecompiledFunctionTable[330442] = bhEff_E12_Fire_0x242320; // 0x242b30 - g_ps2RecompiledFunctionTable[330443] = bhEff_E12_Fire_0x242320; // 0x242b34 - g_ps2RecompiledFunctionTable[330444] = bhEff_E12_Fire_0x242320; // 0x242b38 - g_ps2RecompiledFunctionTable[330445] = bhEff_E12_Fire_0x242320; // 0x242b3c - g_ps2RecompiledFunctionTable[330446] = bhEff_E12_Fire_0x242320; // 0x242b40 - g_ps2RecompiledFunctionTable[330447] = bhEff_E12_Fire_0x242320; // 0x242b44 - g_ps2RecompiledFunctionTable[330448] = bhEff_E12_Fire_0x242320; // 0x242b48 - g_ps2RecompiledFunctionTable[330449] = bhEff_E12_Fire_0x242320; // 0x242b4c - g_ps2RecompiledFunctionTable[330450] = bhEff_E12_Fire_0x242320; // 0x242b50 - g_ps2RecompiledFunctionTable[330451] = bhEff_E12_Fire_0x242320; // 0x242b54 - g_ps2RecompiledFunctionTable[330452] = bhEff_E12_Fire_0x242320; // 0x242b58 - g_ps2RecompiledFunctionTable[330453] = bhEff_E12_Fire_0x242320; // 0x242b5c - g_ps2RecompiledFunctionTable[330454] = bhEff_E12_Fire_0x242320; // 0x242b60 - g_ps2RecompiledFunctionTable[330455] = bhEff_E12_Fire_0x242320; // 0x242b64 - g_ps2RecompiledFunctionTable[330456] = bhEff_E12_Fire_0x242320; // 0x242b68 - g_ps2RecompiledFunctionTable[330457] = bhEff_E12_Fire_0x242320; // 0x242b6c - g_ps2RecompiledFunctionTable[330458] = bhEff_E12_Fire_0x242320; // 0x242b70 - g_ps2RecompiledFunctionTable[330459] = bhEff_E12_Fire_0x242320; // 0x242b74 - g_ps2RecompiledFunctionTable[330460] = bhEff_E12_Fire_0x242320; // 0x242b78 - g_ps2RecompiledFunctionTable[330461] = bhEff_E12_Fire_0x242320; // 0x242b7c - g_ps2RecompiledFunctionTable[330462] = bhEff_E12_Fire_0x242320; // 0x242b80 - g_ps2RecompiledFunctionTable[330463] = bhEff_E12_Fire_0x242320; // 0x242b84 - g_ps2RecompiledFunctionTable[330464] = bhEff_E12_Fire_0x242320; // 0x242b88 - g_ps2RecompiledFunctionTable[330465] = bhEff_E12_Fire_0x242320; // 0x242b8c - g_ps2RecompiledFunctionTable[330466] = bhEff_E12_Fire_0x242320; // 0x242b90 - g_ps2RecompiledFunctionTable[330467] = bhEff_E12_Fire_0x242320; // 0x242b94 - g_ps2RecompiledFunctionTable[330468] = bhEff_E12_Fire_0x242320; // 0x242b98 - g_ps2RecompiledFunctionTable[330469] = bhEff_E12_Fire_0x242320; // 0x242b9c - g_ps2RecompiledFunctionTable[330470] = bhEff_E12_Fire_0x242320; // 0x242ba0 - g_ps2RecompiledFunctionTable[330471] = bhEff_E12_Fire_0x242320; // 0x242ba4 - g_ps2RecompiledFunctionTable[330472] = bhEff_E12_Fire_0x242320; // 0x242ba8 - g_ps2RecompiledFunctionTable[330473] = bhEff_E12_Fire_0x242320; // 0x242bac - g_ps2RecompiledFunctionTable[330474] = bhEff_E12_Fire_0x242320; // 0x242bb0 - g_ps2RecompiledFunctionTable[330475] = bhEff_E12_Fire_0x242320; // 0x242bb4 - g_ps2RecompiledFunctionTable[330476] = bhEff_E12_Fire_0x242320; // 0x242bb8 - g_ps2RecompiledFunctionTable[330477] = bhEff_E12_Fire_0x242320; // 0x242bbc - g_ps2RecompiledFunctionTable[330478] = bhEff_E12_Fire_0x242320; // 0x242bc0 - g_ps2RecompiledFunctionTable[330479] = bhEff_E12_Fire_0x242320; // 0x242bc4 - g_ps2RecompiledFunctionTable[330480] = bhEff_E12_Fire_0x242320; // 0x242bc8 - g_ps2RecompiledFunctionTable[330481] = bhEff_E12_Fire_0x242320; // 0x242bcc - g_ps2RecompiledFunctionTable[330482] = bhEff_E12_Fire_0x242320; // 0x242bd0 - g_ps2RecompiledFunctionTable[330483] = bhEff_E12_Fire_0x242320; // 0x242bd4 - g_ps2RecompiledFunctionTable[330484] = bhEff_E12_Fire_0x242320; // 0x242bd8 - g_ps2RecompiledFunctionTable[330485] = bhEff_E12_Fire_0x242320; // 0x242bdc - g_ps2RecompiledFunctionTable[330486] = bhEff_E12_Fire_0x242320; // 0x242be0 - g_ps2RecompiledFunctionTable[330487] = bhEff_E12_Fire_0x242320; // 0x242be4 - g_ps2RecompiledFunctionTable[330488] = bhEff_E12_Fire_0x242320; // 0x242be8 - g_ps2RecompiledFunctionTable[330489] = bhEff_E12_Fire_0x242320; // 0x242bec - g_ps2RecompiledFunctionTable[330490] = bhEff_E12_Fire_0x242320; // 0x242bf0 - g_ps2RecompiledFunctionTable[330491] = bhEff_E12_Fire_0x242320; // 0x242bf4 - g_ps2RecompiledFunctionTable[330492] = bhEff_E12_Fire_0x242320; // 0x242bf8 - g_ps2RecompiledFunctionTable[330493] = bhEff_E12_Fire_0x242320; // 0x242bfc - g_ps2RecompiledFunctionTable[330494] = bhEff_E12_Fire_0x242320; // 0x242c00 - g_ps2RecompiledFunctionTable[330495] = bhEff_E12_Fire_0x242320; // 0x242c04 - g_ps2RecompiledFunctionTable[330496] = bhEff_E12_Fire_0x242320; // 0x242c08 - g_ps2RecompiledFunctionTable[330497] = bhEff_E12_Fire_0x242320; // 0x242c0c - g_ps2RecompiledFunctionTable[330498] = bhEff_E12_Fire_0x242320; // 0x242c10 - g_ps2RecompiledFunctionTable[330499] = bhEff_E12_Fire_0x242320; // 0x242c14 - g_ps2RecompiledFunctionTable[330500] = bhEff_E12_Fire_0x242320; // 0x242c18 - g_ps2RecompiledFunctionTable[330501] = bhEff_E12_Fire_0x242320; // 0x242c1c - g_ps2RecompiledFunctionTable[330502] = bhEff_E12_Fire_0x242320; // 0x242c20 - g_ps2RecompiledFunctionTable[330503] = bhEff_E12_Fire_0x242320; // 0x242c24 - g_ps2RecompiledFunctionTable[330504] = bhEff_E12_Fire_0x242320; // 0x242c28 - g_ps2RecompiledFunctionTable[330505] = bhEff_E12_Fire_0x242320; // 0x242c2c - g_ps2RecompiledFunctionTable[330506] = bhEff_E12_Fire_0x242320; // 0x242c30 - g_ps2RecompiledFunctionTable[330507] = bhEff_E12_Fire_0x242320; // 0x242c34 - g_ps2RecompiledFunctionTable[330508] = bhEff_E12_Fire_0x242320; // 0x242c38 - g_ps2RecompiledFunctionTable[330509] = bhEff_E12_Fire_0x242320; // 0x242c3c - g_ps2RecompiledFunctionTable[330510] = bhEff_E12_Fire_0x242320; // 0x242c40 - g_ps2RecompiledFunctionTable[330511] = bhEff_E12_Fire_0x242320; // 0x242c44 - g_ps2RecompiledFunctionTable[330512] = bhEff_E12_Fire_0x242320; // 0x242c48 - g_ps2RecompiledFunctionTable[330513] = bhEff_E12_Fire_0x242320; // 0x242c4c - g_ps2RecompiledFunctionTable[330514] = bhEff_E12_Fire_0x242320; // 0x242c50 - g_ps2RecompiledFunctionTable[330515] = bhEff_E12_Fire_0x242320; // 0x242c54 - g_ps2RecompiledFunctionTable[330516] = bhEff_E12_Fire_0x242320; // 0x242c58 - g_ps2RecompiledFunctionTable[330517] = bhEff_E12_Fire_0x242320; // 0x242c5c - g_ps2RecompiledFunctionTable[330518] = bhEff_E12_Fire_0x242320; // 0x242c60 - g_ps2RecompiledFunctionTable[330519] = bhEff_E12_Fire_0x242320; // 0x242c64 - g_ps2RecompiledFunctionTable[330520] = bhEff_E12_Fire_0x242320; // 0x242c68 - g_ps2RecompiledFunctionTable[330521] = bhEff_E12_Fire_0x242320; // 0x242c6c - g_ps2RecompiledFunctionTable[330522] = bhEff_E12_Fire_0x242320; // 0x242c70 - g_ps2RecompiledFunctionTable[330523] = bhEff_E12_Fire_0x242320; // 0x242c74 - g_ps2RecompiledFunctionTable[330524] = bhEff_E12_Fire_0x242320; // 0x242c78 - g_ps2RecompiledFunctionTable[330525] = bhEff_E12_Fire_0x242320; // 0x242c7c - g_ps2RecompiledFunctionTable[330526] = bhEff_E12_Fire_0x242320; // 0x242c80 - g_ps2RecompiledFunctionTable[330527] = bhEff_E12_Fire_0x242320; // 0x242c84 - g_ps2RecompiledFunctionTable[330528] = bhEff_E12_Fire_0x242320; // 0x242c88 - g_ps2RecompiledFunctionTable[330529] = bhEff_E12_Fire_0x242320; // 0x242c8c - g_ps2RecompiledFunctionTable[330530] = bhEff_E12_Fire_0x242320; // 0x242c90 - g_ps2RecompiledFunctionTable[330531] = bhEff_E12_Fire_0x242320; // 0x242c94 - g_ps2RecompiledFunctionTable[330532] = bhEff_E12_Fire_0x242320; // 0x242c98 - g_ps2RecompiledFunctionTable[330533] = bhEff_E12_Fire_0x242320; // 0x242c9c - g_ps2RecompiledFunctionTable[330534] = bhEff_E12_Fire_0x242320; // 0x242ca0 - g_ps2RecompiledFunctionTable[330535] = bhEff_E12_Fire_0x242320; // 0x242ca4 - g_ps2RecompiledFunctionTable[330536] = bhEff_E12_Fire_0x242320; // 0x242ca8 - g_ps2RecompiledFunctionTable[330537] = bhEff_E12_Fire_0x242320; // 0x242cac - g_ps2RecompiledFunctionTable[330538] = bhEff_E12_Fire_0x242320; // 0x242cb0 - g_ps2RecompiledFunctionTable[330539] = bhEff_E12_Fire_0x242320; // 0x242cb4 - g_ps2RecompiledFunctionTable[330540] = bhEff_E12_Fire_0x242320; // 0x242cb8 - g_ps2RecompiledFunctionTable[330541] = bhEff_E12_Fire_0x242320; // 0x242cbc - g_ps2RecompiledFunctionTable[330542] = bhEff_E12_Fire_0x242320; // 0x242cc0 - g_ps2RecompiledFunctionTable[330543] = bhEff_E12_Fire_0x242320; // 0x242cc4 - g_ps2RecompiledFunctionTable[330544] = bhEff_E12_Fire_0x242320; // 0x242cc8 - g_ps2RecompiledFunctionTable[330545] = bhEff_E12_Fire_0x242320; // 0x242ccc - g_ps2RecompiledFunctionTable[330546] = bhEff_E12_Fire_0x242320; // 0x242cd0 - g_ps2RecompiledFunctionTable[330547] = bhEff_E12_Fire_0x242320; // 0x242cd4 - g_ps2RecompiledFunctionTable[330548] = bhEff_E12_Fire_0x242320; // 0x242cd8 - g_ps2RecompiledFunctionTable[330549] = bhEff_E12_Fire_0x242320; // 0x242cdc - g_ps2RecompiledFunctionTable[330550] = bhEff_E12_Fire_0x242320; // 0x242ce0 - g_ps2RecompiledFunctionTable[330551] = bhEff_E12_Fire_0x242320; // 0x242ce4 - g_ps2RecompiledFunctionTable[330552] = bhEff_E12_Fire_0x242320; // 0x242ce8 - g_ps2RecompiledFunctionTable[330553] = bhEff_E12_Fire_0x242320; // 0x242cec - g_ps2RecompiledFunctionTable[330554] = bhEff_E12_Fire_0x242320; // 0x242cf0 - g_ps2RecompiledFunctionTable[330555] = bhEff_E12_Fire_0x242320; // 0x242cf4 - g_ps2RecompiledFunctionTable[330556] = bhEff_E12_Fire_0x242320; // 0x242cf8 - g_ps2RecompiledFunctionTable[330557] = bhEff_E12_Fire_0x242320; // 0x242cfc - g_ps2RecompiledFunctionTable[330558] = bhEff_E12_Fire_0x242320; // 0x242d00 - g_ps2RecompiledFunctionTable[330559] = bhEff_E12_Fire_0x242320; // 0x242d04 - g_ps2RecompiledFunctionTable[330560] = bhEff_E12_Fire_0x242320; // 0x242d08 - g_ps2RecompiledFunctionTable[330561] = bhEff_E12_Fire_0x242320; // 0x242d0c - g_ps2RecompiledFunctionTable[330562] = bhEff_E12_Fire_0x242320; // 0x242d10 - g_ps2RecompiledFunctionTable[330563] = bhEff_E12_Fire_0x242320; // 0x242d14 - g_ps2RecompiledFunctionTable[330564] = bhEff_E12_Fire_0x242320; // 0x242d18 - g_ps2RecompiledFunctionTable[330565] = bhEff_E12_Fire_0x242320; // 0x242d1c - g_ps2RecompiledFunctionTable[330566] = bhEff_E12_Fire_0x242320; // 0x242d20 - g_ps2RecompiledFunctionTable[330567] = bhEff_E12_Fire_0x242320; // 0x242d24 - g_ps2RecompiledFunctionTable[330568] = bhEff_E12_Fire_0x242320; // 0x242d28 - g_ps2RecompiledFunctionTable[330569] = bhEff_E12_Fire_0x242320; // 0x242d2c - g_ps2RecompiledFunctionTable[330570] = bhEff_E12_Fire_0x242320; // 0x242d30 - g_ps2RecompiledFunctionTable[330571] = bhEff_E12_Fire_0x242320; // 0x242d34 - g_ps2RecompiledFunctionTable[330574] = bhEff_E12_FrameLiquid_0x242d40; // 0x242d40 - g_ps2RecompiledFunctionTable[330613] = bhEff_E12_FrameLiquid_0x242d40; // 0x242ddc - g_ps2RecompiledFunctionTable[330642] = bhEff_E12_FrameLiquid_0x242d40; // 0x242e50 - g_ps2RecompiledFunctionTable[330691] = bhEff_E12_FrameLiquid_0x242d40; // 0x242f14 - g_ps2RecompiledFunctionTable[330708] = bhEff_E12_FrameLiquid_0x242d40; // 0x242f58 - g_ps2RecompiledFunctionTable[330710] = bhEff_E12_FrameLiquid_0x242d40; // 0x242f60 - g_ps2RecompiledFunctionTable[330726] = bhEff_E12_FrameLiquid_0x242d40; // 0x242fa0 - g_ps2RecompiledFunctionTable[330752] = bhEff_E12_FrameLiquid_0x242d40; // 0x243008 - g_ps2RecompiledFunctionTable[330765] = bhEff_E12_FrameLiquid_0x242d40; // 0x24303c - g_ps2RecompiledFunctionTable[330778] = bhEff_E12_FrameLiquid_0x242d40; // 0x243070 - g_ps2RecompiledFunctionTable[330785] = bhEff_E12_FrameLiquid_0x242d40; // 0x24308c - g_ps2RecompiledFunctionTable[330868] = bhEff_E12_FrameLiquid_0x242d40; // 0x2431d8 - g_ps2RecompiledFunctionTable[330908] = bhEff_E12_FrameLiquid_0x242d40; // 0x243278 - g_ps2RecompiledFunctionTable[330955] = bhEff_E12_FrameLiquid_0x242d40; // 0x243334 - g_ps2RecompiledFunctionTable[330979] = bhEff_E12_FrameLiquid_0x242d40; // 0x243394 - g_ps2RecompiledFunctionTable[331010] = bhEff_E12_FloorBlood2_0x243410; // 0x243410 - g_ps2RecompiledFunctionTable[331031] = bhEff_E12_FloorBlood2_0x243410; // 0x243464 - g_ps2RecompiledFunctionTable[331044] = bhEff_E12_FloorBlood2_0x243410; // 0x243498 - g_ps2RecompiledFunctionTable[331089] = bhEff_E12_FloorBlood2_0x243410; // 0x24354c - g_ps2RecompiledFunctionTable[331091] = bhEff_E12_FloorBlood2_0x243410; // 0x243554 - g_ps2RecompiledFunctionTable[331107] = bhEff_E12_FloorBlood2_0x243410; // 0x243594 - g_ps2RecompiledFunctionTable[331134] = bhEff_E12_FloorBlood2_0x243410; // 0x243600 - g_ps2RecompiledFunctionTable[331147] = bhEff_E12_FloorBlood2_0x243410; // 0x243634 - g_ps2RecompiledFunctionTable[331160] = bhEff_E12_FloorBlood2_0x243410; // 0x243668 - g_ps2RecompiledFunctionTable[331167] = bhEff_E12_FloorBlood2_0x243410; // 0x243684 - g_ps2RecompiledFunctionTable[331192] = bhEff_E12_FloorBlood2_0x243410; // 0x2436e8 - g_ps2RecompiledFunctionTable[331197] = bhEff_E12_FloorBlood2_0x243410; // 0x2436fc - g_ps2RecompiledFunctionTable[331213] = bhEff_E12_FloorBlood2_0x243410; // 0x24373c - g_ps2RecompiledFunctionTable[331287] = bhEff_E12_FloorBlood2_0x243410; // 0x243864 - g_ps2RecompiledFunctionTable[331318] = bhEff_E12_FireSpark_0x2438e0; // 0x2438e0 - g_ps2RecompiledFunctionTable[331343] = bhEff_E12_FireSpark_0x2438e0; // 0x243944 - g_ps2RecompiledFunctionTable[331355] = bhEff_E12_FireSpark_0x2438e0; // 0x243974 - g_ps2RecompiledFunctionTable[331357] = bhEff_E12_FireSpark_0x2438e0; // 0x24397c - g_ps2RecompiledFunctionTable[331374] = bhEff_E12_FireSpark_0x2438e0; // 0x2439c0 - g_ps2RecompiledFunctionTable[331387] = bhEff_E12_FireSpark_0x2438e0; // 0x2439f4 - g_ps2RecompiledFunctionTable[331404] = bhEff_E12_FireSpark_0x2438e0; // 0x243a38 - g_ps2RecompiledFunctionTable[331418] = bhEff_E12_FireSpark_0x2438e0; // 0x243a70 - g_ps2RecompiledFunctionTable[331431] = bhEff_E12_FireSpark_0x2438e0; // 0x243aa4 - g_ps2RecompiledFunctionTable[331434] = bhEff_E12_FireSpark_0x2438e0; // 0x243ab0 - g_ps2RecompiledFunctionTable[331439] = bhEff_E12_FireSpark_0x2438e0; // 0x243ac4 - g_ps2RecompiledFunctionTable[331453] = bhEff_E12_FireSpark_0x2438e0; // 0x243afc - g_ps2RecompiledFunctionTable[331471] = bhEff_E12_FireSpark_0x2438e0; // 0x243b44 - g_ps2RecompiledFunctionTable[331485] = bhEff_E12_FireSpark_0x2438e0; // 0x243b7c - g_ps2RecompiledFunctionTable[331508] = bhEff_E12_FireSpark_0x2438e0; // 0x243bd8 - g_ps2RecompiledFunctionTable[331510] = bhEff_E12_FireSpark_0x2438e0; // 0x243be0 - g_ps2RecompiledFunctionTable[331529] = bhEff_E12_FireSpark_0x2438e0; // 0x243c2c - g_ps2RecompiledFunctionTable[331548] = bhEff_E12_FireSpark_0x2438e0; // 0x243c78 - g_ps2RecompiledFunctionTable[331598] = bhEff_E12_FireSpark_0x2438e0; // 0x243d40 - g_ps2RecompiledFunctionTable[331611] = bhEff_E12_FireSpark_0x2438e0; // 0x243d74 - g_ps2RecompiledFunctionTable[331621] = bhEff_E12_FireSpark_0x2438e0; // 0x243d9c - g_ps2RecompiledFunctionTable[331634] = bhEff_E12_FireSpark_0x2438e0; // 0x243dd0 - g_ps2RecompiledFunctionTable[331686] = bhEff_E12_FireManager_0x243ea0; // 0x243ea0 - g_ps2RecompiledFunctionTable[331703] = bhEff_E12_FireManager_0x243ea0; // 0x243ee4 - g_ps2RecompiledFunctionTable[331746] = bhEff_E12_FireBurstDraw_0x243f90; // 0x243f90 - g_ps2RecompiledFunctionTable[331756] = bhEff_E12_FireBurstDraw_0x243f90; // 0x243fb8 - g_ps2RecompiledFunctionTable[331758] = bhEff_E12_FireBurstDraw_0x243f90; // 0x243fc0 - g_ps2RecompiledFunctionTable[331764] = bhEff_E12_FireBurstDraw_0x243f90; // 0x243fd8 - g_ps2RecompiledFunctionTable[331775] = bhEff_E12_FireBurstDraw_0x243f90; // 0x244004 - g_ps2RecompiledFunctionTable[331777] = bhEff_E12_FireBurstDraw_0x243f90; // 0x24400c - g_ps2RecompiledFunctionTable[331780] = bhEff_E12_FireBurstDraw_0x243f90; // 0x244018 - g_ps2RecompiledFunctionTable[331783] = bhEff_E12_FireBurstDraw_0x243f90; // 0x244024 - g_ps2RecompiledFunctionTable[331785] = bhEff_E12_FireBurstDraw_0x243f90; // 0x24402c - g_ps2RecompiledFunctionTable[331789] = bhEff_E12_FireBurstDraw_0x243f90; // 0x24403c - g_ps2RecompiledFunctionTable[331793] = bhEff_E12_FireBurstDraw_0x243f90; // 0x24404c - g_ps2RecompiledFunctionTable[331795] = bhEff_E12_FireBurstDraw_0x243f90; // 0x244054 - g_ps2RecompiledFunctionTable[331797] = bhEff_E12_FireBurstDraw_0x243f90; // 0x24405c - g_ps2RecompiledFunctionTable[331799] = bhEff_E12_FireBurstDraw_0x243f90; // 0x244064 - g_ps2RecompiledFunctionTable[331802] = bhEff_E12_FireBurstDraw_0x243f90; // 0x244070 - g_ps2RecompiledFunctionTable[331804] = bhEff_E12_FireBurstDraw_0x243f90; // 0x244078 - g_ps2RecompiledFunctionTable[331806] = bhEff_E12_FireBurstDraw_0x243f90; // 0x244080 - g_ps2RecompiledFunctionTable[331809] = bhEff_E12_FireBurstDraw_0x243f90; // 0x24408c - g_ps2RecompiledFunctionTable[331816] = bhEff_E12_FireBurstDraw_0x243f90; // 0x2440a8 - g_ps2RecompiledFunctionTable[331819] = bhEff_E12_FireBurstDraw_0x243f90; // 0x2440b4 - g_ps2RecompiledFunctionTable[331823] = bhEff_E12_FireBurstDraw_0x243f90; // 0x2440c4 - g_ps2RecompiledFunctionTable[331825] = bhEff_E12_FireBurstDraw_0x243f90; // 0x2440cc - g_ps2RecompiledFunctionTable[331830] = bhEff_E12_FireBurstDraw_0x243f90; // 0x2440e0 - g_ps2RecompiledFunctionTable[331838] = bhEff_E12_FireBurstDraw_0x243f90; // 0x244100 - g_ps2RecompiledFunctionTable[331846] = bhEff_E12_Fire2_0x244120; // 0x244120 - g_ps2RecompiledFunctionTable[331869] = bhEff_E12_Fire2_0x244120; // 0x24417c - g_ps2RecompiledFunctionTable[331880] = bhEff_E12_Fire2_0x244120; // 0x2441a8 - g_ps2RecompiledFunctionTable[331882] = bhEff_E12_Fire2_0x244120; // 0x2441b0 - g_ps2RecompiledFunctionTable[331895] = bhEff_E12_Fire2_0x244120; // 0x2441e4 - g_ps2RecompiledFunctionTable[331943] = bhEff_E12_Fire2_0x244120; // 0x2442a4 - g_ps2RecompiledFunctionTable[331974] = bhEff_E12_Fire2_0x244120; // 0x244320 - g_ps2RecompiledFunctionTable[332010] = bhEff_E12_Fire3_0x2443b0; // 0x2443b0 - g_ps2RecompiledFunctionTable[332026] = bhEff_E12_Fire3_0x2443b0; // 0x2443f0 - g_ps2RecompiledFunctionTable[332037] = bhEff_E12_Fire3_0x2443b0; // 0x24441c - g_ps2RecompiledFunctionTable[332039] = bhEff_E12_Fire3_0x2443b0; // 0x244424 - g_ps2RecompiledFunctionTable[332052] = bhEff_E12_Fire3_0x2443b0; // 0x244458 - g_ps2RecompiledFunctionTable[332090] = bhEff_E12_Fire3_0x2443b0; // 0x2444f0 - g_ps2RecompiledFunctionTable[332121] = bhEff_E12_Fire3_0x2443b0; // 0x24456c - g_ps2RecompiledFunctionTable[332147] = bhEff_E12_Fire3_0x2443b0; // 0x2445d4 - g_ps2RecompiledFunctionTable[332166] = bhEff_E12_Fire3_0x2443b0; // 0x244620 - g_ps2RecompiledFunctionTable[332185] = bhEff_E12_Fire3_0x2443b0; // 0x24466c - g_ps2RecompiledFunctionTable[332226] = bhEff_E12_BintaEffControl_0x244710; // 0x244710 - g_ps2RecompiledFunctionTable[332264] = bhEff_E12_BintaEffControl_0x244710; // 0x2447a8 - g_ps2RecompiledFunctionTable[332269] = bhEff_E12_BintaEffControl_0x244710; // 0x2447bc - g_ps2RecompiledFunctionTable[332274] = bhEff_E12_BintaEffControl_0x244710; // 0x2447d0 - g_ps2RecompiledFunctionTable[332278] = bhEff_E13_Fluid_0x2447e0; // 0x2447e0 - g_ps2RecompiledFunctionTable[332303] = bhEff_E13_Fluid_0x2447e0; // 0x244844 - g_ps2RecompiledFunctionTable[332310] = bhEff_E13_Fluid_0x2447e0; // 0x244860 - g_ps2RecompiledFunctionTable[332323] = bhEff_E13_Fluid_0x2447e0; // 0x244894 - g_ps2RecompiledFunctionTable[332339] = bhEff_E13_Fluid_0x2447e0; // 0x2448d4 - g_ps2RecompiledFunctionTable[332353] = bhEff_E13_Fluid_0x2447e0; // 0x24490c - g_ps2RecompiledFunctionTable[332357] = bhEff_E13_Fluid_0x2447e0; // 0x24491c - g_ps2RecompiledFunctionTable[332371] = bhEff_E13_Fluid_0x2447e0; // 0x244954 - g_ps2RecompiledFunctionTable[332415] = bhEff_E13_Fluid_0x2447e0; // 0x244a04 - g_ps2RecompiledFunctionTable[332478] = bhEff_E13_Fluid_0x2447e0; // 0x244b00 - g_ps2RecompiledFunctionTable[332482] = bhEff_E13_Fluid_0x2447e0; // 0x244b10 - g_ps2RecompiledFunctionTable[332484] = bhEff_E13_Fluid_0x2447e0; // 0x244b18 - g_ps2RecompiledFunctionTable[332521] = bhEff_E13_Fluid_0x2447e0; // 0x244bac - g_ps2RecompiledFunctionTable[332550] = bhEff_E14_Explosion_0x244c20; // 0x244c20 - g_ps2RecompiledFunctionTable[332637] = bhEff_E14_Explosion_0x244c20; // 0x244d7c - g_ps2RecompiledFunctionTable[332714] = bhEff_E14_Explosion_0x244c20; // 0x244eb0 - g_ps2RecompiledFunctionTable[332812] = bhEff_E14_Explosion_0x244c20; // 0x245038 - g_ps2RecompiledFunctionTable[332818] = bhEff_E14_Fire_0x245050; // 0x245050 - g_ps2RecompiledFunctionTable[332846] = bhEff_E14_Fire_0x245050; // 0x2450c0 - g_ps2RecompiledFunctionTable[332856] = bhEff_E14_Fire_0x245050; // 0x2450e8 - g_ps2RecompiledFunctionTable[332858] = bhEff_E14_Fire_0x245050; // 0x2450f0 - g_ps2RecompiledFunctionTable[332871] = bhEff_E14_Fire_0x245050; // 0x245124 - g_ps2RecompiledFunctionTable[332873] = bhEff_E14_Fire_0x245050; // 0x24512c - g_ps2RecompiledFunctionTable[332886] = bhEff_E14_Fire_0x245050; // 0x245160 - g_ps2RecompiledFunctionTable[332895] = bhEff_E14_Fire_0x245050; // 0x245184 - g_ps2RecompiledFunctionTable[332908] = bhEff_E14_Fire_0x245050; // 0x2451b8 - g_ps2RecompiledFunctionTable[333001] = bhEff_E14_Fire_0x245050; // 0x24532c - g_ps2RecompiledFunctionTable[333046] = bhEff_E14_Fire_0x245050; // 0x2453e0 - g_ps2RecompiledFunctionTable[333048] = bhEff_E14_Fire_0x245050; // 0x2453e8 - g_ps2RecompiledFunctionTable[333064] = bhEff_E14_Fire_0x245050; // 0x245428 - g_ps2RecompiledFunctionTable[333092] = bhEff_E14_Fire_0x245050; // 0x245498 - g_ps2RecompiledFunctionTable[333107] = bhEff_E14_Fire_0x245050; // 0x2454d4 - g_ps2RecompiledFunctionTable[333120] = bhEff_E14_Fire_0x245050; // 0x245508 - g_ps2RecompiledFunctionTable[333127] = bhEff_E14_Fire_0x245050; // 0x245524 - g_ps2RecompiledFunctionTable[333217] = bhEff_E14_Fire_0x245050; // 0x24568c - g_ps2RecompiledFunctionTable[333219] = bhEff_E14_Fire_0x245050; // 0x245694 - g_ps2RecompiledFunctionTable[333232] = bhEff_E14_Fire_0x245050; // 0x2456c8 - g_ps2RecompiledFunctionTable[333299] = bhEff_E14_Fire_0x245050; // 0x2457d4 - g_ps2RecompiledFunctionTable[333330] = bhEff_E14_Fire_0x245050; // 0x245850 - g_ps2RecompiledFunctionTable[333343] = bhEff_E14_Fire_0x245050; // 0x245884 - g_ps2RecompiledFunctionTable[333374] = bhEff_E14_Fire2_0x245900; // 0x245900 - g_ps2RecompiledFunctionTable[333402] = bhEff_E14_Fire2_0x245900; // 0x245970 - g_ps2RecompiledFunctionTable[333404] = bhEff_E14_Fire2_0x245900; // 0x245978 - g_ps2RecompiledFunctionTable[333420] = bhEff_E14_Fire2_0x245900; // 0x2459b8 - g_ps2RecompiledFunctionTable[333515] = bhEff_E14_Fire2_0x245900; // 0x245b34 - g_ps2RecompiledFunctionTable[333542] = bhEff_E14_Mucus_0x245ba0; // 0x245ba0 - g_ps2RecompiledFunctionTable[333565] = bhEff_E14_Mucus_0x245ba0; // 0x245bfc - g_ps2RecompiledFunctionTable[333585] = bhEff_E14_Mucus_0x245ba0; // 0x245c4c - g_ps2RecompiledFunctionTable[333647] = bhEff_E14_Mucus_0x245ba0; // 0x245d44 - g_ps2RecompiledFunctionTable[333650] = bhEff_E14_Mucus_0x245ba0; // 0x245d50 - g_ps2RecompiledFunctionTable[333660] = bhEff_E14_Mucus_0x245ba0; // 0x245d78 - g_ps2RecompiledFunctionTable[333695] = bhEff_E14_Mucus_0x245ba0; // 0x245e04 - g_ps2RecompiledFunctionTable[333700] = bhEff_E14_Mucus_0x245ba0; // 0x245e18 - g_ps2RecompiledFunctionTable[333703] = bhEff_E14_Mucus_0x245ba0; // 0x245e24 - g_ps2RecompiledFunctionTable[333713] = bhEff_E14_Mucus_0x245ba0; // 0x245e4c - g_ps2RecompiledFunctionTable[333722] = bhEff_E14_Mucus_0x245ba0; // 0x245e70 - g_ps2RecompiledFunctionTable[333727] = bhEff_E14_Mucus_0x245ba0; // 0x245e84 - g_ps2RecompiledFunctionTable[333758] = bhEff_E14_MucusDraw_0x245f00; // 0x245f00 - g_ps2RecompiledFunctionTable[333776] = bhEff_E14_MucusDraw_0x245f00; // 0x245f48 - g_ps2RecompiledFunctionTable[333778] = bhEff_E14_MucusDraw_0x245f00; // 0x245f50 - g_ps2RecompiledFunctionTable[333784] = bhEff_E14_MucusDraw_0x245f00; // 0x245f68 - g_ps2RecompiledFunctionTable[333795] = bhEff_E14_MucusDraw_0x245f00; // 0x245f94 - g_ps2RecompiledFunctionTable[333798] = bhEff_E14_MucusDraw_0x245f00; // 0x245fa0 - g_ps2RecompiledFunctionTable[333801] = bhEff_E14_MucusDraw_0x245f00; // 0x245fac - g_ps2RecompiledFunctionTable[333805] = bhEff_E14_MucusDraw_0x245f00; // 0x245fbc - g_ps2RecompiledFunctionTable[333808] = bhEff_E14_MucusDraw_0x245f00; // 0x245fc8 - g_ps2RecompiledFunctionTable[333811] = bhEff_E14_MucusDraw_0x245f00; // 0x245fd4 - g_ps2RecompiledFunctionTable[333818] = bhEff_DamagePoint_0x245ff0; // 0x245ff0 - g_ps2RecompiledFunctionTable[333843] = bhEff_DamagePoint_0x245ff0; // 0x246054 - g_ps2RecompiledFunctionTable[333930] = bhEff_DamagePointDraw_0x2461b0; // 0x2461b0 - g_ps2RecompiledFunctionTable[333937] = bhEff_DamagePointDraw_0x2461b0; // 0x2461cc - g_ps2RecompiledFunctionTable[333942] = bhEff_Draw3DSprite_0x2461e0; // 0x2461e0 - g_ps2RecompiledFunctionTable[333947] = bhEff_Draw3DSprite_0x2461e0; // 0x2461f4 - g_ps2RecompiledFunctionTable[333951] = bhEff_Draw3DSprite_0x2461e0; // 0x246204 - g_ps2RecompiledFunctionTable[333953] = bhEff_Draw3DSprite_0x2461e0; // 0x24620c - g_ps2RecompiledFunctionTable[333960] = bhEff_Draw3DSprite_0x2461e0; // 0x246228 - g_ps2RecompiledFunctionTable[333965] = bhEff_Draw3DSprite_0x2461e0; // 0x24623c - g_ps2RecompiledFunctionTable[333975] = bhEff_Draw3DSprite_0x2461e0; // 0x246264 - g_ps2RecompiledFunctionTable[333986] = bhEff_Draw3DSprite_0x2461e0; // 0x246290 - g_ps2RecompiledFunctionTable[333990] = bhEff_Draw3DSprite_0x2461e0; // 0x2462a0 - g_ps2RecompiledFunctionTable[333994] = bhEff_Draw3DSprite_0x2461e0; // 0x2462b0 - g_ps2RecompiledFunctionTable[333996] = bhEff_Draw3DSprite_0x2461e0; // 0x2462b8 - g_ps2RecompiledFunctionTable[334007] = bhEff_Draw3DSprite_0x2461e0; // 0x2462e4 - g_ps2RecompiledFunctionTable[334009] = bhEff_Draw3DSprite_0x2461e0; // 0x2462ec - g_ps2RecompiledFunctionTable[334012] = bhEff_Draw3DSprite_0x2461e0; // 0x2462f8 - g_ps2RecompiledFunctionTable[334014] = bhEff_Draw3DSprite_0x2461e0; // 0x246300 - g_ps2RecompiledFunctionTable[334027] = bhEff_Draw3DSprite_0x2461e0; // 0x246334 - g_ps2RecompiledFunctionTable[334032] = bhEff_Draw3DSprite_0x2461e0; // 0x246348 - g_ps2RecompiledFunctionTable[334037] = bhEff_Draw3DSprite_0x2461e0; // 0x24635c - g_ps2RecompiledFunctionTable[334039] = bhEff_Draw3DSprite_0x2461e0; // 0x246364 - g_ps2RecompiledFunctionTable[334042] = bhEff_Draw3DSprite_0x2461e0; // 0x246370 - g_ps2RecompiledFunctionTable[334049] = bhEff_Draw3DSprite_0x2461e0; // 0x24638c - g_ps2RecompiledFunctionTable[334052] = bhEff_Draw3DSprite_0x2461e0; // 0x246398 - g_ps2RecompiledFunctionTable[334069] = bhEff_Draw3DSprite_0x2461e0; // 0x2463dc - g_ps2RecompiledFunctionTable[334082] = bhEff_Draw3DSprite_0x2461e0; // 0x246410 - g_ps2RecompiledFunctionTable[334085] = bhEff_Draw3DSprite_0x2461e0; // 0x24641c - g_ps2RecompiledFunctionTable[334094] = bhEff_Draw3DSprite_0x2461e0; // 0x246440 - g_ps2RecompiledFunctionTable[334099] = bhEff_Draw3DSprite_0x2461e0; // 0x246454 - g_ps2RecompiledFunctionTable[334104] = bhEff_Draw3DSprite_0x2461e0; // 0x246468 - g_ps2RecompiledFunctionTable[334108] = bhEff_Draw3DSprite_0x2461e0; // 0x246478 - g_ps2RecompiledFunctionTable[334113] = bhEff_Draw3DSprite_0x2461e0; // 0x24648c - g_ps2RecompiledFunctionTable[334118] = bhEff_Draw3DSprite_0x2461e0; // 0x2464a0 - g_ps2RecompiledFunctionTable[334123] = bhEff_Draw3DSprite_0x2461e0; // 0x2464b4 - g_ps2RecompiledFunctionTable[334125] = bhEff_Draw3DSprite_0x2461e0; // 0x2464bc - g_ps2RecompiledFunctionTable[334136] = bhEff_Draw3DSprite_0x2461e0; // 0x2464e8 - g_ps2RecompiledFunctionTable[334145] = bhEff_Draw3DSprite_0x2461e0; // 0x24650c - g_ps2RecompiledFunctionTable[334148] = bhEff_Draw3DSprite_0x2461e0; // 0x246518 - g_ps2RecompiledFunctionTable[334152] = bhEff_Draw3DSprite_0x2461e0; // 0x246528 - g_ps2RecompiledFunctionTable[334155] = bhEff_Draw3DSprite_0x2461e0; // 0x246534 - g_ps2RecompiledFunctionTable[334158] = bhEff_Draw3DSprite_0x2461e0; // 0x246540 - g_ps2RecompiledFunctionTable[334160] = bhEff_Draw3DSprite_0x2461e0; // 0x246548 - g_ps2RecompiledFunctionTable[334168] = bhEff_Draw3DSprite_0x2461e0; // 0x246568 - g_ps2RecompiledFunctionTable[334174] = bhEff_SetUVInfo_0x246580; // 0x246580 - g_ps2RecompiledFunctionTable[334210] = bhEff_SetAlign_0x246610; // 0x246610 - g_ps2RecompiledFunctionTable[334274] = bhEff_SetBaseColor_0x246710; // 0x246710 - g_ps2RecompiledFunctionTable[334282] = bhClrEff_YG_0x246730; // 0x246730 - g_ps2RecompiledFunctionTable[334295] = bhClrEff_YG_0x246730; // 0x246764 - g_ps2RecompiledFunctionTable[334334] = AllocOwork_0x246800; // 0x246800 - g_ps2RecompiledFunctionTable[334350] = AllocOwork_0x246800; // 0x246840 - g_ps2RecompiledFunctionTable[334358] = AllocOwork_0x246800; // 0x246860 - g_ps2RecompiledFunctionTable[334378] = AllocOworkOne_0x2468b0; // 0x2468b0 - g_ps2RecompiledFunctionTable[334384] = AllocOworkOne_0x2468b0; // 0x2468c8 - g_ps2RecompiledFunctionTable[334392] = AllocOworkOne_0x2468b0; // 0x2468e8 - g_ps2RecompiledFunctionTable[334406] = bhClrEff_RY_0x246920; // 0x246920 - g_ps2RecompiledFunctionTable[334411] = bhClrEff_RY_0x246920; // 0x246934 - g_ps2RecompiledFunctionTable[334438] = bhSetBloodPoolLnk_0x2469a0; // 0x2469a0 - g_ps2RecompiledFunctionTable[334453] = bhSetBloodPoolLnk_0x2469a0; // 0x2469dc - g_ps2RecompiledFunctionTable[334457] = bhSetBloodPoolLnk_0x2469a0; // 0x2469ec - g_ps2RecompiledFunctionTable[334485] = bhSetBloodPoolLnk_0x2469a0; // 0x246a5c - g_ps2RecompiledFunctionTable[334582] = bhEff300_0x246be0; // 0x246be0 - g_ps2RecompiledFunctionTable[334612] = bhEff300_0x246be0; // 0x246c58 - g_ps2RecompiledFunctionTable[334618] = bhEff300_0x246be0; // 0x246c70 - g_ps2RecompiledFunctionTable[334626] = bhEff300_0x246be0; // 0x246c90 - g_ps2RecompiledFunctionTable[334638] = bhEff300_0x246be0; // 0x246cc0 - g_ps2RecompiledFunctionTable[334645] = bhEff300_0x246be0; // 0x246cdc - g_ps2RecompiledFunctionTable[334655] = bhEff300_0x246be0; // 0x246d04 - g_ps2RecompiledFunctionTable[334660] = bhEff300_0x246be0; // 0x246d18 - g_ps2RecompiledFunctionTable[334666] = bhEff300_0x246be0; // 0x246d30 - g_ps2RecompiledFunctionTable[334680] = bhEff300_0x246be0; // 0x246d68 - g_ps2RecompiledFunctionTable[334683] = bhEff300_0x246be0; // 0x246d74 - g_ps2RecompiledFunctionTable[334699] = bhEff300_0x246be0; // 0x246db4 - g_ps2RecompiledFunctionTable[334742] = bhEff300_0x246be0; // 0x246e60 - g_ps2RecompiledFunctionTable[334749] = bhEff300_0x246be0; // 0x246e7c - g_ps2RecompiledFunctionTable[334767] = bhEff300_0x246be0; // 0x246ec4 - g_ps2RecompiledFunctionTable[334789] = bhEff300_0x246be0; // 0x246f1c - g_ps2RecompiledFunctionTable[334802] = bhEff300_0x246be0; // 0x246f50 - g_ps2RecompiledFunctionTable[334824] = bhEff300_0x246be0; // 0x246fa8 - g_ps2RecompiledFunctionTable[334837] = bhEff300_0x246be0; // 0x246fdc - g_ps2RecompiledFunctionTable[334859] = bhEff300_0x246be0; // 0x247034 - g_ps2RecompiledFunctionTable[334872] = bhEff300_0x246be0; // 0x247068 - g_ps2RecompiledFunctionTable[334926] = bhEff301_0x247140; // 0x247140 - g_ps2RecompiledFunctionTable[335007] = bhEff301_0x247140; // 0x247284 - g_ps2RecompiledFunctionTable[335025] = bhEff301_0x247140; // 0x2472cc - g_ps2RecompiledFunctionTable[335028] = bhEff301_0x247140; // 0x2472d8 - g_ps2RecompiledFunctionTable[335045] = bhEff301_0x247140; // 0x24731c - g_ps2RecompiledFunctionTable[335051] = bhEff301_0x247140; // 0x247334 - g_ps2RecompiledFunctionTable[335054] = bhEff301_0x247140; // 0x247340 - g_ps2RecompiledFunctionTable[335059] = bhEff301_0x247140; // 0x247354 - g_ps2RecompiledFunctionTable[335063] = bhEff301_0x247140; // 0x247364 - g_ps2RecompiledFunctionTable[335066] = bhEff301_0x247140; // 0x247370 - g_ps2RecompiledFunctionTable[335080] = bhEff301_0x247140; // 0x2473a8 - g_ps2RecompiledFunctionTable[335113] = bhEff301_0x247140; // 0x24742c - g_ps2RecompiledFunctionTable[335143] = bhEff301_0x247140; // 0x2474a4 - g_ps2RecompiledFunctionTable[335160] = bhEff301_0x247140; // 0x2474e8 - g_ps2RecompiledFunctionTable[335165] = bhEff301_0x247140; // 0x2474fc - g_ps2RecompiledFunctionTable[335173] = bhEff301_0x247140; // 0x24751c - g_ps2RecompiledFunctionTable[335191] = bhEff301_0x247140; // 0x247564 - g_ps2RecompiledFunctionTable[335194] = bhEff301_0x247140; // 0x247570 - g_ps2RecompiledFunctionTable[335205] = bhEff301_0x247140; // 0x24759c - g_ps2RecompiledFunctionTable[335213] = bhEff301_0x247140; // 0x2475bc - g_ps2RecompiledFunctionTable[335252] = bhEff301_0x247140; // 0x247658 - g_ps2RecompiledFunctionTable[335293] = bhEff301_0x247140; // 0x2476fc - g_ps2RecompiledFunctionTable[335297] = bhEff301_0x247140; // 0x24770c - g_ps2RecompiledFunctionTable[335414] = bhEff301_0x247140; // 0x2478e0 - g_ps2RecompiledFunctionTable[335419] = bhEff301_0x247140; // 0x2478f4 - g_ps2RecompiledFunctionTable[335423] = bhEff301_0x247140; // 0x247904 - g_ps2RecompiledFunctionTable[335428] = bhEff301_0x247140; // 0x247918 - g_ps2RecompiledFunctionTable[335525] = bhEff301_0x247140; // 0x247a9c - g_ps2RecompiledFunctionTable[335544] = bhEff301_0x247140; // 0x247ae8 - g_ps2RecompiledFunctionTable[335548] = bhEff301_0x247140; // 0x247af8 - g_ps2RecompiledFunctionTable[335559] = bhEff301_0x247140; // 0x247b24 - g_ps2RecompiledFunctionTable[335639] = bhEff301_0x247140; // 0x247c64 - g_ps2RecompiledFunctionTable[335643] = bhEff301_0x247140; // 0x247c74 - g_ps2RecompiledFunctionTable[335648] = bhEff301_0x247140; // 0x247c88 - g_ps2RecompiledFunctionTable[335653] = bhEff301_0x247140; // 0x247c9c - g_ps2RecompiledFunctionTable[335658] = bhEff301_0x247140; // 0x247cb0 - g_ps2RecompiledFunctionTable[335699] = bhEff301_0x247140; // 0x247d54 - g_ps2RecompiledFunctionTable[335906] = bhSetEffParticle_0x248090; // 0x248090 - g_ps2RecompiledFunctionTable[335935] = bhSetEffParticle_0x248090; // 0x248104 - g_ps2RecompiledFunctionTable[335937] = bhSetEffParticle_0x248090; // 0x24810c - g_ps2RecompiledFunctionTable[335939] = bhSetEffParticle_0x248090; // 0x248114 - g_ps2RecompiledFunctionTable[335941] = bhSetEffParticle_0x248090; // 0x24811c - g_ps2RecompiledFunctionTable[336048] = bhSetEffParticle_0x248090; // 0x2482c8 - g_ps2RecompiledFunctionTable[336066] = bhSetEffParticleMk2_0x248310; // 0x248310 - g_ps2RecompiledFunctionTable[336097] = bhSetEffParticleMk2_0x248310; // 0x24838c - g_ps2RecompiledFunctionTable[336099] = bhSetEffParticleMk2_0x248310; // 0x248394 - g_ps2RecompiledFunctionTable[336101] = bhSetEffParticleMk2_0x248310; // 0x24839c - g_ps2RecompiledFunctionTable[336103] = bhSetEffParticleMk2_0x248310; // 0x2483a4 - g_ps2RecompiledFunctionTable[336206] = bhSetEffParticleMk2_0x248310; // 0x248540 - g_ps2RecompiledFunctionTable[336226] = bhEff302_0x248590; // 0x248590 - g_ps2RecompiledFunctionTable[336301] = bhEff302_0x248590; // 0x2486bc - g_ps2RecompiledFunctionTable[336324] = bhEff302_0x248590; // 0x248718 - g_ps2RecompiledFunctionTable[336326] = bhEff302_0x248590; // 0x248720 - g_ps2RecompiledFunctionTable[336343] = bhEff302_0x248590; // 0x248764 - g_ps2RecompiledFunctionTable[336345] = bhEff302_0x248590; // 0x24876c - g_ps2RecompiledFunctionTable[336362] = bhEff302_0x248590; // 0x2487b0 - g_ps2RecompiledFunctionTable[336364] = bhEff302_0x248590; // 0x2487b8 - g_ps2RecompiledFunctionTable[336381] = bhEff302_0x248590; // 0x2487fc - g_ps2RecompiledFunctionTable[336391] = bhEff302_0x248590; // 0x248824 - g_ps2RecompiledFunctionTable[336397] = bhEff302_0x248590; // 0x24883c - g_ps2RecompiledFunctionTable[336402] = bhEff302_0x248590; // 0x248850 - g_ps2RecompiledFunctionTable[336510] = bhEff302_0x248590; // 0x248a00 - g_ps2RecompiledFunctionTable[336522] = bhEff302_0x248590; // 0x248a30 - g_ps2RecompiledFunctionTable[336529] = bhEff302_0x248590; // 0x248a4c - g_ps2RecompiledFunctionTable[336543] = bhEff302_0x248590; // 0x248a84 - g_ps2RecompiledFunctionTable[336557] = bhEff302_0x248590; // 0x248abc - g_ps2RecompiledFunctionTable[336571] = bhEff302_0x248590; // 0x248af4 - g_ps2RecompiledFunctionTable[336607] = bhEff302_0x248590; // 0x248b84 - g_ps2RecompiledFunctionTable[336687] = bhEff302_0x248590; // 0x248cc4 - g_ps2RecompiledFunctionTable[336688] = bhEff302_0x248590; // 0x248cc8 - g_ps2RecompiledFunctionTable[336712] = bhEff302_0x248590; // 0x248d28 - g_ps2RecompiledFunctionTable[336746] = bhEff_PtclSpriteDrawB_0x248db0; // 0x248db0 - g_ps2RecompiledFunctionTable[336759] = bhEff_PtclSpriteDrawB_0x248db0; // 0x248de4 - g_ps2RecompiledFunctionTable[336762] = bhEff_PtclSpriteDrawB_0x248db0; // 0x248df0 - g_ps2RecompiledFunctionTable[336765] = bhEff_PtclSpriteDrawB_0x248db0; // 0x248dfc - g_ps2RecompiledFunctionTable[336767] = bhEff_PtclSpriteDrawB_0x248db0; // 0x248e04 - g_ps2RecompiledFunctionTable[336771] = bhEff_PtclSpriteDrawB_0x248db0; // 0x248e14 - g_ps2RecompiledFunctionTable[336773] = bhEff_PtclSpriteDrawB_0x248db0; // 0x248e1c - g_ps2RecompiledFunctionTable[336778] = bhEff_PtclSpriteDrawB_0x248db0; // 0x248e30 - g_ps2RecompiledFunctionTable[336787] = bhEff_PtclSpriteDrawB_0x248db0; // 0x248e54 - g_ps2RecompiledFunctionTable[336792] = bhEff_PtclSpriteDrawB_0x248db0; // 0x248e68 - g_ps2RecompiledFunctionTable[336797] = bhEff_PtclSpriteDrawB_0x248db0; // 0x248e7c - g_ps2RecompiledFunctionTable[336802] = bhEff_PtclSpriteDrawB_0x248db0; // 0x248e90 - g_ps2RecompiledFunctionTable[336807] = bhEff_PtclSpriteDrawB_0x248db0; // 0x248ea4 - g_ps2RecompiledFunctionTable[336809] = bhEff_PtclSpriteDrawB_0x248db0; // 0x248eac - g_ps2RecompiledFunctionTable[336816] = bhEff_PtclSpriteDrawB_0x248db0; // 0x248ec8 - g_ps2RecompiledFunctionTable[336826] = bhEff_PtclLineDraw_0x248ef0; // 0x248ef0 - g_ps2RecompiledFunctionTable[336843] = bhEff_PtclLineDraw_0x248ef0; // 0x248f34 - g_ps2RecompiledFunctionTable[336866] = bhEff_PtclLineDraw_0x248ef0; // 0x248f90 - g_ps2RecompiledFunctionTable[336878] = bhEff_PtclLineDraw_0x248ef0; // 0x248fc0 - g_ps2RecompiledFunctionTable[336905] = bhEff_PtclLineDraw_0x248ef0; // 0x24902c - g_ps2RecompiledFunctionTable[336926] = bhEff_PtclLineDraw_0x248ef0; // 0x249080 - g_ps2RecompiledFunctionTable[336958] = bhEff303_0x249100; // 0x249100 - g_ps2RecompiledFunctionTable[337050] = bhEff303_0x249100; // 0x249270 - g_ps2RecompiledFunctionTable[337055] = bhEff303_0x249100; // 0x249284 - g_ps2RecompiledFunctionTable[337059] = bhEff303_0x249100; // 0x249294 - g_ps2RecompiledFunctionTable[337143] = bhEff303_0x249100; // 0x2493e4 - g_ps2RecompiledFunctionTable[337166] = bhCheckCamWall2D_0x249440; // 0x249440 - g_ps2RecompiledFunctionTable[337181] = bhCheckCamWall2D_0x249440; // 0x24947c - g_ps2RecompiledFunctionTable[337187] = bhCheckCamWall2D_0x249440; // 0x249494 - g_ps2RecompiledFunctionTable[337191] = bhCheckCamWall2D_0x249440; // 0x2494a4 - g_ps2RecompiledFunctionTable[337202] = bhCheckCamWall2D_0x249440; // 0x2494d0 - g_ps2RecompiledFunctionTable[337231] = bhCheckCamWall2D_0x249440; // 0x249544 - g_ps2RecompiledFunctionTable[337258] = rySetShadow_0x2495b0; // 0x2495b0 - g_ps2RecompiledFunctionTable[337273] = rySetShadow_0x2495b0; // 0x2495ec - g_ps2RecompiledFunctionTable[337338] = bhEff304_0x2496f0; // 0x2496f0 - g_ps2RecompiledFunctionTable[337397] = bhEff304_0x2496f0; // 0x2497dc - g_ps2RecompiledFunctionTable[337400] = bhEff304_0x2496f0; // 0x2497e8 - g_ps2RecompiledFunctionTable[337410] = bhEff304_0x2496f0; // 0x249810 - g_ps2RecompiledFunctionTable[337413] = bhEff304_0x2496f0; // 0x24981c - g_ps2RecompiledFunctionTable[337418] = bhEff304_0x2496f0; // 0x249830 - g_ps2RecompiledFunctionTable[337461] = bhEff304_0x2496f0; // 0x2498dc - g_ps2RecompiledFunctionTable[337495] = bhEff304_0x2496f0; // 0x249964 - g_ps2RecompiledFunctionTable[337550] = bhEff305_0x249a40; // 0x249a40 - g_ps2RecompiledFunctionTable[337656] = bhEff305_0x249a40; // 0x249be8 - g_ps2RecompiledFunctionTable[337658] = bhEff305_0x249a40; // 0x249bf0 - g_ps2RecompiledFunctionTable[337677] = bhEff305_0x249a40; // 0x249c3c - g_ps2RecompiledFunctionTable[337680] = bhEff305_0x249a40; // 0x249c48 - g_ps2RecompiledFunctionTable[337684] = bhEff305_0x249a40; // 0x249c58 - g_ps2RecompiledFunctionTable[337687] = bhEff305_0x249a40; // 0x249c64 - g_ps2RecompiledFunctionTable[337690] = bhEff305_0x249a40; // 0x249c70 - g_ps2RecompiledFunctionTable[337720] = bhEff305_0x249a40; // 0x249ce8 - g_ps2RecompiledFunctionTable[337743] = bhEff305_0x249a40; // 0x249d44 - g_ps2RecompiledFunctionTable[337750] = bhEff305_0x249a40; // 0x249d60 - g_ps2RecompiledFunctionTable[337834] = bhEff306_0x249eb0; // 0x249eb0 - g_ps2RecompiledFunctionTable[337869] = bhEff306_0x249eb0; // 0x249f3c - g_ps2RecompiledFunctionTable[337882] = bhEff306_0x249eb0; // 0x249f70 - g_ps2RecompiledFunctionTable[337923] = bhEff306_0x249eb0; // 0x24a014 - g_ps2RecompiledFunctionTable[337937] = bhEff306_0x249eb0; // 0x24a04c - g_ps2RecompiledFunctionTable[337967] = bhEff306_0x249eb0; // 0x24a0c4 - g_ps2RecompiledFunctionTable[338001] = bhEff306_0x249eb0; // 0x24a14c - g_ps2RecompiledFunctionTable[338040] = bhEff306_0x249eb0; // 0x24a1e8 - g_ps2RecompiledFunctionTable[338066] = bhEff306_0x249eb0; // 0x24a250 - g_ps2RecompiledFunctionTable[338068] = bhEff306_0x249eb0; // 0x24a258 - g_ps2RecompiledFunctionTable[338138] = bhSetRapEff_0x24a370; // 0x24a370 - g_ps2RecompiledFunctionTable[338148] = bhSetRapEff_0x24a370; // 0x24a398 - g_ps2RecompiledFunctionTable[338158] = bhSetRapEff_0x24a370; // 0x24a3c0 - g_ps2RecompiledFunctionTable[338166] = bhEff307_0x24a3e0; // 0x24a3e0 - g_ps2RecompiledFunctionTable[338230] = bhEff307_0x24a3e0; // 0x24a4e0 - g_ps2RecompiledFunctionTable[338234] = bhEff307_0x24a3e0; // 0x24a4f0 - g_ps2RecompiledFunctionTable[338247] = bhEff307_0x24a3e0; // 0x24a524 - g_ps2RecompiledFunctionTable[338249] = bhEff307_0x24a3e0; // 0x24a52c - g_ps2RecompiledFunctionTable[338300] = bhEff307_0x24a3e0; // 0x24a5f8 - g_ps2RecompiledFunctionTable[338302] = bhEff307_0x24a3e0; // 0x24a600 - g_ps2RecompiledFunctionTable[338305] = bhEff307_0x24a3e0; // 0x24a60c - g_ps2RecompiledFunctionTable[338308] = bhEff307_0x24a3e0; // 0x24a618 - g_ps2RecompiledFunctionTable[338328] = bhEff307_0x24a3e0; // 0x24a668 - g_ps2RecompiledFunctionTable[338334] = bhEff307_0x24a3e0; // 0x24a680 - g_ps2RecompiledFunctionTable[338343] = bhEff307_0x24a3e0; // 0x24a6a4 - g_ps2RecompiledFunctionTable[338346] = bhEff307_0x24a3e0; // 0x24a6b0 - g_ps2RecompiledFunctionTable[338360] = bhEff307_0x24a3e0; // 0x24a6e8 - g_ps2RecompiledFunctionTable[338422] = bhEff307Drw_0x24a7e0; // 0x24a7e0 - g_ps2RecompiledFunctionTable[338437] = bhEff307Drw_0x24a7e0; // 0x24a81c - g_ps2RecompiledFunctionTable[338440] = bhEff307Drw_0x24a7e0; // 0x24a828 - g_ps2RecompiledFunctionTable[338443] = bhEff307Drw_0x24a7e0; // 0x24a834 - g_ps2RecompiledFunctionTable[338445] = bhEff307Drw_0x24a7e0; // 0x24a83c - g_ps2RecompiledFunctionTable[338450] = bhEff307Drw_0x24a7e0; // 0x24a850 - g_ps2RecompiledFunctionTable[338452] = bhEff307Drw_0x24a7e0; // 0x24a858 - g_ps2RecompiledFunctionTable[338460] = bhEff307Drw_0x24a7e0; // 0x24a878 - g_ps2RecompiledFunctionTable[338465] = bhEff307Drw_0x24a7e0; // 0x24a88c - g_ps2RecompiledFunctionTable[338467] = bhEff307Drw_0x24a7e0; // 0x24a894 - g_ps2RecompiledFunctionTable[338468] = bhEff307Drw_0x24a7e0; // 0x24a898 - g_ps2RecompiledFunctionTable[338494] = bhEff307Drw_0x24a7e0; // 0x24a900 - g_ps2RecompiledFunctionTable[338504] = bhEff307Drw_0x24a7e0; // 0x24a928 - g_ps2RecompiledFunctionTable[338522] = bhEff307Drw_0x24a7e0; // 0x24a970 - g_ps2RecompiledFunctionTable[338528] = bhEff307Drw_0x24a7e0; // 0x24a988 - g_ps2RecompiledFunctionTable[338543] = bhEff307Drw_0x24a7e0; // 0x24a9c4 - g_ps2RecompiledFunctionTable[338549] = bhEff307Drw_0x24a7e0; // 0x24a9dc - g_ps2RecompiledFunctionTable[338555] = bhEff307Drw_0x24a7e0; // 0x24a9f4 - g_ps2RecompiledFunctionTable[338559] = bhEff307Drw_0x24a7e0; // 0x24aa04 - g_ps2RecompiledFunctionTable[338574] = bhSetEffGunSpark_0x24aa40; // 0x24aa40 - g_ps2RecompiledFunctionTable[338593] = bhSetEffGunSpark_0x24aa40; // 0x24aa8c - g_ps2RecompiledFunctionTable[338622] = bhSetEffSpark_0x24ab00; // 0x24ab00 - g_ps2RecompiledFunctionTable[338642] = bhSetEffSpark_0x24ab00; // 0x24ab50 - g_ps2RecompiledFunctionTable[338662] = bhSetEffSpark_0x24ab00; // 0x24aba0 - g_ps2RecompiledFunctionTable[338722] = bhEff308_0x24ac90; // 0x24ac90 - g_ps2RecompiledFunctionTable[338746] = bhEff308_0x24ac90; // 0x24acf0 - g_ps2RecompiledFunctionTable[338752] = bhEff308_0x24ac90; // 0x24ad08 - g_ps2RecompiledFunctionTable[338754] = bhEff308_0x24ac90; // 0x24ad10 - g_ps2RecompiledFunctionTable[338771] = bhEff308_0x24ac90; // 0x24ad54 - g_ps2RecompiledFunctionTable[338773] = bhEff308_0x24ac90; // 0x24ad5c - g_ps2RecompiledFunctionTable[338790] = bhEff308_0x24ac90; // 0x24ada0 - g_ps2RecompiledFunctionTable[338792] = bhEff308_0x24ac90; // 0x24ada8 - g_ps2RecompiledFunctionTable[338809] = bhEff308_0x24ac90; // 0x24adec - g_ps2RecompiledFunctionTable[338813] = bhEff308_0x24ac90; // 0x24adfc - g_ps2RecompiledFunctionTable[338817] = bhEff308_0x24ac90; // 0x24ae0c - g_ps2RecompiledFunctionTable[338822] = bhEff308_0x24ac90; // 0x24ae20 - g_ps2RecompiledFunctionTable[338838] = bhEff308_0x24ac90; // 0x24ae60 - g_ps2RecompiledFunctionTable[338859] = bhEff308_0x24ac90; // 0x24aeb4 - g_ps2RecompiledFunctionTable[338861] = bhEff308_0x24ac90; // 0x24aebc - g_ps2RecompiledFunctionTable[338874] = bhEff308_0x24ac90; // 0x24aef0 - g_ps2RecompiledFunctionTable[338992] = bhEff308_0x24ac90; // 0x24b0c8 - g_ps2RecompiledFunctionTable[338998] = bhEff308_0x24ac90; // 0x24b0e0 - g_ps2RecompiledFunctionTable[339007] = bhEff308_0x24ac90; // 0x24b104 - g_ps2RecompiledFunctionTable[339024] = bhEff308_0x24ac90; // 0x24b148 - g_ps2RecompiledFunctionTable[339027] = bhEff308_0x24ac90; // 0x24b154 - g_ps2RecompiledFunctionTable[339110] = bhEff308Drw_0x24b2a0; // 0x24b2a0 - g_ps2RecompiledFunctionTable[339123] = bhEff308Drw_0x24b2a0; // 0x24b2d4 - g_ps2RecompiledFunctionTable[339129] = bhEff308Drw_0x24b2a0; // 0x24b2ec - g_ps2RecompiledFunctionTable[339143] = bhEff308Drw_0x24b2a0; // 0x24b324 - g_ps2RecompiledFunctionTable[339162] = ryLinerColor_0x24b370; // 0x24b370 - g_ps2RecompiledFunctionTable[339172] = ryLinerColor_0x24b370; // 0x24b398 - g_ps2RecompiledFunctionTable[339214] = rySetEffBlood_0x24b440; // 0x24b440 - g_ps2RecompiledFunctionTable[339244] = rySetEffBlood_0x24b440; // 0x24b4b8 - g_ps2RecompiledFunctionTable[339282] = bhEff309_0x24b550; // 0x24b550 - g_ps2RecompiledFunctionTable[339311] = bhEff309_0x24b550; // 0x24b5c4 - g_ps2RecompiledFunctionTable[339324] = bhEff309_0x24b550; // 0x24b5f8 - g_ps2RecompiledFunctionTable[339327] = bhEff309_0x24b550; // 0x24b604 - g_ps2RecompiledFunctionTable[339336] = bhEff309_0x24b550; // 0x24b628 - g_ps2RecompiledFunctionTable[339345] = bhEff309_0x24b550; // 0x24b64c - g_ps2RecompiledFunctionTable[339348] = bhEff309_0x24b550; // 0x24b658 - g_ps2RecompiledFunctionTable[339353] = bhEff309_0x24b550; // 0x24b66c - g_ps2RecompiledFunctionTable[339366] = bhEff309_0x24b550; // 0x24b6a0 - g_ps2RecompiledFunctionTable[339370] = bhEff309_0x24b550; // 0x24b6b0 - g_ps2RecompiledFunctionTable[339374] = bhEff309_0x24b550; // 0x24b6c0 - g_ps2RecompiledFunctionTable[339376] = bhEff309_0x24b550; // 0x24b6c8 - g_ps2RecompiledFunctionTable[339393] = bhEff309_0x24b550; // 0x24b70c - g_ps2RecompiledFunctionTable[339397] = bhEff309_0x24b550; // 0x24b71c - g_ps2RecompiledFunctionTable[339399] = bhEff309_0x24b550; // 0x24b724 - g_ps2RecompiledFunctionTable[339416] = bhEff309_0x24b550; // 0x24b768 - g_ps2RecompiledFunctionTable[339420] = bhEff309_0x24b550; // 0x24b778 - g_ps2RecompiledFunctionTable[339422] = bhEff309_0x24b550; // 0x24b780 - g_ps2RecompiledFunctionTable[339441] = bhEff309_0x24b550; // 0x24b7cc - g_ps2RecompiledFunctionTable[339459] = bhEff309_0x24b550; // 0x24b814 - g_ps2RecompiledFunctionTable[339467] = bhEff309_0x24b550; // 0x24b834 - g_ps2RecompiledFunctionTable[339475] = bhEff309_0x24b550; // 0x24b854 - g_ps2RecompiledFunctionTable[339496] = bhEff309_0x24b550; // 0x24b8a8 - g_ps2RecompiledFunctionTable[339538] = bhEff309Drw_0x24b950; // 0x24b950 - g_ps2RecompiledFunctionTable[339544] = bhEff309Drw_0x24b950; // 0x24b968 - g_ps2RecompiledFunctionTable[339547] = bhEff309Drw_0x24b950; // 0x24b974 - g_ps2RecompiledFunctionTable[339550] = bhEff309Drw_0x24b950; // 0x24b980 - g_ps2RecompiledFunctionTable[339556] = bhEff309Drw_0x24b950; // 0x24b998 - g_ps2RecompiledFunctionTable[339562] = ryRapTexDrw_0x24b9b0; // 0x24b9b0 - g_ps2RecompiledFunctionTable[339569] = ryRapTexDrw_0x24b9b0; // 0x24b9cc - g_ps2RecompiledFunctionTable[339571] = ryRapTexDrw_0x24b9b0; // 0x24b9d4 - g_ps2RecompiledFunctionTable[339573] = ryRapTexDrw_0x24b9b0; // 0x24b9dc - g_ps2RecompiledFunctionTable[339575] = ryRapTexDrw_0x24b9b0; // 0x24b9e4 - g_ps2RecompiledFunctionTable[339577] = ryRapTexDrw_0x24b9b0; // 0x24b9ec - g_ps2RecompiledFunctionTable[339581] = ryRapTexDrw_0x24b9b0; // 0x24b9fc - g_ps2RecompiledFunctionTable[339584] = ryRapTexDrw_0x24b9b0; // 0x24ba08 - g_ps2RecompiledFunctionTable[339586] = ryRapTexDrw_0x24b9b0; // 0x24ba10 - g_ps2RecompiledFunctionTable[339592] = ryRapTexDrw_0x24b9b0; // 0x24ba28 - g_ps2RecompiledFunctionTable[339595] = ryRapTexDrw_0x24b9b0; // 0x24ba34 - g_ps2RecompiledFunctionTable[339600] = ryRapTexDrw_0x24b9b0; // 0x24ba48 - g_ps2RecompiledFunctionTable[339602] = ryRapTexDrw_0x24b9b0; // 0x24ba50 - g_ps2RecompiledFunctionTable[339610] = ryRapTexAnm_0x24ba70; // 0x24ba70 - g_ps2RecompiledFunctionTable[339662] = ryRapDspSet_0x24bb40; // 0x24bb40 - g_ps2RecompiledFunctionTable[339686] = ryRapAnmColSet_0x24bba0; // 0x24bba0 - g_ps2RecompiledFunctionTable[339770] = bhEff30a_0x24bcf0; // 0x24bcf0 - g_ps2RecompiledFunctionTable[339824] = bhEff30a_0x24bcf0; // 0x24bdc8 - g_ps2RecompiledFunctionTable[339826] = bhEff30a_0x24bcf0; // 0x24bdd0 - g_ps2RecompiledFunctionTable[339831] = bhEff30a_0x24bcf0; // 0x24bde4 - g_ps2RecompiledFunctionTable[339840] = bhEff30a_0x24bcf0; // 0x24be08 - g_ps2RecompiledFunctionTable[339874] = bhEff30a_0x24bcf0; // 0x24be90 - g_ps2RecompiledFunctionTable[339882] = bhEff349_0x24beb0; // 0x24beb0 - g_ps2RecompiledFunctionTable[339883] = bhEff349_0x24beb0; // 0x24beb4 - g_ps2RecompiledFunctionTable[339884] = bhEff349_0x24beb0; // 0x24beb8 - g_ps2RecompiledFunctionTable[339885] = bhEff349_0x24beb0; // 0x24bebc - g_ps2RecompiledFunctionTable[339886] = bhEff349_0x24beb0; // 0x24bec0 - g_ps2RecompiledFunctionTable[339887] = bhEff349_0x24beb0; // 0x24bec4 - g_ps2RecompiledFunctionTable[339888] = bhEff349_0x24beb0; // 0x24bec8 - g_ps2RecompiledFunctionTable[339889] = bhEff349_0x24beb0; // 0x24becc - g_ps2RecompiledFunctionTable[339890] = bhEff349_0x24beb0; // 0x24bed0 - g_ps2RecompiledFunctionTable[339891] = bhEff349_0x24beb0; // 0x24bed4 - g_ps2RecompiledFunctionTable[339892] = bhEff349_0x24beb0; // 0x24bed8 - g_ps2RecompiledFunctionTable[339893] = bhEff349_0x24beb0; // 0x24bedc - g_ps2RecompiledFunctionTable[339894] = bhEff349_0x24beb0; // 0x24bee0 - g_ps2RecompiledFunctionTable[339895] = bhEff349_0x24beb0; // 0x24bee4 - g_ps2RecompiledFunctionTable[339896] = bhEff349_0x24beb0; // 0x24bee8 - g_ps2RecompiledFunctionTable[339897] = bhEff349_0x24beb0; // 0x24beec - g_ps2RecompiledFunctionTable[339898] = bhEff349_0x24beb0; // 0x24bef0 - g_ps2RecompiledFunctionTable[339899] = bhEff349_0x24beb0; // 0x24bef4 - g_ps2RecompiledFunctionTable[339900] = bhEff349_0x24beb0; // 0x24bef8 - g_ps2RecompiledFunctionTable[339901] = bhEff349_0x24beb0; // 0x24befc - g_ps2RecompiledFunctionTable[339902] = bhEff349_0x24beb0; // 0x24bf00 - g_ps2RecompiledFunctionTable[339903] = bhEff349_0x24beb0; // 0x24bf04 - g_ps2RecompiledFunctionTable[339904] = bhEff349_0x24beb0; // 0x24bf08 - g_ps2RecompiledFunctionTable[339905] = bhEff349_0x24beb0; // 0x24bf0c - g_ps2RecompiledFunctionTable[339906] = bhEff349_0x24beb0; // 0x24bf10 - g_ps2RecompiledFunctionTable[339907] = bhEff349_0x24beb0; // 0x24bf14 - g_ps2RecompiledFunctionTable[339908] = bhEff349_0x24beb0; // 0x24bf18 - g_ps2RecompiledFunctionTable[339909] = bhEff349_0x24beb0; // 0x24bf1c - g_ps2RecompiledFunctionTable[339910] = bhEff349_0x24beb0; // 0x24bf20 - g_ps2RecompiledFunctionTable[339911] = bhEff349_0x24beb0; // 0x24bf24 - g_ps2RecompiledFunctionTable[339912] = bhEff349_0x24beb0; // 0x24bf28 - g_ps2RecompiledFunctionTable[339913] = bhEff349_0x24beb0; // 0x24bf2c - g_ps2RecompiledFunctionTable[339914] = bhEff349_0x24beb0; // 0x24bf30 - g_ps2RecompiledFunctionTable[339918] = rySetEffBlood2_0x24bf40; // 0x24bf40 - g_ps2RecompiledFunctionTable[339931] = rySetEffBlood2_0x24bf40; // 0x24bf74 - g_ps2RecompiledFunctionTable[339959] = rySetEffBlood2_0x24bf40; // 0x24bfe4 - g_ps2RecompiledFunctionTable[339994] = bhEff30b_0x24c070; // 0x24c070 - g_ps2RecompiledFunctionTable[340028] = bhEff30b_0x24c070; // 0x24c0f8 - g_ps2RecompiledFunctionTable[340031] = bhEff30b_0x24c070; // 0x24c104 - g_ps2RecompiledFunctionTable[340040] = bhEff30b_0x24c070; // 0x24c128 - g_ps2RecompiledFunctionTable[340049] = bhEff30b_0x24c070; // 0x24c14c - g_ps2RecompiledFunctionTable[340052] = bhEff30b_0x24c070; // 0x24c158 - g_ps2RecompiledFunctionTable[340066] = bhEff30b_0x24c070; // 0x24c190 - g_ps2RecompiledFunctionTable[340072] = bhEff30b_0x24c070; // 0x24c1a8 - g_ps2RecompiledFunctionTable[340074] = bhEff30b_0x24c070; // 0x24c1b0 - g_ps2RecompiledFunctionTable[340092] = bhEff30b_0x24c070; // 0x24c1f8 - g_ps2RecompiledFunctionTable[340094] = bhEff30b_0x24c070; // 0x24c200 - g_ps2RecompiledFunctionTable[340101] = bhEff30b_0x24c070; // 0x24c21c - g_ps2RecompiledFunctionTable[340114] = bhEff30b_0x24c070; // 0x24c250 - g_ps2RecompiledFunctionTable[340126] = bhEff30b_0x24c070; // 0x24c280 - g_ps2RecompiledFunctionTable[340142] = bhEff30b_0x24c070; // 0x24c2c0 - g_ps2RecompiledFunctionTable[340144] = bhEff30b_0x24c070; // 0x24c2c8 - g_ps2RecompiledFunctionTable[340160] = bhEff30b_0x24c070; // 0x24c308 - g_ps2RecompiledFunctionTable[340162] = bhEff30b_0x24c070; // 0x24c310 - g_ps2RecompiledFunctionTable[340178] = bhEff30b_0x24c070; // 0x24c350 - g_ps2RecompiledFunctionTable[340182] = bhEff30b_0x24c070; // 0x24c360 - g_ps2RecompiledFunctionTable[340188] = bhEff30b_0x24c070; // 0x24c378 - g_ps2RecompiledFunctionTable[340192] = bhEff30b_0x24c070; // 0x24c388 - g_ps2RecompiledFunctionTable[340200] = bhEff30b_0x24c070; // 0x24c3a8 - g_ps2RecompiledFunctionTable[340204] = bhEff30b_0x24c070; // 0x24c3b8 - g_ps2RecompiledFunctionTable[340206] = bhEff30b_0x24c070; // 0x24c3c0 - g_ps2RecompiledFunctionTable[340221] = bhEff30b_0x24c070; // 0x24c3fc - g_ps2RecompiledFunctionTable[340234] = bhEff30b_0x24c070; // 0x24c430 - g_ps2RecompiledFunctionTable[340328] = bhEff30b_0x24c070; // 0x24c5a8 - g_ps2RecompiledFunctionTable[340350] = bhEff30bDrw_0x24c600; // 0x24c600 - g_ps2RecompiledFunctionTable[340361] = bhEff30bDrw_0x24c600; // 0x24c62c - g_ps2RecompiledFunctionTable[340364] = bhEff30bDrw_0x24c600; // 0x24c638 - g_ps2RecompiledFunctionTable[340366] = bhEff30bDrw_0x24c600; // 0x24c640 - g_ps2RecompiledFunctionTable[340370] = bhEff30bDrw_0x24c600; // 0x24c650 - g_ps2RecompiledFunctionTable[340372] = bhEff30bDrw_0x24c600; // 0x24c658 - g_ps2RecompiledFunctionTable[340374] = bhEff30bDrw_0x24c600; // 0x24c660 - g_ps2RecompiledFunctionTable[340378] = bhEff30bDrw_0x24c600; // 0x24c670 - g_ps2RecompiledFunctionTable[340380] = bhEff30bDrw_0x24c600; // 0x24c678 - g_ps2RecompiledFunctionTable[340387] = bhEff30bDrw_0x24c600; // 0x24c694 - g_ps2RecompiledFunctionTable[340390] = bhEff30bDrw_0x24c600; // 0x24c6a0 - g_ps2RecompiledFunctionTable[340392] = bhEff30bDrw_0x24c600; // 0x24c6a8 - g_ps2RecompiledFunctionTable[340397] = bhEff30bDrw_0x24c600; // 0x24c6bc - g_ps2RecompiledFunctionTable[340411] = bhEff30bDrw_0x24c600; // 0x24c6f4 - g_ps2RecompiledFunctionTable[340416] = bhEff30bDrw_0x24c600; // 0x24c708 - g_ps2RecompiledFunctionTable[340424] = bhEff30bDrw_0x24c600; // 0x24c728 - g_ps2RecompiledFunctionTable[340434] = bhEff30c_0x24c750; // 0x24c750 - g_ps2RecompiledFunctionTable[340460] = bhEff30c_0x24c750; // 0x24c7b8 - g_ps2RecompiledFunctionTable[340465] = bhEff30c_0x24c750; // 0x24c7cc - g_ps2RecompiledFunctionTable[340470] = bhEff30c_0x24c750; // 0x24c7e0 - g_ps2RecompiledFunctionTable[340494] = bhEff30cDrw_0x24c840; // 0x24c840 - g_ps2RecompiledFunctionTable[340503] = bhEff30cDrw_0x24c840; // 0x24c864 - g_ps2RecompiledFunctionTable[340506] = bhEff30cDrw_0x24c840; // 0x24c870 - g_ps2RecompiledFunctionTable[340509] = bhEff30cDrw_0x24c840; // 0x24c87c - g_ps2RecompiledFunctionTable[340511] = bhEff30cDrw_0x24c840; // 0x24c884 - g_ps2RecompiledFunctionTable[340513] = bhEff30cDrw_0x24c840; // 0x24c88c - g_ps2RecompiledFunctionTable[340518] = bhEff_SetPtcl_0x24c8a0; // 0x24c8a0 - g_ps2RecompiledFunctionTable[340529] = bhEff_SetPtcl_0x24c8a0; // 0x24c8cc - g_ps2RecompiledFunctionTable[340536] = bhEff_SetPtcl_0x24c8a0; // 0x24c8e8 - g_ps2RecompiledFunctionTable[340541] = bhEff_SetPtcl_0x24c8a0; // 0x24c8fc - g_ps2RecompiledFunctionTable[340554] = bhEff_SetPtcl1_0x24c930; // 0x24c930 - g_ps2RecompiledFunctionTable[340579] = bhEff_SetPtcl1_0x24c930; // 0x24c994 - g_ps2RecompiledFunctionTable[340584] = bhEff_SetPtcl1_0x24c930; // 0x24c9a8 - g_ps2RecompiledFunctionTable[340610] = bhEff_SetPtcl1_0x24c930; // 0x24ca10 - g_ps2RecompiledFunctionTable[340613] = bhEff_SetPtcl1_0x24c930; // 0x24ca1c - g_ps2RecompiledFunctionTable[340614] = bhEff_SetPtcl1_0x24c930; // 0x24ca20 - g_ps2RecompiledFunctionTable[340616] = bhEff_SetPtcl1_0x24c930; // 0x24ca28 - g_ps2RecompiledFunctionTable[340632] = bhEff_SetPtcl1_0x24c930; // 0x24ca68 - g_ps2RecompiledFunctionTable[340647] = bhEff_SetPtcl1_0x24c930; // 0x24caa4 - g_ps2RecompiledFunctionTable[340682] = bhEff_SetPtcl1_0x24c930; // 0x24cb30 - g_ps2RecompiledFunctionTable[340698] = bhEff_SetPtcl2_0x24cb70; // 0x24cb70 - g_ps2RecompiledFunctionTable[340725] = bhEff_SetPtcl2_0x24cb70; // 0x24cbdc - g_ps2RecompiledFunctionTable[340730] = bhEff_SetPtcl2_0x24cb70; // 0x24cbf0 - g_ps2RecompiledFunctionTable[340754] = bhEff_SetPtcl2_0x24cb70; // 0x24cc50 - g_ps2RecompiledFunctionTable[340756] = bhEff_SetPtcl2_0x24cb70; // 0x24cc58 - g_ps2RecompiledFunctionTable[340759] = bhEff_SetPtcl2_0x24cb70; // 0x24cc64 - g_ps2RecompiledFunctionTable[340760] = bhEff_SetPtcl2_0x24cb70; // 0x24cc68 - g_ps2RecompiledFunctionTable[340770] = bhEff_SetPtcl2_0x24cb70; // 0x24cc90 - g_ps2RecompiledFunctionTable[340778] = bhEff_SetPtcl2_0x24cb70; // 0x24ccb0 - g_ps2RecompiledFunctionTable[340785] = bhEff_SetPtcl2_0x24cb70; // 0x24cccc - g_ps2RecompiledFunctionTable[340801] = bhEff_SetPtcl2_0x24cb70; // 0x24cd0c - g_ps2RecompiledFunctionTable[340804] = bhEff_SetPtcl2_0x24cb70; // 0x24cd18 - g_ps2RecompiledFunctionTable[340809] = bhEff_SetPtcl2_0x24cb70; // 0x24cd2c - g_ps2RecompiledFunctionTable[340813] = bhEff_SetPtcl2_0x24cb70; // 0x24cd3c - g_ps2RecompiledFunctionTable[340816] = bhEff_SetPtcl2_0x24cb70; // 0x24cd48 - g_ps2RecompiledFunctionTable[340823] = bhEff_SetPtcl2_0x24cb70; // 0x24cd64 - g_ps2RecompiledFunctionTable[340842] = bhEff_SetPtcl2V_0x24cdb0; // 0x24cdb0 - g_ps2RecompiledFunctionTable[340870] = bhEff_SetPtcl2V_0x24cdb0; // 0x24ce20 - g_ps2RecompiledFunctionTable[340875] = bhEff_SetPtcl2V_0x24cdb0; // 0x24ce34 - g_ps2RecompiledFunctionTable[340898] = bhEff_SetPtcl2V_0x24cdb0; // 0x24ce90 - g_ps2RecompiledFunctionTable[340908] = bhEff_SetPtcl2V_0x24cdb0; // 0x24ceb8 - g_ps2RecompiledFunctionTable[340915] = bhEff_SetPtcl2V_0x24cdb0; // 0x24ced4 - g_ps2RecompiledFunctionTable[340922] = bhEff_SetPtcl2V_0x24cdb0; // 0x24cef0 - g_ps2RecompiledFunctionTable[340938] = bhEff_SetPtcl2V_0x24cdb0; // 0x24cf30 - g_ps2RecompiledFunctionTable[340940] = bhEff_SetPtcl2V_0x24cdb0; // 0x24cf38 - g_ps2RecompiledFunctionTable[340945] = bhEff_SetPtcl2V_0x24cdb0; // 0x24cf4c - g_ps2RecompiledFunctionTable[340949] = bhEff_SetPtcl2V_0x24cdb0; // 0x24cf5c - g_ps2RecompiledFunctionTable[340978] = bhEff_SetBlood5_0x24cfd0; // 0x24cfd0 - g_ps2RecompiledFunctionTable[341051] = bhEff_SetBlood5_0x24cfd0; // 0x24d0f4 - g_ps2RecompiledFunctionTable[341102] = bhEff_Sub350_0x24d1c0; // 0x24d1c0 - g_ps2RecompiledFunctionTable[341151] = bhEff_Sub350_0x24d1c0; // 0x24d284 - g_ps2RecompiledFunctionTable[341157] = bhEff_Sub350_0x24d1c0; // 0x24d29c - g_ps2RecompiledFunctionTable[341163] = bhEff_Sub350_0x24d1c0; // 0x24d2b4 - g_ps2RecompiledFunctionTable[341168] = bhEff_Sub350_0x24d1c0; // 0x24d2c8 - g_ps2RecompiledFunctionTable[341225] = bhEff_Sub350_0x24d1c0; // 0x24d3ac - g_ps2RecompiledFunctionTable[341270] = bhEff_Sub350_0x24d1c0; // 0x24d460 - g_ps2RecompiledFunctionTable[341318] = bhEff_Sub350_0x24d1c0; // 0x24d520 - g_ps2RecompiledFunctionTable[341369] = bhEff_Sub350_0x24d1c0; // 0x24d5ec - g_ps2RecompiledFunctionTable[341391] = bhEff_Sub350_0x24d1c0; // 0x24d644 - g_ps2RecompiledFunctionTable[341393] = bhEff_Sub350_0x24d1c0; // 0x24d64c - g_ps2RecompiledFunctionTable[341406] = bhEff_Sub350_0x24d1c0; // 0x24d680 - g_ps2RecompiledFunctionTable[341426] = bhEff_Sub350_0x24d1c0; // 0x24d6d0 - g_ps2RecompiledFunctionTable[341444] = bhEff_Sub350_0x24d1c0; // 0x24d718 - g_ps2RecompiledFunctionTable[341465] = bhEff_Sub350_0x24d1c0; // 0x24d76c - g_ps2RecompiledFunctionTable[341515] = bhEff_Sub350_0x24d1c0; // 0x24d834 - g_ps2RecompiledFunctionTable[341544] = bhEff_Sub350_0x24d1c0; // 0x24d8a8 - g_ps2RecompiledFunctionTable[341565] = bhEff_Sub350_0x24d1c0; // 0x24d8fc - g_ps2RecompiledFunctionTable[341589] = bhEff_Sub350_0x24d1c0; // 0x24d95c - g_ps2RecompiledFunctionTable[341630] = bhEff_Sub350_0x24d1c0; // 0x24da00 - g_ps2RecompiledFunctionTable[341642] = bhEff_Sub351_0x24da30; // 0x24da30 - g_ps2RecompiledFunctionTable[341736] = bhEff_Sub351_0x24da30; // 0x24dba8 - g_ps2RecompiledFunctionTable[341742] = bhEff_Sub352_0x24dbc0; // 0x24dbc0 - g_ps2RecompiledFunctionTable[341875] = bhEff_Sub352_0x24dbc0; // 0x24ddd4 - g_ps2RecompiledFunctionTable[341954] = bhEff_Sub352_0x24dbc0; // 0x24df10 - g_ps2RecompiledFunctionTable[341985] = bhEff_Sub352_0x24dbc0; // 0x24df8c - g_ps2RecompiledFunctionTable[341989] = bhEff_Sub352_0x24dbc0; // 0x24df9c - g_ps2RecompiledFunctionTable[342011] = bhEff_Sub352_0x24dbc0; // 0x24dff4 - g_ps2RecompiledFunctionTable[342015] = bhEff_Sub352_0x24dbc0; // 0x24e004 - g_ps2RecompiledFunctionTable[342034] = bhEff_Sub353_0x24e050; // 0x24e050 - g_ps2RecompiledFunctionTable[342274] = bhEff_Sub354_0x24e410; // 0x24e410 - g_ps2RecompiledFunctionTable[342384] = bhEff_Sub354_0x24e410; // 0x24e5c8 - g_ps2RecompiledFunctionTable[342418] = bhEff_Sub354_0x24e410; // 0x24e650 - g_ps2RecompiledFunctionTable[342420] = bhEff_Sub354_0x24e410; // 0x24e658 - g_ps2RecompiledFunctionTable[342432] = bhEff_Sub354_0x24e410; // 0x24e688 - g_ps2RecompiledFunctionTable[342436] = bhEff_Sub354_0x24e410; // 0x24e698 - g_ps2RecompiledFunctionTable[342439] = bhEff_Sub354_0x24e410; // 0x24e6a4 - g_ps2RecompiledFunctionTable[342442] = bhEff_Sub354_0x24e410; // 0x24e6b0 - g_ps2RecompiledFunctionTable[342444] = bhEff_Sub354_0x24e410; // 0x24e6b8 - g_ps2RecompiledFunctionTable[342446] = bhEff_Sub354_0x24e410; // 0x24e6c0 - g_ps2RecompiledFunctionTable[342458] = bhEff_Sub354_0x24e410; // 0x24e6f0 - g_ps2RecompiledFunctionTable[342462] = bhEff_Sub354_0x24e410; // 0x24e700 - g_ps2RecompiledFunctionTable[342465] = bhEff_Sub354_0x24e410; // 0x24e70c - g_ps2RecompiledFunctionTable[342468] = bhEff_Sub354_0x24e410; // 0x24e718 - g_ps2RecompiledFunctionTable[342470] = bhEff_Sub354_0x24e410; // 0x24e720 - g_ps2RecompiledFunctionTable[342477] = bhEff_Sub354_0x24e410; // 0x24e73c - g_ps2RecompiledFunctionTable[342499] = bhEff_Sub354_0x24e410; // 0x24e794 - g_ps2RecompiledFunctionTable[342503] = bhEff_Sub354_0x24e410; // 0x24e7a4 - g_ps2RecompiledFunctionTable[342518] = bhEff_Sub355_0x24e7e0; // 0x24e7e0 - g_ps2RecompiledFunctionTable[342630] = bhEff_Sub356_0x24e9a0; // 0x24e9a0 - g_ps2RecompiledFunctionTable[342631] = bhEff_Sub356_0x24e9a0; // 0x24e9a4 - g_ps2RecompiledFunctionTable[342632] = bhEff_Sub356_0x24e9a0; // 0x24e9a8 - g_ps2RecompiledFunctionTable[342633] = bhEff_Sub356_0x24e9a0; // 0x24e9ac - g_ps2RecompiledFunctionTable[342634] = bhEff_Sub356_0x24e9a0; // 0x24e9b0 - g_ps2RecompiledFunctionTable[342635] = bhEff_Sub356_0x24e9a0; // 0x24e9b4 - g_ps2RecompiledFunctionTable[342636] = bhEff_Sub356_0x24e9a0; // 0x24e9b8 - g_ps2RecompiledFunctionTable[342637] = bhEff_Sub356_0x24e9a0; // 0x24e9bc - g_ps2RecompiledFunctionTable[342638] = bhEff_Sub356_0x24e9a0; // 0x24e9c0 - g_ps2RecompiledFunctionTable[342639] = bhEff_Sub356_0x24e9a0; // 0x24e9c4 - g_ps2RecompiledFunctionTable[342640] = bhEff_Sub356_0x24e9a0; // 0x24e9c8 - g_ps2RecompiledFunctionTable[342641] = bhEff_Sub356_0x24e9a0; // 0x24e9cc - g_ps2RecompiledFunctionTable[342642] = bhEff_Sub356_0x24e9a0; // 0x24e9d0 - g_ps2RecompiledFunctionTable[342643] = bhEff_Sub356_0x24e9a0; // 0x24e9d4 - g_ps2RecompiledFunctionTable[342644] = bhEff_Sub356_0x24e9a0; // 0x24e9d8 - g_ps2RecompiledFunctionTable[342645] = bhEff_Sub356_0x24e9a0; // 0x24e9dc - g_ps2RecompiledFunctionTable[342646] = bhEff_Sub356_0x24e9a0; // 0x24e9e0 - g_ps2RecompiledFunctionTable[342647] = bhEff_Sub356_0x24e9a0; // 0x24e9e4 - g_ps2RecompiledFunctionTable[342648] = bhEff_Sub356_0x24e9a0; // 0x24e9e8 - g_ps2RecompiledFunctionTable[342649] = bhEff_Sub356_0x24e9a0; // 0x24e9ec - g_ps2RecompiledFunctionTable[342650] = bhEff_Sub356_0x24e9a0; // 0x24e9f0 - g_ps2RecompiledFunctionTable[342651] = bhEff_Sub356_0x24e9a0; // 0x24e9f4 - g_ps2RecompiledFunctionTable[342652] = bhEff_Sub356_0x24e9a0; // 0x24e9f8 - g_ps2RecompiledFunctionTable[342653] = bhEff_Sub356_0x24e9a0; // 0x24e9fc - g_ps2RecompiledFunctionTable[342654] = bhEff_Sub356_0x24e9a0; // 0x24ea00 - g_ps2RecompiledFunctionTable[342655] = bhEff_Sub356_0x24e9a0; // 0x24ea04 - g_ps2RecompiledFunctionTable[342656] = bhEff_Sub356_0x24e9a0; // 0x24ea08 - g_ps2RecompiledFunctionTable[342657] = bhEff_Sub356_0x24e9a0; // 0x24ea0c - g_ps2RecompiledFunctionTable[342658] = bhEff_Sub356_0x24e9a0; // 0x24ea10 - g_ps2RecompiledFunctionTable[342659] = bhEff_Sub356_0x24e9a0; // 0x24ea14 - g_ps2RecompiledFunctionTable[342660] = bhEff_Sub356_0x24e9a0; // 0x24ea18 - g_ps2RecompiledFunctionTable[342661] = bhEff_Sub356_0x24e9a0; // 0x24ea1c - g_ps2RecompiledFunctionTable[342662] = bhEff_Sub356_0x24e9a0; // 0x24ea20 - g_ps2RecompiledFunctionTable[342663] = bhEff_Sub356_0x24e9a0; // 0x24ea24 - g_ps2RecompiledFunctionTable[342664] = bhEff_Sub356_0x24e9a0; // 0x24ea28 - g_ps2RecompiledFunctionTable[342665] = bhEff_Sub356_0x24e9a0; // 0x24ea2c - g_ps2RecompiledFunctionTable[342666] = bhEff_Sub356_0x24e9a0; // 0x24ea30 - g_ps2RecompiledFunctionTable[342667] = bhEff_Sub356_0x24e9a0; // 0x24ea34 - g_ps2RecompiledFunctionTable[342668] = bhEff_Sub356_0x24e9a0; // 0x24ea38 - g_ps2RecompiledFunctionTable[342669] = bhEff_Sub356_0x24e9a0; // 0x24ea3c - g_ps2RecompiledFunctionTable[342670] = bhEff_Sub356_0x24e9a0; // 0x24ea40 - g_ps2RecompiledFunctionTable[342671] = bhEff_Sub356_0x24e9a0; // 0x24ea44 - g_ps2RecompiledFunctionTable[342672] = bhEff_Sub356_0x24e9a0; // 0x24ea48 - g_ps2RecompiledFunctionTable[342673] = bhEff_Sub356_0x24e9a0; // 0x24ea4c - g_ps2RecompiledFunctionTable[342674] = bhEff_Sub356_0x24e9a0; // 0x24ea50 - g_ps2RecompiledFunctionTable[342675] = bhEff_Sub356_0x24e9a0; // 0x24ea54 - g_ps2RecompiledFunctionTable[342676] = bhEff_Sub356_0x24e9a0; // 0x24ea58 - g_ps2RecompiledFunctionTable[342677] = bhEff_Sub356_0x24e9a0; // 0x24ea5c - g_ps2RecompiledFunctionTable[342678] = bhEff_Sub356_0x24e9a0; // 0x24ea60 - g_ps2RecompiledFunctionTable[342679] = bhEff_Sub356_0x24e9a0; // 0x24ea64 - g_ps2RecompiledFunctionTable[342680] = bhEff_Sub356_0x24e9a0; // 0x24ea68 - g_ps2RecompiledFunctionTable[342681] = bhEff_Sub356_0x24e9a0; // 0x24ea6c - g_ps2RecompiledFunctionTable[342682] = bhEff_Sub356_0x24e9a0; // 0x24ea70 - g_ps2RecompiledFunctionTable[342683] = bhEff_Sub356_0x24e9a0; // 0x24ea74 - g_ps2RecompiledFunctionTable[342684] = bhEff_Sub356_0x24e9a0; // 0x24ea78 - g_ps2RecompiledFunctionTable[342685] = bhEff_Sub356_0x24e9a0; // 0x24ea7c - g_ps2RecompiledFunctionTable[342686] = bhEff_Sub356_0x24e9a0; // 0x24ea80 - g_ps2RecompiledFunctionTable[342687] = bhEff_Sub356_0x24e9a0; // 0x24ea84 - g_ps2RecompiledFunctionTable[342688] = bhEff_Sub356_0x24e9a0; // 0x24ea88 - g_ps2RecompiledFunctionTable[342689] = bhEff_Sub356_0x24e9a0; // 0x24ea8c - g_ps2RecompiledFunctionTable[342690] = bhEff_Sub356_0x24e9a0; // 0x24ea90 - g_ps2RecompiledFunctionTable[342691] = bhEff_Sub356_0x24e9a0; // 0x24ea94 - g_ps2RecompiledFunctionTable[342692] = bhEff_Sub356_0x24e9a0; // 0x24ea98 - g_ps2RecompiledFunctionTable[342694] = bhEff_Sub357_0x24eaa0; // 0x24eaa0 - g_ps2RecompiledFunctionTable[342698] = bhEff_Sub360_0x24eab0; // 0x24eab0 - g_ps2RecompiledFunctionTable[342770] = bhEff_Sub360_0x24eab0; // 0x24ebd0 - g_ps2RecompiledFunctionTable[342774] = bhEff_Sub361_0x24ebe0; // 0x24ebe0 - g_ps2RecompiledFunctionTable[342854] = bhEff_Sub361_0x24ebe0; // 0x24ed20 - g_ps2RecompiledFunctionTable[342858] = bhEff_Sub362_0x24ed30; // 0x24ed30 - g_ps2RecompiledFunctionTable[342913] = bhEff_Sub362_0x24ed30; // 0x24ee0c - g_ps2RecompiledFunctionTable[342926] = bhEff_Sub362_0x24ed30; // 0x24ee40 - g_ps2RecompiledFunctionTable[343011] = bhEff_Sub362_0x24ed30; // 0x24ef94 - g_ps2RecompiledFunctionTable[343024] = bhEff_Sub362_0x24ed30; // 0x24efc8 - g_ps2RecompiledFunctionTable[343026] = bhEff_Sub362_0x24ed30; // 0x24efd0 - g_ps2RecompiledFunctionTable[343071] = bhEff_Sub362_0x24ed30; // 0x24f084 - g_ps2RecompiledFunctionTable[343081] = bhEff_Sub362_0x24ed30; // 0x24f0ac - g_ps2RecompiledFunctionTable[343130] = bhEff_Sub362_0x24ed30; // 0x24f170 - g_ps2RecompiledFunctionTable[343140] = bhEff_Sub362_0x24ed30; // 0x24f198 - g_ps2RecompiledFunctionTable[343155] = bhEff_Sub362_0x24ed30; // 0x24f1d4 - g_ps2RecompiledFunctionTable[343162] = bhEff_Sub363_0x24f1f0; // 0x24f1f0 - g_ps2RecompiledFunctionTable[343214] = bhEff_Sub363_0x24f1f0; // 0x24f2c0 - g_ps2RecompiledFunctionTable[343227] = bhEff_Sub363_0x24f1f0; // 0x24f2f4 - g_ps2RecompiledFunctionTable[343237] = bhEff_Sub363_0x24f1f0; // 0x24f31c - g_ps2RecompiledFunctionTable[343346] = bhEff_Sub363_0x24f1f0; // 0x24f4d0 - g_ps2RecompiledFunctionTable[343350] = bhEff_Sub364_0x24f4e0; // 0x24f4e0 - g_ps2RecompiledFunctionTable[343406] = bhEff_Sub365_0x24f5c0; // 0x24f5c0 - g_ps2RecompiledFunctionTable[343450] = bhEff_Sub365_0x24f5c0; // 0x24f670 - g_ps2RecompiledFunctionTable[343522] = bhEff_Sub366_0x24f790; // 0x24f790 - g_ps2RecompiledFunctionTable[343594] = bhEff_Sub366_0x24f790; // 0x24f8b0 - g_ps2RecompiledFunctionTable[343702] = bhEff_Sub367_0x24fa60; // 0x24fa60 - g_ps2RecompiledFunctionTable[343748] = bhEff_Sub367_0x24fa60; // 0x24fb18 - g_ps2RecompiledFunctionTable[343754] = bhEff_Sub367_0x24fa60; // 0x24fb30 - g_ps2RecompiledFunctionTable[343761] = bhEff_Sub367_0x24fa60; // 0x24fb4c - g_ps2RecompiledFunctionTable[343826] = bhEff_Sub368_0x24fc50; // 0x24fc50 - g_ps2RecompiledFunctionTable[343916] = bhEff_Sub368_0x24fc50; // 0x24fdb8 - g_ps2RecompiledFunctionTable[343922] = bhEff_Sub369_0x24fdd0; // 0x24fdd0 - g_ps2RecompiledFunctionTable[343983] = bhEff_Sub369_0x24fdd0; // 0x24fec4 - g_ps2RecompiledFunctionTable[343991] = bhEff_Sub369_0x24fdd0; // 0x24fee4 - g_ps2RecompiledFunctionTable[344015] = bhEff_Sub369_0x24fdd0; // 0x24ff44 - g_ps2RecompiledFunctionTable[344022] = bhEff_Sub370_0x24ff60; // 0x24ff60 - g_ps2RecompiledFunctionTable[344125] = bhEff_Sub370_0x24ff60; // 0x2500fc - g_ps2RecompiledFunctionTable[344137] = bhEff_Sub370_0x24ff60; // 0x25012c - g_ps2RecompiledFunctionTable[344162] = bhEff_Sub370_0x24ff60; // 0x250190 - g_ps2RecompiledFunctionTable[344171] = bhEff_Sub370_0x24ff60; // 0x2501b4 - g_ps2RecompiledFunctionTable[344197] = bhEff_Sub370_0x24ff60; // 0x25021c - g_ps2RecompiledFunctionTable[344226] = bhEff_Sub370_0x24ff60; // 0x250290 - g_ps2RecompiledFunctionTable[344280] = bhEff_Sub370_0x24ff60; // 0x250368 - g_ps2RecompiledFunctionTable[344284] = bhEff_Sub370_0x24ff60; // 0x250378 - g_ps2RecompiledFunctionTable[344317] = bhEff_Sub370_0x24ff60; // 0x2503fc - g_ps2RecompiledFunctionTable[344362] = bhEff_Sub371_0x2504b0; // 0x2504b0 - g_ps2RecompiledFunctionTable[344514] = bhEff_Sub371_0x2504b0; // 0x250710 - g_ps2RecompiledFunctionTable[344518] = bhEff_Sub372_0x250720; // 0x250720 - g_ps2RecompiledFunctionTable[344621] = bhEff_Sub372_0x250720; // 0x2508bc - g_ps2RecompiledFunctionTable[344626] = bhEff_Sub373_0x2508d0; // 0x2508d0 - g_ps2RecompiledFunctionTable[344761] = bhEff_Sub373_0x2508d0; // 0x250aec - g_ps2RecompiledFunctionTable[344766] = bhEff_Sub398_0x250b00; // 0x250b00 - g_ps2RecompiledFunctionTable[344858] = bhEff_Sub398_0x250b00; // 0x250c70 - g_ps2RecompiledFunctionTable[344877] = bhEff_Sub398_0x250b00; // 0x250cbc - g_ps2RecompiledFunctionTable[344900] = bhEff_Sub398_0x250b00; // 0x250d18 - g_ps2RecompiledFunctionTable[344947] = bhEff_Sub398_0x250b00; // 0x250dd4 - g_ps2RecompiledFunctionTable[345034] = bhEff_Sub398_0x250b00; // 0x250f30 - g_ps2RecompiledFunctionTable[345039] = bhEff_Sub398_0x250b00; // 0x250f44 - g_ps2RecompiledFunctionTable[345044] = bhEff_Sub398_0x250b00; // 0x250f58 - g_ps2RecompiledFunctionTable[345067] = bhEff_Sub398_0x250b00; // 0x250fb4 - g_ps2RecompiledFunctionTable[345142] = bhEff_AllocOwork_0x2510e0; // 0x2510e0 - g_ps2RecompiledFunctionTable[345148] = bhEff_AllocOwork_0x2510e0; // 0x2510f8 - g_ps2RecompiledFunctionTable[345156] = bhEff_AllocOwork_0x2510e0; // 0x251118 - g_ps2RecompiledFunctionTable[345170] = bhEff_PtclSpriteDraw_0x251150; // 0x251150 - g_ps2RecompiledFunctionTable[345180] = bhEff_PtclSpriteDraw_0x251150; // 0x251178 - g_ps2RecompiledFunctionTable[345183] = bhEff_PtclSpriteDraw_0x251150; // 0x251184 - g_ps2RecompiledFunctionTable[345186] = bhEff_PtclSpriteDraw_0x251150; // 0x251190 - g_ps2RecompiledFunctionTable[345188] = bhEff_PtclSpriteDraw_0x251150; // 0x251198 - g_ps2RecompiledFunctionTable[345192] = bhEff_PtclSpriteDraw_0x251150; // 0x2511a8 - g_ps2RecompiledFunctionTable[345194] = bhEff_PtclSpriteDraw_0x251150; // 0x2511b0 - g_ps2RecompiledFunctionTable[345200] = bhEff_PtclSpriteDraw_0x251150; // 0x2511c8 - g_ps2RecompiledFunctionTable[345202] = bhEff_PtclSpriteDraw_0x251150; // 0x2511d0 - g_ps2RecompiledFunctionTable[345207] = bhEff_PtclSpriteDraw_0x251150; // 0x2511e4 - g_ps2RecompiledFunctionTable[345216] = bhEff_PtclSpriteDraw_0x251150; // 0x251208 - g_ps2RecompiledFunctionTable[345218] = bhEff_PtclSpriteDraw_0x251150; // 0x251210 - g_ps2RecompiledFunctionTable[345226] = bhEff_LineDraw_0x251230; // 0x251230 - g_ps2RecompiledFunctionTable[345237] = bhEff_LineDraw_0x251230; // 0x25125c - g_ps2RecompiledFunctionTable[345240] = bhEff_LineDraw_0x251230; // 0x251268 - g_ps2RecompiledFunctionTable[345243] = bhEff_LineDraw_0x251230; // 0x251274 - g_ps2RecompiledFunctionTable[345245] = bhEff_LineDraw_0x251230; // 0x25127c - g_ps2RecompiledFunctionTable[345249] = bhEff_LineDraw_0x251230; // 0x25128c - g_ps2RecompiledFunctionTable[345259] = bhEff_LineDraw_0x251230; // 0x2512b4 - g_ps2RecompiledFunctionTable[345290] = bhEff_LineDraw_0x251230; // 0x251330 - g_ps2RecompiledFunctionTable[345300] = bhEff_LineDraw_0x251230; // 0x251358 - g_ps2RecompiledFunctionTable[345302] = bhEff_LineDraw_0x251230; // 0x251360 - g_ps2RecompiledFunctionTable[345310] = bhEff_SetSprite_0x251380; // 0x251380 - g_ps2RecompiledFunctionTable[345398] = bhEff_SetSpriteAnime_0x2514e0; // 0x2514e0 - g_ps2RecompiledFunctionTable[345443] = bhEff_SetSpriteAnime_0x2514e0; // 0x251594 - g_ps2RecompiledFunctionTable[345446] = bhEff_3DSpriteDraw_0x2515a0; // 0x2515a0 - g_ps2RecompiledFunctionTable[345452] = bhEff_3DSpriteDraw_0x2515a0; // 0x2515b8 - g_ps2RecompiledFunctionTable[345475] = bhEff_3DSpriteDraw_0x2515a0; // 0x251614 - g_ps2RecompiledFunctionTable[345483] = bhEff_3DSpriteDraw_0x2515a0; // 0x251634 - g_ps2RecompiledFunctionTable[345488] = bhEff_3DSpriteDraw_0x2515a0; // 0x251648 - g_ps2RecompiledFunctionTable[345498] = bhEff_3DSpriteDraw_0x2515a0; // 0x251670 - g_ps2RecompiledFunctionTable[345510] = bhEff_3DSpriteDraw_0x2515a0; // 0x2516a0 - g_ps2RecompiledFunctionTable[345514] = bhEff_3DSpriteDraw_0x2515a0; // 0x2516b0 - g_ps2RecompiledFunctionTable[345519] = bhEff_3DSpriteDraw_0x2515a0; // 0x2516c4 - g_ps2RecompiledFunctionTable[345527] = bhEff_3DSpriteDraw_0x2515a0; // 0x2516e4 - g_ps2RecompiledFunctionTable[345529] = bhEff_3DSpriteDraw_0x2515a0; // 0x2516ec - g_ps2RecompiledFunctionTable[345540] = bhEff_3DSpriteDraw_0x2515a0; // 0x251718 - g_ps2RecompiledFunctionTable[345542] = bhEff_3DSpriteDraw_0x2515a0; // 0x251720 - g_ps2RecompiledFunctionTable[345545] = bhEff_3DSpriteDraw_0x2515a0; // 0x25172c - g_ps2RecompiledFunctionTable[345547] = bhEff_3DSpriteDraw_0x2515a0; // 0x251734 - g_ps2RecompiledFunctionTable[345560] = bhEff_3DSpriteDraw_0x2515a0; // 0x251768 - g_ps2RecompiledFunctionTable[345565] = bhEff_3DSpriteDraw_0x2515a0; // 0x25177c - g_ps2RecompiledFunctionTable[345570] = bhEff_3DSpriteDraw_0x2515a0; // 0x251790 - g_ps2RecompiledFunctionTable[345572] = bhEff_3DSpriteDraw_0x2515a0; // 0x251798 - g_ps2RecompiledFunctionTable[345575] = bhEff_3DSpriteDraw_0x2515a0; // 0x2517a4 - g_ps2RecompiledFunctionTable[345582] = bhEff_3DSpriteDraw_0x2515a0; // 0x2517c0 - g_ps2RecompiledFunctionTable[345585] = bhEff_3DSpriteDraw_0x2515a0; // 0x2517cc - g_ps2RecompiledFunctionTable[345588] = bhEff_3DSpriteDraw_0x2515a0; // 0x2517d8 - g_ps2RecompiledFunctionTable[345591] = bhEff_3DSpriteDraw_0x2515a0; // 0x2517e4 - g_ps2RecompiledFunctionTable[345594] = bhEff_3DSpriteDraw_0x2515a0; // 0x2517f0 - g_ps2RecompiledFunctionTable[345596] = bhEff_3DSpriteDraw_0x2515a0; // 0x2517f8 - g_ps2RecompiledFunctionTable[345600] = bhEff_3DSpriteDraw_0x2515a0; // 0x251808 - g_ps2RecompiledFunctionTable[345602] = bhEff_3DSpriteDraw_0x2515a0; // 0x251810 - g_ps2RecompiledFunctionTable[345605] = bhEff_3DSpriteDraw_0x2515a0; // 0x25181c - g_ps2RecompiledFunctionTable[345608] = bhEff_3DSpriteDraw_0x2515a0; // 0x251828 - g_ps2RecompiledFunctionTable[345610] = bhEff_3DSpriteDraw_0x2515a0; // 0x251830 - g_ps2RecompiledFunctionTable[345618] = bhEff_ModelDraw_0x251850; // 0x251850 - g_ps2RecompiledFunctionTable[345629] = bhEff_ModelDraw_0x251850; // 0x25187c - g_ps2RecompiledFunctionTable[345636] = bhEff_ModelDraw_0x251850; // 0x251898 - g_ps2RecompiledFunctionTable[345645] = bhEff_ModelDraw_0x251850; // 0x2518bc - g_ps2RecompiledFunctionTable[345647] = bhEff_ModelDraw_0x251850; // 0x2518c4 - g_ps2RecompiledFunctionTable[345668] = bhEff_ModelDraw_0x251850; // 0x251918 - g_ps2RecompiledFunctionTable[345676] = bhEff_ModelDraw_0x251850; // 0x251938 - g_ps2RecompiledFunctionTable[345681] = bhEff_ModelDraw_0x251850; // 0x25194c - g_ps2RecompiledFunctionTable[345705] = bhEff_ModelDraw_0x251850; // 0x2519ac - g_ps2RecompiledFunctionTable[345707] = bhEff_ModelDraw_0x251850; // 0x2519b4 - g_ps2RecompiledFunctionTable[345711] = bhEff_ModelDraw_0x251850; // 0x2519c4 - g_ps2RecompiledFunctionTable[345713] = bhEff_ModelDraw_0x251850; // 0x2519cc - g_ps2RecompiledFunctionTable[345715] = bhEff_ModelDraw_0x251850; // 0x2519d4 - g_ps2RecompiledFunctionTable[345726] = bhEff_ModelDraw_0x251850; // 0x251a00 - g_ps2RecompiledFunctionTable[345728] = bhEff_ModelDraw_0x251850; // 0x251a08 - g_ps2RecompiledFunctionTable[345731] = bhEff_ModelDraw_0x251850; // 0x251a14 - g_ps2RecompiledFunctionTable[345733] = bhEff_ModelDraw_0x251850; // 0x251a1c - g_ps2RecompiledFunctionTable[345746] = bhEff_ModelDraw_0x251850; // 0x251a50 - g_ps2RecompiledFunctionTable[345751] = bhEff_ModelDraw_0x251850; // 0x251a64 - g_ps2RecompiledFunctionTable[345756] = bhEff_ModelDraw_0x251850; // 0x251a78 - g_ps2RecompiledFunctionTable[345758] = bhEff_ModelDraw_0x251850; // 0x251a80 - g_ps2RecompiledFunctionTable[345761] = bhEff_ModelDraw_0x251850; // 0x251a8c - g_ps2RecompiledFunctionTable[345763] = bhEff_ModelDraw_0x251850; // 0x251a94 - g_ps2RecompiledFunctionTable[345777] = bhEff_ModelDraw_0x251850; // 0x251acc - g_ps2RecompiledFunctionTable[345787] = bhEff_ModelDraw_0x251850; // 0x251af4 - g_ps2RecompiledFunctionTable[345798] = bhEff_ModelDraw_0x251850; // 0x251b20 - g_ps2RecompiledFunctionTable[345806] = bhEff200_0x251b40; // 0x251b40 - g_ps2RecompiledFunctionTable[345850] = bhEff200_0x251b40; // 0x251bf0 - g_ps2RecompiledFunctionTable[345863] = bhEff200_0x251b40; // 0x251c24 - g_ps2RecompiledFunctionTable[345946] = bhEff201_0x251d70; // 0x251d70 - g_ps2RecompiledFunctionTable[345990] = bhEff201_0x251d70; // 0x251e20 - g_ps2RecompiledFunctionTable[346003] = bhEff201_0x251d70; // 0x251e54 - g_ps2RecompiledFunctionTable[346086] = bhEff202_0x251fa0; // 0x251fa0 - g_ps2RecompiledFunctionTable[346144] = bhEff202_0x251fa0; // 0x252088 - g_ps2RecompiledFunctionTable[346149] = bhEff202_0x251fa0; // 0x25209c - g_ps2RecompiledFunctionTable[346188] = bhEff202_0x251fa0; // 0x252138 - g_ps2RecompiledFunctionTable[346201] = bhEff202_0x251fa0; // 0x25216c - g_ps2RecompiledFunctionTable[346205] = bhEff202_0x251fa0; // 0x25217c - g_ps2RecompiledFunctionTable[346220] = bhEff202_0x251fa0; // 0x2521b8 - g_ps2RecompiledFunctionTable[346242] = bhEff202_0x251fa0; // 0x252210 - g_ps2RecompiledFunctionTable[346255] = bhEff202_0x251fa0; // 0x252244 - g_ps2RecompiledFunctionTable[346265] = bhEff202_0x251fa0; // 0x25226c - g_ps2RecompiledFunctionTable[346278] = bhEff202_0x251fa0; // 0x2522a0 - g_ps2RecompiledFunctionTable[346306] = bhEff202_0x251fa0; // 0x252310 - g_ps2RecompiledFunctionTable[346320] = bhEff202_0x251fa0; // 0x252348 - g_ps2RecompiledFunctionTable[346323] = bhEff202_0x251fa0; // 0x252354 - g_ps2RecompiledFunctionTable[346337] = bhEff202_0x251fa0; // 0x25238c - g_ps2RecompiledFunctionTable[346374] = bhEff202_0x251fa0; // 0x252420 - g_ps2RecompiledFunctionTable[346395] = bhEff202_0x251fa0; // 0x252474 - g_ps2RecompiledFunctionTable[346397] = bhEff202_0x251fa0; // 0x25247c - g_ps2RecompiledFunctionTable[346400] = bhEff202_0x251fa0; // 0x252488 - g_ps2RecompiledFunctionTable[346403] = bhEff202_0x251fa0; // 0x252494 - g_ps2RecompiledFunctionTable[346405] = bhEff202_0x251fa0; // 0x25249c - g_ps2RecompiledFunctionTable[346419] = bhEff202_0x251fa0; // 0x2524d4 - g_ps2RecompiledFunctionTable[346422] = bhEff202_0x251fa0; // 0x2524e0 - g_ps2RecompiledFunctionTable[346426] = bhEff202_0x251fa0; // 0x2524f0 - g_ps2RecompiledFunctionTable[346428] = bhEff202_0x251fa0; // 0x2524f8 - g_ps2RecompiledFunctionTable[346452] = bhEff202_0x251fa0; // 0x252558 - g_ps2RecompiledFunctionTable[346474] = bhEff203_0x2525b0; // 0x2525b0 - g_ps2RecompiledFunctionTable[346525] = bhEff203_0x2525b0; // 0x25267c - g_ps2RecompiledFunctionTable[346592] = bhEff203_0x2525b0; // 0x252788 - g_ps2RecompiledFunctionTable[346594] = bhEff203_0x2525b0; // 0x252790 - g_ps2RecompiledFunctionTable[346597] = bhEff203_0x2525b0; // 0x25279c - g_ps2RecompiledFunctionTable[346600] = bhEff203_0x2525b0; // 0x2527a8 - g_ps2RecompiledFunctionTable[346603] = bhEff203_0x2525b0; // 0x2527b4 - g_ps2RecompiledFunctionTable[346606] = bhEff203_0x2525b0; // 0x2527c0 - g_ps2RecompiledFunctionTable[346610] = bhEff203_0x2525b0; // 0x2527d0 - g_ps2RecompiledFunctionTable[346612] = bhEff203_0x2525b0; // 0x2527d8 - g_ps2RecompiledFunctionTable[346633] = bhEff203_0x2525b0; // 0x25282c - g_ps2RecompiledFunctionTable[346637] = bhEff203_0x2525b0; // 0x25283c - g_ps2RecompiledFunctionTable[346641] = bhEff203_0x2525b0; // 0x25284c - g_ps2RecompiledFunctionTable[346643] = bhEff203_0x2525b0; // 0x252854 - g_ps2RecompiledFunctionTable[346658] = bhEff203_0x2525b0; // 0x252890 - g_ps2RecompiledFunctionTable[346662] = bhEff203_0x2525b0; // 0x2528a0 - g_ps2RecompiledFunctionTable[346666] = bhEff203_0x2525b0; // 0x2528b0 - g_ps2RecompiledFunctionTable[346668] = bhEff203_0x2525b0; // 0x2528b8 - g_ps2RecompiledFunctionTable[346747] = bhEff203_0x2525b0; // 0x2529f4 - g_ps2RecompiledFunctionTable[346804] = bhEff203_0x2525b0; // 0x252ad8 - g_ps2RecompiledFunctionTable[346806] = bhEff203_0x2525b0; // 0x252ae0 - g_ps2RecompiledFunctionTable[346809] = bhEff203_0x2525b0; // 0x252aec - g_ps2RecompiledFunctionTable[346812] = bhEff203_0x2525b0; // 0x252af8 - g_ps2RecompiledFunctionTable[346816] = bhEff203_0x2525b0; // 0x252b08 - g_ps2RecompiledFunctionTable[346818] = bhEff203_0x2525b0; // 0x252b10 - g_ps2RecompiledFunctionTable[346874] = bhEff204_0x252bf0; // 0x252bf0 - g_ps2RecompiledFunctionTable[346962] = bhEff205_0x252d50; // 0x252d50 - g_ps2RecompiledFunctionTable[347028] = bhEff205_0x252d50; // 0x252e58 - g_ps2RecompiledFunctionTable[347118] = bhEff206_0x252fc0; // 0x252fc0 - g_ps2RecompiledFunctionTable[347193] = bhEff206_0x252fc0; // 0x2530ec - g_ps2RecompiledFunctionTable[347198] = bhEff207_0x253100; // 0x253100 - g_ps2RecompiledFunctionTable[347246] = bhEff207_0x253100; // 0x2531c0 - g_ps2RecompiledFunctionTable[347248] = bhEff207_0x253100; // 0x2531c8 - g_ps2RecompiledFunctionTable[347258] = bhEff207_0x253100; // 0x2531f0 - g_ps2RecompiledFunctionTable[347271] = bhEff207_0x253100; // 0x253224 - g_ps2RecompiledFunctionTable[347278] = bhEff207_0x253100; // 0x253240 - g_ps2RecompiledFunctionTable[347280] = bhEff207_0x253100; // 0x253248 - g_ps2RecompiledFunctionTable[347293] = bhEff207_0x253100; // 0x25327c - g_ps2RecompiledFunctionTable[347300] = bhEff207_0x253100; // 0x253298 - g_ps2RecompiledFunctionTable[347304] = bhEff207_0x253100; // 0x2532a8 - g_ps2RecompiledFunctionTable[347317] = bhEff207_0x253100; // 0x2532dc - g_ps2RecompiledFunctionTable[347324] = bhEff207_0x253100; // 0x2532f8 - g_ps2RecompiledFunctionTable[347326] = bhEff207_0x253100; // 0x253300 - g_ps2RecompiledFunctionTable[347339] = bhEff207_0x253100; // 0x253334 - g_ps2RecompiledFunctionTable[347346] = bhEff207_0x253100; // 0x253350 - g_ps2RecompiledFunctionTable[347350] = bhEff207_0x253100; // 0x253360 - g_ps2RecompiledFunctionTable[347352] = bhEff207_0x253100; // 0x253368 - g_ps2RecompiledFunctionTable[347558] = bhEff208_0x2536a0; // 0x2536a0 - g_ps2RecompiledFunctionTable[347631] = bhEff208_0x2536a0; // 0x2537c4 - g_ps2RecompiledFunctionTable[347638] = bhEff209_0x2537e0; // 0x2537e0 - g_ps2RecompiledFunctionTable[347668] = bhEff209_0x2537e0; // 0x253858 - g_ps2RecompiledFunctionTable[347670] = bhEff209_0x2537e0; // 0x253860 - g_ps2RecompiledFunctionTable[347673] = bhEff209_0x2537e0; // 0x25386c - g_ps2RecompiledFunctionTable[347676] = bhEff209_0x2537e0; // 0x253878 - g_ps2RecompiledFunctionTable[347680] = bhEff209_0x2537e0; // 0x253888 - g_ps2RecompiledFunctionTable[347682] = bhEff209_0x2537e0; // 0x253890 - g_ps2RecompiledFunctionTable[347694] = bhEff209_0x2537e0; // 0x2538c0 - g_ps2RecompiledFunctionTable[347810] = bhEff210_0x253a90; // 0x253a90 - g_ps2RecompiledFunctionTable[347885] = bhEff210_0x253a90; // 0x253bbc - g_ps2RecompiledFunctionTable[347954] = bhEff211_0x253cd0; // 0x253cd0 - g_ps2RecompiledFunctionTable[348029] = bhEff211_0x253cd0; // 0x253dfc - g_ps2RecompiledFunctionTable[348098] = bhEff212_0x253f10; // 0x253f10 - g_ps2RecompiledFunctionTable[348171] = bhEff212_0x253f10; // 0x254034 - g_ps2RecompiledFunctionTable[348238] = bhEff213_0x254140; // 0x254140 - g_ps2RecompiledFunctionTable[348309] = bhEff213_0x254140; // 0x25425c - g_ps2RecompiledFunctionTable[348386] = bhEff214_0x254390; // 0x254390 - g_ps2RecompiledFunctionTable[348442] = bhEff214_0x254390; // 0x254470 - g_ps2RecompiledFunctionTable[348450] = bhEff215_0x254490; // 0x254490 - g_ps2RecompiledFunctionTable[348523] = bhEff215_0x254490; // 0x2545b4 - g_ps2RecompiledFunctionTable[348530] = bhEff216_0x2545d0; // 0x2545d0 - g_ps2RecompiledFunctionTable[348543] = bhEff216_0x2545d0; // 0x254604 - g_ps2RecompiledFunctionTable[348546] = bhEff216_0x2545d0; // 0x254610 - g_ps2RecompiledFunctionTable[348601] = bhEff216_0x2545d0; // 0x2546ec - g_ps2RecompiledFunctionTable[348604] = bhEff216_0x2545d0; // 0x2546f8 - g_ps2RecompiledFunctionTable[348616] = bhEff216_0x2545d0; // 0x254728 - g_ps2RecompiledFunctionTable[348618] = bhEff216_0x2545d0; // 0x254730 - g_ps2RecompiledFunctionTable[348621] = bhEff216_0x2545d0; // 0x25473c - g_ps2RecompiledFunctionTable[348624] = bhEff216_0x2545d0; // 0x254748 - g_ps2RecompiledFunctionTable[348628] = bhEff216_0x2545d0; // 0x254758 - g_ps2RecompiledFunctionTable[348630] = bhEff216_0x2545d0; // 0x254760 - g_ps2RecompiledFunctionTable[348758] = bhEff217_0x254960; // 0x254960 - g_ps2RecompiledFunctionTable[348785] = bhEff217_0x254960; // 0x2549cc - g_ps2RecompiledFunctionTable[348797] = bhEff217_0x254960; // 0x2549fc - g_ps2RecompiledFunctionTable[348799] = bhEff217_0x254960; // 0x254a04 - g_ps2RecompiledFunctionTable[348811] = bhEff217_0x254960; // 0x254a34 - g_ps2RecompiledFunctionTable[348823] = bhEff217_0x254960; // 0x254a64 - g_ps2RecompiledFunctionTable[348835] = bhEff217_0x254960; // 0x254a94 - g_ps2RecompiledFunctionTable[348847] = bhEff217_0x254960; // 0x254ac4 - g_ps2RecompiledFunctionTable[348859] = bhEff217_0x254960; // 0x254af4 - g_ps2RecompiledFunctionTable[348875] = bhEff217_0x254960; // 0x254b34 - g_ps2RecompiledFunctionTable[348887] = bhEff217_0x254960; // 0x254b64 - g_ps2RecompiledFunctionTable[348889] = bhEff217_0x254960; // 0x254b6c - g_ps2RecompiledFunctionTable[348901] = bhEff217_0x254960; // 0x254b9c - g_ps2RecompiledFunctionTable[348913] = bhEff217_0x254960; // 0x254bcc - g_ps2RecompiledFunctionTable[348916] = bhEff217_0x254960; // 0x254bd8 - g_ps2RecompiledFunctionTable[348918] = bhEff217_0x254960; // 0x254be0 - g_ps2RecompiledFunctionTable[348930] = bhEff217_0x254960; // 0x254c10 - g_ps2RecompiledFunctionTable[348939] = bhEff217_0x254960; // 0x254c34 - g_ps2RecompiledFunctionTable[348942] = bhEff217_0x254960; // 0x254c40 - g_ps2RecompiledFunctionTable[348946] = bhEff217_0x254960; // 0x254c50 - g_ps2RecompiledFunctionTable[348948] = bhEff217_0x254960; // 0x254c58 - g_ps2RecompiledFunctionTable[348965] = bhEff217_0x254960; // 0x254c9c - g_ps2RecompiledFunctionTable[348978] = bhEff217_0x254960; // 0x254cd0 - g_ps2RecompiledFunctionTable[349001] = bhEff217_0x254960; // 0x254d2c - g_ps2RecompiledFunctionTable[349070] = bhEff218_0x254e40; // 0x254e40 - g_ps2RecompiledFunctionTable[349139] = bhEff218_0x254e40; // 0x254f54 - g_ps2RecompiledFunctionTable[349155] = bhEff218_0x254e40; // 0x254f94 - g_ps2RecompiledFunctionTable[349278] = bhEff219_0x255180; // 0x255180 - g_ps2RecompiledFunctionTable[349314] = bhEff219_0x255180; // 0x255210 - g_ps2RecompiledFunctionTable[349330] = bhEff219_0x255180; // 0x255250 - g_ps2RecompiledFunctionTable[349358] = bhEff219_0x255180; // 0x2552c0 - g_ps2RecompiledFunctionTable[349377] = bhEff219_0x255180; // 0x25530c - g_ps2RecompiledFunctionTable[349384] = bhEff219_0x255180; // 0x255328 - g_ps2RecompiledFunctionTable[349386] = bhEff219_0x255180; // 0x255330 - g_ps2RecompiledFunctionTable[349400] = bhEff219_0x255180; // 0x255368 - g_ps2RecompiledFunctionTable[349440] = bhEff219_0x255180; // 0x255408 - g_ps2RecompiledFunctionTable[349459] = bhEff219_0x255180; // 0x255454 - g_ps2RecompiledFunctionTable[349469] = bhEff219_0x255180; // 0x25547c - g_ps2RecompiledFunctionTable[349483] = bhEff219_0x255180; // 0x2554b4 - g_ps2RecompiledFunctionTable[349502] = bhEff219_0x255180; // 0x255500 - g_ps2RecompiledFunctionTable[349504] = bhEff219_0x255180; // 0x255508 - g_ps2RecompiledFunctionTable[349534] = bhEff220_0x255580; // 0x255580 - g_ps2RecompiledFunctionTable[349631] = bhEff220_0x255580; // 0x255704 - g_ps2RecompiledFunctionTable[349633] = bhEff220_0x255580; // 0x25570c - g_ps2RecompiledFunctionTable[349646] = bhEff220_0x255580; // 0x255740 - g_ps2RecompiledFunctionTable[349651] = bhEff220_0x255580; // 0x255754 - g_ps2RecompiledFunctionTable[349653] = bhEff220_0x255580; // 0x25575c - g_ps2RecompiledFunctionTable[349683] = bhEff220_0x255580; // 0x2557d4 - g_ps2RecompiledFunctionTable[349692] = bhEff220_0x255580; // 0x2557f8 - g_ps2RecompiledFunctionTable[349722] = bhEff220_0x255580; // 0x255870 - g_ps2RecompiledFunctionTable[349741] = bhEff220_0x255580; // 0x2558bc - g_ps2RecompiledFunctionTable[349752] = bhEff220_0x255580; // 0x2558e8 - g_ps2RecompiledFunctionTable[349756] = bhEff220_0x255580; // 0x2558f8 - g_ps2RecompiledFunctionTable[349803] = bhEff220_0x255580; // 0x2559b4 - g_ps2RecompiledFunctionTable[349838] = bhEff221_0x255a40; // 0x255a40 - g_ps2RecompiledFunctionTable[350026] = bhEff221_0x255a40; // 0x255d30 - g_ps2RecompiledFunctionTable[350028] = bhEff221_0x255a40; // 0x255d38 - g_ps2RecompiledFunctionTable[350044] = bhEff221_0x255a40; // 0x255d78 - g_ps2RecompiledFunctionTable[350047] = bhEff221_0x255a40; // 0x255d84 - g_ps2RecompiledFunctionTable[350063] = bhEff221_0x255a40; // 0x255dc4 - g_ps2RecompiledFunctionTable[350246] = bhDrawEff221_0x2560a0; // 0x2560a0 - g_ps2RecompiledFunctionTable[350260] = bhDrawEff221_0x2560a0; // 0x2560d8 - g_ps2RecompiledFunctionTable[350265] = bhDrawEff221_0x2560a0; // 0x2560ec - g_ps2RecompiledFunctionTable[350269] = bhDrawEff221_0x2560a0; // 0x2560fc - g_ps2RecompiledFunctionTable[350273] = bhDrawEff221_0x2560a0; // 0x25610c - g_ps2RecompiledFunctionTable[350275] = bhDrawEff221_0x2560a0; // 0x256114 - g_ps2RecompiledFunctionTable[350284] = bhDrawEff221_0x2560a0; // 0x256138 - g_ps2RecompiledFunctionTable[350286] = bhDrawEff221_0x2560a0; // 0x256140 - g_ps2RecompiledFunctionTable[350290] = bhDrawEff221_0x2560a0; // 0x256150 - g_ps2RecompiledFunctionTable[350306] = bhDrawEff221_0x2560a0; // 0x256190 - g_ps2RecompiledFunctionTable[350312] = bhDrawEff221_0x2560a0; // 0x2561a8 - g_ps2RecompiledFunctionTable[350321] = bhDrawEff221_0x2560a0; // 0x2561cc - g_ps2RecompiledFunctionTable[350329] = bhDrawEff221_0x2560a0; // 0x2561ec - g_ps2RecompiledFunctionTable[350331] = bhDrawEff221_0x2560a0; // 0x2561f4 - g_ps2RecompiledFunctionTable[350334] = bhDrawEff221_0x2560a0; // 0x256200 - g_ps2RecompiledFunctionTable[350336] = bhDrawEff221_0x2560a0; // 0x256208 - g_ps2RecompiledFunctionTable[350342] = bhDrawEff221_0x2560a0; // 0x256220 - g_ps2RecompiledFunctionTable[350344] = bhDrawEff221_0x2560a0; // 0x256228 - g_ps2RecompiledFunctionTable[350346] = bhDrawEff221_0x2560a0; // 0x256230 - g_ps2RecompiledFunctionTable[350348] = bhDrawEff221_0x2560a0; // 0x256238 - g_ps2RecompiledFunctionTable[350351] = bhDrawEff221_0x2560a0; // 0x256244 - g_ps2RecompiledFunctionTable[350354] = bhDrawEff221_0x2560a0; // 0x256250 - g_ps2RecompiledFunctionTable[350358] = bhDrawEff221_0x2560a0; // 0x256260 - g_ps2RecompiledFunctionTable[350361] = bhDrawEff221_0x2560a0; // 0x25626c - g_ps2RecompiledFunctionTable[350364] = bhDrawEff221_0x2560a0; // 0x256278 - g_ps2RecompiledFunctionTable[350370] = bhEff222_0x256290; // 0x256290 - g_ps2RecompiledFunctionTable[350444] = bhEff222_0x256290; // 0x2563b8 - g_ps2RecompiledFunctionTable[350461] = bhEff222_0x256290; // 0x2563fc - g_ps2RecompiledFunctionTable[350495] = bhEff222_0x256290; // 0x256484 - g_ps2RecompiledFunctionTable[350502] = bhEff223_0x2564a0; // 0x2564a0 - g_ps2RecompiledFunctionTable[350536] = bhEff223_0x2564a0; // 0x256528 - g_ps2RecompiledFunctionTable[350544] = bhEff223_0x2564a0; // 0x256548 - g_ps2RecompiledFunctionTable[350557] = bhEff223_0x2564a0; // 0x25657c - g_ps2RecompiledFunctionTable[350559] = bhEff223_0x2564a0; // 0x256584 - g_ps2RecompiledFunctionTable[350572] = bhEff223_0x2564a0; // 0x2565b8 - g_ps2RecompiledFunctionTable[350575] = bhEff223_0x2564a0; // 0x2565c4 - g_ps2RecompiledFunctionTable[350588] = bhEff223_0x2564a0; // 0x2565f8 - g_ps2RecompiledFunctionTable[350595] = bhEff223_0x2564a0; // 0x256614 - g_ps2RecompiledFunctionTable[350608] = bhEff223_0x2564a0; // 0x256648 - g_ps2RecompiledFunctionTable[350627] = bhEff223_0x2564a0; // 0x256694 - g_ps2RecompiledFunctionTable[350640] = bhEff223_0x2564a0; // 0x2566c8 - g_ps2RecompiledFunctionTable[350659] = bhEff223_0x2564a0; // 0x256714 - g_ps2RecompiledFunctionTable[350675] = bhEff223_0x2564a0; // 0x256754 - g_ps2RecompiledFunctionTable[350677] = bhEff223_0x2564a0; // 0x25675c - g_ps2RecompiledFunctionTable[350690] = bhEff223_0x2564a0; // 0x256790 - g_ps2RecompiledFunctionTable[350692] = bhEff223_0x2564a0; // 0x256798 - g_ps2RecompiledFunctionTable[350741] = bhEff223_0x2564a0; // 0x25685c - g_ps2RecompiledFunctionTable[350743] = bhEff223_0x2564a0; // 0x256864 - g_ps2RecompiledFunctionTable[350746] = bhEff223_0x2564a0; // 0x256870 - g_ps2RecompiledFunctionTable[350749] = bhEff223_0x2564a0; // 0x25687c - g_ps2RecompiledFunctionTable[350753] = bhEff223_0x2564a0; // 0x25688c - g_ps2RecompiledFunctionTable[350755] = bhEff223_0x2564a0; // 0x256894 - g_ps2RecompiledFunctionTable[350781] = bhEff223_0x2564a0; // 0x2568fc - g_ps2RecompiledFunctionTable[350878] = bhEff224_0x256a80; // 0x256a80 - g_ps2RecompiledFunctionTable[350941] = bhEff224_0x256a80; // 0x256b7c - g_ps2RecompiledFunctionTable[350950] = bhEff225_0x256ba0; // 0x256ba0 - g_ps2RecompiledFunctionTable[351134] = bhEff226_0x256e80; // 0x256e80 - g_ps2RecompiledFunctionTable[351190] = bhEff226_0x256e80; // 0x256f60 - g_ps2RecompiledFunctionTable[351192] = bhEff226_0x256e80; // 0x256f68 - g_ps2RecompiledFunctionTable[351205] = bhEff226_0x256e80; // 0x256f9c - g_ps2RecompiledFunctionTable[351213] = bhEff226_0x256e80; // 0x256fbc - g_ps2RecompiledFunctionTable[351242] = bhEff227_0x257030; // 0x257030 - g_ps2RecompiledFunctionTable[351334] = bhEff227_0x257030; // 0x2571a0 - g_ps2RecompiledFunctionTable[351340] = bhEff227_0x257030; // 0x2571b8 - g_ps2RecompiledFunctionTable[351343] = bhEff227_0x257030; // 0x2571c4 - g_ps2RecompiledFunctionTable[351346] = bhEff227_0x257030; // 0x2571d0 - g_ps2RecompiledFunctionTable[351352] = bhEff227_0x257030; // 0x2571e8 - g_ps2RecompiledFunctionTable[351356] = bhEff227_0x257030; // 0x2571f8 - g_ps2RecompiledFunctionTable[351358] = bhEff227_0x257030; // 0x257200 - g_ps2RecompiledFunctionTable[351438] = bhEff228_0x257340; // 0x257340 - g_ps2RecompiledFunctionTable[351540] = bhEff228_0x257340; // 0x2574d8 - g_ps2RecompiledFunctionTable[351568] = bhEff228_0x257340; // 0x257548 - g_ps2RecompiledFunctionTable[351570] = bhEff228_0x257340; // 0x257550 - g_ps2RecompiledFunctionTable[351573] = bhEff228_0x257340; // 0x25755c - g_ps2RecompiledFunctionTable[351576] = bhEff228_0x257340; // 0x257568 - g_ps2RecompiledFunctionTable[351580] = bhEff228_0x257340; // 0x257578 - g_ps2RecompiledFunctionTable[351582] = bhEff228_0x257340; // 0x257580 - g_ps2RecompiledFunctionTable[351620] = bhEff228_0x257340; // 0x257618 - g_ps2RecompiledFunctionTable[351626] = bhEff229_0x257630; // 0x257630 - g_ps2RecompiledFunctionTable[351694] = bhDrawWeaponEffect2_0x257740; // 0x257740 - g_ps2RecompiledFunctionTable[351710] = bhDrawWeaponEffect2_0x257740; // 0x257780 - g_ps2RecompiledFunctionTable[351712] = bhDrawWeaponEffect2_0x257740; // 0x257788 - g_ps2RecompiledFunctionTable[351719] = bhDrawWeaponEffect2_0x257740; // 0x2577a4 - g_ps2RecompiledFunctionTable[351724] = bhDrawWeaponEffect2_0x257740; // 0x2577b8 - g_ps2RecompiledFunctionTable[351730] = bhDrawWeaponEffect2_0x257740; // 0x2577d0 - g_ps2RecompiledFunctionTable[351741] = bhDrawWeaponEffect2_0x257740; // 0x2577fc - g_ps2RecompiledFunctionTable[351752] = bhDrawWeaponEffect2_0x257740; // 0x257828 - g_ps2RecompiledFunctionTable[351757] = bhDrawWeaponEffect2_0x257740; // 0x25783c - g_ps2RecompiledFunctionTable[351762] = bhDrawWeaponEffect2_0x257740; // 0x257850 - g_ps2RecompiledFunctionTable[351766] = bhDrawWeaponEffect2_0x257740; // 0x257860 - g_ps2RecompiledFunctionTable[351769] = bhDrawWeaponEffect2_0x257740; // 0x25786c - g_ps2RecompiledFunctionTable[351774] = bhDrawWeaponEffect2_0x257740; // 0x257880 - g_ps2RecompiledFunctionTable[351777] = bhDrawWeaponEffect2_0x257740; // 0x25788c - g_ps2RecompiledFunctionTable[351780] = bhDrawWeaponEffect2_0x257740; // 0x257898 - g_ps2RecompiledFunctionTable[351784] = bhDrawWeaponEffect2_0x257740; // 0x2578a8 - g_ps2RecompiledFunctionTable[351813] = bhDrawWeaponEffect2_0x257740; // 0x25791c - g_ps2RecompiledFunctionTable[351901] = bhDrawWeaponEffect2_0x257740; // 0x257a7c - g_ps2RecompiledFunctionTable[351975] = bhDrawWeaponEffect2_0x257740; // 0x257ba4 - g_ps2RecompiledFunctionTable[351997] = bhDrawWeaponEffect2_0x257740; // 0x257bfc - g_ps2RecompiledFunctionTable[352011] = bhDrawWeaponEffect2_0x257740; // 0x257c34 - g_ps2RecompiledFunctionTable[352014] = bhDrawWeaponEffect2_0x257740; // 0x257c40 - g_ps2RecompiledFunctionTable[352017] = bhDrawWeaponEffect2_0x257740; // 0x257c4c - g_ps2RecompiledFunctionTable[352141] = bhDrawWeaponEffect2_0x257740; // 0x257e3c - g_ps2RecompiledFunctionTable[352145] = bhDrawWeaponEffect2_0x257740; // 0x257e4c - g_ps2RecompiledFunctionTable[352149] = bhDrawWeaponEffect2_0x257740; // 0x257e5c - g_ps2RecompiledFunctionTable[352152] = bhDrawWeaponEffect2_0x257740; // 0x257e68 - g_ps2RecompiledFunctionTable[352159] = bhDrawWeaponEffect2_0x257740; // 0x257e84 - g_ps2RecompiledFunctionTable[352163] = bhDrawWeaponEffect2_0x257740; // 0x257e94 - g_ps2RecompiledFunctionTable[352167] = bhDrawWeaponEffect2_0x257740; // 0x257ea4 - g_ps2RecompiledFunctionTable[352170] = bhDrawWeaponEffect2_0x257740; // 0x257eb0 - g_ps2RecompiledFunctionTable[352177] = bhDrawWeaponEffect2_0x257740; // 0x257ecc - g_ps2RecompiledFunctionTable[352180] = bhDrawWeaponEffect2_0x257740; // 0x257ed8 - g_ps2RecompiledFunctionTable[352182] = bhDrawWeaponEffect2_0x257740; // 0x257ee0 - g_ps2RecompiledFunctionTable[352198] = bhEff230_0x257f20; // 0x257f20 - g_ps2RecompiledFunctionTable[352342] = bhEff231_0x258160; // 0x258160 - g_ps2RecompiledFunctionTable[352412] = bhEff231_0x258160; // 0x258278 - g_ps2RecompiledFunctionTable[352423] = bhEff231_0x258160; // 0x2582a4 - g_ps2RecompiledFunctionTable[352425] = bhEff231_0x258160; // 0x2582ac - g_ps2RecompiledFunctionTable[352434] = bhEff232_0x2582d0; // 0x2582d0 - g_ps2RecompiledFunctionTable[352546] = bhEff233_0x258490; // 0x258490 - g_ps2RecompiledFunctionTable[352644] = bhEff233_0x258490; // 0x258618 - g_ps2RecompiledFunctionTable[352659] = bhEff233_0x258490; // 0x258654 - g_ps2RecompiledFunctionTable[352726] = bhEff234_0x258760; // 0x258760 - g_ps2RecompiledFunctionTable[352835] = bhEff234_0x258760; // 0x258914 - g_ps2RecompiledFunctionTable[352848] = bhEff234_0x258760; // 0x258948 - g_ps2RecompiledFunctionTable[352918] = bhEff235_0x258a60; // 0x258a60 - g_ps2RecompiledFunctionTable[353008] = bhEff235_0x258a60; // 0x258bc8 - g_ps2RecompiledFunctionTable[353018] = bhEff235_0x258a60; // 0x258bf0 - g_ps2RecompiledFunctionTable[353110] = bhEff236_0x258d60; // 0x258d60 - g_ps2RecompiledFunctionTable[353206] = bhEff236_0x258d60; // 0x258ee0 - g_ps2RecompiledFunctionTable[353217] = bhEff236_0x258d60; // 0x258f0c - g_ps2RecompiledFunctionTable[353220] = bhEff236_0x258d60; // 0x258f18 - g_ps2RecompiledFunctionTable[353224] = bhEff236_0x258d60; // 0x258f28 - g_ps2RecompiledFunctionTable[353242] = bhEff236_0x258d60; // 0x258f70 - g_ps2RecompiledFunctionTable[353274] = bhEff236_0x258d60; // 0x258ff0 - g_ps2RecompiledFunctionTable[353277] = bhEff236_0x258d60; // 0x258ffc - g_ps2RecompiledFunctionTable[353281] = bhEff236_0x258d60; // 0x25900c - g_ps2RecompiledFunctionTable[353294] = bhEff236_0x258d60; // 0x259040 - g_ps2RecompiledFunctionTable[353304] = bhEff236_0x258d60; // 0x259068 - g_ps2RecompiledFunctionTable[353398] = bhDrawEff236_0x2591e0; // 0x2591e0 - g_ps2RecompiledFunctionTable[353408] = bhDrawEff236_0x2591e0; // 0x259208 - g_ps2RecompiledFunctionTable[353419] = bhDrawEff236_0x2591e0; // 0x259234 - g_ps2RecompiledFunctionTable[353421] = bhDrawEff236_0x2591e0; // 0x25923c - g_ps2RecompiledFunctionTable[353424] = bhDrawEff236_0x2591e0; // 0x259248 - g_ps2RecompiledFunctionTable[353427] = bhDrawEff236_0x2591e0; // 0x259254 - g_ps2RecompiledFunctionTable[353431] = bhDrawEff236_0x2591e0; // 0x259264 - g_ps2RecompiledFunctionTable[353434] = bhDrawEff236_0x2591e0; // 0x259270 - g_ps2RecompiledFunctionTable[353437] = bhDrawEff236_0x2591e0; // 0x25927c - g_ps2RecompiledFunctionTable[353442] = bhEff237_0x259290; // 0x259290 - g_ps2RecompiledFunctionTable[353502] = bhEff237_0x259290; // 0x259380 - g_ps2RecompiledFunctionTable[353504] = bhEff237_0x259290; // 0x259388 - g_ps2RecompiledFunctionTable[353507] = bhEff237_0x259290; // 0x259394 - g_ps2RecompiledFunctionTable[353510] = bhEff237_0x259290; // 0x2593a0 - g_ps2RecompiledFunctionTable[353514] = bhEff237_0x259290; // 0x2593b0 - g_ps2RecompiledFunctionTable[353516] = bhEff237_0x259290; // 0x2593b8 - g_ps2RecompiledFunctionTable[353626] = bhEff238_0x259570; // 0x259570 - g_ps2RecompiledFunctionTable[353697] = bhEff238_0x259570; // 0x25968c - g_ps2RecompiledFunctionTable[353713] = bhEff238_0x259570; // 0x2596cc - g_ps2RecompiledFunctionTable[353717] = bhEff238_0x259570; // 0x2596dc - g_ps2RecompiledFunctionTable[353725] = bhEff238_0x259570; // 0x2596fc - g_ps2RecompiledFunctionTable[353729] = bhEff238_0x259570; // 0x25970c - g_ps2RecompiledFunctionTable[353731] = bhEff238_0x259570; // 0x259714 - g_ps2RecompiledFunctionTable[353733] = bhEff238_0x259570; // 0x25971c - g_ps2RecompiledFunctionTable[353735] = bhEff238_0x259570; // 0x259724 - g_ps2RecompiledFunctionTable[353746] = bhEff238_0x259570; // 0x259750 - g_ps2RecompiledFunctionTable[353749] = bhEff238_0x259570; // 0x25975c - g_ps2RecompiledFunctionTable[353762] = bhEff238_0x259570; // 0x259790 - g_ps2RecompiledFunctionTable[353764] = bhEff238_0x259570; // 0x259798 - g_ps2RecompiledFunctionTable[353767] = bhEff238_0x259570; // 0x2597a4 - g_ps2RecompiledFunctionTable[353770] = bhEff238_0x259570; // 0x2597b0 - g_ps2RecompiledFunctionTable[353774] = bhEff238_0x259570; // 0x2597c0 - g_ps2RecompiledFunctionTable[353776] = bhEff238_0x259570; // 0x2597c8 - g_ps2RecompiledFunctionTable[353806] = bhEff239_0x259840; // 0x259840 - g_ps2RecompiledFunctionTable[353860] = bhEff239_0x259840; // 0x259918 - g_ps2RecompiledFunctionTable[354006] = bhEff240_0x259b60; // 0x259b60 - g_ps2RecompiledFunctionTable[354103] = bhEff240_0x259b60; // 0x259ce4 - g_ps2RecompiledFunctionTable[354105] = bhEff240_0x259b60; // 0x259cec - g_ps2RecompiledFunctionTable[354118] = bhEff240_0x259b60; // 0x259d20 - g_ps2RecompiledFunctionTable[354123] = bhEff240_0x259b60; // 0x259d34 - g_ps2RecompiledFunctionTable[354125] = bhEff240_0x259b60; // 0x259d3c - g_ps2RecompiledFunctionTable[354155] = bhEff240_0x259b60; // 0x259db4 - g_ps2RecompiledFunctionTable[354164] = bhEff240_0x259b60; // 0x259dd8 - g_ps2RecompiledFunctionTable[354194] = bhEff240_0x259b60; // 0x259e50 - g_ps2RecompiledFunctionTable[354213] = bhEff240_0x259b60; // 0x259e9c - g_ps2RecompiledFunctionTable[354224] = bhEff240_0x259b60; // 0x259ec8 - g_ps2RecompiledFunctionTable[354228] = bhEff240_0x259b60; // 0x259ed8 - g_ps2RecompiledFunctionTable[354275] = bhEff240_0x259b60; // 0x259f94 - g_ps2RecompiledFunctionTable[354310] = bhEff241_0x25a020; // 0x25a020 - g_ps2RecompiledFunctionTable[354337] = bhEff241_0x25a020; // 0x25a08c - g_ps2RecompiledFunctionTable[354371] = bhEff241_0x25a020; // 0x25a114 - g_ps2RecompiledFunctionTable[354386] = bhEff242_0x25a150; // 0x25a150 - g_ps2RecompiledFunctionTable[354423] = bhEff242_0x25a150; // 0x25a1e4 - g_ps2RecompiledFunctionTable[354431] = bhEff242_0x25a150; // 0x25a204 - g_ps2RecompiledFunctionTable[354444] = bhEff242_0x25a150; // 0x25a238 - g_ps2RecompiledFunctionTable[354452] = bhEff242_0x25a150; // 0x25a258 - g_ps2RecompiledFunctionTable[354464] = bhEff242_0x25a150; // 0x25a288 - g_ps2RecompiledFunctionTable[354479] = bhEff242_0x25a150; // 0x25a2c4 - g_ps2RecompiledFunctionTable[354594] = bhEff242_0x25a150; // 0x25a490 - g_ps2RecompiledFunctionTable[354597] = bhEff242_0x25a150; // 0x25a49c - g_ps2RecompiledFunctionTable[354609] = bhEff242_0x25a150; // 0x25a4cc - g_ps2RecompiledFunctionTable[354612] = bhEff242_0x25a150; // 0x25a4d8 - g_ps2RecompiledFunctionTable[354615] = bhEff242_0x25a150; // 0x25a4e4 - g_ps2RecompiledFunctionTable[354617] = bhEff242_0x25a150; // 0x25a4ec - g_ps2RecompiledFunctionTable[354630] = bhEff242_0x25a150; // 0x25a520 - g_ps2RecompiledFunctionTable[354633] = bhEff242_0x25a150; // 0x25a52c - g_ps2RecompiledFunctionTable[354637] = bhEff242_0x25a150; // 0x25a53c - g_ps2RecompiledFunctionTable[354652] = bhEff242_0x25a150; // 0x25a578 - g_ps2RecompiledFunctionTable[354664] = bhEff242_0x25a150; // 0x25a5a8 - g_ps2RecompiledFunctionTable[354677] = bhEff242_0x25a150; // 0x25a5dc - g_ps2RecompiledFunctionTable[354680] = bhEff242_0x25a150; // 0x25a5e8 - g_ps2RecompiledFunctionTable[354683] = bhEff242_0x25a150; // 0x25a5f4 - g_ps2RecompiledFunctionTable[354685] = bhEff242_0x25a150; // 0x25a5fc - g_ps2RecompiledFunctionTable[354698] = bhEff242_0x25a150; // 0x25a630 - g_ps2RecompiledFunctionTable[354701] = bhEff242_0x25a150; // 0x25a63c - g_ps2RecompiledFunctionTable[354703] = bhEff242_0x25a150; // 0x25a644 - g_ps2RecompiledFunctionTable[354706] = bhEff242_0x25a150; // 0x25a650 - g_ps2RecompiledFunctionTable[354710] = bhEff242_0x25a150; // 0x25a660 - g_ps2RecompiledFunctionTable[354712] = bhEff242_0x25a150; // 0x25a668 - g_ps2RecompiledFunctionTable[354714] = bhEff242_0x25a150; // 0x25a670 - g_ps2RecompiledFunctionTable[354730] = bhEff242_0x25a150; // 0x25a6b0 - g_ps2RecompiledFunctionTable[354746] = bhEff242_0x25a150; // 0x25a6f0 - g_ps2RecompiledFunctionTable[354797] = bhEff242_0x25a150; // 0x25a7bc - g_ps2RecompiledFunctionTable[354799] = bhEff242_0x25a150; // 0x25a7c4 - g_ps2RecompiledFunctionTable[354802] = bhEff242_0x25a150; // 0x25a7d0 - g_ps2RecompiledFunctionTable[354805] = bhEff242_0x25a150; // 0x25a7dc - g_ps2RecompiledFunctionTable[354808] = bhEff242_0x25a150; // 0x25a7e8 - g_ps2RecompiledFunctionTable[354812] = bhEff242_0x25a150; // 0x25a7f8 - g_ps2RecompiledFunctionTable[354814] = bhEff242_0x25a150; // 0x25a800 - g_ps2RecompiledFunctionTable[354845] = bhEff242_0x25a150; // 0x25a87c - g_ps2RecompiledFunctionTable[354850] = bhEff242_0x25a150; // 0x25a890 - g_ps2RecompiledFunctionTable[354855] = bhEff242_0x25a150; // 0x25a8a4 - g_ps2RecompiledFunctionTable[354946] = bhEff243_0x25aa10; // 0x25aa10 - g_ps2RecompiledFunctionTable[355047] = bhEff243_0x25aa10; // 0x25aba4 - g_ps2RecompiledFunctionTable[355065] = bhEff243_0x25aa10; // 0x25abec - g_ps2RecompiledFunctionTable[355068] = bhEff243_0x25aa10; // 0x25abf8 - g_ps2RecompiledFunctionTable[355071] = bhEff243_0x25aa10; // 0x25ac04 - g_ps2RecompiledFunctionTable[355075] = bhEff243_0x25aa10; // 0x25ac14 - g_ps2RecompiledFunctionTable[355079] = bhEff243_0x25aa10; // 0x25ac24 - g_ps2RecompiledFunctionTable[355081] = bhEff243_0x25aa10; // 0x25ac2c - g_ps2RecompiledFunctionTable[355084] = bhEff243_0x25aa10; // 0x25ac38 - g_ps2RecompiledFunctionTable[355089] = bhEff243_0x25aa10; // 0x25ac4c - g_ps2RecompiledFunctionTable[355093] = bhEff243_0x25aa10; // 0x25ac5c - g_ps2RecompiledFunctionTable[355097] = bhEff243_0x25aa10; // 0x25ac6c - g_ps2RecompiledFunctionTable[355100] = bhEff243_0x25aa10; // 0x25ac78 - g_ps2RecompiledFunctionTable[355105] = bhEff243_0x25aa10; // 0x25ac8c - g_ps2RecompiledFunctionTable[355108] = bhEff243_0x25aa10; // 0x25ac98 - g_ps2RecompiledFunctionTable[355190] = bhDrawEff243_0x25ade0; // 0x25ade0 - g_ps2RecompiledFunctionTable[355200] = bhDrawEff243_0x25ade0; // 0x25ae08 - g_ps2RecompiledFunctionTable[355211] = bhDrawEff243_0x25ade0; // 0x25ae34 - g_ps2RecompiledFunctionTable[355213] = bhDrawEff243_0x25ade0; // 0x25ae3c - g_ps2RecompiledFunctionTable[355216] = bhDrawEff243_0x25ade0; // 0x25ae48 - g_ps2RecompiledFunctionTable[355219] = bhDrawEff243_0x25ade0; // 0x25ae54 - g_ps2RecompiledFunctionTable[355221] = bhDrawEff243_0x25ade0; // 0x25ae5c - g_ps2RecompiledFunctionTable[355223] = bhDrawEff243_0x25ade0; // 0x25ae64 - g_ps2RecompiledFunctionTable[355226] = bhDrawEff243_0x25ade0; // 0x25ae70 - g_ps2RecompiledFunctionTable[355229] = bhDrawEff243_0x25ade0; // 0x25ae7c - g_ps2RecompiledFunctionTable[355232] = bhDrawEff243_0x25ade0; // 0x25ae88 - g_ps2RecompiledFunctionTable[355234] = bhDrawEff243_0x25ade0; // 0x25ae90 - g_ps2RecompiledFunctionTable[355238] = bhDrawEff243_0x25ade0; // 0x25aea0 - g_ps2RecompiledFunctionTable[355240] = bhDrawEff243_0x25ade0; // 0x25aea8 - g_ps2RecompiledFunctionTable[355243] = bhDrawEff243_0x25ade0; // 0x25aeb4 - g_ps2RecompiledFunctionTable[355246] = bhDrawEff243_0x25ade0; // 0x25aec0 - g_ps2RecompiledFunctionTable[355250] = bhEff244_0x25aed0; // 0x25aed0 - g_ps2RecompiledFunctionTable[355331] = bhEff244_0x25aed0; // 0x25b014 - g_ps2RecompiledFunctionTable[355345] = bhEff244_0x25aed0; // 0x25b04c - g_ps2RecompiledFunctionTable[355426] = bhEff245_0x25b190; // 0x25b190 - g_ps2RecompiledFunctionTable[355518] = bhEff245_0x25b190; // 0x25b300 - g_ps2RecompiledFunctionTable[355538] = bhEff246_0x25b350; // 0x25b350 - g_ps2RecompiledFunctionTable[355574] = bhEff246_0x25b350; // 0x25b3e0 - g_ps2RecompiledFunctionTable[355587] = bhEff246_0x25b350; // 0x25b414 - g_ps2RecompiledFunctionTable[355622] = bhEff246_0x25b350; // 0x25b4a0 - g_ps2RecompiledFunctionTable[355624] = bhEff246_0x25b350; // 0x25b4a8 - g_ps2RecompiledFunctionTable[355629] = bhEff246_0x25b350; // 0x25b4bc - g_ps2RecompiledFunctionTable[355633] = bhEff246_0x25b350; // 0x25b4cc - g_ps2RecompiledFunctionTable[355635] = bhEff246_0x25b350; // 0x25b4d4 - g_ps2RecompiledFunctionTable[355652] = bhEff246_0x25b350; // 0x25b518 - g_ps2RecompiledFunctionTable[355654] = bhEff246_0x25b350; // 0x25b520 - g_ps2RecompiledFunctionTable[355656] = bhEff246_0x25b350; // 0x25b528 - g_ps2RecompiledFunctionTable[355670] = bhEff246_0x25b350; // 0x25b560 - g_ps2RecompiledFunctionTable[355673] = bhEff246_0x25b350; // 0x25b56c - g_ps2RecompiledFunctionTable[355677] = bhEff246_0x25b350; // 0x25b57c - g_ps2RecompiledFunctionTable[355679] = bhEff246_0x25b350; // 0x25b584 - g_ps2RecompiledFunctionTable[355723] = bhEff246_0x25b350; // 0x25b634 - g_ps2RecompiledFunctionTable[355735] = bhEff246_0x25b350; // 0x25b664 - g_ps2RecompiledFunctionTable[355752] = bhEff246_0x25b350; // 0x25b6a8 - g_ps2RecompiledFunctionTable[355764] = bhEff246_0x25b350; // 0x25b6d8 - g_ps2RecompiledFunctionTable[355781] = bhEff246_0x25b350; // 0x25b71c - g_ps2RecompiledFunctionTable[355793] = bhEff246_0x25b350; // 0x25b74c - g_ps2RecompiledFunctionTable[355829] = bhEff246_0x25b350; // 0x25b7dc - g_ps2RecompiledFunctionTable[355841] = bhEff246_0x25b350; // 0x25b80c - g_ps2RecompiledFunctionTable[355858] = bhEff246_0x25b350; // 0x25b850 - g_ps2RecompiledFunctionTable[355870] = bhEff246_0x25b350; // 0x25b880 - g_ps2RecompiledFunctionTable[355887] = bhEff246_0x25b350; // 0x25b8c4 - g_ps2RecompiledFunctionTable[355899] = bhEff246_0x25b350; // 0x25b8f4 - g_ps2RecompiledFunctionTable[355951] = bhEff246_0x25b350; // 0x25b9c4 - g_ps2RecompiledFunctionTable[355964] = bhEff246_0x25b350; // 0x25b9f8 - g_ps2RecompiledFunctionTable[355983] = bhEff246_0x25b350; // 0x25ba44 - g_ps2RecompiledFunctionTable[355991] = bhEff246_0x25b350; // 0x25ba64 - g_ps2RecompiledFunctionTable[355993] = bhEff246_0x25b350; // 0x25ba6c - g_ps2RecompiledFunctionTable[355998] = bhEff246_0x25b350; // 0x25ba80 - g_ps2RecompiledFunctionTable[356000] = bhEff246_0x25b350; // 0x25ba88 - g_ps2RecompiledFunctionTable[356013] = bhEff246_0x25b350; // 0x25babc - g_ps2RecompiledFunctionTable[356016] = bhEff246_0x25b350; // 0x25bac8 - g_ps2RecompiledFunctionTable[356018] = bhEff246_0x25b350; // 0x25bad0 - g_ps2RecompiledFunctionTable[356025] = bhEff246_0x25b350; // 0x25baec - g_ps2RecompiledFunctionTable[356028] = bhEff246_0x25b350; // 0x25baf8 - g_ps2RecompiledFunctionTable[356032] = bhEff246_0x25b350; // 0x25bb08 - g_ps2RecompiledFunctionTable[356034] = bhEff246_0x25b350; // 0x25bb10 - g_ps2RecompiledFunctionTable[356039] = bhEff246_0x25b350; // 0x25bb24 - g_ps2RecompiledFunctionTable[356049] = bhEff246_0x25b350; // 0x25bb4c - g_ps2RecompiledFunctionTable[356057] = bhEff246_0x25b350; // 0x25bb6c - g_ps2RecompiledFunctionTable[356067] = bhEff246_0x25b350; // 0x25bb94 - g_ps2RecompiledFunctionTable[356075] = bhEff246_0x25b350; // 0x25bbb4 - g_ps2RecompiledFunctionTable[356088] = bhEff246_0x25b350; // 0x25bbe8 - g_ps2RecompiledFunctionTable[356202] = bhEff247_0x25bdb0; // 0x25bdb0 - g_ps2RecompiledFunctionTable[356260] = bhEff247_0x25bdb0; // 0x25be98 - g_ps2RecompiledFunctionTable[356278] = bhEff248_0x25bee0; // 0x25bee0 - g_ps2RecompiledFunctionTable[356310] = bhEff248_0x25bee0; // 0x25bf60 - g_ps2RecompiledFunctionTable[356313] = bhEff248_0x25bee0; // 0x25bf6c - g_ps2RecompiledFunctionTable[356320] = bhEff248_0x25bee0; // 0x25bf88 - g_ps2RecompiledFunctionTable[356323] = bhEff248_0x25bee0; // 0x25bf94 - g_ps2RecompiledFunctionTable[356333] = bhEff248_0x25bee0; // 0x25bfbc - g_ps2RecompiledFunctionTable[356336] = bhEff248_0x25bee0; // 0x25bfc8 - g_ps2RecompiledFunctionTable[356339] = bhEff248_0x25bee0; // 0x25bfd4 - g_ps2RecompiledFunctionTable[356341] = bhEff248_0x25bee0; // 0x25bfdc - g_ps2RecompiledFunctionTable[356345] = bhEff248_0x25bee0; // 0x25bfec - g_ps2RecompiledFunctionTable[356347] = bhEff248_0x25bee0; // 0x25bff4 - g_ps2RecompiledFunctionTable[356350] = bhEff248_0x25bee0; // 0x25c000 - g_ps2RecompiledFunctionTable[356378] = bhEff248_0x25bee0; // 0x25c070 - g_ps2RecompiledFunctionTable[356391] = bhEff248_0x25bee0; // 0x25c0a4 - g_ps2RecompiledFunctionTable[356402] = bhEff248_0x25bee0; // 0x25c0d0 - g_ps2RecompiledFunctionTable[356415] = bhEff248_0x25bee0; // 0x25c104 - g_ps2RecompiledFunctionTable[356420] = bhEff248_0x25bee0; // 0x25c118 - g_ps2RecompiledFunctionTable[356422] = bhEff248_0x25bee0; // 0x25c120 - g_ps2RecompiledFunctionTable[356435] = bhEff248_0x25bee0; // 0x25c154 - g_ps2RecompiledFunctionTable[356438] = bhEff248_0x25bee0; // 0x25c160 - g_ps2RecompiledFunctionTable[356440] = bhEff248_0x25bee0; // 0x25c168 - g_ps2RecompiledFunctionTable[356452] = bhEff248_0x25bee0; // 0x25c198 - g_ps2RecompiledFunctionTable[356465] = bhEff248_0x25bee0; // 0x25c1cc - g_ps2RecompiledFunctionTable[356468] = bhEff248_0x25bee0; // 0x25c1d8 - g_ps2RecompiledFunctionTable[356472] = bhEff248_0x25bee0; // 0x25c1e8 - g_ps2RecompiledFunctionTable[356474] = bhEff248_0x25bee0; // 0x25c1f0 - g_ps2RecompiledFunctionTable[356533] = bhEff248_0x25bee0; // 0x25c2dc - g_ps2RecompiledFunctionTable[356549] = bhEff248_0x25bee0; // 0x25c31c - g_ps2RecompiledFunctionTable[356562] = bhEff248_0x25bee0; // 0x25c350 - g_ps2RecompiledFunctionTable[356571] = bhEff248_0x25bee0; // 0x25c374 - g_ps2RecompiledFunctionTable[356573] = bhEff248_0x25bee0; // 0x25c37c - g_ps2RecompiledFunctionTable[356658] = bhEff249_0x25c4d0; // 0x25c4d0 - g_ps2RecompiledFunctionTable[356721] = bhEff249_0x25c4d0; // 0x25c5cc - g_ps2RecompiledFunctionTable[356724] = bhEff249_0x25c4d0; // 0x25c5d8 - g_ps2RecompiledFunctionTable[356726] = bhEff249_0x25c4d0; // 0x25c5e0 - g_ps2RecompiledFunctionTable[356730] = bhEff249_0x25c4d0; // 0x25c5f0 - g_ps2RecompiledFunctionTable[356732] = bhEff249_0x25c4d0; // 0x25c5f8 - g_ps2RecompiledFunctionTable[356735] = bhEff249_0x25c4d0; // 0x25c604 - g_ps2RecompiledFunctionTable[356743] = bhEff249_0x25c4d0; // 0x25c624 - g_ps2RecompiledFunctionTable[356746] = bhEff249_0x25c4d0; // 0x25c630 - g_ps2RecompiledFunctionTable[356748] = bhEff249_0x25c4d0; // 0x25c638 - g_ps2RecompiledFunctionTable[356752] = bhEff249_0x25c4d0; // 0x25c648 - g_ps2RecompiledFunctionTable[356754] = bhEff249_0x25c4d0; // 0x25c650 - g_ps2RecompiledFunctionTable[356757] = bhEff249_0x25c4d0; // 0x25c65c - g_ps2RecompiledFunctionTable[356773] = bhEff249_0x25c4d0; // 0x25c69c - g_ps2RecompiledFunctionTable[356775] = bhEff249_0x25c4d0; // 0x25c6a4 - g_ps2RecompiledFunctionTable[356780] = bhEff249_0x25c4d0; // 0x25c6b8 - g_ps2RecompiledFunctionTable[356784] = bhEff249_0x25c4d0; // 0x25c6c8 - g_ps2RecompiledFunctionTable[356786] = bhEff249_0x25c4d0; // 0x25c6d0 - g_ps2RecompiledFunctionTable[356926] = CreateEff5SnowRect_0x25c900; // 0x25c900 - g_ps2RecompiledFunctionTable[356934] = CreateEff5SnowRect_0x25c900; // 0x25c920 - g_ps2RecompiledFunctionTable[356968] = CreateEff5SnowRect_0x25c900; // 0x25c9a8 - g_ps2RecompiledFunctionTable[356970] = CreateEff5SnowRect_0x25c900; // 0x25c9b0 - g_ps2RecompiledFunctionTable[356976] = CreateEff5SnowRect_0x25c900; // 0x25c9c8 - g_ps2RecompiledFunctionTable[356998] = CreateEff5SnowRect_0x25c900; // 0x25ca20 - g_ps2RecompiledFunctionTable[357004] = CreateEff5SnowRect_0x25c900; // 0x25ca38 - g_ps2RecompiledFunctionTable[357010] = CreateEff5SnowRect_0x25c900; // 0x25ca50 - g_ps2RecompiledFunctionTable[357012] = CreateEff5SnowRect_0x25c900; // 0x25ca58 - g_ps2RecompiledFunctionTable[357030] = CreateEff5SnowRect_0x25c900; // 0x25caa0 - g_ps2RecompiledFunctionTable[357044] = CreateEff5SnowRect_0x25c900; // 0x25cad8 - g_ps2RecompiledFunctionTable[357078] = DeleteEff5SnowRect_0x25cb60; // 0x25cb60 - g_ps2RecompiledFunctionTable[357081] = DeleteEff5SnowRect_0x25cb60; // 0x25cb6c - g_ps2RecompiledFunctionTable[357094] = ExecEff5SnowRect_0x25cba0; // 0x25cba0 - g_ps2RecompiledFunctionTable[357143] = ExecEff5SnowRect_0x25cba0; // 0x25cc64 - g_ps2RecompiledFunctionTable[357163] = ExecEff5SnowRect_0x25cba0; // 0x25ccb4 - g_ps2RecompiledFunctionTable[357170] = ExecEff5SnowRect_0x25cba0; // 0x25ccd0 - g_ps2RecompiledFunctionTable[357200] = ExecEff5SnowRect_0x25cba0; // 0x25cd48 - g_ps2RecompiledFunctionTable[357215] = ExecEff5SnowRect_0x25cba0; // 0x25cd84 - g_ps2RecompiledFunctionTable[357230] = ExecEff5SnowRect_0x25cba0; // 0x25cdc0 - g_ps2RecompiledFunctionTable[357245] = ExecEff5SnowRect_0x25cba0; // 0x25cdfc - g_ps2RecompiledFunctionTable[357260] = ExecEff5SnowRect_0x25cba0; // 0x25ce38 - g_ps2RecompiledFunctionTable[357275] = ExecEff5SnowRect_0x25cba0; // 0x25ce74 - g_ps2RecompiledFunctionTable[357306] = DrawEff5SnowRect_0x25cef0; // 0x25cef0 - g_ps2RecompiledFunctionTable[357320] = DrawEff5SnowRect_0x25cef0; // 0x25cf28 - g_ps2RecompiledFunctionTable[357322] = DrawEff5SnowRect_0x25cef0; // 0x25cf30 - g_ps2RecompiledFunctionTable[357324] = DrawEff5SnowRect_0x25cef0; // 0x25cf38 - g_ps2RecompiledFunctionTable[357328] = DrawEff5SnowRect_0x25cef0; // 0x25cf48 - g_ps2RecompiledFunctionTable[357339] = DrawEff5SnowRect_0x25cef0; // 0x25cf74 - g_ps2RecompiledFunctionTable[357342] = DrawEff5SnowRect_0x25cef0; // 0x25cf80 - g_ps2RecompiledFunctionTable[357347] = DrawEff5SnowRect_0x25cef0; // 0x25cf94 - g_ps2RecompiledFunctionTable[357360] = DrawEff5SnowRect_0x25cef0; // 0x25cfc8 - g_ps2RecompiledFunctionTable[357362] = DrawEff5SnowRect_0x25cef0; // 0x25cfd0 - g_ps2RecompiledFunctionTable[357366] = DrawEff5SnowRect_0x25cef0; // 0x25cfe0 - g_ps2RecompiledFunctionTable[357372] = DrawEff5SnowRect_0x25cef0; // 0x25cff8 - g_ps2RecompiledFunctionTable[357375] = DrawEff5SnowRect_0x25cef0; // 0x25d004 - g_ps2RecompiledFunctionTable[357377] = DrawEff5SnowRect_0x25cef0; // 0x25d00c - g_ps2RecompiledFunctionTable[357379] = DrawEff5SnowRect_0x25cef0; // 0x25d014 - g_ps2RecompiledFunctionTable[357382] = DrawEff5SnowRect_0x25cef0; // 0x25d020 - g_ps2RecompiledFunctionTable[357386] = DrawEff5SnowRect_0x25cef0; // 0x25d030 - g_ps2RecompiledFunctionTable[357396] = DrawEff5SnowRect_0x25cef0; // 0x25d058 - g_ps2RecompiledFunctionTable[357409] = DrawEff5SnowRect_0x25cef0; // 0x25d08c - g_ps2RecompiledFunctionTable[357411] = DrawEff5SnowRect_0x25cef0; // 0x25d094 - g_ps2RecompiledFunctionTable[357415] = DrawEff5SnowRect_0x25cef0; // 0x25d0a4 - g_ps2RecompiledFunctionTable[357426] = DrawEff5SnowRect_0x25cef0; // 0x25d0d0 - g_ps2RecompiledFunctionTable[357429] = DrawEff5SnowRect_0x25cef0; // 0x25d0dc - g_ps2RecompiledFunctionTable[357431] = DrawEff5SnowRect_0x25cef0; // 0x25d0e4 - g_ps2RecompiledFunctionTable[357433] = DrawEff5SnowRect_0x25cef0; // 0x25d0ec - g_ps2RecompiledFunctionTable[357436] = DrawEff5SnowRect_0x25cef0; // 0x25d0f8 - g_ps2RecompiledFunctionTable[357447] = DrawEff5SnowRect_0x25cef0; // 0x25d124 - g_ps2RecompiledFunctionTable[357455] = DrawEff5SnowRect_0x25cef0; // 0x25d144 - g_ps2RecompiledFunctionTable[357459] = DrawEff5SnowRect_0x25cef0; // 0x25d154 - g_ps2RecompiledFunctionTable[357468] = DrawEff5SnowRect_0x25cef0; // 0x25d178 - g_ps2RecompiledFunctionTable[357482] = SetEff5SnowRectAreaCenter_0x25d1b0; // 0x25d1b0 - g_ps2RecompiledFunctionTable[357514] = SetEff5SnowRectAreaCenterAndSize_0x25d230; // 0x25d230 - g_ps2RecompiledFunctionTable[357538] = SetEff5SnowRectParticleMax_0x25d290; // 0x25d290 - g_ps2RecompiledFunctionTable[357554] = MovEff5SnowRectParticleMax_0x25d2d0; // 0x25d2d0 - g_ps2RecompiledFunctionTable[357574] = ArrangeEff5SnowRectParticle_0x25d320; // 0x25d320 - g_ps2RecompiledFunctionTable[357585] = ArrangeEff5SnowRectParticle_0x25d320; // 0x25d34c - g_ps2RecompiledFunctionTable[357588] = ArrangeEff5SnowRectParticle_0x25d320; // 0x25d358 - g_ps2RecompiledFunctionTable[357590] = ArrangeEff5SnowRectParticle_0x25d320; // 0x25d360 - g_ps2RecompiledFunctionTable[357602] = ArrangeEff5SnowRectParticle_0x25d320; // 0x25d390 - g_ps2RecompiledFunctionTable[357614] = ArrangeEff5SnowRectParticle_0x25d320; // 0x25d3c0 - g_ps2RecompiledFunctionTable[357642] = SetEff5SnowRectParticleTexture_0x25d430; // 0x25d430 - g_ps2RecompiledFunctionTable[357654] = SetEff5SnowRectParticleColor_0x25d460; // 0x25d460 - g_ps2RecompiledFunctionTable[357662] = SetEff5SnowRectParticleSize_0x25d480; // 0x25d480 - g_ps2RecompiledFunctionTable[357686] = GetEff5SnowRectCurrentWindVector_0x25d4e0; // 0x25d4e0 - g_ps2RecompiledFunctionTable[357696] = GetEff5SnowRectCurrentWindVector_0x25d4e0; // 0x25d508 - g_ps2RecompiledFunctionTable[357714] = GetEff5SnowRectCurrentWindVector_0x25d4e0; // 0x25d550 - g_ps2RecompiledFunctionTable[357730] = bhCheckWall_0x25d590; // 0x25d590 - g_ps2RecompiledFunctionTable[357731] = bhCheckWall_0x25d590; // 0x25d594 - g_ps2RecompiledFunctionTable[357732] = bhCheckWall_0x25d590; // 0x25d598 - g_ps2RecompiledFunctionTable[357733] = bhCheckWall_0x25d590; // 0x25d59c - g_ps2RecompiledFunctionTable[357734] = bhCheckWall_0x25d590; // 0x25d5a0 - g_ps2RecompiledFunctionTable[357735] = bhCheckWall_0x25d590; // 0x25d5a4 - g_ps2RecompiledFunctionTable[357736] = bhCheckWall_0x25d590; // 0x25d5a8 - g_ps2RecompiledFunctionTable[357737] = bhCheckWall_0x25d590; // 0x25d5ac - g_ps2RecompiledFunctionTable[357738] = bhCheckWall_0x25d590; // 0x25d5b0 - g_ps2RecompiledFunctionTable[357739] = bhCheckWall_0x25d590; // 0x25d5b4 - g_ps2RecompiledFunctionTable[357740] = bhCheckWall_0x25d590; // 0x25d5b8 - g_ps2RecompiledFunctionTable[357741] = bhCheckWall_0x25d590; // 0x25d5bc - g_ps2RecompiledFunctionTable[357742] = bhCheckWall_0x25d590; // 0x25d5c0 - g_ps2RecompiledFunctionTable[357743] = bhCheckWall_0x25d590; // 0x25d5c4 - g_ps2RecompiledFunctionTable[357744] = bhCheckWall_0x25d590; // 0x25d5c8 - g_ps2RecompiledFunctionTable[357745] = bhCheckWall_0x25d590; // 0x25d5cc - g_ps2RecompiledFunctionTable[357746] = bhCheckWall_0x25d590; // 0x25d5d0 - g_ps2RecompiledFunctionTable[357747] = bhCheckWall_0x25d590; // 0x25d5d4 - g_ps2RecompiledFunctionTable[357748] = bhCheckWall_0x25d590; // 0x25d5d8 - g_ps2RecompiledFunctionTable[357749] = bhCheckWall_0x25d590; // 0x25d5dc - g_ps2RecompiledFunctionTable[357750] = bhCheckWall_0x25d590; // 0x25d5e0 - g_ps2RecompiledFunctionTable[357751] = bhCheckWall_0x25d590; // 0x25d5e4 - g_ps2RecompiledFunctionTable[357752] = bhCheckWall_0x25d590; // 0x25d5e8 - g_ps2RecompiledFunctionTable[357753] = bhCheckWall_0x25d590; // 0x25d5ec - g_ps2RecompiledFunctionTable[357754] = bhCheckWall_0x25d590; // 0x25d5f0 - g_ps2RecompiledFunctionTable[357755] = bhCheckWall_0x25d590; // 0x25d5f4 - g_ps2RecompiledFunctionTable[357756] = bhCheckWall_0x25d590; // 0x25d5f8 - g_ps2RecompiledFunctionTable[357757] = bhCheckWall_0x25d590; // 0x25d5fc - g_ps2RecompiledFunctionTable[357758] = bhCheckWall_0x25d590; // 0x25d600 - g_ps2RecompiledFunctionTable[357759] = bhCheckWall_0x25d590; // 0x25d604 - g_ps2RecompiledFunctionTable[357760] = bhCheckWall_0x25d590; // 0x25d608 - g_ps2RecompiledFunctionTable[357761] = bhCheckWall_0x25d590; // 0x25d60c - g_ps2RecompiledFunctionTable[357762] = bhCheckWall_0x25d590; // 0x25d610 - g_ps2RecompiledFunctionTable[357763] = bhCheckWall_0x25d590; // 0x25d614 - g_ps2RecompiledFunctionTable[357764] = bhCheckWall_0x25d590; // 0x25d618 - g_ps2RecompiledFunctionTable[357765] = bhCheckWall_0x25d590; // 0x25d61c - g_ps2RecompiledFunctionTable[357766] = bhCheckWall_0x25d590; // 0x25d620 - g_ps2RecompiledFunctionTable[357767] = bhCheckWall_0x25d590; // 0x25d624 - g_ps2RecompiledFunctionTable[357768] = bhCheckWall_0x25d590; // 0x25d628 - g_ps2RecompiledFunctionTable[357769] = bhCheckWall_0x25d590; // 0x25d62c - g_ps2RecompiledFunctionTable[357770] = bhCheckWall_0x25d590; // 0x25d630 - g_ps2RecompiledFunctionTable[357771] = bhCheckWall_0x25d590; // 0x25d634 - g_ps2RecompiledFunctionTable[357772] = bhCheckWall_0x25d590; // 0x25d638 - g_ps2RecompiledFunctionTable[357773] = bhCheckWall_0x25d590; // 0x25d63c - g_ps2RecompiledFunctionTable[357774] = bhCheckWall_0x25d590; // 0x25d640 - g_ps2RecompiledFunctionTable[357775] = bhCheckWall_0x25d590; // 0x25d644 - g_ps2RecompiledFunctionTable[357776] = bhCheckWall_0x25d590; // 0x25d648 - g_ps2RecompiledFunctionTable[357777] = bhCheckWall_0x25d590; // 0x25d64c - g_ps2RecompiledFunctionTable[357778] = bhCheckWall_0x25d590; // 0x25d650 - g_ps2RecompiledFunctionTable[357779] = bhCheckWall_0x25d590; // 0x25d654 - g_ps2RecompiledFunctionTable[357780] = bhCheckWall_0x25d590; // 0x25d658 - g_ps2RecompiledFunctionTable[357781] = bhCheckWall_0x25d590; // 0x25d65c - g_ps2RecompiledFunctionTable[357782] = bhCheckWall_0x25d590; // 0x25d660 - g_ps2RecompiledFunctionTable[357783] = bhCheckWall_0x25d590; // 0x25d664 - g_ps2RecompiledFunctionTable[357784] = bhCheckWall_0x25d590; // 0x25d668 - g_ps2RecompiledFunctionTable[357785] = bhCheckWall_0x25d590; // 0x25d66c - g_ps2RecompiledFunctionTable[357786] = bhCheckWall_0x25d590; // 0x25d670 - g_ps2RecompiledFunctionTable[357787] = bhCheckWall_0x25d590; // 0x25d674 - g_ps2RecompiledFunctionTable[357788] = bhCheckWall_0x25d590; // 0x25d678 - g_ps2RecompiledFunctionTable[357789] = bhCheckWall_0x25d590; // 0x25d67c - g_ps2RecompiledFunctionTable[357790] = bhCheckWall_0x25d590; // 0x25d680 - g_ps2RecompiledFunctionTable[357791] = bhCheckWall_0x25d590; // 0x25d684 - g_ps2RecompiledFunctionTable[357792] = bhCheckWall_0x25d590; // 0x25d688 - g_ps2RecompiledFunctionTable[357793] = bhCheckWall_0x25d590; // 0x25d68c - g_ps2RecompiledFunctionTable[357794] = bhCheckWall_0x25d590; // 0x25d690 - g_ps2RecompiledFunctionTable[357795] = bhCheckWall_0x25d590; // 0x25d694 - g_ps2RecompiledFunctionTable[357796] = bhCheckWall_0x25d590; // 0x25d698 - g_ps2RecompiledFunctionTable[357797] = bhCheckWall_0x25d590; // 0x25d69c - g_ps2RecompiledFunctionTable[357798] = bhCheckWall_0x25d590; // 0x25d6a0 - g_ps2RecompiledFunctionTable[357799] = bhCheckWall_0x25d590; // 0x25d6a4 - g_ps2RecompiledFunctionTable[357800] = bhCheckWall_0x25d590; // 0x25d6a8 - g_ps2RecompiledFunctionTable[357801] = bhCheckWall_0x25d590; // 0x25d6ac - g_ps2RecompiledFunctionTable[357802] = bhCheckWall_0x25d590; // 0x25d6b0 - g_ps2RecompiledFunctionTable[357803] = bhCheckWall_0x25d590; // 0x25d6b4 - g_ps2RecompiledFunctionTable[357804] = bhCheckWall_0x25d590; // 0x25d6b8 - g_ps2RecompiledFunctionTable[357805] = bhCheckWall_0x25d590; // 0x25d6bc - g_ps2RecompiledFunctionTable[357806] = bhCheckWall_0x25d590; // 0x25d6c0 - g_ps2RecompiledFunctionTable[357807] = bhCheckWall_0x25d590; // 0x25d6c4 - g_ps2RecompiledFunctionTable[357808] = bhCheckWall_0x25d590; // 0x25d6c8 - g_ps2RecompiledFunctionTable[357809] = bhCheckWall_0x25d590; // 0x25d6cc - g_ps2RecompiledFunctionTable[357810] = bhCheckWall_0x25d590; // 0x25d6d0 - g_ps2RecompiledFunctionTable[357811] = bhCheckWall_0x25d590; // 0x25d6d4 - g_ps2RecompiledFunctionTable[357812] = bhCheckWall_0x25d590; // 0x25d6d8 - g_ps2RecompiledFunctionTable[357813] = bhCheckWall_0x25d590; // 0x25d6dc - g_ps2RecompiledFunctionTable[357814] = bhCheckWall_0x25d590; // 0x25d6e0 - g_ps2RecompiledFunctionTable[357815] = bhCheckWall_0x25d590; // 0x25d6e4 - g_ps2RecompiledFunctionTable[357816] = bhCheckWall_0x25d590; // 0x25d6e8 - g_ps2RecompiledFunctionTable[357817] = bhCheckWall_0x25d590; // 0x25d6ec - g_ps2RecompiledFunctionTable[357818] = bhCheckWall_0x25d590; // 0x25d6f0 - g_ps2RecompiledFunctionTable[357819] = bhCheckWall_0x25d590; // 0x25d6f4 - g_ps2RecompiledFunctionTable[357820] = bhCheckWall_0x25d590; // 0x25d6f8 - g_ps2RecompiledFunctionTable[357821] = bhCheckWall_0x25d590; // 0x25d6fc - g_ps2RecompiledFunctionTable[357822] = bhCheckWall_0x25d590; // 0x25d700 - g_ps2RecompiledFunctionTable[357823] = bhCheckWall_0x25d590; // 0x25d704 - g_ps2RecompiledFunctionTable[357824] = bhCheckWall_0x25d590; // 0x25d708 - g_ps2RecompiledFunctionTable[357825] = bhCheckWall_0x25d590; // 0x25d70c - g_ps2RecompiledFunctionTable[357826] = bhCheckWall_0x25d590; // 0x25d710 - g_ps2RecompiledFunctionTable[357827] = bhCheckWall_0x25d590; // 0x25d714 - g_ps2RecompiledFunctionTable[357828] = bhCheckWall_0x25d590; // 0x25d718 - g_ps2RecompiledFunctionTable[357829] = bhCheckWall_0x25d590; // 0x25d71c - g_ps2RecompiledFunctionTable[357830] = bhCheckWall_0x25d590; // 0x25d720 - g_ps2RecompiledFunctionTable[357831] = bhCheckWall_0x25d590; // 0x25d724 - g_ps2RecompiledFunctionTable[357832] = bhCheckWall_0x25d590; // 0x25d728 - g_ps2RecompiledFunctionTable[357833] = bhCheckWall_0x25d590; // 0x25d72c - g_ps2RecompiledFunctionTable[357834] = bhCheckWall_0x25d590; // 0x25d730 - g_ps2RecompiledFunctionTable[357835] = bhCheckWall_0x25d590; // 0x25d734 - g_ps2RecompiledFunctionTable[357836] = bhCheckWall_0x25d590; // 0x25d738 - g_ps2RecompiledFunctionTable[357837] = bhCheckWall_0x25d590; // 0x25d73c - g_ps2RecompiledFunctionTable[357838] = bhCheckWall_0x25d590; // 0x25d740 - g_ps2RecompiledFunctionTable[357839] = bhCheckWall_0x25d590; // 0x25d744 - g_ps2RecompiledFunctionTable[357840] = bhCheckWall_0x25d590; // 0x25d748 - g_ps2RecompiledFunctionTable[357841] = bhCheckWall_0x25d590; // 0x25d74c - g_ps2RecompiledFunctionTable[357842] = bhCheckWall_0x25d590; // 0x25d750 - g_ps2RecompiledFunctionTable[357843] = bhCheckWall_0x25d590; // 0x25d754 - g_ps2RecompiledFunctionTable[357844] = bhCheckWall_0x25d590; // 0x25d758 - g_ps2RecompiledFunctionTable[357845] = bhCheckWall_0x25d590; // 0x25d75c - g_ps2RecompiledFunctionTable[357846] = bhCheckWall_0x25d590; // 0x25d760 - g_ps2RecompiledFunctionTable[357847] = bhCheckWall_0x25d590; // 0x25d764 - g_ps2RecompiledFunctionTable[357848] = bhCheckWall_0x25d590; // 0x25d768 - g_ps2RecompiledFunctionTable[357849] = bhCheckWall_0x25d590; // 0x25d76c - g_ps2RecompiledFunctionTable[357850] = bhCheckWall_0x25d590; // 0x25d770 - g_ps2RecompiledFunctionTable[357851] = bhCheckWall_0x25d590; // 0x25d774 - g_ps2RecompiledFunctionTable[357852] = bhCheckWall_0x25d590; // 0x25d778 - g_ps2RecompiledFunctionTable[357853] = bhCheckWall_0x25d590; // 0x25d77c - g_ps2RecompiledFunctionTable[357854] = bhCheckWall_0x25d590; // 0x25d780 - g_ps2RecompiledFunctionTable[357855] = bhCheckWall_0x25d590; // 0x25d784 - g_ps2RecompiledFunctionTable[357856] = bhCheckWall_0x25d590; // 0x25d788 - g_ps2RecompiledFunctionTable[357857] = bhCheckWall_0x25d590; // 0x25d78c - g_ps2RecompiledFunctionTable[357858] = bhCheckWall_0x25d590; // 0x25d790 - g_ps2RecompiledFunctionTable[357859] = bhCheckWall_0x25d590; // 0x25d794 - g_ps2RecompiledFunctionTable[357860] = bhCheckWall_0x25d590; // 0x25d798 - g_ps2RecompiledFunctionTable[357861] = bhCheckWall_0x25d590; // 0x25d79c - g_ps2RecompiledFunctionTable[357862] = bhCheckWall_0x25d590; // 0x25d7a0 - g_ps2RecompiledFunctionTable[357863] = bhCheckWall_0x25d590; // 0x25d7a4 - g_ps2RecompiledFunctionTable[357864] = bhCheckWall_0x25d590; // 0x25d7a8 - g_ps2RecompiledFunctionTable[357865] = bhCheckWall_0x25d590; // 0x25d7ac - g_ps2RecompiledFunctionTable[357866] = bhCheckWall_0x25d590; // 0x25d7b0 - g_ps2RecompiledFunctionTable[357867] = bhCheckWall_0x25d590; // 0x25d7b4 - g_ps2RecompiledFunctionTable[357868] = bhCheckWall_0x25d590; // 0x25d7b8 - g_ps2RecompiledFunctionTable[357869] = bhCheckWall_0x25d590; // 0x25d7bc - g_ps2RecompiledFunctionTable[357870] = bhCheckWall_0x25d590; // 0x25d7c0 - g_ps2RecompiledFunctionTable[357871] = bhCheckWall_0x25d590; // 0x25d7c4 - g_ps2RecompiledFunctionTable[357872] = bhCheckWall_0x25d590; // 0x25d7c8 - g_ps2RecompiledFunctionTable[357873] = bhCheckWall_0x25d590; // 0x25d7cc - g_ps2RecompiledFunctionTable[357874] = bhCheckWall_0x25d590; // 0x25d7d0 - g_ps2RecompiledFunctionTable[357875] = bhCheckWall_0x25d590; // 0x25d7d4 - g_ps2RecompiledFunctionTable[357876] = bhCheckWall_0x25d590; // 0x25d7d8 - g_ps2RecompiledFunctionTable[357877] = bhCheckWall_0x25d590; // 0x25d7dc - g_ps2RecompiledFunctionTable[357878] = bhCheckWall_0x25d590; // 0x25d7e0 - g_ps2RecompiledFunctionTable[357879] = bhCheckWall_0x25d590; // 0x25d7e4 - g_ps2RecompiledFunctionTable[357880] = bhCheckWall_0x25d590; // 0x25d7e8 - g_ps2RecompiledFunctionTable[357881] = bhCheckWall_0x25d590; // 0x25d7ec - g_ps2RecompiledFunctionTable[357882] = bhCheckWall_0x25d590; // 0x25d7f0 - g_ps2RecompiledFunctionTable[357883] = bhCheckWall_0x25d590; // 0x25d7f4 - g_ps2RecompiledFunctionTable[357884] = bhCheckWall_0x25d590; // 0x25d7f8 - g_ps2RecompiledFunctionTable[357885] = bhCheckWall_0x25d590; // 0x25d7fc - g_ps2RecompiledFunctionTable[357886] = bhCheckWall_0x25d590; // 0x25d800 - g_ps2RecompiledFunctionTable[357887] = bhCheckWall_0x25d590; // 0x25d804 - g_ps2RecompiledFunctionTable[357888] = bhCheckWall_0x25d590; // 0x25d808 - g_ps2RecompiledFunctionTable[357889] = bhCheckWall_0x25d590; // 0x25d80c - g_ps2RecompiledFunctionTable[357890] = bhCheckWall_0x25d590; // 0x25d810 - g_ps2RecompiledFunctionTable[357891] = bhCheckWall_0x25d590; // 0x25d814 - g_ps2RecompiledFunctionTable[357892] = bhCheckWall_0x25d590; // 0x25d818 - g_ps2RecompiledFunctionTable[357893] = bhCheckWall_0x25d590; // 0x25d81c - g_ps2RecompiledFunctionTable[357894] = bhCheckWall_0x25d590; // 0x25d820 - g_ps2RecompiledFunctionTable[357895] = bhCheckWall_0x25d590; // 0x25d824 - g_ps2RecompiledFunctionTable[357896] = bhCheckWall_0x25d590; // 0x25d828 - g_ps2RecompiledFunctionTable[357897] = bhCheckWall_0x25d590; // 0x25d82c - g_ps2RecompiledFunctionTable[357898] = bhCheckWall_0x25d590; // 0x25d830 - g_ps2RecompiledFunctionTable[357899] = bhCheckWall_0x25d590; // 0x25d834 - g_ps2RecompiledFunctionTable[357900] = bhCheckWall_0x25d590; // 0x25d838 - g_ps2RecompiledFunctionTable[357901] = bhCheckWall_0x25d590; // 0x25d83c - g_ps2RecompiledFunctionTable[357902] = bhCheckWall_0x25d590; // 0x25d840 - g_ps2RecompiledFunctionTable[357903] = bhCheckWall_0x25d590; // 0x25d844 - g_ps2RecompiledFunctionTable[357904] = bhCheckWall_0x25d590; // 0x25d848 - g_ps2RecompiledFunctionTable[357905] = bhCheckWall_0x25d590; // 0x25d84c - g_ps2RecompiledFunctionTable[357906] = bhCheckWall_0x25d590; // 0x25d850 - g_ps2RecompiledFunctionTable[357907] = bhCheckWall_0x25d590; // 0x25d854 - g_ps2RecompiledFunctionTable[357908] = bhCheckWall_0x25d590; // 0x25d858 - g_ps2RecompiledFunctionTable[357909] = bhCheckWall_0x25d590; // 0x25d85c - g_ps2RecompiledFunctionTable[357910] = bhCheckWall_0x25d590; // 0x25d860 - g_ps2RecompiledFunctionTable[357911] = bhCheckWall_0x25d590; // 0x25d864 - g_ps2RecompiledFunctionTable[357912] = bhCheckWall_0x25d590; // 0x25d868 - g_ps2RecompiledFunctionTable[357913] = bhCheckWall_0x25d590; // 0x25d86c - g_ps2RecompiledFunctionTable[357914] = bhCheckWall_0x25d590; // 0x25d870 - g_ps2RecompiledFunctionTable[357915] = bhCheckWall_0x25d590; // 0x25d874 - g_ps2RecompiledFunctionTable[357916] = bhCheckWall_0x25d590; // 0x25d878 - g_ps2RecompiledFunctionTable[357917] = bhCheckWall_0x25d590; // 0x25d87c - g_ps2RecompiledFunctionTable[357918] = bhCheckWall_0x25d590; // 0x25d880 - g_ps2RecompiledFunctionTable[357919] = bhCheckWall_0x25d590; // 0x25d884 - g_ps2RecompiledFunctionTable[357920] = bhCheckWall_0x25d590; // 0x25d888 - g_ps2RecompiledFunctionTable[357921] = bhCheckWall_0x25d590; // 0x25d88c - g_ps2RecompiledFunctionTable[357922] = bhCheckWall_0x25d590; // 0x25d890 - g_ps2RecompiledFunctionTable[357923] = bhCheckWall_0x25d590; // 0x25d894 - g_ps2RecompiledFunctionTable[357924] = bhCheckWall_0x25d590; // 0x25d898 - g_ps2RecompiledFunctionTable[357925] = bhCheckWall_0x25d590; // 0x25d89c - g_ps2RecompiledFunctionTable[357926] = bhCheckWall_0x25d590; // 0x25d8a0 - g_ps2RecompiledFunctionTable[357927] = bhCheckWall_0x25d590; // 0x25d8a4 - g_ps2RecompiledFunctionTable[357928] = bhCheckWall_0x25d590; // 0x25d8a8 - g_ps2RecompiledFunctionTable[357929] = bhCheckWall_0x25d590; // 0x25d8ac - g_ps2RecompiledFunctionTable[357930] = bhCheckWall_0x25d590; // 0x25d8b0 - g_ps2RecompiledFunctionTable[357931] = bhCheckWall_0x25d590; // 0x25d8b4 - g_ps2RecompiledFunctionTable[357932] = bhCheckWall_0x25d590; // 0x25d8b8 - g_ps2RecompiledFunctionTable[357933] = bhCheckWall_0x25d590; // 0x25d8bc - g_ps2RecompiledFunctionTable[357934] = bhCheckWall_0x25d590; // 0x25d8c0 - g_ps2RecompiledFunctionTable[357935] = bhCheckWall_0x25d590; // 0x25d8c4 - g_ps2RecompiledFunctionTable[357936] = bhCheckWall_0x25d590; // 0x25d8c8 - g_ps2RecompiledFunctionTable[357937] = bhCheckWall_0x25d590; // 0x25d8cc - g_ps2RecompiledFunctionTable[357938] = bhCheckWall_0x25d590; // 0x25d8d0 - g_ps2RecompiledFunctionTable[357939] = bhCheckWall_0x25d590; // 0x25d8d4 - g_ps2RecompiledFunctionTable[357940] = bhCheckWall_0x25d590; // 0x25d8d8 - g_ps2RecompiledFunctionTable[357941] = bhCheckWall_0x25d590; // 0x25d8dc - g_ps2RecompiledFunctionTable[357942] = bhCheckWall_0x25d590; // 0x25d8e0 - g_ps2RecompiledFunctionTable[357943] = bhCheckWall_0x25d590; // 0x25d8e4 - g_ps2RecompiledFunctionTable[357944] = bhCheckWall_0x25d590; // 0x25d8e8 - g_ps2RecompiledFunctionTable[357945] = bhCheckWall_0x25d590; // 0x25d8ec - g_ps2RecompiledFunctionTable[357946] = bhCheckWall_0x25d590; // 0x25d8f0 - g_ps2RecompiledFunctionTable[357947] = bhCheckWall_0x25d590; // 0x25d8f4 - g_ps2RecompiledFunctionTable[357948] = bhCheckWall_0x25d590; // 0x25d8f8 - g_ps2RecompiledFunctionTable[357949] = bhCheckWall_0x25d590; // 0x25d8fc - g_ps2RecompiledFunctionTable[357950] = bhCheckWall_0x25d590; // 0x25d900 - g_ps2RecompiledFunctionTable[357951] = bhCheckWall_0x25d590; // 0x25d904 - g_ps2RecompiledFunctionTable[357952] = bhCheckWall_0x25d590; // 0x25d908 - g_ps2RecompiledFunctionTable[357953] = bhCheckWall_0x25d590; // 0x25d90c - g_ps2RecompiledFunctionTable[357954] = bhCheckWall_0x25d590; // 0x25d910 - g_ps2RecompiledFunctionTable[357955] = bhCheckWall_0x25d590; // 0x25d914 - g_ps2RecompiledFunctionTable[357956] = bhCheckWall_0x25d590; // 0x25d918 - g_ps2RecompiledFunctionTable[357957] = bhCheckWall_0x25d590; // 0x25d91c - g_ps2RecompiledFunctionTable[357958] = bhCheckWall_0x25d590; // 0x25d920 - g_ps2RecompiledFunctionTable[357959] = bhCheckWall_0x25d590; // 0x25d924 - g_ps2RecompiledFunctionTable[357960] = bhCheckWall_0x25d590; // 0x25d928 - g_ps2RecompiledFunctionTable[357961] = bhCheckWall_0x25d590; // 0x25d92c - g_ps2RecompiledFunctionTable[357962] = bhCheckWall_0x25d590; // 0x25d930 - g_ps2RecompiledFunctionTable[357963] = bhCheckWall_0x25d590; // 0x25d934 - g_ps2RecompiledFunctionTable[357964] = bhCheckWall_0x25d590; // 0x25d938 - g_ps2RecompiledFunctionTable[357965] = bhCheckWall_0x25d590; // 0x25d93c - g_ps2RecompiledFunctionTable[357966] = bhCheckWall_0x25d590; // 0x25d940 - g_ps2RecompiledFunctionTable[357967] = bhCheckWall_0x25d590; // 0x25d944 - g_ps2RecompiledFunctionTable[357968] = bhCheckWall_0x25d590; // 0x25d948 - g_ps2RecompiledFunctionTable[357969] = bhCheckWall_0x25d590; // 0x25d94c - g_ps2RecompiledFunctionTable[357970] = bhCheckWall_0x25d590; // 0x25d950 - g_ps2RecompiledFunctionTable[357971] = bhCheckWall_0x25d590; // 0x25d954 - g_ps2RecompiledFunctionTable[357972] = bhCheckWall_0x25d590; // 0x25d958 - g_ps2RecompiledFunctionTable[357973] = bhCheckWall_0x25d590; // 0x25d95c - g_ps2RecompiledFunctionTable[357974] = bhCheckWall_0x25d590; // 0x25d960 - g_ps2RecompiledFunctionTable[357975] = bhCheckWall_0x25d590; // 0x25d964 - g_ps2RecompiledFunctionTable[357976] = bhCheckWall_0x25d590; // 0x25d968 - g_ps2RecompiledFunctionTable[357977] = bhCheckWall_0x25d590; // 0x25d96c - g_ps2RecompiledFunctionTable[357978] = bhCheckWall_0x25d590; // 0x25d970 - g_ps2RecompiledFunctionTable[357979] = bhCheckWall_0x25d590; // 0x25d974 - g_ps2RecompiledFunctionTable[357980] = bhCheckWall_0x25d590; // 0x25d978 - g_ps2RecompiledFunctionTable[357981] = bhCheckWall_0x25d590; // 0x25d97c - g_ps2RecompiledFunctionTable[357982] = bhCheckWall_0x25d590; // 0x25d980 - g_ps2RecompiledFunctionTable[357983] = bhCheckWall_0x25d590; // 0x25d984 - g_ps2RecompiledFunctionTable[357984] = bhCheckWall_0x25d590; // 0x25d988 - g_ps2RecompiledFunctionTable[357985] = bhCheckWall_0x25d590; // 0x25d98c - g_ps2RecompiledFunctionTable[357986] = bhCheckWall_0x25d590; // 0x25d990 - g_ps2RecompiledFunctionTable[357987] = bhCheckWall_0x25d590; // 0x25d994 - g_ps2RecompiledFunctionTable[357988] = bhCheckWall_0x25d590; // 0x25d998 - g_ps2RecompiledFunctionTable[357989] = bhCheckWall_0x25d590; // 0x25d99c - g_ps2RecompiledFunctionTable[357990] = bhCheckWall_0x25d590; // 0x25d9a0 - g_ps2RecompiledFunctionTable[357991] = bhCheckWall_0x25d590; // 0x25d9a4 - g_ps2RecompiledFunctionTable[357992] = bhCheckWall_0x25d590; // 0x25d9a8 - g_ps2RecompiledFunctionTable[357993] = bhCheckWall_0x25d590; // 0x25d9ac - g_ps2RecompiledFunctionTable[357994] = bhCheckWall_0x25d590; // 0x25d9b0 - g_ps2RecompiledFunctionTable[357995] = bhCheckWall_0x25d590; // 0x25d9b4 - g_ps2RecompiledFunctionTable[357996] = bhCheckWall_0x25d590; // 0x25d9b8 - g_ps2RecompiledFunctionTable[357997] = bhCheckWall_0x25d590; // 0x25d9bc - g_ps2RecompiledFunctionTable[357998] = bhCheckWall_0x25d590; // 0x25d9c0 - g_ps2RecompiledFunctionTable[357999] = bhCheckWall_0x25d590; // 0x25d9c4 - g_ps2RecompiledFunctionTable[358000] = bhCheckWall_0x25d590; // 0x25d9c8 - g_ps2RecompiledFunctionTable[358001] = bhCheckWall_0x25d590; // 0x25d9cc - g_ps2RecompiledFunctionTable[358002] = bhCheckWall_0x25d590; // 0x25d9d0 - g_ps2RecompiledFunctionTable[358003] = bhCheckWall_0x25d590; // 0x25d9d4 - g_ps2RecompiledFunctionTable[358004] = bhCheckWall_0x25d590; // 0x25d9d8 - g_ps2RecompiledFunctionTable[358005] = bhCheckWall_0x25d590; // 0x25d9dc - g_ps2RecompiledFunctionTable[358006] = bhCheckWall_0x25d590; // 0x25d9e0 - g_ps2RecompiledFunctionTable[358007] = bhCheckWall_0x25d590; // 0x25d9e4 - g_ps2RecompiledFunctionTable[358008] = bhCheckWall_0x25d590; // 0x25d9e8 - g_ps2RecompiledFunctionTable[358009] = bhCheckWall_0x25d590; // 0x25d9ec - g_ps2RecompiledFunctionTable[358010] = bhCheckWall_0x25d590; // 0x25d9f0 - g_ps2RecompiledFunctionTable[358011] = bhCheckWall_0x25d590; // 0x25d9f4 - g_ps2RecompiledFunctionTable[358012] = bhCheckWall_0x25d590; // 0x25d9f8 - g_ps2RecompiledFunctionTable[358013] = bhCheckWall_0x25d590; // 0x25d9fc - g_ps2RecompiledFunctionTable[358014] = bhCheckWall_0x25d590; // 0x25da00 - g_ps2RecompiledFunctionTable[358015] = bhCheckWall_0x25d590; // 0x25da04 - g_ps2RecompiledFunctionTable[358016] = bhCheckWall_0x25d590; // 0x25da08 - g_ps2RecompiledFunctionTable[358017] = bhCheckWall_0x25d590; // 0x25da0c - g_ps2RecompiledFunctionTable[358018] = bhCheckWall_0x25d590; // 0x25da10 - g_ps2RecompiledFunctionTable[358019] = bhCheckWall_0x25d590; // 0x25da14 - g_ps2RecompiledFunctionTable[358020] = bhCheckWall_0x25d590; // 0x25da18 - g_ps2RecompiledFunctionTable[358021] = bhCheckWall_0x25d590; // 0x25da1c - g_ps2RecompiledFunctionTable[358022] = bhCheckWall_0x25d590; // 0x25da20 - g_ps2RecompiledFunctionTable[358023] = bhCheckWall_0x25d590; // 0x25da24 - g_ps2RecompiledFunctionTable[358024] = bhCheckWall_0x25d590; // 0x25da28 - g_ps2RecompiledFunctionTable[358025] = bhCheckWall_0x25d590; // 0x25da2c - g_ps2RecompiledFunctionTable[358026] = bhCheckWall_0x25d590; // 0x25da30 - g_ps2RecompiledFunctionTable[358027] = bhCheckWall_0x25d590; // 0x25da34 - g_ps2RecompiledFunctionTable[358028] = bhCheckWall_0x25d590; // 0x25da38 - g_ps2RecompiledFunctionTable[358029] = bhCheckWall_0x25d590; // 0x25da3c - g_ps2RecompiledFunctionTable[358030] = bhCheckWall_0x25d590; // 0x25da40 - g_ps2RecompiledFunctionTable[358031] = bhCheckWall_0x25d590; // 0x25da44 - g_ps2RecompiledFunctionTable[358032] = bhCheckWall_0x25d590; // 0x25da48 - g_ps2RecompiledFunctionTable[358033] = bhCheckWall_0x25d590; // 0x25da4c - g_ps2RecompiledFunctionTable[358034] = bhCheckWall_0x25d590; // 0x25da50 - g_ps2RecompiledFunctionTable[358035] = bhCheckWall_0x25d590; // 0x25da54 - g_ps2RecompiledFunctionTable[358036] = bhCheckWall_0x25d590; // 0x25da58 - g_ps2RecompiledFunctionTable[358037] = bhCheckWall_0x25d590; // 0x25da5c - g_ps2RecompiledFunctionTable[358038] = bhCheckWall_0x25d590; // 0x25da60 - g_ps2RecompiledFunctionTable[358039] = bhCheckWall_0x25d590; // 0x25da64 - g_ps2RecompiledFunctionTable[358040] = bhCheckWall_0x25d590; // 0x25da68 - g_ps2RecompiledFunctionTable[358041] = bhCheckWall_0x25d590; // 0x25da6c - g_ps2RecompiledFunctionTable[358042] = bhCheckWall_0x25d590; // 0x25da70 - g_ps2RecompiledFunctionTable[358043] = bhCheckWall_0x25d590; // 0x25da74 - g_ps2RecompiledFunctionTable[358044] = bhCheckWall_0x25d590; // 0x25da78 - g_ps2RecompiledFunctionTable[358045] = bhCheckWall_0x25d590; // 0x25da7c - g_ps2RecompiledFunctionTable[358046] = bhCheckWall_0x25d590; // 0x25da80 - g_ps2RecompiledFunctionTable[358047] = bhCheckWall_0x25d590; // 0x25da84 - g_ps2RecompiledFunctionTable[358048] = bhCheckWall_0x25d590; // 0x25da88 - g_ps2RecompiledFunctionTable[358049] = bhCheckWall_0x25d590; // 0x25da8c - g_ps2RecompiledFunctionTable[358050] = bhCheckWall_0x25d590; // 0x25da90 - g_ps2RecompiledFunctionTable[358051] = bhCheckWall_0x25d590; // 0x25da94 - g_ps2RecompiledFunctionTable[358052] = bhCheckWall_0x25d590; // 0x25da98 - g_ps2RecompiledFunctionTable[358053] = bhCheckWall_0x25d590; // 0x25da9c - g_ps2RecompiledFunctionTable[358054] = bhCheckWall_0x25d590; // 0x25daa0 - g_ps2RecompiledFunctionTable[358055] = bhCheckWall_0x25d590; // 0x25daa4 - g_ps2RecompiledFunctionTable[358056] = bhCheckWall_0x25d590; // 0x25daa8 - g_ps2RecompiledFunctionTable[358057] = bhCheckWall_0x25d590; // 0x25daac - g_ps2RecompiledFunctionTable[358058] = bhCheckWall_0x25d590; // 0x25dab0 - g_ps2RecompiledFunctionTable[358059] = bhCheckWall_0x25d590; // 0x25dab4 - g_ps2RecompiledFunctionTable[358060] = bhCheckWall_0x25d590; // 0x25dab8 - g_ps2RecompiledFunctionTable[358061] = bhCheckWall_0x25d590; // 0x25dabc - g_ps2RecompiledFunctionTable[358062] = bhCheckWall_0x25d590; // 0x25dac0 - g_ps2RecompiledFunctionTable[358063] = bhCheckWall_0x25d590; // 0x25dac4 - g_ps2RecompiledFunctionTable[358064] = bhCheckWall_0x25d590; // 0x25dac8 - g_ps2RecompiledFunctionTable[358065] = bhCheckWall_0x25d590; // 0x25dacc - g_ps2RecompiledFunctionTable[358066] = bhCheckWall_0x25d590; // 0x25dad0 - g_ps2RecompiledFunctionTable[358067] = bhCheckWall_0x25d590; // 0x25dad4 - g_ps2RecompiledFunctionTable[358068] = bhCheckWall_0x25d590; // 0x25dad8 - g_ps2RecompiledFunctionTable[358069] = bhCheckWall_0x25d590; // 0x25dadc - g_ps2RecompiledFunctionTable[358070] = bhCheckWall_0x25d590; // 0x25dae0 - g_ps2RecompiledFunctionTable[358071] = bhCheckWall_0x25d590; // 0x25dae4 - g_ps2RecompiledFunctionTable[358072] = bhCheckWall_0x25d590; // 0x25dae8 - g_ps2RecompiledFunctionTable[358073] = bhCheckWall_0x25d590; // 0x25daec - g_ps2RecompiledFunctionTable[358074] = bhCheckWall_0x25d590; // 0x25daf0 - g_ps2RecompiledFunctionTable[358075] = bhCheckWall_0x25d590; // 0x25daf4 - g_ps2RecompiledFunctionTable[358076] = bhCheckWall_0x25d590; // 0x25daf8 - g_ps2RecompiledFunctionTable[358077] = bhCheckWall_0x25d590; // 0x25dafc - g_ps2RecompiledFunctionTable[358078] = bhCheckWall_0x25d590; // 0x25db00 - g_ps2RecompiledFunctionTable[358079] = bhCheckWall_0x25d590; // 0x25db04 - g_ps2RecompiledFunctionTable[358080] = bhCheckWall_0x25d590; // 0x25db08 - g_ps2RecompiledFunctionTable[358081] = bhCheckWall_0x25d590; // 0x25db0c - g_ps2RecompiledFunctionTable[358082] = bhCheckWall_0x25d590; // 0x25db10 - g_ps2RecompiledFunctionTable[358083] = bhCheckWall_0x25d590; // 0x25db14 - g_ps2RecompiledFunctionTable[358084] = bhCheckWall_0x25d590; // 0x25db18 - g_ps2RecompiledFunctionTable[358085] = bhCheckWall_0x25d590; // 0x25db1c - g_ps2RecompiledFunctionTable[358086] = bhCheckWall_0x25d590; // 0x25db20 - g_ps2RecompiledFunctionTable[358087] = bhCheckWall_0x25d590; // 0x25db24 - g_ps2RecompiledFunctionTable[358088] = bhCheckWall_0x25d590; // 0x25db28 - g_ps2RecompiledFunctionTable[358089] = bhCheckWall_0x25d590; // 0x25db2c - g_ps2RecompiledFunctionTable[358090] = bhCheckWall_0x25d590; // 0x25db30 - g_ps2RecompiledFunctionTable[358091] = bhCheckWall_0x25d590; // 0x25db34 - g_ps2RecompiledFunctionTable[358092] = bhCheckWall_0x25d590; // 0x25db38 - g_ps2RecompiledFunctionTable[358093] = bhCheckWall_0x25d590; // 0x25db3c - g_ps2RecompiledFunctionTable[358094] = bhCheckWall_0x25d590; // 0x25db40 - g_ps2RecompiledFunctionTable[358095] = bhCheckWall_0x25d590; // 0x25db44 - g_ps2RecompiledFunctionTable[358096] = bhCheckWall_0x25d590; // 0x25db48 - g_ps2RecompiledFunctionTable[358097] = bhCheckWall_0x25d590; // 0x25db4c - g_ps2RecompiledFunctionTable[358098] = bhCheckWall_0x25d590; // 0x25db50 - g_ps2RecompiledFunctionTable[358099] = bhCheckWall_0x25d590; // 0x25db54 - g_ps2RecompiledFunctionTable[358100] = bhCheckWall_0x25d590; // 0x25db58 - g_ps2RecompiledFunctionTable[358101] = bhCheckWall_0x25d590; // 0x25db5c - g_ps2RecompiledFunctionTable[358102] = bhCheckWall_0x25d590; // 0x25db60 - g_ps2RecompiledFunctionTable[358103] = bhCheckWall_0x25d590; // 0x25db64 - g_ps2RecompiledFunctionTable[358104] = bhCheckWall_0x25d590; // 0x25db68 - g_ps2RecompiledFunctionTable[358105] = bhCheckWall_0x25d590; // 0x25db6c - g_ps2RecompiledFunctionTable[358106] = bhCheckWall_0x25d590; // 0x25db70 - g_ps2RecompiledFunctionTable[358107] = bhCheckWall_0x25d590; // 0x25db74 - g_ps2RecompiledFunctionTable[358108] = bhCheckWall_0x25d590; // 0x25db78 - g_ps2RecompiledFunctionTable[358109] = bhCheckWall_0x25d590; // 0x25db7c - g_ps2RecompiledFunctionTable[358110] = bhCheckWall_0x25d590; // 0x25db80 - g_ps2RecompiledFunctionTable[358111] = bhCheckWall_0x25d590; // 0x25db84 - g_ps2RecompiledFunctionTable[358112] = bhCheckWall_0x25d590; // 0x25db88 - g_ps2RecompiledFunctionTable[358113] = bhCheckWall_0x25d590; // 0x25db8c - g_ps2RecompiledFunctionTable[358114] = bhCheckWall_0x25d590; // 0x25db90 - g_ps2RecompiledFunctionTable[358115] = bhCheckWall_0x25d590; // 0x25db94 - g_ps2RecompiledFunctionTable[358116] = bhCheckWall_0x25d590; // 0x25db98 - g_ps2RecompiledFunctionTable[358117] = bhCheckWall_0x25d590; // 0x25db9c - g_ps2RecompiledFunctionTable[358118] = bhCheckWall_0x25d590; // 0x25dba0 - g_ps2RecompiledFunctionTable[358119] = bhCheckWall_0x25d590; // 0x25dba4 - g_ps2RecompiledFunctionTable[358120] = bhCheckWall_0x25d590; // 0x25dba8 - g_ps2RecompiledFunctionTable[358121] = bhCheckWall_0x25d590; // 0x25dbac - g_ps2RecompiledFunctionTable[358122] = bhCheckWall_0x25d590; // 0x25dbb0 - g_ps2RecompiledFunctionTable[358123] = bhCheckWall_0x25d590; // 0x25dbb4 - g_ps2RecompiledFunctionTable[358124] = bhCheckWall_0x25d590; // 0x25dbb8 - g_ps2RecompiledFunctionTable[358125] = bhCheckWall_0x25d590; // 0x25dbbc - g_ps2RecompiledFunctionTable[358126] = bhCheckWall_0x25d590; // 0x25dbc0 - g_ps2RecompiledFunctionTable[358127] = bhCheckWall_0x25d590; // 0x25dbc4 - g_ps2RecompiledFunctionTable[358128] = bhCheckWall_0x25d590; // 0x25dbc8 - g_ps2RecompiledFunctionTable[358129] = bhCheckWall_0x25d590; // 0x25dbcc - g_ps2RecompiledFunctionTable[358130] = bhCheckWall_0x25d590; // 0x25dbd0 - g_ps2RecompiledFunctionTable[358131] = bhCheckWall_0x25d590; // 0x25dbd4 - g_ps2RecompiledFunctionTable[358132] = bhCheckWall_0x25d590; // 0x25dbd8 - g_ps2RecompiledFunctionTable[358133] = bhCheckWall_0x25d590; // 0x25dbdc - g_ps2RecompiledFunctionTable[358134] = bhCheckWall_0x25d590; // 0x25dbe0 - g_ps2RecompiledFunctionTable[358135] = bhCheckWall_0x25d590; // 0x25dbe4 - g_ps2RecompiledFunctionTable[358136] = bhCheckWall_0x25d590; // 0x25dbe8 - g_ps2RecompiledFunctionTable[358137] = bhCheckWall_0x25d590; // 0x25dbec - g_ps2RecompiledFunctionTable[358138] = bhCheckWall_0x25d590; // 0x25dbf0 - g_ps2RecompiledFunctionTable[358139] = bhCheckWall_0x25d590; // 0x25dbf4 - g_ps2RecompiledFunctionTable[358140] = bhCheckWall_0x25d590; // 0x25dbf8 - g_ps2RecompiledFunctionTable[358141] = bhCheckWall_0x25d590; // 0x25dbfc - g_ps2RecompiledFunctionTable[358142] = bhCheckWall_0x25d590; // 0x25dc00 - g_ps2RecompiledFunctionTable[358143] = bhCheckWall_0x25d590; // 0x25dc04 - g_ps2RecompiledFunctionTable[358144] = bhCheckWall_0x25d590; // 0x25dc08 - g_ps2RecompiledFunctionTable[358145] = bhCheckWall_0x25d590; // 0x25dc0c - g_ps2RecompiledFunctionTable[358146] = bhCheckWall_0x25d590; // 0x25dc10 - g_ps2RecompiledFunctionTable[358147] = bhCheckWall_0x25d590; // 0x25dc14 - g_ps2RecompiledFunctionTable[358148] = bhCheckWall_0x25d590; // 0x25dc18 - g_ps2RecompiledFunctionTable[358149] = bhCheckWall_0x25d590; // 0x25dc1c - g_ps2RecompiledFunctionTable[358150] = bhCheckWall_0x25d590; // 0x25dc20 - g_ps2RecompiledFunctionTable[358151] = bhCheckWall_0x25d590; // 0x25dc24 - g_ps2RecompiledFunctionTable[358152] = bhCheckWall_0x25d590; // 0x25dc28 - g_ps2RecompiledFunctionTable[358153] = bhCheckWall_0x25d590; // 0x25dc2c - g_ps2RecompiledFunctionTable[358154] = bhCheckWall_0x25d590; // 0x25dc30 - g_ps2RecompiledFunctionTable[358155] = bhCheckWall_0x25d590; // 0x25dc34 - g_ps2RecompiledFunctionTable[358156] = bhCheckWall_0x25d590; // 0x25dc38 - g_ps2RecompiledFunctionTable[358157] = bhCheckWall_0x25d590; // 0x25dc3c - g_ps2RecompiledFunctionTable[358158] = bhCheckWall_0x25d590; // 0x25dc40 - g_ps2RecompiledFunctionTable[358159] = bhCheckWall_0x25d590; // 0x25dc44 - g_ps2RecompiledFunctionTable[358160] = bhCheckWall_0x25d590; // 0x25dc48 - g_ps2RecompiledFunctionTable[358161] = bhCheckWall_0x25d590; // 0x25dc4c - g_ps2RecompiledFunctionTable[358162] = bhCheckWall_0x25d590; // 0x25dc50 - g_ps2RecompiledFunctionTable[358163] = bhCheckWall_0x25d590; // 0x25dc54 - g_ps2RecompiledFunctionTable[358164] = bhCheckWall_0x25d590; // 0x25dc58 - g_ps2RecompiledFunctionTable[358165] = bhCheckWall_0x25d590; // 0x25dc5c - g_ps2RecompiledFunctionTable[358166] = bhCheckWall_0x25d590; // 0x25dc60 - g_ps2RecompiledFunctionTable[358167] = bhCheckWall_0x25d590; // 0x25dc64 - g_ps2RecompiledFunctionTable[358168] = bhCheckWall_0x25d590; // 0x25dc68 - g_ps2RecompiledFunctionTable[358169] = bhCheckWall_0x25d590; // 0x25dc6c - g_ps2RecompiledFunctionTable[358170] = bhCheckWall_0x25d590; // 0x25dc70 - g_ps2RecompiledFunctionTable[358171] = bhCheckWall_0x25d590; // 0x25dc74 - g_ps2RecompiledFunctionTable[358172] = bhCheckWall_0x25d590; // 0x25dc78 - g_ps2RecompiledFunctionTable[358173] = bhCheckWall_0x25d590; // 0x25dc7c - g_ps2RecompiledFunctionTable[358174] = bhCheckWall_0x25d590; // 0x25dc80 - g_ps2RecompiledFunctionTable[358175] = bhCheckWall_0x25d590; // 0x25dc84 - g_ps2RecompiledFunctionTable[358176] = bhCheckWall_0x25d590; // 0x25dc88 - g_ps2RecompiledFunctionTable[358177] = bhCheckWall_0x25d590; // 0x25dc8c - g_ps2RecompiledFunctionTable[358178] = bhCheckWall_0x25d590; // 0x25dc90 - g_ps2RecompiledFunctionTable[358179] = bhCheckWall_0x25d590; // 0x25dc94 - g_ps2RecompiledFunctionTable[358180] = bhCheckWall_0x25d590; // 0x25dc98 - g_ps2RecompiledFunctionTable[358181] = bhCheckWall_0x25d590; // 0x25dc9c - g_ps2RecompiledFunctionTable[358182] = bhCheckWall_0x25d590; // 0x25dca0 - g_ps2RecompiledFunctionTable[358183] = bhCheckWall_0x25d590; // 0x25dca4 - g_ps2RecompiledFunctionTable[358184] = bhCheckWall_0x25d590; // 0x25dca8 - g_ps2RecompiledFunctionTable[358185] = bhCheckWall_0x25d590; // 0x25dcac - g_ps2RecompiledFunctionTable[358186] = bhCheckWall_0x25d590; // 0x25dcb0 - g_ps2RecompiledFunctionTable[358187] = bhCheckWall_0x25d590; // 0x25dcb4 - g_ps2RecompiledFunctionTable[358188] = bhCheckWall_0x25d590; // 0x25dcb8 - g_ps2RecompiledFunctionTable[358189] = bhCheckWall_0x25d590; // 0x25dcbc - g_ps2RecompiledFunctionTable[358190] = bhCheckWall_0x25d590; // 0x25dcc0 - g_ps2RecompiledFunctionTable[358191] = bhCheckWall_0x25d590; // 0x25dcc4 - g_ps2RecompiledFunctionTable[358192] = bhCheckWall_0x25d590; // 0x25dcc8 - g_ps2RecompiledFunctionTable[358193] = bhCheckWall_0x25d590; // 0x25dccc - g_ps2RecompiledFunctionTable[358194] = bhCheckWall_0x25d590; // 0x25dcd0 - g_ps2RecompiledFunctionTable[358195] = bhCheckWall_0x25d590; // 0x25dcd4 - g_ps2RecompiledFunctionTable[358196] = bhCheckWall_0x25d590; // 0x25dcd8 - g_ps2RecompiledFunctionTable[358197] = bhCheckWall_0x25d590; // 0x25dcdc - g_ps2RecompiledFunctionTable[358198] = bhCheckWall_0x25d590; // 0x25dce0 - g_ps2RecompiledFunctionTable[358199] = bhCheckWall_0x25d590; // 0x25dce4 - g_ps2RecompiledFunctionTable[358200] = bhCheckWall_0x25d590; // 0x25dce8 - g_ps2RecompiledFunctionTable[358201] = bhCheckWall_0x25d590; // 0x25dcec - g_ps2RecompiledFunctionTable[358202] = bhCheckWall_0x25d590; // 0x25dcf0 - g_ps2RecompiledFunctionTable[358203] = bhCheckWall_0x25d590; // 0x25dcf4 - g_ps2RecompiledFunctionTable[358204] = bhCheckWall_0x25d590; // 0x25dcf8 - g_ps2RecompiledFunctionTable[358205] = bhCheckWall_0x25d590; // 0x25dcfc - g_ps2RecompiledFunctionTable[358206] = bhCheckWall_0x25d590; // 0x25dd00 - g_ps2RecompiledFunctionTable[358207] = bhCheckWall_0x25d590; // 0x25dd04 - g_ps2RecompiledFunctionTable[358208] = bhCheckWall_0x25d590; // 0x25dd08 - g_ps2RecompiledFunctionTable[358209] = bhCheckWall_0x25d590; // 0x25dd0c - g_ps2RecompiledFunctionTable[358210] = bhCheckWall_0x25d590; // 0x25dd10 - g_ps2RecompiledFunctionTable[358211] = bhCheckWall_0x25d590; // 0x25dd14 - g_ps2RecompiledFunctionTable[358212] = bhCheckWall_0x25d590; // 0x25dd18 - g_ps2RecompiledFunctionTable[358213] = bhCheckWall_0x25d590; // 0x25dd1c - g_ps2RecompiledFunctionTable[358214] = bhCheckWall_0x25d590; // 0x25dd20 - g_ps2RecompiledFunctionTable[358215] = bhCheckWall_0x25d590; // 0x25dd24 - g_ps2RecompiledFunctionTable[358216] = bhCheckWall_0x25d590; // 0x25dd28 - g_ps2RecompiledFunctionTable[358217] = bhCheckWall_0x25d590; // 0x25dd2c - g_ps2RecompiledFunctionTable[358218] = bhCheckWall_0x25d590; // 0x25dd30 - g_ps2RecompiledFunctionTable[358219] = bhCheckWall_0x25d590; // 0x25dd34 - g_ps2RecompiledFunctionTable[358220] = bhCheckWall_0x25d590; // 0x25dd38 - g_ps2RecompiledFunctionTable[358221] = bhCheckWall_0x25d590; // 0x25dd3c - g_ps2RecompiledFunctionTable[358222] = bhCheckWall_0x25d590; // 0x25dd40 - g_ps2RecompiledFunctionTable[358223] = bhCheckWall_0x25d590; // 0x25dd44 - g_ps2RecompiledFunctionTable[358224] = bhCheckWall_0x25d590; // 0x25dd48 - g_ps2RecompiledFunctionTable[358225] = bhCheckWall_0x25d590; // 0x25dd4c - g_ps2RecompiledFunctionTable[358226] = bhCheckWall_0x25d590; // 0x25dd50 - g_ps2RecompiledFunctionTable[358227] = bhCheckWall_0x25d590; // 0x25dd54 - g_ps2RecompiledFunctionTable[358228] = bhCheckWall_0x25d590; // 0x25dd58 - g_ps2RecompiledFunctionTable[358229] = bhCheckWall_0x25d590; // 0x25dd5c - g_ps2RecompiledFunctionTable[358230] = bhCheckWall_0x25d590; // 0x25dd60 - g_ps2RecompiledFunctionTable[358231] = bhCheckWall_0x25d590; // 0x25dd64 - g_ps2RecompiledFunctionTable[358232] = bhCheckWall_0x25d590; // 0x25dd68 - g_ps2RecompiledFunctionTable[358233] = bhCheckWall_0x25d590; // 0x25dd6c - g_ps2RecompiledFunctionTable[358234] = bhCheckWall_0x25d590; // 0x25dd70 - g_ps2RecompiledFunctionTable[358235] = bhCheckWall_0x25d590; // 0x25dd74 - g_ps2RecompiledFunctionTable[358236] = bhCheckWall_0x25d590; // 0x25dd78 - g_ps2RecompiledFunctionTable[358237] = bhCheckWall_0x25d590; // 0x25dd7c - g_ps2RecompiledFunctionTable[358238] = bhCheckWall_0x25d590; // 0x25dd80 - g_ps2RecompiledFunctionTable[358239] = bhCheckWall_0x25d590; // 0x25dd84 - g_ps2RecompiledFunctionTable[358240] = bhCheckWall_0x25d590; // 0x25dd88 - g_ps2RecompiledFunctionTable[358241] = bhCheckWall_0x25d590; // 0x25dd8c - g_ps2RecompiledFunctionTable[358242] = bhCheckWall_0x25d590; // 0x25dd90 - g_ps2RecompiledFunctionTable[358243] = bhCheckWall_0x25d590; // 0x25dd94 - g_ps2RecompiledFunctionTable[358244] = bhCheckWall_0x25d590; // 0x25dd98 - g_ps2RecompiledFunctionTable[358245] = bhCheckWall_0x25d590; // 0x25dd9c - g_ps2RecompiledFunctionTable[358246] = bhCheckWall_0x25d590; // 0x25dda0 - g_ps2RecompiledFunctionTable[358247] = bhCheckWall_0x25d590; // 0x25dda4 - g_ps2RecompiledFunctionTable[358248] = bhCheckWall_0x25d590; // 0x25dda8 - g_ps2RecompiledFunctionTable[358249] = bhCheckWall_0x25d590; // 0x25ddac - g_ps2RecompiledFunctionTable[358250] = bhCheckWall_0x25d590; // 0x25ddb0 - g_ps2RecompiledFunctionTable[358251] = bhCheckWall_0x25d590; // 0x25ddb4 - g_ps2RecompiledFunctionTable[358252] = bhCheckWall_0x25d590; // 0x25ddb8 - g_ps2RecompiledFunctionTable[358253] = bhCheckWall_0x25d590; // 0x25ddbc - g_ps2RecompiledFunctionTable[358254] = bhCheckWall_0x25d590; // 0x25ddc0 - g_ps2RecompiledFunctionTable[358255] = bhCheckWall_0x25d590; // 0x25ddc4 - g_ps2RecompiledFunctionTable[358256] = bhCheckWall_0x25d590; // 0x25ddc8 - g_ps2RecompiledFunctionTable[358257] = bhCheckWall_0x25d590; // 0x25ddcc - g_ps2RecompiledFunctionTable[358258] = bhCheckWall_0x25d590; // 0x25ddd0 - g_ps2RecompiledFunctionTable[358259] = bhCheckWall_0x25d590; // 0x25ddd4 - g_ps2RecompiledFunctionTable[358260] = bhCheckWall_0x25d590; // 0x25ddd8 - g_ps2RecompiledFunctionTable[358261] = bhCheckWall_0x25d590; // 0x25dddc - g_ps2RecompiledFunctionTable[358262] = bhCheckWall_0x25d590; // 0x25dde0 - g_ps2RecompiledFunctionTable[358263] = bhCheckWall_0x25d590; // 0x25dde4 - g_ps2RecompiledFunctionTable[358264] = bhCheckWall_0x25d590; // 0x25dde8 - g_ps2RecompiledFunctionTable[358265] = bhCheckWall_0x25d590; // 0x25ddec - g_ps2RecompiledFunctionTable[358266] = bhCheckWall_0x25d590; // 0x25ddf0 - g_ps2RecompiledFunctionTable[358267] = bhCheckWall_0x25d590; // 0x25ddf4 - g_ps2RecompiledFunctionTable[358268] = bhCheckWall_0x25d590; // 0x25ddf8 - g_ps2RecompiledFunctionTable[358269] = bhCheckWall_0x25d590; // 0x25ddfc - g_ps2RecompiledFunctionTable[358270] = bhCheckWall_0x25d590; // 0x25de00 - g_ps2RecompiledFunctionTable[358271] = bhCheckWall_0x25d590; // 0x25de04 - g_ps2RecompiledFunctionTable[358272] = bhCheckWall_0x25d590; // 0x25de08 - g_ps2RecompiledFunctionTable[358273] = bhCheckWall_0x25d590; // 0x25de0c - g_ps2RecompiledFunctionTable[358274] = bhCheckWall_0x25d590; // 0x25de10 - g_ps2RecompiledFunctionTable[358275] = bhCheckWall_0x25d590; // 0x25de14 - g_ps2RecompiledFunctionTable[358276] = bhCheckWall_0x25d590; // 0x25de18 - g_ps2RecompiledFunctionTable[358277] = bhCheckWall_0x25d590; // 0x25de1c - g_ps2RecompiledFunctionTable[358278] = bhCheckWall_0x25d590; // 0x25de20 - g_ps2RecompiledFunctionTable[358279] = bhCheckWall_0x25d590; // 0x25de24 - g_ps2RecompiledFunctionTable[358280] = bhCheckWall_0x25d590; // 0x25de28 - g_ps2RecompiledFunctionTable[358281] = bhCheckWall_0x25d590; // 0x25de2c - g_ps2RecompiledFunctionTable[358282] = bhCheckWall_0x25d590; // 0x25de30 - g_ps2RecompiledFunctionTable[358283] = bhCheckWall_0x25d590; // 0x25de34 - g_ps2RecompiledFunctionTable[358284] = bhCheckWall_0x25d590; // 0x25de38 - g_ps2RecompiledFunctionTable[358285] = bhCheckWall_0x25d590; // 0x25de3c - g_ps2RecompiledFunctionTable[358286] = bhCheckWall_0x25d590; // 0x25de40 - g_ps2RecompiledFunctionTable[358287] = bhCheckWall_0x25d590; // 0x25de44 - g_ps2RecompiledFunctionTable[358288] = bhCheckWall_0x25d590; // 0x25de48 - g_ps2RecompiledFunctionTable[358289] = bhCheckWall_0x25d590; // 0x25de4c - g_ps2RecompiledFunctionTable[358290] = bhCheckWall_0x25d590; // 0x25de50 - g_ps2RecompiledFunctionTable[358291] = bhCheckWall_0x25d590; // 0x25de54 - g_ps2RecompiledFunctionTable[358292] = bhCheckWall_0x25d590; // 0x25de58 - g_ps2RecompiledFunctionTable[358293] = bhCheckWall_0x25d590; // 0x25de5c - g_ps2RecompiledFunctionTable[358294] = bhCheckWall_0x25d590; // 0x25de60 - g_ps2RecompiledFunctionTable[358295] = bhCheckWall_0x25d590; // 0x25de64 - g_ps2RecompiledFunctionTable[358296] = bhCheckWall_0x25d590; // 0x25de68 - g_ps2RecompiledFunctionTable[358297] = bhCheckWall_0x25d590; // 0x25de6c - g_ps2RecompiledFunctionTable[358298] = bhCheckWall_0x25d590; // 0x25de70 - g_ps2RecompiledFunctionTable[358299] = bhCheckWall_0x25d590; // 0x25de74 - g_ps2RecompiledFunctionTable[358300] = bhCheckWall_0x25d590; // 0x25de78 - g_ps2RecompiledFunctionTable[358301] = bhCheckWall_0x25d590; // 0x25de7c - g_ps2RecompiledFunctionTable[358302] = bhCheckWall_0x25d590; // 0x25de80 - g_ps2RecompiledFunctionTable[358303] = bhCheckWall_0x25d590; // 0x25de84 - g_ps2RecompiledFunctionTable[358304] = bhCheckWall_0x25d590; // 0x25de88 - g_ps2RecompiledFunctionTable[358305] = bhCheckWall_0x25d590; // 0x25de8c - g_ps2RecompiledFunctionTable[358306] = bhCheckWall_0x25d590; // 0x25de90 - g_ps2RecompiledFunctionTable[358307] = bhCheckWall_0x25d590; // 0x25de94 - g_ps2RecompiledFunctionTable[358308] = bhCheckWall_0x25d590; // 0x25de98 - g_ps2RecompiledFunctionTable[358309] = bhCheckWall_0x25d590; // 0x25de9c - g_ps2RecompiledFunctionTable[358310] = bhCheckWall_0x25d590; // 0x25dea0 - g_ps2RecompiledFunctionTable[358311] = bhCheckWall_0x25d590; // 0x25dea4 - g_ps2RecompiledFunctionTable[358312] = bhCheckWall_0x25d590; // 0x25dea8 - g_ps2RecompiledFunctionTable[358313] = bhCheckWall_0x25d590; // 0x25deac - g_ps2RecompiledFunctionTable[358314] = bhCheckWall_0x25d590; // 0x25deb0 - g_ps2RecompiledFunctionTable[358315] = bhCheckWall_0x25d590; // 0x25deb4 - g_ps2RecompiledFunctionTable[358316] = bhCheckWall_0x25d590; // 0x25deb8 - g_ps2RecompiledFunctionTable[358317] = bhCheckWall_0x25d590; // 0x25debc - g_ps2RecompiledFunctionTable[358318] = bhCheckWall_0x25d590; // 0x25dec0 - g_ps2RecompiledFunctionTable[358319] = bhCheckWall_0x25d590; // 0x25dec4 - g_ps2RecompiledFunctionTable[358320] = bhCheckWall_0x25d590; // 0x25dec8 - g_ps2RecompiledFunctionTable[358321] = bhCheckWall_0x25d590; // 0x25decc - g_ps2RecompiledFunctionTable[358322] = bhCheckWall_0x25d590; // 0x25ded0 - g_ps2RecompiledFunctionTable[358323] = bhCheckWall_0x25d590; // 0x25ded4 - g_ps2RecompiledFunctionTable[358324] = bhCheckWall_0x25d590; // 0x25ded8 - g_ps2RecompiledFunctionTable[358325] = bhCheckWall_0x25d590; // 0x25dedc - g_ps2RecompiledFunctionTable[358326] = bhCheckWall_0x25d590; // 0x25dee0 - g_ps2RecompiledFunctionTable[358327] = bhCheckWall_0x25d590; // 0x25dee4 - g_ps2RecompiledFunctionTable[358328] = bhCheckWall_0x25d590; // 0x25dee8 - g_ps2RecompiledFunctionTable[358329] = bhCheckWall_0x25d590; // 0x25deec - g_ps2RecompiledFunctionTable[358330] = bhCheckWall_0x25d590; // 0x25def0 - g_ps2RecompiledFunctionTable[358331] = bhCheckWall_0x25d590; // 0x25def4 - g_ps2RecompiledFunctionTable[358332] = bhCheckWall_0x25d590; // 0x25def8 - g_ps2RecompiledFunctionTable[358333] = bhCheckWall_0x25d590; // 0x25defc - g_ps2RecompiledFunctionTable[358334] = bhCheckWall_0x25d590; // 0x25df00 - g_ps2RecompiledFunctionTable[358335] = bhCheckWall_0x25d590; // 0x25df04 - g_ps2RecompiledFunctionTable[358336] = bhCheckWall_0x25d590; // 0x25df08 - g_ps2RecompiledFunctionTable[358337] = bhCheckWall_0x25d590; // 0x25df0c - g_ps2RecompiledFunctionTable[358338] = bhCheckWall_0x25d590; // 0x25df10 - g_ps2RecompiledFunctionTable[358339] = bhCheckWall_0x25d590; // 0x25df14 - g_ps2RecompiledFunctionTable[358340] = bhCheckWall_0x25d590; // 0x25df18 - g_ps2RecompiledFunctionTable[358341] = bhCheckWall_0x25d590; // 0x25df1c - g_ps2RecompiledFunctionTable[358342] = bhCheckWall_0x25d590; // 0x25df20 - g_ps2RecompiledFunctionTable[358343] = bhCheckWall_0x25d590; // 0x25df24 - g_ps2RecompiledFunctionTable[358344] = bhCheckWall_0x25d590; // 0x25df28 - g_ps2RecompiledFunctionTable[358345] = bhCheckWall_0x25d590; // 0x25df2c - g_ps2RecompiledFunctionTable[358346] = bhCheckWall_0x25d590; // 0x25df30 - g_ps2RecompiledFunctionTable[358347] = bhCheckWall_0x25d590; // 0x25df34 - g_ps2RecompiledFunctionTable[358348] = bhCheckWall_0x25d590; // 0x25df38 - g_ps2RecompiledFunctionTable[358349] = bhCheckWall_0x25d590; // 0x25df3c - g_ps2RecompiledFunctionTable[358350] = bhCheckWall_0x25d590; // 0x25df40 - g_ps2RecompiledFunctionTable[358351] = bhCheckWall_0x25d590; // 0x25df44 - g_ps2RecompiledFunctionTable[358352] = bhCheckWall_0x25d590; // 0x25df48 - g_ps2RecompiledFunctionTable[358353] = bhCheckWall_0x25d590; // 0x25df4c - g_ps2RecompiledFunctionTable[358354] = bhCheckWall_0x25d590; // 0x25df50 - g_ps2RecompiledFunctionTable[358355] = bhCheckWall_0x25d590; // 0x25df54 - g_ps2RecompiledFunctionTable[358356] = bhCheckWall_0x25d590; // 0x25df58 - g_ps2RecompiledFunctionTable[358357] = bhCheckWall_0x25d590; // 0x25df5c - g_ps2RecompiledFunctionTable[358358] = bhCheckWall_0x25d590; // 0x25df60 - g_ps2RecompiledFunctionTable[358359] = bhCheckWall_0x25d590; // 0x25df64 - g_ps2RecompiledFunctionTable[358360] = bhCheckWall_0x25d590; // 0x25df68 - g_ps2RecompiledFunctionTable[358361] = bhCheckWall_0x25d590; // 0x25df6c - g_ps2RecompiledFunctionTable[358362] = bhCheckWall_0x25d590; // 0x25df70 - g_ps2RecompiledFunctionTable[358363] = bhCheckWall_0x25d590; // 0x25df74 - g_ps2RecompiledFunctionTable[358364] = bhCheckWall_0x25d590; // 0x25df78 - g_ps2RecompiledFunctionTable[358365] = bhCheckWall_0x25d590; // 0x25df7c - g_ps2RecompiledFunctionTable[358366] = bhCheckWall_0x25d590; // 0x25df80 - g_ps2RecompiledFunctionTable[358367] = bhCheckWall_0x25d590; // 0x25df84 - g_ps2RecompiledFunctionTable[358368] = bhCheckWall_0x25d590; // 0x25df88 - g_ps2RecompiledFunctionTable[358369] = bhCheckWall_0x25d590; // 0x25df8c - g_ps2RecompiledFunctionTable[358370] = bhCheckWall_0x25d590; // 0x25df90 - g_ps2RecompiledFunctionTable[358371] = bhCheckWall_0x25d590; // 0x25df94 - g_ps2RecompiledFunctionTable[358372] = bhCheckWall_0x25d590; // 0x25df98 - g_ps2RecompiledFunctionTable[358373] = bhCheckWall_0x25d590; // 0x25df9c - g_ps2RecompiledFunctionTable[358374] = bhCheckWall_0x25d590; // 0x25dfa0 - g_ps2RecompiledFunctionTable[358375] = bhCheckWall_0x25d590; // 0x25dfa4 - g_ps2RecompiledFunctionTable[358376] = bhCheckWall_0x25d590; // 0x25dfa8 - g_ps2RecompiledFunctionTable[358377] = bhCheckWall_0x25d590; // 0x25dfac - g_ps2RecompiledFunctionTable[358378] = bhCheckWall_0x25d590; // 0x25dfb0 - g_ps2RecompiledFunctionTable[358379] = bhCheckWall_0x25d590; // 0x25dfb4 - g_ps2RecompiledFunctionTable[358380] = bhCheckWall_0x25d590; // 0x25dfb8 - g_ps2RecompiledFunctionTable[358381] = bhCheckWall_0x25d590; // 0x25dfbc - g_ps2RecompiledFunctionTable[358382] = bhCheckWall_0x25d590; // 0x25dfc0 - g_ps2RecompiledFunctionTable[358383] = bhCheckWall_0x25d590; // 0x25dfc4 - g_ps2RecompiledFunctionTable[358384] = bhCheckWall_0x25d590; // 0x25dfc8 - g_ps2RecompiledFunctionTable[358385] = bhCheckWall_0x25d590; // 0x25dfcc - g_ps2RecompiledFunctionTable[358386] = bhCheckWall_0x25d590; // 0x25dfd0 - g_ps2RecompiledFunctionTable[358387] = bhCheckWall_0x25d590; // 0x25dfd4 - g_ps2RecompiledFunctionTable[358388] = bhCheckWall_0x25d590; // 0x25dfd8 - g_ps2RecompiledFunctionTable[358389] = bhCheckWall_0x25d590; // 0x25dfdc - g_ps2RecompiledFunctionTable[358390] = bhCheckWall_0x25d590; // 0x25dfe0 - g_ps2RecompiledFunctionTable[358391] = bhCheckWall_0x25d590; // 0x25dfe4 - g_ps2RecompiledFunctionTable[358392] = bhCheckWall_0x25d590; // 0x25dfe8 - g_ps2RecompiledFunctionTable[358393] = bhCheckWall_0x25d590; // 0x25dfec - g_ps2RecompiledFunctionTable[358394] = bhCheckWall_0x25d590; // 0x25dff0 - g_ps2RecompiledFunctionTable[358395] = bhCheckWall_0x25d590; // 0x25dff4 - g_ps2RecompiledFunctionTable[358396] = bhCheckWall_0x25d590; // 0x25dff8 - g_ps2RecompiledFunctionTable[358397] = bhCheckWall_0x25d590; // 0x25dffc - g_ps2RecompiledFunctionTable[358398] = bhCheckWall_0x25d590; // 0x25e000 - g_ps2RecompiledFunctionTable[358399] = bhCheckWall_0x25d590; // 0x25e004 - g_ps2RecompiledFunctionTable[358400] = bhCheckWall_0x25d590; // 0x25e008 - g_ps2RecompiledFunctionTable[358401] = bhCheckWall_0x25d590; // 0x25e00c - g_ps2RecompiledFunctionTable[358402] = bhCheckWall_0x25d590; // 0x25e010 - g_ps2RecompiledFunctionTable[358403] = bhCheckWall_0x25d590; // 0x25e014 - g_ps2RecompiledFunctionTable[358404] = bhCheckWall_0x25d590; // 0x25e018 - g_ps2RecompiledFunctionTable[358405] = bhCheckWall_0x25d590; // 0x25e01c - g_ps2RecompiledFunctionTable[358406] = bhCheckWall_0x25d590; // 0x25e020 - g_ps2RecompiledFunctionTable[358407] = bhCheckWall_0x25d590; // 0x25e024 - g_ps2RecompiledFunctionTable[358408] = bhCheckWall_0x25d590; // 0x25e028 - g_ps2RecompiledFunctionTable[358409] = bhCheckWall_0x25d590; // 0x25e02c - g_ps2RecompiledFunctionTable[358410] = bhCheckWall_0x25d590; // 0x25e030 - g_ps2RecompiledFunctionTable[358411] = bhCheckWall_0x25d590; // 0x25e034 - g_ps2RecompiledFunctionTable[358412] = bhCheckWall_0x25d590; // 0x25e038 - g_ps2RecompiledFunctionTable[358413] = bhCheckWall_0x25d590; // 0x25e03c - g_ps2RecompiledFunctionTable[358414] = bhCheckWall_0x25d590; // 0x25e040 - g_ps2RecompiledFunctionTable[358415] = bhCheckWall_0x25d590; // 0x25e044 - g_ps2RecompiledFunctionTable[358416] = bhCheckWall_0x25d590; // 0x25e048 - g_ps2RecompiledFunctionTable[358417] = bhCheckWall_0x25d590; // 0x25e04c - g_ps2RecompiledFunctionTable[358418] = bhCheckWall_0x25d590; // 0x25e050 - g_ps2RecompiledFunctionTable[358419] = bhCheckWall_0x25d590; // 0x25e054 - g_ps2RecompiledFunctionTable[358420] = bhCheckWall_0x25d590; // 0x25e058 - g_ps2RecompiledFunctionTable[358421] = bhCheckWall_0x25d590; // 0x25e05c - g_ps2RecompiledFunctionTable[358422] = bhCheckWall_0x25d590; // 0x25e060 - g_ps2RecompiledFunctionTable[358423] = bhCheckWall_0x25d590; // 0x25e064 - g_ps2RecompiledFunctionTable[358424] = bhCheckWall_0x25d590; // 0x25e068 - g_ps2RecompiledFunctionTable[358425] = bhCheckWall_0x25d590; // 0x25e06c - g_ps2RecompiledFunctionTable[358426] = bhCheckWall_0x25d590; // 0x25e070 - g_ps2RecompiledFunctionTable[358427] = bhCheckWall_0x25d590; // 0x25e074 - g_ps2RecompiledFunctionTable[358428] = bhCheckWall_0x25d590; // 0x25e078 - g_ps2RecompiledFunctionTable[358429] = bhCheckWall_0x25d590; // 0x25e07c - g_ps2RecompiledFunctionTable[358430] = bhCheckWall_0x25d590; // 0x25e080 - g_ps2RecompiledFunctionTable[358431] = bhCheckWall_0x25d590; // 0x25e084 - g_ps2RecompiledFunctionTable[358432] = bhCheckWall_0x25d590; // 0x25e088 - g_ps2RecompiledFunctionTable[358433] = bhCheckWall_0x25d590; // 0x25e08c - g_ps2RecompiledFunctionTable[358434] = bhCheckWall_0x25d590; // 0x25e090 - g_ps2RecompiledFunctionTable[358435] = bhCheckWall_0x25d590; // 0x25e094 - g_ps2RecompiledFunctionTable[358436] = bhCheckWall_0x25d590; // 0x25e098 - g_ps2RecompiledFunctionTable[358437] = bhCheckWall_0x25d590; // 0x25e09c - g_ps2RecompiledFunctionTable[358438] = bhCheckWall_0x25d590; // 0x25e0a0 - g_ps2RecompiledFunctionTable[358439] = bhCheckWall_0x25d590; // 0x25e0a4 - g_ps2RecompiledFunctionTable[358440] = bhCheckWall_0x25d590; // 0x25e0a8 - g_ps2RecompiledFunctionTable[358441] = bhCheckWall_0x25d590; // 0x25e0ac - g_ps2RecompiledFunctionTable[358442] = bhCheckWall_0x25d590; // 0x25e0b0 - g_ps2RecompiledFunctionTable[358443] = bhCheckWall_0x25d590; // 0x25e0b4 - g_ps2RecompiledFunctionTable[358444] = bhCheckWall_0x25d590; // 0x25e0b8 - g_ps2RecompiledFunctionTable[358445] = bhCheckWall_0x25d590; // 0x25e0bc - g_ps2RecompiledFunctionTable[358446] = bhCheckWall_0x25d590; // 0x25e0c0 - g_ps2RecompiledFunctionTable[358447] = bhCheckWall_0x25d590; // 0x25e0c4 - g_ps2RecompiledFunctionTable[358448] = bhCheckWall_0x25d590; // 0x25e0c8 - g_ps2RecompiledFunctionTable[358449] = bhCheckWall_0x25d590; // 0x25e0cc - g_ps2RecompiledFunctionTable[358450] = bhCheckWall_0x25d590; // 0x25e0d0 - g_ps2RecompiledFunctionTable[358451] = bhCheckWall_0x25d590; // 0x25e0d4 - g_ps2RecompiledFunctionTable[358452] = bhCheckWall_0x25d590; // 0x25e0d8 - g_ps2RecompiledFunctionTable[358453] = bhCheckWall_0x25d590; // 0x25e0dc - g_ps2RecompiledFunctionTable[358454] = bhCheckWall_0x25d590; // 0x25e0e0 - g_ps2RecompiledFunctionTable[358455] = bhCheckWall_0x25d590; // 0x25e0e4 - g_ps2RecompiledFunctionTable[358456] = bhCheckWall_0x25d590; // 0x25e0e8 - g_ps2RecompiledFunctionTable[358457] = bhCheckWall_0x25d590; // 0x25e0ec - g_ps2RecompiledFunctionTable[358458] = bhCheckWall_0x25d590; // 0x25e0f0 - g_ps2RecompiledFunctionTable[358459] = bhCheckWall_0x25d590; // 0x25e0f4 - g_ps2RecompiledFunctionTable[358460] = bhCheckWall_0x25d590; // 0x25e0f8 - g_ps2RecompiledFunctionTable[358461] = bhCheckWall_0x25d590; // 0x25e0fc - g_ps2RecompiledFunctionTable[358462] = bhCheckWall_0x25d590; // 0x25e100 - g_ps2RecompiledFunctionTable[358463] = bhCheckWall_0x25d590; // 0x25e104 - g_ps2RecompiledFunctionTable[358464] = bhCheckWall_0x25d590; // 0x25e108 - g_ps2RecompiledFunctionTable[358465] = bhCheckWall_0x25d590; // 0x25e10c - g_ps2RecompiledFunctionTable[358466] = bhCheckWall_0x25d590; // 0x25e110 - g_ps2RecompiledFunctionTable[358467] = bhCheckWall_0x25d590; // 0x25e114 - g_ps2RecompiledFunctionTable[358468] = bhCheckWall_0x25d590; // 0x25e118 - g_ps2RecompiledFunctionTable[358469] = bhCheckWall_0x25d590; // 0x25e11c - g_ps2RecompiledFunctionTable[358470] = bhCheckWall_0x25d590; // 0x25e120 - g_ps2RecompiledFunctionTable[358471] = bhCheckWall_0x25d590; // 0x25e124 - g_ps2RecompiledFunctionTable[358472] = bhCheckWall_0x25d590; // 0x25e128 - g_ps2RecompiledFunctionTable[358473] = bhCheckWall_0x25d590; // 0x25e12c - g_ps2RecompiledFunctionTable[358474] = bhCheckWall_0x25d590; // 0x25e130 - g_ps2RecompiledFunctionTable[358475] = bhCheckWall_0x25d590; // 0x25e134 - g_ps2RecompiledFunctionTable[358476] = bhCheckWall_0x25d590; // 0x25e138 - g_ps2RecompiledFunctionTable[358477] = bhCheckWall_0x25d590; // 0x25e13c - g_ps2RecompiledFunctionTable[358478] = bhCheckWall_0x25d590; // 0x25e140 - g_ps2RecompiledFunctionTable[358479] = bhCheckWall_0x25d590; // 0x25e144 - g_ps2RecompiledFunctionTable[358480] = bhCheckWall_0x25d590; // 0x25e148 - g_ps2RecompiledFunctionTable[358481] = bhCheckWall_0x25d590; // 0x25e14c - g_ps2RecompiledFunctionTable[358482] = bhCheckWall_0x25d590; // 0x25e150 - g_ps2RecompiledFunctionTable[358483] = bhCheckWall_0x25d590; // 0x25e154 - g_ps2RecompiledFunctionTable[358484] = bhCheckWall_0x25d590; // 0x25e158 - g_ps2RecompiledFunctionTable[358485] = bhCheckWall_0x25d590; // 0x25e15c - g_ps2RecompiledFunctionTable[358486] = bhCheckWall_0x25d590; // 0x25e160 - g_ps2RecompiledFunctionTable[358487] = bhCheckWall_0x25d590; // 0x25e164 - g_ps2RecompiledFunctionTable[358488] = bhCheckWall_0x25d590; // 0x25e168 - g_ps2RecompiledFunctionTable[358489] = bhCheckWall_0x25d590; // 0x25e16c - g_ps2RecompiledFunctionTable[358490] = bhCheckWall_0x25d590; // 0x25e170 - g_ps2RecompiledFunctionTable[358491] = bhCheckWall_0x25d590; // 0x25e174 - g_ps2RecompiledFunctionTable[358492] = bhCheckWall_0x25d590; // 0x25e178 - g_ps2RecompiledFunctionTable[358493] = bhCheckWall_0x25d590; // 0x25e17c - g_ps2RecompiledFunctionTable[358494] = bhCheckWall_0x25d590; // 0x25e180 - g_ps2RecompiledFunctionTable[358495] = bhCheckWall_0x25d590; // 0x25e184 - g_ps2RecompiledFunctionTable[358496] = bhCheckWall_0x25d590; // 0x25e188 - g_ps2RecompiledFunctionTable[358497] = bhCheckWall_0x25d590; // 0x25e18c - g_ps2RecompiledFunctionTable[358498] = bhCheckWall_0x25d590; // 0x25e190 - g_ps2RecompiledFunctionTable[358499] = bhCheckWall_0x25d590; // 0x25e194 - g_ps2RecompiledFunctionTable[358500] = bhCheckWall_0x25d590; // 0x25e198 - g_ps2RecompiledFunctionTable[358501] = bhCheckWall_0x25d590; // 0x25e19c - g_ps2RecompiledFunctionTable[358502] = bhCheckWall_0x25d590; // 0x25e1a0 - g_ps2RecompiledFunctionTable[358503] = bhCheckWall_0x25d590; // 0x25e1a4 - g_ps2RecompiledFunctionTable[358504] = bhCheckWall_0x25d590; // 0x25e1a8 - g_ps2RecompiledFunctionTable[358505] = bhCheckWall_0x25d590; // 0x25e1ac - g_ps2RecompiledFunctionTable[358506] = bhCheckWall_0x25d590; // 0x25e1b0 - g_ps2RecompiledFunctionTable[358507] = bhCheckWall_0x25d590; // 0x25e1b4 - g_ps2RecompiledFunctionTable[358508] = bhCheckWall_0x25d590; // 0x25e1b8 - g_ps2RecompiledFunctionTable[358509] = bhCheckWall_0x25d590; // 0x25e1bc - g_ps2RecompiledFunctionTable[358510] = bhCheckWall_0x25d590; // 0x25e1c0 - g_ps2RecompiledFunctionTable[358511] = bhCheckWall_0x25d590; // 0x25e1c4 - g_ps2RecompiledFunctionTable[358512] = bhCheckWall_0x25d590; // 0x25e1c8 - g_ps2RecompiledFunctionTable[358513] = bhCheckWall_0x25d590; // 0x25e1cc - g_ps2RecompiledFunctionTable[358514] = bhCheckWall_0x25d590; // 0x25e1d0 - g_ps2RecompiledFunctionTable[358515] = bhCheckWall_0x25d590; // 0x25e1d4 - g_ps2RecompiledFunctionTable[358516] = bhCheckWall_0x25d590; // 0x25e1d8 - g_ps2RecompiledFunctionTable[358517] = bhCheckWall_0x25d590; // 0x25e1dc - g_ps2RecompiledFunctionTable[358518] = bhCheckWall_0x25d590; // 0x25e1e0 - g_ps2RecompiledFunctionTable[358519] = bhCheckWall_0x25d590; // 0x25e1e4 - g_ps2RecompiledFunctionTable[358520] = bhCheckWall_0x25d590; // 0x25e1e8 - g_ps2RecompiledFunctionTable[358521] = bhCheckWall_0x25d590; // 0x25e1ec - g_ps2RecompiledFunctionTable[358522] = bhCheckWall_0x25d590; // 0x25e1f0 - g_ps2RecompiledFunctionTable[358523] = bhCheckWall_0x25d590; // 0x25e1f4 - g_ps2RecompiledFunctionTable[358524] = bhCheckWall_0x25d590; // 0x25e1f8 - g_ps2RecompiledFunctionTable[358525] = bhCheckWall_0x25d590; // 0x25e1fc - g_ps2RecompiledFunctionTable[358526] = bhCheckWall_0x25d590; // 0x25e200 - g_ps2RecompiledFunctionTable[358527] = bhCheckWall_0x25d590; // 0x25e204 - g_ps2RecompiledFunctionTable[358528] = bhCheckWall_0x25d590; // 0x25e208 - g_ps2RecompiledFunctionTable[358529] = bhCheckWall_0x25d590; // 0x25e20c - g_ps2RecompiledFunctionTable[358530] = bhCheckWall_0x25d590; // 0x25e210 - g_ps2RecompiledFunctionTable[358531] = bhCheckWall_0x25d590; // 0x25e214 - g_ps2RecompiledFunctionTable[358532] = bhCheckWall_0x25d590; // 0x25e218 - g_ps2RecompiledFunctionTable[358533] = bhCheckWall_0x25d590; // 0x25e21c - g_ps2RecompiledFunctionTable[358534] = bhCheckWall_0x25d590; // 0x25e220 - g_ps2RecompiledFunctionTable[358535] = bhCheckWall_0x25d590; // 0x25e224 - g_ps2RecompiledFunctionTable[358536] = bhCheckWall_0x25d590; // 0x25e228 - g_ps2RecompiledFunctionTable[358537] = bhCheckWall_0x25d590; // 0x25e22c - g_ps2RecompiledFunctionTable[358538] = bhCheckWall_0x25d590; // 0x25e230 - g_ps2RecompiledFunctionTable[358539] = bhCheckWall_0x25d590; // 0x25e234 - g_ps2RecompiledFunctionTable[358540] = bhCheckWall_0x25d590; // 0x25e238 - g_ps2RecompiledFunctionTable[358541] = bhCheckWall_0x25d590; // 0x25e23c - g_ps2RecompiledFunctionTable[358542] = bhCheckWall_0x25d590; // 0x25e240 - g_ps2RecompiledFunctionTable[358543] = bhCheckWall_0x25d590; // 0x25e244 - g_ps2RecompiledFunctionTable[358544] = bhCheckWall_0x25d590; // 0x25e248 - g_ps2RecompiledFunctionTable[358545] = bhCheckWall_0x25d590; // 0x25e24c - g_ps2RecompiledFunctionTable[358546] = bhCheckWall_0x25d590; // 0x25e250 - g_ps2RecompiledFunctionTable[358547] = bhCheckWall_0x25d590; // 0x25e254 - g_ps2RecompiledFunctionTable[358548] = bhCheckWall_0x25d590; // 0x25e258 - g_ps2RecompiledFunctionTable[358549] = bhCheckWall_0x25d590; // 0x25e25c - g_ps2RecompiledFunctionTable[358550] = bhCheckWall_0x25d590; // 0x25e260 - g_ps2RecompiledFunctionTable[358551] = bhCheckWall_0x25d590; // 0x25e264 - g_ps2RecompiledFunctionTable[358552] = bhCheckWall_0x25d590; // 0x25e268 - g_ps2RecompiledFunctionTable[358553] = bhCheckWall_0x25d590; // 0x25e26c - g_ps2RecompiledFunctionTable[358554] = bhCheckWall_0x25d590; // 0x25e270 - g_ps2RecompiledFunctionTable[358555] = bhCheckWall_0x25d590; // 0x25e274 - g_ps2RecompiledFunctionTable[358556] = bhCheckWall_0x25d590; // 0x25e278 - g_ps2RecompiledFunctionTable[358557] = bhCheckWall_0x25d590; // 0x25e27c - g_ps2RecompiledFunctionTable[358558] = bhCheckWall_0x25d590; // 0x25e280 - g_ps2RecompiledFunctionTable[358559] = bhCheckWall_0x25d590; // 0x25e284 - g_ps2RecompiledFunctionTable[358560] = bhCheckWall_0x25d590; // 0x25e288 - g_ps2RecompiledFunctionTable[358561] = bhCheckWall_0x25d590; // 0x25e28c - g_ps2RecompiledFunctionTable[358562] = bhCheckWall_0x25d590; // 0x25e290 - g_ps2RecompiledFunctionTable[358563] = bhCheckWall_0x25d590; // 0x25e294 - g_ps2RecompiledFunctionTable[358564] = bhCheckWall_0x25d590; // 0x25e298 - g_ps2RecompiledFunctionTable[358565] = bhCheckWall_0x25d590; // 0x25e29c - g_ps2RecompiledFunctionTable[358566] = bhCheckWall_0x25d590; // 0x25e2a0 - g_ps2RecompiledFunctionTable[358567] = bhCheckWall_0x25d590; // 0x25e2a4 - g_ps2RecompiledFunctionTable[358568] = bhCheckWall_0x25d590; // 0x25e2a8 - g_ps2RecompiledFunctionTable[358569] = bhCheckWall_0x25d590; // 0x25e2ac - g_ps2RecompiledFunctionTable[358570] = bhCheckWall_0x25d590; // 0x25e2b0 - g_ps2RecompiledFunctionTable[358571] = bhCheckWall_0x25d590; // 0x25e2b4 - g_ps2RecompiledFunctionTable[358572] = bhCheckWall_0x25d590; // 0x25e2b8 - g_ps2RecompiledFunctionTable[358573] = bhCheckWall_0x25d590; // 0x25e2bc - g_ps2RecompiledFunctionTable[358574] = bhCheckWall_0x25d590; // 0x25e2c0 - g_ps2RecompiledFunctionTable[358575] = bhCheckWall_0x25d590; // 0x25e2c4 - g_ps2RecompiledFunctionTable[358576] = bhCheckWall_0x25d590; // 0x25e2c8 - g_ps2RecompiledFunctionTable[358577] = bhCheckWall_0x25d590; // 0x25e2cc - g_ps2RecompiledFunctionTable[358578] = bhCheckWall_0x25d590; // 0x25e2d0 - g_ps2RecompiledFunctionTable[358579] = bhCheckWall_0x25d590; // 0x25e2d4 - g_ps2RecompiledFunctionTable[358580] = bhCheckWall_0x25d590; // 0x25e2d8 - g_ps2RecompiledFunctionTable[358581] = bhCheckWall_0x25d590; // 0x25e2dc - g_ps2RecompiledFunctionTable[358582] = bhCheckWall_0x25d590; // 0x25e2e0 - g_ps2RecompiledFunctionTable[358583] = bhCheckWall_0x25d590; // 0x25e2e4 - g_ps2RecompiledFunctionTable[358584] = bhCheckWall_0x25d590; // 0x25e2e8 - g_ps2RecompiledFunctionTable[358585] = bhCheckWall_0x25d590; // 0x25e2ec - g_ps2RecompiledFunctionTable[358586] = bhCheckWall_0x25d590; // 0x25e2f0 - g_ps2RecompiledFunctionTable[358587] = bhCheckWall_0x25d590; // 0x25e2f4 - g_ps2RecompiledFunctionTable[358588] = bhCheckWall_0x25d590; // 0x25e2f8 - g_ps2RecompiledFunctionTable[358589] = bhCheckWall_0x25d590; // 0x25e2fc - g_ps2RecompiledFunctionTable[358590] = bhCheckWall_0x25d590; // 0x25e300 - g_ps2RecompiledFunctionTable[358591] = bhCheckWall_0x25d590; // 0x25e304 - g_ps2RecompiledFunctionTable[358592] = bhCheckWall_0x25d590; // 0x25e308 - g_ps2RecompiledFunctionTable[358593] = bhCheckWall_0x25d590; // 0x25e30c - g_ps2RecompiledFunctionTable[358594] = bhCheckWall_0x25d590; // 0x25e310 - g_ps2RecompiledFunctionTable[358595] = bhCheckWall_0x25d590; // 0x25e314 - g_ps2RecompiledFunctionTable[358596] = bhCheckWall_0x25d590; // 0x25e318 - g_ps2RecompiledFunctionTable[358597] = bhCheckWall_0x25d590; // 0x25e31c - g_ps2RecompiledFunctionTable[358598] = bhCheckWall_0x25d590; // 0x25e320 - g_ps2RecompiledFunctionTable[358599] = bhCheckWall_0x25d590; // 0x25e324 - g_ps2RecompiledFunctionTable[358600] = bhCheckWall_0x25d590; // 0x25e328 - g_ps2RecompiledFunctionTable[358601] = bhCheckWall_0x25d590; // 0x25e32c - g_ps2RecompiledFunctionTable[358602] = bhCheckWall_0x25d590; // 0x25e330 - g_ps2RecompiledFunctionTable[358603] = bhCheckWall_0x25d590; // 0x25e334 - g_ps2RecompiledFunctionTable[358604] = bhCheckWall_0x25d590; // 0x25e338 - g_ps2RecompiledFunctionTable[358605] = bhCheckWall_0x25d590; // 0x25e33c - g_ps2RecompiledFunctionTable[358606] = bhCheckWall_0x25d590; // 0x25e340 - g_ps2RecompiledFunctionTable[358607] = bhCheckWall_0x25d590; // 0x25e344 - g_ps2RecompiledFunctionTable[358608] = bhCheckWall_0x25d590; // 0x25e348 - g_ps2RecompiledFunctionTable[358609] = bhCheckWall_0x25d590; // 0x25e34c - g_ps2RecompiledFunctionTable[358610] = bhCheckWall_0x25d590; // 0x25e350 - g_ps2RecompiledFunctionTable[358611] = bhCheckWall_0x25d590; // 0x25e354 - g_ps2RecompiledFunctionTable[358612] = bhCheckWall_0x25d590; // 0x25e358 - g_ps2RecompiledFunctionTable[358613] = bhCheckWall_0x25d590; // 0x25e35c - g_ps2RecompiledFunctionTable[358614] = bhCheckWall_0x25d590; // 0x25e360 - g_ps2RecompiledFunctionTable[358615] = bhCheckWall_0x25d590; // 0x25e364 - g_ps2RecompiledFunctionTable[358616] = bhCheckWall_0x25d590; // 0x25e368 - g_ps2RecompiledFunctionTable[358617] = bhCheckWall_0x25d590; // 0x25e36c - g_ps2RecompiledFunctionTable[358618] = bhCheckWall_0x25d590; // 0x25e370 - g_ps2RecompiledFunctionTable[358619] = bhCheckWall_0x25d590; // 0x25e374 - g_ps2RecompiledFunctionTable[358620] = bhCheckWall_0x25d590; // 0x25e378 - g_ps2RecompiledFunctionTable[358621] = bhCheckWall_0x25d590; // 0x25e37c - g_ps2RecompiledFunctionTable[358622] = bhCheckWall_0x25d590; // 0x25e380 - g_ps2RecompiledFunctionTable[358623] = bhCheckWall_0x25d590; // 0x25e384 - g_ps2RecompiledFunctionTable[358624] = bhCheckWall_0x25d590; // 0x25e388 - g_ps2RecompiledFunctionTable[358625] = bhCheckWall_0x25d590; // 0x25e38c - g_ps2RecompiledFunctionTable[358626] = bhCheckWall_0x25d590; // 0x25e390 - g_ps2RecompiledFunctionTable[358627] = bhCheckWall_0x25d590; // 0x25e394 - g_ps2RecompiledFunctionTable[358628] = bhCheckWall_0x25d590; // 0x25e398 - g_ps2RecompiledFunctionTable[358629] = bhCheckWall_0x25d590; // 0x25e39c - g_ps2RecompiledFunctionTable[358630] = bhCheckWall_0x25d590; // 0x25e3a0 - g_ps2RecompiledFunctionTable[358631] = bhCheckWall_0x25d590; // 0x25e3a4 - g_ps2RecompiledFunctionTable[358632] = bhCheckWall_0x25d590; // 0x25e3a8 - g_ps2RecompiledFunctionTable[358633] = bhCheckWall_0x25d590; // 0x25e3ac - g_ps2RecompiledFunctionTable[358634] = bhCheckWall_0x25d590; // 0x25e3b0 - g_ps2RecompiledFunctionTable[358635] = bhCheckWall_0x25d590; // 0x25e3b4 - g_ps2RecompiledFunctionTable[358636] = bhCheckWall_0x25d590; // 0x25e3b8 - g_ps2RecompiledFunctionTable[358637] = bhCheckWall_0x25d590; // 0x25e3bc - g_ps2RecompiledFunctionTable[358638] = bhCheckWall_0x25d590; // 0x25e3c0 - g_ps2RecompiledFunctionTable[358639] = bhCheckWall_0x25d590; // 0x25e3c4 - g_ps2RecompiledFunctionTable[358640] = bhCheckWall_0x25d590; // 0x25e3c8 - g_ps2RecompiledFunctionTable[358641] = bhCheckWall_0x25d590; // 0x25e3cc - g_ps2RecompiledFunctionTable[358642] = bhCheckWall_0x25d590; // 0x25e3d0 - g_ps2RecompiledFunctionTable[358643] = bhCheckWall_0x25d590; // 0x25e3d4 - g_ps2RecompiledFunctionTable[358644] = bhCheckWall_0x25d590; // 0x25e3d8 - g_ps2RecompiledFunctionTable[358645] = bhCheckWall_0x25d590; // 0x25e3dc - g_ps2RecompiledFunctionTable[358646] = bhCheckWall_0x25d590; // 0x25e3e0 - g_ps2RecompiledFunctionTable[358647] = bhCheckWall_0x25d590; // 0x25e3e4 - g_ps2RecompiledFunctionTable[358648] = bhCheckWall_0x25d590; // 0x25e3e8 - g_ps2RecompiledFunctionTable[358649] = bhCheckWall_0x25d590; // 0x25e3ec - g_ps2RecompiledFunctionTable[358650] = bhCheckWall_0x25d590; // 0x25e3f0 - g_ps2RecompiledFunctionTable[358651] = bhCheckWall_0x25d590; // 0x25e3f4 - g_ps2RecompiledFunctionTable[358652] = bhCheckWall_0x25d590; // 0x25e3f8 - g_ps2RecompiledFunctionTable[358653] = bhCheckWall_0x25d590; // 0x25e3fc - g_ps2RecompiledFunctionTable[358654] = bhCheckWall_0x25d590; // 0x25e400 - g_ps2RecompiledFunctionTable[358655] = bhCheckWall_0x25d590; // 0x25e404 - g_ps2RecompiledFunctionTable[358656] = bhCheckWall_0x25d590; // 0x25e408 - g_ps2RecompiledFunctionTable[358657] = bhCheckWall_0x25d590; // 0x25e40c - g_ps2RecompiledFunctionTable[358658] = bhCheckWall_0x25d590; // 0x25e410 - g_ps2RecompiledFunctionTable[358659] = bhCheckWall_0x25d590; // 0x25e414 - g_ps2RecompiledFunctionTable[358660] = bhCheckWall_0x25d590; // 0x25e418 - g_ps2RecompiledFunctionTable[358661] = bhCheckWall_0x25d590; // 0x25e41c - g_ps2RecompiledFunctionTable[358662] = bhCheckWall_0x25d590; // 0x25e420 - g_ps2RecompiledFunctionTable[358663] = bhCheckWall_0x25d590; // 0x25e424 - g_ps2RecompiledFunctionTable[358664] = bhCheckWall_0x25d590; // 0x25e428 - g_ps2RecompiledFunctionTable[358665] = bhCheckWall_0x25d590; // 0x25e42c - g_ps2RecompiledFunctionTable[358666] = bhCheckWall_0x25d590; // 0x25e430 - g_ps2RecompiledFunctionTable[358667] = bhCheckWall_0x25d590; // 0x25e434 - g_ps2RecompiledFunctionTable[358668] = bhCheckWall_0x25d590; // 0x25e438 - g_ps2RecompiledFunctionTable[358669] = bhCheckWall_0x25d590; // 0x25e43c - g_ps2RecompiledFunctionTable[358670] = bhCheckWall_0x25d590; // 0x25e440 - g_ps2RecompiledFunctionTable[358671] = bhCheckWall_0x25d590; // 0x25e444 - g_ps2RecompiledFunctionTable[358672] = bhCheckWall_0x25d590; // 0x25e448 - g_ps2RecompiledFunctionTable[358673] = bhCheckWall_0x25d590; // 0x25e44c - g_ps2RecompiledFunctionTable[358674] = bhCheckWall_0x25d590; // 0x25e450 - g_ps2RecompiledFunctionTable[358675] = bhCheckWall_0x25d590; // 0x25e454 - g_ps2RecompiledFunctionTable[358676] = bhCheckWall_0x25d590; // 0x25e458 - g_ps2RecompiledFunctionTable[358677] = bhCheckWall_0x25d590; // 0x25e45c - g_ps2RecompiledFunctionTable[358678] = bhCheckWall_0x25d590; // 0x25e460 - g_ps2RecompiledFunctionTable[358679] = bhCheckWall_0x25d590; // 0x25e464 - g_ps2RecompiledFunctionTable[358680] = bhCheckWall_0x25d590; // 0x25e468 - g_ps2RecompiledFunctionTable[358681] = bhCheckWall_0x25d590; // 0x25e46c - g_ps2RecompiledFunctionTable[358682] = bhCheckWall_0x25d590; // 0x25e470 - g_ps2RecompiledFunctionTable[358683] = bhCheckWall_0x25d590; // 0x25e474 - g_ps2RecompiledFunctionTable[358684] = bhCheckWall_0x25d590; // 0x25e478 - g_ps2RecompiledFunctionTable[358685] = bhCheckWall_0x25d590; // 0x25e47c - g_ps2RecompiledFunctionTable[358686] = bhCheckWall_0x25d590; // 0x25e480 - g_ps2RecompiledFunctionTable[358687] = bhCheckWall_0x25d590; // 0x25e484 - g_ps2RecompiledFunctionTable[358688] = bhCheckWall_0x25d590; // 0x25e488 - g_ps2RecompiledFunctionTable[358689] = bhCheckWall_0x25d590; // 0x25e48c - g_ps2RecompiledFunctionTable[358690] = bhCheckWall_0x25d590; // 0x25e490 - g_ps2RecompiledFunctionTable[358691] = bhCheckWall_0x25d590; // 0x25e494 - g_ps2RecompiledFunctionTable[358692] = bhCheckWall_0x25d590; // 0x25e498 - g_ps2RecompiledFunctionTable[358693] = bhCheckWall_0x25d590; // 0x25e49c - g_ps2RecompiledFunctionTable[358694] = bhCheckWall_0x25d590; // 0x25e4a0 - g_ps2RecompiledFunctionTable[358695] = bhCheckWall_0x25d590; // 0x25e4a4 - g_ps2RecompiledFunctionTable[358696] = bhCheckWall_0x25d590; // 0x25e4a8 - g_ps2RecompiledFunctionTable[358697] = bhCheckWall_0x25d590; // 0x25e4ac - g_ps2RecompiledFunctionTable[358698] = bhCheckWall_0x25d590; // 0x25e4b0 - g_ps2RecompiledFunctionTable[358699] = bhCheckWall_0x25d590; // 0x25e4b4 - g_ps2RecompiledFunctionTable[358700] = bhCheckWall_0x25d590; // 0x25e4b8 - g_ps2RecompiledFunctionTable[358701] = bhCheckWall_0x25d590; // 0x25e4bc - g_ps2RecompiledFunctionTable[358702] = bhCheckWall_0x25d590; // 0x25e4c0 - g_ps2RecompiledFunctionTable[358703] = bhCheckWall_0x25d590; // 0x25e4c4 - g_ps2RecompiledFunctionTable[358704] = bhCheckWall_0x25d590; // 0x25e4c8 - g_ps2RecompiledFunctionTable[358705] = bhCheckWall_0x25d590; // 0x25e4cc - g_ps2RecompiledFunctionTable[358706] = bhCheckWall_0x25d590; // 0x25e4d0 - g_ps2RecompiledFunctionTable[358707] = bhCheckWall_0x25d590; // 0x25e4d4 - g_ps2RecompiledFunctionTable[358708] = bhCheckWall_0x25d590; // 0x25e4d8 - g_ps2RecompiledFunctionTable[358709] = bhCheckWall_0x25d590; // 0x25e4dc - g_ps2RecompiledFunctionTable[358710] = bhCheckWall_0x25d590; // 0x25e4e0 - g_ps2RecompiledFunctionTable[358711] = bhCheckWall_0x25d590; // 0x25e4e4 - g_ps2RecompiledFunctionTable[358712] = bhCheckWall_0x25d590; // 0x25e4e8 - g_ps2RecompiledFunctionTable[358713] = bhCheckWall_0x25d590; // 0x25e4ec - g_ps2RecompiledFunctionTable[358714] = bhCheckWall_0x25d590; // 0x25e4f0 - g_ps2RecompiledFunctionTable[358715] = bhCheckWall_0x25d590; // 0x25e4f4 - g_ps2RecompiledFunctionTable[358716] = bhCheckWall_0x25d590; // 0x25e4f8 - g_ps2RecompiledFunctionTable[358717] = bhCheckWall_0x25d590; // 0x25e4fc - g_ps2RecompiledFunctionTable[358718] = bhCheckWall_0x25d590; // 0x25e500 - g_ps2RecompiledFunctionTable[358719] = bhCheckWall_0x25d590; // 0x25e504 - g_ps2RecompiledFunctionTable[358720] = bhCheckWall_0x25d590; // 0x25e508 - g_ps2RecompiledFunctionTable[358721] = bhCheckWall_0x25d590; // 0x25e50c - g_ps2RecompiledFunctionTable[358722] = bhCheckWall_0x25d590; // 0x25e510 - g_ps2RecompiledFunctionTable[358723] = bhCheckWall_0x25d590; // 0x25e514 - g_ps2RecompiledFunctionTable[358724] = bhCheckWall_0x25d590; // 0x25e518 - g_ps2RecompiledFunctionTable[358725] = bhCheckWall_0x25d590; // 0x25e51c - g_ps2RecompiledFunctionTable[358726] = bhCheckWall_0x25d590; // 0x25e520 - g_ps2RecompiledFunctionTable[358727] = bhCheckWall_0x25d590; // 0x25e524 - g_ps2RecompiledFunctionTable[358728] = bhCheckWall_0x25d590; // 0x25e528 - g_ps2RecompiledFunctionTable[358729] = bhCheckWall_0x25d590; // 0x25e52c - g_ps2RecompiledFunctionTable[358730] = bhCheckWall_0x25d590; // 0x25e530 - g_ps2RecompiledFunctionTable[358731] = bhCheckWall_0x25d590; // 0x25e534 - g_ps2RecompiledFunctionTable[358732] = bhCheckWall_0x25d590; // 0x25e538 - g_ps2RecompiledFunctionTable[358733] = bhCheckWall_0x25d590; // 0x25e53c - g_ps2RecompiledFunctionTable[358734] = bhCheckWall_0x25d590; // 0x25e540 - g_ps2RecompiledFunctionTable[358735] = bhCheckWall_0x25d590; // 0x25e544 - g_ps2RecompiledFunctionTable[358736] = bhCheckWall_0x25d590; // 0x25e548 - g_ps2RecompiledFunctionTable[358737] = bhCheckWall_0x25d590; // 0x25e54c - g_ps2RecompiledFunctionTable[358738] = bhCheckWall_0x25d590; // 0x25e550 - g_ps2RecompiledFunctionTable[358739] = bhCheckWall_0x25d590; // 0x25e554 - g_ps2RecompiledFunctionTable[358740] = bhCheckWall_0x25d590; // 0x25e558 - g_ps2RecompiledFunctionTable[358741] = bhCheckWall_0x25d590; // 0x25e55c - g_ps2RecompiledFunctionTable[358742] = bhCheckWall_0x25d590; // 0x25e560 - g_ps2RecompiledFunctionTable[358743] = bhCheckWall_0x25d590; // 0x25e564 - g_ps2RecompiledFunctionTable[358744] = bhCheckWall_0x25d590; // 0x25e568 - g_ps2RecompiledFunctionTable[358745] = bhCheckWall_0x25d590; // 0x25e56c - g_ps2RecompiledFunctionTable[358746] = bhCheckWall_0x25d590; // 0x25e570 - g_ps2RecompiledFunctionTable[358747] = bhCheckWall_0x25d590; // 0x25e574 - g_ps2RecompiledFunctionTable[358748] = bhCheckWall_0x25d590; // 0x25e578 - g_ps2RecompiledFunctionTable[358749] = bhCheckWall_0x25d590; // 0x25e57c - g_ps2RecompiledFunctionTable[358750] = bhCheckWall_0x25d590; // 0x25e580 - g_ps2RecompiledFunctionTable[358751] = bhCheckWall_0x25d590; // 0x25e584 - g_ps2RecompiledFunctionTable[358752] = bhCheckWall_0x25d590; // 0x25e588 - g_ps2RecompiledFunctionTable[358753] = bhCheckWall_0x25d590; // 0x25e58c - g_ps2RecompiledFunctionTable[358754] = bhCheckWall_0x25d590; // 0x25e590 - g_ps2RecompiledFunctionTable[358755] = bhCheckWall_0x25d590; // 0x25e594 - g_ps2RecompiledFunctionTable[358756] = bhCheckWall_0x25d590; // 0x25e598 - g_ps2RecompiledFunctionTable[358757] = bhCheckWall_0x25d590; // 0x25e59c - g_ps2RecompiledFunctionTable[358758] = bhCheckWall_0x25d590; // 0x25e5a0 - g_ps2RecompiledFunctionTable[358759] = bhCheckWall_0x25d590; // 0x25e5a4 - g_ps2RecompiledFunctionTable[358760] = bhCheckWall_0x25d590; // 0x25e5a8 - g_ps2RecompiledFunctionTable[358761] = bhCheckWall_0x25d590; // 0x25e5ac - g_ps2RecompiledFunctionTable[358762] = bhCheckWall_0x25d590; // 0x25e5b0 - g_ps2RecompiledFunctionTable[358763] = bhCheckWall_0x25d590; // 0x25e5b4 - g_ps2RecompiledFunctionTable[358764] = bhCheckWall_0x25d590; // 0x25e5b8 - g_ps2RecompiledFunctionTable[358765] = bhCheckWall_0x25d590; // 0x25e5bc - g_ps2RecompiledFunctionTable[358766] = bhCheckWall_0x25d590; // 0x25e5c0 - g_ps2RecompiledFunctionTable[358767] = bhCheckWall_0x25d590; // 0x25e5c4 - g_ps2RecompiledFunctionTable[358768] = bhCheckWall_0x25d590; // 0x25e5c8 - g_ps2RecompiledFunctionTable[358769] = bhCheckWall_0x25d590; // 0x25e5cc - g_ps2RecompiledFunctionTable[358770] = bhCheckWall_0x25d590; // 0x25e5d0 - g_ps2RecompiledFunctionTable[358771] = bhCheckWall_0x25d590; // 0x25e5d4 - g_ps2RecompiledFunctionTable[358772] = bhCheckWall_0x25d590; // 0x25e5d8 - g_ps2RecompiledFunctionTable[358773] = bhCheckWall_0x25d590; // 0x25e5dc - g_ps2RecompiledFunctionTable[358774] = bhCheckWall_0x25d590; // 0x25e5e0 - g_ps2RecompiledFunctionTable[358775] = bhCheckWall_0x25d590; // 0x25e5e4 - g_ps2RecompiledFunctionTable[358776] = bhCheckWall_0x25d590; // 0x25e5e8 - g_ps2RecompiledFunctionTable[358777] = bhCheckWall_0x25d590; // 0x25e5ec - g_ps2RecompiledFunctionTable[358778] = bhCheckWall_0x25d590; // 0x25e5f0 - g_ps2RecompiledFunctionTable[358779] = bhCheckWall_0x25d590; // 0x25e5f4 - g_ps2RecompiledFunctionTable[358780] = bhCheckWall_0x25d590; // 0x25e5f8 - g_ps2RecompiledFunctionTable[358781] = bhCheckWall_0x25d590; // 0x25e5fc - g_ps2RecompiledFunctionTable[358782] = bhCheckWall_0x25d590; // 0x25e600 - g_ps2RecompiledFunctionTable[358783] = bhCheckWall_0x25d590; // 0x25e604 - g_ps2RecompiledFunctionTable[358784] = bhCheckWall_0x25d590; // 0x25e608 - g_ps2RecompiledFunctionTable[358785] = bhCheckWall_0x25d590; // 0x25e60c - g_ps2RecompiledFunctionTable[358786] = bhCheckWall_0x25d590; // 0x25e610 - g_ps2RecompiledFunctionTable[358787] = bhCheckWall_0x25d590; // 0x25e614 - g_ps2RecompiledFunctionTable[358788] = bhCheckWall_0x25d590; // 0x25e618 - g_ps2RecompiledFunctionTable[358789] = bhCheckWall_0x25d590; // 0x25e61c - g_ps2RecompiledFunctionTable[358790] = bhCheckWall_0x25d590; // 0x25e620 - g_ps2RecompiledFunctionTable[358791] = bhCheckWall_0x25d590; // 0x25e624 - g_ps2RecompiledFunctionTable[358792] = bhCheckWall_0x25d590; // 0x25e628 - g_ps2RecompiledFunctionTable[358793] = bhCheckWall_0x25d590; // 0x25e62c - g_ps2RecompiledFunctionTable[358794] = bhCheckWall_0x25d590; // 0x25e630 - g_ps2RecompiledFunctionTable[358795] = bhCheckWall_0x25d590; // 0x25e634 - g_ps2RecompiledFunctionTable[358796] = bhCheckWall_0x25d590; // 0x25e638 - g_ps2RecompiledFunctionTable[358797] = bhCheckWall_0x25d590; // 0x25e63c - g_ps2RecompiledFunctionTable[358798] = bhCheckWall_0x25d590; // 0x25e640 - g_ps2RecompiledFunctionTable[358799] = bhCheckWall_0x25d590; // 0x25e644 - g_ps2RecompiledFunctionTable[358800] = bhCheckWall_0x25d590; // 0x25e648 - g_ps2RecompiledFunctionTable[358801] = bhCheckWall_0x25d590; // 0x25e64c - g_ps2RecompiledFunctionTable[358802] = bhCheckWall_0x25d590; // 0x25e650 - g_ps2RecompiledFunctionTable[358803] = bhCheckWall_0x25d590; // 0x25e654 - g_ps2RecompiledFunctionTable[358804] = bhCheckWall_0x25d590; // 0x25e658 - g_ps2RecompiledFunctionTable[358805] = bhCheckWall_0x25d590; // 0x25e65c - g_ps2RecompiledFunctionTable[358806] = bhCheckWall_0x25d590; // 0x25e660 - g_ps2RecompiledFunctionTable[358807] = bhCheckWall_0x25d590; // 0x25e664 - g_ps2RecompiledFunctionTable[358808] = bhCheckWall_0x25d590; // 0x25e668 - g_ps2RecompiledFunctionTable[358809] = bhCheckWall_0x25d590; // 0x25e66c - g_ps2RecompiledFunctionTable[358810] = bhCheckWall_0x25d590; // 0x25e670 - g_ps2RecompiledFunctionTable[358811] = bhCheckWall_0x25d590; // 0x25e674 - g_ps2RecompiledFunctionTable[358812] = bhCheckWall_0x25d590; // 0x25e678 - g_ps2RecompiledFunctionTable[358813] = bhCheckWall_0x25d590; // 0x25e67c - g_ps2RecompiledFunctionTable[358814] = bhCheckWall_0x25d590; // 0x25e680 - g_ps2RecompiledFunctionTable[358815] = bhCheckWall_0x25d590; // 0x25e684 - g_ps2RecompiledFunctionTable[358816] = bhCheckWall_0x25d590; // 0x25e688 - g_ps2RecompiledFunctionTable[358817] = bhCheckWall_0x25d590; // 0x25e68c - g_ps2RecompiledFunctionTable[358818] = bhCheckWall_0x25d590; // 0x25e690 - g_ps2RecompiledFunctionTable[358819] = bhCheckWall_0x25d590; // 0x25e694 - g_ps2RecompiledFunctionTable[358820] = bhCheckWall_0x25d590; // 0x25e698 - g_ps2RecompiledFunctionTable[358821] = bhCheckWall_0x25d590; // 0x25e69c - g_ps2RecompiledFunctionTable[358822] = bhCheckWall_0x25d590; // 0x25e6a0 - g_ps2RecompiledFunctionTable[358823] = bhCheckWall_0x25d590; // 0x25e6a4 - g_ps2RecompiledFunctionTable[358824] = bhCheckWall_0x25d590; // 0x25e6a8 - g_ps2RecompiledFunctionTable[358825] = bhCheckWall_0x25d590; // 0x25e6ac - g_ps2RecompiledFunctionTable[358826] = bhCheckWall_0x25d590; // 0x25e6b0 - g_ps2RecompiledFunctionTable[358827] = bhCheckWall_0x25d590; // 0x25e6b4 - g_ps2RecompiledFunctionTable[358828] = bhCheckWall_0x25d590; // 0x25e6b8 - g_ps2RecompiledFunctionTable[358829] = bhCheckWall_0x25d590; // 0x25e6bc - g_ps2RecompiledFunctionTable[358830] = bhCheckWall_0x25d590; // 0x25e6c0 - g_ps2RecompiledFunctionTable[358831] = bhCheckWall_0x25d590; // 0x25e6c4 - g_ps2RecompiledFunctionTable[358832] = bhCheckWall_0x25d590; // 0x25e6c8 - g_ps2RecompiledFunctionTable[358833] = bhCheckWall_0x25d590; // 0x25e6cc - g_ps2RecompiledFunctionTable[358834] = bhCheckWall_0x25d590; // 0x25e6d0 - g_ps2RecompiledFunctionTable[358835] = bhCheckWall_0x25d590; // 0x25e6d4 - g_ps2RecompiledFunctionTable[358836] = bhCheckWall_0x25d590; // 0x25e6d8 - g_ps2RecompiledFunctionTable[358837] = bhCheckWall_0x25d590; // 0x25e6dc - g_ps2RecompiledFunctionTable[358838] = bhCheckWall_0x25d590; // 0x25e6e0 - g_ps2RecompiledFunctionTable[358839] = bhCheckWall_0x25d590; // 0x25e6e4 - g_ps2RecompiledFunctionTable[358840] = bhCheckWall_0x25d590; // 0x25e6e8 - g_ps2RecompiledFunctionTable[358841] = bhCheckWall_0x25d590; // 0x25e6ec - g_ps2RecompiledFunctionTable[358842] = bhCheckWall_0x25d590; // 0x25e6f0 - g_ps2RecompiledFunctionTable[358843] = bhCheckWall_0x25d590; // 0x25e6f4 - g_ps2RecompiledFunctionTable[358844] = bhCheckWall_0x25d590; // 0x25e6f8 - g_ps2RecompiledFunctionTable[358845] = bhCheckWall_0x25d590; // 0x25e6fc - g_ps2RecompiledFunctionTable[358846] = bhCheckWall_0x25d590; // 0x25e700 - g_ps2RecompiledFunctionTable[358847] = bhCheckWall_0x25d590; // 0x25e704 - g_ps2RecompiledFunctionTable[358848] = bhCheckWall_0x25d590; // 0x25e708 - g_ps2RecompiledFunctionTable[358849] = bhCheckWall_0x25d590; // 0x25e70c - g_ps2RecompiledFunctionTable[358850] = bhCheckWall_0x25d590; // 0x25e710 - g_ps2RecompiledFunctionTable[358851] = bhCheckWall_0x25d590; // 0x25e714 - g_ps2RecompiledFunctionTable[358852] = bhCheckWall_0x25d590; // 0x25e718 - g_ps2RecompiledFunctionTable[358853] = bhCheckWall_0x25d590; // 0x25e71c - g_ps2RecompiledFunctionTable[358854] = bhCheckWall_0x25d590; // 0x25e720 - g_ps2RecompiledFunctionTable[358855] = bhCheckWall_0x25d590; // 0x25e724 - g_ps2RecompiledFunctionTable[358856] = bhCheckWall_0x25d590; // 0x25e728 - g_ps2RecompiledFunctionTable[358857] = bhCheckWall_0x25d590; // 0x25e72c - g_ps2RecompiledFunctionTable[358858] = bhCheckWall_0x25d590; // 0x25e730 - g_ps2RecompiledFunctionTable[358859] = bhCheckWall_0x25d590; // 0x25e734 - g_ps2RecompiledFunctionTable[358860] = bhCheckWall_0x25d590; // 0x25e738 - g_ps2RecompiledFunctionTable[358861] = bhCheckWall_0x25d590; // 0x25e73c - g_ps2RecompiledFunctionTable[358862] = bhCheckWall_0x25d590; // 0x25e740 - g_ps2RecompiledFunctionTable[358863] = bhCheckWall_0x25d590; // 0x25e744 - g_ps2RecompiledFunctionTable[358864] = bhCheckWall_0x25d590; // 0x25e748 - g_ps2RecompiledFunctionTable[358865] = bhCheckWall_0x25d590; // 0x25e74c - g_ps2RecompiledFunctionTable[358866] = bhCheckWall_0x25d590; // 0x25e750 - g_ps2RecompiledFunctionTable[358867] = bhCheckWall_0x25d590; // 0x25e754 - g_ps2RecompiledFunctionTable[358868] = bhCheckWall_0x25d590; // 0x25e758 - g_ps2RecompiledFunctionTable[358869] = bhCheckWall_0x25d590; // 0x25e75c - g_ps2RecompiledFunctionTable[358870] = bhCheckWall_0x25d590; // 0x25e760 - g_ps2RecompiledFunctionTable[358871] = bhCheckWall_0x25d590; // 0x25e764 - g_ps2RecompiledFunctionTable[358872] = bhCheckWall_0x25d590; // 0x25e768 - g_ps2RecompiledFunctionTable[358873] = bhCheckWall_0x25d590; // 0x25e76c - g_ps2RecompiledFunctionTable[358874] = bhCheckWall_0x25d590; // 0x25e770 - g_ps2RecompiledFunctionTable[358875] = bhCheckWall_0x25d590; // 0x25e774 - g_ps2RecompiledFunctionTable[358876] = bhCheckWall_0x25d590; // 0x25e778 - g_ps2RecompiledFunctionTable[358877] = bhCheckWall_0x25d590; // 0x25e77c - g_ps2RecompiledFunctionTable[358878] = bhCheckWall_0x25d590; // 0x25e780 - g_ps2RecompiledFunctionTable[358879] = bhCheckWall_0x25d590; // 0x25e784 - g_ps2RecompiledFunctionTable[358880] = bhCheckWall_0x25d590; // 0x25e788 - g_ps2RecompiledFunctionTable[358881] = bhCheckWall_0x25d590; // 0x25e78c - g_ps2RecompiledFunctionTable[358882] = bhCheckWall_0x25d590; // 0x25e790 - g_ps2RecompiledFunctionTable[358883] = bhCheckWall_0x25d590; // 0x25e794 - g_ps2RecompiledFunctionTable[358884] = bhCheckWall_0x25d590; // 0x25e798 - g_ps2RecompiledFunctionTable[358885] = bhCheckWall_0x25d590; // 0x25e79c - g_ps2RecompiledFunctionTable[358886] = bhCheckWall_0x25d590; // 0x25e7a0 - g_ps2RecompiledFunctionTable[358887] = bhCheckWall_0x25d590; // 0x25e7a4 - g_ps2RecompiledFunctionTable[358888] = bhCheckWall_0x25d590; // 0x25e7a8 - g_ps2RecompiledFunctionTable[358889] = bhCheckWall_0x25d590; // 0x25e7ac - g_ps2RecompiledFunctionTable[358890] = bhCheckWall_0x25d590; // 0x25e7b0 - g_ps2RecompiledFunctionTable[358891] = bhCheckWall_0x25d590; // 0x25e7b4 - g_ps2RecompiledFunctionTable[358892] = bhCheckWall_0x25d590; // 0x25e7b8 - g_ps2RecompiledFunctionTable[358893] = bhCheckWall_0x25d590; // 0x25e7bc - g_ps2RecompiledFunctionTable[358894] = bhCheckWall_0x25d590; // 0x25e7c0 - g_ps2RecompiledFunctionTable[358895] = bhCheckWall_0x25d590; // 0x25e7c4 - g_ps2RecompiledFunctionTable[358896] = bhCheckWall_0x25d590; // 0x25e7c8 - g_ps2RecompiledFunctionTable[358897] = bhCheckWall_0x25d590; // 0x25e7cc - g_ps2RecompiledFunctionTable[358898] = bhCheckWall_0x25d590; // 0x25e7d0 - g_ps2RecompiledFunctionTable[358899] = bhCheckWall_0x25d590; // 0x25e7d4 - g_ps2RecompiledFunctionTable[358900] = bhCheckWall_0x25d590; // 0x25e7d8 - g_ps2RecompiledFunctionTable[358901] = bhCheckWall_0x25d590; // 0x25e7dc - g_ps2RecompiledFunctionTable[358902] = bhCheckWall_0x25d590; // 0x25e7e0 - g_ps2RecompiledFunctionTable[358903] = bhCheckWall_0x25d590; // 0x25e7e4 - g_ps2RecompiledFunctionTable[358904] = bhCheckWall_0x25d590; // 0x25e7e8 - g_ps2RecompiledFunctionTable[358905] = bhCheckWall_0x25d590; // 0x25e7ec - g_ps2RecompiledFunctionTable[358906] = bhCheckWall_0x25d590; // 0x25e7f0 - g_ps2RecompiledFunctionTable[358907] = bhCheckWall_0x25d590; // 0x25e7f4 - g_ps2RecompiledFunctionTable[358908] = bhCheckWall_0x25d590; // 0x25e7f8 - g_ps2RecompiledFunctionTable[358909] = bhCheckWall_0x25d590; // 0x25e7fc - g_ps2RecompiledFunctionTable[358910] = bhCheckWall_0x25d590; // 0x25e800 - g_ps2RecompiledFunctionTable[358911] = bhCheckWall_0x25d590; // 0x25e804 - g_ps2RecompiledFunctionTable[358912] = bhCheckWall_0x25d590; // 0x25e808 - g_ps2RecompiledFunctionTable[358913] = bhCheckWall_0x25d590; // 0x25e80c - g_ps2RecompiledFunctionTable[358914] = bhCheckWall_0x25d590; // 0x25e810 - g_ps2RecompiledFunctionTable[358915] = bhCheckWall_0x25d590; // 0x25e814 - g_ps2RecompiledFunctionTable[358916] = bhCheckWall_0x25d590; // 0x25e818 - g_ps2RecompiledFunctionTable[358917] = bhCheckWall_0x25d590; // 0x25e81c - g_ps2RecompiledFunctionTable[358918] = bhCheckWall_0x25d590; // 0x25e820 - g_ps2RecompiledFunctionTable[358919] = bhCheckWall_0x25d590; // 0x25e824 - g_ps2RecompiledFunctionTable[358920] = bhCheckWall_0x25d590; // 0x25e828 - g_ps2RecompiledFunctionTable[358921] = bhCheckWall_0x25d590; // 0x25e82c - g_ps2RecompiledFunctionTable[358922] = bhCheckWall_0x25d590; // 0x25e830 - g_ps2RecompiledFunctionTable[358923] = bhCheckWall_0x25d590; // 0x25e834 - g_ps2RecompiledFunctionTable[358924] = bhCheckWall_0x25d590; // 0x25e838 - g_ps2RecompiledFunctionTable[358925] = bhCheckWall_0x25d590; // 0x25e83c - g_ps2RecompiledFunctionTable[358926] = bhCheckWall_0x25d590; // 0x25e840 - g_ps2RecompiledFunctionTable[358927] = bhCheckWall_0x25d590; // 0x25e844 - g_ps2RecompiledFunctionTable[358928] = bhCheckWall_0x25d590; // 0x25e848 - g_ps2RecompiledFunctionTable[358929] = bhCheckWall_0x25d590; // 0x25e84c - g_ps2RecompiledFunctionTable[358930] = bhCheckWall_0x25d590; // 0x25e850 - g_ps2RecompiledFunctionTable[358931] = bhCheckWall_0x25d590; // 0x25e854 - g_ps2RecompiledFunctionTable[358932] = bhCheckWall_0x25d590; // 0x25e858 - g_ps2RecompiledFunctionTable[358933] = bhCheckWall_0x25d590; // 0x25e85c - g_ps2RecompiledFunctionTable[358934] = bhCheckWall_0x25d590; // 0x25e860 - g_ps2RecompiledFunctionTable[358935] = bhCheckWall_0x25d590; // 0x25e864 - g_ps2RecompiledFunctionTable[358936] = bhCheckWall_0x25d590; // 0x25e868 - g_ps2RecompiledFunctionTable[358937] = bhCheckWall_0x25d590; // 0x25e86c - g_ps2RecompiledFunctionTable[358938] = bhCheckWall_0x25d590; // 0x25e870 - g_ps2RecompiledFunctionTable[358939] = bhCheckWall_0x25d590; // 0x25e874 - g_ps2RecompiledFunctionTable[358940] = bhCheckWall_0x25d590; // 0x25e878 - g_ps2RecompiledFunctionTable[358941] = bhCheckWall_0x25d590; // 0x25e87c - g_ps2RecompiledFunctionTable[358942] = bhCheckWall_0x25d590; // 0x25e880 - g_ps2RecompiledFunctionTable[358943] = bhCheckWall_0x25d590; // 0x25e884 - g_ps2RecompiledFunctionTable[358944] = bhCheckWall_0x25d590; // 0x25e888 - g_ps2RecompiledFunctionTable[358945] = bhCheckWall_0x25d590; // 0x25e88c - g_ps2RecompiledFunctionTable[358946] = bhCheckWall_0x25d590; // 0x25e890 - g_ps2RecompiledFunctionTable[358947] = bhCheckWall_0x25d590; // 0x25e894 - g_ps2RecompiledFunctionTable[358948] = bhCheckWall_0x25d590; // 0x25e898 - g_ps2RecompiledFunctionTable[358949] = bhCheckWall_0x25d590; // 0x25e89c - g_ps2RecompiledFunctionTable[358950] = bhCheckWall_0x25d590; // 0x25e8a0 - g_ps2RecompiledFunctionTable[358951] = bhCheckWall_0x25d590; // 0x25e8a4 - g_ps2RecompiledFunctionTable[358952] = bhCheckWall_0x25d590; // 0x25e8a8 - g_ps2RecompiledFunctionTable[358953] = bhCheckWall_0x25d590; // 0x25e8ac - g_ps2RecompiledFunctionTable[358954] = bhCheckWall_0x25d590; // 0x25e8b0 - g_ps2RecompiledFunctionTable[358955] = bhCheckWall_0x25d590; // 0x25e8b4 - g_ps2RecompiledFunctionTable[358956] = bhCheckWall_0x25d590; // 0x25e8b8 - g_ps2RecompiledFunctionTable[358957] = bhCheckWall_0x25d590; // 0x25e8bc - g_ps2RecompiledFunctionTable[358958] = bhCheckWall_0x25d590; // 0x25e8c0 - g_ps2RecompiledFunctionTable[358959] = bhCheckWall_0x25d590; // 0x25e8c4 - g_ps2RecompiledFunctionTable[358960] = bhCheckWall_0x25d590; // 0x25e8c8 - g_ps2RecompiledFunctionTable[358961] = bhCheckWall_0x25d590; // 0x25e8cc - g_ps2RecompiledFunctionTable[358962] = bhCheckWall_0x25d590; // 0x25e8d0 - g_ps2RecompiledFunctionTable[358963] = bhCheckWall_0x25d590; // 0x25e8d4 - g_ps2RecompiledFunctionTable[358964] = bhCheckWall_0x25d590; // 0x25e8d8 - g_ps2RecompiledFunctionTable[358965] = bhCheckWall_0x25d590; // 0x25e8dc - g_ps2RecompiledFunctionTable[358966] = bhCheckWall_0x25d590; // 0x25e8e0 - g_ps2RecompiledFunctionTable[358967] = bhCheckWall_0x25d590; // 0x25e8e4 - g_ps2RecompiledFunctionTable[358968] = bhCheckWall_0x25d590; // 0x25e8e8 - g_ps2RecompiledFunctionTable[358969] = bhCheckWall_0x25d590; // 0x25e8ec - g_ps2RecompiledFunctionTable[358970] = bhCheckWall_0x25d590; // 0x25e8f0 - g_ps2RecompiledFunctionTable[358971] = bhCheckWall_0x25d590; // 0x25e8f4 - g_ps2RecompiledFunctionTable[358972] = bhCheckWall_0x25d590; // 0x25e8f8 - g_ps2RecompiledFunctionTable[358973] = bhCheckWall_0x25d590; // 0x25e8fc - g_ps2RecompiledFunctionTable[358974] = bhCheckWall_0x25d590; // 0x25e900 - g_ps2RecompiledFunctionTable[358975] = bhCheckWall_0x25d590; // 0x25e904 - g_ps2RecompiledFunctionTable[358976] = bhCheckWall_0x25d590; // 0x25e908 - g_ps2RecompiledFunctionTable[358977] = bhCheckWall_0x25d590; // 0x25e90c - g_ps2RecompiledFunctionTable[358978] = bhCheckWall_0x25d590; // 0x25e910 - g_ps2RecompiledFunctionTable[358979] = bhCheckWall_0x25d590; // 0x25e914 - g_ps2RecompiledFunctionTable[358980] = bhCheckWall_0x25d590; // 0x25e918 - g_ps2RecompiledFunctionTable[358981] = bhCheckWall_0x25d590; // 0x25e91c - g_ps2RecompiledFunctionTable[358982] = bhCheckWall_0x25d590; // 0x25e920 - g_ps2RecompiledFunctionTable[358986] = bhCheckWallEx_0x25e930; // 0x25e930 - g_ps2RecompiledFunctionTable[358987] = bhCheckWallEx_0x25e930; // 0x25e934 - g_ps2RecompiledFunctionTable[358988] = bhCheckWallEx_0x25e930; // 0x25e938 - g_ps2RecompiledFunctionTable[358989] = bhCheckWallEx_0x25e930; // 0x25e93c - g_ps2RecompiledFunctionTable[358990] = bhCheckWallEx_0x25e930; // 0x25e940 - g_ps2RecompiledFunctionTable[358991] = bhCheckWallEx_0x25e930; // 0x25e944 - g_ps2RecompiledFunctionTable[358992] = bhCheckWallEx_0x25e930; // 0x25e948 - g_ps2RecompiledFunctionTable[358993] = bhCheckWallEx_0x25e930; // 0x25e94c - g_ps2RecompiledFunctionTable[358994] = bhCheckWallEx_0x25e930; // 0x25e950 - g_ps2RecompiledFunctionTable[358995] = bhCheckWallEx_0x25e930; // 0x25e954 - g_ps2RecompiledFunctionTable[358996] = bhCheckWallEx_0x25e930; // 0x25e958 - g_ps2RecompiledFunctionTable[358997] = bhCheckWallEx_0x25e930; // 0x25e95c - g_ps2RecompiledFunctionTable[358998] = bhCheckWallEx_0x25e930; // 0x25e960 - g_ps2RecompiledFunctionTable[358999] = bhCheckWallEx_0x25e930; // 0x25e964 - g_ps2RecompiledFunctionTable[359000] = bhCheckWallEx_0x25e930; // 0x25e968 - g_ps2RecompiledFunctionTable[359001] = bhCheckWallEx_0x25e930; // 0x25e96c - g_ps2RecompiledFunctionTable[359002] = bhCheckWallEx_0x25e930; // 0x25e970 - g_ps2RecompiledFunctionTable[359003] = bhCheckWallEx_0x25e930; // 0x25e974 - g_ps2RecompiledFunctionTable[359004] = bhCheckWallEx_0x25e930; // 0x25e978 - g_ps2RecompiledFunctionTable[359005] = bhCheckWallEx_0x25e930; // 0x25e97c - g_ps2RecompiledFunctionTable[359006] = bhCheckWallEx_0x25e930; // 0x25e980 - g_ps2RecompiledFunctionTable[359007] = bhCheckWallEx_0x25e930; // 0x25e984 - g_ps2RecompiledFunctionTable[359008] = bhCheckWallEx_0x25e930; // 0x25e988 - g_ps2RecompiledFunctionTable[359009] = bhCheckWallEx_0x25e930; // 0x25e98c - g_ps2RecompiledFunctionTable[359010] = bhCheckWallEx_0x25e930; // 0x25e990 - g_ps2RecompiledFunctionTable[359011] = bhCheckWallEx_0x25e930; // 0x25e994 - g_ps2RecompiledFunctionTable[359012] = bhCheckWallEx_0x25e930; // 0x25e998 - g_ps2RecompiledFunctionTable[359013] = bhCheckWallEx_0x25e930; // 0x25e99c - g_ps2RecompiledFunctionTable[359014] = bhCheckWallEx_0x25e930; // 0x25e9a0 - g_ps2RecompiledFunctionTable[359015] = bhCheckWallEx_0x25e930; // 0x25e9a4 - g_ps2RecompiledFunctionTable[359016] = bhCheckWallEx_0x25e930; // 0x25e9a8 - g_ps2RecompiledFunctionTable[359017] = bhCheckWallEx_0x25e930; // 0x25e9ac - g_ps2RecompiledFunctionTable[359018] = bhCheckWallEx_0x25e930; // 0x25e9b0 - g_ps2RecompiledFunctionTable[359019] = bhCheckWallEx_0x25e930; // 0x25e9b4 - g_ps2RecompiledFunctionTable[359020] = bhCheckWallEx_0x25e930; // 0x25e9b8 - g_ps2RecompiledFunctionTable[359021] = bhCheckWallEx_0x25e930; // 0x25e9bc - g_ps2RecompiledFunctionTable[359022] = bhCheckWallEx_0x25e930; // 0x25e9c0 - g_ps2RecompiledFunctionTable[359023] = bhCheckWallEx_0x25e930; // 0x25e9c4 - g_ps2RecompiledFunctionTable[359024] = bhCheckWallEx_0x25e930; // 0x25e9c8 - g_ps2RecompiledFunctionTable[359025] = bhCheckWallEx_0x25e930; // 0x25e9cc - g_ps2RecompiledFunctionTable[359026] = bhCheckWallEx_0x25e930; // 0x25e9d0 - g_ps2RecompiledFunctionTable[359027] = bhCheckWallEx_0x25e930; // 0x25e9d4 - g_ps2RecompiledFunctionTable[359028] = bhCheckWallEx_0x25e930; // 0x25e9d8 - g_ps2RecompiledFunctionTable[359029] = bhCheckWallEx_0x25e930; // 0x25e9dc - g_ps2RecompiledFunctionTable[359030] = bhCheckWallEx_0x25e930; // 0x25e9e0 - g_ps2RecompiledFunctionTable[359031] = bhCheckWallEx_0x25e930; // 0x25e9e4 - g_ps2RecompiledFunctionTable[359032] = bhCheckWallEx_0x25e930; // 0x25e9e8 - g_ps2RecompiledFunctionTable[359033] = bhCheckWallEx_0x25e930; // 0x25e9ec - g_ps2RecompiledFunctionTable[359034] = bhCheckWallEx_0x25e930; // 0x25e9f0 - g_ps2RecompiledFunctionTable[359035] = bhCheckWallEx_0x25e930; // 0x25e9f4 - g_ps2RecompiledFunctionTable[359036] = bhCheckWallEx_0x25e930; // 0x25e9f8 - g_ps2RecompiledFunctionTable[359037] = bhCheckWallEx_0x25e930; // 0x25e9fc - g_ps2RecompiledFunctionTable[359038] = bhCheckWallEx_0x25e930; // 0x25ea00 - g_ps2RecompiledFunctionTable[359039] = bhCheckWallEx_0x25e930; // 0x25ea04 - g_ps2RecompiledFunctionTable[359040] = bhCheckWallEx_0x25e930; // 0x25ea08 - g_ps2RecompiledFunctionTable[359041] = bhCheckWallEx_0x25e930; // 0x25ea0c - g_ps2RecompiledFunctionTable[359042] = bhCheckWallEx_0x25e930; // 0x25ea10 - g_ps2RecompiledFunctionTable[359043] = bhCheckWallEx_0x25e930; // 0x25ea14 - g_ps2RecompiledFunctionTable[359044] = bhCheckWallEx_0x25e930; // 0x25ea18 - g_ps2RecompiledFunctionTable[359045] = bhCheckWallEx_0x25e930; // 0x25ea1c - g_ps2RecompiledFunctionTable[359046] = bhCheckWallEx_0x25e930; // 0x25ea20 - g_ps2RecompiledFunctionTable[359047] = bhCheckWallEx_0x25e930; // 0x25ea24 - g_ps2RecompiledFunctionTable[359048] = bhCheckWallEx_0x25e930; // 0x25ea28 - g_ps2RecompiledFunctionTable[359049] = bhCheckWallEx_0x25e930; // 0x25ea2c - g_ps2RecompiledFunctionTable[359050] = bhCheckWallEx_0x25e930; // 0x25ea30 - g_ps2RecompiledFunctionTable[359051] = bhCheckWallEx_0x25e930; // 0x25ea34 - g_ps2RecompiledFunctionTable[359052] = bhCheckWallEx_0x25e930; // 0x25ea38 - g_ps2RecompiledFunctionTable[359053] = bhCheckWallEx_0x25e930; // 0x25ea3c - g_ps2RecompiledFunctionTable[359054] = bhCheckWallEx_0x25e930; // 0x25ea40 - g_ps2RecompiledFunctionTable[359055] = bhCheckWallEx_0x25e930; // 0x25ea44 - g_ps2RecompiledFunctionTable[359056] = bhCheckWallEx_0x25e930; // 0x25ea48 - g_ps2RecompiledFunctionTable[359057] = bhCheckWallEx_0x25e930; // 0x25ea4c - g_ps2RecompiledFunctionTable[359058] = bhCheckWallEx_0x25e930; // 0x25ea50 - g_ps2RecompiledFunctionTable[359059] = bhCheckWallEx_0x25e930; // 0x25ea54 - g_ps2RecompiledFunctionTable[359060] = bhCheckWallEx_0x25e930; // 0x25ea58 - g_ps2RecompiledFunctionTable[359061] = bhCheckWallEx_0x25e930; // 0x25ea5c - g_ps2RecompiledFunctionTable[359062] = bhCheckWallEx_0x25e930; // 0x25ea60 - g_ps2RecompiledFunctionTable[359063] = bhCheckWallEx_0x25e930; // 0x25ea64 - g_ps2RecompiledFunctionTable[359064] = bhCheckWallEx_0x25e930; // 0x25ea68 - g_ps2RecompiledFunctionTable[359065] = bhCheckWallEx_0x25e930; // 0x25ea6c - g_ps2RecompiledFunctionTable[359066] = bhCheckWallEx_0x25e930; // 0x25ea70 - g_ps2RecompiledFunctionTable[359067] = bhCheckWallEx_0x25e930; // 0x25ea74 - g_ps2RecompiledFunctionTable[359068] = bhCheckWallEx_0x25e930; // 0x25ea78 - g_ps2RecompiledFunctionTable[359069] = bhCheckWallEx_0x25e930; // 0x25ea7c - g_ps2RecompiledFunctionTable[359070] = bhCheckWallEx_0x25e930; // 0x25ea80 - g_ps2RecompiledFunctionTable[359071] = bhCheckWallEx_0x25e930; // 0x25ea84 - g_ps2RecompiledFunctionTable[359072] = bhCheckWallEx_0x25e930; // 0x25ea88 - g_ps2RecompiledFunctionTable[359073] = bhCheckWallEx_0x25e930; // 0x25ea8c - g_ps2RecompiledFunctionTable[359074] = bhCheckWallEx_0x25e930; // 0x25ea90 - g_ps2RecompiledFunctionTable[359075] = bhCheckWallEx_0x25e930; // 0x25ea94 - g_ps2RecompiledFunctionTable[359076] = bhCheckWallEx_0x25e930; // 0x25ea98 - g_ps2RecompiledFunctionTable[359077] = bhCheckWallEx_0x25e930; // 0x25ea9c - g_ps2RecompiledFunctionTable[359078] = bhCheckWallEx_0x25e930; // 0x25eaa0 - g_ps2RecompiledFunctionTable[359079] = bhCheckWallEx_0x25e930; // 0x25eaa4 - g_ps2RecompiledFunctionTable[359080] = bhCheckWallEx_0x25e930; // 0x25eaa8 - g_ps2RecompiledFunctionTable[359081] = bhCheckWallEx_0x25e930; // 0x25eaac - g_ps2RecompiledFunctionTable[359082] = bhCheckWallEx_0x25e930; // 0x25eab0 - g_ps2RecompiledFunctionTable[359083] = bhCheckWallEx_0x25e930; // 0x25eab4 - g_ps2RecompiledFunctionTable[359084] = bhCheckWallEx_0x25e930; // 0x25eab8 - g_ps2RecompiledFunctionTable[359085] = bhCheckWallEx_0x25e930; // 0x25eabc - g_ps2RecompiledFunctionTable[359086] = bhCheckWallEx_0x25e930; // 0x25eac0 - g_ps2RecompiledFunctionTable[359087] = bhCheckWallEx_0x25e930; // 0x25eac4 - g_ps2RecompiledFunctionTable[359088] = bhCheckWallEx_0x25e930; // 0x25eac8 - g_ps2RecompiledFunctionTable[359089] = bhCheckWallEx_0x25e930; // 0x25eacc - g_ps2RecompiledFunctionTable[359090] = bhCheckWallEx_0x25e930; // 0x25ead0 - g_ps2RecompiledFunctionTable[359091] = bhCheckWallEx_0x25e930; // 0x25ead4 - g_ps2RecompiledFunctionTable[359092] = bhCheckWallEx_0x25e930; // 0x25ead8 - g_ps2RecompiledFunctionTable[359093] = bhCheckWallEx_0x25e930; // 0x25eadc - g_ps2RecompiledFunctionTable[359094] = bhCheckWallEx_0x25e930; // 0x25eae0 - g_ps2RecompiledFunctionTable[359095] = bhCheckWallEx_0x25e930; // 0x25eae4 - g_ps2RecompiledFunctionTable[359096] = bhCheckWallEx_0x25e930; // 0x25eae8 - g_ps2RecompiledFunctionTable[359097] = bhCheckWallEx_0x25e930; // 0x25eaec - g_ps2RecompiledFunctionTable[359098] = bhCheckWallEx_0x25e930; // 0x25eaf0 - g_ps2RecompiledFunctionTable[359099] = bhCheckWallEx_0x25e930; // 0x25eaf4 - g_ps2RecompiledFunctionTable[359100] = bhCheckWallEx_0x25e930; // 0x25eaf8 - g_ps2RecompiledFunctionTable[359101] = bhCheckWallEx_0x25e930; // 0x25eafc - g_ps2RecompiledFunctionTable[359102] = bhCheckWallEx_0x25e930; // 0x25eb00 - g_ps2RecompiledFunctionTable[359103] = bhCheckWallEx_0x25e930; // 0x25eb04 - g_ps2RecompiledFunctionTable[359104] = bhCheckWallEx_0x25e930; // 0x25eb08 - g_ps2RecompiledFunctionTable[359105] = bhCheckWallEx_0x25e930; // 0x25eb0c - g_ps2RecompiledFunctionTable[359106] = bhCheckWallEx_0x25e930; // 0x25eb10 - g_ps2RecompiledFunctionTable[359107] = bhCheckWallEx_0x25e930; // 0x25eb14 - g_ps2RecompiledFunctionTable[359108] = bhCheckWallEx_0x25e930; // 0x25eb18 - g_ps2RecompiledFunctionTable[359109] = bhCheckWallEx_0x25e930; // 0x25eb1c - g_ps2RecompiledFunctionTable[359110] = bhCheckWallEx_0x25e930; // 0x25eb20 - g_ps2RecompiledFunctionTable[359111] = bhCheckWallEx_0x25e930; // 0x25eb24 - g_ps2RecompiledFunctionTable[359112] = bhCheckWallEx_0x25e930; // 0x25eb28 - g_ps2RecompiledFunctionTable[359113] = bhCheckWallEx_0x25e930; // 0x25eb2c - g_ps2RecompiledFunctionTable[359114] = bhCheckWallEx_0x25e930; // 0x25eb30 - g_ps2RecompiledFunctionTable[359115] = bhCheckWallEx_0x25e930; // 0x25eb34 - g_ps2RecompiledFunctionTable[359116] = bhCheckWallEx_0x25e930; // 0x25eb38 - g_ps2RecompiledFunctionTable[359117] = bhCheckWallEx_0x25e930; // 0x25eb3c - g_ps2RecompiledFunctionTable[359118] = bhCheckWallEx_0x25e930; // 0x25eb40 - g_ps2RecompiledFunctionTable[359119] = bhCheckWallEx_0x25e930; // 0x25eb44 - g_ps2RecompiledFunctionTable[359120] = bhCheckWallEx_0x25e930; // 0x25eb48 - g_ps2RecompiledFunctionTable[359121] = bhCheckWallEx_0x25e930; // 0x25eb4c - g_ps2RecompiledFunctionTable[359122] = bhCheckWallEx_0x25e930; // 0x25eb50 - g_ps2RecompiledFunctionTable[359123] = bhCheckWallEx_0x25e930; // 0x25eb54 - g_ps2RecompiledFunctionTable[359124] = bhCheckWallEx_0x25e930; // 0x25eb58 - g_ps2RecompiledFunctionTable[359125] = bhCheckWallEx_0x25e930; // 0x25eb5c - g_ps2RecompiledFunctionTable[359126] = bhCheckWallEx_0x25e930; // 0x25eb60 - g_ps2RecompiledFunctionTable[359127] = bhCheckWallEx_0x25e930; // 0x25eb64 - g_ps2RecompiledFunctionTable[359128] = bhCheckWallEx_0x25e930; // 0x25eb68 - g_ps2RecompiledFunctionTable[359129] = bhCheckWallEx_0x25e930; // 0x25eb6c - g_ps2RecompiledFunctionTable[359130] = bhCheckWallEx_0x25e930; // 0x25eb70 - g_ps2RecompiledFunctionTable[359131] = bhCheckWallEx_0x25e930; // 0x25eb74 - g_ps2RecompiledFunctionTable[359132] = bhCheckWallEx_0x25e930; // 0x25eb78 - g_ps2RecompiledFunctionTable[359133] = bhCheckWallEx_0x25e930; // 0x25eb7c - g_ps2RecompiledFunctionTable[359134] = bhCheckWallEx_0x25e930; // 0x25eb80 - g_ps2RecompiledFunctionTable[359135] = bhCheckWallEx_0x25e930; // 0x25eb84 - g_ps2RecompiledFunctionTable[359136] = bhCheckWallEx_0x25e930; // 0x25eb88 - g_ps2RecompiledFunctionTable[359137] = bhCheckWallEx_0x25e930; // 0x25eb8c - g_ps2RecompiledFunctionTable[359138] = bhCheckWallEx_0x25e930; // 0x25eb90 - g_ps2RecompiledFunctionTable[359139] = bhCheckWallEx_0x25e930; // 0x25eb94 - g_ps2RecompiledFunctionTable[359140] = bhCheckWallEx_0x25e930; // 0x25eb98 - g_ps2RecompiledFunctionTable[359141] = bhCheckWallEx_0x25e930; // 0x25eb9c - g_ps2RecompiledFunctionTable[359142] = bhCheckWallEx_0x25e930; // 0x25eba0 - g_ps2RecompiledFunctionTable[359143] = bhCheckWallEx_0x25e930; // 0x25eba4 - g_ps2RecompiledFunctionTable[359144] = bhCheckWallEx_0x25e930; // 0x25eba8 - g_ps2RecompiledFunctionTable[359145] = bhCheckWallEx_0x25e930; // 0x25ebac - g_ps2RecompiledFunctionTable[359146] = bhCheckWallEx_0x25e930; // 0x25ebb0 - g_ps2RecompiledFunctionTable[359147] = bhCheckWallEx_0x25e930; // 0x25ebb4 - g_ps2RecompiledFunctionTable[359148] = bhCheckWallEx_0x25e930; // 0x25ebb8 - g_ps2RecompiledFunctionTable[359149] = bhCheckWallEx_0x25e930; // 0x25ebbc - g_ps2RecompiledFunctionTable[359150] = bhCheckWallEx_0x25e930; // 0x25ebc0 - g_ps2RecompiledFunctionTable[359151] = bhCheckWallEx_0x25e930; // 0x25ebc4 - g_ps2RecompiledFunctionTable[359152] = bhCheckWallEx_0x25e930; // 0x25ebc8 - g_ps2RecompiledFunctionTable[359153] = bhCheckWallEx_0x25e930; // 0x25ebcc - g_ps2RecompiledFunctionTable[359154] = bhCheckWallEx_0x25e930; // 0x25ebd0 - g_ps2RecompiledFunctionTable[359155] = bhCheckWallEx_0x25e930; // 0x25ebd4 - g_ps2RecompiledFunctionTable[359156] = bhCheckWallEx_0x25e930; // 0x25ebd8 - g_ps2RecompiledFunctionTable[359157] = bhCheckWallEx_0x25e930; // 0x25ebdc - g_ps2RecompiledFunctionTable[359158] = bhCheckWallEx_0x25e930; // 0x25ebe0 - g_ps2RecompiledFunctionTable[359159] = bhCheckWallEx_0x25e930; // 0x25ebe4 - g_ps2RecompiledFunctionTable[359160] = bhCheckWallEx_0x25e930; // 0x25ebe8 - g_ps2RecompiledFunctionTable[359161] = bhCheckWallEx_0x25e930; // 0x25ebec - g_ps2RecompiledFunctionTable[359162] = bhCheckWallEx_0x25e930; // 0x25ebf0 - g_ps2RecompiledFunctionTable[359163] = bhCheckWallEx_0x25e930; // 0x25ebf4 - g_ps2RecompiledFunctionTable[359164] = bhCheckWallEx_0x25e930; // 0x25ebf8 - g_ps2RecompiledFunctionTable[359165] = bhCheckWallEx_0x25e930; // 0x25ebfc - g_ps2RecompiledFunctionTable[359166] = bhCheckWallEx_0x25e930; // 0x25ec00 - g_ps2RecompiledFunctionTable[359167] = bhCheckWallEx_0x25e930; // 0x25ec04 - g_ps2RecompiledFunctionTable[359168] = bhCheckWallEx_0x25e930; // 0x25ec08 - g_ps2RecompiledFunctionTable[359169] = bhCheckWallEx_0x25e930; // 0x25ec0c - g_ps2RecompiledFunctionTable[359170] = bhCheckWallEx_0x25e930; // 0x25ec10 - g_ps2RecompiledFunctionTable[359171] = bhCheckWallEx_0x25e930; // 0x25ec14 - g_ps2RecompiledFunctionTable[359172] = bhCheckWallEx_0x25e930; // 0x25ec18 - g_ps2RecompiledFunctionTable[359173] = bhCheckWallEx_0x25e930; // 0x25ec1c - g_ps2RecompiledFunctionTable[359174] = bhCheckWallEx_0x25e930; // 0x25ec20 - g_ps2RecompiledFunctionTable[359175] = bhCheckWallEx_0x25e930; // 0x25ec24 - g_ps2RecompiledFunctionTable[359176] = bhCheckWallEx_0x25e930; // 0x25ec28 - g_ps2RecompiledFunctionTable[359177] = bhCheckWallEx_0x25e930; // 0x25ec2c - g_ps2RecompiledFunctionTable[359178] = bhCheckWallEx_0x25e930; // 0x25ec30 - g_ps2RecompiledFunctionTable[359179] = bhCheckWallEx_0x25e930; // 0x25ec34 - g_ps2RecompiledFunctionTable[359180] = bhCheckWallEx_0x25e930; // 0x25ec38 - g_ps2RecompiledFunctionTable[359181] = bhCheckWallEx_0x25e930; // 0x25ec3c - g_ps2RecompiledFunctionTable[359182] = bhCheckWallEx_0x25e930; // 0x25ec40 - g_ps2RecompiledFunctionTable[359183] = bhCheckWallEx_0x25e930; // 0x25ec44 - g_ps2RecompiledFunctionTable[359184] = bhCheckWallEx_0x25e930; // 0x25ec48 - g_ps2RecompiledFunctionTable[359185] = bhCheckWallEx_0x25e930; // 0x25ec4c - g_ps2RecompiledFunctionTable[359186] = bhCheckWallEx_0x25e930; // 0x25ec50 - g_ps2RecompiledFunctionTable[359187] = bhCheckWallEx_0x25e930; // 0x25ec54 - g_ps2RecompiledFunctionTable[359188] = bhCheckWallEx_0x25e930; // 0x25ec58 - g_ps2RecompiledFunctionTable[359189] = bhCheckWallEx_0x25e930; // 0x25ec5c - g_ps2RecompiledFunctionTable[359190] = bhCheckWallEx_0x25e930; // 0x25ec60 - g_ps2RecompiledFunctionTable[359191] = bhCheckWallEx_0x25e930; // 0x25ec64 - g_ps2RecompiledFunctionTable[359192] = bhCheckWallEx_0x25e930; // 0x25ec68 - g_ps2RecompiledFunctionTable[359193] = bhCheckWallEx_0x25e930; // 0x25ec6c - g_ps2RecompiledFunctionTable[359194] = bhCheckWallEx_0x25e930; // 0x25ec70 - g_ps2RecompiledFunctionTable[359195] = bhCheckWallEx_0x25e930; // 0x25ec74 - g_ps2RecompiledFunctionTable[359196] = bhCheckWallEx_0x25e930; // 0x25ec78 - g_ps2RecompiledFunctionTable[359197] = bhCheckWallEx_0x25e930; // 0x25ec7c - g_ps2RecompiledFunctionTable[359198] = bhCheckWallEx_0x25e930; // 0x25ec80 - g_ps2RecompiledFunctionTable[359199] = bhCheckWallEx_0x25e930; // 0x25ec84 - g_ps2RecompiledFunctionTable[359200] = bhCheckWallEx_0x25e930; // 0x25ec88 - g_ps2RecompiledFunctionTable[359201] = bhCheckWallEx_0x25e930; // 0x25ec8c - g_ps2RecompiledFunctionTable[359202] = bhCheckWallEx_0x25e930; // 0x25ec90 - g_ps2RecompiledFunctionTable[359203] = bhCheckWallEx_0x25e930; // 0x25ec94 - g_ps2RecompiledFunctionTable[359204] = bhCheckWallEx_0x25e930; // 0x25ec98 - g_ps2RecompiledFunctionTable[359205] = bhCheckWallEx_0x25e930; // 0x25ec9c - g_ps2RecompiledFunctionTable[359206] = bhCheckWallEx_0x25e930; // 0x25eca0 - g_ps2RecompiledFunctionTable[359207] = bhCheckWallEx_0x25e930; // 0x25eca4 - g_ps2RecompiledFunctionTable[359208] = bhCheckWallEx_0x25e930; // 0x25eca8 - g_ps2RecompiledFunctionTable[359209] = bhCheckWallEx_0x25e930; // 0x25ecac - g_ps2RecompiledFunctionTable[359210] = bhCheckWallEx_0x25e930; // 0x25ecb0 - g_ps2RecompiledFunctionTable[359211] = bhCheckWallEx_0x25e930; // 0x25ecb4 - g_ps2RecompiledFunctionTable[359212] = bhCheckWallEx_0x25e930; // 0x25ecb8 - g_ps2RecompiledFunctionTable[359213] = bhCheckWallEx_0x25e930; // 0x25ecbc - g_ps2RecompiledFunctionTable[359214] = bhCheckWallEx_0x25e930; // 0x25ecc0 - g_ps2RecompiledFunctionTable[359215] = bhCheckWallEx_0x25e930; // 0x25ecc4 - g_ps2RecompiledFunctionTable[359216] = bhCheckWallEx_0x25e930; // 0x25ecc8 - g_ps2RecompiledFunctionTable[359217] = bhCheckWallEx_0x25e930; // 0x25eccc - g_ps2RecompiledFunctionTable[359218] = bhCheckWallEx_0x25e930; // 0x25ecd0 - g_ps2RecompiledFunctionTable[359219] = bhCheckWallEx_0x25e930; // 0x25ecd4 - g_ps2RecompiledFunctionTable[359220] = bhCheckWallEx_0x25e930; // 0x25ecd8 - g_ps2RecompiledFunctionTable[359221] = bhCheckWallEx_0x25e930; // 0x25ecdc - g_ps2RecompiledFunctionTable[359222] = bhCheckWallEx_0x25e930; // 0x25ece0 - g_ps2RecompiledFunctionTable[359223] = bhCheckWallEx_0x25e930; // 0x25ece4 - g_ps2RecompiledFunctionTable[359224] = bhCheckWallEx_0x25e930; // 0x25ece8 - g_ps2RecompiledFunctionTable[359225] = bhCheckWallEx_0x25e930; // 0x25ecec - g_ps2RecompiledFunctionTable[359226] = bhCheckWallEx_0x25e930; // 0x25ecf0 - g_ps2RecompiledFunctionTable[359227] = bhCheckWallEx_0x25e930; // 0x25ecf4 - g_ps2RecompiledFunctionTable[359228] = bhCheckWallEx_0x25e930; // 0x25ecf8 - g_ps2RecompiledFunctionTable[359229] = bhCheckWallEx_0x25e930; // 0x25ecfc - g_ps2RecompiledFunctionTable[359230] = bhCheckWallEx_0x25e930; // 0x25ed00 - g_ps2RecompiledFunctionTable[359231] = bhCheckWallEx_0x25e930; // 0x25ed04 - g_ps2RecompiledFunctionTable[359232] = bhCheckWallEx_0x25e930; // 0x25ed08 - g_ps2RecompiledFunctionTable[359233] = bhCheckWallEx_0x25e930; // 0x25ed0c - g_ps2RecompiledFunctionTable[359234] = bhCheckWallEx_0x25e930; // 0x25ed10 - g_ps2RecompiledFunctionTable[359235] = bhCheckWallEx_0x25e930; // 0x25ed14 - g_ps2RecompiledFunctionTable[359236] = bhCheckWallEx_0x25e930; // 0x25ed18 - g_ps2RecompiledFunctionTable[359237] = bhCheckWallEx_0x25e930; // 0x25ed1c - g_ps2RecompiledFunctionTable[359238] = bhCheckWallEx_0x25e930; // 0x25ed20 - g_ps2RecompiledFunctionTable[359239] = bhCheckWallEx_0x25e930; // 0x25ed24 - g_ps2RecompiledFunctionTable[359240] = bhCheckWallEx_0x25e930; // 0x25ed28 - g_ps2RecompiledFunctionTable[359241] = bhCheckWallEx_0x25e930; // 0x25ed2c - g_ps2RecompiledFunctionTable[359242] = bhCheckWallEx_0x25e930; // 0x25ed30 - g_ps2RecompiledFunctionTable[359243] = bhCheckWallEx_0x25e930; // 0x25ed34 - g_ps2RecompiledFunctionTable[359244] = bhCheckWallEx_0x25e930; // 0x25ed38 - g_ps2RecompiledFunctionTable[359245] = bhCheckWallEx_0x25e930; // 0x25ed3c - g_ps2RecompiledFunctionTable[359246] = bhCheckWallEx_0x25e930; // 0x25ed40 - g_ps2RecompiledFunctionTable[359247] = bhCheckWallEx_0x25e930; // 0x25ed44 - g_ps2RecompiledFunctionTable[359248] = bhCheckWallEx_0x25e930; // 0x25ed48 - g_ps2RecompiledFunctionTable[359249] = bhCheckWallEx_0x25e930; // 0x25ed4c - g_ps2RecompiledFunctionTable[359250] = bhCheckWallEx_0x25e930; // 0x25ed50 - g_ps2RecompiledFunctionTable[359251] = bhCheckWallEx_0x25e930; // 0x25ed54 - g_ps2RecompiledFunctionTable[359252] = bhCheckWallEx_0x25e930; // 0x25ed58 - g_ps2RecompiledFunctionTable[359253] = bhCheckWallEx_0x25e930; // 0x25ed5c - g_ps2RecompiledFunctionTable[359254] = bhCheckWallEx_0x25e930; // 0x25ed60 - g_ps2RecompiledFunctionTable[359255] = bhCheckWallEx_0x25e930; // 0x25ed64 - g_ps2RecompiledFunctionTable[359256] = bhCheckWallEx_0x25e930; // 0x25ed68 - g_ps2RecompiledFunctionTable[359257] = bhCheckWallEx_0x25e930; // 0x25ed6c - g_ps2RecompiledFunctionTable[359258] = bhCheckWallEx_0x25e930; // 0x25ed70 - g_ps2RecompiledFunctionTable[359259] = bhCheckWallEx_0x25e930; // 0x25ed74 - g_ps2RecompiledFunctionTable[359260] = bhCheckWallEx_0x25e930; // 0x25ed78 - g_ps2RecompiledFunctionTable[359261] = bhCheckWallEx_0x25e930; // 0x25ed7c - g_ps2RecompiledFunctionTable[359262] = bhCheckWallEx_0x25e930; // 0x25ed80 - g_ps2RecompiledFunctionTable[359263] = bhCheckWallEx_0x25e930; // 0x25ed84 - g_ps2RecompiledFunctionTable[359264] = bhCheckWallEx_0x25e930; // 0x25ed88 - g_ps2RecompiledFunctionTable[359265] = bhCheckWallEx_0x25e930; // 0x25ed8c - g_ps2RecompiledFunctionTable[359266] = bhCheckWallEx_0x25e930; // 0x25ed90 - g_ps2RecompiledFunctionTable[359267] = bhCheckWallEx_0x25e930; // 0x25ed94 - g_ps2RecompiledFunctionTable[359268] = bhCheckWallEx_0x25e930; // 0x25ed98 - g_ps2RecompiledFunctionTable[359269] = bhCheckWallEx_0x25e930; // 0x25ed9c - g_ps2RecompiledFunctionTable[359270] = bhCheckWallEx_0x25e930; // 0x25eda0 - g_ps2RecompiledFunctionTable[359271] = bhCheckWallEx_0x25e930; // 0x25eda4 - g_ps2RecompiledFunctionTable[359272] = bhCheckWallEx_0x25e930; // 0x25eda8 - g_ps2RecompiledFunctionTable[359273] = bhCheckWallEx_0x25e930; // 0x25edac - g_ps2RecompiledFunctionTable[359274] = bhCheckWallEx_0x25e930; // 0x25edb0 - g_ps2RecompiledFunctionTable[359275] = bhCheckWallEx_0x25e930; // 0x25edb4 - g_ps2RecompiledFunctionTable[359276] = bhCheckWallEx_0x25e930; // 0x25edb8 - g_ps2RecompiledFunctionTable[359277] = bhCheckWallEx_0x25e930; // 0x25edbc - g_ps2RecompiledFunctionTable[359278] = bhCheckWallEx_0x25e930; // 0x25edc0 - g_ps2RecompiledFunctionTable[359279] = bhCheckWallEx_0x25e930; // 0x25edc4 - g_ps2RecompiledFunctionTable[359280] = bhCheckWallEx_0x25e930; // 0x25edc8 - g_ps2RecompiledFunctionTable[359281] = bhCheckWallEx_0x25e930; // 0x25edcc - g_ps2RecompiledFunctionTable[359282] = bhCheckWallEx_0x25e930; // 0x25edd0 - g_ps2RecompiledFunctionTable[359283] = bhCheckWallEx_0x25e930; // 0x25edd4 - g_ps2RecompiledFunctionTable[359284] = bhCheckWallEx_0x25e930; // 0x25edd8 - g_ps2RecompiledFunctionTable[359285] = bhCheckWallEx_0x25e930; // 0x25eddc - g_ps2RecompiledFunctionTable[359286] = bhCheckWallEx_0x25e930; // 0x25ede0 - g_ps2RecompiledFunctionTable[359287] = bhCheckWallEx_0x25e930; // 0x25ede4 - g_ps2RecompiledFunctionTable[359288] = bhCheckWallEx_0x25e930; // 0x25ede8 - g_ps2RecompiledFunctionTable[359289] = bhCheckWallEx_0x25e930; // 0x25edec - g_ps2RecompiledFunctionTable[359290] = bhCheckWallEx_0x25e930; // 0x25edf0 - g_ps2RecompiledFunctionTable[359291] = bhCheckWallEx_0x25e930; // 0x25edf4 - g_ps2RecompiledFunctionTable[359292] = bhCheckWallEx_0x25e930; // 0x25edf8 - g_ps2RecompiledFunctionTable[359293] = bhCheckWallEx_0x25e930; // 0x25edfc - g_ps2RecompiledFunctionTable[359294] = bhCheckWallEx_0x25e930; // 0x25ee00 - g_ps2RecompiledFunctionTable[359295] = bhCheckWallEx_0x25e930; // 0x25ee04 - g_ps2RecompiledFunctionTable[359296] = bhCheckWallEx_0x25e930; // 0x25ee08 - g_ps2RecompiledFunctionTable[359297] = bhCheckWallEx_0x25e930; // 0x25ee0c - g_ps2RecompiledFunctionTable[359298] = bhCheckWallEx_0x25e930; // 0x25ee10 - g_ps2RecompiledFunctionTable[359299] = bhCheckWallEx_0x25e930; // 0x25ee14 - g_ps2RecompiledFunctionTable[359300] = bhCheckWallEx_0x25e930; // 0x25ee18 - g_ps2RecompiledFunctionTable[359301] = bhCheckWallEx_0x25e930; // 0x25ee1c - g_ps2RecompiledFunctionTable[359302] = bhCheckWallEx_0x25e930; // 0x25ee20 - g_ps2RecompiledFunctionTable[359303] = bhCheckWallEx_0x25e930; // 0x25ee24 - g_ps2RecompiledFunctionTable[359304] = bhCheckWallEx_0x25e930; // 0x25ee28 - g_ps2RecompiledFunctionTable[359305] = bhCheckWallEx_0x25e930; // 0x25ee2c - g_ps2RecompiledFunctionTable[359306] = bhCheckWallEx_0x25e930; // 0x25ee30 - g_ps2RecompiledFunctionTable[359307] = bhCheckWallEx_0x25e930; // 0x25ee34 - g_ps2RecompiledFunctionTable[359308] = bhCheckWallEx_0x25e930; // 0x25ee38 - g_ps2RecompiledFunctionTable[359309] = bhCheckWallEx_0x25e930; // 0x25ee3c - g_ps2RecompiledFunctionTable[359310] = bhCheckWallEx_0x25e930; // 0x25ee40 - g_ps2RecompiledFunctionTable[359311] = bhCheckWallEx_0x25e930; // 0x25ee44 - g_ps2RecompiledFunctionTable[359312] = bhCheckWallEx_0x25e930; // 0x25ee48 - g_ps2RecompiledFunctionTable[359313] = bhCheckWallEx_0x25e930; // 0x25ee4c - g_ps2RecompiledFunctionTable[359314] = bhCheckWallEx_0x25e930; // 0x25ee50 - g_ps2RecompiledFunctionTable[359315] = bhCheckWallEx_0x25e930; // 0x25ee54 - g_ps2RecompiledFunctionTable[359316] = bhCheckWallEx_0x25e930; // 0x25ee58 - g_ps2RecompiledFunctionTable[359317] = bhCheckWallEx_0x25e930; // 0x25ee5c - g_ps2RecompiledFunctionTable[359318] = bhCheckWallEx_0x25e930; // 0x25ee60 - g_ps2RecompiledFunctionTable[359319] = bhCheckWallEx_0x25e930; // 0x25ee64 - g_ps2RecompiledFunctionTable[359320] = bhCheckWallEx_0x25e930; // 0x25ee68 - g_ps2RecompiledFunctionTable[359321] = bhCheckWallEx_0x25e930; // 0x25ee6c - g_ps2RecompiledFunctionTable[359322] = bhCheckWallEx_0x25e930; // 0x25ee70 - g_ps2RecompiledFunctionTable[359323] = bhCheckWallEx_0x25e930; // 0x25ee74 - g_ps2RecompiledFunctionTable[359324] = bhCheckWallEx_0x25e930; // 0x25ee78 - g_ps2RecompiledFunctionTable[359325] = bhCheckWallEx_0x25e930; // 0x25ee7c - g_ps2RecompiledFunctionTable[359326] = bhCheckWallEx_0x25e930; // 0x25ee80 - g_ps2RecompiledFunctionTable[359327] = bhCheckWallEx_0x25e930; // 0x25ee84 - g_ps2RecompiledFunctionTable[359328] = bhCheckWallEx_0x25e930; // 0x25ee88 - g_ps2RecompiledFunctionTable[359329] = bhCheckWallEx_0x25e930; // 0x25ee8c - g_ps2RecompiledFunctionTable[359330] = bhCheckWallEx_0x25e930; // 0x25ee90 - g_ps2RecompiledFunctionTable[359331] = bhCheckWallEx_0x25e930; // 0x25ee94 - g_ps2RecompiledFunctionTable[359332] = bhCheckWallEx_0x25e930; // 0x25ee98 - g_ps2RecompiledFunctionTable[359333] = bhCheckWallEx_0x25e930; // 0x25ee9c - g_ps2RecompiledFunctionTable[359334] = bhCheckWallEx_0x25e930; // 0x25eea0 - g_ps2RecompiledFunctionTable[359335] = bhCheckWallEx_0x25e930; // 0x25eea4 - g_ps2RecompiledFunctionTable[359336] = bhCheckWallEx_0x25e930; // 0x25eea8 - g_ps2RecompiledFunctionTable[359337] = bhCheckWallEx_0x25e930; // 0x25eeac - g_ps2RecompiledFunctionTable[359338] = bhCheckWallEx_0x25e930; // 0x25eeb0 - g_ps2RecompiledFunctionTable[359339] = bhCheckWallEx_0x25e930; // 0x25eeb4 - g_ps2RecompiledFunctionTable[359340] = bhCheckWallEx_0x25e930; // 0x25eeb8 - g_ps2RecompiledFunctionTable[359341] = bhCheckWallEx_0x25e930; // 0x25eebc - g_ps2RecompiledFunctionTable[359342] = bhCheckWallEx_0x25e930; // 0x25eec0 - g_ps2RecompiledFunctionTable[359343] = bhCheckWallEx_0x25e930; // 0x25eec4 - g_ps2RecompiledFunctionTable[359344] = bhCheckWallEx_0x25e930; // 0x25eec8 - g_ps2RecompiledFunctionTable[359345] = bhCheckWallEx_0x25e930; // 0x25eecc - g_ps2RecompiledFunctionTable[359346] = bhCheckWallEx_0x25e930; // 0x25eed0 - g_ps2RecompiledFunctionTable[359347] = bhCheckWallEx_0x25e930; // 0x25eed4 - g_ps2RecompiledFunctionTable[359348] = bhCheckWallEx_0x25e930; // 0x25eed8 - g_ps2RecompiledFunctionTable[359349] = bhCheckWallEx_0x25e930; // 0x25eedc - g_ps2RecompiledFunctionTable[359350] = bhCheckWallEx_0x25e930; // 0x25eee0 - g_ps2RecompiledFunctionTable[359351] = bhCheckWallEx_0x25e930; // 0x25eee4 - g_ps2RecompiledFunctionTable[359352] = bhCheckWallEx_0x25e930; // 0x25eee8 - g_ps2RecompiledFunctionTable[359353] = bhCheckWallEx_0x25e930; // 0x25eeec - g_ps2RecompiledFunctionTable[359354] = bhCheckWallEx_0x25e930; // 0x25eef0 - g_ps2RecompiledFunctionTable[359355] = bhCheckWallEx_0x25e930; // 0x25eef4 - g_ps2RecompiledFunctionTable[359356] = bhCheckWallEx_0x25e930; // 0x25eef8 - g_ps2RecompiledFunctionTable[359357] = bhCheckWallEx_0x25e930; // 0x25eefc - g_ps2RecompiledFunctionTable[359358] = bhCheckWallEx_0x25e930; // 0x25ef00 - g_ps2RecompiledFunctionTable[359359] = bhCheckWallEx_0x25e930; // 0x25ef04 - g_ps2RecompiledFunctionTable[359360] = bhCheckWallEx_0x25e930; // 0x25ef08 - g_ps2RecompiledFunctionTable[359361] = bhCheckWallEx_0x25e930; // 0x25ef0c - g_ps2RecompiledFunctionTable[359362] = bhCheckWallEx_0x25e930; // 0x25ef10 - g_ps2RecompiledFunctionTable[359363] = bhCheckWallEx_0x25e930; // 0x25ef14 - g_ps2RecompiledFunctionTable[359364] = bhCheckWallEx_0x25e930; // 0x25ef18 - g_ps2RecompiledFunctionTable[359365] = bhCheckWallEx_0x25e930; // 0x25ef1c - g_ps2RecompiledFunctionTable[359366] = bhCheckWallEx_0x25e930; // 0x25ef20 - g_ps2RecompiledFunctionTable[359367] = bhCheckWallEx_0x25e930; // 0x25ef24 - g_ps2RecompiledFunctionTable[359368] = bhCheckWallEx_0x25e930; // 0x25ef28 - g_ps2RecompiledFunctionTable[359369] = bhCheckWallEx_0x25e930; // 0x25ef2c - g_ps2RecompiledFunctionTable[359370] = bhCheckWallEx_0x25e930; // 0x25ef30 - g_ps2RecompiledFunctionTable[359371] = bhCheckWallEx_0x25e930; // 0x25ef34 - g_ps2RecompiledFunctionTable[359372] = bhCheckWallEx_0x25e930; // 0x25ef38 - g_ps2RecompiledFunctionTable[359373] = bhCheckWallEx_0x25e930; // 0x25ef3c - g_ps2RecompiledFunctionTable[359374] = bhCheckWallEx_0x25e930; // 0x25ef40 - g_ps2RecompiledFunctionTable[359375] = bhCheckWallEx_0x25e930; // 0x25ef44 - g_ps2RecompiledFunctionTable[359376] = bhCheckWallEx_0x25e930; // 0x25ef48 - g_ps2RecompiledFunctionTable[359377] = bhCheckWallEx_0x25e930; // 0x25ef4c - g_ps2RecompiledFunctionTable[359378] = bhCheckWallEx_0x25e930; // 0x25ef50 - g_ps2RecompiledFunctionTable[359379] = bhCheckWallEx_0x25e930; // 0x25ef54 - g_ps2RecompiledFunctionTable[359380] = bhCheckWallEx_0x25e930; // 0x25ef58 - g_ps2RecompiledFunctionTable[359381] = bhCheckWallEx_0x25e930; // 0x25ef5c - g_ps2RecompiledFunctionTable[359382] = bhCheckWallEx_0x25e930; // 0x25ef60 - g_ps2RecompiledFunctionTable[359383] = bhCheckWallEx_0x25e930; // 0x25ef64 - g_ps2RecompiledFunctionTable[359384] = bhCheckWallEx_0x25e930; // 0x25ef68 - g_ps2RecompiledFunctionTable[359385] = bhCheckWallEx_0x25e930; // 0x25ef6c - g_ps2RecompiledFunctionTable[359386] = bhCheckWallEx_0x25e930; // 0x25ef70 - g_ps2RecompiledFunctionTable[359387] = bhCheckWallEx_0x25e930; // 0x25ef74 - g_ps2RecompiledFunctionTable[359388] = bhCheckWallEx_0x25e930; // 0x25ef78 - g_ps2RecompiledFunctionTable[359389] = bhCheckWallEx_0x25e930; // 0x25ef7c - g_ps2RecompiledFunctionTable[359390] = bhCheckWallEx_0x25e930; // 0x25ef80 - g_ps2RecompiledFunctionTable[359391] = bhCheckWallEx_0x25e930; // 0x25ef84 - g_ps2RecompiledFunctionTable[359392] = bhCheckWallEx_0x25e930; // 0x25ef88 - g_ps2RecompiledFunctionTable[359393] = bhCheckWallEx_0x25e930; // 0x25ef8c - g_ps2RecompiledFunctionTable[359394] = bhCheckWallEx_0x25e930; // 0x25ef90 - g_ps2RecompiledFunctionTable[359395] = bhCheckWallEx_0x25e930; // 0x25ef94 - g_ps2RecompiledFunctionTable[359396] = bhCheckWallEx_0x25e930; // 0x25ef98 - g_ps2RecompiledFunctionTable[359397] = bhCheckWallEx_0x25e930; // 0x25ef9c - g_ps2RecompiledFunctionTable[359398] = bhCheckWallEx_0x25e930; // 0x25efa0 - g_ps2RecompiledFunctionTable[359399] = bhCheckWallEx_0x25e930; // 0x25efa4 - g_ps2RecompiledFunctionTable[359400] = bhCheckWallEx_0x25e930; // 0x25efa8 - g_ps2RecompiledFunctionTable[359401] = bhCheckWallEx_0x25e930; // 0x25efac - g_ps2RecompiledFunctionTable[359402] = bhCheckWallEx_0x25e930; // 0x25efb0 - g_ps2RecompiledFunctionTable[359403] = bhCheckWallEx_0x25e930; // 0x25efb4 - g_ps2RecompiledFunctionTable[359404] = bhCheckWallEx_0x25e930; // 0x25efb8 - g_ps2RecompiledFunctionTable[359405] = bhCheckWallEx_0x25e930; // 0x25efbc - g_ps2RecompiledFunctionTable[359406] = bhCheckWallEx_0x25e930; // 0x25efc0 - g_ps2RecompiledFunctionTable[359407] = bhCheckWallEx_0x25e930; // 0x25efc4 - g_ps2RecompiledFunctionTable[359408] = bhCheckWallEx_0x25e930; // 0x25efc8 - g_ps2RecompiledFunctionTable[359409] = bhCheckWallEx_0x25e930; // 0x25efcc - g_ps2RecompiledFunctionTable[359410] = bhCheckWallEx_0x25e930; // 0x25efd0 - g_ps2RecompiledFunctionTable[359411] = bhCheckWallEx_0x25e930; // 0x25efd4 - g_ps2RecompiledFunctionTable[359412] = bhCheckWallEx_0x25e930; // 0x25efd8 - g_ps2RecompiledFunctionTable[359413] = bhCheckWallEx_0x25e930; // 0x25efdc - g_ps2RecompiledFunctionTable[359414] = bhCheckWallEx_0x25e930; // 0x25efe0 - g_ps2RecompiledFunctionTable[359415] = bhCheckWallEx_0x25e930; // 0x25efe4 - g_ps2RecompiledFunctionTable[359416] = bhCheckWallEx_0x25e930; // 0x25efe8 - g_ps2RecompiledFunctionTable[359417] = bhCheckWallEx_0x25e930; // 0x25efec - g_ps2RecompiledFunctionTable[359418] = bhCheckWallEx_0x25e930; // 0x25eff0 - g_ps2RecompiledFunctionTable[359419] = bhCheckWallEx_0x25e930; // 0x25eff4 - g_ps2RecompiledFunctionTable[359420] = bhCheckWallEx_0x25e930; // 0x25eff8 - g_ps2RecompiledFunctionTable[359421] = bhCheckWallEx_0x25e930; // 0x25effc - g_ps2RecompiledFunctionTable[359422] = bhCheckWallEx_0x25e930; // 0x25f000 - g_ps2RecompiledFunctionTable[359423] = bhCheckWallEx_0x25e930; // 0x25f004 - g_ps2RecompiledFunctionTable[359424] = bhCheckWallEx_0x25e930; // 0x25f008 - g_ps2RecompiledFunctionTable[359425] = bhCheckWallEx_0x25e930; // 0x25f00c - g_ps2RecompiledFunctionTable[359426] = bhCheckWallEx_0x25e930; // 0x25f010 - g_ps2RecompiledFunctionTable[359427] = bhCheckWallEx_0x25e930; // 0x25f014 - g_ps2RecompiledFunctionTable[359428] = bhCheckWallEx_0x25e930; // 0x25f018 - g_ps2RecompiledFunctionTable[359429] = bhCheckWallEx_0x25e930; // 0x25f01c - g_ps2RecompiledFunctionTable[359430] = bhCheckWallEx_0x25e930; // 0x25f020 - g_ps2RecompiledFunctionTable[359431] = bhCheckWallEx_0x25e930; // 0x25f024 - g_ps2RecompiledFunctionTable[359432] = bhCheckWallEx_0x25e930; // 0x25f028 - g_ps2RecompiledFunctionTable[359433] = bhCheckWallEx_0x25e930; // 0x25f02c - g_ps2RecompiledFunctionTable[359434] = bhCheckWallEx_0x25e930; // 0x25f030 - g_ps2RecompiledFunctionTable[359435] = bhCheckWallEx_0x25e930; // 0x25f034 - g_ps2RecompiledFunctionTable[359436] = bhCheckWallEx_0x25e930; // 0x25f038 - g_ps2RecompiledFunctionTable[359437] = bhCheckWallEx_0x25e930; // 0x25f03c - g_ps2RecompiledFunctionTable[359438] = bhCheckWallEx_0x25e930; // 0x25f040 - g_ps2RecompiledFunctionTable[359439] = bhCheckWallEx_0x25e930; // 0x25f044 - g_ps2RecompiledFunctionTable[359440] = bhCheckWallEx_0x25e930; // 0x25f048 - g_ps2RecompiledFunctionTable[359441] = bhCheckWallEx_0x25e930; // 0x25f04c - g_ps2RecompiledFunctionTable[359442] = bhCheckWallEx_0x25e930; // 0x25f050 - g_ps2RecompiledFunctionTable[359443] = bhCheckWallEx_0x25e930; // 0x25f054 - g_ps2RecompiledFunctionTable[359444] = bhCheckWallEx_0x25e930; // 0x25f058 - g_ps2RecompiledFunctionTable[359445] = bhCheckWallEx_0x25e930; // 0x25f05c - g_ps2RecompiledFunctionTable[359446] = bhCheckWallEx_0x25e930; // 0x25f060 - g_ps2RecompiledFunctionTable[359447] = bhCheckWallEx_0x25e930; // 0x25f064 - g_ps2RecompiledFunctionTable[359448] = bhCheckWallEx_0x25e930; // 0x25f068 - g_ps2RecompiledFunctionTable[359449] = bhCheckWallEx_0x25e930; // 0x25f06c - g_ps2RecompiledFunctionTable[359450] = bhCheckWallEx_0x25e930; // 0x25f070 - g_ps2RecompiledFunctionTable[359451] = bhCheckWallEx_0x25e930; // 0x25f074 - g_ps2RecompiledFunctionTable[359452] = bhCheckWallEx_0x25e930; // 0x25f078 - g_ps2RecompiledFunctionTable[359453] = bhCheckWallEx_0x25e930; // 0x25f07c - g_ps2RecompiledFunctionTable[359454] = bhCheckWallEx_0x25e930; // 0x25f080 - g_ps2RecompiledFunctionTable[359455] = bhCheckWallEx_0x25e930; // 0x25f084 - g_ps2RecompiledFunctionTable[359456] = bhCheckWallEx_0x25e930; // 0x25f088 - g_ps2RecompiledFunctionTable[359457] = bhCheckWallEx_0x25e930; // 0x25f08c - g_ps2RecompiledFunctionTable[359458] = bhCheckWallEx_0x25e930; // 0x25f090 - g_ps2RecompiledFunctionTable[359459] = bhCheckWallEx_0x25e930; // 0x25f094 - g_ps2RecompiledFunctionTable[359460] = bhCheckWallEx_0x25e930; // 0x25f098 - g_ps2RecompiledFunctionTable[359461] = bhCheckWallEx_0x25e930; // 0x25f09c - g_ps2RecompiledFunctionTable[359462] = bhCheckWallEx_0x25e930; // 0x25f0a0 - g_ps2RecompiledFunctionTable[359463] = bhCheckWallEx_0x25e930; // 0x25f0a4 - g_ps2RecompiledFunctionTable[359464] = bhCheckWallEx_0x25e930; // 0x25f0a8 - g_ps2RecompiledFunctionTable[359465] = bhCheckWallEx_0x25e930; // 0x25f0ac - g_ps2RecompiledFunctionTable[359466] = bhCheckWallEx_0x25e930; // 0x25f0b0 - g_ps2RecompiledFunctionTable[359467] = bhCheckWallEx_0x25e930; // 0x25f0b4 - g_ps2RecompiledFunctionTable[359468] = bhCheckWallEx_0x25e930; // 0x25f0b8 - g_ps2RecompiledFunctionTable[359469] = bhCheckWallEx_0x25e930; // 0x25f0bc - g_ps2RecompiledFunctionTable[359470] = bhCheckWallEx_0x25e930; // 0x25f0c0 - g_ps2RecompiledFunctionTable[359471] = bhCheckWallEx_0x25e930; // 0x25f0c4 - g_ps2RecompiledFunctionTable[359472] = bhCheckWallEx_0x25e930; // 0x25f0c8 - g_ps2RecompiledFunctionTable[359473] = bhCheckWallEx_0x25e930; // 0x25f0cc - g_ps2RecompiledFunctionTable[359474] = bhCheckWallEx_0x25e930; // 0x25f0d0 - g_ps2RecompiledFunctionTable[359475] = bhCheckWallEx_0x25e930; // 0x25f0d4 - g_ps2RecompiledFunctionTable[359476] = bhCheckWallEx_0x25e930; // 0x25f0d8 - g_ps2RecompiledFunctionTable[359477] = bhCheckWallEx_0x25e930; // 0x25f0dc - g_ps2RecompiledFunctionTable[359478] = bhCheckWallEx_0x25e930; // 0x25f0e0 - g_ps2RecompiledFunctionTable[359479] = bhCheckWallEx_0x25e930; // 0x25f0e4 - g_ps2RecompiledFunctionTable[359480] = bhCheckWallEx_0x25e930; // 0x25f0e8 - g_ps2RecompiledFunctionTable[359481] = bhCheckWallEx_0x25e930; // 0x25f0ec - g_ps2RecompiledFunctionTable[359482] = bhCheckWallEx_0x25e930; // 0x25f0f0 - g_ps2RecompiledFunctionTable[359483] = bhCheckWallEx_0x25e930; // 0x25f0f4 - g_ps2RecompiledFunctionTable[359484] = bhCheckWallEx_0x25e930; // 0x25f0f8 - g_ps2RecompiledFunctionTable[359485] = bhCheckWallEx_0x25e930; // 0x25f0fc - g_ps2RecompiledFunctionTable[359486] = bhCheckWallEx_0x25e930; // 0x25f100 - g_ps2RecompiledFunctionTable[359487] = bhCheckWallEx_0x25e930; // 0x25f104 - g_ps2RecompiledFunctionTable[359488] = bhCheckWallEx_0x25e930; // 0x25f108 - g_ps2RecompiledFunctionTable[359489] = bhCheckWallEx_0x25e930; // 0x25f10c - g_ps2RecompiledFunctionTable[359490] = bhCheckWallEx_0x25e930; // 0x25f110 - g_ps2RecompiledFunctionTable[359491] = bhCheckWallEx_0x25e930; // 0x25f114 - g_ps2RecompiledFunctionTable[359492] = bhCheckWallEx_0x25e930; // 0x25f118 - g_ps2RecompiledFunctionTable[359493] = bhCheckWallEx_0x25e930; // 0x25f11c - g_ps2RecompiledFunctionTable[359494] = bhCheckWallEx_0x25e930; // 0x25f120 - g_ps2RecompiledFunctionTable[359495] = bhCheckWallEx_0x25e930; // 0x25f124 - g_ps2RecompiledFunctionTable[359496] = bhCheckWallEx_0x25e930; // 0x25f128 - g_ps2RecompiledFunctionTable[359497] = bhCheckWallEx_0x25e930; // 0x25f12c - g_ps2RecompiledFunctionTable[359498] = bhCheckWallEx_0x25e930; // 0x25f130 - g_ps2RecompiledFunctionTable[359499] = bhCheckWallEx_0x25e930; // 0x25f134 - g_ps2RecompiledFunctionTable[359500] = bhCheckWallEx_0x25e930; // 0x25f138 - g_ps2RecompiledFunctionTable[359501] = bhCheckWallEx_0x25e930; // 0x25f13c - g_ps2RecompiledFunctionTable[359502] = bhCheckWallEx_0x25e930; // 0x25f140 - g_ps2RecompiledFunctionTable[359503] = bhCheckWallEx_0x25e930; // 0x25f144 - g_ps2RecompiledFunctionTable[359504] = bhCheckWallEx_0x25e930; // 0x25f148 - g_ps2RecompiledFunctionTable[359505] = bhCheckWallEx_0x25e930; // 0x25f14c - g_ps2RecompiledFunctionTable[359506] = bhCheckWallEx_0x25e930; // 0x25f150 - g_ps2RecompiledFunctionTable[359507] = bhCheckWallEx_0x25e930; // 0x25f154 - g_ps2RecompiledFunctionTable[359508] = bhCheckWallEx_0x25e930; // 0x25f158 - g_ps2RecompiledFunctionTable[359509] = bhCheckWallEx_0x25e930; // 0x25f15c - g_ps2RecompiledFunctionTable[359510] = bhCheckWallEx_0x25e930; // 0x25f160 - g_ps2RecompiledFunctionTable[359511] = bhCheckWallEx_0x25e930; // 0x25f164 - g_ps2RecompiledFunctionTable[359512] = bhCheckWallEx_0x25e930; // 0x25f168 - g_ps2RecompiledFunctionTable[359513] = bhCheckWallEx_0x25e930; // 0x25f16c - g_ps2RecompiledFunctionTable[359514] = bhCheckWallEx_0x25e930; // 0x25f170 - g_ps2RecompiledFunctionTable[359515] = bhCheckWallEx_0x25e930; // 0x25f174 - g_ps2RecompiledFunctionTable[359516] = bhCheckWallEx_0x25e930; // 0x25f178 - g_ps2RecompiledFunctionTable[359517] = bhCheckWallEx_0x25e930; // 0x25f17c - g_ps2RecompiledFunctionTable[359518] = bhCheckWallEx_0x25e930; // 0x25f180 - g_ps2RecompiledFunctionTable[359519] = bhCheckWallEx_0x25e930; // 0x25f184 - g_ps2RecompiledFunctionTable[359520] = bhCheckWallEx_0x25e930; // 0x25f188 - g_ps2RecompiledFunctionTable[359521] = bhCheckWallEx_0x25e930; // 0x25f18c - g_ps2RecompiledFunctionTable[359522] = bhCheckWallEx_0x25e930; // 0x25f190 - g_ps2RecompiledFunctionTable[359523] = bhCheckWallEx_0x25e930; // 0x25f194 - g_ps2RecompiledFunctionTable[359524] = bhCheckWallEx_0x25e930; // 0x25f198 - g_ps2RecompiledFunctionTable[359525] = bhCheckWallEx_0x25e930; // 0x25f19c - g_ps2RecompiledFunctionTable[359526] = bhCheckWallEx_0x25e930; // 0x25f1a0 - g_ps2RecompiledFunctionTable[359527] = bhCheckWallEx_0x25e930; // 0x25f1a4 - g_ps2RecompiledFunctionTable[359528] = bhCheckWallEx_0x25e930; // 0x25f1a8 - g_ps2RecompiledFunctionTable[359529] = bhCheckWallEx_0x25e930; // 0x25f1ac - g_ps2RecompiledFunctionTable[359530] = bhCheckWallEx_0x25e930; // 0x25f1b0 - g_ps2RecompiledFunctionTable[359531] = bhCheckWallEx_0x25e930; // 0x25f1b4 - g_ps2RecompiledFunctionTable[359532] = bhCheckWallEx_0x25e930; // 0x25f1b8 - g_ps2RecompiledFunctionTable[359533] = bhCheckWallEx_0x25e930; // 0x25f1bc - g_ps2RecompiledFunctionTable[359534] = bhCheckWallEx_0x25e930; // 0x25f1c0 - g_ps2RecompiledFunctionTable[359535] = bhCheckWallEx_0x25e930; // 0x25f1c4 - g_ps2RecompiledFunctionTable[359536] = bhCheckWallEx_0x25e930; // 0x25f1c8 - g_ps2RecompiledFunctionTable[359537] = bhCheckWallEx_0x25e930; // 0x25f1cc - g_ps2RecompiledFunctionTable[359538] = bhCheckWallEx_0x25e930; // 0x25f1d0 - g_ps2RecompiledFunctionTable[359539] = bhCheckWallEx_0x25e930; // 0x25f1d4 - g_ps2RecompiledFunctionTable[359540] = bhCheckWallEx_0x25e930; // 0x25f1d8 - g_ps2RecompiledFunctionTable[359541] = bhCheckWallEx_0x25e930; // 0x25f1dc - g_ps2RecompiledFunctionTable[359542] = bhCheckWallEx_0x25e930; // 0x25f1e0 - g_ps2RecompiledFunctionTable[359543] = bhCheckWallEx_0x25e930; // 0x25f1e4 - g_ps2RecompiledFunctionTable[359544] = bhCheckWallEx_0x25e930; // 0x25f1e8 - g_ps2RecompiledFunctionTable[359545] = bhCheckWallEx_0x25e930; // 0x25f1ec - g_ps2RecompiledFunctionTable[359546] = bhCheckWallEx_0x25e930; // 0x25f1f0 - g_ps2RecompiledFunctionTable[359547] = bhCheckWallEx_0x25e930; // 0x25f1f4 - g_ps2RecompiledFunctionTable[359548] = bhCheckWallEx_0x25e930; // 0x25f1f8 - g_ps2RecompiledFunctionTable[359549] = bhCheckWallEx_0x25e930; // 0x25f1fc - g_ps2RecompiledFunctionTable[359550] = bhCheckWallEx_0x25e930; // 0x25f200 - g_ps2RecompiledFunctionTable[359551] = bhCheckWallEx_0x25e930; // 0x25f204 - g_ps2RecompiledFunctionTable[359552] = bhCheckWallEx_0x25e930; // 0x25f208 - g_ps2RecompiledFunctionTable[359553] = bhCheckWallEx_0x25e930; // 0x25f20c - g_ps2RecompiledFunctionTable[359554] = bhCheckWallEx_0x25e930; // 0x25f210 - g_ps2RecompiledFunctionTable[359555] = bhCheckWallEx_0x25e930; // 0x25f214 - g_ps2RecompiledFunctionTable[359556] = bhCheckWallEx_0x25e930; // 0x25f218 - g_ps2RecompiledFunctionTable[359557] = bhCheckWallEx_0x25e930; // 0x25f21c - g_ps2RecompiledFunctionTable[359558] = bhCheckWallEx_0x25e930; // 0x25f220 - g_ps2RecompiledFunctionTable[359559] = bhCheckWallEx_0x25e930; // 0x25f224 - g_ps2RecompiledFunctionTable[359560] = bhCheckWallEx_0x25e930; // 0x25f228 - g_ps2RecompiledFunctionTable[359561] = bhCheckWallEx_0x25e930; // 0x25f22c - g_ps2RecompiledFunctionTable[359562] = bhCheckWallEx_0x25e930; // 0x25f230 - g_ps2RecompiledFunctionTable[359563] = bhCheckWallEx_0x25e930; // 0x25f234 - g_ps2RecompiledFunctionTable[359564] = bhCheckWallEx_0x25e930; // 0x25f238 - g_ps2RecompiledFunctionTable[359565] = bhCheckWallEx_0x25e930; // 0x25f23c - g_ps2RecompiledFunctionTable[359566] = bhCheckWallEx_0x25e930; // 0x25f240 - g_ps2RecompiledFunctionTable[359567] = bhCheckWallEx_0x25e930; // 0x25f244 - g_ps2RecompiledFunctionTable[359568] = bhCheckWallEx_0x25e930; // 0x25f248 - g_ps2RecompiledFunctionTable[359569] = bhCheckWallEx_0x25e930; // 0x25f24c - g_ps2RecompiledFunctionTable[359570] = bhCheckWallEx_0x25e930; // 0x25f250 - g_ps2RecompiledFunctionTable[359571] = bhCheckWallEx_0x25e930; // 0x25f254 - g_ps2RecompiledFunctionTable[359572] = bhCheckWallEx_0x25e930; // 0x25f258 - g_ps2RecompiledFunctionTable[359573] = bhCheckWallEx_0x25e930; // 0x25f25c - g_ps2RecompiledFunctionTable[359574] = bhCheckWallEx_0x25e930; // 0x25f260 - g_ps2RecompiledFunctionTable[359575] = bhCheckWallEx_0x25e930; // 0x25f264 - g_ps2RecompiledFunctionTable[359576] = bhCheckWallEx_0x25e930; // 0x25f268 - g_ps2RecompiledFunctionTable[359577] = bhCheckWallEx_0x25e930; // 0x25f26c - g_ps2RecompiledFunctionTable[359578] = bhCheckWallEx_0x25e930; // 0x25f270 - g_ps2RecompiledFunctionTable[359579] = bhCheckWallEx_0x25e930; // 0x25f274 - g_ps2RecompiledFunctionTable[359580] = bhCheckWallEx_0x25e930; // 0x25f278 - g_ps2RecompiledFunctionTable[359581] = bhCheckWallEx_0x25e930; // 0x25f27c - g_ps2RecompiledFunctionTable[359582] = bhCheckWallEx_0x25e930; // 0x25f280 - g_ps2RecompiledFunctionTable[359583] = bhCheckWallEx_0x25e930; // 0x25f284 - g_ps2RecompiledFunctionTable[359584] = bhCheckWallEx_0x25e930; // 0x25f288 - g_ps2RecompiledFunctionTable[359585] = bhCheckWallEx_0x25e930; // 0x25f28c - g_ps2RecompiledFunctionTable[359586] = bhCheckWallEx_0x25e930; // 0x25f290 - g_ps2RecompiledFunctionTable[359587] = bhCheckWallEx_0x25e930; // 0x25f294 - g_ps2RecompiledFunctionTable[359588] = bhCheckWallEx_0x25e930; // 0x25f298 - g_ps2RecompiledFunctionTable[359589] = bhCheckWallEx_0x25e930; // 0x25f29c - g_ps2RecompiledFunctionTable[359590] = bhCheckWallEx_0x25e930; // 0x25f2a0 - g_ps2RecompiledFunctionTable[359591] = bhCheckWallEx_0x25e930; // 0x25f2a4 - g_ps2RecompiledFunctionTable[359592] = bhCheckWallEx_0x25e930; // 0x25f2a8 - g_ps2RecompiledFunctionTable[359593] = bhCheckWallEx_0x25e930; // 0x25f2ac - g_ps2RecompiledFunctionTable[359594] = bhCheckWallEx_0x25e930; // 0x25f2b0 - g_ps2RecompiledFunctionTable[359595] = bhCheckWallEx_0x25e930; // 0x25f2b4 - g_ps2RecompiledFunctionTable[359596] = bhCheckWallEx_0x25e930; // 0x25f2b8 - g_ps2RecompiledFunctionTable[359597] = bhCheckWallEx_0x25e930; // 0x25f2bc - g_ps2RecompiledFunctionTable[359598] = bhCheckWallEx_0x25e930; // 0x25f2c0 - g_ps2RecompiledFunctionTable[359599] = bhCheckWallEx_0x25e930; // 0x25f2c4 - g_ps2RecompiledFunctionTable[359600] = bhCheckWallEx_0x25e930; // 0x25f2c8 - g_ps2RecompiledFunctionTable[359601] = bhCheckWallEx_0x25e930; // 0x25f2cc - g_ps2RecompiledFunctionTable[359602] = bhCheckWallEx_0x25e930; // 0x25f2d0 - g_ps2RecompiledFunctionTable[359603] = bhCheckWallEx_0x25e930; // 0x25f2d4 - g_ps2RecompiledFunctionTable[359604] = bhCheckWallEx_0x25e930; // 0x25f2d8 - g_ps2RecompiledFunctionTable[359605] = bhCheckWallEx_0x25e930; // 0x25f2dc - g_ps2RecompiledFunctionTable[359606] = bhCheckWallEx_0x25e930; // 0x25f2e0 - g_ps2RecompiledFunctionTable[359607] = bhCheckWallEx_0x25e930; // 0x25f2e4 - g_ps2RecompiledFunctionTable[359608] = bhCheckWallEx_0x25e930; // 0x25f2e8 - g_ps2RecompiledFunctionTable[359609] = bhCheckWallEx_0x25e930; // 0x25f2ec - g_ps2RecompiledFunctionTable[359610] = bhCheckWallEx_0x25e930; // 0x25f2f0 - g_ps2RecompiledFunctionTable[359611] = bhCheckWallEx_0x25e930; // 0x25f2f4 - g_ps2RecompiledFunctionTable[359612] = bhCheckWallEx_0x25e930; // 0x25f2f8 - g_ps2RecompiledFunctionTable[359613] = bhCheckWallEx_0x25e930; // 0x25f2fc - g_ps2RecompiledFunctionTable[359614] = bhCheckWallEx_0x25e930; // 0x25f300 - g_ps2RecompiledFunctionTable[359615] = bhCheckWallEx_0x25e930; // 0x25f304 - g_ps2RecompiledFunctionTable[359616] = bhCheckWallEx_0x25e930; // 0x25f308 - g_ps2RecompiledFunctionTable[359617] = bhCheckWallEx_0x25e930; // 0x25f30c - g_ps2RecompiledFunctionTable[359618] = bhCheckWallEx_0x25e930; // 0x25f310 - g_ps2RecompiledFunctionTable[359619] = bhCheckWallEx_0x25e930; // 0x25f314 - g_ps2RecompiledFunctionTable[359620] = bhCheckWallEx_0x25e930; // 0x25f318 - g_ps2RecompiledFunctionTable[359621] = bhCheckWallEx_0x25e930; // 0x25f31c - g_ps2RecompiledFunctionTable[359622] = bhCheckWallEx_0x25e930; // 0x25f320 - g_ps2RecompiledFunctionTable[359623] = bhCheckWallEx_0x25e930; // 0x25f324 - g_ps2RecompiledFunctionTable[359624] = bhCheckWallEx_0x25e930; // 0x25f328 - g_ps2RecompiledFunctionTable[359625] = bhCheckWallEx_0x25e930; // 0x25f32c - g_ps2RecompiledFunctionTable[359626] = bhCheckWallEx_0x25e930; // 0x25f330 - g_ps2RecompiledFunctionTable[359627] = bhCheckWallEx_0x25e930; // 0x25f334 - g_ps2RecompiledFunctionTable[359628] = bhCheckWallEx_0x25e930; // 0x25f338 - g_ps2RecompiledFunctionTable[359629] = bhCheckWallEx_0x25e930; // 0x25f33c - g_ps2RecompiledFunctionTable[359630] = bhCheckWallEx_0x25e930; // 0x25f340 - g_ps2RecompiledFunctionTable[359631] = bhCheckWallEx_0x25e930; // 0x25f344 - g_ps2RecompiledFunctionTable[359632] = bhCheckWallEx_0x25e930; // 0x25f348 - g_ps2RecompiledFunctionTable[359633] = bhCheckWallEx_0x25e930; // 0x25f34c - g_ps2RecompiledFunctionTable[359634] = bhCheckWallEx_0x25e930; // 0x25f350 - g_ps2RecompiledFunctionTable[359635] = bhCheckWallEx_0x25e930; // 0x25f354 - g_ps2RecompiledFunctionTable[359636] = bhCheckWallEx_0x25e930; // 0x25f358 - g_ps2RecompiledFunctionTable[359637] = bhCheckWallEx_0x25e930; // 0x25f35c - g_ps2RecompiledFunctionTable[359638] = bhCheckWallEx_0x25e930; // 0x25f360 - g_ps2RecompiledFunctionTable[359639] = bhCheckWallEx_0x25e930; // 0x25f364 - g_ps2RecompiledFunctionTable[359640] = bhCheckWallEx_0x25e930; // 0x25f368 - g_ps2RecompiledFunctionTable[359641] = bhCheckWallEx_0x25e930; // 0x25f36c - g_ps2RecompiledFunctionTable[359642] = bhCheckWallEx_0x25e930; // 0x25f370 - g_ps2RecompiledFunctionTable[359643] = bhCheckWallEx_0x25e930; // 0x25f374 - g_ps2RecompiledFunctionTable[359644] = bhCheckWallEx_0x25e930; // 0x25f378 - g_ps2RecompiledFunctionTable[359645] = bhCheckWallEx_0x25e930; // 0x25f37c - g_ps2RecompiledFunctionTable[359646] = bhCheckWallEx_0x25e930; // 0x25f380 - g_ps2RecompiledFunctionTable[359647] = bhCheckWallEx_0x25e930; // 0x25f384 - g_ps2RecompiledFunctionTable[359648] = bhCheckWallEx_0x25e930; // 0x25f388 - g_ps2RecompiledFunctionTable[359649] = bhCheckWallEx_0x25e930; // 0x25f38c - g_ps2RecompiledFunctionTable[359650] = bhCheckWallEx_0x25e930; // 0x25f390 - g_ps2RecompiledFunctionTable[359651] = bhCheckWallEx_0x25e930; // 0x25f394 - g_ps2RecompiledFunctionTable[359652] = bhCheckWallEx_0x25e930; // 0x25f398 - g_ps2RecompiledFunctionTable[359653] = bhCheckWallEx_0x25e930; // 0x25f39c - g_ps2RecompiledFunctionTable[359654] = bhCheckWallEx_0x25e930; // 0x25f3a0 - g_ps2RecompiledFunctionTable[359655] = bhCheckWallEx_0x25e930; // 0x25f3a4 - g_ps2RecompiledFunctionTable[359656] = bhCheckWallEx_0x25e930; // 0x25f3a8 - g_ps2RecompiledFunctionTable[359657] = bhCheckWallEx_0x25e930; // 0x25f3ac - g_ps2RecompiledFunctionTable[359658] = bhCheckWallEx_0x25e930; // 0x25f3b0 - g_ps2RecompiledFunctionTable[359659] = bhCheckWallEx_0x25e930; // 0x25f3b4 - g_ps2RecompiledFunctionTable[359660] = bhCheckWallEx_0x25e930; // 0x25f3b8 - g_ps2RecompiledFunctionTable[359661] = bhCheckWallEx_0x25e930; // 0x25f3bc - g_ps2RecompiledFunctionTable[359662] = bhCheckWallEx_0x25e930; // 0x25f3c0 - g_ps2RecompiledFunctionTable[359663] = bhCheckWallEx_0x25e930; // 0x25f3c4 - g_ps2RecompiledFunctionTable[359664] = bhCheckWallEx_0x25e930; // 0x25f3c8 - g_ps2RecompiledFunctionTable[359665] = bhCheckWallEx_0x25e930; // 0x25f3cc - g_ps2RecompiledFunctionTable[359666] = bhCheckWallEx_0x25e930; // 0x25f3d0 - g_ps2RecompiledFunctionTable[359667] = bhCheckWallEx_0x25e930; // 0x25f3d4 - g_ps2RecompiledFunctionTable[359668] = bhCheckWallEx_0x25e930; // 0x25f3d8 - g_ps2RecompiledFunctionTable[359669] = bhCheckWallEx_0x25e930; // 0x25f3dc - g_ps2RecompiledFunctionTable[359670] = bhCheckWallEx_0x25e930; // 0x25f3e0 - g_ps2RecompiledFunctionTable[359671] = bhCheckWallEx_0x25e930; // 0x25f3e4 - g_ps2RecompiledFunctionTable[359672] = bhCheckWallEx_0x25e930; // 0x25f3e8 - g_ps2RecompiledFunctionTable[359673] = bhCheckWallEx_0x25e930; // 0x25f3ec - g_ps2RecompiledFunctionTable[359674] = bhCheckWallEx_0x25e930; // 0x25f3f0 - g_ps2RecompiledFunctionTable[359675] = bhCheckWallEx_0x25e930; // 0x25f3f4 - g_ps2RecompiledFunctionTable[359676] = bhCheckWallEx_0x25e930; // 0x25f3f8 - g_ps2RecompiledFunctionTable[359677] = bhCheckWallEx_0x25e930; // 0x25f3fc - g_ps2RecompiledFunctionTable[359678] = bhCheckWallEx_0x25e930; // 0x25f400 - g_ps2RecompiledFunctionTable[359679] = bhCheckWallEx_0x25e930; // 0x25f404 - g_ps2RecompiledFunctionTable[359680] = bhCheckWallEx_0x25e930; // 0x25f408 - g_ps2RecompiledFunctionTable[359681] = bhCheckWallEx_0x25e930; // 0x25f40c - g_ps2RecompiledFunctionTable[359682] = bhCheckWallEx_0x25e930; // 0x25f410 - g_ps2RecompiledFunctionTable[359683] = bhCheckWallEx_0x25e930; // 0x25f414 - g_ps2RecompiledFunctionTable[359684] = bhCheckWallEx_0x25e930; // 0x25f418 - g_ps2RecompiledFunctionTable[359685] = bhCheckWallEx_0x25e930; // 0x25f41c - g_ps2RecompiledFunctionTable[359686] = bhCheckWallEx_0x25e930; // 0x25f420 - g_ps2RecompiledFunctionTable[359687] = bhCheckWallEx_0x25e930; // 0x25f424 - g_ps2RecompiledFunctionTable[359688] = bhCheckWallEx_0x25e930; // 0x25f428 - g_ps2RecompiledFunctionTable[359689] = bhCheckWallEx_0x25e930; // 0x25f42c - g_ps2RecompiledFunctionTable[359690] = bhCheckWallEx_0x25e930; // 0x25f430 - g_ps2RecompiledFunctionTable[359691] = bhCheckWallEx_0x25e930; // 0x25f434 - g_ps2RecompiledFunctionTable[359692] = bhCheckWallEx_0x25e930; // 0x25f438 - g_ps2RecompiledFunctionTable[359693] = bhCheckWallEx_0x25e930; // 0x25f43c - g_ps2RecompiledFunctionTable[359694] = bhCheckWallEx_0x25e930; // 0x25f440 - g_ps2RecompiledFunctionTable[359695] = bhCheckWallEx_0x25e930; // 0x25f444 - g_ps2RecompiledFunctionTable[359696] = bhCheckWallEx_0x25e930; // 0x25f448 - g_ps2RecompiledFunctionTable[359697] = bhCheckWallEx_0x25e930; // 0x25f44c - g_ps2RecompiledFunctionTable[359698] = bhCheckWallEx_0x25e930; // 0x25f450 - g_ps2RecompiledFunctionTable[359699] = bhCheckWallEx_0x25e930; // 0x25f454 - g_ps2RecompiledFunctionTable[359700] = bhCheckWallEx_0x25e930; // 0x25f458 - g_ps2RecompiledFunctionTable[359701] = bhCheckWallEx_0x25e930; // 0x25f45c - g_ps2RecompiledFunctionTable[359702] = bhCheckWallEx_0x25e930; // 0x25f460 - g_ps2RecompiledFunctionTable[359703] = bhCheckWallEx_0x25e930; // 0x25f464 - g_ps2RecompiledFunctionTable[359704] = bhCheckWallEx_0x25e930; // 0x25f468 - g_ps2RecompiledFunctionTable[359705] = bhCheckWallEx_0x25e930; // 0x25f46c - g_ps2RecompiledFunctionTable[359706] = bhCheckWallEx_0x25e930; // 0x25f470 - g_ps2RecompiledFunctionTable[359707] = bhCheckWallEx_0x25e930; // 0x25f474 - g_ps2RecompiledFunctionTable[359708] = bhCheckWallEx_0x25e930; // 0x25f478 - g_ps2RecompiledFunctionTable[359709] = bhCheckWallEx_0x25e930; // 0x25f47c - g_ps2RecompiledFunctionTable[359710] = bhCheckWallEx_0x25e930; // 0x25f480 - g_ps2RecompiledFunctionTable[359711] = bhCheckWallEx_0x25e930; // 0x25f484 - g_ps2RecompiledFunctionTable[359712] = bhCheckWallEx_0x25e930; // 0x25f488 - g_ps2RecompiledFunctionTable[359713] = bhCheckWallEx_0x25e930; // 0x25f48c - g_ps2RecompiledFunctionTable[359714] = bhCheckWallEx_0x25e930; // 0x25f490 - g_ps2RecompiledFunctionTable[359715] = bhCheckWallEx_0x25e930; // 0x25f494 - g_ps2RecompiledFunctionTable[359716] = bhCheckWallEx_0x25e930; // 0x25f498 - g_ps2RecompiledFunctionTable[359717] = bhCheckWallEx_0x25e930; // 0x25f49c - g_ps2RecompiledFunctionTable[359718] = bhCheckWallEx_0x25e930; // 0x25f4a0 - g_ps2RecompiledFunctionTable[359719] = bhCheckWallEx_0x25e930; // 0x25f4a4 - g_ps2RecompiledFunctionTable[359720] = bhCheckWallEx_0x25e930; // 0x25f4a8 - g_ps2RecompiledFunctionTable[359721] = bhCheckWallEx_0x25e930; // 0x25f4ac - g_ps2RecompiledFunctionTable[359722] = bhCheckWallEx_0x25e930; // 0x25f4b0 - g_ps2RecompiledFunctionTable[359723] = bhCheckWallEx_0x25e930; // 0x25f4b4 - g_ps2RecompiledFunctionTable[359724] = bhCheckWallEx_0x25e930; // 0x25f4b8 - g_ps2RecompiledFunctionTable[359725] = bhCheckWallEx_0x25e930; // 0x25f4bc - g_ps2RecompiledFunctionTable[359726] = bhCheckWallEx_0x25e930; // 0x25f4c0 - g_ps2RecompiledFunctionTable[359727] = bhCheckWallEx_0x25e930; // 0x25f4c4 - g_ps2RecompiledFunctionTable[359728] = bhCheckWallEx_0x25e930; // 0x25f4c8 - g_ps2RecompiledFunctionTable[359729] = bhCheckWallEx_0x25e930; // 0x25f4cc - g_ps2RecompiledFunctionTable[359730] = bhCheckWallEx_0x25e930; // 0x25f4d0 - g_ps2RecompiledFunctionTable[359731] = bhCheckWallEx_0x25e930; // 0x25f4d4 - g_ps2RecompiledFunctionTable[359732] = bhCheckWallEx_0x25e930; // 0x25f4d8 - g_ps2RecompiledFunctionTable[359733] = bhCheckWallEx_0x25e930; // 0x25f4dc - g_ps2RecompiledFunctionTable[359734] = bhCheckWallEx_0x25e930; // 0x25f4e0 - g_ps2RecompiledFunctionTable[359735] = bhCheckWallEx_0x25e930; // 0x25f4e4 - g_ps2RecompiledFunctionTable[359736] = bhCheckWallEx_0x25e930; // 0x25f4e8 - g_ps2RecompiledFunctionTable[359737] = bhCheckWallEx_0x25e930; // 0x25f4ec - g_ps2RecompiledFunctionTable[359738] = bhCheckWallEx_0x25e930; // 0x25f4f0 - g_ps2RecompiledFunctionTable[359739] = bhCheckWallEx_0x25e930; // 0x25f4f4 - g_ps2RecompiledFunctionTable[359740] = bhCheckWallEx_0x25e930; // 0x25f4f8 - g_ps2RecompiledFunctionTable[359741] = bhCheckWallEx_0x25e930; // 0x25f4fc - g_ps2RecompiledFunctionTable[359742] = bhCheckWallEx_0x25e930; // 0x25f500 - g_ps2RecompiledFunctionTable[359743] = bhCheckWallEx_0x25e930; // 0x25f504 - g_ps2RecompiledFunctionTable[359744] = bhCheckWallEx_0x25e930; // 0x25f508 - g_ps2RecompiledFunctionTable[359745] = bhCheckWallEx_0x25e930; // 0x25f50c - g_ps2RecompiledFunctionTable[359746] = bhCheckWallEx_0x25e930; // 0x25f510 - g_ps2RecompiledFunctionTable[359747] = bhCheckWallEx_0x25e930; // 0x25f514 - g_ps2RecompiledFunctionTable[359748] = bhCheckWallEx_0x25e930; // 0x25f518 - g_ps2RecompiledFunctionTable[359749] = bhCheckWallEx_0x25e930; // 0x25f51c - g_ps2RecompiledFunctionTable[359750] = bhCheckWallEx_0x25e930; // 0x25f520 - g_ps2RecompiledFunctionTable[359751] = bhCheckWallEx_0x25e930; // 0x25f524 - g_ps2RecompiledFunctionTable[359752] = bhCheckWallEx_0x25e930; // 0x25f528 - g_ps2RecompiledFunctionTable[359753] = bhCheckWallEx_0x25e930; // 0x25f52c - g_ps2RecompiledFunctionTable[359754] = bhCheckWallEx_0x25e930; // 0x25f530 - g_ps2RecompiledFunctionTable[359755] = bhCheckWallEx_0x25e930; // 0x25f534 - g_ps2RecompiledFunctionTable[359756] = bhCheckWallEx_0x25e930; // 0x25f538 - g_ps2RecompiledFunctionTable[359757] = bhCheckWallEx_0x25e930; // 0x25f53c - g_ps2RecompiledFunctionTable[359758] = bhCheckWallEx_0x25e930; // 0x25f540 - g_ps2RecompiledFunctionTable[359759] = bhCheckWallEx_0x25e930; // 0x25f544 - g_ps2RecompiledFunctionTable[359760] = bhCheckWallEx_0x25e930; // 0x25f548 - g_ps2RecompiledFunctionTable[359761] = bhCheckWallEx_0x25e930; // 0x25f54c - g_ps2RecompiledFunctionTable[359762] = bhCheckWallEx_0x25e930; // 0x25f550 - g_ps2RecompiledFunctionTable[359763] = bhCheckWallEx_0x25e930; // 0x25f554 - g_ps2RecompiledFunctionTable[359764] = bhCheckWallEx_0x25e930; // 0x25f558 - g_ps2RecompiledFunctionTable[359765] = bhCheckWallEx_0x25e930; // 0x25f55c - g_ps2RecompiledFunctionTable[359766] = bhCheckWallEx_0x25e930; // 0x25f560 - g_ps2RecompiledFunctionTable[359767] = bhCheckWallEx_0x25e930; // 0x25f564 - g_ps2RecompiledFunctionTable[359768] = bhCheckWallEx_0x25e930; // 0x25f568 - g_ps2RecompiledFunctionTable[359769] = bhCheckWallEx_0x25e930; // 0x25f56c - g_ps2RecompiledFunctionTable[359770] = bhCheckWallEx_0x25e930; // 0x25f570 - g_ps2RecompiledFunctionTable[359771] = bhCheckWallEx_0x25e930; // 0x25f574 - g_ps2RecompiledFunctionTable[359772] = bhCheckWallEx_0x25e930; // 0x25f578 - g_ps2RecompiledFunctionTable[359773] = bhCheckWallEx_0x25e930; // 0x25f57c - g_ps2RecompiledFunctionTable[359774] = bhCheckWallEx_0x25e930; // 0x25f580 - g_ps2RecompiledFunctionTable[359775] = bhCheckWallEx_0x25e930; // 0x25f584 - g_ps2RecompiledFunctionTable[359776] = bhCheckWallEx_0x25e930; // 0x25f588 - g_ps2RecompiledFunctionTable[359777] = bhCheckWallEx_0x25e930; // 0x25f58c - g_ps2RecompiledFunctionTable[359778] = bhCheckWallEx_0x25e930; // 0x25f590 - g_ps2RecompiledFunctionTable[359779] = bhCheckWallEx_0x25e930; // 0x25f594 - g_ps2RecompiledFunctionTable[359780] = bhCheckWallEx_0x25e930; // 0x25f598 - g_ps2RecompiledFunctionTable[359781] = bhCheckWallEx_0x25e930; // 0x25f59c - g_ps2RecompiledFunctionTable[359782] = bhCheckWallEx_0x25e930; // 0x25f5a0 - g_ps2RecompiledFunctionTable[359783] = bhCheckWallEx_0x25e930; // 0x25f5a4 - g_ps2RecompiledFunctionTable[359784] = bhCheckWallEx_0x25e930; // 0x25f5a8 - g_ps2RecompiledFunctionTable[359785] = bhCheckWallEx_0x25e930; // 0x25f5ac - g_ps2RecompiledFunctionTable[359786] = bhCheckWallEx_0x25e930; // 0x25f5b0 - g_ps2RecompiledFunctionTable[359787] = bhCheckWallEx_0x25e930; // 0x25f5b4 - g_ps2RecompiledFunctionTable[359788] = bhCheckWallEx_0x25e930; // 0x25f5b8 - g_ps2RecompiledFunctionTable[359789] = bhCheckWallEx_0x25e930; // 0x25f5bc - g_ps2RecompiledFunctionTable[359790] = bhCheckWallEx_0x25e930; // 0x25f5c0 - g_ps2RecompiledFunctionTable[359791] = bhCheckWallEx_0x25e930; // 0x25f5c4 - g_ps2RecompiledFunctionTable[359792] = bhCheckWallEx_0x25e930; // 0x25f5c8 - g_ps2RecompiledFunctionTable[359793] = bhCheckWallEx_0x25e930; // 0x25f5cc - g_ps2RecompiledFunctionTable[359794] = bhCheckWallEx_0x25e930; // 0x25f5d0 - g_ps2RecompiledFunctionTable[359795] = bhCheckWallEx_0x25e930; // 0x25f5d4 - g_ps2RecompiledFunctionTable[359796] = bhCheckWallEx_0x25e930; // 0x25f5d8 - g_ps2RecompiledFunctionTable[359797] = bhCheckWallEx_0x25e930; // 0x25f5dc - g_ps2RecompiledFunctionTable[359798] = bhCheckWallEx_0x25e930; // 0x25f5e0 - g_ps2RecompiledFunctionTable[359799] = bhCheckWallEx_0x25e930; // 0x25f5e4 - g_ps2RecompiledFunctionTable[359800] = bhCheckWallEx_0x25e930; // 0x25f5e8 - g_ps2RecompiledFunctionTable[359801] = bhCheckWallEx_0x25e930; // 0x25f5ec - g_ps2RecompiledFunctionTable[359802] = bhCheckWallEx_0x25e930; // 0x25f5f0 - g_ps2RecompiledFunctionTable[359803] = bhCheckWallEx_0x25e930; // 0x25f5f4 - g_ps2RecompiledFunctionTable[359804] = bhCheckWallEx_0x25e930; // 0x25f5f8 - g_ps2RecompiledFunctionTable[359805] = bhCheckWallEx_0x25e930; // 0x25f5fc - g_ps2RecompiledFunctionTable[359806] = bhCheckWallEx_0x25e930; // 0x25f600 - g_ps2RecompiledFunctionTable[359807] = bhCheckWallEx_0x25e930; // 0x25f604 - g_ps2RecompiledFunctionTable[359808] = bhCheckWallEx_0x25e930; // 0x25f608 - g_ps2RecompiledFunctionTable[359809] = bhCheckWallEx_0x25e930; // 0x25f60c - g_ps2RecompiledFunctionTable[359810] = bhCheckWallEx_0x25e930; // 0x25f610 - g_ps2RecompiledFunctionTable[359811] = bhCheckWallEx_0x25e930; // 0x25f614 - g_ps2RecompiledFunctionTable[359812] = bhCheckWallEx_0x25e930; // 0x25f618 - g_ps2RecompiledFunctionTable[359813] = bhCheckWallEx_0x25e930; // 0x25f61c - g_ps2RecompiledFunctionTable[359814] = bhCheckWallEx_0x25e930; // 0x25f620 - g_ps2RecompiledFunctionTable[359815] = bhCheckWallEx_0x25e930; // 0x25f624 - g_ps2RecompiledFunctionTable[359816] = bhCheckWallEx_0x25e930; // 0x25f628 - g_ps2RecompiledFunctionTable[359817] = bhCheckWallEx_0x25e930; // 0x25f62c - g_ps2RecompiledFunctionTable[359818] = bhCheckWallEx_0x25e930; // 0x25f630 - g_ps2RecompiledFunctionTable[359819] = bhCheckWallEx_0x25e930; // 0x25f634 - g_ps2RecompiledFunctionTable[359820] = bhCheckWallEx_0x25e930; // 0x25f638 - g_ps2RecompiledFunctionTable[359821] = bhCheckWallEx_0x25e930; // 0x25f63c - g_ps2RecompiledFunctionTable[359822] = bhCheckWallEx_0x25e930; // 0x25f640 - g_ps2RecompiledFunctionTable[359823] = bhCheckWallEx_0x25e930; // 0x25f644 - g_ps2RecompiledFunctionTable[359824] = bhCheckWallEx_0x25e930; // 0x25f648 - g_ps2RecompiledFunctionTable[359825] = bhCheckWallEx_0x25e930; // 0x25f64c - g_ps2RecompiledFunctionTable[359826] = bhCheckWallEx_0x25e930; // 0x25f650 - g_ps2RecompiledFunctionTable[359827] = bhCheckWallEx_0x25e930; // 0x25f654 - g_ps2RecompiledFunctionTable[359828] = bhCheckWallEx_0x25e930; // 0x25f658 - g_ps2RecompiledFunctionTable[359829] = bhCheckWallEx_0x25e930; // 0x25f65c - g_ps2RecompiledFunctionTable[359830] = bhCheckWallEx_0x25e930; // 0x25f660 - g_ps2RecompiledFunctionTable[359831] = bhCheckWallEx_0x25e930; // 0x25f664 - g_ps2RecompiledFunctionTable[359832] = bhCheckWallEx_0x25e930; // 0x25f668 - g_ps2RecompiledFunctionTable[359833] = bhCheckWallEx_0x25e930; // 0x25f66c - g_ps2RecompiledFunctionTable[359834] = bhCheckWallEx_0x25e930; // 0x25f670 - g_ps2RecompiledFunctionTable[359835] = bhCheckWallEx_0x25e930; // 0x25f674 - g_ps2RecompiledFunctionTable[359836] = bhCheckWallEx_0x25e930; // 0x25f678 - g_ps2RecompiledFunctionTable[359837] = bhCheckWallEx_0x25e930; // 0x25f67c - g_ps2RecompiledFunctionTable[359838] = bhCheckWallEx_0x25e930; // 0x25f680 - g_ps2RecompiledFunctionTable[359839] = bhCheckWallEx_0x25e930; // 0x25f684 - g_ps2RecompiledFunctionTable[359840] = bhCheckWallEx_0x25e930; // 0x25f688 - g_ps2RecompiledFunctionTable[359841] = bhCheckWallEx_0x25e930; // 0x25f68c - g_ps2RecompiledFunctionTable[359842] = bhCheckWallEx_0x25e930; // 0x25f690 - g_ps2RecompiledFunctionTable[359843] = bhCheckWallEx_0x25e930; // 0x25f694 - g_ps2RecompiledFunctionTable[359844] = bhCheckWallEx_0x25e930; // 0x25f698 - g_ps2RecompiledFunctionTable[359845] = bhCheckWallEx_0x25e930; // 0x25f69c - g_ps2RecompiledFunctionTable[359846] = bhCheckWallEx_0x25e930; // 0x25f6a0 - g_ps2RecompiledFunctionTable[359847] = bhCheckWallEx_0x25e930; // 0x25f6a4 - g_ps2RecompiledFunctionTable[359848] = bhCheckWallEx_0x25e930; // 0x25f6a8 - g_ps2RecompiledFunctionTable[359849] = bhCheckWallEx_0x25e930; // 0x25f6ac - g_ps2RecompiledFunctionTable[359850] = bhCheckWallEx_0x25e930; // 0x25f6b0 - g_ps2RecompiledFunctionTable[359851] = bhCheckWallEx_0x25e930; // 0x25f6b4 - g_ps2RecompiledFunctionTable[359852] = bhCheckWallEx_0x25e930; // 0x25f6b8 - g_ps2RecompiledFunctionTable[359853] = bhCheckWallEx_0x25e930; // 0x25f6bc - g_ps2RecompiledFunctionTable[359854] = bhCheckWallEx_0x25e930; // 0x25f6c0 - g_ps2RecompiledFunctionTable[359855] = bhCheckWallEx_0x25e930; // 0x25f6c4 - g_ps2RecompiledFunctionTable[359856] = bhCheckWallEx_0x25e930; // 0x25f6c8 - g_ps2RecompiledFunctionTable[359857] = bhCheckWallEx_0x25e930; // 0x25f6cc - g_ps2RecompiledFunctionTable[359858] = bhCheckWallEx_0x25e930; // 0x25f6d0 - g_ps2RecompiledFunctionTable[359859] = bhCheckWallEx_0x25e930; // 0x25f6d4 - g_ps2RecompiledFunctionTable[359860] = bhCheckWallEx_0x25e930; // 0x25f6d8 - g_ps2RecompiledFunctionTable[359861] = bhCheckWallEx_0x25e930; // 0x25f6dc - g_ps2RecompiledFunctionTable[359862] = bhCheckWallEx_0x25e930; // 0x25f6e0 - g_ps2RecompiledFunctionTable[359863] = bhCheckWallEx_0x25e930; // 0x25f6e4 - g_ps2RecompiledFunctionTable[359864] = bhCheckWallEx_0x25e930; // 0x25f6e8 - g_ps2RecompiledFunctionTable[359865] = bhCheckWallEx_0x25e930; // 0x25f6ec - g_ps2RecompiledFunctionTable[359866] = bhCheckWallEx_0x25e930; // 0x25f6f0 - g_ps2RecompiledFunctionTable[359867] = bhCheckWallEx_0x25e930; // 0x25f6f4 - g_ps2RecompiledFunctionTable[359868] = bhCheckWallEx_0x25e930; // 0x25f6f8 - g_ps2RecompiledFunctionTable[359869] = bhCheckWallEx_0x25e930; // 0x25f6fc - g_ps2RecompiledFunctionTable[359870] = bhCheckWallEx_0x25e930; // 0x25f700 - g_ps2RecompiledFunctionTable[359871] = bhCheckWallEx_0x25e930; // 0x25f704 - g_ps2RecompiledFunctionTable[359872] = bhCheckWallEx_0x25e930; // 0x25f708 - g_ps2RecompiledFunctionTable[359873] = bhCheckWallEx_0x25e930; // 0x25f70c - g_ps2RecompiledFunctionTable[359874] = bhCheckWallEx_0x25e930; // 0x25f710 - g_ps2RecompiledFunctionTable[359875] = bhCheckWallEx_0x25e930; // 0x25f714 - g_ps2RecompiledFunctionTable[359876] = bhCheckWallEx_0x25e930; // 0x25f718 - g_ps2RecompiledFunctionTable[359877] = bhCheckWallEx_0x25e930; // 0x25f71c - g_ps2RecompiledFunctionTable[359878] = bhCheckWallEx_0x25e930; // 0x25f720 - g_ps2RecompiledFunctionTable[359879] = bhCheckWallEx_0x25e930; // 0x25f724 - g_ps2RecompiledFunctionTable[359880] = bhCheckWallEx_0x25e930; // 0x25f728 - g_ps2RecompiledFunctionTable[359881] = bhCheckWallEx_0x25e930; // 0x25f72c - g_ps2RecompiledFunctionTable[359882] = bhCheckWallEx_0x25e930; // 0x25f730 - g_ps2RecompiledFunctionTable[359883] = bhCheckWallEx_0x25e930; // 0x25f734 - g_ps2RecompiledFunctionTable[359884] = bhCheckWallEx_0x25e930; // 0x25f738 - g_ps2RecompiledFunctionTable[359885] = bhCheckWallEx_0x25e930; // 0x25f73c - g_ps2RecompiledFunctionTable[359886] = bhCheckWallEx_0x25e930; // 0x25f740 - g_ps2RecompiledFunctionTable[359887] = bhCheckWallEx_0x25e930; // 0x25f744 - g_ps2RecompiledFunctionTable[359888] = bhCheckWallEx_0x25e930; // 0x25f748 - g_ps2RecompiledFunctionTable[359889] = bhCheckWallEx_0x25e930; // 0x25f74c - g_ps2RecompiledFunctionTable[359890] = bhCheckWallEx_0x25e930; // 0x25f750 - g_ps2RecompiledFunctionTable[359891] = bhCheckWallEx_0x25e930; // 0x25f754 - g_ps2RecompiledFunctionTable[359892] = bhCheckWallEx_0x25e930; // 0x25f758 - g_ps2RecompiledFunctionTable[359893] = bhCheckWallEx_0x25e930; // 0x25f75c - g_ps2RecompiledFunctionTable[359894] = bhCheckWallEx_0x25e930; // 0x25f760 - g_ps2RecompiledFunctionTable[359895] = bhCheckWallEx_0x25e930; // 0x25f764 - g_ps2RecompiledFunctionTable[359896] = bhCheckWallEx_0x25e930; // 0x25f768 - g_ps2RecompiledFunctionTable[359897] = bhCheckWallEx_0x25e930; // 0x25f76c - g_ps2RecompiledFunctionTable[359898] = bhCheckWallEx_0x25e930; // 0x25f770 - g_ps2RecompiledFunctionTable[359899] = bhCheckWallEx_0x25e930; // 0x25f774 - g_ps2RecompiledFunctionTable[359900] = bhCheckWallEx_0x25e930; // 0x25f778 - g_ps2RecompiledFunctionTable[359901] = bhCheckWallEx_0x25e930; // 0x25f77c - g_ps2RecompiledFunctionTable[359902] = bhCheckWallEx_0x25e930; // 0x25f780 - g_ps2RecompiledFunctionTable[359903] = bhCheckWallEx_0x25e930; // 0x25f784 - g_ps2RecompiledFunctionTable[359904] = bhCheckWallEx_0x25e930; // 0x25f788 - g_ps2RecompiledFunctionTable[359905] = bhCheckWallEx_0x25e930; // 0x25f78c - g_ps2RecompiledFunctionTable[359906] = bhCheckWallEx_0x25e930; // 0x25f790 - g_ps2RecompiledFunctionTable[359907] = bhCheckWallEx_0x25e930; // 0x25f794 - g_ps2RecompiledFunctionTable[359908] = bhCheckWallEx_0x25e930; // 0x25f798 - g_ps2RecompiledFunctionTable[359909] = bhCheckWallEx_0x25e930; // 0x25f79c - g_ps2RecompiledFunctionTable[359910] = bhCheckWallEx_0x25e930; // 0x25f7a0 - g_ps2RecompiledFunctionTable[359911] = bhCheckWallEx_0x25e930; // 0x25f7a4 - g_ps2RecompiledFunctionTable[359912] = bhCheckWallEx_0x25e930; // 0x25f7a8 - g_ps2RecompiledFunctionTable[359913] = bhCheckWallEx_0x25e930; // 0x25f7ac - g_ps2RecompiledFunctionTable[359914] = bhCheckWallEx_0x25e930; // 0x25f7b0 - g_ps2RecompiledFunctionTable[359915] = bhCheckWallEx_0x25e930; // 0x25f7b4 - g_ps2RecompiledFunctionTable[359916] = bhCheckWallEx_0x25e930; // 0x25f7b8 - g_ps2RecompiledFunctionTable[359917] = bhCheckWallEx_0x25e930; // 0x25f7bc - g_ps2RecompiledFunctionTable[359918] = bhCheckWallEx_0x25e930; // 0x25f7c0 - g_ps2RecompiledFunctionTable[359919] = bhCheckWallEx_0x25e930; // 0x25f7c4 - g_ps2RecompiledFunctionTable[359920] = bhCheckWallEx_0x25e930; // 0x25f7c8 - g_ps2RecompiledFunctionTable[359921] = bhCheckWallEx_0x25e930; // 0x25f7cc - g_ps2RecompiledFunctionTable[359922] = bhCheckWallEx_0x25e930; // 0x25f7d0 - g_ps2RecompiledFunctionTable[359923] = bhCheckWallEx_0x25e930; // 0x25f7d4 - g_ps2RecompiledFunctionTable[359924] = bhCheckWallEx_0x25e930; // 0x25f7d8 - g_ps2RecompiledFunctionTable[359925] = bhCheckWallEx_0x25e930; // 0x25f7dc - g_ps2RecompiledFunctionTable[359926] = bhCheckWallEx_0x25e930; // 0x25f7e0 - g_ps2RecompiledFunctionTable[359927] = bhCheckWallEx_0x25e930; // 0x25f7e4 - g_ps2RecompiledFunctionTable[359928] = bhCheckWallEx_0x25e930; // 0x25f7e8 - g_ps2RecompiledFunctionTable[359929] = bhCheckWallEx_0x25e930; // 0x25f7ec - g_ps2RecompiledFunctionTable[359930] = bhCheckWallEx_0x25e930; // 0x25f7f0 - g_ps2RecompiledFunctionTable[359931] = bhCheckWallEx_0x25e930; // 0x25f7f4 - g_ps2RecompiledFunctionTable[359932] = bhCheckWallEx_0x25e930; // 0x25f7f8 - g_ps2RecompiledFunctionTable[359933] = bhCheckWallEx_0x25e930; // 0x25f7fc - g_ps2RecompiledFunctionTable[359934] = bhCheckWallEx_0x25e930; // 0x25f800 - g_ps2RecompiledFunctionTable[359935] = bhCheckWallEx_0x25e930; // 0x25f804 - g_ps2RecompiledFunctionTable[359936] = bhCheckWallEx_0x25e930; // 0x25f808 - g_ps2RecompiledFunctionTable[359937] = bhCheckWallEx_0x25e930; // 0x25f80c - g_ps2RecompiledFunctionTable[359938] = bhCheckWallEx_0x25e930; // 0x25f810 - g_ps2RecompiledFunctionTable[359939] = bhCheckWallEx_0x25e930; // 0x25f814 - g_ps2RecompiledFunctionTable[359940] = bhCheckWallEx_0x25e930; // 0x25f818 - g_ps2RecompiledFunctionTable[359941] = bhCheckWallEx_0x25e930; // 0x25f81c - g_ps2RecompiledFunctionTable[359942] = bhCheckWallEx_0x25e930; // 0x25f820 - g_ps2RecompiledFunctionTable[359943] = bhCheckWallEx_0x25e930; // 0x25f824 - g_ps2RecompiledFunctionTable[359944] = bhCheckWallEx_0x25e930; // 0x25f828 - g_ps2RecompiledFunctionTable[359945] = bhCheckWallEx_0x25e930; // 0x25f82c - g_ps2RecompiledFunctionTable[359946] = bhCheckWallEx_0x25e930; // 0x25f830 - g_ps2RecompiledFunctionTable[359947] = bhCheckWallEx_0x25e930; // 0x25f834 - g_ps2RecompiledFunctionTable[359948] = bhCheckWallEx_0x25e930; // 0x25f838 - g_ps2RecompiledFunctionTable[359949] = bhCheckWallEx_0x25e930; // 0x25f83c - g_ps2RecompiledFunctionTable[359950] = bhCheckWallEx_0x25e930; // 0x25f840 - g_ps2RecompiledFunctionTable[359951] = bhCheckWallEx_0x25e930; // 0x25f844 - g_ps2RecompiledFunctionTable[359952] = bhCheckWallEx_0x25e930; // 0x25f848 - g_ps2RecompiledFunctionTable[359953] = bhCheckWallEx_0x25e930; // 0x25f84c - g_ps2RecompiledFunctionTable[359954] = bhCheckWallEx_0x25e930; // 0x25f850 - g_ps2RecompiledFunctionTable[359955] = bhCheckWallEx_0x25e930; // 0x25f854 - g_ps2RecompiledFunctionTable[359956] = bhCheckWallEx_0x25e930; // 0x25f858 - g_ps2RecompiledFunctionTable[359957] = bhCheckWallEx_0x25e930; // 0x25f85c - g_ps2RecompiledFunctionTable[359958] = bhCheckWallEx_0x25e930; // 0x25f860 - g_ps2RecompiledFunctionTable[359959] = bhCheckWallEx_0x25e930; // 0x25f864 - g_ps2RecompiledFunctionTable[359960] = bhCheckWallEx_0x25e930; // 0x25f868 - g_ps2RecompiledFunctionTable[359961] = bhCheckWallEx_0x25e930; // 0x25f86c - g_ps2RecompiledFunctionTable[359962] = bhCheckWallEx_0x25e930; // 0x25f870 - g_ps2RecompiledFunctionTable[359963] = bhCheckWallEx_0x25e930; // 0x25f874 - g_ps2RecompiledFunctionTable[359964] = bhCheckWallEx_0x25e930; // 0x25f878 - g_ps2RecompiledFunctionTable[359965] = bhCheckWallEx_0x25e930; // 0x25f87c - g_ps2RecompiledFunctionTable[359966] = bhCheckWallEx_0x25e930; // 0x25f880 - g_ps2RecompiledFunctionTable[359967] = bhCheckWallEx_0x25e930; // 0x25f884 - g_ps2RecompiledFunctionTable[359968] = bhCheckWallEx_0x25e930; // 0x25f888 - g_ps2RecompiledFunctionTable[359969] = bhCheckWallEx_0x25e930; // 0x25f88c - g_ps2RecompiledFunctionTable[359970] = bhCheckWallEx_0x25e930; // 0x25f890 - g_ps2RecompiledFunctionTable[359971] = bhCheckWallEx_0x25e930; // 0x25f894 - g_ps2RecompiledFunctionTable[359972] = bhCheckWallEx_0x25e930; // 0x25f898 - g_ps2RecompiledFunctionTable[359973] = bhCheckWallEx_0x25e930; // 0x25f89c - g_ps2RecompiledFunctionTable[359974] = bhCheckWallEx_0x25e930; // 0x25f8a0 - g_ps2RecompiledFunctionTable[359975] = bhCheckWallEx_0x25e930; // 0x25f8a4 - g_ps2RecompiledFunctionTable[359976] = bhCheckWallEx_0x25e930; // 0x25f8a8 - g_ps2RecompiledFunctionTable[359977] = bhCheckWallEx_0x25e930; // 0x25f8ac - g_ps2RecompiledFunctionTable[359978] = bhCheckWallEx_0x25e930; // 0x25f8b0 - g_ps2RecompiledFunctionTable[359979] = bhCheckWallEx_0x25e930; // 0x25f8b4 - g_ps2RecompiledFunctionTable[359980] = bhCheckWallEx_0x25e930; // 0x25f8b8 - g_ps2RecompiledFunctionTable[359981] = bhCheckWallEx_0x25e930; // 0x25f8bc - g_ps2RecompiledFunctionTable[359982] = bhCheckWallEx_0x25e930; // 0x25f8c0 - g_ps2RecompiledFunctionTable[359983] = bhCheckWallEx_0x25e930; // 0x25f8c4 - g_ps2RecompiledFunctionTable[359984] = bhCheckWallEx_0x25e930; // 0x25f8c8 - g_ps2RecompiledFunctionTable[359985] = bhCheckWallEx_0x25e930; // 0x25f8cc - g_ps2RecompiledFunctionTable[359986] = bhCheckWallEx_0x25e930; // 0x25f8d0 - g_ps2RecompiledFunctionTable[359987] = bhCheckWallEx_0x25e930; // 0x25f8d4 - g_ps2RecompiledFunctionTable[359988] = bhCheckWallEx_0x25e930; // 0x25f8d8 - g_ps2RecompiledFunctionTable[359989] = bhCheckWallEx_0x25e930; // 0x25f8dc - g_ps2RecompiledFunctionTable[359990] = bhCheckWallEx_0x25e930; // 0x25f8e0 - g_ps2RecompiledFunctionTable[359991] = bhCheckWallEx_0x25e930; // 0x25f8e4 - g_ps2RecompiledFunctionTable[359992] = bhCheckWallEx_0x25e930; // 0x25f8e8 - g_ps2RecompiledFunctionTable[359993] = bhCheckWallEx_0x25e930; // 0x25f8ec - g_ps2RecompiledFunctionTable[359994] = bhCheckWallEx_0x25e930; // 0x25f8f0 - g_ps2RecompiledFunctionTable[359995] = bhCheckWallEx_0x25e930; // 0x25f8f4 - g_ps2RecompiledFunctionTable[359996] = bhCheckWallEx_0x25e930; // 0x25f8f8 - g_ps2RecompiledFunctionTable[359997] = bhCheckWallEx_0x25e930; // 0x25f8fc - g_ps2RecompiledFunctionTable[359998] = bhCheckWallEx_0x25e930; // 0x25f900 - g_ps2RecompiledFunctionTable[359999] = bhCheckWallEx_0x25e930; // 0x25f904 - g_ps2RecompiledFunctionTable[360000] = bhCheckWallEx_0x25e930; // 0x25f908 - g_ps2RecompiledFunctionTable[360001] = bhCheckWallEx_0x25e930; // 0x25f90c - g_ps2RecompiledFunctionTable[360002] = bhCheckWallEx_0x25e930; // 0x25f910 - g_ps2RecompiledFunctionTable[360003] = bhCheckWallEx_0x25e930; // 0x25f914 - g_ps2RecompiledFunctionTable[360004] = bhCheckWallEx_0x25e930; // 0x25f918 - g_ps2RecompiledFunctionTable[360005] = bhCheckWallEx_0x25e930; // 0x25f91c - g_ps2RecompiledFunctionTable[360006] = bhCheckWallEx_0x25e930; // 0x25f920 - g_ps2RecompiledFunctionTable[360007] = bhCheckWallEx_0x25e930; // 0x25f924 - g_ps2RecompiledFunctionTable[360008] = bhCheckWallEx_0x25e930; // 0x25f928 - g_ps2RecompiledFunctionTable[360009] = bhCheckWallEx_0x25e930; // 0x25f92c - g_ps2RecompiledFunctionTable[360010] = bhCheckWallEx_0x25e930; // 0x25f930 - g_ps2RecompiledFunctionTable[360011] = bhCheckWallEx_0x25e930; // 0x25f934 - g_ps2RecompiledFunctionTable[360012] = bhCheckWallEx_0x25e930; // 0x25f938 - g_ps2RecompiledFunctionTable[360013] = bhCheckWallEx_0x25e930; // 0x25f93c - g_ps2RecompiledFunctionTable[360014] = bhCheckWallEx_0x25e930; // 0x25f940 - g_ps2RecompiledFunctionTable[360015] = bhCheckWallEx_0x25e930; // 0x25f944 - g_ps2RecompiledFunctionTable[360016] = bhCheckWallEx_0x25e930; // 0x25f948 - g_ps2RecompiledFunctionTable[360017] = bhCheckWallEx_0x25e930; // 0x25f94c - g_ps2RecompiledFunctionTable[360018] = bhCheckWallEx_0x25e930; // 0x25f950 - g_ps2RecompiledFunctionTable[360019] = bhCheckWallEx_0x25e930; // 0x25f954 - g_ps2RecompiledFunctionTable[360020] = bhCheckWallEx_0x25e930; // 0x25f958 - g_ps2RecompiledFunctionTable[360021] = bhCheckWallEx_0x25e930; // 0x25f95c - g_ps2RecompiledFunctionTable[360022] = bhCheckWallEx_0x25e930; // 0x25f960 - g_ps2RecompiledFunctionTable[360023] = bhCheckWallEx_0x25e930; // 0x25f964 - g_ps2RecompiledFunctionTable[360024] = bhCheckWallEx_0x25e930; // 0x25f968 - g_ps2RecompiledFunctionTable[360025] = bhCheckWallEx_0x25e930; // 0x25f96c - g_ps2RecompiledFunctionTable[360026] = bhCheckWallEx_0x25e930; // 0x25f970 - g_ps2RecompiledFunctionTable[360027] = bhCheckWallEx_0x25e930; // 0x25f974 - g_ps2RecompiledFunctionTable[360028] = bhCheckWallEx_0x25e930; // 0x25f978 - g_ps2RecompiledFunctionTable[360029] = bhCheckWallEx_0x25e930; // 0x25f97c - g_ps2RecompiledFunctionTable[360030] = bhCheckWallEx_0x25e930; // 0x25f980 - g_ps2RecompiledFunctionTable[360031] = bhCheckWallEx_0x25e930; // 0x25f984 - g_ps2RecompiledFunctionTable[360032] = bhCheckWallEx_0x25e930; // 0x25f988 - g_ps2RecompiledFunctionTable[360033] = bhCheckWallEx_0x25e930; // 0x25f98c - g_ps2RecompiledFunctionTable[360034] = bhCheckWallEx_0x25e930; // 0x25f990 - g_ps2RecompiledFunctionTable[360035] = bhCheckWallEx_0x25e930; // 0x25f994 - g_ps2RecompiledFunctionTable[360036] = bhCheckWallEx_0x25e930; // 0x25f998 - g_ps2RecompiledFunctionTable[360037] = bhCheckWallEx_0x25e930; // 0x25f99c - g_ps2RecompiledFunctionTable[360038] = bhCheckWallEx_0x25e930; // 0x25f9a0 - g_ps2RecompiledFunctionTable[360039] = bhCheckWallEx_0x25e930; // 0x25f9a4 - g_ps2RecompiledFunctionTable[360040] = bhCheckWallEx_0x25e930; // 0x25f9a8 - g_ps2RecompiledFunctionTable[360041] = bhCheckWallEx_0x25e930; // 0x25f9ac - g_ps2RecompiledFunctionTable[360042] = bhCheckWallEx_0x25e930; // 0x25f9b0 - g_ps2RecompiledFunctionTable[360043] = bhCheckWallEx_0x25e930; // 0x25f9b4 - g_ps2RecompiledFunctionTable[360044] = bhCheckWallEx_0x25e930; // 0x25f9b8 - g_ps2RecompiledFunctionTable[360045] = bhCheckWallEx_0x25e930; // 0x25f9bc - g_ps2RecompiledFunctionTable[360046] = bhCheckWallEx_0x25e930; // 0x25f9c0 - g_ps2RecompiledFunctionTable[360047] = bhCheckWallEx_0x25e930; // 0x25f9c4 - g_ps2RecompiledFunctionTable[360048] = bhCheckWallEx_0x25e930; // 0x25f9c8 - g_ps2RecompiledFunctionTable[360049] = bhCheckWallEx_0x25e930; // 0x25f9cc - g_ps2RecompiledFunctionTable[360050] = bhCheckWallEx_0x25e930; // 0x25f9d0 - g_ps2RecompiledFunctionTable[360051] = bhCheckWallEx_0x25e930; // 0x25f9d4 - g_ps2RecompiledFunctionTable[360052] = bhCheckWallEx_0x25e930; // 0x25f9d8 - g_ps2RecompiledFunctionTable[360053] = bhCheckWallEx_0x25e930; // 0x25f9dc - g_ps2RecompiledFunctionTable[360054] = bhCheckWallEx_0x25e930; // 0x25f9e0 - g_ps2RecompiledFunctionTable[360055] = bhCheckWallEx_0x25e930; // 0x25f9e4 - g_ps2RecompiledFunctionTable[360056] = bhCheckWallEx_0x25e930; // 0x25f9e8 - g_ps2RecompiledFunctionTable[360057] = bhCheckWallEx_0x25e930; // 0x25f9ec - g_ps2RecompiledFunctionTable[360058] = bhCheckWallEx_0x25e930; // 0x25f9f0 - g_ps2RecompiledFunctionTable[360059] = bhCheckWallEx_0x25e930; // 0x25f9f4 - g_ps2RecompiledFunctionTable[360060] = bhCheckWallEx_0x25e930; // 0x25f9f8 - g_ps2RecompiledFunctionTable[360061] = bhCheckWallEx_0x25e930; // 0x25f9fc - g_ps2RecompiledFunctionTable[360062] = bhCheckWallEx_0x25e930; // 0x25fa00 - g_ps2RecompiledFunctionTable[360063] = bhCheckWallEx_0x25e930; // 0x25fa04 - g_ps2RecompiledFunctionTable[360064] = bhCheckWallEx_0x25e930; // 0x25fa08 - g_ps2RecompiledFunctionTable[360065] = bhCheckWallEx_0x25e930; // 0x25fa0c - g_ps2RecompiledFunctionTable[360066] = bhCheckWallEx_0x25e930; // 0x25fa10 - g_ps2RecompiledFunctionTable[360067] = bhCheckWallEx_0x25e930; // 0x25fa14 - g_ps2RecompiledFunctionTable[360068] = bhCheckWallEx_0x25e930; // 0x25fa18 - g_ps2RecompiledFunctionTable[360069] = bhCheckWallEx_0x25e930; // 0x25fa1c - g_ps2RecompiledFunctionTable[360070] = bhCheckWallEx_0x25e930; // 0x25fa20 - g_ps2RecompiledFunctionTable[360071] = bhCheckWallEx_0x25e930; // 0x25fa24 - g_ps2RecompiledFunctionTable[360072] = bhCheckWallEx_0x25e930; // 0x25fa28 - g_ps2RecompiledFunctionTable[360073] = bhCheckWallEx_0x25e930; // 0x25fa2c - g_ps2RecompiledFunctionTable[360074] = bhCheckWallEx_0x25e930; // 0x25fa30 - g_ps2RecompiledFunctionTable[360075] = bhCheckWallEx_0x25e930; // 0x25fa34 - g_ps2RecompiledFunctionTable[360076] = bhCheckWallEx_0x25e930; // 0x25fa38 - g_ps2RecompiledFunctionTable[360077] = bhCheckWallEx_0x25e930; // 0x25fa3c - g_ps2RecompiledFunctionTable[360078] = bhCheckWallEx_0x25e930; // 0x25fa40 - g_ps2RecompiledFunctionTable[360079] = bhCheckWallEx_0x25e930; // 0x25fa44 - g_ps2RecompiledFunctionTable[360080] = bhCheckWallEx_0x25e930; // 0x25fa48 - g_ps2RecompiledFunctionTable[360081] = bhCheckWallEx_0x25e930; // 0x25fa4c - g_ps2RecompiledFunctionTable[360082] = bhCheckWallEx_0x25e930; // 0x25fa50 - g_ps2RecompiledFunctionTable[360083] = bhCheckWallEx_0x25e930; // 0x25fa54 - g_ps2RecompiledFunctionTable[360084] = bhCheckWallEx_0x25e930; // 0x25fa58 - g_ps2RecompiledFunctionTable[360085] = bhCheckWallEx_0x25e930; // 0x25fa5c - g_ps2RecompiledFunctionTable[360086] = bhCheckWallEx_0x25e930; // 0x25fa60 - g_ps2RecompiledFunctionTable[360087] = bhCheckWallEx_0x25e930; // 0x25fa64 - g_ps2RecompiledFunctionTable[360088] = bhCheckWallEx_0x25e930; // 0x25fa68 - g_ps2RecompiledFunctionTable[360089] = bhCheckWallEx_0x25e930; // 0x25fa6c - g_ps2RecompiledFunctionTable[360090] = bhCheckWallEx_0x25e930; // 0x25fa70 - g_ps2RecompiledFunctionTable[360091] = bhCheckWallEx_0x25e930; // 0x25fa74 - g_ps2RecompiledFunctionTable[360092] = bhCheckWallEx_0x25e930; // 0x25fa78 - g_ps2RecompiledFunctionTable[360093] = bhCheckWallEx_0x25e930; // 0x25fa7c - g_ps2RecompiledFunctionTable[360094] = bhCheckWallEx_0x25e930; // 0x25fa80 - g_ps2RecompiledFunctionTable[360095] = bhCheckWallEx_0x25e930; // 0x25fa84 - g_ps2RecompiledFunctionTable[360096] = bhCheckWallEx_0x25e930; // 0x25fa88 - g_ps2RecompiledFunctionTable[360097] = bhCheckWallEx_0x25e930; // 0x25fa8c - g_ps2RecompiledFunctionTable[360098] = bhCheckWallEx_0x25e930; // 0x25fa90 - g_ps2RecompiledFunctionTable[360099] = bhCheckWallEx_0x25e930; // 0x25fa94 - g_ps2RecompiledFunctionTable[360100] = bhCheckWallEx_0x25e930; // 0x25fa98 - g_ps2RecompiledFunctionTable[360101] = bhCheckWallEx_0x25e930; // 0x25fa9c - g_ps2RecompiledFunctionTable[360102] = bhCheckWallEx_0x25e930; // 0x25faa0 - g_ps2RecompiledFunctionTable[360103] = bhCheckWallEx_0x25e930; // 0x25faa4 - g_ps2RecompiledFunctionTable[360104] = bhCheckWallEx_0x25e930; // 0x25faa8 - g_ps2RecompiledFunctionTable[360105] = bhCheckWallEx_0x25e930; // 0x25faac - g_ps2RecompiledFunctionTable[360106] = bhCheckWallEx_0x25e930; // 0x25fab0 - g_ps2RecompiledFunctionTable[360107] = bhCheckWallEx_0x25e930; // 0x25fab4 - g_ps2RecompiledFunctionTable[360108] = bhCheckWallEx_0x25e930; // 0x25fab8 - g_ps2RecompiledFunctionTable[360109] = bhCheckWallEx_0x25e930; // 0x25fabc - g_ps2RecompiledFunctionTable[360110] = bhCheckWallEx_0x25e930; // 0x25fac0 - g_ps2RecompiledFunctionTable[360111] = bhCheckWallEx_0x25e930; // 0x25fac4 - g_ps2RecompiledFunctionTable[360112] = bhCheckWallEx_0x25e930; // 0x25fac8 - g_ps2RecompiledFunctionTable[360113] = bhCheckWallEx_0x25e930; // 0x25facc - g_ps2RecompiledFunctionTable[360114] = bhCheckWallEx_0x25e930; // 0x25fad0 - g_ps2RecompiledFunctionTable[360115] = bhCheckWallEx_0x25e930; // 0x25fad4 - g_ps2RecompiledFunctionTable[360116] = bhCheckWallEx_0x25e930; // 0x25fad8 - g_ps2RecompiledFunctionTable[360117] = bhCheckWallEx_0x25e930; // 0x25fadc - g_ps2RecompiledFunctionTable[360118] = bhCheckWallEx_0x25e930; // 0x25fae0 - g_ps2RecompiledFunctionTable[360119] = bhCheckWallEx_0x25e930; // 0x25fae4 - g_ps2RecompiledFunctionTable[360120] = bhCheckWallEx_0x25e930; // 0x25fae8 - g_ps2RecompiledFunctionTable[360121] = bhCheckWallEx_0x25e930; // 0x25faec - g_ps2RecompiledFunctionTable[360122] = bhCheckWallEx_0x25e930; // 0x25faf0 - g_ps2RecompiledFunctionTable[360123] = bhCheckWallEx_0x25e930; // 0x25faf4 - g_ps2RecompiledFunctionTable[360124] = bhCheckWallEx_0x25e930; // 0x25faf8 - g_ps2RecompiledFunctionTable[360125] = bhCheckWallEx_0x25e930; // 0x25fafc - g_ps2RecompiledFunctionTable[360126] = bhCheckWallEx_0x25e930; // 0x25fb00 - g_ps2RecompiledFunctionTable[360127] = bhCheckWallEx_0x25e930; // 0x25fb04 - g_ps2RecompiledFunctionTable[360128] = bhCheckWallEx_0x25e930; // 0x25fb08 - g_ps2RecompiledFunctionTable[360129] = bhCheckWallEx_0x25e930; // 0x25fb0c - g_ps2RecompiledFunctionTable[360130] = bhCheckWallEx_0x25e930; // 0x25fb10 - g_ps2RecompiledFunctionTable[360131] = bhCheckWallEx_0x25e930; // 0x25fb14 - g_ps2RecompiledFunctionTable[360132] = bhCheckWallEx_0x25e930; // 0x25fb18 - g_ps2RecompiledFunctionTable[360133] = bhCheckWallEx_0x25e930; // 0x25fb1c - g_ps2RecompiledFunctionTable[360134] = bhCheckWallEx_0x25e930; // 0x25fb20 - g_ps2RecompiledFunctionTable[360135] = bhCheckWallEx_0x25e930; // 0x25fb24 - g_ps2RecompiledFunctionTable[360136] = bhCheckWallEx_0x25e930; // 0x25fb28 - g_ps2RecompiledFunctionTable[360137] = bhCheckWallEx_0x25e930; // 0x25fb2c - g_ps2RecompiledFunctionTable[360138] = bhCheckWallEx_0x25e930; // 0x25fb30 - g_ps2RecompiledFunctionTable[360139] = bhCheckWallEx_0x25e930; // 0x25fb34 - g_ps2RecompiledFunctionTable[360140] = bhCheckWallEx_0x25e930; // 0x25fb38 - g_ps2RecompiledFunctionTable[360141] = bhCheckWallEx_0x25e930; // 0x25fb3c - g_ps2RecompiledFunctionTable[360142] = bhCheckWallEx_0x25e930; // 0x25fb40 - g_ps2RecompiledFunctionTable[360143] = bhCheckWallEx_0x25e930; // 0x25fb44 - g_ps2RecompiledFunctionTable[360144] = bhCheckWallEx_0x25e930; // 0x25fb48 - g_ps2RecompiledFunctionTable[360145] = bhCheckWallEx_0x25e930; // 0x25fb4c - g_ps2RecompiledFunctionTable[360146] = bhCheckWallEx_0x25e930; // 0x25fb50 - g_ps2RecompiledFunctionTable[360147] = bhCheckWallEx_0x25e930; // 0x25fb54 - g_ps2RecompiledFunctionTable[360148] = bhCheckWallEx_0x25e930; // 0x25fb58 - g_ps2RecompiledFunctionTable[360149] = bhCheckWallEx_0x25e930; // 0x25fb5c - g_ps2RecompiledFunctionTable[360150] = bhCheckWallEx_0x25e930; // 0x25fb60 - g_ps2RecompiledFunctionTable[360151] = bhCheckWallEx_0x25e930; // 0x25fb64 - g_ps2RecompiledFunctionTable[360152] = bhCheckWallEx_0x25e930; // 0x25fb68 - g_ps2RecompiledFunctionTable[360153] = bhCheckWallEx_0x25e930; // 0x25fb6c - g_ps2RecompiledFunctionTable[360154] = bhCheckWallEx_0x25e930; // 0x25fb70 - g_ps2RecompiledFunctionTable[360155] = bhCheckWallEx_0x25e930; // 0x25fb74 - g_ps2RecompiledFunctionTable[360156] = bhCheckWallEx_0x25e930; // 0x25fb78 - g_ps2RecompiledFunctionTable[360157] = bhCheckWallEx_0x25e930; // 0x25fb7c - g_ps2RecompiledFunctionTable[360158] = bhCheckWallEx_0x25e930; // 0x25fb80 - g_ps2RecompiledFunctionTable[360159] = bhCheckWallEx_0x25e930; // 0x25fb84 - g_ps2RecompiledFunctionTable[360160] = bhCheckWallEx_0x25e930; // 0x25fb88 - g_ps2RecompiledFunctionTable[360161] = bhCheckWallEx_0x25e930; // 0x25fb8c - g_ps2RecompiledFunctionTable[360162] = bhCheckWallEx_0x25e930; // 0x25fb90 - g_ps2RecompiledFunctionTable[360163] = bhCheckWallEx_0x25e930; // 0x25fb94 - g_ps2RecompiledFunctionTable[360164] = bhCheckWallEx_0x25e930; // 0x25fb98 - g_ps2RecompiledFunctionTable[360165] = bhCheckWallEx_0x25e930; // 0x25fb9c - g_ps2RecompiledFunctionTable[360166] = bhCheckWallEx_0x25e930; // 0x25fba0 - g_ps2RecompiledFunctionTable[360167] = bhCheckWallEx_0x25e930; // 0x25fba4 - g_ps2RecompiledFunctionTable[360168] = bhCheckWallEx_0x25e930; // 0x25fba8 - g_ps2RecompiledFunctionTable[360169] = bhCheckWallEx_0x25e930; // 0x25fbac - g_ps2RecompiledFunctionTable[360170] = bhCheckWallEx_0x25e930; // 0x25fbb0 - g_ps2RecompiledFunctionTable[360171] = bhCheckWallEx_0x25e930; // 0x25fbb4 - g_ps2RecompiledFunctionTable[360172] = bhCheckWallEx_0x25e930; // 0x25fbb8 - g_ps2RecompiledFunctionTable[360173] = bhCheckWallEx_0x25e930; // 0x25fbbc - g_ps2RecompiledFunctionTable[360174] = bhCheckWallEx_0x25e930; // 0x25fbc0 - g_ps2RecompiledFunctionTable[360175] = bhCheckWallEx_0x25e930; // 0x25fbc4 - g_ps2RecompiledFunctionTable[360176] = bhCheckWallEx_0x25e930; // 0x25fbc8 - g_ps2RecompiledFunctionTable[360177] = bhCheckWallEx_0x25e930; // 0x25fbcc - g_ps2RecompiledFunctionTable[360178] = bhCheckWallEx_0x25e930; // 0x25fbd0 - g_ps2RecompiledFunctionTable[360179] = bhCheckWallEx_0x25e930; // 0x25fbd4 - g_ps2RecompiledFunctionTable[360180] = bhCheckWallEx_0x25e930; // 0x25fbd8 - g_ps2RecompiledFunctionTable[360181] = bhCheckWallEx_0x25e930; // 0x25fbdc - g_ps2RecompiledFunctionTable[360182] = bhCheckWallEx_0x25e930; // 0x25fbe0 - g_ps2RecompiledFunctionTable[360183] = bhCheckWallEx_0x25e930; // 0x25fbe4 - g_ps2RecompiledFunctionTable[360184] = bhCheckWallEx_0x25e930; // 0x25fbe8 - g_ps2RecompiledFunctionTable[360186] = bhCheckWall2Box_0x25fbf0; // 0x25fbf0 - g_ps2RecompiledFunctionTable[360187] = bhCheckWall2Box_0x25fbf0; // 0x25fbf4 - g_ps2RecompiledFunctionTable[360188] = bhCheckWall2Box_0x25fbf0; // 0x25fbf8 - g_ps2RecompiledFunctionTable[360189] = bhCheckWall2Box_0x25fbf0; // 0x25fbfc - g_ps2RecompiledFunctionTable[360190] = bhCheckWall2Box_0x25fbf0; // 0x25fc00 - g_ps2RecompiledFunctionTable[360191] = bhCheckWall2Box_0x25fbf0; // 0x25fc04 - g_ps2RecompiledFunctionTable[360192] = bhCheckWall2Box_0x25fbf0; // 0x25fc08 - g_ps2RecompiledFunctionTable[360193] = bhCheckWall2Box_0x25fbf0; // 0x25fc0c - g_ps2RecompiledFunctionTable[360194] = bhCheckWall2Box_0x25fbf0; // 0x25fc10 - g_ps2RecompiledFunctionTable[360195] = bhCheckWall2Box_0x25fbf0; // 0x25fc14 - g_ps2RecompiledFunctionTable[360196] = bhCheckWall2Box_0x25fbf0; // 0x25fc18 - g_ps2RecompiledFunctionTable[360197] = bhCheckWall2Box_0x25fbf0; // 0x25fc1c - g_ps2RecompiledFunctionTable[360198] = bhCheckWall2Box_0x25fbf0; // 0x25fc20 - g_ps2RecompiledFunctionTable[360199] = bhCheckWall2Box_0x25fbf0; // 0x25fc24 - g_ps2RecompiledFunctionTable[360200] = bhCheckWall2Box_0x25fbf0; // 0x25fc28 - g_ps2RecompiledFunctionTable[360201] = bhCheckWall2Box_0x25fbf0; // 0x25fc2c - g_ps2RecompiledFunctionTable[360202] = bhCheckWall2Box_0x25fbf0; // 0x25fc30 - g_ps2RecompiledFunctionTable[360203] = bhCheckWall2Box_0x25fbf0; // 0x25fc34 - g_ps2RecompiledFunctionTable[360204] = bhCheckWall2Box_0x25fbf0; // 0x25fc38 - g_ps2RecompiledFunctionTable[360205] = bhCheckWall2Box_0x25fbf0; // 0x25fc3c - g_ps2RecompiledFunctionTable[360206] = bhCheckWall2Box_0x25fbf0; // 0x25fc40 - g_ps2RecompiledFunctionTable[360207] = bhCheckWall2Box_0x25fbf0; // 0x25fc44 - g_ps2RecompiledFunctionTable[360208] = bhCheckWall2Box_0x25fbf0; // 0x25fc48 - g_ps2RecompiledFunctionTable[360209] = bhCheckWall2Box_0x25fbf0; // 0x25fc4c - g_ps2RecompiledFunctionTable[360210] = bhCheckWall2Box_0x25fbf0; // 0x25fc50 - g_ps2RecompiledFunctionTable[360211] = bhCheckWall2Box_0x25fbf0; // 0x25fc54 - g_ps2RecompiledFunctionTable[360212] = bhCheckWall2Box_0x25fbf0; // 0x25fc58 - g_ps2RecompiledFunctionTable[360213] = bhCheckWall2Box_0x25fbf0; // 0x25fc5c - g_ps2RecompiledFunctionTable[360214] = bhCheckWall2Box_0x25fbf0; // 0x25fc60 - g_ps2RecompiledFunctionTable[360215] = bhCheckWall2Box_0x25fbf0; // 0x25fc64 - g_ps2RecompiledFunctionTable[360216] = bhCheckWall2Box_0x25fbf0; // 0x25fc68 - g_ps2RecompiledFunctionTable[360217] = bhCheckWall2Box_0x25fbf0; // 0x25fc6c - g_ps2RecompiledFunctionTable[360218] = bhCheckWall2Box_0x25fbf0; // 0x25fc70 - g_ps2RecompiledFunctionTable[360219] = bhCheckWall2Box_0x25fbf0; // 0x25fc74 - g_ps2RecompiledFunctionTable[360220] = bhCheckWall2Box_0x25fbf0; // 0x25fc78 - g_ps2RecompiledFunctionTable[360221] = bhCheckWall2Box_0x25fbf0; // 0x25fc7c - g_ps2RecompiledFunctionTable[360222] = bhCheckWall2Box_0x25fbf0; // 0x25fc80 - g_ps2RecompiledFunctionTable[360223] = bhCheckWall2Box_0x25fbf0; // 0x25fc84 - g_ps2RecompiledFunctionTable[360224] = bhCheckWall2Box_0x25fbf0; // 0x25fc88 - g_ps2RecompiledFunctionTable[360225] = bhCheckWall2Box_0x25fbf0; // 0x25fc8c - g_ps2RecompiledFunctionTable[360226] = bhCheckWall2Box_0x25fbf0; // 0x25fc90 - g_ps2RecompiledFunctionTable[360227] = bhCheckWall2Box_0x25fbf0; // 0x25fc94 - g_ps2RecompiledFunctionTable[360228] = bhCheckWall2Box_0x25fbf0; // 0x25fc98 - g_ps2RecompiledFunctionTable[360229] = bhCheckWall2Box_0x25fbf0; // 0x25fc9c - g_ps2RecompiledFunctionTable[360230] = bhCheckWall2Box_0x25fbf0; // 0x25fca0 - g_ps2RecompiledFunctionTable[360231] = bhCheckWall2Box_0x25fbf0; // 0x25fca4 - g_ps2RecompiledFunctionTable[360232] = bhCheckWall2Box_0x25fbf0; // 0x25fca8 - g_ps2RecompiledFunctionTable[360233] = bhCheckWall2Box_0x25fbf0; // 0x25fcac - g_ps2RecompiledFunctionTable[360234] = bhCheckWall2Box_0x25fbf0; // 0x25fcb0 - g_ps2RecompiledFunctionTable[360235] = bhCheckWall2Box_0x25fbf0; // 0x25fcb4 - g_ps2RecompiledFunctionTable[360236] = bhCheckWall2Box_0x25fbf0; // 0x25fcb8 - g_ps2RecompiledFunctionTable[360237] = bhCheckWall2Box_0x25fbf0; // 0x25fcbc - g_ps2RecompiledFunctionTable[360238] = bhCheckWall2Box_0x25fbf0; // 0x25fcc0 - g_ps2RecompiledFunctionTable[360239] = bhCheckWall2Box_0x25fbf0; // 0x25fcc4 - g_ps2RecompiledFunctionTable[360240] = bhCheckWall2Box_0x25fbf0; // 0x25fcc8 - g_ps2RecompiledFunctionTable[360241] = bhCheckWall2Box_0x25fbf0; // 0x25fccc - g_ps2RecompiledFunctionTable[360242] = bhCheckWall2Box_0x25fbf0; // 0x25fcd0 - g_ps2RecompiledFunctionTable[360243] = bhCheckWall2Box_0x25fbf0; // 0x25fcd4 - g_ps2RecompiledFunctionTable[360244] = bhCheckWall2Box_0x25fbf0; // 0x25fcd8 - g_ps2RecompiledFunctionTable[360245] = bhCheckWall2Box_0x25fbf0; // 0x25fcdc - g_ps2RecompiledFunctionTable[360246] = bhCheckWall2Box_0x25fbf0; // 0x25fce0 - g_ps2RecompiledFunctionTable[360247] = bhCheckWall2Box_0x25fbf0; // 0x25fce4 - g_ps2RecompiledFunctionTable[360248] = bhCheckWall2Box_0x25fbf0; // 0x25fce8 - g_ps2RecompiledFunctionTable[360249] = bhCheckWall2Box_0x25fbf0; // 0x25fcec - g_ps2RecompiledFunctionTable[360250] = bhCheckWall2Box_0x25fbf0; // 0x25fcf0 - g_ps2RecompiledFunctionTable[360251] = bhCheckWall2Box_0x25fbf0; // 0x25fcf4 - g_ps2RecompiledFunctionTable[360252] = bhCheckWall2Box_0x25fbf0; // 0x25fcf8 - g_ps2RecompiledFunctionTable[360253] = bhCheckWall2Box_0x25fbf0; // 0x25fcfc - g_ps2RecompiledFunctionTable[360254] = bhCheckWall2Box_0x25fbf0; // 0x25fd00 - g_ps2RecompiledFunctionTable[360255] = bhCheckWall2Box_0x25fbf0; // 0x25fd04 - g_ps2RecompiledFunctionTable[360256] = bhCheckWall2Box_0x25fbf0; // 0x25fd08 - g_ps2RecompiledFunctionTable[360257] = bhCheckWall2Box_0x25fbf0; // 0x25fd0c - g_ps2RecompiledFunctionTable[360258] = bhCheckWall2Box_0x25fbf0; // 0x25fd10 - g_ps2RecompiledFunctionTable[360259] = bhCheckWall2Box_0x25fbf0; // 0x25fd14 - g_ps2RecompiledFunctionTable[360260] = bhCheckWall2Box_0x25fbf0; // 0x25fd18 - g_ps2RecompiledFunctionTable[360261] = bhCheckWall2Box_0x25fbf0; // 0x25fd1c - g_ps2RecompiledFunctionTable[360262] = bhCheckWall2Box_0x25fbf0; // 0x25fd20 - g_ps2RecompiledFunctionTable[360263] = bhCheckWall2Box_0x25fbf0; // 0x25fd24 - g_ps2RecompiledFunctionTable[360264] = bhCheckWall2Box_0x25fbf0; // 0x25fd28 - g_ps2RecompiledFunctionTable[360265] = bhCheckWall2Box_0x25fbf0; // 0x25fd2c - g_ps2RecompiledFunctionTable[360266] = bhCheckWall2Box_0x25fbf0; // 0x25fd30 - g_ps2RecompiledFunctionTable[360267] = bhCheckWall2Box_0x25fbf0; // 0x25fd34 - g_ps2RecompiledFunctionTable[360268] = bhCheckWall2Box_0x25fbf0; // 0x25fd38 - g_ps2RecompiledFunctionTable[360269] = bhCheckWall2Box_0x25fbf0; // 0x25fd3c - g_ps2RecompiledFunctionTable[360270] = bhCheckWall2Box_0x25fbf0; // 0x25fd40 - g_ps2RecompiledFunctionTable[360271] = bhCheckWall2Box_0x25fbf0; // 0x25fd44 - g_ps2RecompiledFunctionTable[360272] = bhCheckWall2Box_0x25fbf0; // 0x25fd48 - g_ps2RecompiledFunctionTable[360273] = bhCheckWall2Box_0x25fbf0; // 0x25fd4c - g_ps2RecompiledFunctionTable[360274] = bhCheckWall2Box_0x25fbf0; // 0x25fd50 - g_ps2RecompiledFunctionTable[360275] = bhCheckWall2Box_0x25fbf0; // 0x25fd54 - g_ps2RecompiledFunctionTable[360276] = bhCheckWall2Box_0x25fbf0; // 0x25fd58 - g_ps2RecompiledFunctionTable[360277] = bhCheckWall2Box_0x25fbf0; // 0x25fd5c - g_ps2RecompiledFunctionTable[360278] = bhCheckWall2Box_0x25fbf0; // 0x25fd60 - g_ps2RecompiledFunctionTable[360279] = bhCheckWall2Box_0x25fbf0; // 0x25fd64 - g_ps2RecompiledFunctionTable[360280] = bhCheckWall2Box_0x25fbf0; // 0x25fd68 - g_ps2RecompiledFunctionTable[360281] = bhCheckWall2Box_0x25fbf0; // 0x25fd6c - g_ps2RecompiledFunctionTable[360282] = bhCheckWall2Box_0x25fbf0; // 0x25fd70 - g_ps2RecompiledFunctionTable[360283] = bhCheckWall2Box_0x25fbf0; // 0x25fd74 - g_ps2RecompiledFunctionTable[360284] = bhCheckWall2Box_0x25fbf0; // 0x25fd78 - g_ps2RecompiledFunctionTable[360285] = bhCheckWall2Box_0x25fbf0; // 0x25fd7c - g_ps2RecompiledFunctionTable[360286] = bhCheckWall2Box_0x25fbf0; // 0x25fd80 - g_ps2RecompiledFunctionTable[360287] = bhCheckWall2Box_0x25fbf0; // 0x25fd84 - g_ps2RecompiledFunctionTable[360288] = bhCheckWall2Box_0x25fbf0; // 0x25fd88 - g_ps2RecompiledFunctionTable[360289] = bhCheckWall2Box_0x25fbf0; // 0x25fd8c - g_ps2RecompiledFunctionTable[360290] = bhCheckWall2Box_0x25fbf0; // 0x25fd90 - g_ps2RecompiledFunctionTable[360291] = bhCheckWall2Box_0x25fbf0; // 0x25fd94 - g_ps2RecompiledFunctionTable[360292] = bhCheckWall2Box_0x25fbf0; // 0x25fd98 - g_ps2RecompiledFunctionTable[360293] = bhCheckWall2Box_0x25fbf0; // 0x25fd9c - g_ps2RecompiledFunctionTable[360294] = bhCheckWall2Box_0x25fbf0; // 0x25fda0 - g_ps2RecompiledFunctionTable[360295] = bhCheckWall2Box_0x25fbf0; // 0x25fda4 - g_ps2RecompiledFunctionTable[360296] = bhCheckWall2Box_0x25fbf0; // 0x25fda8 - g_ps2RecompiledFunctionTable[360297] = bhCheckWall2Box_0x25fbf0; // 0x25fdac - g_ps2RecompiledFunctionTable[360298] = bhCheckWall2Box_0x25fbf0; // 0x25fdb0 - g_ps2RecompiledFunctionTable[360299] = bhCheckWall2Box_0x25fbf0; // 0x25fdb4 - g_ps2RecompiledFunctionTable[360300] = bhCheckWall2Box_0x25fbf0; // 0x25fdb8 - g_ps2RecompiledFunctionTable[360301] = bhCheckWall2Box_0x25fbf0; // 0x25fdbc - g_ps2RecompiledFunctionTable[360302] = bhCheckWall2Box_0x25fbf0; // 0x25fdc0 - g_ps2RecompiledFunctionTable[360303] = bhCheckWall2Box_0x25fbf0; // 0x25fdc4 - g_ps2RecompiledFunctionTable[360304] = bhCheckWall2Box_0x25fbf0; // 0x25fdc8 - g_ps2RecompiledFunctionTable[360305] = bhCheckWall2Box_0x25fbf0; // 0x25fdcc - g_ps2RecompiledFunctionTable[360306] = bhCheckWall2Box_0x25fbf0; // 0x25fdd0 - g_ps2RecompiledFunctionTable[360307] = bhCheckWall2Box_0x25fbf0; // 0x25fdd4 - g_ps2RecompiledFunctionTable[360308] = bhCheckWall2Box_0x25fbf0; // 0x25fdd8 - g_ps2RecompiledFunctionTable[360309] = bhCheckWall2Box_0x25fbf0; // 0x25fddc - g_ps2RecompiledFunctionTable[360310] = bhCheckWall2Box_0x25fbf0; // 0x25fde0 - g_ps2RecompiledFunctionTable[360311] = bhCheckWall2Box_0x25fbf0; // 0x25fde4 - g_ps2RecompiledFunctionTable[360312] = bhCheckWall2Box_0x25fbf0; // 0x25fde8 - g_ps2RecompiledFunctionTable[360313] = bhCheckWall2Box_0x25fbf0; // 0x25fdec - g_ps2RecompiledFunctionTable[360314] = bhCheckWall2Box_0x25fbf0; // 0x25fdf0 - g_ps2RecompiledFunctionTable[360315] = bhCheckWall2Box_0x25fbf0; // 0x25fdf4 - g_ps2RecompiledFunctionTable[360316] = bhCheckWall2Box_0x25fbf0; // 0x25fdf8 - g_ps2RecompiledFunctionTable[360317] = bhCheckWall2Box_0x25fbf0; // 0x25fdfc - g_ps2RecompiledFunctionTable[360318] = bhCheckWall2Box_0x25fbf0; // 0x25fe00 - g_ps2RecompiledFunctionTable[360319] = bhCheckWall2Box_0x25fbf0; // 0x25fe04 - g_ps2RecompiledFunctionTable[360320] = bhCheckWall2Box_0x25fbf0; // 0x25fe08 - g_ps2RecompiledFunctionTable[360321] = bhCheckWall2Box_0x25fbf0; // 0x25fe0c - g_ps2RecompiledFunctionTable[360322] = bhCheckWall2Box_0x25fbf0; // 0x25fe10 - g_ps2RecompiledFunctionTable[360323] = bhCheckWall2Box_0x25fbf0; // 0x25fe14 - g_ps2RecompiledFunctionTable[360324] = bhCheckWall2Box_0x25fbf0; // 0x25fe18 - g_ps2RecompiledFunctionTable[360325] = bhCheckWall2Box_0x25fbf0; // 0x25fe1c - g_ps2RecompiledFunctionTable[360326] = bhCheckWall2Box_0x25fbf0; // 0x25fe20 - g_ps2RecompiledFunctionTable[360327] = bhCheckWall2Box_0x25fbf0; // 0x25fe24 - g_ps2RecompiledFunctionTable[360328] = bhCheckWall2Box_0x25fbf0; // 0x25fe28 - g_ps2RecompiledFunctionTable[360329] = bhCheckWall2Box_0x25fbf0; // 0x25fe2c - g_ps2RecompiledFunctionTable[360330] = bhCheckWall2Box_0x25fbf0; // 0x25fe30 - g_ps2RecompiledFunctionTable[360331] = bhCheckWall2Box_0x25fbf0; // 0x25fe34 - g_ps2RecompiledFunctionTable[360332] = bhCheckWall2Box_0x25fbf0; // 0x25fe38 - g_ps2RecompiledFunctionTable[360333] = bhCheckWall2Box_0x25fbf0; // 0x25fe3c - g_ps2RecompiledFunctionTable[360334] = bhCheckWall2Box_0x25fbf0; // 0x25fe40 - g_ps2RecompiledFunctionTable[360335] = bhCheckWall2Box_0x25fbf0; // 0x25fe44 - g_ps2RecompiledFunctionTable[360336] = bhCheckWall2Box_0x25fbf0; // 0x25fe48 - g_ps2RecompiledFunctionTable[360337] = bhCheckWall2Box_0x25fbf0; // 0x25fe4c - g_ps2RecompiledFunctionTable[360338] = bhCheckWall2Box_0x25fbf0; // 0x25fe50 - g_ps2RecompiledFunctionTable[360339] = bhCheckWall2Box_0x25fbf0; // 0x25fe54 - g_ps2RecompiledFunctionTable[360340] = bhCheckWall2Box_0x25fbf0; // 0x25fe58 - g_ps2RecompiledFunctionTable[360341] = bhCheckWall2Box_0x25fbf0; // 0x25fe5c - g_ps2RecompiledFunctionTable[360342] = bhCheckWall2Box_0x25fbf0; // 0x25fe60 - g_ps2RecompiledFunctionTable[360343] = bhCheckWall2Box_0x25fbf0; // 0x25fe64 - g_ps2RecompiledFunctionTable[360344] = bhCheckWall2Box_0x25fbf0; // 0x25fe68 - g_ps2RecompiledFunctionTable[360345] = bhCheckWall2Box_0x25fbf0; // 0x25fe6c - g_ps2RecompiledFunctionTable[360346] = bhCheckWall2Box_0x25fbf0; // 0x25fe70 - g_ps2RecompiledFunctionTable[360347] = bhCheckWall2Box_0x25fbf0; // 0x25fe74 - g_ps2RecompiledFunctionTable[360348] = bhCheckWall2Box_0x25fbf0; // 0x25fe78 - g_ps2RecompiledFunctionTable[360349] = bhCheckWall2Box_0x25fbf0; // 0x25fe7c - g_ps2RecompiledFunctionTable[360350] = bhCheckWall2Box_0x25fbf0; // 0x25fe80 - g_ps2RecompiledFunctionTable[360351] = bhCheckWall2Box_0x25fbf0; // 0x25fe84 - g_ps2RecompiledFunctionTable[360352] = bhCheckWall2Box_0x25fbf0; // 0x25fe88 - g_ps2RecompiledFunctionTable[360353] = bhCheckWall2Box_0x25fbf0; // 0x25fe8c - g_ps2RecompiledFunctionTable[360354] = bhCheckWall2Box_0x25fbf0; // 0x25fe90 - g_ps2RecompiledFunctionTable[360355] = bhCheckWall2Box_0x25fbf0; // 0x25fe94 - g_ps2RecompiledFunctionTable[360356] = bhCheckWall2Box_0x25fbf0; // 0x25fe98 - g_ps2RecompiledFunctionTable[360357] = bhCheckWall2Box_0x25fbf0; // 0x25fe9c - g_ps2RecompiledFunctionTable[360358] = bhCheckWall2Box_0x25fbf0; // 0x25fea0 - g_ps2RecompiledFunctionTable[360359] = bhCheckWall2Box_0x25fbf0; // 0x25fea4 - g_ps2RecompiledFunctionTable[360360] = bhCheckWall2Box_0x25fbf0; // 0x25fea8 - g_ps2RecompiledFunctionTable[360361] = bhCheckWall2Box_0x25fbf0; // 0x25feac - g_ps2RecompiledFunctionTable[360362] = bhCheckWall2Box_0x25fbf0; // 0x25feb0 - g_ps2RecompiledFunctionTable[360363] = bhCheckWall2Box_0x25fbf0; // 0x25feb4 - g_ps2RecompiledFunctionTable[360364] = bhCheckWall2Box_0x25fbf0; // 0x25feb8 - g_ps2RecompiledFunctionTable[360365] = bhCheckWall2Box_0x25fbf0; // 0x25febc - g_ps2RecompiledFunctionTable[360366] = bhCheckWall2Box_0x25fbf0; // 0x25fec0 - g_ps2RecompiledFunctionTable[360367] = bhCheckWall2Box_0x25fbf0; // 0x25fec4 - g_ps2RecompiledFunctionTable[360368] = bhCheckWall2Box_0x25fbf0; // 0x25fec8 - g_ps2RecompiledFunctionTable[360369] = bhCheckWall2Box_0x25fbf0; // 0x25fecc - g_ps2RecompiledFunctionTable[360370] = bhCheckWall2Box_0x25fbf0; // 0x25fed0 - g_ps2RecompiledFunctionTable[360371] = bhCheckWall2Box_0x25fbf0; // 0x25fed4 - g_ps2RecompiledFunctionTable[360372] = bhCheckWall2Box_0x25fbf0; // 0x25fed8 - g_ps2RecompiledFunctionTable[360373] = bhCheckWall2Box_0x25fbf0; // 0x25fedc - g_ps2RecompiledFunctionTable[360374] = bhCheckWall2Box_0x25fbf0; // 0x25fee0 - g_ps2RecompiledFunctionTable[360375] = bhCheckWall2Box_0x25fbf0; // 0x25fee4 - g_ps2RecompiledFunctionTable[360376] = bhCheckWall2Box_0x25fbf0; // 0x25fee8 - g_ps2RecompiledFunctionTable[360377] = bhCheckWall2Box_0x25fbf0; // 0x25feec - g_ps2RecompiledFunctionTable[360378] = bhCheckWall2Box_0x25fbf0; // 0x25fef0 - g_ps2RecompiledFunctionTable[360379] = bhCheckWall2Box_0x25fbf0; // 0x25fef4 - g_ps2RecompiledFunctionTable[360380] = bhCheckWall2Box_0x25fbf0; // 0x25fef8 - g_ps2RecompiledFunctionTable[360381] = bhCheckWall2Box_0x25fbf0; // 0x25fefc - g_ps2RecompiledFunctionTable[360382] = bhCheckWall2Box_0x25fbf0; // 0x25ff00 - g_ps2RecompiledFunctionTable[360383] = bhCheckWall2Box_0x25fbf0; // 0x25ff04 - g_ps2RecompiledFunctionTable[360384] = bhCheckWall2Box_0x25fbf0; // 0x25ff08 - g_ps2RecompiledFunctionTable[360385] = bhCheckWall2Box_0x25fbf0; // 0x25ff0c - g_ps2RecompiledFunctionTable[360386] = bhCheckWall2Box_0x25fbf0; // 0x25ff10 - g_ps2RecompiledFunctionTable[360387] = bhCheckWall2Box_0x25fbf0; // 0x25ff14 - g_ps2RecompiledFunctionTable[360388] = bhCheckWall2Box_0x25fbf0; // 0x25ff18 - g_ps2RecompiledFunctionTable[360389] = bhCheckWall2Box_0x25fbf0; // 0x25ff1c - g_ps2RecompiledFunctionTable[360390] = bhCheckWall2Box_0x25fbf0; // 0x25ff20 - g_ps2RecompiledFunctionTable[360391] = bhCheckWall2Box_0x25fbf0; // 0x25ff24 - g_ps2RecompiledFunctionTable[360392] = bhCheckWall2Box_0x25fbf0; // 0x25ff28 - g_ps2RecompiledFunctionTable[360393] = bhCheckWall2Box_0x25fbf0; // 0x25ff2c - g_ps2RecompiledFunctionTable[360394] = bhCheckWall2Box_0x25fbf0; // 0x25ff30 - g_ps2RecompiledFunctionTable[360395] = bhCheckWall2Box_0x25fbf0; // 0x25ff34 - g_ps2RecompiledFunctionTable[360396] = bhCheckWall2Box_0x25fbf0; // 0x25ff38 - g_ps2RecompiledFunctionTable[360397] = bhCheckWall2Box_0x25fbf0; // 0x25ff3c - g_ps2RecompiledFunctionTable[360398] = bhCheckWall2Box_0x25fbf0; // 0x25ff40 - g_ps2RecompiledFunctionTable[360399] = bhCheckWall2Box_0x25fbf0; // 0x25ff44 - g_ps2RecompiledFunctionTable[360400] = bhCheckWall2Box_0x25fbf0; // 0x25ff48 - g_ps2RecompiledFunctionTable[360401] = bhCheckWall2Box_0x25fbf0; // 0x25ff4c - g_ps2RecompiledFunctionTable[360402] = bhCheckWall2Box_0x25fbf0; // 0x25ff50 - g_ps2RecompiledFunctionTable[360403] = bhCheckWall2Box_0x25fbf0; // 0x25ff54 - g_ps2RecompiledFunctionTable[360404] = bhCheckWall2Box_0x25fbf0; // 0x25ff58 - g_ps2RecompiledFunctionTable[360405] = bhCheckWall2Box_0x25fbf0; // 0x25ff5c - g_ps2RecompiledFunctionTable[360406] = bhCheckWall2Box_0x25fbf0; // 0x25ff60 - g_ps2RecompiledFunctionTable[360407] = bhCheckWall2Box_0x25fbf0; // 0x25ff64 - g_ps2RecompiledFunctionTable[360408] = bhCheckWall2Box_0x25fbf0; // 0x25ff68 - g_ps2RecompiledFunctionTable[360409] = bhCheckWall2Box_0x25fbf0; // 0x25ff6c - g_ps2RecompiledFunctionTable[360410] = bhCheckWall2Box_0x25fbf0; // 0x25ff70 - g_ps2RecompiledFunctionTable[360411] = bhCheckWall2Box_0x25fbf0; // 0x25ff74 - g_ps2RecompiledFunctionTable[360412] = bhCheckWall2Box_0x25fbf0; // 0x25ff78 - g_ps2RecompiledFunctionTable[360413] = bhCheckWall2Box_0x25fbf0; // 0x25ff7c - g_ps2RecompiledFunctionTable[360414] = bhCheckWall2Box_0x25fbf0; // 0x25ff80 - g_ps2RecompiledFunctionTable[360415] = bhCheckWall2Box_0x25fbf0; // 0x25ff84 - g_ps2RecompiledFunctionTable[360416] = bhCheckWall2Box_0x25fbf0; // 0x25ff88 - g_ps2RecompiledFunctionTable[360417] = bhCheckWall2Box_0x25fbf0; // 0x25ff8c - g_ps2RecompiledFunctionTable[360418] = bhCheckWall2Box_0x25fbf0; // 0x25ff90 - g_ps2RecompiledFunctionTable[360419] = bhCheckWall2Box_0x25fbf0; // 0x25ff94 - g_ps2RecompiledFunctionTable[360420] = bhCheckWall2Box_0x25fbf0; // 0x25ff98 - g_ps2RecompiledFunctionTable[360421] = bhCheckWall2Box_0x25fbf0; // 0x25ff9c - g_ps2RecompiledFunctionTable[360422] = bhCheckWall2Box_0x25fbf0; // 0x25ffa0 - g_ps2RecompiledFunctionTable[360423] = bhCheckWall2Box_0x25fbf0; // 0x25ffa4 - g_ps2RecompiledFunctionTable[360424] = bhCheckWall2Box_0x25fbf0; // 0x25ffa8 - g_ps2RecompiledFunctionTable[360425] = bhCheckWall2Box_0x25fbf0; // 0x25ffac - g_ps2RecompiledFunctionTable[360426] = bhCheckWall2Box_0x25fbf0; // 0x25ffb0 - g_ps2RecompiledFunctionTable[360427] = bhCheckWall2Box_0x25fbf0; // 0x25ffb4 - g_ps2RecompiledFunctionTable[360428] = bhCheckWall2Box_0x25fbf0; // 0x25ffb8 - g_ps2RecompiledFunctionTable[360429] = bhCheckWall2Box_0x25fbf0; // 0x25ffbc - g_ps2RecompiledFunctionTable[360430] = bhCheckWall2Box_0x25fbf0; // 0x25ffc0 - g_ps2RecompiledFunctionTable[360431] = bhCheckWall2Box_0x25fbf0; // 0x25ffc4 - g_ps2RecompiledFunctionTable[360432] = bhCheckWall2Box_0x25fbf0; // 0x25ffc8 - g_ps2RecompiledFunctionTable[360433] = bhCheckWall2Box_0x25fbf0; // 0x25ffcc - g_ps2RecompiledFunctionTable[360434] = bhCheckWall2Box_0x25fbf0; // 0x25ffd0 - g_ps2RecompiledFunctionTable[360435] = bhCheckWall2Box_0x25fbf0; // 0x25ffd4 - g_ps2RecompiledFunctionTable[360436] = bhCheckWall2Box_0x25fbf0; // 0x25ffd8 - g_ps2RecompiledFunctionTable[360437] = bhCheckWall2Box_0x25fbf0; // 0x25ffdc - g_ps2RecompiledFunctionTable[360438] = bhCheckWall2Box_0x25fbf0; // 0x25ffe0 - g_ps2RecompiledFunctionTable[360439] = bhCheckWall2Box_0x25fbf0; // 0x25ffe4 - g_ps2RecompiledFunctionTable[360440] = bhCheckWall2Box_0x25fbf0; // 0x25ffe8 - g_ps2RecompiledFunctionTable[360441] = bhCheckWall2Box_0x25fbf0; // 0x25ffec - g_ps2RecompiledFunctionTable[360442] = bhCheckWall2Box_0x25fbf0; // 0x25fff0 - g_ps2RecompiledFunctionTable[360443] = bhCheckWall2Box_0x25fbf0; // 0x25fff4 - g_ps2RecompiledFunctionTable[360444] = bhCheckWall2Box_0x25fbf0; // 0x25fff8 - g_ps2RecompiledFunctionTable[360445] = bhCheckWall2Box_0x25fbf0; // 0x25fffc - g_ps2RecompiledFunctionTable[360446] = bhCheckWall2Box_0x25fbf0; // 0x260000 - g_ps2RecompiledFunctionTable[360447] = bhCheckWall2Box_0x25fbf0; // 0x260004 - g_ps2RecompiledFunctionTable[360448] = bhCheckWall2Box_0x25fbf0; // 0x260008 - g_ps2RecompiledFunctionTable[360449] = bhCheckWall2Box_0x25fbf0; // 0x26000c - g_ps2RecompiledFunctionTable[360450] = bhCheckWall2Box_0x25fbf0; // 0x260010 - g_ps2RecompiledFunctionTable[360451] = bhCheckWall2Box_0x25fbf0; // 0x260014 - g_ps2RecompiledFunctionTable[360452] = bhCheckWall2Box_0x25fbf0; // 0x260018 - g_ps2RecompiledFunctionTable[360453] = bhCheckWall2Box_0x25fbf0; // 0x26001c - g_ps2RecompiledFunctionTable[360454] = bhCheckWall2Box_0x25fbf0; // 0x260020 - g_ps2RecompiledFunctionTable[360455] = bhCheckWall2Box_0x25fbf0; // 0x260024 - g_ps2RecompiledFunctionTable[360456] = bhCheckWall2Box_0x25fbf0; // 0x260028 - g_ps2RecompiledFunctionTable[360457] = bhCheckWall2Box_0x25fbf0; // 0x26002c - g_ps2RecompiledFunctionTable[360458] = bhCheckWall2Box_0x25fbf0; // 0x260030 - g_ps2RecompiledFunctionTable[360459] = bhCheckWall2Box_0x25fbf0; // 0x260034 - g_ps2RecompiledFunctionTable[360460] = bhCheckWall2Box_0x25fbf0; // 0x260038 - g_ps2RecompiledFunctionTable[360461] = bhCheckWall2Box_0x25fbf0; // 0x26003c - g_ps2RecompiledFunctionTable[360462] = bhCheckWall2Box_0x25fbf0; // 0x260040 - g_ps2RecompiledFunctionTable[360463] = bhCheckWall2Box_0x25fbf0; // 0x260044 - g_ps2RecompiledFunctionTable[360464] = bhCheckWall2Box_0x25fbf0; // 0x260048 - g_ps2RecompiledFunctionTable[360465] = bhCheckWall2Box_0x25fbf0; // 0x26004c - g_ps2RecompiledFunctionTable[360466] = bhCheckWall2Box_0x25fbf0; // 0x260050 - g_ps2RecompiledFunctionTable[360467] = bhCheckWall2Box_0x25fbf0; // 0x260054 - g_ps2RecompiledFunctionTable[360468] = bhCheckWall2Box_0x25fbf0; // 0x260058 - g_ps2RecompiledFunctionTable[360469] = bhCheckWall2Box_0x25fbf0; // 0x26005c - g_ps2RecompiledFunctionTable[360470] = bhCheckWall2Box_0x25fbf0; // 0x260060 - g_ps2RecompiledFunctionTable[360471] = bhCheckWall2Box_0x25fbf0; // 0x260064 - g_ps2RecompiledFunctionTable[360472] = bhCheckWall2Box_0x25fbf0; // 0x260068 - g_ps2RecompiledFunctionTable[360473] = bhCheckWall2Box_0x25fbf0; // 0x26006c - g_ps2RecompiledFunctionTable[360474] = bhCheckWall2Box_0x25fbf0; // 0x260070 - g_ps2RecompiledFunctionTable[360475] = bhCheckWall2Box_0x25fbf0; // 0x260074 - g_ps2RecompiledFunctionTable[360476] = bhCheckWall2Box_0x25fbf0; // 0x260078 - g_ps2RecompiledFunctionTable[360477] = bhCheckWall2Box_0x25fbf0; // 0x26007c - g_ps2RecompiledFunctionTable[360478] = bhCheckWall2Box_0x25fbf0; // 0x260080 - g_ps2RecompiledFunctionTable[360479] = bhCheckWall2Box_0x25fbf0; // 0x260084 - g_ps2RecompiledFunctionTable[360480] = bhCheckWall2Box_0x25fbf0; // 0x260088 - g_ps2RecompiledFunctionTable[360481] = bhCheckWall2Box_0x25fbf0; // 0x26008c - g_ps2RecompiledFunctionTable[360482] = bhCheckWall2Box_0x25fbf0; // 0x260090 - g_ps2RecompiledFunctionTable[360483] = bhCheckWall2Box_0x25fbf0; // 0x260094 - g_ps2RecompiledFunctionTable[360484] = bhCheckWall2Box_0x25fbf0; // 0x260098 - g_ps2RecompiledFunctionTable[360485] = bhCheckWall2Box_0x25fbf0; // 0x26009c - g_ps2RecompiledFunctionTable[360486] = bhCheckWall2Box_0x25fbf0; // 0x2600a0 - g_ps2RecompiledFunctionTable[360487] = bhCheckWall2Box_0x25fbf0; // 0x2600a4 - g_ps2RecompiledFunctionTable[360488] = bhCheckWall2Box_0x25fbf0; // 0x2600a8 - g_ps2RecompiledFunctionTable[360489] = bhCheckWall2Box_0x25fbf0; // 0x2600ac - g_ps2RecompiledFunctionTable[360490] = bhCheckWall2Box_0x25fbf0; // 0x2600b0 - g_ps2RecompiledFunctionTable[360491] = bhCheckWall2Box_0x25fbf0; // 0x2600b4 - g_ps2RecompiledFunctionTable[360492] = bhCheckWall2Box_0x25fbf0; // 0x2600b8 - g_ps2RecompiledFunctionTable[360493] = bhCheckWall2Box_0x25fbf0; // 0x2600bc - g_ps2RecompiledFunctionTable[360494] = bhCheckWall2Box_0x25fbf0; // 0x2600c0 - g_ps2RecompiledFunctionTable[360495] = bhCheckWall2Box_0x25fbf0; // 0x2600c4 - g_ps2RecompiledFunctionTable[360496] = bhCheckWall2Box_0x25fbf0; // 0x2600c8 - g_ps2RecompiledFunctionTable[360497] = bhCheckWall2Box_0x25fbf0; // 0x2600cc - g_ps2RecompiledFunctionTable[360498] = bhCheckWall2Box_0x25fbf0; // 0x2600d0 - g_ps2RecompiledFunctionTable[360499] = bhCheckWall2Box_0x25fbf0; // 0x2600d4 - g_ps2RecompiledFunctionTable[360500] = bhCheckWall2Box_0x25fbf0; // 0x2600d8 - g_ps2RecompiledFunctionTable[360501] = bhCheckWall2Box_0x25fbf0; // 0x2600dc - g_ps2RecompiledFunctionTable[360502] = bhCheckWall2Box_0x25fbf0; // 0x2600e0 - g_ps2RecompiledFunctionTable[360503] = bhCheckWall2Box_0x25fbf0; // 0x2600e4 - g_ps2RecompiledFunctionTable[360504] = bhCheckWall2Box_0x25fbf0; // 0x2600e8 - g_ps2RecompiledFunctionTable[360505] = bhCheckWall2Box_0x25fbf0; // 0x2600ec - g_ps2RecompiledFunctionTable[360506] = bhCheckWall2Box_0x25fbf0; // 0x2600f0 - g_ps2RecompiledFunctionTable[360507] = bhCheckWall2Box_0x25fbf0; // 0x2600f4 - g_ps2RecompiledFunctionTable[360508] = bhCheckWall2Box_0x25fbf0; // 0x2600f8 - g_ps2RecompiledFunctionTable[360509] = bhCheckWall2Box_0x25fbf0; // 0x2600fc - g_ps2RecompiledFunctionTable[360510] = bhCheckWall2Box_0x25fbf0; // 0x260100 - g_ps2RecompiledFunctionTable[360511] = bhCheckWall2Box_0x25fbf0; // 0x260104 - g_ps2RecompiledFunctionTable[360512] = bhCheckWall2Box_0x25fbf0; // 0x260108 - g_ps2RecompiledFunctionTable[360513] = bhCheckWall2Box_0x25fbf0; // 0x26010c - g_ps2RecompiledFunctionTable[360514] = bhCheckWall2Box_0x25fbf0; // 0x260110 - g_ps2RecompiledFunctionTable[360515] = bhCheckWall2Box_0x25fbf0; // 0x260114 - g_ps2RecompiledFunctionTable[360516] = bhCheckWall2Box_0x25fbf0; // 0x260118 - g_ps2RecompiledFunctionTable[360517] = bhCheckWall2Box_0x25fbf0; // 0x26011c - g_ps2RecompiledFunctionTable[360518] = bhCheckWall2Box_0x25fbf0; // 0x260120 - g_ps2RecompiledFunctionTable[360519] = bhCheckWall2Box_0x25fbf0; // 0x260124 - g_ps2RecompiledFunctionTable[360520] = bhCheckWall2Box_0x25fbf0; // 0x260128 - g_ps2RecompiledFunctionTable[360521] = bhCheckWall2Box_0x25fbf0; // 0x26012c - g_ps2RecompiledFunctionTable[360522] = bhCheckWall2Box_0x25fbf0; // 0x260130 - g_ps2RecompiledFunctionTable[360523] = bhCheckWall2Box_0x25fbf0; // 0x260134 - g_ps2RecompiledFunctionTable[360524] = bhCheckWall2Box_0x25fbf0; // 0x260138 - g_ps2RecompiledFunctionTable[360525] = bhCheckWall2Box_0x25fbf0; // 0x26013c - g_ps2RecompiledFunctionTable[360526] = bhCheckWall2Box_0x25fbf0; // 0x260140 - g_ps2RecompiledFunctionTable[360527] = bhCheckWall2Box_0x25fbf0; // 0x260144 - g_ps2RecompiledFunctionTable[360528] = bhCheckWall2Box_0x25fbf0; // 0x260148 - g_ps2RecompiledFunctionTable[360529] = bhCheckWall2Box_0x25fbf0; // 0x26014c - g_ps2RecompiledFunctionTable[360530] = bhCheckWall2Box_0x25fbf0; // 0x260150 - g_ps2RecompiledFunctionTable[360531] = bhCheckWall2Box_0x25fbf0; // 0x260154 - g_ps2RecompiledFunctionTable[360532] = bhCheckWall2Box_0x25fbf0; // 0x260158 - g_ps2RecompiledFunctionTable[360533] = bhCheckWall2Box_0x25fbf0; // 0x26015c - g_ps2RecompiledFunctionTable[360534] = bhCheckWall2Box_0x25fbf0; // 0x260160 - g_ps2RecompiledFunctionTable[360535] = bhCheckWall2Box_0x25fbf0; // 0x260164 - g_ps2RecompiledFunctionTable[360536] = bhCheckWall2Box_0x25fbf0; // 0x260168 - g_ps2RecompiledFunctionTable[360537] = bhCheckWall2Box_0x25fbf0; // 0x26016c - g_ps2RecompiledFunctionTable[360538] = bhCheckWall2Box_0x25fbf0; // 0x260170 - g_ps2RecompiledFunctionTable[360539] = bhCheckWall2Box_0x25fbf0; // 0x260174 - g_ps2RecompiledFunctionTable[360540] = bhCheckWall2Box_0x25fbf0; // 0x260178 - g_ps2RecompiledFunctionTable[360541] = bhCheckWall2Box_0x25fbf0; // 0x26017c - g_ps2RecompiledFunctionTable[360542] = bhCheckWall2Box_0x25fbf0; // 0x260180 - g_ps2RecompiledFunctionTable[360543] = bhCheckWall2Box_0x25fbf0; // 0x260184 - g_ps2RecompiledFunctionTable[360544] = bhCheckWall2Box_0x25fbf0; // 0x260188 - g_ps2RecompiledFunctionTable[360545] = bhCheckWall2Box_0x25fbf0; // 0x26018c - g_ps2RecompiledFunctionTable[360546] = bhCheckWall2Box_0x25fbf0; // 0x260190 - g_ps2RecompiledFunctionTable[360547] = bhCheckWall2Box_0x25fbf0; // 0x260194 - g_ps2RecompiledFunctionTable[360548] = bhCheckWall2Box_0x25fbf0; // 0x260198 - g_ps2RecompiledFunctionTable[360549] = bhCheckWall2Box_0x25fbf0; // 0x26019c - g_ps2RecompiledFunctionTable[360550] = bhCheckWall2Box_0x25fbf0; // 0x2601a0 - g_ps2RecompiledFunctionTable[360551] = bhCheckWall2Box_0x25fbf0; // 0x2601a4 - g_ps2RecompiledFunctionTable[360552] = bhCheckWall2Box_0x25fbf0; // 0x2601a8 - g_ps2RecompiledFunctionTable[360553] = bhCheckWall2Box_0x25fbf0; // 0x2601ac - g_ps2RecompiledFunctionTable[360554] = bhCheckWall2Box_0x25fbf0; // 0x2601b0 - g_ps2RecompiledFunctionTable[360555] = bhCheckWall2Box_0x25fbf0; // 0x2601b4 - g_ps2RecompiledFunctionTable[360556] = bhCheckWall2Box_0x25fbf0; // 0x2601b8 - g_ps2RecompiledFunctionTable[360557] = bhCheckWall2Box_0x25fbf0; // 0x2601bc - g_ps2RecompiledFunctionTable[360558] = bhCheckWall2Box_0x25fbf0; // 0x2601c0 - g_ps2RecompiledFunctionTable[360559] = bhCheckWall2Box_0x25fbf0; // 0x2601c4 - g_ps2RecompiledFunctionTable[360560] = bhCheckWall2Box_0x25fbf0; // 0x2601c8 - g_ps2RecompiledFunctionTable[360561] = bhCheckWall2Box_0x25fbf0; // 0x2601cc - g_ps2RecompiledFunctionTable[360562] = bhCheckWall2Box_0x25fbf0; // 0x2601d0 - g_ps2RecompiledFunctionTable[360563] = bhCheckWall2Box_0x25fbf0; // 0x2601d4 - g_ps2RecompiledFunctionTable[360564] = bhCheckWall2Box_0x25fbf0; // 0x2601d8 - g_ps2RecompiledFunctionTable[360565] = bhCheckWall2Box_0x25fbf0; // 0x2601dc - g_ps2RecompiledFunctionTable[360566] = bhCheckWall2Box_0x25fbf0; // 0x2601e0 - g_ps2RecompiledFunctionTable[360567] = bhCheckWall2Box_0x25fbf0; // 0x2601e4 - g_ps2RecompiledFunctionTable[360568] = bhCheckWall2Box_0x25fbf0; // 0x2601e8 - g_ps2RecompiledFunctionTable[360569] = bhCheckWall2Box_0x25fbf0; // 0x2601ec - g_ps2RecompiledFunctionTable[360570] = bhCheckWall2Box_0x25fbf0; // 0x2601f0 - g_ps2RecompiledFunctionTable[360571] = bhCheckWall2Box_0x25fbf0; // 0x2601f4 - g_ps2RecompiledFunctionTable[360572] = bhCheckWall2Box_0x25fbf0; // 0x2601f8 - g_ps2RecompiledFunctionTable[360573] = bhCheckWall2Box_0x25fbf0; // 0x2601fc - g_ps2RecompiledFunctionTable[360574] = bhCheckWall2Box_0x25fbf0; // 0x260200 - g_ps2RecompiledFunctionTable[360575] = bhCheckWall2Box_0x25fbf0; // 0x260204 - g_ps2RecompiledFunctionTable[360576] = bhCheckWall2Box_0x25fbf0; // 0x260208 - g_ps2RecompiledFunctionTable[360577] = bhCheckWall2Box_0x25fbf0; // 0x26020c - g_ps2RecompiledFunctionTable[360578] = bhCheckWall2Box_0x25fbf0; // 0x260210 - g_ps2RecompiledFunctionTable[360579] = bhCheckWall2Box_0x25fbf0; // 0x260214 - g_ps2RecompiledFunctionTable[360580] = bhCheckWall2Box_0x25fbf0; // 0x260218 - g_ps2RecompiledFunctionTable[360581] = bhCheckWall2Box_0x25fbf0; // 0x26021c - g_ps2RecompiledFunctionTable[360582] = bhCheckWall2Box_0x25fbf0; // 0x260220 - g_ps2RecompiledFunctionTable[360583] = bhCheckWall2Box_0x25fbf0; // 0x260224 - g_ps2RecompiledFunctionTable[360584] = bhCheckWall2Box_0x25fbf0; // 0x260228 - g_ps2RecompiledFunctionTable[360585] = bhCheckWall2Box_0x25fbf0; // 0x26022c - g_ps2RecompiledFunctionTable[360586] = bhCheckWall2Box_0x25fbf0; // 0x260230 - g_ps2RecompiledFunctionTable[360587] = bhCheckWall2Box_0x25fbf0; // 0x260234 - g_ps2RecompiledFunctionTable[360588] = bhCheckWall2Box_0x25fbf0; // 0x260238 - g_ps2RecompiledFunctionTable[360589] = bhCheckWall2Box_0x25fbf0; // 0x26023c - g_ps2RecompiledFunctionTable[360590] = bhCheckWall2Box_0x25fbf0; // 0x260240 - g_ps2RecompiledFunctionTable[360591] = bhCheckWall2Box_0x25fbf0; // 0x260244 - g_ps2RecompiledFunctionTable[360592] = bhCheckWall2Box_0x25fbf0; // 0x260248 - g_ps2RecompiledFunctionTable[360593] = bhCheckWall2Box_0x25fbf0; // 0x26024c - g_ps2RecompiledFunctionTable[360594] = bhCheckWall2Box_0x25fbf0; // 0x260250 - g_ps2RecompiledFunctionTable[360595] = bhCheckWall2Box_0x25fbf0; // 0x260254 - g_ps2RecompiledFunctionTable[360596] = bhCheckWall2Box_0x25fbf0; // 0x260258 - g_ps2RecompiledFunctionTable[360597] = bhCheckWall2Box_0x25fbf0; // 0x26025c - g_ps2RecompiledFunctionTable[360598] = bhCheckWall2Box_0x25fbf0; // 0x260260 - g_ps2RecompiledFunctionTable[360599] = bhCheckWall2Box_0x25fbf0; // 0x260264 - g_ps2RecompiledFunctionTable[360600] = bhCheckWall2Box_0x25fbf0; // 0x260268 - g_ps2RecompiledFunctionTable[360601] = bhCheckWall2Box_0x25fbf0; // 0x26026c - g_ps2RecompiledFunctionTable[360602] = bhCheckWall2Box_0x25fbf0; // 0x260270 - g_ps2RecompiledFunctionTable[360603] = bhCheckWall2Box_0x25fbf0; // 0x260274 - g_ps2RecompiledFunctionTable[360604] = bhCheckWall2Box_0x25fbf0; // 0x260278 - g_ps2RecompiledFunctionTable[360605] = bhCheckWall2Box_0x25fbf0; // 0x26027c - g_ps2RecompiledFunctionTable[360606] = bhCheckWall2Box_0x25fbf0; // 0x260280 - g_ps2RecompiledFunctionTable[360607] = bhCheckWall2Box_0x25fbf0; // 0x260284 - g_ps2RecompiledFunctionTable[360608] = bhCheckWall2Box_0x25fbf0; // 0x260288 - g_ps2RecompiledFunctionTable[360609] = bhCheckWall2Box_0x25fbf0; // 0x26028c - g_ps2RecompiledFunctionTable[360610] = bhCheckWall2Box_0x25fbf0; // 0x260290 - g_ps2RecompiledFunctionTable[360611] = bhCheckWall2Box_0x25fbf0; // 0x260294 - g_ps2RecompiledFunctionTable[360612] = bhCheckWall2Box_0x25fbf0; // 0x260298 - g_ps2RecompiledFunctionTable[360613] = bhCheckWall2Box_0x25fbf0; // 0x26029c - g_ps2RecompiledFunctionTable[360614] = bhCheckWall2Box_0x25fbf0; // 0x2602a0 - g_ps2RecompiledFunctionTable[360615] = bhCheckWall2Box_0x25fbf0; // 0x2602a4 - g_ps2RecompiledFunctionTable[360616] = bhCheckWall2Box_0x25fbf0; // 0x2602a8 - g_ps2RecompiledFunctionTable[360617] = bhCheckWall2Box_0x25fbf0; // 0x2602ac - g_ps2RecompiledFunctionTable[360618] = bhCheckWall2Box_0x25fbf0; // 0x2602b0 - g_ps2RecompiledFunctionTable[360619] = bhCheckWall2Box_0x25fbf0; // 0x2602b4 - g_ps2RecompiledFunctionTable[360620] = bhCheckWall2Box_0x25fbf0; // 0x2602b8 - g_ps2RecompiledFunctionTable[360621] = bhCheckWall2Box_0x25fbf0; // 0x2602bc - g_ps2RecompiledFunctionTable[360622] = bhCheckWall2Box_0x25fbf0; // 0x2602c0 - g_ps2RecompiledFunctionTable[360623] = bhCheckWall2Box_0x25fbf0; // 0x2602c4 - g_ps2RecompiledFunctionTable[360624] = bhCheckWall2Box_0x25fbf0; // 0x2602c8 - g_ps2RecompiledFunctionTable[360625] = bhCheckWall2Box_0x25fbf0; // 0x2602cc - g_ps2RecompiledFunctionTable[360626] = bhCheckWall2Box_0x25fbf0; // 0x2602d0 - g_ps2RecompiledFunctionTable[360627] = bhCheckWall2Box_0x25fbf0; // 0x2602d4 - g_ps2RecompiledFunctionTable[360628] = bhCheckWall2Box_0x25fbf0; // 0x2602d8 - g_ps2RecompiledFunctionTable[360629] = bhCheckWall2Box_0x25fbf0; // 0x2602dc - g_ps2RecompiledFunctionTable[360630] = bhCheckWall2Box_0x25fbf0; // 0x2602e0 - g_ps2RecompiledFunctionTable[360631] = bhCheckWall2Box_0x25fbf0; // 0x2602e4 - g_ps2RecompiledFunctionTable[360632] = bhCheckWall2Box_0x25fbf0; // 0x2602e8 - g_ps2RecompiledFunctionTable[360633] = bhCheckWall2Box_0x25fbf0; // 0x2602ec - g_ps2RecompiledFunctionTable[360634] = bhCheckWall2Box_0x25fbf0; // 0x2602f0 - g_ps2RecompiledFunctionTable[360635] = bhCheckWall2Box_0x25fbf0; // 0x2602f4 - g_ps2RecompiledFunctionTable[360636] = bhCheckWall2Box_0x25fbf0; // 0x2602f8 - g_ps2RecompiledFunctionTable[360637] = bhCheckWall2Box_0x25fbf0; // 0x2602fc - g_ps2RecompiledFunctionTable[360638] = bhCheckWall2Box_0x25fbf0; // 0x260300 - g_ps2RecompiledFunctionTable[360639] = bhCheckWall2Box_0x25fbf0; // 0x260304 - g_ps2RecompiledFunctionTable[360640] = bhCheckWall2Box_0x25fbf0; // 0x260308 - g_ps2RecompiledFunctionTable[360641] = bhCheckWall2Box_0x25fbf0; // 0x26030c - g_ps2RecompiledFunctionTable[360642] = bhCheckWall2Box_0x25fbf0; // 0x260310 - g_ps2RecompiledFunctionTable[360643] = bhCheckWall2Box_0x25fbf0; // 0x260314 - g_ps2RecompiledFunctionTable[360644] = bhCheckWall2Box_0x25fbf0; // 0x260318 - g_ps2RecompiledFunctionTable[360645] = bhCheckWall2Box_0x25fbf0; // 0x26031c - g_ps2RecompiledFunctionTable[360646] = bhCheckWall2Box_0x25fbf0; // 0x260320 - g_ps2RecompiledFunctionTable[360647] = bhCheckWall2Box_0x25fbf0; // 0x260324 - g_ps2RecompiledFunctionTable[360648] = bhCheckWall2Box_0x25fbf0; // 0x260328 - g_ps2RecompiledFunctionTable[360649] = bhCheckWall2Box_0x25fbf0; // 0x26032c - g_ps2RecompiledFunctionTable[360650] = bhCheckWall2Box_0x25fbf0; // 0x260330 - g_ps2RecompiledFunctionTable[360651] = bhCheckWall2Box_0x25fbf0; // 0x260334 - g_ps2RecompiledFunctionTable[360652] = bhCheckWall2Box_0x25fbf0; // 0x260338 - g_ps2RecompiledFunctionTable[360653] = bhCheckWall2Box_0x25fbf0; // 0x26033c - g_ps2RecompiledFunctionTable[360654] = bhCheckWall2Box_0x25fbf0; // 0x260340 - g_ps2RecompiledFunctionTable[360655] = bhCheckWall2Box_0x25fbf0; // 0x260344 - g_ps2RecompiledFunctionTable[360656] = bhCheckWall2Box_0x25fbf0; // 0x260348 - g_ps2RecompiledFunctionTable[360657] = bhCheckWall2Box_0x25fbf0; // 0x26034c - g_ps2RecompiledFunctionTable[360658] = bhCheckWall2Box_0x25fbf0; // 0x260350 - g_ps2RecompiledFunctionTable[360659] = bhCheckWall2Box_0x25fbf0; // 0x260354 - g_ps2RecompiledFunctionTable[360660] = bhCheckWall2Box_0x25fbf0; // 0x260358 - g_ps2RecompiledFunctionTable[360661] = bhCheckWall2Box_0x25fbf0; // 0x26035c - g_ps2RecompiledFunctionTable[360662] = bhCheckWall2Box_0x25fbf0; // 0x260360 - g_ps2RecompiledFunctionTable[360663] = bhCheckWall2Box_0x25fbf0; // 0x260364 - g_ps2RecompiledFunctionTable[360664] = bhCheckWall2Box_0x25fbf0; // 0x260368 - g_ps2RecompiledFunctionTable[360665] = bhCheckWall2Box_0x25fbf0; // 0x26036c - g_ps2RecompiledFunctionTable[360666] = bhCheckWall2Box_0x25fbf0; // 0x260370 - g_ps2RecompiledFunctionTable[360667] = bhCheckWall2Box_0x25fbf0; // 0x260374 - g_ps2RecompiledFunctionTable[360668] = bhCheckWall2Box_0x25fbf0; // 0x260378 - g_ps2RecompiledFunctionTable[360669] = bhCheckWall2Box_0x25fbf0; // 0x26037c - g_ps2RecompiledFunctionTable[360670] = bhCheckWall2Box_0x25fbf0; // 0x260380 - g_ps2RecompiledFunctionTable[360671] = bhCheckWall2Box_0x25fbf0; // 0x260384 - g_ps2RecompiledFunctionTable[360672] = bhCheckWall2Box_0x25fbf0; // 0x260388 - g_ps2RecompiledFunctionTable[360673] = bhCheckWall2Box_0x25fbf0; // 0x26038c - g_ps2RecompiledFunctionTable[360674] = bhCheckWall2Box_0x25fbf0; // 0x260390 - g_ps2RecompiledFunctionTable[360675] = bhCheckWall2Box_0x25fbf0; // 0x260394 - g_ps2RecompiledFunctionTable[360676] = bhCheckWall2Box_0x25fbf0; // 0x260398 - g_ps2RecompiledFunctionTable[360677] = bhCheckWall2Box_0x25fbf0; // 0x26039c - g_ps2RecompiledFunctionTable[360678] = bhCheckWall2Box_0x25fbf0; // 0x2603a0 - g_ps2RecompiledFunctionTable[360679] = bhCheckWall2Box_0x25fbf0; // 0x2603a4 - g_ps2RecompiledFunctionTable[360680] = bhCheckWall2Box_0x25fbf0; // 0x2603a8 - g_ps2RecompiledFunctionTable[360681] = bhCheckWall2Box_0x25fbf0; // 0x2603ac - g_ps2RecompiledFunctionTable[360682] = bhCheckWall2Box_0x25fbf0; // 0x2603b0 - g_ps2RecompiledFunctionTable[360683] = bhCheckWall2Box_0x25fbf0; // 0x2603b4 - g_ps2RecompiledFunctionTable[360684] = bhCheckWall2Box_0x25fbf0; // 0x2603b8 - g_ps2RecompiledFunctionTable[360685] = bhCheckWall2Box_0x25fbf0; // 0x2603bc - g_ps2RecompiledFunctionTable[360686] = bhCheckWall2Box_0x25fbf0; // 0x2603c0 - g_ps2RecompiledFunctionTable[360687] = bhCheckWall2Box_0x25fbf0; // 0x2603c4 - g_ps2RecompiledFunctionTable[360688] = bhCheckWall2Box_0x25fbf0; // 0x2603c8 - g_ps2RecompiledFunctionTable[360689] = bhCheckWall2Box_0x25fbf0; // 0x2603cc - g_ps2RecompiledFunctionTable[360690] = bhCheckWall2Box_0x25fbf0; // 0x2603d0 - g_ps2RecompiledFunctionTable[360691] = bhCheckWall2Box_0x25fbf0; // 0x2603d4 - g_ps2RecompiledFunctionTable[360692] = bhCheckWall2Box_0x25fbf0; // 0x2603d8 - g_ps2RecompiledFunctionTable[360693] = bhCheckWall2Box_0x25fbf0; // 0x2603dc - g_ps2RecompiledFunctionTable[360694] = bhCheckWall2Box_0x25fbf0; // 0x2603e0 - g_ps2RecompiledFunctionTable[360695] = bhCheckWall2Box_0x25fbf0; // 0x2603e4 - g_ps2RecompiledFunctionTable[360696] = bhCheckWall2Box_0x25fbf0; // 0x2603e8 - g_ps2RecompiledFunctionTable[360697] = bhCheckWall2Box_0x25fbf0; // 0x2603ec - g_ps2RecompiledFunctionTable[360698] = bhCheckWall2Box_0x25fbf0; // 0x2603f0 - g_ps2RecompiledFunctionTable[360699] = bhCheckWall2Box_0x25fbf0; // 0x2603f4 - g_ps2RecompiledFunctionTable[360700] = bhCheckWall2Box_0x25fbf0; // 0x2603f8 - g_ps2RecompiledFunctionTable[360701] = bhCheckWall2Box_0x25fbf0; // 0x2603fc - g_ps2RecompiledFunctionTable[360702] = bhCheckWall2Box_0x25fbf0; // 0x260400 - g_ps2RecompiledFunctionTable[360703] = bhCheckWall2Box_0x25fbf0; // 0x260404 - g_ps2RecompiledFunctionTable[360704] = bhCheckWall2Box_0x25fbf0; // 0x260408 - g_ps2RecompiledFunctionTable[360705] = bhCheckWall2Box_0x25fbf0; // 0x26040c - g_ps2RecompiledFunctionTable[360706] = bhCheckWall2Box_0x25fbf0; // 0x260410 - g_ps2RecompiledFunctionTable[360707] = bhCheckWall2Box_0x25fbf0; // 0x260414 - g_ps2RecompiledFunctionTable[360708] = bhCheckWall2Box_0x25fbf0; // 0x260418 - g_ps2RecompiledFunctionTable[360709] = bhCheckWall2Box_0x25fbf0; // 0x26041c - g_ps2RecompiledFunctionTable[360710] = bhCheckWall2Box_0x25fbf0; // 0x260420 - g_ps2RecompiledFunctionTable[360711] = bhCheckWall2Box_0x25fbf0; // 0x260424 - g_ps2RecompiledFunctionTable[360712] = bhCheckWall2Box_0x25fbf0; // 0x260428 - g_ps2RecompiledFunctionTable[360713] = bhCheckWall2Box_0x25fbf0; // 0x26042c - g_ps2RecompiledFunctionTable[360714] = bhCheckWall2Box_0x25fbf0; // 0x260430 - g_ps2RecompiledFunctionTable[360715] = bhCheckWall2Box_0x25fbf0; // 0x260434 - g_ps2RecompiledFunctionTable[360716] = bhCheckWall2Box_0x25fbf0; // 0x260438 - g_ps2RecompiledFunctionTable[360717] = bhCheckWall2Box_0x25fbf0; // 0x26043c - g_ps2RecompiledFunctionTable[360718] = bhCheckWall2Box_0x25fbf0; // 0x260440 - g_ps2RecompiledFunctionTable[360719] = bhCheckWall2Box_0x25fbf0; // 0x260444 - g_ps2RecompiledFunctionTable[360720] = bhCheckWall2Box_0x25fbf0; // 0x260448 - g_ps2RecompiledFunctionTable[360721] = bhCheckWall2Box_0x25fbf0; // 0x26044c - g_ps2RecompiledFunctionTable[360722] = bhCheckWall2Box_0x25fbf0; // 0x260450 - g_ps2RecompiledFunctionTable[360723] = bhCheckWall2Box_0x25fbf0; // 0x260454 - g_ps2RecompiledFunctionTable[360724] = bhCheckWall2Box_0x25fbf0; // 0x260458 - g_ps2RecompiledFunctionTable[360725] = bhCheckWall2Box_0x25fbf0; // 0x26045c - g_ps2RecompiledFunctionTable[360726] = bhCheckWall2Box_0x25fbf0; // 0x260460 - g_ps2RecompiledFunctionTable[360727] = bhCheckWall2Box_0x25fbf0; // 0x260464 - g_ps2RecompiledFunctionTable[360728] = bhCheckWall2Box_0x25fbf0; // 0x260468 - g_ps2RecompiledFunctionTable[360729] = bhCheckWall2Box_0x25fbf0; // 0x26046c - g_ps2RecompiledFunctionTable[360730] = bhCheckWall2Box_0x25fbf0; // 0x260470 - g_ps2RecompiledFunctionTable[360731] = bhCheckWall2Box_0x25fbf0; // 0x260474 - g_ps2RecompiledFunctionTable[360732] = bhCheckWall2Box_0x25fbf0; // 0x260478 - g_ps2RecompiledFunctionTable[360733] = bhCheckWall2Box_0x25fbf0; // 0x26047c - g_ps2RecompiledFunctionTable[360734] = bhCheckWall2Box_0x25fbf0; // 0x260480 - g_ps2RecompiledFunctionTable[360735] = bhCheckWall2Box_0x25fbf0; // 0x260484 - g_ps2RecompiledFunctionTable[360736] = bhCheckWall2Box_0x25fbf0; // 0x260488 - g_ps2RecompiledFunctionTable[360737] = bhCheckWall2Box_0x25fbf0; // 0x26048c - g_ps2RecompiledFunctionTable[360738] = bhCheckWall2Box_0x25fbf0; // 0x260490 - g_ps2RecompiledFunctionTable[360739] = bhCheckWall2Box_0x25fbf0; // 0x260494 - g_ps2RecompiledFunctionTable[360740] = bhCheckWall2Box_0x25fbf0; // 0x260498 - g_ps2RecompiledFunctionTable[360741] = bhCheckWall2Box_0x25fbf0; // 0x26049c - g_ps2RecompiledFunctionTable[360742] = bhCheckWall2Box_0x25fbf0; // 0x2604a0 - g_ps2RecompiledFunctionTable[360743] = bhCheckWall2Box_0x25fbf0; // 0x2604a4 - g_ps2RecompiledFunctionTable[360744] = bhCheckWall2Box_0x25fbf0; // 0x2604a8 - g_ps2RecompiledFunctionTable[360745] = bhCheckWall2Box_0x25fbf0; // 0x2604ac - g_ps2RecompiledFunctionTable[360746] = bhCheckWall2Box_0x25fbf0; // 0x2604b0 - g_ps2RecompiledFunctionTable[360747] = bhCheckWall2Box_0x25fbf0; // 0x2604b4 - g_ps2RecompiledFunctionTable[360748] = bhCheckWall2Box_0x25fbf0; // 0x2604b8 - g_ps2RecompiledFunctionTable[360749] = bhCheckWall2Box_0x25fbf0; // 0x2604bc - g_ps2RecompiledFunctionTable[360750] = bhCheckWall2Box_0x25fbf0; // 0x2604c0 - g_ps2RecompiledFunctionTable[360751] = bhCheckWall2Box_0x25fbf0; // 0x2604c4 - g_ps2RecompiledFunctionTable[360752] = bhCheckWall2Box_0x25fbf0; // 0x2604c8 - g_ps2RecompiledFunctionTable[360753] = bhCheckWall2Box_0x25fbf0; // 0x2604cc - g_ps2RecompiledFunctionTable[360754] = bhCheckWall2Box_0x25fbf0; // 0x2604d0 - g_ps2RecompiledFunctionTable[360755] = bhCheckWall2Box_0x25fbf0; // 0x2604d4 - g_ps2RecompiledFunctionTable[360756] = bhCheckWall2Box_0x25fbf0; // 0x2604d8 - g_ps2RecompiledFunctionTable[360757] = bhCheckWall2Box_0x25fbf0; // 0x2604dc - g_ps2RecompiledFunctionTable[360758] = bhCheckWall2Box_0x25fbf0; // 0x2604e0 - g_ps2RecompiledFunctionTable[360759] = bhCheckWall2Box_0x25fbf0; // 0x2604e4 - g_ps2RecompiledFunctionTable[360760] = bhCheckWall2Box_0x25fbf0; // 0x2604e8 - g_ps2RecompiledFunctionTable[360761] = bhCheckWall2Box_0x25fbf0; // 0x2604ec - g_ps2RecompiledFunctionTable[360762] = bhCheckWall2Box_0x25fbf0; // 0x2604f0 - g_ps2RecompiledFunctionTable[360763] = bhCheckWall2Box_0x25fbf0; // 0x2604f4 - g_ps2RecompiledFunctionTable[360764] = bhCheckWall2Box_0x25fbf0; // 0x2604f8 - g_ps2RecompiledFunctionTable[360765] = bhCheckWall2Box_0x25fbf0; // 0x2604fc - g_ps2RecompiledFunctionTable[360766] = bhCheckWall2Box_0x25fbf0; // 0x260500 - g_ps2RecompiledFunctionTable[360767] = bhCheckWall2Box_0x25fbf0; // 0x260504 - g_ps2RecompiledFunctionTable[360768] = bhCheckWall2Box_0x25fbf0; // 0x260508 - g_ps2RecompiledFunctionTable[360769] = bhCheckWall2Box_0x25fbf0; // 0x26050c - g_ps2RecompiledFunctionTable[360770] = bhCheckWall2Box_0x25fbf0; // 0x260510 - g_ps2RecompiledFunctionTable[360771] = bhCheckWall2Box_0x25fbf0; // 0x260514 - g_ps2RecompiledFunctionTable[360772] = bhCheckWall2Box_0x25fbf0; // 0x260518 - g_ps2RecompiledFunctionTable[360773] = bhCheckWall2Box_0x25fbf0; // 0x26051c - g_ps2RecompiledFunctionTable[360774] = bhCheckWall2Box_0x25fbf0; // 0x260520 - g_ps2RecompiledFunctionTable[360775] = bhCheckWall2Box_0x25fbf0; // 0x260524 - g_ps2RecompiledFunctionTable[360776] = bhCheckWall2Box_0x25fbf0; // 0x260528 - g_ps2RecompiledFunctionTable[360777] = bhCheckWall2Box_0x25fbf0; // 0x26052c - g_ps2RecompiledFunctionTable[360778] = bhCheckWall2Box_0x25fbf0; // 0x260530 - g_ps2RecompiledFunctionTable[360779] = bhCheckWall2Box_0x25fbf0; // 0x260534 - g_ps2RecompiledFunctionTable[360780] = bhCheckWall2Box_0x25fbf0; // 0x260538 - g_ps2RecompiledFunctionTable[360781] = bhCheckWall2Box_0x25fbf0; // 0x26053c - g_ps2RecompiledFunctionTable[360782] = bhCheckWall2Box_0x25fbf0; // 0x260540 - g_ps2RecompiledFunctionTable[360783] = bhCheckWall2Box_0x25fbf0; // 0x260544 - g_ps2RecompiledFunctionTable[360784] = bhCheckWall2Box_0x25fbf0; // 0x260548 - g_ps2RecompiledFunctionTable[360785] = bhCheckWall2Box_0x25fbf0; // 0x26054c - g_ps2RecompiledFunctionTable[360786] = bhCheckWall2Box_0x25fbf0; // 0x260550 - g_ps2RecompiledFunctionTable[360787] = bhCheckWall2Box_0x25fbf0; // 0x260554 - g_ps2RecompiledFunctionTable[360788] = bhCheckWall2Box_0x25fbf0; // 0x260558 - g_ps2RecompiledFunctionTable[360789] = bhCheckWall2Box_0x25fbf0; // 0x26055c - g_ps2RecompiledFunctionTable[360790] = bhCheckWall2Box_0x25fbf0; // 0x260560 - g_ps2RecompiledFunctionTable[360791] = bhCheckWall2Box_0x25fbf0; // 0x260564 - g_ps2RecompiledFunctionTable[360792] = bhCheckWall2Box_0x25fbf0; // 0x260568 - g_ps2RecompiledFunctionTable[360793] = bhCheckWall2Box_0x25fbf0; // 0x26056c - g_ps2RecompiledFunctionTable[360794] = bhCheckWall2Box_0x25fbf0; // 0x260570 - g_ps2RecompiledFunctionTable[360795] = bhCheckWall2Box_0x25fbf0; // 0x260574 - g_ps2RecompiledFunctionTable[360796] = bhCheckWall2Box_0x25fbf0; // 0x260578 - g_ps2RecompiledFunctionTable[360797] = bhCheckWall2Box_0x25fbf0; // 0x26057c - g_ps2RecompiledFunctionTable[360798] = bhCheckWall2Box_0x25fbf0; // 0x260580 - g_ps2RecompiledFunctionTable[360799] = bhCheckWall2Box_0x25fbf0; // 0x260584 - g_ps2RecompiledFunctionTable[360800] = bhCheckWall2Box_0x25fbf0; // 0x260588 - g_ps2RecompiledFunctionTable[360801] = bhCheckWall2Box_0x25fbf0; // 0x26058c - g_ps2RecompiledFunctionTable[360802] = bhCheckWall2Box_0x25fbf0; // 0x260590 - g_ps2RecompiledFunctionTable[360803] = bhCheckWall2Box_0x25fbf0; // 0x260594 - g_ps2RecompiledFunctionTable[360804] = bhCheckWall2Box_0x25fbf0; // 0x260598 - g_ps2RecompiledFunctionTable[360805] = bhCheckWall2Box_0x25fbf0; // 0x26059c - g_ps2RecompiledFunctionTable[360806] = bhCheckWall2Box_0x25fbf0; // 0x2605a0 - g_ps2RecompiledFunctionTable[360807] = bhCheckWall2Box_0x25fbf0; // 0x2605a4 - g_ps2RecompiledFunctionTable[360808] = bhCheckWall2Box_0x25fbf0; // 0x2605a8 - g_ps2RecompiledFunctionTable[360809] = bhCheckWall2Box_0x25fbf0; // 0x2605ac - g_ps2RecompiledFunctionTable[360810] = bhCheckWall2Box_0x25fbf0; // 0x2605b0 - g_ps2RecompiledFunctionTable[360811] = bhCheckWall2Box_0x25fbf0; // 0x2605b4 - g_ps2RecompiledFunctionTable[360812] = bhCheckWall2Box_0x25fbf0; // 0x2605b8 - g_ps2RecompiledFunctionTable[360813] = bhCheckWall2Box_0x25fbf0; // 0x2605bc - g_ps2RecompiledFunctionTable[360814] = bhCheckWall2Box_0x25fbf0; // 0x2605c0 - g_ps2RecompiledFunctionTable[360815] = bhCheckWall2Box_0x25fbf0; // 0x2605c4 - g_ps2RecompiledFunctionTable[360816] = bhCheckWall2Box_0x25fbf0; // 0x2605c8 - g_ps2RecompiledFunctionTable[360817] = bhCheckWall2Box_0x25fbf0; // 0x2605cc - g_ps2RecompiledFunctionTable[360818] = bhCheckWall2Box_0x25fbf0; // 0x2605d0 - g_ps2RecompiledFunctionTable[360819] = bhCheckWall2Box_0x25fbf0; // 0x2605d4 - g_ps2RecompiledFunctionTable[360820] = bhCheckWall2Box_0x25fbf0; // 0x2605d8 - g_ps2RecompiledFunctionTable[360821] = bhCheckWall2Box_0x25fbf0; // 0x2605dc - g_ps2RecompiledFunctionTable[360822] = bhCheckWall2Box_0x25fbf0; // 0x2605e0 - g_ps2RecompiledFunctionTable[360823] = bhCheckWall2Box_0x25fbf0; // 0x2605e4 - g_ps2RecompiledFunctionTable[360824] = bhCheckWall2Box_0x25fbf0; // 0x2605e8 - g_ps2RecompiledFunctionTable[360825] = bhCheckWall2Box_0x25fbf0; // 0x2605ec - g_ps2RecompiledFunctionTable[360826] = bhCheckWall2Box_0x25fbf0; // 0x2605f0 - g_ps2RecompiledFunctionTable[360827] = bhCheckWall2Box_0x25fbf0; // 0x2605f4 - g_ps2RecompiledFunctionTable[360828] = bhCheckWall2Box_0x25fbf0; // 0x2605f8 - g_ps2RecompiledFunctionTable[360829] = bhCheckWall2Box_0x25fbf0; // 0x2605fc - g_ps2RecompiledFunctionTable[360830] = bhCheckWall2Box_0x25fbf0; // 0x260600 - g_ps2RecompiledFunctionTable[360831] = bhCheckWall2Box_0x25fbf0; // 0x260604 - g_ps2RecompiledFunctionTable[360832] = bhCheckWall2Box_0x25fbf0; // 0x260608 - g_ps2RecompiledFunctionTable[360833] = bhCheckWall2Box_0x25fbf0; // 0x26060c - g_ps2RecompiledFunctionTable[360834] = bhCheckWall2Box_0x25fbf0; // 0x260610 - g_ps2RecompiledFunctionTable[360835] = bhCheckWall2Box_0x25fbf0; // 0x260614 - g_ps2RecompiledFunctionTable[360836] = bhCheckWall2Box_0x25fbf0; // 0x260618 - g_ps2RecompiledFunctionTable[360837] = bhCheckWall2Box_0x25fbf0; // 0x26061c - g_ps2RecompiledFunctionTable[360838] = bhCheckWall2Box_0x25fbf0; // 0x260620 - g_ps2RecompiledFunctionTable[360839] = bhCheckWall2Box_0x25fbf0; // 0x260624 - g_ps2RecompiledFunctionTable[360840] = bhCheckWall2Box_0x25fbf0; // 0x260628 - g_ps2RecompiledFunctionTable[360841] = bhCheckWall2Box_0x25fbf0; // 0x26062c - g_ps2RecompiledFunctionTable[360842] = bhCheckWall2Box_0x25fbf0; // 0x260630 - g_ps2RecompiledFunctionTable[360843] = bhCheckWall2Box_0x25fbf0; // 0x260634 - g_ps2RecompiledFunctionTable[360844] = bhCheckWall2Box_0x25fbf0; // 0x260638 - g_ps2RecompiledFunctionTable[360845] = bhCheckWall2Box_0x25fbf0; // 0x26063c - g_ps2RecompiledFunctionTable[360846] = bhCheckWall2Box_0x25fbf0; // 0x260640 - g_ps2RecompiledFunctionTable[360847] = bhCheckWall2Box_0x25fbf0; // 0x260644 - g_ps2RecompiledFunctionTable[360848] = bhCheckWall2Box_0x25fbf0; // 0x260648 - g_ps2RecompiledFunctionTable[360849] = bhCheckWall2Box_0x25fbf0; // 0x26064c - g_ps2RecompiledFunctionTable[360850] = bhCheckWall2Box_0x25fbf0; // 0x260650 - g_ps2RecompiledFunctionTable[360851] = bhCheckWall2Box_0x25fbf0; // 0x260654 - g_ps2RecompiledFunctionTable[360852] = bhCheckWall2Box_0x25fbf0; // 0x260658 - g_ps2RecompiledFunctionTable[360853] = bhCheckWall2Box_0x25fbf0; // 0x26065c - g_ps2RecompiledFunctionTable[360854] = bhCheckWall2Box_0x25fbf0; // 0x260660 - g_ps2RecompiledFunctionTable[360855] = bhCheckWall2Box_0x25fbf0; // 0x260664 - g_ps2RecompiledFunctionTable[360856] = bhCheckWall2Box_0x25fbf0; // 0x260668 - g_ps2RecompiledFunctionTable[360857] = bhCheckWall2Box_0x25fbf0; // 0x26066c - g_ps2RecompiledFunctionTable[360858] = bhCheckWall2Box_0x25fbf0; // 0x260670 - g_ps2RecompiledFunctionTable[360859] = bhCheckWall2Box_0x25fbf0; // 0x260674 - g_ps2RecompiledFunctionTable[360860] = bhCheckWall2Box_0x25fbf0; // 0x260678 - g_ps2RecompiledFunctionTable[360861] = bhCheckWall2Box_0x25fbf0; // 0x26067c - g_ps2RecompiledFunctionTable[360862] = bhCheckWall2Box_0x25fbf0; // 0x260680 - g_ps2RecompiledFunctionTable[360863] = bhCheckWall2Box_0x25fbf0; // 0x260684 - g_ps2RecompiledFunctionTable[360864] = bhCheckWall2Box_0x25fbf0; // 0x260688 - g_ps2RecompiledFunctionTable[360865] = bhCheckWall2Box_0x25fbf0; // 0x26068c - g_ps2RecompiledFunctionTable[360866] = bhCheckWall2Box_0x25fbf0; // 0x260690 - g_ps2RecompiledFunctionTable[360867] = bhCheckWall2Box_0x25fbf0; // 0x260694 - g_ps2RecompiledFunctionTable[360868] = bhCheckWall2Box_0x25fbf0; // 0x260698 - g_ps2RecompiledFunctionTable[360869] = bhCheckWall2Box_0x25fbf0; // 0x26069c - g_ps2RecompiledFunctionTable[360870] = bhCheckWall2Box_0x25fbf0; // 0x2606a0 - g_ps2RecompiledFunctionTable[360871] = bhCheckWall2Box_0x25fbf0; // 0x2606a4 - g_ps2RecompiledFunctionTable[360872] = bhCheckWall2Box_0x25fbf0; // 0x2606a8 - g_ps2RecompiledFunctionTable[360873] = bhCheckWall2Box_0x25fbf0; // 0x2606ac - g_ps2RecompiledFunctionTable[360874] = bhCheckWall2Box_0x25fbf0; // 0x2606b0 - g_ps2RecompiledFunctionTable[360875] = bhCheckWall2Box_0x25fbf0; // 0x2606b4 - g_ps2RecompiledFunctionTable[360876] = bhCheckWall2Box_0x25fbf0; // 0x2606b8 - g_ps2RecompiledFunctionTable[360877] = bhCheckWall2Box_0x25fbf0; // 0x2606bc - g_ps2RecompiledFunctionTable[360878] = bhCheckWall2Box_0x25fbf0; // 0x2606c0 - g_ps2RecompiledFunctionTable[360879] = bhCheckWall2Box_0x25fbf0; // 0x2606c4 - g_ps2RecompiledFunctionTable[360880] = bhCheckWall2Box_0x25fbf0; // 0x2606c8 - g_ps2RecompiledFunctionTable[360881] = bhCheckWall2Box_0x25fbf0; // 0x2606cc - g_ps2RecompiledFunctionTable[360882] = bhCheckWall2Box_0x25fbf0; // 0x2606d0 - g_ps2RecompiledFunctionTable[360883] = bhCheckWall2Box_0x25fbf0; // 0x2606d4 - g_ps2RecompiledFunctionTable[360884] = bhCheckWall2Box_0x25fbf0; // 0x2606d8 - g_ps2RecompiledFunctionTable[360885] = bhCheckWall2Box_0x25fbf0; // 0x2606dc - g_ps2RecompiledFunctionTable[360886] = bhCheckWall2Box_0x25fbf0; // 0x2606e0 - g_ps2RecompiledFunctionTable[360887] = bhCheckWall2Box_0x25fbf0; // 0x2606e4 - g_ps2RecompiledFunctionTable[360888] = bhCheckWall2Box_0x25fbf0; // 0x2606e8 - g_ps2RecompiledFunctionTable[360889] = bhCheckWall2Box_0x25fbf0; // 0x2606ec - g_ps2RecompiledFunctionTable[360890] = bhCheckWall2Box_0x25fbf0; // 0x2606f0 - g_ps2RecompiledFunctionTable[360891] = bhCheckWall2Box_0x25fbf0; // 0x2606f4 - g_ps2RecompiledFunctionTable[360892] = bhCheckWall2Box_0x25fbf0; // 0x2606f8 - g_ps2RecompiledFunctionTable[360893] = bhCheckWall2Box_0x25fbf0; // 0x2606fc - g_ps2RecompiledFunctionTable[360894] = bhCheckWall2Box_0x25fbf0; // 0x260700 - g_ps2RecompiledFunctionTable[360895] = bhCheckWall2Box_0x25fbf0; // 0x260704 - g_ps2RecompiledFunctionTable[360896] = bhCheckWall2Box_0x25fbf0; // 0x260708 - g_ps2RecompiledFunctionTable[360897] = bhCheckWall2Box_0x25fbf0; // 0x26070c - g_ps2RecompiledFunctionTable[360898] = bhCheckWall2Box_0x25fbf0; // 0x260710 - g_ps2RecompiledFunctionTable[360899] = bhCheckWall2Box_0x25fbf0; // 0x260714 - g_ps2RecompiledFunctionTable[360900] = bhCheckWall2Box_0x25fbf0; // 0x260718 - g_ps2RecompiledFunctionTable[360901] = bhCheckWall2Box_0x25fbf0; // 0x26071c - g_ps2RecompiledFunctionTable[360902] = bhCheckWall2Box_0x25fbf0; // 0x260720 - g_ps2RecompiledFunctionTable[360903] = bhCheckWall2Box_0x25fbf0; // 0x260724 - g_ps2RecompiledFunctionTable[360904] = bhCheckWall2Box_0x25fbf0; // 0x260728 - g_ps2RecompiledFunctionTable[360905] = bhCheckWall2Box_0x25fbf0; // 0x26072c - g_ps2RecompiledFunctionTable[360906] = bhCheckWall2Box_0x25fbf0; // 0x260730 - g_ps2RecompiledFunctionTable[360907] = bhCheckWall2Box_0x25fbf0; // 0x260734 - g_ps2RecompiledFunctionTable[360908] = bhCheckWall2Box_0x25fbf0; // 0x260738 - g_ps2RecompiledFunctionTable[360909] = bhCheckWall2Box_0x25fbf0; // 0x26073c - g_ps2RecompiledFunctionTable[360910] = bhCheckWall2Box_0x25fbf0; // 0x260740 - g_ps2RecompiledFunctionTable[360911] = bhCheckWall2Box_0x25fbf0; // 0x260744 - g_ps2RecompiledFunctionTable[360912] = bhCheckWall2Box_0x25fbf0; // 0x260748 - g_ps2RecompiledFunctionTable[360913] = bhCheckWall2Box_0x25fbf0; // 0x26074c - g_ps2RecompiledFunctionTable[360914] = bhCheckWall2Box_0x25fbf0; // 0x260750 - g_ps2RecompiledFunctionTable[360915] = bhCheckWall2Box_0x25fbf0; // 0x260754 - g_ps2RecompiledFunctionTable[360916] = bhCheckWall2Box_0x25fbf0; // 0x260758 - g_ps2RecompiledFunctionTable[360917] = bhCheckWall2Box_0x25fbf0; // 0x26075c - g_ps2RecompiledFunctionTable[360918] = bhCheckWall2Box_0x25fbf0; // 0x260760 - g_ps2RecompiledFunctionTable[360919] = bhCheckWall2Box_0x25fbf0; // 0x260764 - g_ps2RecompiledFunctionTable[360920] = bhCheckWall2Box_0x25fbf0; // 0x260768 - g_ps2RecompiledFunctionTable[360921] = bhCheckWall2Box_0x25fbf0; // 0x26076c - g_ps2RecompiledFunctionTable[360922] = bhCheckWall2Box_0x25fbf0; // 0x260770 - g_ps2RecompiledFunctionTable[360923] = bhCheckWall2Box_0x25fbf0; // 0x260774 - g_ps2RecompiledFunctionTable[360924] = bhCheckWall2Box_0x25fbf0; // 0x260778 - g_ps2RecompiledFunctionTable[360925] = bhCheckWall2Box_0x25fbf0; // 0x26077c - g_ps2RecompiledFunctionTable[360926] = bhCheckWall2Box_0x25fbf0; // 0x260780 - g_ps2RecompiledFunctionTable[360927] = bhCheckWall2Box_0x25fbf0; // 0x260784 - g_ps2RecompiledFunctionTable[360928] = bhCheckWall2Box_0x25fbf0; // 0x260788 - g_ps2RecompiledFunctionTable[360929] = bhCheckWall2Box_0x25fbf0; // 0x26078c - g_ps2RecompiledFunctionTable[360930] = bhCheckWall2Box_0x25fbf0; // 0x260790 - g_ps2RecompiledFunctionTable[360931] = bhCheckWall2Box_0x25fbf0; // 0x260794 - g_ps2RecompiledFunctionTable[360932] = bhCheckWall2Box_0x25fbf0; // 0x260798 - g_ps2RecompiledFunctionTable[360933] = bhCheckWall2Box_0x25fbf0; // 0x26079c - g_ps2RecompiledFunctionTable[360934] = bhCheckWall2Box_0x25fbf0; // 0x2607a0 - g_ps2RecompiledFunctionTable[360935] = bhCheckWall2Box_0x25fbf0; // 0x2607a4 - g_ps2RecompiledFunctionTable[360936] = bhCheckWall2Box_0x25fbf0; // 0x2607a8 - g_ps2RecompiledFunctionTable[360937] = bhCheckWall2Box_0x25fbf0; // 0x2607ac - g_ps2RecompiledFunctionTable[360938] = bhCheckWall2Box_0x25fbf0; // 0x2607b0 - g_ps2RecompiledFunctionTable[360939] = bhCheckWall2Box_0x25fbf0; // 0x2607b4 - g_ps2RecompiledFunctionTable[360940] = bhCheckWall2Box_0x25fbf0; // 0x2607b8 - g_ps2RecompiledFunctionTable[360941] = bhCheckWall2Box_0x25fbf0; // 0x2607bc - g_ps2RecompiledFunctionTable[360942] = bhCheckWall2Box_0x25fbf0; // 0x2607c0 - g_ps2RecompiledFunctionTable[360943] = bhCheckWall2Box_0x25fbf0; // 0x2607c4 - g_ps2RecompiledFunctionTable[360944] = bhCheckWall2Box_0x25fbf0; // 0x2607c8 - g_ps2RecompiledFunctionTable[360945] = bhCheckWall2Box_0x25fbf0; // 0x2607cc - g_ps2RecompiledFunctionTable[360946] = bhCheckWall2Box_0x25fbf0; // 0x2607d0 - g_ps2RecompiledFunctionTable[360947] = bhCheckWall2Box_0x25fbf0; // 0x2607d4 - g_ps2RecompiledFunctionTable[360948] = bhCheckWall2Box_0x25fbf0; // 0x2607d8 - g_ps2RecompiledFunctionTable[360949] = bhCheckWall2Box_0x25fbf0; // 0x2607dc - g_ps2RecompiledFunctionTable[360950] = bhCheckWall2Box_0x25fbf0; // 0x2607e0 - g_ps2RecompiledFunctionTable[360951] = bhCheckWall2Box_0x25fbf0; // 0x2607e4 - g_ps2RecompiledFunctionTable[360952] = bhCheckWall2Box_0x25fbf0; // 0x2607e8 - g_ps2RecompiledFunctionTable[360953] = bhCheckWall2Box_0x25fbf0; // 0x2607ec - g_ps2RecompiledFunctionTable[360954] = bhCheckWall2Box_0x25fbf0; // 0x2607f0 - g_ps2RecompiledFunctionTable[360955] = bhCheckWall2Box_0x25fbf0; // 0x2607f4 - g_ps2RecompiledFunctionTable[360956] = bhCheckWall2Box_0x25fbf0; // 0x2607f8 - g_ps2RecompiledFunctionTable[360957] = bhCheckWall2Box_0x25fbf0; // 0x2607fc - g_ps2RecompiledFunctionTable[360958] = bhCheckWall2Box_0x25fbf0; // 0x260800 - g_ps2RecompiledFunctionTable[360959] = bhCheckWall2Box_0x25fbf0; // 0x260804 - g_ps2RecompiledFunctionTable[360960] = bhCheckWall2Box_0x25fbf0; // 0x260808 - g_ps2RecompiledFunctionTable[360961] = bhCheckWall2Box_0x25fbf0; // 0x26080c - g_ps2RecompiledFunctionTable[360962] = bhCheckWall2Box_0x25fbf0; // 0x260810 - g_ps2RecompiledFunctionTable[360963] = bhCheckWall2Box_0x25fbf0; // 0x260814 - g_ps2RecompiledFunctionTable[360964] = bhCheckWall2Box_0x25fbf0; // 0x260818 - g_ps2RecompiledFunctionTable[360965] = bhCheckWall2Box_0x25fbf0; // 0x26081c - g_ps2RecompiledFunctionTable[360966] = bhCheckWall2Box_0x25fbf0; // 0x260820 - g_ps2RecompiledFunctionTable[360967] = bhCheckWall2Box_0x25fbf0; // 0x260824 - g_ps2RecompiledFunctionTable[360968] = bhCheckWall2Box_0x25fbf0; // 0x260828 - g_ps2RecompiledFunctionTable[360969] = bhCheckWall2Box_0x25fbf0; // 0x26082c - g_ps2RecompiledFunctionTable[360970] = bhCheckWall2Box_0x25fbf0; // 0x260830 - g_ps2RecompiledFunctionTable[360971] = bhCheckWall2Box_0x25fbf0; // 0x260834 - g_ps2RecompiledFunctionTable[360972] = bhCheckWall2Box_0x25fbf0; // 0x260838 - g_ps2RecompiledFunctionTable[360973] = bhCheckWall2Box_0x25fbf0; // 0x26083c - g_ps2RecompiledFunctionTable[360974] = bhCheckWall2Box_0x25fbf0; // 0x260840 - g_ps2RecompiledFunctionTable[360975] = bhCheckWall2Box_0x25fbf0; // 0x260844 - g_ps2RecompiledFunctionTable[360976] = bhCheckWall2Box_0x25fbf0; // 0x260848 - g_ps2RecompiledFunctionTable[360977] = bhCheckWall2Box_0x25fbf0; // 0x26084c - g_ps2RecompiledFunctionTable[360978] = bhCheckWall2Box_0x25fbf0; // 0x260850 - g_ps2RecompiledFunctionTable[360979] = bhCheckWall2Box_0x25fbf0; // 0x260854 - g_ps2RecompiledFunctionTable[360980] = bhCheckWall2Box_0x25fbf0; // 0x260858 - g_ps2RecompiledFunctionTable[360981] = bhCheckWall2Box_0x25fbf0; // 0x26085c - g_ps2RecompiledFunctionTable[360982] = bhCheckWall2Box_0x25fbf0; // 0x260860 - g_ps2RecompiledFunctionTable[360983] = bhCheckWall2Box_0x25fbf0; // 0x260864 - g_ps2RecompiledFunctionTable[360984] = bhCheckWall2Box_0x25fbf0; // 0x260868 - g_ps2RecompiledFunctionTable[360985] = bhCheckWall2Box_0x25fbf0; // 0x26086c - g_ps2RecompiledFunctionTable[360986] = bhCheckWall2Box_0x25fbf0; // 0x260870 - g_ps2RecompiledFunctionTable[360987] = bhCheckWall2Box_0x25fbf0; // 0x260874 - g_ps2RecompiledFunctionTable[360988] = bhCheckWall2Box_0x25fbf0; // 0x260878 - g_ps2RecompiledFunctionTable[360989] = bhCheckWall2Box_0x25fbf0; // 0x26087c - g_ps2RecompiledFunctionTable[360990] = bhCheckWall2Box_0x25fbf0; // 0x260880 - g_ps2RecompiledFunctionTable[360991] = bhCheckWall2Box_0x25fbf0; // 0x260884 - g_ps2RecompiledFunctionTable[360992] = bhCheckWall2Box_0x25fbf0; // 0x260888 - g_ps2RecompiledFunctionTable[360993] = bhCheckWall2Box_0x25fbf0; // 0x26088c - g_ps2RecompiledFunctionTable[360994] = bhCheckWall2Box_0x25fbf0; // 0x260890 - g_ps2RecompiledFunctionTable[360995] = bhCheckWall2Box_0x25fbf0; // 0x260894 - g_ps2RecompiledFunctionTable[360996] = bhCheckWall2Box_0x25fbf0; // 0x260898 - g_ps2RecompiledFunctionTable[360997] = bhCheckWall2Box_0x25fbf0; // 0x26089c - g_ps2RecompiledFunctionTable[360998] = bhCheckWall2Box_0x25fbf0; // 0x2608a0 - g_ps2RecompiledFunctionTable[360999] = bhCheckWall2Box_0x25fbf0; // 0x2608a4 - g_ps2RecompiledFunctionTable[361000] = bhCheckWall2Box_0x25fbf0; // 0x2608a8 - g_ps2RecompiledFunctionTable[361001] = bhCheckWall2Box_0x25fbf0; // 0x2608ac - g_ps2RecompiledFunctionTable[361002] = bhCheckWall2Box_0x25fbf0; // 0x2608b0 - g_ps2RecompiledFunctionTable[361003] = bhCheckWall2Box_0x25fbf0; // 0x2608b4 - g_ps2RecompiledFunctionTable[361004] = bhCheckWall2Box_0x25fbf0; // 0x2608b8 - g_ps2RecompiledFunctionTable[361005] = bhCheckWall2Box_0x25fbf0; // 0x2608bc - g_ps2RecompiledFunctionTable[361006] = bhCheckWall2Box_0x25fbf0; // 0x2608c0 - g_ps2RecompiledFunctionTable[361007] = bhCheckWall2Box_0x25fbf0; // 0x2608c4 - g_ps2RecompiledFunctionTable[361008] = bhCheckWall2Box_0x25fbf0; // 0x2608c8 - g_ps2RecompiledFunctionTable[361009] = bhCheckWall2Box_0x25fbf0; // 0x2608cc - g_ps2RecompiledFunctionTable[361010] = bhCheckWall2Box_0x25fbf0; // 0x2608d0 - g_ps2RecompiledFunctionTable[361011] = bhCheckWall2Box_0x25fbf0; // 0x2608d4 - g_ps2RecompiledFunctionTable[361012] = bhCheckWall2Box_0x25fbf0; // 0x2608d8 - g_ps2RecompiledFunctionTable[361013] = bhCheckWall2Box_0x25fbf0; // 0x2608dc - g_ps2RecompiledFunctionTable[361014] = bhCheckWall2Box_0x25fbf0; // 0x2608e0 - g_ps2RecompiledFunctionTable[361015] = bhCheckWall2Box_0x25fbf0; // 0x2608e4 - g_ps2RecompiledFunctionTable[361016] = bhCheckWall2Box_0x25fbf0; // 0x2608e8 - g_ps2RecompiledFunctionTable[361017] = bhCheckWall2Box_0x25fbf0; // 0x2608ec - g_ps2RecompiledFunctionTable[361018] = bhCheckWall2Box_0x25fbf0; // 0x2608f0 - g_ps2RecompiledFunctionTable[361019] = bhCheckWall2Box_0x25fbf0; // 0x2608f4 - g_ps2RecompiledFunctionTable[361020] = bhCheckWall2Box_0x25fbf0; // 0x2608f8 - g_ps2RecompiledFunctionTable[361021] = bhCheckWall2Box_0x25fbf0; // 0x2608fc - g_ps2RecompiledFunctionTable[361022] = bhCheckWall2Box_0x25fbf0; // 0x260900 - g_ps2RecompiledFunctionTable[361023] = bhCheckWall2Box_0x25fbf0; // 0x260904 - g_ps2RecompiledFunctionTable[361024] = bhCheckWall2Box_0x25fbf0; // 0x260908 - g_ps2RecompiledFunctionTable[361025] = bhCheckWall2Box_0x25fbf0; // 0x26090c - g_ps2RecompiledFunctionTable[361026] = bhCheckWall2Box_0x25fbf0; // 0x260910 - g_ps2RecompiledFunctionTable[361027] = bhCheckWall2Box_0x25fbf0; // 0x260914 - g_ps2RecompiledFunctionTable[361028] = bhCheckWall2Box_0x25fbf0; // 0x260918 - g_ps2RecompiledFunctionTable[361029] = bhCheckWall2Box_0x25fbf0; // 0x26091c - g_ps2RecompiledFunctionTable[361030] = bhCheckWall2Box_0x25fbf0; // 0x260920 - g_ps2RecompiledFunctionTable[361031] = bhCheckWall2Box_0x25fbf0; // 0x260924 - g_ps2RecompiledFunctionTable[361032] = bhCheckWall2Box_0x25fbf0; // 0x260928 - g_ps2RecompiledFunctionTable[361033] = bhCheckWall2Box_0x25fbf0; // 0x26092c - g_ps2RecompiledFunctionTable[361034] = bhCheckWall2Box_0x25fbf0; // 0x260930 - g_ps2RecompiledFunctionTable[361035] = bhCheckWall2Box_0x25fbf0; // 0x260934 - g_ps2RecompiledFunctionTable[361036] = bhCheckWall2Box_0x25fbf0; // 0x260938 - g_ps2RecompiledFunctionTable[361037] = bhCheckWall2Box_0x25fbf0; // 0x26093c - g_ps2RecompiledFunctionTable[361038] = bhCheckWall2Box_0x25fbf0; // 0x260940 - g_ps2RecompiledFunctionTable[361039] = bhCheckWall2Box_0x25fbf0; // 0x260944 - g_ps2RecompiledFunctionTable[361040] = bhCheckWall2Box_0x25fbf0; // 0x260948 - g_ps2RecompiledFunctionTable[361041] = bhCheckWall2Box_0x25fbf0; // 0x26094c - g_ps2RecompiledFunctionTable[361042] = bhCheckWall2Box_0x25fbf0; // 0x260950 - g_ps2RecompiledFunctionTable[361043] = bhCheckWall2Box_0x25fbf0; // 0x260954 - g_ps2RecompiledFunctionTable[361044] = bhCheckWall2Box_0x25fbf0; // 0x260958 - g_ps2RecompiledFunctionTable[361045] = bhCheckWall2Box_0x25fbf0; // 0x26095c - g_ps2RecompiledFunctionTable[361046] = bhCheckWall2Box_0x25fbf0; // 0x260960 - g_ps2RecompiledFunctionTable[361047] = bhCheckWall2Box_0x25fbf0; // 0x260964 - g_ps2RecompiledFunctionTable[361048] = bhCheckWall2Box_0x25fbf0; // 0x260968 - g_ps2RecompiledFunctionTable[361049] = bhCheckWall2Box_0x25fbf0; // 0x26096c - g_ps2RecompiledFunctionTable[361050] = bhCheckWall2Box_0x25fbf0; // 0x260970 - g_ps2RecompiledFunctionTable[361051] = bhCheckWall2Box_0x25fbf0; // 0x260974 - g_ps2RecompiledFunctionTable[361052] = bhCheckWall2Box_0x25fbf0; // 0x260978 - g_ps2RecompiledFunctionTable[361053] = bhCheckWall2Box_0x25fbf0; // 0x26097c - g_ps2RecompiledFunctionTable[361054] = bhCheckWall2Box_0x25fbf0; // 0x260980 - g_ps2RecompiledFunctionTable[361055] = bhCheckWall2Box_0x25fbf0; // 0x260984 - g_ps2RecompiledFunctionTable[361056] = bhCheckWall2Box_0x25fbf0; // 0x260988 - g_ps2RecompiledFunctionTable[361057] = bhCheckWall2Box_0x25fbf0; // 0x26098c - g_ps2RecompiledFunctionTable[361058] = bhCheckWall2Box_0x25fbf0; // 0x260990 - g_ps2RecompiledFunctionTable[361059] = bhCheckWall2Box_0x25fbf0; // 0x260994 - g_ps2RecompiledFunctionTable[361060] = bhCheckWall2Box_0x25fbf0; // 0x260998 - g_ps2RecompiledFunctionTable[361061] = bhCheckWall2Box_0x25fbf0; // 0x26099c - g_ps2RecompiledFunctionTable[361062] = bhCheckWall2Box_0x25fbf0; // 0x2609a0 - g_ps2RecompiledFunctionTable[361063] = bhCheckWall2Box_0x25fbf0; // 0x2609a4 - g_ps2RecompiledFunctionTable[361064] = bhCheckWall2Box_0x25fbf0; // 0x2609a8 - g_ps2RecompiledFunctionTable[361065] = bhCheckWall2Box_0x25fbf0; // 0x2609ac - g_ps2RecompiledFunctionTable[361066] = bhCheckWall2Box_0x25fbf0; // 0x2609b0 - g_ps2RecompiledFunctionTable[361067] = bhCheckWall2Box_0x25fbf0; // 0x2609b4 - g_ps2RecompiledFunctionTable[361068] = bhCheckWall2Box_0x25fbf0; // 0x2609b8 - g_ps2RecompiledFunctionTable[361069] = bhCheckWall2Box_0x25fbf0; // 0x2609bc - g_ps2RecompiledFunctionTable[361070] = bhCheckWall2Box_0x25fbf0; // 0x2609c0 - g_ps2RecompiledFunctionTable[361071] = bhCheckWall2Box_0x25fbf0; // 0x2609c4 - g_ps2RecompiledFunctionTable[361072] = bhCheckWall2Box_0x25fbf0; // 0x2609c8 - g_ps2RecompiledFunctionTable[361073] = bhCheckWall2Box_0x25fbf0; // 0x2609cc - g_ps2RecompiledFunctionTable[361074] = bhCheckWall2Box_0x25fbf0; // 0x2609d0 - g_ps2RecompiledFunctionTable[361075] = bhCheckWall2Box_0x25fbf0; // 0x2609d4 - g_ps2RecompiledFunctionTable[361076] = bhCheckWall2Box_0x25fbf0; // 0x2609d8 - g_ps2RecompiledFunctionTable[361077] = bhCheckWall2Box_0x25fbf0; // 0x2609dc - g_ps2RecompiledFunctionTable[361078] = bhCheckWall2Box_0x25fbf0; // 0x2609e0 - g_ps2RecompiledFunctionTable[361079] = bhCheckWall2Box_0x25fbf0; // 0x2609e4 - g_ps2RecompiledFunctionTable[361080] = bhCheckWall2Box_0x25fbf0; // 0x2609e8 - g_ps2RecompiledFunctionTable[361081] = bhCheckWall2Box_0x25fbf0; // 0x2609ec - g_ps2RecompiledFunctionTable[361082] = bhCheckWall2Box_0x25fbf0; // 0x2609f0 - g_ps2RecompiledFunctionTable[361083] = bhCheckWall2Box_0x25fbf0; // 0x2609f4 - g_ps2RecompiledFunctionTable[361084] = bhCheckWall2Box_0x25fbf0; // 0x2609f8 - g_ps2RecompiledFunctionTable[361085] = bhCheckWall2Box_0x25fbf0; // 0x2609fc - g_ps2RecompiledFunctionTable[361086] = bhCheckWall2Box_0x25fbf0; // 0x260a00 - g_ps2RecompiledFunctionTable[361087] = bhCheckWall2Box_0x25fbf0; // 0x260a04 - g_ps2RecompiledFunctionTable[361088] = bhCheckWall2Box_0x25fbf0; // 0x260a08 - g_ps2RecompiledFunctionTable[361089] = bhCheckWall2Box_0x25fbf0; // 0x260a0c - g_ps2RecompiledFunctionTable[361090] = bhCheckWall2Box_0x25fbf0; // 0x260a10 - g_ps2RecompiledFunctionTable[361091] = bhCheckWall2Box_0x25fbf0; // 0x260a14 - g_ps2RecompiledFunctionTable[361092] = bhCheckWall2Box_0x25fbf0; // 0x260a18 - g_ps2RecompiledFunctionTable[361093] = bhCheckWall2Box_0x25fbf0; // 0x260a1c - g_ps2RecompiledFunctionTable[361094] = bhCheckWall2Box_0x25fbf0; // 0x260a20 - g_ps2RecompiledFunctionTable[361095] = bhCheckWall2Box_0x25fbf0; // 0x260a24 - g_ps2RecompiledFunctionTable[361096] = bhCheckWall2Box_0x25fbf0; // 0x260a28 - g_ps2RecompiledFunctionTable[361097] = bhCheckWall2Box_0x25fbf0; // 0x260a2c - g_ps2RecompiledFunctionTable[361098] = bhCheckWall2Box_0x25fbf0; // 0x260a30 - g_ps2RecompiledFunctionTable[361099] = bhCheckWall2Box_0x25fbf0; // 0x260a34 - g_ps2RecompiledFunctionTable[361100] = bhCheckWall2Box_0x25fbf0; // 0x260a38 - g_ps2RecompiledFunctionTable[361101] = bhCheckWall2Box_0x25fbf0; // 0x260a3c - g_ps2RecompiledFunctionTable[361102] = bhCheckWall2Box_0x25fbf0; // 0x260a40 - g_ps2RecompiledFunctionTable[361103] = bhCheckWall2Box_0x25fbf0; // 0x260a44 - g_ps2RecompiledFunctionTable[361104] = bhCheckWall2Box_0x25fbf0; // 0x260a48 - g_ps2RecompiledFunctionTable[361105] = bhCheckWall2Box_0x25fbf0; // 0x260a4c - g_ps2RecompiledFunctionTable[361106] = bhCheckWall2Box_0x25fbf0; // 0x260a50 - g_ps2RecompiledFunctionTable[361107] = bhCheckWall2Box_0x25fbf0; // 0x260a54 - g_ps2RecompiledFunctionTable[361108] = bhCheckWall2Box_0x25fbf0; // 0x260a58 - g_ps2RecompiledFunctionTable[361109] = bhCheckWall2Box_0x25fbf0; // 0x260a5c - g_ps2RecompiledFunctionTable[361110] = bhCheckWall2Box_0x25fbf0; // 0x260a60 - g_ps2RecompiledFunctionTable[361111] = bhCheckWall2Box_0x25fbf0; // 0x260a64 - g_ps2RecompiledFunctionTable[361112] = bhCheckWall2Box_0x25fbf0; // 0x260a68 - g_ps2RecompiledFunctionTable[361113] = bhCheckWall2Box_0x25fbf0; // 0x260a6c - g_ps2RecompiledFunctionTable[361114] = bhCheckWall2Box_0x25fbf0; // 0x260a70 - g_ps2RecompiledFunctionTable[361115] = bhCheckWall2Box_0x25fbf0; // 0x260a74 - g_ps2RecompiledFunctionTable[361116] = bhCheckWall2Box_0x25fbf0; // 0x260a78 - g_ps2RecompiledFunctionTable[361117] = bhCheckWall2Box_0x25fbf0; // 0x260a7c - g_ps2RecompiledFunctionTable[361118] = bhCheckWall2Box_0x25fbf0; // 0x260a80 - g_ps2RecompiledFunctionTable[361119] = bhCheckWall2Box_0x25fbf0; // 0x260a84 - g_ps2RecompiledFunctionTable[361120] = bhCheckWall2Box_0x25fbf0; // 0x260a88 - g_ps2RecompiledFunctionTable[361121] = bhCheckWall2Box_0x25fbf0; // 0x260a8c - g_ps2RecompiledFunctionTable[361122] = bhCheckWall2Box_0x25fbf0; // 0x260a90 - g_ps2RecompiledFunctionTable[361123] = bhCheckWall2Box_0x25fbf0; // 0x260a94 - g_ps2RecompiledFunctionTable[361124] = bhCheckWall2Box_0x25fbf0; // 0x260a98 - g_ps2RecompiledFunctionTable[361125] = bhCheckWall2Box_0x25fbf0; // 0x260a9c - g_ps2RecompiledFunctionTable[361126] = bhCheckWall2Box_0x25fbf0; // 0x260aa0 - g_ps2RecompiledFunctionTable[361127] = bhCheckWall2Box_0x25fbf0; // 0x260aa4 - g_ps2RecompiledFunctionTable[361128] = bhCheckWall2Box_0x25fbf0; // 0x260aa8 - g_ps2RecompiledFunctionTable[361129] = bhCheckWall2Box_0x25fbf0; // 0x260aac - g_ps2RecompiledFunctionTable[361130] = bhCheckWall2Box_0x25fbf0; // 0x260ab0 - g_ps2RecompiledFunctionTable[361131] = bhCheckWall2Box_0x25fbf0; // 0x260ab4 - g_ps2RecompiledFunctionTable[361132] = bhCheckWall2Box_0x25fbf0; // 0x260ab8 - g_ps2RecompiledFunctionTable[361133] = bhCheckWall2Box_0x25fbf0; // 0x260abc - g_ps2RecompiledFunctionTable[361134] = bhCheckWall2Box_0x25fbf0; // 0x260ac0 - g_ps2RecompiledFunctionTable[361135] = bhCheckWall2Box_0x25fbf0; // 0x260ac4 - g_ps2RecompiledFunctionTable[361136] = bhCheckWall2Box_0x25fbf0; // 0x260ac8 - g_ps2RecompiledFunctionTable[361137] = bhCheckWall2Box_0x25fbf0; // 0x260acc - g_ps2RecompiledFunctionTable[361138] = bhCheckWall2Box_0x25fbf0; // 0x260ad0 - g_ps2RecompiledFunctionTable[361139] = bhCheckWall2Box_0x25fbf0; // 0x260ad4 - g_ps2RecompiledFunctionTable[361140] = bhCheckWall2Box_0x25fbf0; // 0x260ad8 - g_ps2RecompiledFunctionTable[361141] = bhCheckWall2Box_0x25fbf0; // 0x260adc - g_ps2RecompiledFunctionTable[361142] = bhCheckWall2Box_0x25fbf0; // 0x260ae0 - g_ps2RecompiledFunctionTable[361143] = bhCheckWall2Box_0x25fbf0; // 0x260ae4 - g_ps2RecompiledFunctionTable[361144] = bhCheckWall2Box_0x25fbf0; // 0x260ae8 - g_ps2RecompiledFunctionTable[361145] = bhCheckWall2Box_0x25fbf0; // 0x260aec - g_ps2RecompiledFunctionTable[361146] = bhCheckWall2Box_0x25fbf0; // 0x260af0 - g_ps2RecompiledFunctionTable[361147] = bhCheckWall2Box_0x25fbf0; // 0x260af4 - g_ps2RecompiledFunctionTable[361148] = bhCheckWall2Box_0x25fbf0; // 0x260af8 - g_ps2RecompiledFunctionTable[361149] = bhCheckWall2Box_0x25fbf0; // 0x260afc - g_ps2RecompiledFunctionTable[361150] = bhCheckWall2Box_0x25fbf0; // 0x260b00 - g_ps2RecompiledFunctionTable[361151] = bhCheckWall2Box_0x25fbf0; // 0x260b04 - g_ps2RecompiledFunctionTable[361152] = bhCheckWall2Box_0x25fbf0; // 0x260b08 - g_ps2RecompiledFunctionTable[361153] = bhCheckWall2Box_0x25fbf0; // 0x260b0c - g_ps2RecompiledFunctionTable[361154] = bhCheckWall2Box_0x25fbf0; // 0x260b10 - g_ps2RecompiledFunctionTable[361155] = bhCheckWall2Box_0x25fbf0; // 0x260b14 - g_ps2RecompiledFunctionTable[361156] = bhCheckWall2Box_0x25fbf0; // 0x260b18 - g_ps2RecompiledFunctionTable[361157] = bhCheckWall2Box_0x25fbf0; // 0x260b1c - g_ps2RecompiledFunctionTable[361158] = bhCheckWall2Box_0x25fbf0; // 0x260b20 - g_ps2RecompiledFunctionTable[361159] = bhCheckWall2Box_0x25fbf0; // 0x260b24 - g_ps2RecompiledFunctionTable[361160] = bhCheckWall2Box_0x25fbf0; // 0x260b28 - g_ps2RecompiledFunctionTable[361161] = bhCheckWall2Box_0x25fbf0; // 0x260b2c - g_ps2RecompiledFunctionTable[361162] = bhCheckWall2Box_0x25fbf0; // 0x260b30 - g_ps2RecompiledFunctionTable[361163] = bhCheckWall2Box_0x25fbf0; // 0x260b34 - g_ps2RecompiledFunctionTable[361164] = bhCheckWall2Box_0x25fbf0; // 0x260b38 - g_ps2RecompiledFunctionTable[361165] = bhCheckWall2Box_0x25fbf0; // 0x260b3c - g_ps2RecompiledFunctionTable[361166] = bhCheckWall2Box_0x25fbf0; // 0x260b40 - g_ps2RecompiledFunctionTable[361167] = bhCheckWall2Box_0x25fbf0; // 0x260b44 - g_ps2RecompiledFunctionTable[361168] = bhCheckWall2Box_0x25fbf0; // 0x260b48 - g_ps2RecompiledFunctionTable[361169] = bhCheckWall2Box_0x25fbf0; // 0x260b4c - g_ps2RecompiledFunctionTable[361170] = bhCheckWall2Box_0x25fbf0; // 0x260b50 - g_ps2RecompiledFunctionTable[361171] = bhCheckWall2Box_0x25fbf0; // 0x260b54 - g_ps2RecompiledFunctionTable[361172] = bhCheckWall2Box_0x25fbf0; // 0x260b58 - g_ps2RecompiledFunctionTable[361173] = bhCheckWall2Box_0x25fbf0; // 0x260b5c - g_ps2RecompiledFunctionTable[361174] = bhCheckWall2Box_0x25fbf0; // 0x260b60 - g_ps2RecompiledFunctionTable[361175] = bhCheckWall2Box_0x25fbf0; // 0x260b64 - g_ps2RecompiledFunctionTable[361176] = bhCheckWall2Box_0x25fbf0; // 0x260b68 - g_ps2RecompiledFunctionTable[361177] = bhCheckWall2Box_0x25fbf0; // 0x260b6c - g_ps2RecompiledFunctionTable[361178] = bhCheckWall2Box_0x25fbf0; // 0x260b70 - g_ps2RecompiledFunctionTable[361179] = bhCheckWall2Box_0x25fbf0; // 0x260b74 - g_ps2RecompiledFunctionTable[361180] = bhCheckWall2Box_0x25fbf0; // 0x260b78 - g_ps2RecompiledFunctionTable[361181] = bhCheckWall2Box_0x25fbf0; // 0x260b7c - g_ps2RecompiledFunctionTable[361182] = bhCheckWall2Box_0x25fbf0; // 0x260b80 - g_ps2RecompiledFunctionTable[361183] = bhCheckWall2Box_0x25fbf0; // 0x260b84 - g_ps2RecompiledFunctionTable[361184] = bhCheckWall2Box_0x25fbf0; // 0x260b88 - g_ps2RecompiledFunctionTable[361185] = bhCheckWall2Box_0x25fbf0; // 0x260b8c - g_ps2RecompiledFunctionTable[361186] = bhCheckWall2Box_0x25fbf0; // 0x260b90 - g_ps2RecompiledFunctionTable[361187] = bhCheckWall2Box_0x25fbf0; // 0x260b94 - g_ps2RecompiledFunctionTable[361188] = bhCheckWall2Box_0x25fbf0; // 0x260b98 - g_ps2RecompiledFunctionTable[361189] = bhCheckWall2Box_0x25fbf0; // 0x260b9c - g_ps2RecompiledFunctionTable[361190] = bhCheckWall2Box_0x25fbf0; // 0x260ba0 - g_ps2RecompiledFunctionTable[361191] = bhCheckWall2Box_0x25fbf0; // 0x260ba4 - g_ps2RecompiledFunctionTable[361192] = bhCheckWall2Box_0x25fbf0; // 0x260ba8 - g_ps2RecompiledFunctionTable[361193] = bhCheckWall2Box_0x25fbf0; // 0x260bac - g_ps2RecompiledFunctionTable[361194] = bhCheckWall2Box_0x25fbf0; // 0x260bb0 - g_ps2RecompiledFunctionTable[361195] = bhCheckWall2Box_0x25fbf0; // 0x260bb4 - g_ps2RecompiledFunctionTable[361196] = bhCheckWall2Box_0x25fbf0; // 0x260bb8 - g_ps2RecompiledFunctionTable[361197] = bhCheckWall2Box_0x25fbf0; // 0x260bbc - g_ps2RecompiledFunctionTable[361198] = bhCheckWall2Box_0x25fbf0; // 0x260bc0 - g_ps2RecompiledFunctionTable[361199] = bhCheckWall2Box_0x25fbf0; // 0x260bc4 - g_ps2RecompiledFunctionTable[361200] = bhCheckWall2Box_0x25fbf0; // 0x260bc8 - g_ps2RecompiledFunctionTable[361201] = bhCheckWall2Box_0x25fbf0; // 0x260bcc - g_ps2RecompiledFunctionTable[361202] = bhCheckWall2Box_0x25fbf0; // 0x260bd0 - g_ps2RecompiledFunctionTable[361203] = bhCheckWall2Box_0x25fbf0; // 0x260bd4 - g_ps2RecompiledFunctionTable[361204] = bhCheckWall2Box_0x25fbf0; // 0x260bd8 - g_ps2RecompiledFunctionTable[361205] = bhCheckWall2Box_0x25fbf0; // 0x260bdc - g_ps2RecompiledFunctionTable[361206] = bhCheckWall2Box_0x25fbf0; // 0x260be0 - g_ps2RecompiledFunctionTable[361207] = bhCheckWall2Box_0x25fbf0; // 0x260be4 - g_ps2RecompiledFunctionTable[361208] = bhCheckWall2Box_0x25fbf0; // 0x260be8 - g_ps2RecompiledFunctionTable[361209] = bhCheckWall2Box_0x25fbf0; // 0x260bec - g_ps2RecompiledFunctionTable[361210] = bhCheckWall2Box_0x25fbf0; // 0x260bf0 - g_ps2RecompiledFunctionTable[361211] = bhCheckWall2Box_0x25fbf0; // 0x260bf4 - g_ps2RecompiledFunctionTable[361212] = bhCheckWall2Box_0x25fbf0; // 0x260bf8 - g_ps2RecompiledFunctionTable[361213] = bhCheckWall2Box_0x25fbf0; // 0x260bfc - g_ps2RecompiledFunctionTable[361214] = bhCheckWall2Box_0x25fbf0; // 0x260c00 - g_ps2RecompiledFunctionTable[361215] = bhCheckWall2Box_0x25fbf0; // 0x260c04 - g_ps2RecompiledFunctionTable[361216] = bhCheckWall2Box_0x25fbf0; // 0x260c08 - g_ps2RecompiledFunctionTable[361217] = bhCheckWall2Box_0x25fbf0; // 0x260c0c - g_ps2RecompiledFunctionTable[361218] = bhCheckWall2Box_0x25fbf0; // 0x260c10 - g_ps2RecompiledFunctionTable[361219] = bhCheckWall2Box_0x25fbf0; // 0x260c14 - g_ps2RecompiledFunctionTable[361220] = bhCheckWall2Box_0x25fbf0; // 0x260c18 - g_ps2RecompiledFunctionTable[361221] = bhCheckWall2Box_0x25fbf0; // 0x260c1c - g_ps2RecompiledFunctionTable[361222] = bhCheckWall2Box_0x25fbf0; // 0x260c20 - g_ps2RecompiledFunctionTable[361223] = bhCheckWall2Box_0x25fbf0; // 0x260c24 - g_ps2RecompiledFunctionTable[361224] = bhCheckWall2Box_0x25fbf0; // 0x260c28 - g_ps2RecompiledFunctionTable[361225] = bhCheckWall2Box_0x25fbf0; // 0x260c2c - g_ps2RecompiledFunctionTable[361226] = bhCheckWall2Box_0x25fbf0; // 0x260c30 - g_ps2RecompiledFunctionTable[361227] = bhCheckWall2Box_0x25fbf0; // 0x260c34 - g_ps2RecompiledFunctionTable[361228] = bhCheckWall2Box_0x25fbf0; // 0x260c38 - g_ps2RecompiledFunctionTable[361229] = bhCheckWall2Box_0x25fbf0; // 0x260c3c - g_ps2RecompiledFunctionTable[361230] = bhCheckWall2Box_0x25fbf0; // 0x260c40 - g_ps2RecompiledFunctionTable[361231] = bhCheckWall2Box_0x25fbf0; // 0x260c44 - g_ps2RecompiledFunctionTable[361232] = bhCheckWall2Box_0x25fbf0; // 0x260c48 - g_ps2RecompiledFunctionTable[361233] = bhCheckWall2Box_0x25fbf0; // 0x260c4c - g_ps2RecompiledFunctionTable[361234] = bhCheckWall2Box_0x25fbf0; // 0x260c50 - g_ps2RecompiledFunctionTable[361235] = bhCheckWall2Box_0x25fbf0; // 0x260c54 - g_ps2RecompiledFunctionTable[361236] = bhCheckWall2Box_0x25fbf0; // 0x260c58 - g_ps2RecompiledFunctionTable[361237] = bhCheckWall2Box_0x25fbf0; // 0x260c5c - g_ps2RecompiledFunctionTable[361238] = bhCheckWall2Box_0x25fbf0; // 0x260c60 - g_ps2RecompiledFunctionTable[361239] = bhCheckWall2Box_0x25fbf0; // 0x260c64 - g_ps2RecompiledFunctionTable[361240] = bhCheckWall2Box_0x25fbf0; // 0x260c68 - g_ps2RecompiledFunctionTable[361241] = bhCheckWall2Box_0x25fbf0; // 0x260c6c - g_ps2RecompiledFunctionTable[361242] = bhCheckWall2Box_0x25fbf0; // 0x260c70 - g_ps2RecompiledFunctionTable[361243] = bhCheckWall2Box_0x25fbf0; // 0x260c74 - g_ps2RecompiledFunctionTable[361244] = bhCheckWall2Box_0x25fbf0; // 0x260c78 - g_ps2RecompiledFunctionTable[361245] = bhCheckWall2Box_0x25fbf0; // 0x260c7c - g_ps2RecompiledFunctionTable[361246] = bhCheckWall2Box_0x25fbf0; // 0x260c80 - g_ps2RecompiledFunctionTable[361247] = bhCheckWall2Box_0x25fbf0; // 0x260c84 - g_ps2RecompiledFunctionTable[361248] = bhCheckWall2Box_0x25fbf0; // 0x260c88 - g_ps2RecompiledFunctionTable[361249] = bhCheckWall2Box_0x25fbf0; // 0x260c8c - g_ps2RecompiledFunctionTable[361250] = bhCheckWall2Box_0x25fbf0; // 0x260c90 - g_ps2RecompiledFunctionTable[361251] = bhCheckWall2Box_0x25fbf0; // 0x260c94 - g_ps2RecompiledFunctionTable[361252] = bhCheckWall2Box_0x25fbf0; // 0x260c98 - g_ps2RecompiledFunctionTable[361253] = bhCheckWall2Box_0x25fbf0; // 0x260c9c - g_ps2RecompiledFunctionTable[361254] = bhCheckWall2Box_0x25fbf0; // 0x260ca0 - g_ps2RecompiledFunctionTable[361255] = bhCheckWall2Box_0x25fbf0; // 0x260ca4 - g_ps2RecompiledFunctionTable[361256] = bhCheckWall2Box_0x25fbf0; // 0x260ca8 - g_ps2RecompiledFunctionTable[361257] = bhCheckWall2Box_0x25fbf0; // 0x260cac - g_ps2RecompiledFunctionTable[361258] = bhCheckWall2Box_0x25fbf0; // 0x260cb0 - g_ps2RecompiledFunctionTable[361259] = bhCheckWall2Box_0x25fbf0; // 0x260cb4 - g_ps2RecompiledFunctionTable[361260] = bhCheckWall2Box_0x25fbf0; // 0x260cb8 - g_ps2RecompiledFunctionTable[361261] = bhCheckWall2Box_0x25fbf0; // 0x260cbc - g_ps2RecompiledFunctionTable[361262] = bhCheckWall2Box_0x25fbf0; // 0x260cc0 - g_ps2RecompiledFunctionTable[361263] = bhCheckWall2Box_0x25fbf0; // 0x260cc4 - g_ps2RecompiledFunctionTable[361264] = bhCheckWall2Box_0x25fbf0; // 0x260cc8 - g_ps2RecompiledFunctionTable[361265] = bhCheckWall2Box_0x25fbf0; // 0x260ccc - g_ps2RecompiledFunctionTable[361266] = bhCheckWall2Box_0x25fbf0; // 0x260cd0 - g_ps2RecompiledFunctionTable[361267] = bhCheckWall2Box_0x25fbf0; // 0x260cd4 - g_ps2RecompiledFunctionTable[361268] = bhCheckWall2Box_0x25fbf0; // 0x260cd8 - g_ps2RecompiledFunctionTable[361269] = bhCheckWall2Box_0x25fbf0; // 0x260cdc - g_ps2RecompiledFunctionTable[361270] = bhCheckWall2Box_0x25fbf0; // 0x260ce0 - g_ps2RecompiledFunctionTable[361271] = bhCheckWall2Box_0x25fbf0; // 0x260ce4 - g_ps2RecompiledFunctionTable[361272] = bhCheckWall2Box_0x25fbf0; // 0x260ce8 - g_ps2RecompiledFunctionTable[361273] = bhCheckWall2Box_0x25fbf0; // 0x260cec - g_ps2RecompiledFunctionTable[361274] = bhCheckWall2Box_0x25fbf0; // 0x260cf0 - g_ps2RecompiledFunctionTable[361275] = bhCheckWall2Box_0x25fbf0; // 0x260cf4 - g_ps2RecompiledFunctionTable[361276] = bhCheckWall2Box_0x25fbf0; // 0x260cf8 - g_ps2RecompiledFunctionTable[361277] = bhCheckWall2Box_0x25fbf0; // 0x260cfc - g_ps2RecompiledFunctionTable[361278] = bhCheckWall2Box_0x25fbf0; // 0x260d00 - g_ps2RecompiledFunctionTable[361279] = bhCheckWall2Box_0x25fbf0; // 0x260d04 - g_ps2RecompiledFunctionTable[361280] = bhCheckWall2Box_0x25fbf0; // 0x260d08 - g_ps2RecompiledFunctionTable[361281] = bhCheckWall2Box_0x25fbf0; // 0x260d0c - g_ps2RecompiledFunctionTable[361282] = bhCheckWall2Box_0x25fbf0; // 0x260d10 - g_ps2RecompiledFunctionTable[361283] = bhCheckWall2Box_0x25fbf0; // 0x260d14 - g_ps2RecompiledFunctionTable[361284] = bhCheckWall2Box_0x25fbf0; // 0x260d18 - g_ps2RecompiledFunctionTable[361285] = bhCheckWall2Box_0x25fbf0; // 0x260d1c - g_ps2RecompiledFunctionTable[361286] = bhCheckWall2Box_0x25fbf0; // 0x260d20 - g_ps2RecompiledFunctionTable[361287] = bhCheckWall2Box_0x25fbf0; // 0x260d24 - g_ps2RecompiledFunctionTable[361288] = bhCheckWall2Box_0x25fbf0; // 0x260d28 - g_ps2RecompiledFunctionTable[361289] = bhCheckWall2Box_0x25fbf0; // 0x260d2c - g_ps2RecompiledFunctionTable[361290] = bhCheckWall2Box_0x25fbf0; // 0x260d30 - g_ps2RecompiledFunctionTable[361291] = bhCheckWall2Box_0x25fbf0; // 0x260d34 - g_ps2RecompiledFunctionTable[361292] = bhCheckWall2Box_0x25fbf0; // 0x260d38 - g_ps2RecompiledFunctionTable[361293] = bhCheckWall2Box_0x25fbf0; // 0x260d3c - g_ps2RecompiledFunctionTable[361294] = bhCheckWall2Box_0x25fbf0; // 0x260d40 - g_ps2RecompiledFunctionTable[361295] = bhCheckWall2Box_0x25fbf0; // 0x260d44 - g_ps2RecompiledFunctionTable[361296] = bhCheckWall2Box_0x25fbf0; // 0x260d48 - g_ps2RecompiledFunctionTable[361297] = bhCheckWall2Box_0x25fbf0; // 0x260d4c - g_ps2RecompiledFunctionTable[361298] = bhCheckWall2Box_0x25fbf0; // 0x260d50 - g_ps2RecompiledFunctionTable[361299] = bhCheckWall2Box_0x25fbf0; // 0x260d54 - g_ps2RecompiledFunctionTable[361300] = bhCheckWall2Box_0x25fbf0; // 0x260d58 - g_ps2RecompiledFunctionTable[361301] = bhCheckWall2Box_0x25fbf0; // 0x260d5c - g_ps2RecompiledFunctionTable[361302] = bhCheckWall2Box_0x25fbf0; // 0x260d60 - g_ps2RecompiledFunctionTable[361303] = bhCheckWall2Box_0x25fbf0; // 0x260d64 - g_ps2RecompiledFunctionTable[361304] = bhCheckWall2Box_0x25fbf0; // 0x260d68 - g_ps2RecompiledFunctionTable[361305] = bhCheckWall2Box_0x25fbf0; // 0x260d6c - g_ps2RecompiledFunctionTable[361306] = bhCheckWall2Box_0x25fbf0; // 0x260d70 - g_ps2RecompiledFunctionTable[361307] = bhCheckWall2Box_0x25fbf0; // 0x260d74 - g_ps2RecompiledFunctionTable[361308] = bhCheckWall2Box_0x25fbf0; // 0x260d78 - g_ps2RecompiledFunctionTable[361309] = bhCheckWall2Box_0x25fbf0; // 0x260d7c - g_ps2RecompiledFunctionTable[361310] = bhCheckWall2Box_0x25fbf0; // 0x260d80 - g_ps2RecompiledFunctionTable[361311] = bhCheckWall2Box_0x25fbf0; // 0x260d84 - g_ps2RecompiledFunctionTable[361312] = bhCheckWall2Box_0x25fbf0; // 0x260d88 - g_ps2RecompiledFunctionTable[361313] = bhCheckWall2Box_0x25fbf0; // 0x260d8c - g_ps2RecompiledFunctionTable[361314] = bhCheckWall2Box_0x25fbf0; // 0x260d90 - g_ps2RecompiledFunctionTable[361315] = bhCheckWall2Box_0x25fbf0; // 0x260d94 - g_ps2RecompiledFunctionTable[361316] = bhCheckWall2Box_0x25fbf0; // 0x260d98 - g_ps2RecompiledFunctionTable[361317] = bhCheckWall2Box_0x25fbf0; // 0x260d9c - g_ps2RecompiledFunctionTable[361318] = bhCheckWall2Box_0x25fbf0; // 0x260da0 - g_ps2RecompiledFunctionTable[361319] = bhCheckWall2Box_0x25fbf0; // 0x260da4 - g_ps2RecompiledFunctionTable[361320] = bhCheckWall2Box_0x25fbf0; // 0x260da8 - g_ps2RecompiledFunctionTable[361321] = bhCheckWall2Box_0x25fbf0; // 0x260dac - g_ps2RecompiledFunctionTable[361322] = bhCheckWall2Box_0x25fbf0; // 0x260db0 - g_ps2RecompiledFunctionTable[361323] = bhCheckWall2Box_0x25fbf0; // 0x260db4 - g_ps2RecompiledFunctionTable[361324] = bhCheckWall2Box_0x25fbf0; // 0x260db8 - g_ps2RecompiledFunctionTable[361325] = bhCheckWall2Box_0x25fbf0; // 0x260dbc - g_ps2RecompiledFunctionTable[361326] = bhCheckWall2Box_0x25fbf0; // 0x260dc0 - g_ps2RecompiledFunctionTable[361327] = bhCheckWall2Box_0x25fbf0; // 0x260dc4 - g_ps2RecompiledFunctionTable[361328] = bhCheckWall2Box_0x25fbf0; // 0x260dc8 - g_ps2RecompiledFunctionTable[361329] = bhCheckWall2Box_0x25fbf0; // 0x260dcc - g_ps2RecompiledFunctionTable[361330] = bhCheckWall2Box_0x25fbf0; // 0x260dd0 - g_ps2RecompiledFunctionTable[361331] = bhCheckWall2Box_0x25fbf0; // 0x260dd4 - g_ps2RecompiledFunctionTable[361332] = bhCheckWall2Box_0x25fbf0; // 0x260dd8 - g_ps2RecompiledFunctionTable[361333] = bhCheckWall2Box_0x25fbf0; // 0x260ddc - g_ps2RecompiledFunctionTable[361334] = bhCheckWall2Box_0x25fbf0; // 0x260de0 - g_ps2RecompiledFunctionTable[361335] = bhCheckWall2Box_0x25fbf0; // 0x260de4 - g_ps2RecompiledFunctionTable[361336] = bhCheckWall2Box_0x25fbf0; // 0x260de8 - g_ps2RecompiledFunctionTable[361337] = bhCheckWall2Box_0x25fbf0; // 0x260dec - g_ps2RecompiledFunctionTable[361338] = bhCheckWall2Box_0x25fbf0; // 0x260df0 - g_ps2RecompiledFunctionTable[361339] = bhCheckWall2Box_0x25fbf0; // 0x260df4 - g_ps2RecompiledFunctionTable[361340] = bhCheckWall2Box_0x25fbf0; // 0x260df8 - g_ps2RecompiledFunctionTable[361341] = bhCheckWall2Box_0x25fbf0; // 0x260dfc - g_ps2RecompiledFunctionTable[361342] = bhCheckWall2Box_0x25fbf0; // 0x260e00 - g_ps2RecompiledFunctionTable[361343] = bhCheckWall2Box_0x25fbf0; // 0x260e04 - g_ps2RecompiledFunctionTable[361344] = bhCheckWall2Box_0x25fbf0; // 0x260e08 - g_ps2RecompiledFunctionTable[361345] = bhCheckWall2Box_0x25fbf0; // 0x260e0c - g_ps2RecompiledFunctionTable[361346] = bhCheckWall2Box_0x25fbf0; // 0x260e10 - g_ps2RecompiledFunctionTable[361347] = bhCheckWall2Box_0x25fbf0; // 0x260e14 - g_ps2RecompiledFunctionTable[361348] = bhCheckWall2Box_0x25fbf0; // 0x260e18 - g_ps2RecompiledFunctionTable[361349] = bhCheckWall2Box_0x25fbf0; // 0x260e1c - g_ps2RecompiledFunctionTable[361350] = bhCheckWall2Box_0x25fbf0; // 0x260e20 - g_ps2RecompiledFunctionTable[361351] = bhCheckWall2Box_0x25fbf0; // 0x260e24 - g_ps2RecompiledFunctionTable[361352] = bhCheckWall2Box_0x25fbf0; // 0x260e28 - g_ps2RecompiledFunctionTable[361353] = bhCheckWall2Box_0x25fbf0; // 0x260e2c - g_ps2RecompiledFunctionTable[361354] = bhCheckWall2Box_0x25fbf0; // 0x260e30 - g_ps2RecompiledFunctionTable[361355] = bhCheckWall2Box_0x25fbf0; // 0x260e34 - g_ps2RecompiledFunctionTable[361356] = bhCheckWall2Box_0x25fbf0; // 0x260e38 - g_ps2RecompiledFunctionTable[361357] = bhCheckWall2Box_0x25fbf0; // 0x260e3c - g_ps2RecompiledFunctionTable[361358] = bhCheckWall2Box_0x25fbf0; // 0x260e40 - g_ps2RecompiledFunctionTable[361359] = bhCheckWall2Box_0x25fbf0; // 0x260e44 - g_ps2RecompiledFunctionTable[361360] = bhCheckWall2Box_0x25fbf0; // 0x260e48 - g_ps2RecompiledFunctionTable[361361] = bhCheckWall2Box_0x25fbf0; // 0x260e4c - g_ps2RecompiledFunctionTable[361362] = bhCheckWall2Box_0x25fbf0; // 0x260e50 - g_ps2RecompiledFunctionTable[361363] = bhCheckWall2Box_0x25fbf0; // 0x260e54 - g_ps2RecompiledFunctionTable[361364] = bhCheckWall2Box_0x25fbf0; // 0x260e58 - g_ps2RecompiledFunctionTable[361365] = bhCheckWall2Box_0x25fbf0; // 0x260e5c - g_ps2RecompiledFunctionTable[361366] = bhCheckWall2Box_0x25fbf0; // 0x260e60 - g_ps2RecompiledFunctionTable[361367] = bhCheckWall2Box_0x25fbf0; // 0x260e64 - g_ps2RecompiledFunctionTable[361368] = bhCheckWall2Box_0x25fbf0; // 0x260e68 - g_ps2RecompiledFunctionTable[361369] = bhCheckWall2Box_0x25fbf0; // 0x260e6c - g_ps2RecompiledFunctionTable[361370] = bhCheckWall2Box_0x25fbf0; // 0x260e70 - g_ps2RecompiledFunctionTable[361371] = bhCheckWall2Box_0x25fbf0; // 0x260e74 - g_ps2RecompiledFunctionTable[361372] = bhCheckWall2Box_0x25fbf0; // 0x260e78 - g_ps2RecompiledFunctionTable[361373] = bhCheckWall2Box_0x25fbf0; // 0x260e7c - g_ps2RecompiledFunctionTable[361374] = bhCheckWall2Box_0x25fbf0; // 0x260e80 - g_ps2RecompiledFunctionTable[361375] = bhCheckWall2Box_0x25fbf0; // 0x260e84 - g_ps2RecompiledFunctionTable[361376] = bhCheckWall2Box_0x25fbf0; // 0x260e88 - g_ps2RecompiledFunctionTable[361377] = bhCheckWall2Box_0x25fbf0; // 0x260e8c - g_ps2RecompiledFunctionTable[361378] = bhCheckWall2Box_0x25fbf0; // 0x260e90 - g_ps2RecompiledFunctionTable[361379] = bhCheckWall2Box_0x25fbf0; // 0x260e94 - g_ps2RecompiledFunctionTable[361380] = bhCheckWall2Box_0x25fbf0; // 0x260e98 - g_ps2RecompiledFunctionTable[361381] = bhCheckWall2Box_0x25fbf0; // 0x260e9c - g_ps2RecompiledFunctionTable[361382] = bhCheckWall2Box_0x25fbf0; // 0x260ea0 - g_ps2RecompiledFunctionTable[361383] = bhCheckWall2Box_0x25fbf0; // 0x260ea4 - g_ps2RecompiledFunctionTable[361384] = bhCheckWall2Box_0x25fbf0; // 0x260ea8 - g_ps2RecompiledFunctionTable[361385] = bhCheckWall2Box_0x25fbf0; // 0x260eac - g_ps2RecompiledFunctionTable[361386] = bhCheckWall2Box_0x25fbf0; // 0x260eb0 - g_ps2RecompiledFunctionTable[361387] = bhCheckWall2Box_0x25fbf0; // 0x260eb4 - g_ps2RecompiledFunctionTable[361388] = bhCheckWall2Box_0x25fbf0; // 0x260eb8 - g_ps2RecompiledFunctionTable[361389] = bhCheckWall2Box_0x25fbf0; // 0x260ebc - g_ps2RecompiledFunctionTable[361390] = bhCheckWall2Box_0x25fbf0; // 0x260ec0 - g_ps2RecompiledFunctionTable[361391] = bhCheckWall2Box_0x25fbf0; // 0x260ec4 - g_ps2RecompiledFunctionTable[361392] = bhCheckWall2Box_0x25fbf0; // 0x260ec8 - g_ps2RecompiledFunctionTable[361393] = bhCheckWall2Box_0x25fbf0; // 0x260ecc - g_ps2RecompiledFunctionTable[361394] = bhCheckWall2Box_0x25fbf0; // 0x260ed0 - g_ps2RecompiledFunctionTable[361395] = bhCheckWall2Box_0x25fbf0; // 0x260ed4 - g_ps2RecompiledFunctionTable[361396] = bhCheckWall2Box_0x25fbf0; // 0x260ed8 - g_ps2RecompiledFunctionTable[361397] = bhCheckWall2Box_0x25fbf0; // 0x260edc - g_ps2RecompiledFunctionTable[361398] = bhCheckWall2Box_0x25fbf0; // 0x260ee0 - g_ps2RecompiledFunctionTable[361399] = bhCheckWall2Box_0x25fbf0; // 0x260ee4 - g_ps2RecompiledFunctionTable[361400] = bhCheckWall2Box_0x25fbf0; // 0x260ee8 - g_ps2RecompiledFunctionTable[361401] = bhCheckWall2Box_0x25fbf0; // 0x260eec - g_ps2RecompiledFunctionTable[361402] = bhCheckWall2Box_0x25fbf0; // 0x260ef0 - g_ps2RecompiledFunctionTable[361403] = bhCheckWall2Box_0x25fbf0; // 0x260ef4 - g_ps2RecompiledFunctionTable[361404] = bhCheckWall2Box_0x25fbf0; // 0x260ef8 - g_ps2RecompiledFunctionTable[361405] = bhCheckWall2Box_0x25fbf0; // 0x260efc - g_ps2RecompiledFunctionTable[361406] = bhCheckWall2Box_0x25fbf0; // 0x260f00 - g_ps2RecompiledFunctionTable[361407] = bhCheckWall2Box_0x25fbf0; // 0x260f04 - g_ps2RecompiledFunctionTable[361408] = bhCheckWall2Box_0x25fbf0; // 0x260f08 - g_ps2RecompiledFunctionTable[361409] = bhCheckWall2Box_0x25fbf0; // 0x260f0c - g_ps2RecompiledFunctionTable[361410] = bhCheckWall2Box_0x25fbf0; // 0x260f10 - g_ps2RecompiledFunctionTable[361411] = bhCheckWall2Box_0x25fbf0; // 0x260f14 - g_ps2RecompiledFunctionTable[361412] = bhCheckWall2Box_0x25fbf0; // 0x260f18 - g_ps2RecompiledFunctionTable[361413] = bhCheckWall2Box_0x25fbf0; // 0x260f1c - g_ps2RecompiledFunctionTable[361414] = bhCheckWall2Box_0x25fbf0; // 0x260f20 - g_ps2RecompiledFunctionTable[361415] = bhCheckWall2Box_0x25fbf0; // 0x260f24 - g_ps2RecompiledFunctionTable[361416] = bhCheckWall2Box_0x25fbf0; // 0x260f28 - g_ps2RecompiledFunctionTable[361417] = bhCheckWall2Box_0x25fbf0; // 0x260f2c - g_ps2RecompiledFunctionTable[361418] = bhCheckWall2Box_0x25fbf0; // 0x260f30 - g_ps2RecompiledFunctionTable[361419] = bhCheckWall2Box_0x25fbf0; // 0x260f34 - g_ps2RecompiledFunctionTable[361420] = bhCheckWall2Box_0x25fbf0; // 0x260f38 - g_ps2RecompiledFunctionTable[361421] = bhCheckWall2Box_0x25fbf0; // 0x260f3c - g_ps2RecompiledFunctionTable[361422] = bhCheckWall2Box_0x25fbf0; // 0x260f40 - g_ps2RecompiledFunctionTable[361423] = bhCheckWall2Box_0x25fbf0; // 0x260f44 - g_ps2RecompiledFunctionTable[361424] = bhCheckWall2Box_0x25fbf0; // 0x260f48 - g_ps2RecompiledFunctionTable[361425] = bhCheckWall2Box_0x25fbf0; // 0x260f4c - g_ps2RecompiledFunctionTable[361426] = bhCheckWall2Box_0x25fbf0; // 0x260f50 - g_ps2RecompiledFunctionTable[361427] = bhCheckWall2Box_0x25fbf0; // 0x260f54 - g_ps2RecompiledFunctionTable[361428] = bhCheckWall2Box_0x25fbf0; // 0x260f58 - g_ps2RecompiledFunctionTable[361429] = bhCheckWall2Box_0x25fbf0; // 0x260f5c - g_ps2RecompiledFunctionTable[361430] = bhCheckWall2Box_0x25fbf0; // 0x260f60 - g_ps2RecompiledFunctionTable[361431] = bhCheckWall2Box_0x25fbf0; // 0x260f64 - g_ps2RecompiledFunctionTable[361432] = bhCheckWall2Box_0x25fbf0; // 0x260f68 - g_ps2RecompiledFunctionTable[361433] = bhCheckWall2Box_0x25fbf0; // 0x260f6c - g_ps2RecompiledFunctionTable[361434] = bhCheckWall2Box_0x25fbf0; // 0x260f70 - g_ps2RecompiledFunctionTable[361435] = bhCheckWall2Box_0x25fbf0; // 0x260f74 - g_ps2RecompiledFunctionTable[361436] = bhCheckWall2Box_0x25fbf0; // 0x260f78 - g_ps2RecompiledFunctionTable[361437] = bhCheckWall2Box_0x25fbf0; // 0x260f7c - g_ps2RecompiledFunctionTable[361438] = bhCheckWall2Box_0x25fbf0; // 0x260f80 - g_ps2RecompiledFunctionTable[361439] = bhCheckWall2Box_0x25fbf0; // 0x260f84 - g_ps2RecompiledFunctionTable[361440] = bhCheckWall2Box_0x25fbf0; // 0x260f88 - g_ps2RecompiledFunctionTable[361441] = bhCheckWall2Box_0x25fbf0; // 0x260f8c - g_ps2RecompiledFunctionTable[361442] = bhCheckWall2Box_0x25fbf0; // 0x260f90 - g_ps2RecompiledFunctionTable[361443] = bhCheckWall2Box_0x25fbf0; // 0x260f94 - g_ps2RecompiledFunctionTable[361444] = bhCheckWall2Box_0x25fbf0; // 0x260f98 - g_ps2RecompiledFunctionTable[361445] = bhCheckWall2Box_0x25fbf0; // 0x260f9c - g_ps2RecompiledFunctionTable[361446] = bhCheckWall2Box_0x25fbf0; // 0x260fa0 - g_ps2RecompiledFunctionTable[361447] = bhCheckWall2Box_0x25fbf0; // 0x260fa4 - g_ps2RecompiledFunctionTable[361448] = bhCheckWall2Box_0x25fbf0; // 0x260fa8 - g_ps2RecompiledFunctionTable[361449] = bhCheckWall2Box_0x25fbf0; // 0x260fac - g_ps2RecompiledFunctionTable[361450] = bhCheckWall2Box_0x25fbf0; // 0x260fb0 - g_ps2RecompiledFunctionTable[361451] = bhCheckWall2Box_0x25fbf0; // 0x260fb4 - g_ps2RecompiledFunctionTable[361452] = bhCheckWall2Box_0x25fbf0; // 0x260fb8 - g_ps2RecompiledFunctionTable[361453] = bhCheckWall2Box_0x25fbf0; // 0x260fbc - g_ps2RecompiledFunctionTable[361454] = bhCheckWall2Box_0x25fbf0; // 0x260fc0 - g_ps2RecompiledFunctionTable[361455] = bhCheckWall2Box_0x25fbf0; // 0x260fc4 - g_ps2RecompiledFunctionTable[361456] = bhCheckWall2Box_0x25fbf0; // 0x260fc8 - g_ps2RecompiledFunctionTable[361457] = bhCheckWall2Box_0x25fbf0; // 0x260fcc - g_ps2RecompiledFunctionTable[361458] = bhCheckWall2Box_0x25fbf0; // 0x260fd0 - g_ps2RecompiledFunctionTable[361459] = bhCheckWall2Box_0x25fbf0; // 0x260fd4 - g_ps2RecompiledFunctionTable[361460] = bhCheckWall2Box_0x25fbf0; // 0x260fd8 - g_ps2RecompiledFunctionTable[361461] = bhCheckWall2Box_0x25fbf0; // 0x260fdc - g_ps2RecompiledFunctionTable[361462] = bhCheckWall2Box_0x25fbf0; // 0x260fe0 - g_ps2RecompiledFunctionTable[361463] = bhCheckWall2Box_0x25fbf0; // 0x260fe4 - g_ps2RecompiledFunctionTable[361464] = bhCheckWall2Box_0x25fbf0; // 0x260fe8 - g_ps2RecompiledFunctionTable[361465] = bhCheckWall2Box_0x25fbf0; // 0x260fec - g_ps2RecompiledFunctionTable[361466] = bhCheckWall2Box_0x25fbf0; // 0x260ff0 - g_ps2RecompiledFunctionTable[361467] = bhCheckWall2Box_0x25fbf0; // 0x260ff4 - g_ps2RecompiledFunctionTable[361468] = bhCheckWall2Box_0x25fbf0; // 0x260ff8 - g_ps2RecompiledFunctionTable[361469] = bhCheckWall2Box_0x25fbf0; // 0x260ffc - g_ps2RecompiledFunctionTable[361470] = bhCheckWall2Box_0x25fbf0; // 0x261000 - g_ps2RecompiledFunctionTable[361471] = bhCheckWall2Box_0x25fbf0; // 0x261004 - g_ps2RecompiledFunctionTable[361472] = bhCheckWall2Box_0x25fbf0; // 0x261008 - g_ps2RecompiledFunctionTable[361473] = bhCheckWall2Box_0x25fbf0; // 0x26100c - g_ps2RecompiledFunctionTable[361474] = bhCheckWall2Box_0x25fbf0; // 0x261010 - g_ps2RecompiledFunctionTable[361475] = bhCheckWall2Box_0x25fbf0; // 0x261014 - g_ps2RecompiledFunctionTable[361476] = bhCheckWall2Box_0x25fbf0; // 0x261018 - g_ps2RecompiledFunctionTable[361477] = bhCheckWall2Box_0x25fbf0; // 0x26101c - g_ps2RecompiledFunctionTable[361478] = bhCheckWall2Box_0x25fbf0; // 0x261020 - g_ps2RecompiledFunctionTable[361479] = bhCheckWall2Box_0x25fbf0; // 0x261024 - g_ps2RecompiledFunctionTable[361480] = bhCheckWall2Box_0x25fbf0; // 0x261028 - g_ps2RecompiledFunctionTable[361481] = bhCheckWall2Box_0x25fbf0; // 0x26102c - g_ps2RecompiledFunctionTable[361482] = bhCheckWall2Box_0x25fbf0; // 0x261030 - g_ps2RecompiledFunctionTable[361483] = bhCheckWall2Box_0x25fbf0; // 0x261034 - g_ps2RecompiledFunctionTable[361484] = bhCheckWall2Box_0x25fbf0; // 0x261038 - g_ps2RecompiledFunctionTable[361485] = bhCheckWall2Box_0x25fbf0; // 0x26103c - g_ps2RecompiledFunctionTable[361486] = bhCheckWall2Box_0x25fbf0; // 0x261040 - g_ps2RecompiledFunctionTable[361487] = bhCheckWall2Box_0x25fbf0; // 0x261044 - g_ps2RecompiledFunctionTable[361488] = bhCheckWall2Box_0x25fbf0; // 0x261048 - g_ps2RecompiledFunctionTable[361489] = bhCheckWall2Box_0x25fbf0; // 0x26104c - g_ps2RecompiledFunctionTable[361490] = bhCheckWall2Box_0x25fbf0; // 0x261050 - g_ps2RecompiledFunctionTable[361491] = bhCheckWall2Box_0x25fbf0; // 0x261054 - g_ps2RecompiledFunctionTable[361492] = bhCheckWall2Box_0x25fbf0; // 0x261058 - g_ps2RecompiledFunctionTable[361493] = bhCheckWall2Box_0x25fbf0; // 0x26105c - g_ps2RecompiledFunctionTable[361494] = bhCheckWall2Box_0x25fbf0; // 0x261060 - g_ps2RecompiledFunctionTable[361495] = bhCheckWall2Box_0x25fbf0; // 0x261064 - g_ps2RecompiledFunctionTable[361496] = bhCheckWall2Box_0x25fbf0; // 0x261068 - g_ps2RecompiledFunctionTable[361497] = bhCheckWall2Box_0x25fbf0; // 0x26106c - g_ps2RecompiledFunctionTable[361498] = bhCheckWall2Box_0x25fbf0; // 0x261070 - g_ps2RecompiledFunctionTable[361499] = bhCheckWall2Box_0x25fbf0; // 0x261074 - g_ps2RecompiledFunctionTable[361500] = bhCheckWall2Box_0x25fbf0; // 0x261078 - g_ps2RecompiledFunctionTable[361501] = bhCheckWall2Box_0x25fbf0; // 0x26107c - g_ps2RecompiledFunctionTable[361502] = bhCheckWall2Box_0x25fbf0; // 0x261080 - g_ps2RecompiledFunctionTable[361503] = bhCheckWall2Box_0x25fbf0; // 0x261084 - g_ps2RecompiledFunctionTable[361504] = bhCheckWall2Box_0x25fbf0; // 0x261088 - g_ps2RecompiledFunctionTable[361505] = bhCheckWall2Box_0x25fbf0; // 0x26108c - g_ps2RecompiledFunctionTable[361506] = bhCheckWall2Box_0x25fbf0; // 0x261090 - g_ps2RecompiledFunctionTable[361507] = bhCheckWall2Box_0x25fbf0; // 0x261094 - g_ps2RecompiledFunctionTable[361508] = bhCheckWall2Box_0x25fbf0; // 0x261098 - g_ps2RecompiledFunctionTable[361509] = bhCheckWall2Box_0x25fbf0; // 0x26109c - g_ps2RecompiledFunctionTable[361510] = bhCheckWall2Box_0x25fbf0; // 0x2610a0 - g_ps2RecompiledFunctionTable[361511] = bhCheckWall2Box_0x25fbf0; // 0x2610a4 - g_ps2RecompiledFunctionTable[361512] = bhCheckWall2Box_0x25fbf0; // 0x2610a8 - g_ps2RecompiledFunctionTable[361513] = bhCheckWall2Box_0x25fbf0; // 0x2610ac - g_ps2RecompiledFunctionTable[361514] = bhCheckWall2Box_0x25fbf0; // 0x2610b0 - g_ps2RecompiledFunctionTable[361515] = bhCheckWall2Box_0x25fbf0; // 0x2610b4 - g_ps2RecompiledFunctionTable[361516] = bhCheckWall2Box_0x25fbf0; // 0x2610b8 - g_ps2RecompiledFunctionTable[361517] = bhCheckWall2Box_0x25fbf0; // 0x2610bc - g_ps2RecompiledFunctionTable[361518] = bhCheckWall2Box_0x25fbf0; // 0x2610c0 - g_ps2RecompiledFunctionTable[361519] = bhCheckWall2Box_0x25fbf0; // 0x2610c4 - g_ps2RecompiledFunctionTable[361520] = bhCheckWall2Box_0x25fbf0; // 0x2610c8 - g_ps2RecompiledFunctionTable[361521] = bhCheckWall2Box_0x25fbf0; // 0x2610cc - g_ps2RecompiledFunctionTable[361522] = bhCheckWall2Box_0x25fbf0; // 0x2610d0 - g_ps2RecompiledFunctionTable[361523] = bhCheckWall2Box_0x25fbf0; // 0x2610d4 - g_ps2RecompiledFunctionTable[361524] = bhCheckWall2Box_0x25fbf0; // 0x2610d8 - g_ps2RecompiledFunctionTable[361525] = bhCheckWall2Box_0x25fbf0; // 0x2610dc - g_ps2RecompiledFunctionTable[361526] = bhCheckWall2Box_0x25fbf0; // 0x2610e0 - g_ps2RecompiledFunctionTable[361527] = bhCheckWall2Box_0x25fbf0; // 0x2610e4 - g_ps2RecompiledFunctionTable[361528] = bhCheckWall2Box_0x25fbf0; // 0x2610e8 - g_ps2RecompiledFunctionTable[361529] = bhCheckWall2Box_0x25fbf0; // 0x2610ec - g_ps2RecompiledFunctionTable[361530] = bhCheckWall2Box_0x25fbf0; // 0x2610f0 - g_ps2RecompiledFunctionTable[361531] = bhCheckWall2Box_0x25fbf0; // 0x2610f4 - g_ps2RecompiledFunctionTable[361532] = bhCheckWall2Box_0x25fbf0; // 0x2610f8 - g_ps2RecompiledFunctionTable[361533] = bhCheckWall2Box_0x25fbf0; // 0x2610fc - g_ps2RecompiledFunctionTable[361534] = bhCheckWall2Box_0x25fbf0; // 0x261100 - g_ps2RecompiledFunctionTable[361535] = bhCheckWall2Box_0x25fbf0; // 0x261104 - g_ps2RecompiledFunctionTable[361536] = bhCheckWall2Box_0x25fbf0; // 0x261108 - g_ps2RecompiledFunctionTable[361537] = bhCheckWall2Box_0x25fbf0; // 0x26110c - g_ps2RecompiledFunctionTable[361538] = bhCheckWall2Box_0x25fbf0; // 0x261110 - g_ps2RecompiledFunctionTable[361539] = bhCheckWall2Box_0x25fbf0; // 0x261114 - g_ps2RecompiledFunctionTable[361540] = bhCheckWall2Box_0x25fbf0; // 0x261118 - g_ps2RecompiledFunctionTable[361541] = bhCheckWall2Box_0x25fbf0; // 0x26111c - g_ps2RecompiledFunctionTable[361542] = bhCheckWall2Box_0x25fbf0; // 0x261120 - g_ps2RecompiledFunctionTable[361543] = bhCheckWall2Box_0x25fbf0; // 0x261124 - g_ps2RecompiledFunctionTable[361544] = bhCheckWall2Box_0x25fbf0; // 0x261128 - g_ps2RecompiledFunctionTable[361545] = bhCheckWall2Box_0x25fbf0; // 0x26112c - g_ps2RecompiledFunctionTable[361546] = bhCheckWall2Box_0x25fbf0; // 0x261130 - g_ps2RecompiledFunctionTable[361547] = bhCheckWall2Box_0x25fbf0; // 0x261134 - g_ps2RecompiledFunctionTable[361548] = bhCheckWall2Box_0x25fbf0; // 0x261138 - g_ps2RecompiledFunctionTable[361549] = bhCheckWall2Box_0x25fbf0; // 0x26113c - g_ps2RecompiledFunctionTable[361550] = bhCheckWall2Box_0x25fbf0; // 0x261140 - g_ps2RecompiledFunctionTable[361551] = bhCheckWall2Box_0x25fbf0; // 0x261144 - g_ps2RecompiledFunctionTable[361552] = bhCheckWall2Box_0x25fbf0; // 0x261148 - g_ps2RecompiledFunctionTable[361553] = bhCheckWall2Box_0x25fbf0; // 0x26114c - g_ps2RecompiledFunctionTable[361554] = bhCheckWall2Box_0x25fbf0; // 0x261150 - g_ps2RecompiledFunctionTable[361555] = bhCheckWall2Box_0x25fbf0; // 0x261154 - g_ps2RecompiledFunctionTable[361556] = bhCheckWall2Box_0x25fbf0; // 0x261158 - g_ps2RecompiledFunctionTable[361557] = bhCheckWall2Box_0x25fbf0; // 0x26115c - g_ps2RecompiledFunctionTable[361558] = bhCheckWall2Box_0x25fbf0; // 0x261160 - g_ps2RecompiledFunctionTable[361559] = bhCheckWall2Box_0x25fbf0; // 0x261164 - g_ps2RecompiledFunctionTable[361560] = bhCheckWall2Box_0x25fbf0; // 0x261168 - g_ps2RecompiledFunctionTable[361561] = bhCheckWall2Box_0x25fbf0; // 0x26116c - g_ps2RecompiledFunctionTable[361562] = bhCheckWall2Box_0x25fbf0; // 0x261170 - g_ps2RecompiledFunctionTable[361563] = bhCheckWall2Box_0x25fbf0; // 0x261174 - g_ps2RecompiledFunctionTable[361564] = bhCheckWall2Box_0x25fbf0; // 0x261178 - g_ps2RecompiledFunctionTable[361565] = bhCheckWall2Box_0x25fbf0; // 0x26117c - g_ps2RecompiledFunctionTable[361566] = bhCheckWall2Box_0x25fbf0; // 0x261180 - g_ps2RecompiledFunctionTable[361567] = bhCheckWall2Box_0x25fbf0; // 0x261184 - g_ps2RecompiledFunctionTable[361568] = bhCheckWall2Box_0x25fbf0; // 0x261188 - g_ps2RecompiledFunctionTable[361569] = bhCheckWall2Box_0x25fbf0; // 0x26118c - g_ps2RecompiledFunctionTable[361570] = bhCheckWall2Box_0x25fbf0; // 0x261190 - g_ps2RecompiledFunctionTable[361571] = bhCheckWall2Box_0x25fbf0; // 0x261194 - g_ps2RecompiledFunctionTable[361572] = bhCheckWall2Box_0x25fbf0; // 0x261198 - g_ps2RecompiledFunctionTable[361573] = bhCheckWall2Box_0x25fbf0; // 0x26119c - g_ps2RecompiledFunctionTable[361574] = bhCheckWall2Box_0x25fbf0; // 0x2611a0 - g_ps2RecompiledFunctionTable[361575] = bhCheckWall2Box_0x25fbf0; // 0x2611a4 - g_ps2RecompiledFunctionTable[361576] = bhCheckWall2Box_0x25fbf0; // 0x2611a8 - g_ps2RecompiledFunctionTable[361577] = bhCheckWall2Box_0x25fbf0; // 0x2611ac - g_ps2RecompiledFunctionTable[361578] = bhCheckWall2Box_0x25fbf0; // 0x2611b0 - g_ps2RecompiledFunctionTable[361579] = bhCheckWall2Box_0x25fbf0; // 0x2611b4 - g_ps2RecompiledFunctionTable[361580] = bhCheckWall2Box_0x25fbf0; // 0x2611b8 - g_ps2RecompiledFunctionTable[361581] = bhCheckWall2Box_0x25fbf0; // 0x2611bc - g_ps2RecompiledFunctionTable[361582] = bhCheckWall2Box_0x25fbf0; // 0x2611c0 - g_ps2RecompiledFunctionTable[361583] = bhCheckWall2Box_0x25fbf0; // 0x2611c4 - g_ps2RecompiledFunctionTable[361584] = bhCheckWall2Box_0x25fbf0; // 0x2611c8 - g_ps2RecompiledFunctionTable[361585] = bhCheckWall2Box_0x25fbf0; // 0x2611cc - g_ps2RecompiledFunctionTable[361586] = bhCheckWall2Box_0x25fbf0; // 0x2611d0 - g_ps2RecompiledFunctionTable[361587] = bhCheckWall2Box_0x25fbf0; // 0x2611d4 - g_ps2RecompiledFunctionTable[361588] = bhCheckWall2Box_0x25fbf0; // 0x2611d8 - g_ps2RecompiledFunctionTable[361589] = bhCheckWall2Box_0x25fbf0; // 0x2611dc - g_ps2RecompiledFunctionTable[361590] = bhCheckWall2Box_0x25fbf0; // 0x2611e0 - g_ps2RecompiledFunctionTable[361591] = bhCheckWall2Box_0x25fbf0; // 0x2611e4 - g_ps2RecompiledFunctionTable[361592] = bhCheckWall2Box_0x25fbf0; // 0x2611e8 - g_ps2RecompiledFunctionTable[361593] = bhCheckWall2Box_0x25fbf0; // 0x2611ec - g_ps2RecompiledFunctionTable[361594] = bhCheckWall2Box_0x25fbf0; // 0x2611f0 - g_ps2RecompiledFunctionTable[361595] = bhCheckWall2Box_0x25fbf0; // 0x2611f4 - g_ps2RecompiledFunctionTable[361596] = bhCheckWall2Box_0x25fbf0; // 0x2611f8 - g_ps2RecompiledFunctionTable[361597] = bhCheckWall2Box_0x25fbf0; // 0x2611fc - g_ps2RecompiledFunctionTable[361598] = bhCheckWall2Box_0x25fbf0; // 0x261200 - g_ps2RecompiledFunctionTable[361599] = bhCheckWall2Box_0x25fbf0; // 0x261204 - g_ps2RecompiledFunctionTable[361600] = bhCheckWall2Box_0x25fbf0; // 0x261208 - g_ps2RecompiledFunctionTable[361601] = bhCheckWall2Box_0x25fbf0; // 0x26120c - g_ps2RecompiledFunctionTable[361602] = bhCheckWall2Box_0x25fbf0; // 0x261210 - g_ps2RecompiledFunctionTable[361603] = bhCheckWall2Box_0x25fbf0; // 0x261214 - g_ps2RecompiledFunctionTable[361604] = bhCheckWall2Box_0x25fbf0; // 0x261218 - g_ps2RecompiledFunctionTable[361605] = bhCheckWall2Box_0x25fbf0; // 0x26121c - g_ps2RecompiledFunctionTable[361606] = bhCheckWall2Box_0x25fbf0; // 0x261220 - g_ps2RecompiledFunctionTable[361607] = bhCheckWall2Box_0x25fbf0; // 0x261224 - g_ps2RecompiledFunctionTable[361608] = bhCheckWall2Box_0x25fbf0; // 0x261228 - g_ps2RecompiledFunctionTable[361609] = bhCheckWall2Box_0x25fbf0; // 0x26122c - g_ps2RecompiledFunctionTable[361610] = bhCheckWall2Box_0x25fbf0; // 0x261230 - g_ps2RecompiledFunctionTable[361611] = bhCheckWall2Box_0x25fbf0; // 0x261234 - g_ps2RecompiledFunctionTable[361612] = bhCheckWall2Box_0x25fbf0; // 0x261238 - g_ps2RecompiledFunctionTable[361613] = bhCheckWall2Box_0x25fbf0; // 0x26123c - g_ps2RecompiledFunctionTable[361614] = bhCheckWall2Box_0x25fbf0; // 0x261240 - g_ps2RecompiledFunctionTable[361615] = bhCheckWall2Box_0x25fbf0; // 0x261244 - g_ps2RecompiledFunctionTable[361616] = bhCheckWall2Box_0x25fbf0; // 0x261248 - g_ps2RecompiledFunctionTable[361617] = bhCheckWall2Box_0x25fbf0; // 0x26124c - g_ps2RecompiledFunctionTable[361618] = bhCheckWall2Box_0x25fbf0; // 0x261250 - g_ps2RecompiledFunctionTable[361619] = bhCheckWall2Box_0x25fbf0; // 0x261254 - g_ps2RecompiledFunctionTable[361620] = bhCheckWall2Box_0x25fbf0; // 0x261258 - g_ps2RecompiledFunctionTable[361621] = bhCheckWall2Box_0x25fbf0; // 0x26125c - g_ps2RecompiledFunctionTable[361622] = bhCheckWall2Box_0x25fbf0; // 0x261260 - g_ps2RecompiledFunctionTable[361623] = bhCheckWall2Box_0x25fbf0; // 0x261264 - g_ps2RecompiledFunctionTable[361624] = bhCheckWall2Box_0x25fbf0; // 0x261268 - g_ps2RecompiledFunctionTable[361625] = bhCheckWall2Box_0x25fbf0; // 0x26126c - g_ps2RecompiledFunctionTable[361626] = bhCheckWall2Box_0x25fbf0; // 0x261270 - g_ps2RecompiledFunctionTable[361627] = bhCheckWall2Box_0x25fbf0; // 0x261274 - g_ps2RecompiledFunctionTable[361628] = bhCheckWall2Box_0x25fbf0; // 0x261278 - g_ps2RecompiledFunctionTable[361629] = bhCheckWall2Box_0x25fbf0; // 0x26127c - g_ps2RecompiledFunctionTable[361630] = bhCheckWall2Box_0x25fbf0; // 0x261280 - g_ps2RecompiledFunctionTable[361631] = bhCheckWall2Box_0x25fbf0; // 0x261284 - g_ps2RecompiledFunctionTable[361632] = bhCheckWall2Box_0x25fbf0; // 0x261288 - g_ps2RecompiledFunctionTable[361633] = bhCheckWall2Box_0x25fbf0; // 0x26128c - g_ps2RecompiledFunctionTable[361634] = bhCheckWall2Box_0x25fbf0; // 0x261290 - g_ps2RecompiledFunctionTable[361635] = bhCheckWall2Box_0x25fbf0; // 0x261294 - g_ps2RecompiledFunctionTable[361636] = bhCheckWall2Box_0x25fbf0; // 0x261298 - g_ps2RecompiledFunctionTable[361637] = bhCheckWall2Box_0x25fbf0; // 0x26129c - g_ps2RecompiledFunctionTable[361638] = bhCheckWall2Box_0x25fbf0; // 0x2612a0 - g_ps2RecompiledFunctionTable[361639] = bhCheckWall2Box_0x25fbf0; // 0x2612a4 - g_ps2RecompiledFunctionTable[361640] = bhCheckWall2Box_0x25fbf0; // 0x2612a8 - g_ps2RecompiledFunctionTable[361641] = bhCheckWall2Box_0x25fbf0; // 0x2612ac - g_ps2RecompiledFunctionTable[361642] = bhCheckWall2Box_0x25fbf0; // 0x2612b0 - g_ps2RecompiledFunctionTable[361643] = bhCheckWall2Box_0x25fbf0; // 0x2612b4 - g_ps2RecompiledFunctionTable[361644] = bhCheckWall2Box_0x25fbf0; // 0x2612b8 - g_ps2RecompiledFunctionTable[361645] = bhCheckWall2Box_0x25fbf0; // 0x2612bc - g_ps2RecompiledFunctionTable[361646] = bhCheckWall2Box_0x25fbf0; // 0x2612c0 - g_ps2RecompiledFunctionTable[361647] = bhCheckWall2Box_0x25fbf0; // 0x2612c4 - g_ps2RecompiledFunctionTable[361648] = bhCheckWall2Box_0x25fbf0; // 0x2612c8 - g_ps2RecompiledFunctionTable[361649] = bhCheckWall2Box_0x25fbf0; // 0x2612cc - g_ps2RecompiledFunctionTable[361650] = bhCheckWall2Box_0x25fbf0; // 0x2612d0 - g_ps2RecompiledFunctionTable[361651] = bhCheckWall2Box_0x25fbf0; // 0x2612d4 - g_ps2RecompiledFunctionTable[361652] = bhCheckWall2Box_0x25fbf0; // 0x2612d8 - g_ps2RecompiledFunctionTable[361653] = bhCheckWall2Box_0x25fbf0; // 0x2612dc - g_ps2RecompiledFunctionTable[361654] = bhCheckWall2Box_0x25fbf0; // 0x2612e0 - g_ps2RecompiledFunctionTable[361655] = bhCheckWall2Box_0x25fbf0; // 0x2612e4 - g_ps2RecompiledFunctionTable[361656] = bhCheckWall2Box_0x25fbf0; // 0x2612e8 - g_ps2RecompiledFunctionTable[361657] = bhCheckWall2Box_0x25fbf0; // 0x2612ec - g_ps2RecompiledFunctionTable[361658] = bhCheckWall2Box_0x25fbf0; // 0x2612f0 - g_ps2RecompiledFunctionTable[361659] = bhCheckWall2Box_0x25fbf0; // 0x2612f4 - g_ps2RecompiledFunctionTable[361660] = bhCheckWall2Box_0x25fbf0; // 0x2612f8 - g_ps2RecompiledFunctionTable[361661] = bhCheckWall2Box_0x25fbf0; // 0x2612fc - g_ps2RecompiledFunctionTable[361662] = bhCheckWall2Box_0x25fbf0; // 0x261300 - g_ps2RecompiledFunctionTable[361663] = bhCheckWall2Box_0x25fbf0; // 0x261304 - g_ps2RecompiledFunctionTable[361664] = bhCheckWall2Box_0x25fbf0; // 0x261308 - g_ps2RecompiledFunctionTable[361665] = bhCheckWall2Box_0x25fbf0; // 0x26130c - g_ps2RecompiledFunctionTable[361666] = bhCheckWall2Box_0x25fbf0; // 0x261310 - g_ps2RecompiledFunctionTable[361667] = bhCheckWall2Box_0x25fbf0; // 0x261314 - g_ps2RecompiledFunctionTable[361668] = bhCheckWall2Box_0x25fbf0; // 0x261318 - g_ps2RecompiledFunctionTable[361669] = bhCheckWall2Box_0x25fbf0; // 0x26131c - g_ps2RecompiledFunctionTable[361670] = bhCheckWall2Box_0x25fbf0; // 0x261320 - g_ps2RecompiledFunctionTable[361671] = bhCheckWall2Box_0x25fbf0; // 0x261324 - g_ps2RecompiledFunctionTable[361672] = bhCheckWall2Box_0x25fbf0; // 0x261328 - g_ps2RecompiledFunctionTable[361673] = bhCheckWall2Box_0x25fbf0; // 0x26132c - g_ps2RecompiledFunctionTable[361674] = bhCheckWall2Box_0x25fbf0; // 0x261330 - g_ps2RecompiledFunctionTable[361678] = bhCheckWallType_0x261340; // 0x261340 - g_ps2RecompiledFunctionTable[361679] = bhCheckWallType_0x261340; // 0x261344 - g_ps2RecompiledFunctionTable[361680] = bhCheckWallType_0x261340; // 0x261348 - g_ps2RecompiledFunctionTable[361681] = bhCheckWallType_0x261340; // 0x26134c - g_ps2RecompiledFunctionTable[361682] = bhCheckWallType_0x261340; // 0x261350 - g_ps2RecompiledFunctionTable[361683] = bhCheckWallType_0x261340; // 0x261354 - g_ps2RecompiledFunctionTable[361684] = bhCheckWallType_0x261340; // 0x261358 - g_ps2RecompiledFunctionTable[361685] = bhCheckWallType_0x261340; // 0x26135c - g_ps2RecompiledFunctionTable[361686] = bhCheckWallType_0x261340; // 0x261360 - g_ps2RecompiledFunctionTable[361687] = bhCheckWallType_0x261340; // 0x261364 - g_ps2RecompiledFunctionTable[361688] = bhCheckWallType_0x261340; // 0x261368 - g_ps2RecompiledFunctionTable[361689] = bhCheckWallType_0x261340; // 0x26136c - g_ps2RecompiledFunctionTable[361690] = bhCheckWallType_0x261340; // 0x261370 - g_ps2RecompiledFunctionTable[361691] = bhCheckWallType_0x261340; // 0x261374 - g_ps2RecompiledFunctionTable[361692] = bhCheckWallType_0x261340; // 0x261378 - g_ps2RecompiledFunctionTable[361693] = bhCheckWallType_0x261340; // 0x26137c - g_ps2RecompiledFunctionTable[361694] = bhCheckWallType_0x261340; // 0x261380 - g_ps2RecompiledFunctionTable[361695] = bhCheckWallType_0x261340; // 0x261384 - g_ps2RecompiledFunctionTable[361696] = bhCheckWallType_0x261340; // 0x261388 - g_ps2RecompiledFunctionTable[361697] = bhCheckWallType_0x261340; // 0x26138c - g_ps2RecompiledFunctionTable[361698] = bhCheckWallType_0x261340; // 0x261390 - g_ps2RecompiledFunctionTable[361699] = bhCheckWallType_0x261340; // 0x261394 - g_ps2RecompiledFunctionTable[361700] = bhCheckWallType_0x261340; // 0x261398 - g_ps2RecompiledFunctionTable[361701] = bhCheckWallType_0x261340; // 0x26139c - g_ps2RecompiledFunctionTable[361702] = bhCheckWallType_0x261340; // 0x2613a0 - g_ps2RecompiledFunctionTable[361703] = bhCheckWallType_0x261340; // 0x2613a4 - g_ps2RecompiledFunctionTable[361704] = bhCheckWallType_0x261340; // 0x2613a8 - g_ps2RecompiledFunctionTable[361705] = bhCheckWallType_0x261340; // 0x2613ac - g_ps2RecompiledFunctionTable[361706] = bhCheckWallType_0x261340; // 0x2613b0 - g_ps2RecompiledFunctionTable[361707] = bhCheckWallType_0x261340; // 0x2613b4 - g_ps2RecompiledFunctionTable[361708] = bhCheckWallType_0x261340; // 0x2613b8 - g_ps2RecompiledFunctionTable[361709] = bhCheckWallType_0x261340; // 0x2613bc - g_ps2RecompiledFunctionTable[361710] = bhCheckWallType_0x261340; // 0x2613c0 - g_ps2RecompiledFunctionTable[361711] = bhCheckWallType_0x261340; // 0x2613c4 - g_ps2RecompiledFunctionTable[361712] = bhCheckWallType_0x261340; // 0x2613c8 - g_ps2RecompiledFunctionTable[361713] = bhCheckWallType_0x261340; // 0x2613cc - g_ps2RecompiledFunctionTable[361714] = bhCheckWallType_0x261340; // 0x2613d0 - g_ps2RecompiledFunctionTable[361715] = bhCheckWallType_0x261340; // 0x2613d4 - g_ps2RecompiledFunctionTable[361716] = bhCheckWallType_0x261340; // 0x2613d8 - g_ps2RecompiledFunctionTable[361717] = bhCheckWallType_0x261340; // 0x2613dc - g_ps2RecompiledFunctionTable[361718] = bhCheckWallType_0x261340; // 0x2613e0 - g_ps2RecompiledFunctionTable[361719] = bhCheckWallType_0x261340; // 0x2613e4 - g_ps2RecompiledFunctionTable[361720] = bhCheckWallType_0x261340; // 0x2613e8 - g_ps2RecompiledFunctionTable[361721] = bhCheckWallType_0x261340; // 0x2613ec - g_ps2RecompiledFunctionTable[361722] = bhCheckWallType_0x261340; // 0x2613f0 - g_ps2RecompiledFunctionTable[361723] = bhCheckWallType_0x261340; // 0x2613f4 - g_ps2RecompiledFunctionTable[361724] = bhCheckWallType_0x261340; // 0x2613f8 - g_ps2RecompiledFunctionTable[361725] = bhCheckWallType_0x261340; // 0x2613fc - g_ps2RecompiledFunctionTable[361726] = bhCheckWallType_0x261340; // 0x261400 - g_ps2RecompiledFunctionTable[361727] = bhCheckWallType_0x261340; // 0x261404 - g_ps2RecompiledFunctionTable[361728] = bhCheckWallType_0x261340; // 0x261408 - g_ps2RecompiledFunctionTable[361729] = bhCheckWallType_0x261340; // 0x26140c - g_ps2RecompiledFunctionTable[361730] = bhCheckWallType_0x261340; // 0x261410 - g_ps2RecompiledFunctionTable[361731] = bhCheckWallType_0x261340; // 0x261414 - g_ps2RecompiledFunctionTable[361732] = bhCheckWallType_0x261340; // 0x261418 - g_ps2RecompiledFunctionTable[361733] = bhCheckWallType_0x261340; // 0x26141c - g_ps2RecompiledFunctionTable[361734] = bhCheckWallType_0x261340; // 0x261420 - g_ps2RecompiledFunctionTable[361735] = bhCheckWallType_0x261340; // 0x261424 - g_ps2RecompiledFunctionTable[361736] = bhCheckWallType_0x261340; // 0x261428 - g_ps2RecompiledFunctionTable[361737] = bhCheckWallType_0x261340; // 0x26142c - g_ps2RecompiledFunctionTable[361738] = bhCheckWallType_0x261340; // 0x261430 - g_ps2RecompiledFunctionTable[361739] = bhCheckWallType_0x261340; // 0x261434 - g_ps2RecompiledFunctionTable[361740] = bhCheckWallType_0x261340; // 0x261438 - g_ps2RecompiledFunctionTable[361741] = bhCheckWallType_0x261340; // 0x26143c - g_ps2RecompiledFunctionTable[361742] = bhCheckWallType_0x261340; // 0x261440 - g_ps2RecompiledFunctionTable[361743] = bhCheckWallType_0x261340; // 0x261444 - g_ps2RecompiledFunctionTable[361744] = bhCheckWallType_0x261340; // 0x261448 - g_ps2RecompiledFunctionTable[361745] = bhCheckWallType_0x261340; // 0x26144c - g_ps2RecompiledFunctionTable[361746] = bhCheckWallType_0x261340; // 0x261450 - g_ps2RecompiledFunctionTable[361747] = bhCheckWallType_0x261340; // 0x261454 - g_ps2RecompiledFunctionTable[361748] = bhCheckWallType_0x261340; // 0x261458 - g_ps2RecompiledFunctionTable[361749] = bhCheckWallType_0x261340; // 0x26145c - g_ps2RecompiledFunctionTable[361750] = bhCheckWallType_0x261340; // 0x261460 - g_ps2RecompiledFunctionTable[361751] = bhCheckWallType_0x261340; // 0x261464 - g_ps2RecompiledFunctionTable[361752] = bhCheckWallType_0x261340; // 0x261468 - g_ps2RecompiledFunctionTable[361753] = bhCheckWallType_0x261340; // 0x26146c - g_ps2RecompiledFunctionTable[361754] = bhCheckWallType_0x261340; // 0x261470 - g_ps2RecompiledFunctionTable[361755] = bhCheckWallType_0x261340; // 0x261474 - g_ps2RecompiledFunctionTable[361756] = bhCheckWallType_0x261340; // 0x261478 - g_ps2RecompiledFunctionTable[361757] = bhCheckWallType_0x261340; // 0x26147c - g_ps2RecompiledFunctionTable[361758] = bhCheckWallType_0x261340; // 0x261480 - g_ps2RecompiledFunctionTable[361759] = bhCheckWallType_0x261340; // 0x261484 - g_ps2RecompiledFunctionTable[361760] = bhCheckWallType_0x261340; // 0x261488 - g_ps2RecompiledFunctionTable[361761] = bhCheckWallType_0x261340; // 0x26148c - g_ps2RecompiledFunctionTable[361762] = bhCheckWallType_0x261340; // 0x261490 - g_ps2RecompiledFunctionTable[361763] = bhCheckWallType_0x261340; // 0x261494 - g_ps2RecompiledFunctionTable[361764] = bhCheckWallType_0x261340; // 0x261498 - g_ps2RecompiledFunctionTable[361765] = bhCheckWallType_0x261340; // 0x26149c - g_ps2RecompiledFunctionTable[361766] = bhCheckWallType_0x261340; // 0x2614a0 - g_ps2RecompiledFunctionTable[361767] = bhCheckWallType_0x261340; // 0x2614a4 - g_ps2RecompiledFunctionTable[361768] = bhCheckWallType_0x261340; // 0x2614a8 - g_ps2RecompiledFunctionTable[361769] = bhCheckWallType_0x261340; // 0x2614ac - g_ps2RecompiledFunctionTable[361770] = bhCheckWallType_0x261340; // 0x2614b0 - g_ps2RecompiledFunctionTable[361771] = bhCheckWallType_0x261340; // 0x2614b4 - g_ps2RecompiledFunctionTable[361772] = bhCheckWallType_0x261340; // 0x2614b8 - g_ps2RecompiledFunctionTable[361773] = bhCheckWallType_0x261340; // 0x2614bc - g_ps2RecompiledFunctionTable[361774] = bhCheckWallType_0x261340; // 0x2614c0 - g_ps2RecompiledFunctionTable[361775] = bhCheckWallType_0x261340; // 0x2614c4 - g_ps2RecompiledFunctionTable[361776] = bhCheckWallType_0x261340; // 0x2614c8 - g_ps2RecompiledFunctionTable[361777] = bhCheckWallType_0x261340; // 0x2614cc - g_ps2RecompiledFunctionTable[361778] = bhCheckWallType_0x261340; // 0x2614d0 - g_ps2RecompiledFunctionTable[361779] = bhCheckWallType_0x261340; // 0x2614d4 - g_ps2RecompiledFunctionTable[361780] = bhCheckWallType_0x261340; // 0x2614d8 - g_ps2RecompiledFunctionTable[361781] = bhCheckWallType_0x261340; // 0x2614dc - g_ps2RecompiledFunctionTable[361782] = bhCheckWallType_0x261340; // 0x2614e0 - g_ps2RecompiledFunctionTable[361783] = bhCheckWallType_0x261340; // 0x2614e4 - g_ps2RecompiledFunctionTable[361784] = bhCheckWallType_0x261340; // 0x2614e8 - g_ps2RecompiledFunctionTable[361785] = bhCheckWallType_0x261340; // 0x2614ec - g_ps2RecompiledFunctionTable[361786] = bhCheckWallType_0x261340; // 0x2614f0 - g_ps2RecompiledFunctionTable[361787] = bhCheckWallType_0x261340; // 0x2614f4 - g_ps2RecompiledFunctionTable[361788] = bhCheckWallType_0x261340; // 0x2614f8 - g_ps2RecompiledFunctionTable[361789] = bhCheckWallType_0x261340; // 0x2614fc - g_ps2RecompiledFunctionTable[361790] = bhCheckWallType_0x261340; // 0x261500 - g_ps2RecompiledFunctionTable[361791] = bhCheckWallType_0x261340; // 0x261504 - g_ps2RecompiledFunctionTable[361792] = bhCheckWallType_0x261340; // 0x261508 - g_ps2RecompiledFunctionTable[361793] = bhCheckWallType_0x261340; // 0x26150c - g_ps2RecompiledFunctionTable[361794] = bhCheckWallType_0x261340; // 0x261510 - g_ps2RecompiledFunctionTable[361795] = bhCheckWallType_0x261340; // 0x261514 - g_ps2RecompiledFunctionTable[361796] = bhCheckWallType_0x261340; // 0x261518 - g_ps2RecompiledFunctionTable[361797] = bhCheckWallType_0x261340; // 0x26151c - g_ps2RecompiledFunctionTable[361798] = bhCheckWallType_0x261340; // 0x261520 - g_ps2RecompiledFunctionTable[361799] = bhCheckWallType_0x261340; // 0x261524 - g_ps2RecompiledFunctionTable[361800] = bhCheckWallType_0x261340; // 0x261528 - g_ps2RecompiledFunctionTable[361801] = bhCheckWallType_0x261340; // 0x26152c - g_ps2RecompiledFunctionTable[361802] = bhCheckWallType_0x261340; // 0x261530 - g_ps2RecompiledFunctionTable[361803] = bhCheckWallType_0x261340; // 0x261534 - g_ps2RecompiledFunctionTable[361804] = bhCheckWallType_0x261340; // 0x261538 - g_ps2RecompiledFunctionTable[361805] = bhCheckWallType_0x261340; // 0x26153c - g_ps2RecompiledFunctionTable[361806] = bhCheckWallType_0x261340; // 0x261540 - g_ps2RecompiledFunctionTable[361807] = bhCheckWallType_0x261340; // 0x261544 - g_ps2RecompiledFunctionTable[361808] = bhCheckWallType_0x261340; // 0x261548 - g_ps2RecompiledFunctionTable[361809] = bhCheckWallType_0x261340; // 0x26154c - g_ps2RecompiledFunctionTable[361810] = bhCheckWallType_0x261340; // 0x261550 - g_ps2RecompiledFunctionTable[361811] = bhCheckWallType_0x261340; // 0x261554 - g_ps2RecompiledFunctionTable[361812] = bhCheckWallType_0x261340; // 0x261558 - g_ps2RecompiledFunctionTable[361813] = bhCheckWallType_0x261340; // 0x26155c - g_ps2RecompiledFunctionTable[361814] = bhCheckWallType_0x261340; // 0x261560 - g_ps2RecompiledFunctionTable[361815] = bhCheckWallType_0x261340; // 0x261564 - g_ps2RecompiledFunctionTable[361816] = bhCheckWallType_0x261340; // 0x261568 - g_ps2RecompiledFunctionTable[361817] = bhCheckWallType_0x261340; // 0x26156c - g_ps2RecompiledFunctionTable[361818] = bhCheckWallType_0x261340; // 0x261570 - g_ps2RecompiledFunctionTable[361819] = bhCheckWallType_0x261340; // 0x261574 - g_ps2RecompiledFunctionTable[361820] = bhCheckWallType_0x261340; // 0x261578 - g_ps2RecompiledFunctionTable[361821] = bhCheckWallType_0x261340; // 0x26157c - g_ps2RecompiledFunctionTable[361822] = bhCheckWallType_0x261340; // 0x261580 - g_ps2RecompiledFunctionTable[361823] = bhCheckWallType_0x261340; // 0x261584 - g_ps2RecompiledFunctionTable[361824] = bhCheckWallType_0x261340; // 0x261588 - g_ps2RecompiledFunctionTable[361825] = bhCheckWallType_0x261340; // 0x26158c - g_ps2RecompiledFunctionTable[361826] = bhCheckWallType_0x261340; // 0x261590 - g_ps2RecompiledFunctionTable[361827] = bhCheckWallType_0x261340; // 0x261594 - g_ps2RecompiledFunctionTable[361828] = bhCheckWallType_0x261340; // 0x261598 - g_ps2RecompiledFunctionTable[361829] = bhCheckWallType_0x261340; // 0x26159c - g_ps2RecompiledFunctionTable[361830] = bhCheckWallType_0x261340; // 0x2615a0 - g_ps2RecompiledFunctionTable[361831] = bhCheckWallType_0x261340; // 0x2615a4 - g_ps2RecompiledFunctionTable[361832] = bhCheckWallType_0x261340; // 0x2615a8 - g_ps2RecompiledFunctionTable[361833] = bhCheckWallType_0x261340; // 0x2615ac - g_ps2RecompiledFunctionTable[361834] = bhCheckWallType_0x261340; // 0x2615b0 - g_ps2RecompiledFunctionTable[361835] = bhCheckWallType_0x261340; // 0x2615b4 - g_ps2RecompiledFunctionTable[361836] = bhCheckWallType_0x261340; // 0x2615b8 - g_ps2RecompiledFunctionTable[361837] = bhCheckWallType_0x261340; // 0x2615bc - g_ps2RecompiledFunctionTable[361838] = bhCheckWallType_0x261340; // 0x2615c0 - g_ps2RecompiledFunctionTable[361839] = bhCheckWallType_0x261340; // 0x2615c4 - g_ps2RecompiledFunctionTable[361840] = bhCheckWallType_0x261340; // 0x2615c8 - g_ps2RecompiledFunctionTable[361841] = bhCheckWallType_0x261340; // 0x2615cc - g_ps2RecompiledFunctionTable[361842] = bhCheckWallType_0x261340; // 0x2615d0 - g_ps2RecompiledFunctionTable[361843] = bhCheckWallType_0x261340; // 0x2615d4 - g_ps2RecompiledFunctionTable[361844] = bhCheckWallType_0x261340; // 0x2615d8 - g_ps2RecompiledFunctionTable[361845] = bhCheckWallType_0x261340; // 0x2615dc - g_ps2RecompiledFunctionTable[361846] = bhCheckWallType_0x261340; // 0x2615e0 - g_ps2RecompiledFunctionTable[361847] = bhCheckWallType_0x261340; // 0x2615e4 - g_ps2RecompiledFunctionTable[361848] = bhCheckWallType_0x261340; // 0x2615e8 - g_ps2RecompiledFunctionTable[361849] = bhCheckWallType_0x261340; // 0x2615ec - g_ps2RecompiledFunctionTable[361850] = bhCheckWallType_0x261340; // 0x2615f0 - g_ps2RecompiledFunctionTable[361851] = bhCheckWallType_0x261340; // 0x2615f4 - g_ps2RecompiledFunctionTable[361852] = bhCheckWallType_0x261340; // 0x2615f8 - g_ps2RecompiledFunctionTable[361853] = bhCheckWallType_0x261340; // 0x2615fc - g_ps2RecompiledFunctionTable[361854] = bhCheckWallType_0x261340; // 0x261600 - g_ps2RecompiledFunctionTable[361855] = bhCheckWallType_0x261340; // 0x261604 - g_ps2RecompiledFunctionTable[361856] = bhCheckWallType_0x261340; // 0x261608 - g_ps2RecompiledFunctionTable[361857] = bhCheckWallType_0x261340; // 0x26160c - g_ps2RecompiledFunctionTable[361858] = bhCheckWallType_0x261340; // 0x261610 - g_ps2RecompiledFunctionTable[361859] = bhCheckWallType_0x261340; // 0x261614 - g_ps2RecompiledFunctionTable[361860] = bhCheckWallType_0x261340; // 0x261618 - g_ps2RecompiledFunctionTable[361861] = bhCheckWallType_0x261340; // 0x26161c - g_ps2RecompiledFunctionTable[361862] = bhCheckWallType_0x261340; // 0x261620 - g_ps2RecompiledFunctionTable[361863] = bhCheckWallType_0x261340; // 0x261624 - g_ps2RecompiledFunctionTable[361864] = bhCheckWallType_0x261340; // 0x261628 - g_ps2RecompiledFunctionTable[361865] = bhCheckWallType_0x261340; // 0x26162c - g_ps2RecompiledFunctionTable[361866] = bhCheckWallType_0x261340; // 0x261630 - g_ps2RecompiledFunctionTable[361867] = bhCheckWallType_0x261340; // 0x261634 - g_ps2RecompiledFunctionTable[361868] = bhCheckWallType_0x261340; // 0x261638 - g_ps2RecompiledFunctionTable[361869] = bhCheckWallType_0x261340; // 0x26163c - g_ps2RecompiledFunctionTable[361870] = bhCheckWallType_0x261340; // 0x261640 - g_ps2RecompiledFunctionTable[361871] = bhCheckWallType_0x261340; // 0x261644 - g_ps2RecompiledFunctionTable[361872] = bhCheckWallType_0x261340; // 0x261648 - g_ps2RecompiledFunctionTable[361873] = bhCheckWallType_0x261340; // 0x26164c - g_ps2RecompiledFunctionTable[361874] = bhCheckWallType_0x261340; // 0x261650 - g_ps2RecompiledFunctionTable[361875] = bhCheckWallType_0x261340; // 0x261654 - g_ps2RecompiledFunctionTable[361876] = bhCheckWallType_0x261340; // 0x261658 - g_ps2RecompiledFunctionTable[361877] = bhCheckWallType_0x261340; // 0x26165c - g_ps2RecompiledFunctionTable[361878] = bhCheckWallType_0x261340; // 0x261660 - g_ps2RecompiledFunctionTable[361879] = bhCheckWallType_0x261340; // 0x261664 - g_ps2RecompiledFunctionTable[361880] = bhCheckWallType_0x261340; // 0x261668 - g_ps2RecompiledFunctionTable[361881] = bhCheckWallType_0x261340; // 0x26166c - g_ps2RecompiledFunctionTable[361882] = bhCheckWallType_0x261340; // 0x261670 - g_ps2RecompiledFunctionTable[361883] = bhCheckWallType_0x261340; // 0x261674 - g_ps2RecompiledFunctionTable[361884] = bhCheckWallType_0x261340; // 0x261678 - g_ps2RecompiledFunctionTable[361885] = bhCheckWallType_0x261340; // 0x26167c - g_ps2RecompiledFunctionTable[361886] = bhCheckWallType_0x261340; // 0x261680 - g_ps2RecompiledFunctionTable[361887] = bhCheckWallType_0x261340; // 0x261684 - g_ps2RecompiledFunctionTable[361888] = bhCheckWallType_0x261340; // 0x261688 - g_ps2RecompiledFunctionTable[361889] = bhCheckWallType_0x261340; // 0x26168c - g_ps2RecompiledFunctionTable[361890] = bhCheckWallType_0x261340; // 0x261690 - g_ps2RecompiledFunctionTable[361891] = bhCheckWallType_0x261340; // 0x261694 - g_ps2RecompiledFunctionTable[361892] = bhCheckWallType_0x261340; // 0x261698 - g_ps2RecompiledFunctionTable[361893] = bhCheckWallType_0x261340; // 0x26169c - g_ps2RecompiledFunctionTable[361894] = bhCheckWallType_0x261340; // 0x2616a0 - g_ps2RecompiledFunctionTable[361895] = bhCheckWallType_0x261340; // 0x2616a4 - g_ps2RecompiledFunctionTable[361896] = bhCheckWallType_0x261340; // 0x2616a8 - g_ps2RecompiledFunctionTable[361897] = bhCheckWallType_0x261340; // 0x2616ac - g_ps2RecompiledFunctionTable[361898] = bhCheckWallType_0x261340; // 0x2616b0 - g_ps2RecompiledFunctionTable[361899] = bhCheckWallType_0x261340; // 0x2616b4 - g_ps2RecompiledFunctionTable[361900] = bhCheckWallType_0x261340; // 0x2616b8 - g_ps2RecompiledFunctionTable[361901] = bhCheckWallType_0x261340; // 0x2616bc - g_ps2RecompiledFunctionTable[361902] = bhCheckWallType_0x261340; // 0x2616c0 - g_ps2RecompiledFunctionTable[361903] = bhCheckWallType_0x261340; // 0x2616c4 - g_ps2RecompiledFunctionTable[361904] = bhCheckWallType_0x261340; // 0x2616c8 - g_ps2RecompiledFunctionTable[361905] = bhCheckWallType_0x261340; // 0x2616cc - g_ps2RecompiledFunctionTable[361906] = bhCheckWallType_0x261340; // 0x2616d0 - g_ps2RecompiledFunctionTable[361907] = bhCheckWallType_0x261340; // 0x2616d4 - g_ps2RecompiledFunctionTable[361908] = bhCheckWallType_0x261340; // 0x2616d8 - g_ps2RecompiledFunctionTable[361909] = bhCheckWallType_0x261340; // 0x2616dc - g_ps2RecompiledFunctionTable[361910] = bhCheckWallType_0x261340; // 0x2616e0 - g_ps2RecompiledFunctionTable[361911] = bhCheckWallType_0x261340; // 0x2616e4 - g_ps2RecompiledFunctionTable[361912] = bhCheckWallType_0x261340; // 0x2616e8 - g_ps2RecompiledFunctionTable[361913] = bhCheckWallType_0x261340; // 0x2616ec - g_ps2RecompiledFunctionTable[361914] = bhCheckWallType_0x261340; // 0x2616f0 - g_ps2RecompiledFunctionTable[361915] = bhCheckWallType_0x261340; // 0x2616f4 - g_ps2RecompiledFunctionTable[361916] = bhCheckWallType_0x261340; // 0x2616f8 - g_ps2RecompiledFunctionTable[361917] = bhCheckWallType_0x261340; // 0x2616fc - g_ps2RecompiledFunctionTable[361918] = bhCheckWallType_0x261340; // 0x261700 - g_ps2RecompiledFunctionTable[361919] = bhCheckWallType_0x261340; // 0x261704 - g_ps2RecompiledFunctionTable[361920] = bhCheckWallType_0x261340; // 0x261708 - g_ps2RecompiledFunctionTable[361921] = bhCheckWallType_0x261340; // 0x26170c - g_ps2RecompiledFunctionTable[361922] = bhCheckWallType_0x261340; // 0x261710 - g_ps2RecompiledFunctionTable[361923] = bhCheckWallType_0x261340; // 0x261714 - g_ps2RecompiledFunctionTable[361924] = bhCheckWallType_0x261340; // 0x261718 - g_ps2RecompiledFunctionTable[361925] = bhCheckWallType_0x261340; // 0x26171c - g_ps2RecompiledFunctionTable[361926] = bhCheckWallType_0x261340; // 0x261720 - g_ps2RecompiledFunctionTable[361927] = bhCheckWallType_0x261340; // 0x261724 - g_ps2RecompiledFunctionTable[361928] = bhCheckWallType_0x261340; // 0x261728 - g_ps2RecompiledFunctionTable[361929] = bhCheckWallType_0x261340; // 0x26172c - g_ps2RecompiledFunctionTable[361930] = bhCheckWallType_0x261340; // 0x261730 - g_ps2RecompiledFunctionTable[361931] = bhCheckWallType_0x261340; // 0x261734 - g_ps2RecompiledFunctionTable[361932] = bhCheckWallType_0x261340; // 0x261738 - g_ps2RecompiledFunctionTable[361933] = bhCheckWallType_0x261340; // 0x26173c - g_ps2RecompiledFunctionTable[361934] = bhCheckWallType_0x261340; // 0x261740 - g_ps2RecompiledFunctionTable[361935] = bhCheckWallType_0x261340; // 0x261744 - g_ps2RecompiledFunctionTable[361936] = bhCheckWallType_0x261340; // 0x261748 - g_ps2RecompiledFunctionTable[361937] = bhCheckWallType_0x261340; // 0x26174c - g_ps2RecompiledFunctionTable[361938] = bhCheckWallType_0x261340; // 0x261750 - g_ps2RecompiledFunctionTable[361939] = bhCheckWallType_0x261340; // 0x261754 - g_ps2RecompiledFunctionTable[361940] = bhCheckWallType_0x261340; // 0x261758 - g_ps2RecompiledFunctionTable[361941] = bhCheckWallType_0x261340; // 0x26175c - g_ps2RecompiledFunctionTable[361942] = bhCheckWallType_0x261340; // 0x261760 - g_ps2RecompiledFunctionTable[361943] = bhCheckWallType_0x261340; // 0x261764 - g_ps2RecompiledFunctionTable[361944] = bhCheckWallType_0x261340; // 0x261768 - g_ps2RecompiledFunctionTable[361945] = bhCheckWallType_0x261340; // 0x26176c - g_ps2RecompiledFunctionTable[361946] = bhCheckWallType_0x261340; // 0x261770 - g_ps2RecompiledFunctionTable[361947] = bhCheckWallType_0x261340; // 0x261774 - g_ps2RecompiledFunctionTable[361948] = bhCheckWallType_0x261340; // 0x261778 - g_ps2RecompiledFunctionTable[361949] = bhCheckWallType_0x261340; // 0x26177c - g_ps2RecompiledFunctionTable[361950] = bhCheckWallType_0x261340; // 0x261780 - g_ps2RecompiledFunctionTable[361951] = bhCheckWallType_0x261340; // 0x261784 - g_ps2RecompiledFunctionTable[361952] = bhCheckWallType_0x261340; // 0x261788 - g_ps2RecompiledFunctionTable[361953] = bhCheckWallType_0x261340; // 0x26178c - g_ps2RecompiledFunctionTable[361954] = bhCheckWallType_0x261340; // 0x261790 - g_ps2RecompiledFunctionTable[361955] = bhCheckWallType_0x261340; // 0x261794 - g_ps2RecompiledFunctionTable[361956] = bhCheckWallType_0x261340; // 0x261798 - g_ps2RecompiledFunctionTable[361957] = bhCheckWallType_0x261340; // 0x26179c - g_ps2RecompiledFunctionTable[361958] = bhCheckWallType_0x261340; // 0x2617a0 - g_ps2RecompiledFunctionTable[361959] = bhCheckWallType_0x261340; // 0x2617a4 - g_ps2RecompiledFunctionTable[361960] = bhCheckWallType_0x261340; // 0x2617a8 - g_ps2RecompiledFunctionTable[361961] = bhCheckWallType_0x261340; // 0x2617ac - g_ps2RecompiledFunctionTable[361962] = bhCheckWallType_0x261340; // 0x2617b0 - g_ps2RecompiledFunctionTable[361963] = bhCheckWallType_0x261340; // 0x2617b4 - g_ps2RecompiledFunctionTable[361964] = bhCheckWallType_0x261340; // 0x2617b8 - g_ps2RecompiledFunctionTable[361965] = bhCheckWallType_0x261340; // 0x2617bc - g_ps2RecompiledFunctionTable[361966] = bhCheckWallType_0x261340; // 0x2617c0 - g_ps2RecompiledFunctionTable[361967] = bhCheckWallType_0x261340; // 0x2617c4 - g_ps2RecompiledFunctionTable[361968] = bhCheckWallType_0x261340; // 0x2617c8 - g_ps2RecompiledFunctionTable[361969] = bhCheckWallType_0x261340; // 0x2617cc - g_ps2RecompiledFunctionTable[361970] = bhCheckWallType_0x261340; // 0x2617d0 - g_ps2RecompiledFunctionTable[361971] = bhCheckWallType_0x261340; // 0x2617d4 - g_ps2RecompiledFunctionTable[361972] = bhCheckWallType_0x261340; // 0x2617d8 - g_ps2RecompiledFunctionTable[361973] = bhCheckWallType_0x261340; // 0x2617dc - g_ps2RecompiledFunctionTable[361974] = bhCheckWallType_0x261340; // 0x2617e0 - g_ps2RecompiledFunctionTable[361975] = bhCheckWallType_0x261340; // 0x2617e4 - g_ps2RecompiledFunctionTable[361976] = bhCheckWallType_0x261340; // 0x2617e8 - g_ps2RecompiledFunctionTable[361977] = bhCheckWallType_0x261340; // 0x2617ec - g_ps2RecompiledFunctionTable[361978] = bhCheckWallType_0x261340; // 0x2617f0 - g_ps2RecompiledFunctionTable[361979] = bhCheckWallType_0x261340; // 0x2617f4 - g_ps2RecompiledFunctionTable[361980] = bhCheckWallType_0x261340; // 0x2617f8 - g_ps2RecompiledFunctionTable[361981] = bhCheckWallType_0x261340; // 0x2617fc - g_ps2RecompiledFunctionTable[361982] = bhCheckWallType_0x261340; // 0x261800 - g_ps2RecompiledFunctionTable[361983] = bhCheckWallType_0x261340; // 0x261804 - g_ps2RecompiledFunctionTable[361984] = bhCheckWallType_0x261340; // 0x261808 - g_ps2RecompiledFunctionTable[361985] = bhCheckWallType_0x261340; // 0x26180c - g_ps2RecompiledFunctionTable[361986] = bhCheckWallType_0x261340; // 0x261810 - g_ps2RecompiledFunctionTable[361987] = bhCheckWallType_0x261340; // 0x261814 - g_ps2RecompiledFunctionTable[361988] = bhCheckWallType_0x261340; // 0x261818 - g_ps2RecompiledFunctionTable[361989] = bhCheckWallType_0x261340; // 0x26181c - g_ps2RecompiledFunctionTable[361990] = bhCheckWallType_0x261340; // 0x261820 - g_ps2RecompiledFunctionTable[361991] = bhCheckWallType_0x261340; // 0x261824 - g_ps2RecompiledFunctionTable[361992] = bhCheckWallType_0x261340; // 0x261828 - g_ps2RecompiledFunctionTable[361994] = bhCheckWallType2_0x261830; // 0x261830 - g_ps2RecompiledFunctionTable[361995] = bhCheckWallType2_0x261830; // 0x261834 - g_ps2RecompiledFunctionTable[361996] = bhCheckWallType2_0x261830; // 0x261838 - g_ps2RecompiledFunctionTable[361997] = bhCheckWallType2_0x261830; // 0x26183c - g_ps2RecompiledFunctionTable[361998] = bhCheckWallType2_0x261830; // 0x261840 - g_ps2RecompiledFunctionTable[361999] = bhCheckWallType2_0x261830; // 0x261844 - g_ps2RecompiledFunctionTable[362000] = bhCheckWallType2_0x261830; // 0x261848 - g_ps2RecompiledFunctionTable[362001] = bhCheckWallType2_0x261830; // 0x26184c - g_ps2RecompiledFunctionTable[362002] = bhCheckWallType2_0x261830; // 0x261850 - g_ps2RecompiledFunctionTable[362003] = bhCheckWallType2_0x261830; // 0x261854 - g_ps2RecompiledFunctionTable[362004] = bhCheckWallType2_0x261830; // 0x261858 - g_ps2RecompiledFunctionTable[362005] = bhCheckWallType2_0x261830; // 0x26185c - g_ps2RecompiledFunctionTable[362006] = bhCheckWallType2_0x261830; // 0x261860 - g_ps2RecompiledFunctionTable[362007] = bhCheckWallType2_0x261830; // 0x261864 - g_ps2RecompiledFunctionTable[362008] = bhCheckWallType2_0x261830; // 0x261868 - g_ps2RecompiledFunctionTable[362009] = bhCheckWallType2_0x261830; // 0x26186c - g_ps2RecompiledFunctionTable[362010] = bhCheckWallType2_0x261830; // 0x261870 - g_ps2RecompiledFunctionTable[362011] = bhCheckWallType2_0x261830; // 0x261874 - g_ps2RecompiledFunctionTable[362012] = bhCheckWallType2_0x261830; // 0x261878 - g_ps2RecompiledFunctionTable[362013] = bhCheckWallType2_0x261830; // 0x26187c - g_ps2RecompiledFunctionTable[362014] = bhCheckWallType2_0x261830; // 0x261880 - g_ps2RecompiledFunctionTable[362015] = bhCheckWallType2_0x261830; // 0x261884 - g_ps2RecompiledFunctionTable[362016] = bhCheckWallType2_0x261830; // 0x261888 - g_ps2RecompiledFunctionTable[362017] = bhCheckWallType2_0x261830; // 0x26188c - g_ps2RecompiledFunctionTable[362018] = bhCheckWallType2_0x261830; // 0x261890 - g_ps2RecompiledFunctionTable[362019] = bhCheckWallType2_0x261830; // 0x261894 - g_ps2RecompiledFunctionTable[362020] = bhCheckWallType2_0x261830; // 0x261898 - g_ps2RecompiledFunctionTable[362021] = bhCheckWallType2_0x261830; // 0x26189c - g_ps2RecompiledFunctionTable[362022] = bhCheckWallType2_0x261830; // 0x2618a0 - g_ps2RecompiledFunctionTable[362023] = bhCheckWallType2_0x261830; // 0x2618a4 - g_ps2RecompiledFunctionTable[362024] = bhCheckWallType2_0x261830; // 0x2618a8 - g_ps2RecompiledFunctionTable[362025] = bhCheckWallType2_0x261830; // 0x2618ac - g_ps2RecompiledFunctionTable[362026] = bhCheckWallType2_0x261830; // 0x2618b0 - g_ps2RecompiledFunctionTable[362027] = bhCheckWallType2_0x261830; // 0x2618b4 - g_ps2RecompiledFunctionTable[362028] = bhCheckWallType2_0x261830; // 0x2618b8 - g_ps2RecompiledFunctionTable[362029] = bhCheckWallType2_0x261830; // 0x2618bc - g_ps2RecompiledFunctionTable[362030] = bhCheckWallType2_0x261830; // 0x2618c0 - g_ps2RecompiledFunctionTable[362031] = bhCheckWallType2_0x261830; // 0x2618c4 - g_ps2RecompiledFunctionTable[362032] = bhCheckWallType2_0x261830; // 0x2618c8 - g_ps2RecompiledFunctionTable[362033] = bhCheckWallType2_0x261830; // 0x2618cc - g_ps2RecompiledFunctionTable[362034] = bhCheckWallType2_0x261830; // 0x2618d0 - g_ps2RecompiledFunctionTable[362035] = bhCheckWallType2_0x261830; // 0x2618d4 - g_ps2RecompiledFunctionTable[362036] = bhCheckWallType2_0x261830; // 0x2618d8 - g_ps2RecompiledFunctionTable[362037] = bhCheckWallType2_0x261830; // 0x2618dc - g_ps2RecompiledFunctionTable[362038] = bhCheckWallType2_0x261830; // 0x2618e0 - g_ps2RecompiledFunctionTable[362039] = bhCheckWallType2_0x261830; // 0x2618e4 - g_ps2RecompiledFunctionTable[362040] = bhCheckWallType2_0x261830; // 0x2618e8 - g_ps2RecompiledFunctionTable[362041] = bhCheckWallType2_0x261830; // 0x2618ec - g_ps2RecompiledFunctionTable[362042] = bhCheckWallType2_0x261830; // 0x2618f0 - g_ps2RecompiledFunctionTable[362043] = bhCheckWallType2_0x261830; // 0x2618f4 - g_ps2RecompiledFunctionTable[362044] = bhCheckWallType2_0x261830; // 0x2618f8 - g_ps2RecompiledFunctionTable[362045] = bhCheckWallType2_0x261830; // 0x2618fc - g_ps2RecompiledFunctionTable[362046] = bhCheckWallType2_0x261830; // 0x261900 - g_ps2RecompiledFunctionTable[362047] = bhCheckWallType2_0x261830; // 0x261904 - g_ps2RecompiledFunctionTable[362048] = bhCheckWallType2_0x261830; // 0x261908 - g_ps2RecompiledFunctionTable[362049] = bhCheckWallType2_0x261830; // 0x26190c - g_ps2RecompiledFunctionTable[362050] = bhCheckWallType2_0x261830; // 0x261910 - g_ps2RecompiledFunctionTable[362051] = bhCheckWallType2_0x261830; // 0x261914 - g_ps2RecompiledFunctionTable[362052] = bhCheckWallType2_0x261830; // 0x261918 - g_ps2RecompiledFunctionTable[362053] = bhCheckWallType2_0x261830; // 0x26191c - g_ps2RecompiledFunctionTable[362054] = bhCheckWallType2_0x261830; // 0x261920 - g_ps2RecompiledFunctionTable[362055] = bhCheckWallType2_0x261830; // 0x261924 - g_ps2RecompiledFunctionTable[362056] = bhCheckWallType2_0x261830; // 0x261928 - g_ps2RecompiledFunctionTable[362057] = bhCheckWallType2_0x261830; // 0x26192c - g_ps2RecompiledFunctionTable[362058] = bhCheckWallType2_0x261830; // 0x261930 - g_ps2RecompiledFunctionTable[362059] = bhCheckWallType2_0x261830; // 0x261934 - g_ps2RecompiledFunctionTable[362060] = bhCheckWallType2_0x261830; // 0x261938 - g_ps2RecompiledFunctionTable[362061] = bhCheckWallType2_0x261830; // 0x26193c - g_ps2RecompiledFunctionTable[362062] = bhCheckWallType2_0x261830; // 0x261940 - g_ps2RecompiledFunctionTable[362063] = bhCheckWallType2_0x261830; // 0x261944 - g_ps2RecompiledFunctionTable[362064] = bhCheckWallType2_0x261830; // 0x261948 - g_ps2RecompiledFunctionTable[362065] = bhCheckWallType2_0x261830; // 0x26194c - g_ps2RecompiledFunctionTable[362066] = bhCheckWallType2_0x261830; // 0x261950 - g_ps2RecompiledFunctionTable[362067] = bhCheckWallType2_0x261830; // 0x261954 - g_ps2RecompiledFunctionTable[362068] = bhCheckWallType2_0x261830; // 0x261958 - g_ps2RecompiledFunctionTable[362069] = bhCheckWallType2_0x261830; // 0x26195c - g_ps2RecompiledFunctionTable[362070] = bhCheckWallType2_0x261830; // 0x261960 - g_ps2RecompiledFunctionTable[362071] = bhCheckWallType2_0x261830; // 0x261964 - g_ps2RecompiledFunctionTable[362072] = bhCheckWallType2_0x261830; // 0x261968 - g_ps2RecompiledFunctionTable[362073] = bhCheckWallType2_0x261830; // 0x26196c - g_ps2RecompiledFunctionTable[362074] = bhCheckWallType2_0x261830; // 0x261970 - g_ps2RecompiledFunctionTable[362075] = bhCheckWallType2_0x261830; // 0x261974 - g_ps2RecompiledFunctionTable[362076] = bhCheckWallType2_0x261830; // 0x261978 - g_ps2RecompiledFunctionTable[362077] = bhCheckWallType2_0x261830; // 0x26197c - g_ps2RecompiledFunctionTable[362078] = bhCheckWallType2_0x261830; // 0x261980 - g_ps2RecompiledFunctionTable[362079] = bhCheckWallType2_0x261830; // 0x261984 - g_ps2RecompiledFunctionTable[362080] = bhCheckWallType2_0x261830; // 0x261988 - g_ps2RecompiledFunctionTable[362081] = bhCheckWallType2_0x261830; // 0x26198c - g_ps2RecompiledFunctionTable[362082] = bhCheckWallType2_0x261830; // 0x261990 - g_ps2RecompiledFunctionTable[362083] = bhCheckWallType2_0x261830; // 0x261994 - g_ps2RecompiledFunctionTable[362084] = bhCheckWallType2_0x261830; // 0x261998 - g_ps2RecompiledFunctionTable[362085] = bhCheckWallType2_0x261830; // 0x26199c - g_ps2RecompiledFunctionTable[362086] = bhCheckWallType2_0x261830; // 0x2619a0 - g_ps2RecompiledFunctionTable[362087] = bhCheckWallType2_0x261830; // 0x2619a4 - g_ps2RecompiledFunctionTable[362088] = bhCheckWallType2_0x261830; // 0x2619a8 - g_ps2RecompiledFunctionTable[362089] = bhCheckWallType2_0x261830; // 0x2619ac - g_ps2RecompiledFunctionTable[362090] = bhCheckWallType2_0x261830; // 0x2619b0 - g_ps2RecompiledFunctionTable[362091] = bhCheckWallType2_0x261830; // 0x2619b4 - g_ps2RecompiledFunctionTable[362092] = bhCheckWallType2_0x261830; // 0x2619b8 - g_ps2RecompiledFunctionTable[362093] = bhCheckWallType2_0x261830; // 0x2619bc - g_ps2RecompiledFunctionTable[362094] = bhCheckWallType2_0x261830; // 0x2619c0 - g_ps2RecompiledFunctionTable[362095] = bhCheckWallType2_0x261830; // 0x2619c4 - g_ps2RecompiledFunctionTable[362096] = bhCheckWallType2_0x261830; // 0x2619c8 - g_ps2RecompiledFunctionTable[362097] = bhCheckWallType2_0x261830; // 0x2619cc - g_ps2RecompiledFunctionTable[362098] = bhCheckWallType2_0x261830; // 0x2619d0 - g_ps2RecompiledFunctionTable[362099] = bhCheckWallType2_0x261830; // 0x2619d4 - g_ps2RecompiledFunctionTable[362100] = bhCheckWallType2_0x261830; // 0x2619d8 - g_ps2RecompiledFunctionTable[362101] = bhCheckWallType2_0x261830; // 0x2619dc - g_ps2RecompiledFunctionTable[362102] = bhCheckWallType2_0x261830; // 0x2619e0 - g_ps2RecompiledFunctionTable[362103] = bhCheckWallType2_0x261830; // 0x2619e4 - g_ps2RecompiledFunctionTable[362104] = bhCheckWallType2_0x261830; // 0x2619e8 - g_ps2RecompiledFunctionTable[362105] = bhCheckWallType2_0x261830; // 0x2619ec - g_ps2RecompiledFunctionTable[362106] = bhCheckWallType2_0x261830; // 0x2619f0 - g_ps2RecompiledFunctionTable[362107] = bhCheckWallType2_0x261830; // 0x2619f4 - g_ps2RecompiledFunctionTable[362108] = bhCheckWallType2_0x261830; // 0x2619f8 - g_ps2RecompiledFunctionTable[362109] = bhCheckWallType2_0x261830; // 0x2619fc - g_ps2RecompiledFunctionTable[362110] = bhCheckWallType2_0x261830; // 0x261a00 - g_ps2RecompiledFunctionTable[362111] = bhCheckWallType2_0x261830; // 0x261a04 - g_ps2RecompiledFunctionTable[362112] = bhCheckWallType2_0x261830; // 0x261a08 - g_ps2RecompiledFunctionTable[362113] = bhCheckWallType2_0x261830; // 0x261a0c - g_ps2RecompiledFunctionTable[362114] = bhCheckWallType2_0x261830; // 0x261a10 - g_ps2RecompiledFunctionTable[362115] = bhCheckWallType2_0x261830; // 0x261a14 - g_ps2RecompiledFunctionTable[362116] = bhCheckWallType2_0x261830; // 0x261a18 - g_ps2RecompiledFunctionTable[362117] = bhCheckWallType2_0x261830; // 0x261a1c - g_ps2RecompiledFunctionTable[362118] = bhCheckWallType2_0x261830; // 0x261a20 - g_ps2RecompiledFunctionTable[362119] = bhCheckWallType2_0x261830; // 0x261a24 - g_ps2RecompiledFunctionTable[362120] = bhCheckWallType2_0x261830; // 0x261a28 - g_ps2RecompiledFunctionTable[362121] = bhCheckWallType2_0x261830; // 0x261a2c - g_ps2RecompiledFunctionTable[362122] = bhCheckWallType2_0x261830; // 0x261a30 - g_ps2RecompiledFunctionTable[362123] = bhCheckWallType2_0x261830; // 0x261a34 - g_ps2RecompiledFunctionTable[362124] = bhCheckWallType2_0x261830; // 0x261a38 - g_ps2RecompiledFunctionTable[362125] = bhCheckWallType2_0x261830; // 0x261a3c - g_ps2RecompiledFunctionTable[362126] = bhCheckWallType2_0x261830; // 0x261a40 - g_ps2RecompiledFunctionTable[362127] = bhCheckWallType2_0x261830; // 0x261a44 - g_ps2RecompiledFunctionTable[362128] = bhCheckWallType2_0x261830; // 0x261a48 - g_ps2RecompiledFunctionTable[362129] = bhCheckWallType2_0x261830; // 0x261a4c - g_ps2RecompiledFunctionTable[362130] = bhCheckWallType2_0x261830; // 0x261a50 - g_ps2RecompiledFunctionTable[362131] = bhCheckWallType2_0x261830; // 0x261a54 - g_ps2RecompiledFunctionTable[362132] = bhCheckWallType2_0x261830; // 0x261a58 - g_ps2RecompiledFunctionTable[362133] = bhCheckWallType2_0x261830; // 0x261a5c - g_ps2RecompiledFunctionTable[362134] = bhCheckWallType2_0x261830; // 0x261a60 - g_ps2RecompiledFunctionTable[362135] = bhCheckWallType2_0x261830; // 0x261a64 - g_ps2RecompiledFunctionTable[362136] = bhCheckWallType2_0x261830; // 0x261a68 - g_ps2RecompiledFunctionTable[362137] = bhCheckWallType2_0x261830; // 0x261a6c - g_ps2RecompiledFunctionTable[362138] = bhCheckWallType2_0x261830; // 0x261a70 - g_ps2RecompiledFunctionTable[362139] = bhCheckWallType2_0x261830; // 0x261a74 - g_ps2RecompiledFunctionTable[362140] = bhCheckWallType2_0x261830; // 0x261a78 - g_ps2RecompiledFunctionTable[362141] = bhCheckWallType2_0x261830; // 0x261a7c - g_ps2RecompiledFunctionTable[362142] = bhCheckWallType2_0x261830; // 0x261a80 - g_ps2RecompiledFunctionTable[362143] = bhCheckWallType2_0x261830; // 0x261a84 - g_ps2RecompiledFunctionTable[362144] = bhCheckWallType2_0x261830; // 0x261a88 - g_ps2RecompiledFunctionTable[362145] = bhCheckWallType2_0x261830; // 0x261a8c - g_ps2RecompiledFunctionTable[362146] = bhCheckWallType2_0x261830; // 0x261a90 - g_ps2RecompiledFunctionTable[362147] = bhCheckWallType2_0x261830; // 0x261a94 - g_ps2RecompiledFunctionTable[362148] = bhCheckWallType2_0x261830; // 0x261a98 - g_ps2RecompiledFunctionTable[362149] = bhCheckWallType2_0x261830; // 0x261a9c - g_ps2RecompiledFunctionTable[362150] = bhCheckWallType2_0x261830; // 0x261aa0 - g_ps2RecompiledFunctionTable[362151] = bhCheckWallType2_0x261830; // 0x261aa4 - g_ps2RecompiledFunctionTable[362152] = bhCheckWallType2_0x261830; // 0x261aa8 - g_ps2RecompiledFunctionTable[362153] = bhCheckWallType2_0x261830; // 0x261aac - g_ps2RecompiledFunctionTable[362154] = bhCheckWallType2_0x261830; // 0x261ab0 - g_ps2RecompiledFunctionTable[362155] = bhCheckWallType2_0x261830; // 0x261ab4 - g_ps2RecompiledFunctionTable[362156] = bhCheckWallType2_0x261830; // 0x261ab8 - g_ps2RecompiledFunctionTable[362157] = bhCheckWallType2_0x261830; // 0x261abc - g_ps2RecompiledFunctionTable[362158] = bhCheckWallType2_0x261830; // 0x261ac0 - g_ps2RecompiledFunctionTable[362159] = bhCheckWallType2_0x261830; // 0x261ac4 - g_ps2RecompiledFunctionTable[362160] = bhCheckWallType2_0x261830; // 0x261ac8 - g_ps2RecompiledFunctionTable[362161] = bhCheckWallType2_0x261830; // 0x261acc - g_ps2RecompiledFunctionTable[362162] = bhCheckWallType2_0x261830; // 0x261ad0 - g_ps2RecompiledFunctionTable[362163] = bhCheckWallType2_0x261830; // 0x261ad4 - g_ps2RecompiledFunctionTable[362164] = bhCheckWallType2_0x261830; // 0x261ad8 - g_ps2RecompiledFunctionTable[362165] = bhCheckWallType2_0x261830; // 0x261adc - g_ps2RecompiledFunctionTable[362166] = bhCheckWallType2_0x261830; // 0x261ae0 - g_ps2RecompiledFunctionTable[362167] = bhCheckWallType2_0x261830; // 0x261ae4 - g_ps2RecompiledFunctionTable[362168] = bhCheckWallType2_0x261830; // 0x261ae8 - g_ps2RecompiledFunctionTable[362169] = bhCheckWallType2_0x261830; // 0x261aec - g_ps2RecompiledFunctionTable[362170] = bhCheckWallType2_0x261830; // 0x261af0 - g_ps2RecompiledFunctionTable[362171] = bhCheckWallType2_0x261830; // 0x261af4 - g_ps2RecompiledFunctionTable[362172] = bhCheckWallType2_0x261830; // 0x261af8 - g_ps2RecompiledFunctionTable[362173] = bhCheckWallType2_0x261830; // 0x261afc - g_ps2RecompiledFunctionTable[362174] = bhCheckWallType2_0x261830; // 0x261b00 - g_ps2RecompiledFunctionTable[362175] = bhCheckWallType2_0x261830; // 0x261b04 - g_ps2RecompiledFunctionTable[362176] = bhCheckWallType2_0x261830; // 0x261b08 - g_ps2RecompiledFunctionTable[362177] = bhCheckWallType2_0x261830; // 0x261b0c - g_ps2RecompiledFunctionTable[362178] = bhCheckWallType2_0x261830; // 0x261b10 - g_ps2RecompiledFunctionTable[362179] = bhCheckWallType2_0x261830; // 0x261b14 - g_ps2RecompiledFunctionTable[362180] = bhCheckWallType2_0x261830; // 0x261b18 - g_ps2RecompiledFunctionTable[362181] = bhCheckWallType2_0x261830; // 0x261b1c - g_ps2RecompiledFunctionTable[362182] = bhCheckWallType2_0x261830; // 0x261b20 - g_ps2RecompiledFunctionTable[362183] = bhCheckWallType2_0x261830; // 0x261b24 - g_ps2RecompiledFunctionTable[362184] = bhCheckWallType2_0x261830; // 0x261b28 - g_ps2RecompiledFunctionTable[362185] = bhCheckWallType2_0x261830; // 0x261b2c - g_ps2RecompiledFunctionTable[362186] = bhCheckWallType2_0x261830; // 0x261b30 - g_ps2RecompiledFunctionTable[362187] = bhCheckWallType2_0x261830; // 0x261b34 - g_ps2RecompiledFunctionTable[362188] = bhCheckWallType2_0x261830; // 0x261b38 - g_ps2RecompiledFunctionTable[362189] = bhCheckWallType2_0x261830; // 0x261b3c - g_ps2RecompiledFunctionTable[362190] = bhCheckWallType2_0x261830; // 0x261b40 - g_ps2RecompiledFunctionTable[362191] = bhCheckWallType2_0x261830; // 0x261b44 - g_ps2RecompiledFunctionTable[362192] = bhCheckWallType2_0x261830; // 0x261b48 - g_ps2RecompiledFunctionTable[362193] = bhCheckWallType2_0x261830; // 0x261b4c - g_ps2RecompiledFunctionTable[362194] = bhCheckWallType2_0x261830; // 0x261b50 - g_ps2RecompiledFunctionTable[362195] = bhCheckWallType2_0x261830; // 0x261b54 - g_ps2RecompiledFunctionTable[362196] = bhCheckWallType2_0x261830; // 0x261b58 - g_ps2RecompiledFunctionTable[362197] = bhCheckWallType2_0x261830; // 0x261b5c - g_ps2RecompiledFunctionTable[362198] = bhCheckWallType2_0x261830; // 0x261b60 - g_ps2RecompiledFunctionTable[362199] = bhCheckWallType2_0x261830; // 0x261b64 - g_ps2RecompiledFunctionTable[362200] = bhCheckWallType2_0x261830; // 0x261b68 - g_ps2RecompiledFunctionTable[362201] = bhCheckWallType2_0x261830; // 0x261b6c - g_ps2RecompiledFunctionTable[362202] = bhCheckWallType2_0x261830; // 0x261b70 - g_ps2RecompiledFunctionTable[362203] = bhCheckWallType2_0x261830; // 0x261b74 - g_ps2RecompiledFunctionTable[362204] = bhCheckWallType2_0x261830; // 0x261b78 - g_ps2RecompiledFunctionTable[362205] = bhCheckWallType2_0x261830; // 0x261b7c - g_ps2RecompiledFunctionTable[362206] = bhCheckWallType2_0x261830; // 0x261b80 - g_ps2RecompiledFunctionTable[362207] = bhCheckWallType2_0x261830; // 0x261b84 - g_ps2RecompiledFunctionTable[362208] = bhCheckWallType2_0x261830; // 0x261b88 - g_ps2RecompiledFunctionTable[362209] = bhCheckWallType2_0x261830; // 0x261b8c - g_ps2RecompiledFunctionTable[362210] = bhCheckWallType2_0x261830; // 0x261b90 - g_ps2RecompiledFunctionTable[362211] = bhCheckWallType2_0x261830; // 0x261b94 - g_ps2RecompiledFunctionTable[362212] = bhCheckWallType2_0x261830; // 0x261b98 - g_ps2RecompiledFunctionTable[362213] = bhCheckWallType2_0x261830; // 0x261b9c - g_ps2RecompiledFunctionTable[362214] = bhCheckWallType2_0x261830; // 0x261ba0 - g_ps2RecompiledFunctionTable[362215] = bhCheckWallType2_0x261830; // 0x261ba4 - g_ps2RecompiledFunctionTable[362216] = bhCheckWallType2_0x261830; // 0x261ba8 - g_ps2RecompiledFunctionTable[362217] = bhCheckWallType2_0x261830; // 0x261bac - g_ps2RecompiledFunctionTable[362218] = bhCheckWallType2_0x261830; // 0x261bb0 - g_ps2RecompiledFunctionTable[362219] = bhCheckWallType2_0x261830; // 0x261bb4 - g_ps2RecompiledFunctionTable[362220] = bhCheckWallType2_0x261830; // 0x261bb8 - g_ps2RecompiledFunctionTable[362221] = bhCheckWallType2_0x261830; // 0x261bbc - g_ps2RecompiledFunctionTable[362222] = bhCheckWallType2_0x261830; // 0x261bc0 - g_ps2RecompiledFunctionTable[362223] = bhCheckWallType2_0x261830; // 0x261bc4 - g_ps2RecompiledFunctionTable[362224] = bhCheckWallType2_0x261830; // 0x261bc8 - g_ps2RecompiledFunctionTable[362225] = bhCheckWallType2_0x261830; // 0x261bcc - g_ps2RecompiledFunctionTable[362226] = bhCheckWallType2_0x261830; // 0x261bd0 - g_ps2RecompiledFunctionTable[362227] = bhCheckWallType2_0x261830; // 0x261bd4 - g_ps2RecompiledFunctionTable[362228] = bhCheckWallType2_0x261830; // 0x261bd8 - g_ps2RecompiledFunctionTable[362229] = bhCheckWallType2_0x261830; // 0x261bdc - g_ps2RecompiledFunctionTable[362230] = bhCheckWallType2_0x261830; // 0x261be0 - g_ps2RecompiledFunctionTable[362231] = bhCheckWallType2_0x261830; // 0x261be4 - g_ps2RecompiledFunctionTable[362232] = bhCheckWallType2_0x261830; // 0x261be8 - g_ps2RecompiledFunctionTable[362233] = bhCheckWallType2_0x261830; // 0x261bec - g_ps2RecompiledFunctionTable[362234] = bhCheckWallType2_0x261830; // 0x261bf0 - g_ps2RecompiledFunctionTable[362235] = bhCheckWallType2_0x261830; // 0x261bf4 - g_ps2RecompiledFunctionTable[362236] = bhCheckWallType2_0x261830; // 0x261bf8 - g_ps2RecompiledFunctionTable[362237] = bhCheckWallType2_0x261830; // 0x261bfc - g_ps2RecompiledFunctionTable[362238] = bhCheckWallType2_0x261830; // 0x261c00 - g_ps2RecompiledFunctionTable[362239] = bhCheckWallType2_0x261830; // 0x261c04 - g_ps2RecompiledFunctionTable[362240] = bhCheckWallType2_0x261830; // 0x261c08 - g_ps2RecompiledFunctionTable[362241] = bhCheckWallType2_0x261830; // 0x261c0c - g_ps2RecompiledFunctionTable[362242] = bhCheckWallType2_0x261830; // 0x261c10 - g_ps2RecompiledFunctionTable[362243] = bhCheckWallType2_0x261830; // 0x261c14 - g_ps2RecompiledFunctionTable[362244] = bhCheckWallType2_0x261830; // 0x261c18 - g_ps2RecompiledFunctionTable[362245] = bhCheckWallType2_0x261830; // 0x261c1c - g_ps2RecompiledFunctionTable[362246] = bhCheckWallType2_0x261830; // 0x261c20 - g_ps2RecompiledFunctionTable[362247] = bhCheckWallType2_0x261830; // 0x261c24 - g_ps2RecompiledFunctionTable[362248] = bhCheckWallType2_0x261830; // 0x261c28 - g_ps2RecompiledFunctionTable[362249] = bhCheckWallType2_0x261830; // 0x261c2c - g_ps2RecompiledFunctionTable[362250] = bhCheckWallType2_0x261830; // 0x261c30 - g_ps2RecompiledFunctionTable[362251] = bhCheckWallType2_0x261830; // 0x261c34 - g_ps2RecompiledFunctionTable[362252] = bhCheckWallType2_0x261830; // 0x261c38 - g_ps2RecompiledFunctionTable[362253] = bhCheckWallType2_0x261830; // 0x261c3c - g_ps2RecompiledFunctionTable[362254] = bhCheckWallType2_0x261830; // 0x261c40 - g_ps2RecompiledFunctionTable[362255] = bhCheckWallType2_0x261830; // 0x261c44 - g_ps2RecompiledFunctionTable[362256] = bhCheckWallType2_0x261830; // 0x261c48 - g_ps2RecompiledFunctionTable[362257] = bhCheckWallType2_0x261830; // 0x261c4c - g_ps2RecompiledFunctionTable[362258] = bhCheckWallType2_0x261830; // 0x261c50 - g_ps2RecompiledFunctionTable[362259] = bhCheckWallType2_0x261830; // 0x261c54 - g_ps2RecompiledFunctionTable[362260] = bhCheckWallType2_0x261830; // 0x261c58 - g_ps2RecompiledFunctionTable[362261] = bhCheckWallType2_0x261830; // 0x261c5c - g_ps2RecompiledFunctionTable[362262] = bhCheckWallType2_0x261830; // 0x261c60 - g_ps2RecompiledFunctionTable[362263] = bhCheckWallType2_0x261830; // 0x261c64 - g_ps2RecompiledFunctionTable[362264] = bhCheckWallType2_0x261830; // 0x261c68 - g_ps2RecompiledFunctionTable[362265] = bhCheckWallType2_0x261830; // 0x261c6c - g_ps2RecompiledFunctionTable[362266] = bhCheckWallType2_0x261830; // 0x261c70 - g_ps2RecompiledFunctionTable[362267] = bhCheckWallType2_0x261830; // 0x261c74 - g_ps2RecompiledFunctionTable[362268] = bhCheckWallType2_0x261830; // 0x261c78 - g_ps2RecompiledFunctionTable[362269] = bhCheckWallType2_0x261830; // 0x261c7c - g_ps2RecompiledFunctionTable[362270] = bhCheckWallType2_0x261830; // 0x261c80 - g_ps2RecompiledFunctionTable[362271] = bhCheckWallType2_0x261830; // 0x261c84 - g_ps2RecompiledFunctionTable[362272] = bhCheckWallType2_0x261830; // 0x261c88 - g_ps2RecompiledFunctionTable[362273] = bhCheckWallType2_0x261830; // 0x261c8c - g_ps2RecompiledFunctionTable[362274] = bhCheckWallType2_0x261830; // 0x261c90 - g_ps2RecompiledFunctionTable[362275] = bhCheckWallType2_0x261830; // 0x261c94 - g_ps2RecompiledFunctionTable[362276] = bhCheckWallType2_0x261830; // 0x261c98 - g_ps2RecompiledFunctionTable[362277] = bhCheckWallType2_0x261830; // 0x261c9c - g_ps2RecompiledFunctionTable[362278] = bhCheckWallType2_0x261830; // 0x261ca0 - g_ps2RecompiledFunctionTable[362279] = bhCheckWallType2_0x261830; // 0x261ca4 - g_ps2RecompiledFunctionTable[362280] = bhCheckWallType2_0x261830; // 0x261ca8 - g_ps2RecompiledFunctionTable[362281] = bhCheckWallType2_0x261830; // 0x261cac - g_ps2RecompiledFunctionTable[362282] = bhCheckWallType2_0x261830; // 0x261cb0 - g_ps2RecompiledFunctionTable[362283] = bhCheckWallType2_0x261830; // 0x261cb4 - g_ps2RecompiledFunctionTable[362284] = bhCheckWallType2_0x261830; // 0x261cb8 - g_ps2RecompiledFunctionTable[362285] = bhCheckWallType2_0x261830; // 0x261cbc - g_ps2RecompiledFunctionTable[362286] = bhCheckWallType2_0x261830; // 0x261cc0 - g_ps2RecompiledFunctionTable[362287] = bhCheckWallType2_0x261830; // 0x261cc4 - g_ps2RecompiledFunctionTable[362288] = bhCheckWallType2_0x261830; // 0x261cc8 - g_ps2RecompiledFunctionTable[362289] = bhCheckWallType2_0x261830; // 0x261ccc - g_ps2RecompiledFunctionTable[362290] = bhCheckWallType2_0x261830; // 0x261cd0 - g_ps2RecompiledFunctionTable[362291] = bhCheckWallType2_0x261830; // 0x261cd4 - g_ps2RecompiledFunctionTable[362292] = bhCheckWallType2_0x261830; // 0x261cd8 - g_ps2RecompiledFunctionTable[362293] = bhCheckWallType2_0x261830; // 0x261cdc - g_ps2RecompiledFunctionTable[362294] = bhCheckWallType2_0x261830; // 0x261ce0 - g_ps2RecompiledFunctionTable[362295] = bhCheckWallType2_0x261830; // 0x261ce4 - g_ps2RecompiledFunctionTable[362296] = bhCheckWallType2_0x261830; // 0x261ce8 - g_ps2RecompiledFunctionTable[362297] = bhCheckWallType2_0x261830; // 0x261cec - g_ps2RecompiledFunctionTable[362298] = bhCheckWallType2_0x261830; // 0x261cf0 - g_ps2RecompiledFunctionTable[362299] = bhCheckWallType2_0x261830; // 0x261cf4 - g_ps2RecompiledFunctionTable[362300] = bhCheckWallType2_0x261830; // 0x261cf8 - g_ps2RecompiledFunctionTable[362301] = bhCheckWallType2_0x261830; // 0x261cfc - g_ps2RecompiledFunctionTable[362302] = bhCheckWallType2_0x261830; // 0x261d00 - g_ps2RecompiledFunctionTable[362303] = bhCheckWallType2_0x261830; // 0x261d04 - g_ps2RecompiledFunctionTable[362304] = bhCheckWallType2_0x261830; // 0x261d08 - g_ps2RecompiledFunctionTable[362305] = bhCheckWallType2_0x261830; // 0x261d0c - g_ps2RecompiledFunctionTable[362306] = bhCheckWallType2_0x261830; // 0x261d10 - g_ps2RecompiledFunctionTable[362307] = bhCheckWallType2_0x261830; // 0x261d14 - g_ps2RecompiledFunctionTable[362308] = bhCheckWallType2_0x261830; // 0x261d18 - g_ps2RecompiledFunctionTable[362309] = bhCheckWallType2_0x261830; // 0x261d1c - g_ps2RecompiledFunctionTable[362310] = bhCheckWallType2_0x261830; // 0x261d20 - g_ps2RecompiledFunctionTable[362311] = bhCheckWallType2_0x261830; // 0x261d24 - g_ps2RecompiledFunctionTable[362312] = bhCheckWallType2_0x261830; // 0x261d28 - g_ps2RecompiledFunctionTable[362313] = bhCheckWallType2_0x261830; // 0x261d2c - g_ps2RecompiledFunctionTable[362314] = bhCheckWallType2_0x261830; // 0x261d30 - g_ps2RecompiledFunctionTable[362315] = bhCheckWallType2_0x261830; // 0x261d34 - g_ps2RecompiledFunctionTable[362316] = bhCheckWallType2_0x261830; // 0x261d38 - g_ps2RecompiledFunctionTable[362317] = bhCheckWallType2_0x261830; // 0x261d3c - g_ps2RecompiledFunctionTable[362318] = bhCheckWallType2_0x261830; // 0x261d40 - g_ps2RecompiledFunctionTable[362319] = bhCheckWallType2_0x261830; // 0x261d44 - g_ps2RecompiledFunctionTable[362320] = bhCheckWallType2_0x261830; // 0x261d48 - g_ps2RecompiledFunctionTable[362321] = bhCheckWallType2_0x261830; // 0x261d4c - g_ps2RecompiledFunctionTable[362322] = bhCheckWallType2_0x261830; // 0x261d50 - g_ps2RecompiledFunctionTable[362323] = bhCheckWallType2_0x261830; // 0x261d54 - g_ps2RecompiledFunctionTable[362324] = bhCheckWallType2_0x261830; // 0x261d58 - g_ps2RecompiledFunctionTable[362325] = bhCheckWallType2_0x261830; // 0x261d5c - g_ps2RecompiledFunctionTable[362326] = bhCheckWallType2_0x261830; // 0x261d60 - g_ps2RecompiledFunctionTable[362327] = bhCheckWallType2_0x261830; // 0x261d64 - g_ps2RecompiledFunctionTable[362328] = bhCheckWallType2_0x261830; // 0x261d68 - g_ps2RecompiledFunctionTable[362329] = bhCheckWallType2_0x261830; // 0x261d6c - g_ps2RecompiledFunctionTable[362330] = bhCheckWallType2_0x261830; // 0x261d70 - g_ps2RecompiledFunctionTable[362331] = bhCheckWallType2_0x261830; // 0x261d74 - g_ps2RecompiledFunctionTable[362332] = bhCheckWallType2_0x261830; // 0x261d78 - g_ps2RecompiledFunctionTable[362333] = bhCheckWallType2_0x261830; // 0x261d7c - g_ps2RecompiledFunctionTable[362334] = bhCheckWallType2_0x261830; // 0x261d80 - g_ps2RecompiledFunctionTable[362335] = bhCheckWallType2_0x261830; // 0x261d84 - g_ps2RecompiledFunctionTable[362336] = bhCheckWallType2_0x261830; // 0x261d88 - g_ps2RecompiledFunctionTable[362337] = bhCheckWallType2_0x261830; // 0x261d8c - g_ps2RecompiledFunctionTable[362338] = bhCheckWallType2_0x261830; // 0x261d90 - g_ps2RecompiledFunctionTable[362339] = bhCheckWallType2_0x261830; // 0x261d94 - g_ps2RecompiledFunctionTable[362340] = bhCheckWallType2_0x261830; // 0x261d98 - g_ps2RecompiledFunctionTable[362341] = bhCheckWallType2_0x261830; // 0x261d9c - g_ps2RecompiledFunctionTable[362342] = bhCheckWallType2_0x261830; // 0x261da0 - g_ps2RecompiledFunctionTable[362343] = bhCheckWallType2_0x261830; // 0x261da4 - g_ps2RecompiledFunctionTable[362344] = bhCheckWallType2_0x261830; // 0x261da8 - g_ps2RecompiledFunctionTable[362345] = bhCheckWallType2_0x261830; // 0x261dac - g_ps2RecompiledFunctionTable[362346] = bhCheckWallType2_0x261830; // 0x261db0 - g_ps2RecompiledFunctionTable[362347] = bhCheckWallType2_0x261830; // 0x261db4 - g_ps2RecompiledFunctionTable[362348] = bhCheckWallType2_0x261830; // 0x261db8 - g_ps2RecompiledFunctionTable[362349] = bhCheckWallType2_0x261830; // 0x261dbc - g_ps2RecompiledFunctionTable[362350] = bhCheckWallType2_0x261830; // 0x261dc0 - g_ps2RecompiledFunctionTable[362351] = bhCheckWallType2_0x261830; // 0x261dc4 - g_ps2RecompiledFunctionTable[362352] = bhCheckWallType2_0x261830; // 0x261dc8 - g_ps2RecompiledFunctionTable[362353] = bhCheckWallType2_0x261830; // 0x261dcc - g_ps2RecompiledFunctionTable[362354] = bhCheckWallType2_0x261830; // 0x261dd0 - g_ps2RecompiledFunctionTable[362355] = bhCheckWallType2_0x261830; // 0x261dd4 - g_ps2RecompiledFunctionTable[362356] = bhCheckWallType2_0x261830; // 0x261dd8 - g_ps2RecompiledFunctionTable[362357] = bhCheckWallType2_0x261830; // 0x261ddc - g_ps2RecompiledFunctionTable[362358] = bhCheckWallType2_0x261830; // 0x261de0 - g_ps2RecompiledFunctionTable[362359] = bhCheckWallType2_0x261830; // 0x261de4 - g_ps2RecompiledFunctionTable[362360] = bhCheckWallType2_0x261830; // 0x261de8 - g_ps2RecompiledFunctionTable[362361] = bhCheckWallType2_0x261830; // 0x261dec - g_ps2RecompiledFunctionTable[362362] = bhCheckWallType2_0x261830; // 0x261df0 - g_ps2RecompiledFunctionTable[362363] = bhCheckWallType2_0x261830; // 0x261df4 - g_ps2RecompiledFunctionTable[362364] = bhCheckWallType2_0x261830; // 0x261df8 - g_ps2RecompiledFunctionTable[362365] = bhCheckWallType2_0x261830; // 0x261dfc - g_ps2RecompiledFunctionTable[362366] = bhCheckWallType2_0x261830; // 0x261e00 - g_ps2RecompiledFunctionTable[362367] = bhCheckWallType2_0x261830; // 0x261e04 - g_ps2RecompiledFunctionTable[362368] = bhCheckWallType2_0x261830; // 0x261e08 - g_ps2RecompiledFunctionTable[362369] = bhCheckWallType2_0x261830; // 0x261e0c - g_ps2RecompiledFunctionTable[362370] = bhCheckWallType2_0x261830; // 0x261e10 - g_ps2RecompiledFunctionTable[362371] = bhCheckWallType2_0x261830; // 0x261e14 - g_ps2RecompiledFunctionTable[362372] = bhCheckWallType2_0x261830; // 0x261e18 - g_ps2RecompiledFunctionTable[362373] = bhCheckWallType2_0x261830; // 0x261e1c - g_ps2RecompiledFunctionTable[362374] = bhCheckWallType2_0x261830; // 0x261e20 - g_ps2RecompiledFunctionTable[362375] = bhCheckWallType2_0x261830; // 0x261e24 - g_ps2RecompiledFunctionTable[362376] = bhCheckWallType2_0x261830; // 0x261e28 - g_ps2RecompiledFunctionTable[362377] = bhCheckWallType2_0x261830; // 0x261e2c - g_ps2RecompiledFunctionTable[362378] = bhCheckWallType2_0x261830; // 0x261e30 - g_ps2RecompiledFunctionTable[362379] = bhCheckWallType2_0x261830; // 0x261e34 - g_ps2RecompiledFunctionTable[362380] = bhCheckWallType2_0x261830; // 0x261e38 - g_ps2RecompiledFunctionTable[362381] = bhCheckWallType2_0x261830; // 0x261e3c - g_ps2RecompiledFunctionTable[362382] = bhCheckWallType2_0x261830; // 0x261e40 - g_ps2RecompiledFunctionTable[362383] = bhCheckWallType2_0x261830; // 0x261e44 - g_ps2RecompiledFunctionTable[362384] = bhCheckWallType2_0x261830; // 0x261e48 - g_ps2RecompiledFunctionTable[362385] = bhCheckWallType2_0x261830; // 0x261e4c - g_ps2RecompiledFunctionTable[362386] = bhCheckWallType2_0x261830; // 0x261e50 - g_ps2RecompiledFunctionTable[362387] = bhCheckWallType2_0x261830; // 0x261e54 - g_ps2RecompiledFunctionTable[362388] = bhCheckWallType2_0x261830; // 0x261e58 - g_ps2RecompiledFunctionTable[362389] = bhCheckWallType2_0x261830; // 0x261e5c - g_ps2RecompiledFunctionTable[362390] = bhCheckWallType2_0x261830; // 0x261e60 - g_ps2RecompiledFunctionTable[362391] = bhCheckWallType2_0x261830; // 0x261e64 - g_ps2RecompiledFunctionTable[362392] = bhCheckWallType2_0x261830; // 0x261e68 - g_ps2RecompiledFunctionTable[362393] = bhCheckWallType2_0x261830; // 0x261e6c - g_ps2RecompiledFunctionTable[362394] = bhCheckWallType2_0x261830; // 0x261e70 - g_ps2RecompiledFunctionTable[362395] = bhCheckWallType2_0x261830; // 0x261e74 - g_ps2RecompiledFunctionTable[362396] = bhCheckWallType2_0x261830; // 0x261e78 - g_ps2RecompiledFunctionTable[362397] = bhCheckWallType2_0x261830; // 0x261e7c - g_ps2RecompiledFunctionTable[362398] = bhCheckWallType2_0x261830; // 0x261e80 - g_ps2RecompiledFunctionTable[362399] = bhCheckWallType2_0x261830; // 0x261e84 - g_ps2RecompiledFunctionTable[362400] = bhCheckWallType2_0x261830; // 0x261e88 - g_ps2RecompiledFunctionTable[362401] = bhCheckWallType2_0x261830; // 0x261e8c - g_ps2RecompiledFunctionTable[362402] = bhCheckWallType2_0x261830; // 0x261e90 - g_ps2RecompiledFunctionTable[362403] = bhCheckWallType2_0x261830; // 0x261e94 - g_ps2RecompiledFunctionTable[362404] = bhCheckWallType2_0x261830; // 0x261e98 - g_ps2RecompiledFunctionTable[362405] = bhCheckWallType2_0x261830; // 0x261e9c - g_ps2RecompiledFunctionTable[362406] = bhCheckWallType2_0x261830; // 0x261ea0 - g_ps2RecompiledFunctionTable[362407] = bhCheckWallType2_0x261830; // 0x261ea4 - g_ps2RecompiledFunctionTable[362410] = bhCheckWallRefAngle_0x261eb0; // 0x261eb0 - g_ps2RecompiledFunctionTable[362411] = bhCheckWallRefAngle_0x261eb0; // 0x261eb4 - g_ps2RecompiledFunctionTable[362412] = bhCheckWallRefAngle_0x261eb0; // 0x261eb8 - g_ps2RecompiledFunctionTable[362413] = bhCheckWallRefAngle_0x261eb0; // 0x261ebc - g_ps2RecompiledFunctionTable[362414] = bhCheckWallRefAngle_0x261eb0; // 0x261ec0 - g_ps2RecompiledFunctionTable[362415] = bhCheckWallRefAngle_0x261eb0; // 0x261ec4 - g_ps2RecompiledFunctionTable[362416] = bhCheckWallRefAngle_0x261eb0; // 0x261ec8 - g_ps2RecompiledFunctionTable[362417] = bhCheckWallRefAngle_0x261eb0; // 0x261ecc - g_ps2RecompiledFunctionTable[362418] = bhCheckWallRefAngle_0x261eb0; // 0x261ed0 - g_ps2RecompiledFunctionTable[362419] = bhCheckWallRefAngle_0x261eb0; // 0x261ed4 - g_ps2RecompiledFunctionTable[362420] = bhCheckWallRefAngle_0x261eb0; // 0x261ed8 - g_ps2RecompiledFunctionTable[362421] = bhCheckWallRefAngle_0x261eb0; // 0x261edc - g_ps2RecompiledFunctionTable[362422] = bhCheckWallRefAngle_0x261eb0; // 0x261ee0 - g_ps2RecompiledFunctionTable[362423] = bhCheckWallRefAngle_0x261eb0; // 0x261ee4 - g_ps2RecompiledFunctionTable[362424] = bhCheckWallRefAngle_0x261eb0; // 0x261ee8 - g_ps2RecompiledFunctionTable[362425] = bhCheckWallRefAngle_0x261eb0; // 0x261eec - g_ps2RecompiledFunctionTable[362426] = bhCheckWallRefAngle_0x261eb0; // 0x261ef0 - g_ps2RecompiledFunctionTable[362427] = bhCheckWallRefAngle_0x261eb0; // 0x261ef4 - g_ps2RecompiledFunctionTable[362428] = bhCheckWallRefAngle_0x261eb0; // 0x261ef8 - g_ps2RecompiledFunctionTable[362429] = bhCheckWallRefAngle_0x261eb0; // 0x261efc - g_ps2RecompiledFunctionTable[362430] = bhCheckWallRefAngle_0x261eb0; // 0x261f00 - g_ps2RecompiledFunctionTable[362431] = bhCheckWallRefAngle_0x261eb0; // 0x261f04 - g_ps2RecompiledFunctionTable[362432] = bhCheckWallRefAngle_0x261eb0; // 0x261f08 - g_ps2RecompiledFunctionTable[362433] = bhCheckWallRefAngle_0x261eb0; // 0x261f0c - g_ps2RecompiledFunctionTable[362434] = bhCheckWallRefAngle_0x261eb0; // 0x261f10 - g_ps2RecompiledFunctionTable[362435] = bhCheckWallRefAngle_0x261eb0; // 0x261f14 - g_ps2RecompiledFunctionTable[362436] = bhCheckWallRefAngle_0x261eb0; // 0x261f18 - g_ps2RecompiledFunctionTable[362437] = bhCheckWallRefAngle_0x261eb0; // 0x261f1c - g_ps2RecompiledFunctionTable[362438] = bhCheckWallRefAngle_0x261eb0; // 0x261f20 - g_ps2RecompiledFunctionTable[362439] = bhCheckWallRefAngle_0x261eb0; // 0x261f24 - g_ps2RecompiledFunctionTable[362440] = bhCheckWallRefAngle_0x261eb0; // 0x261f28 - g_ps2RecompiledFunctionTable[362441] = bhCheckWallRefAngle_0x261eb0; // 0x261f2c - g_ps2RecompiledFunctionTable[362442] = bhCheckWallRefAngle_0x261eb0; // 0x261f30 - g_ps2RecompiledFunctionTable[362443] = bhCheckWallRefAngle_0x261eb0; // 0x261f34 - g_ps2RecompiledFunctionTable[362444] = bhCheckWallRefAngle_0x261eb0; // 0x261f38 - g_ps2RecompiledFunctionTable[362445] = bhCheckWallRefAngle_0x261eb0; // 0x261f3c - g_ps2RecompiledFunctionTable[362446] = bhCheckWallRefAngle_0x261eb0; // 0x261f40 - g_ps2RecompiledFunctionTable[362447] = bhCheckWallRefAngle_0x261eb0; // 0x261f44 - g_ps2RecompiledFunctionTable[362448] = bhCheckWallRefAngle_0x261eb0; // 0x261f48 - g_ps2RecompiledFunctionTable[362449] = bhCheckWallRefAngle_0x261eb0; // 0x261f4c - g_ps2RecompiledFunctionTable[362450] = bhCheckWallRefAngle_0x261eb0; // 0x261f50 - g_ps2RecompiledFunctionTable[362451] = bhCheckWallRefAngle_0x261eb0; // 0x261f54 - g_ps2RecompiledFunctionTable[362452] = bhCheckWallRefAngle_0x261eb0; // 0x261f58 - g_ps2RecompiledFunctionTable[362453] = bhCheckWallRefAngle_0x261eb0; // 0x261f5c - g_ps2RecompiledFunctionTable[362454] = bhCheckWallRefAngle_0x261eb0; // 0x261f60 - g_ps2RecompiledFunctionTable[362455] = bhCheckWallRefAngle_0x261eb0; // 0x261f64 - g_ps2RecompiledFunctionTable[362456] = bhCheckWallRefAngle_0x261eb0; // 0x261f68 - g_ps2RecompiledFunctionTable[362457] = bhCheckWallRefAngle_0x261eb0; // 0x261f6c - g_ps2RecompiledFunctionTable[362458] = bhCheckWallRefAngle_0x261eb0; // 0x261f70 - g_ps2RecompiledFunctionTable[362459] = bhCheckWallRefAngle_0x261eb0; // 0x261f74 - g_ps2RecompiledFunctionTable[362460] = bhCheckWallRefAngle_0x261eb0; // 0x261f78 - g_ps2RecompiledFunctionTable[362461] = bhCheckWallRefAngle_0x261eb0; // 0x261f7c - g_ps2RecompiledFunctionTable[362462] = bhCheckWallRefAngle_0x261eb0; // 0x261f80 - g_ps2RecompiledFunctionTable[362463] = bhCheckWallRefAngle_0x261eb0; // 0x261f84 - g_ps2RecompiledFunctionTable[362464] = bhCheckWallRefAngle_0x261eb0; // 0x261f88 - g_ps2RecompiledFunctionTable[362465] = bhCheckWallRefAngle_0x261eb0; // 0x261f8c - g_ps2RecompiledFunctionTable[362466] = bhCheckWallRefAngle_0x261eb0; // 0x261f90 - g_ps2RecompiledFunctionTable[362467] = bhCheckWallRefAngle_0x261eb0; // 0x261f94 - g_ps2RecompiledFunctionTable[362468] = bhCheckWallRefAngle_0x261eb0; // 0x261f98 - g_ps2RecompiledFunctionTable[362469] = bhCheckWallRefAngle_0x261eb0; // 0x261f9c - g_ps2RecompiledFunctionTable[362470] = bhCheckWallRefAngle_0x261eb0; // 0x261fa0 - g_ps2RecompiledFunctionTable[362471] = bhCheckWallRefAngle_0x261eb0; // 0x261fa4 - g_ps2RecompiledFunctionTable[362472] = bhCheckWallRefAngle_0x261eb0; // 0x261fa8 - g_ps2RecompiledFunctionTable[362473] = bhCheckWallRefAngle_0x261eb0; // 0x261fac - g_ps2RecompiledFunctionTable[362474] = bhCheckWallRefAngle_0x261eb0; // 0x261fb0 - g_ps2RecompiledFunctionTable[362475] = bhCheckWallRefAngle_0x261eb0; // 0x261fb4 - g_ps2RecompiledFunctionTable[362476] = bhCheckWallRefAngle_0x261eb0; // 0x261fb8 - g_ps2RecompiledFunctionTable[362477] = bhCheckWallRefAngle_0x261eb0; // 0x261fbc - g_ps2RecompiledFunctionTable[362478] = bhCheckWallRefAngle_0x261eb0; // 0x261fc0 - g_ps2RecompiledFunctionTable[362479] = bhCheckWallRefAngle_0x261eb0; // 0x261fc4 - g_ps2RecompiledFunctionTable[362480] = bhCheckWallRefAngle_0x261eb0; // 0x261fc8 - g_ps2RecompiledFunctionTable[362481] = bhCheckWallRefAngle_0x261eb0; // 0x261fcc - g_ps2RecompiledFunctionTable[362482] = bhCheckWallRefAngle_0x261eb0; // 0x261fd0 - g_ps2RecompiledFunctionTable[362483] = bhCheckWallRefAngle_0x261eb0; // 0x261fd4 - g_ps2RecompiledFunctionTable[362484] = bhCheckWallRefAngle_0x261eb0; // 0x261fd8 - g_ps2RecompiledFunctionTable[362485] = bhCheckWallRefAngle_0x261eb0; // 0x261fdc - g_ps2RecompiledFunctionTable[362486] = bhCheckWallRefAngle_0x261eb0; // 0x261fe0 - g_ps2RecompiledFunctionTable[362487] = bhCheckWallRefAngle_0x261eb0; // 0x261fe4 - g_ps2RecompiledFunctionTable[362488] = bhCheckWallRefAngle_0x261eb0; // 0x261fe8 - g_ps2RecompiledFunctionTable[362489] = bhCheckWallRefAngle_0x261eb0; // 0x261fec - g_ps2RecompiledFunctionTable[362490] = bhCheckWallRefAngle_0x261eb0; // 0x261ff0 - g_ps2RecompiledFunctionTable[362491] = bhCheckWallRefAngle_0x261eb0; // 0x261ff4 - g_ps2RecompiledFunctionTable[362492] = bhCheckWallRefAngle_0x261eb0; // 0x261ff8 - g_ps2RecompiledFunctionTable[362493] = bhCheckWallRefAngle_0x261eb0; // 0x261ffc - g_ps2RecompiledFunctionTable[362494] = bhCheckWallRefAngle_0x261eb0; // 0x262000 - g_ps2RecompiledFunctionTable[362495] = bhCheckWallRefAngle_0x261eb0; // 0x262004 - g_ps2RecompiledFunctionTable[362496] = bhCheckWallRefAngle_0x261eb0; // 0x262008 - g_ps2RecompiledFunctionTable[362497] = bhCheckWallRefAngle_0x261eb0; // 0x26200c - g_ps2RecompiledFunctionTable[362498] = bhCheckWallRefAngle_0x261eb0; // 0x262010 - g_ps2RecompiledFunctionTable[362499] = bhCheckWallRefAngle_0x261eb0; // 0x262014 - g_ps2RecompiledFunctionTable[362500] = bhCheckWallRefAngle_0x261eb0; // 0x262018 - g_ps2RecompiledFunctionTable[362501] = bhCheckWallRefAngle_0x261eb0; // 0x26201c - g_ps2RecompiledFunctionTable[362502] = bhCheckWallRefAngle_0x261eb0; // 0x262020 - g_ps2RecompiledFunctionTable[362503] = bhCheckWallRefAngle_0x261eb0; // 0x262024 - g_ps2RecompiledFunctionTable[362504] = bhCheckWallRefAngle_0x261eb0; // 0x262028 - g_ps2RecompiledFunctionTable[362505] = bhCheckWallRefAngle_0x261eb0; // 0x26202c - g_ps2RecompiledFunctionTable[362506] = bhCheckWallRefAngle_0x261eb0; // 0x262030 - g_ps2RecompiledFunctionTable[362507] = bhCheckWallRefAngle_0x261eb0; // 0x262034 - g_ps2RecompiledFunctionTable[362508] = bhCheckWallRefAngle_0x261eb0; // 0x262038 - g_ps2RecompiledFunctionTable[362509] = bhCheckWallRefAngle_0x261eb0; // 0x26203c - g_ps2RecompiledFunctionTable[362510] = bhCheckWallRefAngle_0x261eb0; // 0x262040 - g_ps2RecompiledFunctionTable[362511] = bhCheckWallRefAngle_0x261eb0; // 0x262044 - g_ps2RecompiledFunctionTable[362512] = bhCheckWallRefAngle_0x261eb0; // 0x262048 - g_ps2RecompiledFunctionTable[362513] = bhCheckWallRefAngle_0x261eb0; // 0x26204c - g_ps2RecompiledFunctionTable[362514] = bhCheckWallRefAngle_0x261eb0; // 0x262050 - g_ps2RecompiledFunctionTable[362515] = bhCheckWallRefAngle_0x261eb0; // 0x262054 - g_ps2RecompiledFunctionTable[362516] = bhCheckWallRefAngle_0x261eb0; // 0x262058 - g_ps2RecompiledFunctionTable[362517] = bhCheckWallRefAngle_0x261eb0; // 0x26205c - g_ps2RecompiledFunctionTable[362518] = bhCheckWallRefAngle_0x261eb0; // 0x262060 - g_ps2RecompiledFunctionTable[362519] = bhCheckWallRefAngle_0x261eb0; // 0x262064 - g_ps2RecompiledFunctionTable[362520] = bhCheckWallRefAngle_0x261eb0; // 0x262068 - g_ps2RecompiledFunctionTable[362521] = bhCheckWallRefAngle_0x261eb0; // 0x26206c - g_ps2RecompiledFunctionTable[362522] = bhCheckWallRefAngle_0x261eb0; // 0x262070 - g_ps2RecompiledFunctionTable[362523] = bhCheckWallRefAngle_0x261eb0; // 0x262074 - g_ps2RecompiledFunctionTable[362524] = bhCheckWallRefAngle_0x261eb0; // 0x262078 - g_ps2RecompiledFunctionTable[362525] = bhCheckWallRefAngle_0x261eb0; // 0x26207c - g_ps2RecompiledFunctionTable[362526] = bhCheckWallRefAngle_0x261eb0; // 0x262080 - g_ps2RecompiledFunctionTable[362527] = bhCheckWallRefAngle_0x261eb0; // 0x262084 - g_ps2RecompiledFunctionTable[362528] = bhCheckWallRefAngle_0x261eb0; // 0x262088 - g_ps2RecompiledFunctionTable[362529] = bhCheckWallRefAngle_0x261eb0; // 0x26208c - g_ps2RecompiledFunctionTable[362530] = bhCheckWallRefAngle_0x261eb0; // 0x262090 - g_ps2RecompiledFunctionTable[362531] = bhCheckWallRefAngle_0x261eb0; // 0x262094 - g_ps2RecompiledFunctionTable[362532] = bhCheckWallRefAngle_0x261eb0; // 0x262098 - g_ps2RecompiledFunctionTable[362533] = bhCheckWallRefAngle_0x261eb0; // 0x26209c - g_ps2RecompiledFunctionTable[362534] = bhCheckWallRefAngle_0x261eb0; // 0x2620a0 - g_ps2RecompiledFunctionTable[362535] = bhCheckWallRefAngle_0x261eb0; // 0x2620a4 - g_ps2RecompiledFunctionTable[362536] = bhCheckWallRefAngle_0x261eb0; // 0x2620a8 - g_ps2RecompiledFunctionTable[362537] = bhCheckWallRefAngle_0x261eb0; // 0x2620ac - g_ps2RecompiledFunctionTable[362538] = bhCheckWallRefAngle_0x261eb0; // 0x2620b0 - g_ps2RecompiledFunctionTable[362539] = bhCheckWallRefAngle_0x261eb0; // 0x2620b4 - g_ps2RecompiledFunctionTable[362540] = bhCheckWallRefAngle_0x261eb0; // 0x2620b8 - g_ps2RecompiledFunctionTable[362541] = bhCheckWallRefAngle_0x261eb0; // 0x2620bc - g_ps2RecompiledFunctionTable[362542] = bhCheckWallRefAngle_0x261eb0; // 0x2620c0 - g_ps2RecompiledFunctionTable[362543] = bhCheckWallRefAngle_0x261eb0; // 0x2620c4 - g_ps2RecompiledFunctionTable[362544] = bhCheckWallRefAngle_0x261eb0; // 0x2620c8 - g_ps2RecompiledFunctionTable[362545] = bhCheckWallRefAngle_0x261eb0; // 0x2620cc - g_ps2RecompiledFunctionTable[362546] = bhCheckWallRefAngle_0x261eb0; // 0x2620d0 - g_ps2RecompiledFunctionTable[362547] = bhCheckWallRefAngle_0x261eb0; // 0x2620d4 - g_ps2RecompiledFunctionTable[362548] = bhCheckWallRefAngle_0x261eb0; // 0x2620d8 - g_ps2RecompiledFunctionTable[362549] = bhCheckWallRefAngle_0x261eb0; // 0x2620dc - g_ps2RecompiledFunctionTable[362550] = bhCheckWallRefAngle_0x261eb0; // 0x2620e0 - g_ps2RecompiledFunctionTable[362551] = bhCheckWallRefAngle_0x261eb0; // 0x2620e4 - g_ps2RecompiledFunctionTable[362552] = bhCheckWallRefAngle_0x261eb0; // 0x2620e8 - g_ps2RecompiledFunctionTable[362553] = bhCheckWallRefAngle_0x261eb0; // 0x2620ec - g_ps2RecompiledFunctionTable[362554] = bhCheckWallRefAngle_0x261eb0; // 0x2620f0 - g_ps2RecompiledFunctionTable[362555] = bhCheckWallRefAngle_0x261eb0; // 0x2620f4 - g_ps2RecompiledFunctionTable[362556] = bhCheckWallRefAngle_0x261eb0; // 0x2620f8 - g_ps2RecompiledFunctionTable[362557] = bhCheckWallRefAngle_0x261eb0; // 0x2620fc - g_ps2RecompiledFunctionTable[362558] = bhCheckWallRefAngle_0x261eb0; // 0x262100 - g_ps2RecompiledFunctionTable[362559] = bhCheckWallRefAngle_0x261eb0; // 0x262104 - g_ps2RecompiledFunctionTable[362560] = bhCheckWallRefAngle_0x261eb0; // 0x262108 - g_ps2RecompiledFunctionTable[362561] = bhCheckWallRefAngle_0x261eb0; // 0x26210c - g_ps2RecompiledFunctionTable[362562] = bhCheckWallRefAngle_0x261eb0; // 0x262110 - g_ps2RecompiledFunctionTable[362563] = bhCheckWallRefAngle_0x261eb0; // 0x262114 - g_ps2RecompiledFunctionTable[362564] = bhCheckWallRefAngle_0x261eb0; // 0x262118 - g_ps2RecompiledFunctionTable[362565] = bhCheckWallRefAngle_0x261eb0; // 0x26211c - g_ps2RecompiledFunctionTable[362566] = bhCheckWallRefAngle_0x261eb0; // 0x262120 - g_ps2RecompiledFunctionTable[362567] = bhCheckWallRefAngle_0x261eb0; // 0x262124 - g_ps2RecompiledFunctionTable[362568] = bhCheckWallRefAngle_0x261eb0; // 0x262128 - g_ps2RecompiledFunctionTable[362569] = bhCheckWallRefAngle_0x261eb0; // 0x26212c - g_ps2RecompiledFunctionTable[362570] = bhCheckWallRefAngle_0x261eb0; // 0x262130 - g_ps2RecompiledFunctionTable[362571] = bhCheckWallRefAngle_0x261eb0; // 0x262134 - g_ps2RecompiledFunctionTable[362572] = bhCheckWallRefAngle_0x261eb0; // 0x262138 - g_ps2RecompiledFunctionTable[362573] = bhCheckWallRefAngle_0x261eb0; // 0x26213c - g_ps2RecompiledFunctionTable[362574] = bhCheckWallRefAngle_0x261eb0; // 0x262140 - g_ps2RecompiledFunctionTable[362575] = bhCheckWallRefAngle_0x261eb0; // 0x262144 - g_ps2RecompiledFunctionTable[362576] = bhCheckWallRefAngle_0x261eb0; // 0x262148 - g_ps2RecompiledFunctionTable[362577] = bhCheckWallRefAngle_0x261eb0; // 0x26214c - g_ps2RecompiledFunctionTable[362578] = bhCheckWallRefAngle_0x261eb0; // 0x262150 - g_ps2RecompiledFunctionTable[362579] = bhCheckWallRefAngle_0x261eb0; // 0x262154 - g_ps2RecompiledFunctionTable[362580] = bhCheckWallRefAngle_0x261eb0; // 0x262158 - g_ps2RecompiledFunctionTable[362581] = bhCheckWallRefAngle_0x261eb0; // 0x26215c - g_ps2RecompiledFunctionTable[362582] = bhCheckWallRefAngle_0x261eb0; // 0x262160 - g_ps2RecompiledFunctionTable[362583] = bhCheckWallRefAngle_0x261eb0; // 0x262164 - g_ps2RecompiledFunctionTable[362584] = bhCheckWallRefAngle_0x261eb0; // 0x262168 - g_ps2RecompiledFunctionTable[362585] = bhCheckWallRefAngle_0x261eb0; // 0x26216c - g_ps2RecompiledFunctionTable[362586] = bhCheckWallRefAngle_0x261eb0; // 0x262170 - g_ps2RecompiledFunctionTable[362587] = bhCheckWallRefAngle_0x261eb0; // 0x262174 - g_ps2RecompiledFunctionTable[362588] = bhCheckWallRefAngle_0x261eb0; // 0x262178 - g_ps2RecompiledFunctionTable[362589] = bhCheckWallRefAngle_0x261eb0; // 0x26217c - g_ps2RecompiledFunctionTable[362590] = bhCheckWallRefAngle_0x261eb0; // 0x262180 - g_ps2RecompiledFunctionTable[362591] = bhCheckWallRefAngle_0x261eb0; // 0x262184 - g_ps2RecompiledFunctionTable[362592] = bhCheckWallRefAngle_0x261eb0; // 0x262188 - g_ps2RecompiledFunctionTable[362593] = bhCheckWallRefAngle_0x261eb0; // 0x26218c - g_ps2RecompiledFunctionTable[362594] = bhCheckWallRefAngle_0x261eb0; // 0x262190 - g_ps2RecompiledFunctionTable[362595] = bhCheckWallRefAngle_0x261eb0; // 0x262194 - g_ps2RecompiledFunctionTable[362596] = bhCheckWallRefAngle_0x261eb0; // 0x262198 - g_ps2RecompiledFunctionTable[362597] = bhCheckWallRefAngle_0x261eb0; // 0x26219c - g_ps2RecompiledFunctionTable[362598] = bhCheckWallRefAngle_0x261eb0; // 0x2621a0 - g_ps2RecompiledFunctionTable[362599] = bhCheckWallRefAngle_0x261eb0; // 0x2621a4 - g_ps2RecompiledFunctionTable[362600] = bhCheckWallRefAngle_0x261eb0; // 0x2621a8 - g_ps2RecompiledFunctionTable[362601] = bhCheckWallRefAngle_0x261eb0; // 0x2621ac - g_ps2RecompiledFunctionTable[362602] = bhCheckWallRefAngle_0x261eb0; // 0x2621b0 - g_ps2RecompiledFunctionTable[362603] = bhCheckWallRefAngle_0x261eb0; // 0x2621b4 - g_ps2RecompiledFunctionTable[362604] = bhCheckWallRefAngle_0x261eb0; // 0x2621b8 - g_ps2RecompiledFunctionTable[362605] = bhCheckWallRefAngle_0x261eb0; // 0x2621bc - g_ps2RecompiledFunctionTable[362606] = bhCheckWallRefAngle_0x261eb0; // 0x2621c0 - g_ps2RecompiledFunctionTable[362607] = bhCheckWallRefAngle_0x261eb0; // 0x2621c4 - g_ps2RecompiledFunctionTable[362608] = bhCheckWallRefAngle_0x261eb0; // 0x2621c8 - g_ps2RecompiledFunctionTable[362609] = bhCheckWallRefAngle_0x261eb0; // 0x2621cc - g_ps2RecompiledFunctionTable[362610] = bhCheckWallRefAngle_0x261eb0; // 0x2621d0 - g_ps2RecompiledFunctionTable[362611] = bhCheckWallRefAngle_0x261eb0; // 0x2621d4 - g_ps2RecompiledFunctionTable[362612] = bhCheckWallRefAngle_0x261eb0; // 0x2621d8 - g_ps2RecompiledFunctionTable[362613] = bhCheckWallRefAngle_0x261eb0; // 0x2621dc - g_ps2RecompiledFunctionTable[362614] = bhCheckWallRefAngle_0x261eb0; // 0x2621e0 - g_ps2RecompiledFunctionTable[362615] = bhCheckWallRefAngle_0x261eb0; // 0x2621e4 - g_ps2RecompiledFunctionTable[362616] = bhCheckWallRefAngle_0x261eb0; // 0x2621e8 - g_ps2RecompiledFunctionTable[362617] = bhCheckWallRefAngle_0x261eb0; // 0x2621ec - g_ps2RecompiledFunctionTable[362618] = bhCheckWallRefAngle_0x261eb0; // 0x2621f0 - g_ps2RecompiledFunctionTable[362619] = bhCheckWallRefAngle_0x261eb0; // 0x2621f4 - g_ps2RecompiledFunctionTable[362620] = bhCheckWallRefAngle_0x261eb0; // 0x2621f8 - g_ps2RecompiledFunctionTable[362621] = bhCheckWallRefAngle_0x261eb0; // 0x2621fc - g_ps2RecompiledFunctionTable[362622] = bhCheckWallRefAngle_0x261eb0; // 0x262200 - g_ps2RecompiledFunctionTable[362623] = bhCheckWallRefAngle_0x261eb0; // 0x262204 - g_ps2RecompiledFunctionTable[362624] = bhCheckWallRefAngle_0x261eb0; // 0x262208 - g_ps2RecompiledFunctionTable[362625] = bhCheckWallRefAngle_0x261eb0; // 0x26220c - g_ps2RecompiledFunctionTable[362626] = bhCheckWallRefAngle_0x261eb0; // 0x262210 - g_ps2RecompiledFunctionTable[362627] = bhCheckWallRefAngle_0x261eb0; // 0x262214 - g_ps2RecompiledFunctionTable[362628] = bhCheckWallRefAngle_0x261eb0; // 0x262218 - g_ps2RecompiledFunctionTable[362629] = bhCheckWallRefAngle_0x261eb0; // 0x26221c - g_ps2RecompiledFunctionTable[362630] = bhCheckWallRefAngle_0x261eb0; // 0x262220 - g_ps2RecompiledFunctionTable[362631] = bhCheckWallRefAngle_0x261eb0; // 0x262224 - g_ps2RecompiledFunctionTable[362632] = bhCheckWallRefAngle_0x261eb0; // 0x262228 - g_ps2RecompiledFunctionTable[362633] = bhCheckWallRefAngle_0x261eb0; // 0x26222c - g_ps2RecompiledFunctionTable[362634] = bhCheckWallRefAngle_0x261eb0; // 0x262230 - g_ps2RecompiledFunctionTable[362635] = bhCheckWallRefAngle_0x261eb0; // 0x262234 - g_ps2RecompiledFunctionTable[362636] = bhCheckWallRefAngle_0x261eb0; // 0x262238 - g_ps2RecompiledFunctionTable[362637] = bhCheckWallRefAngle_0x261eb0; // 0x26223c - g_ps2RecompiledFunctionTable[362638] = bhCheckWallRefAngle_0x261eb0; // 0x262240 - g_ps2RecompiledFunctionTable[362639] = bhCheckWallRefAngle_0x261eb0; // 0x262244 - g_ps2RecompiledFunctionTable[362640] = bhCheckWallRefAngle_0x261eb0; // 0x262248 - g_ps2RecompiledFunctionTable[362641] = bhCheckWallRefAngle_0x261eb0; // 0x26224c - g_ps2RecompiledFunctionTable[362642] = bhCheckWallRefAngle_0x261eb0; // 0x262250 - g_ps2RecompiledFunctionTable[362643] = bhCheckWallRefAngle_0x261eb0; // 0x262254 - g_ps2RecompiledFunctionTable[362644] = bhCheckWallRefAngle_0x261eb0; // 0x262258 - g_ps2RecompiledFunctionTable[362645] = bhCheckWallRefAngle_0x261eb0; // 0x26225c - g_ps2RecompiledFunctionTable[362646] = bhCheckWallRefAngle_0x261eb0; // 0x262260 - g_ps2RecompiledFunctionTable[362647] = bhCheckWallRefAngle_0x261eb0; // 0x262264 - g_ps2RecompiledFunctionTable[362648] = bhCheckWallRefAngle_0x261eb0; // 0x262268 - g_ps2RecompiledFunctionTable[362649] = bhCheckWallRefAngle_0x261eb0; // 0x26226c - g_ps2RecompiledFunctionTable[362650] = bhCheckWallRefAngle_0x261eb0; // 0x262270 - g_ps2RecompiledFunctionTable[362651] = bhCheckWallRefAngle_0x261eb0; // 0x262274 - g_ps2RecompiledFunctionTable[362652] = bhCheckWallRefAngle_0x261eb0; // 0x262278 - g_ps2RecompiledFunctionTable[362653] = bhCheckWallRefAngle_0x261eb0; // 0x26227c - g_ps2RecompiledFunctionTable[362654] = bhCheckWallRefAngle_0x261eb0; // 0x262280 - g_ps2RecompiledFunctionTable[362655] = bhCheckWallRefAngle_0x261eb0; // 0x262284 - g_ps2RecompiledFunctionTable[362656] = bhCheckWallRefAngle_0x261eb0; // 0x262288 - g_ps2RecompiledFunctionTable[362657] = bhCheckWallRefAngle_0x261eb0; // 0x26228c - g_ps2RecompiledFunctionTable[362658] = bhCheckWallRefAngle_0x261eb0; // 0x262290 - g_ps2RecompiledFunctionTable[362659] = bhCheckWallRefAngle_0x261eb0; // 0x262294 - g_ps2RecompiledFunctionTable[362660] = bhCheckWallRefAngle_0x261eb0; // 0x262298 - g_ps2RecompiledFunctionTable[362661] = bhCheckWallRefAngle_0x261eb0; // 0x26229c - g_ps2RecompiledFunctionTable[362662] = bhCheckWallRefAngle_0x261eb0; // 0x2622a0 - g_ps2RecompiledFunctionTable[362663] = bhCheckWallRefAngle_0x261eb0; // 0x2622a4 - g_ps2RecompiledFunctionTable[362664] = bhCheckWallRefAngle_0x261eb0; // 0x2622a8 - g_ps2RecompiledFunctionTable[362665] = bhCheckWallRefAngle_0x261eb0; // 0x2622ac - g_ps2RecompiledFunctionTable[362666] = bhCheckWallRefAngle_0x261eb0; // 0x2622b0 - g_ps2RecompiledFunctionTable[362667] = bhCheckWallRefAngle_0x261eb0; // 0x2622b4 - g_ps2RecompiledFunctionTable[362668] = bhCheckWallRefAngle_0x261eb0; // 0x2622b8 - g_ps2RecompiledFunctionTable[362669] = bhCheckWallRefAngle_0x261eb0; // 0x2622bc - g_ps2RecompiledFunctionTable[362670] = bhCheckWallRefAngle_0x261eb0; // 0x2622c0 - g_ps2RecompiledFunctionTable[362671] = bhCheckWallRefAngle_0x261eb0; // 0x2622c4 - g_ps2RecompiledFunctionTable[362672] = bhCheckWallRefAngle_0x261eb0; // 0x2622c8 - g_ps2RecompiledFunctionTable[362673] = bhCheckWallRefAngle_0x261eb0; // 0x2622cc - g_ps2RecompiledFunctionTable[362674] = bhCheckWallRefAngle_0x261eb0; // 0x2622d0 - g_ps2RecompiledFunctionTable[362675] = bhCheckWallRefAngle_0x261eb0; // 0x2622d4 - g_ps2RecompiledFunctionTable[362676] = bhCheckWallRefAngle_0x261eb0; // 0x2622d8 - g_ps2RecompiledFunctionTable[362677] = bhCheckWallRefAngle_0x261eb0; // 0x2622dc - g_ps2RecompiledFunctionTable[362678] = bhCheckWallRefAngle_0x261eb0; // 0x2622e0 - g_ps2RecompiledFunctionTable[362679] = bhCheckWallRefAngle_0x261eb0; // 0x2622e4 - g_ps2RecompiledFunctionTable[362680] = bhCheckWallRefAngle_0x261eb0; // 0x2622e8 - g_ps2RecompiledFunctionTable[362681] = bhCheckWallRefAngle_0x261eb0; // 0x2622ec - g_ps2RecompiledFunctionTable[362682] = bhCheckWallRefAngle_0x261eb0; // 0x2622f0 - g_ps2RecompiledFunctionTable[362683] = bhCheckWallRefAngle_0x261eb0; // 0x2622f4 - g_ps2RecompiledFunctionTable[362684] = bhCheckWallRefAngle_0x261eb0; // 0x2622f8 - g_ps2RecompiledFunctionTable[362685] = bhCheckWallRefAngle_0x261eb0; // 0x2622fc - g_ps2RecompiledFunctionTable[362686] = bhCheckWallRefAngle_0x261eb0; // 0x262300 - g_ps2RecompiledFunctionTable[362687] = bhCheckWallRefAngle_0x261eb0; // 0x262304 - g_ps2RecompiledFunctionTable[362688] = bhCheckWallRefAngle_0x261eb0; // 0x262308 - g_ps2RecompiledFunctionTable[362689] = bhCheckWallRefAngle_0x261eb0; // 0x26230c - g_ps2RecompiledFunctionTable[362690] = bhCheckWallRefAngle_0x261eb0; // 0x262310 - g_ps2RecompiledFunctionTable[362691] = bhCheckWallRefAngle_0x261eb0; // 0x262314 - g_ps2RecompiledFunctionTable[362692] = bhCheckWallRefAngle_0x261eb0; // 0x262318 - g_ps2RecompiledFunctionTable[362693] = bhCheckWallRefAngle_0x261eb0; // 0x26231c - g_ps2RecompiledFunctionTable[362694] = bhCheckWallRefAngle_0x261eb0; // 0x262320 - g_ps2RecompiledFunctionTable[362695] = bhCheckWallRefAngle_0x261eb0; // 0x262324 - g_ps2RecompiledFunctionTable[362696] = bhCheckWallRefAngle_0x261eb0; // 0x262328 - g_ps2RecompiledFunctionTable[362697] = bhCheckWallRefAngle_0x261eb0; // 0x26232c - g_ps2RecompiledFunctionTable[362698] = bhCheckWallRefAngle_0x261eb0; // 0x262330 - g_ps2RecompiledFunctionTable[362699] = bhCheckWallRefAngle_0x261eb0; // 0x262334 - g_ps2RecompiledFunctionTable[362700] = bhCheckWallRefAngle_0x261eb0; // 0x262338 - g_ps2RecompiledFunctionTable[362701] = bhCheckWallRefAngle_0x261eb0; // 0x26233c - g_ps2RecompiledFunctionTable[362702] = bhCheckWallRefAngle_0x261eb0; // 0x262340 - g_ps2RecompiledFunctionTable[362703] = bhCheckWallRefAngle_0x261eb0; // 0x262344 - g_ps2RecompiledFunctionTable[362704] = bhCheckWallRefAngle_0x261eb0; // 0x262348 - g_ps2RecompiledFunctionTable[362705] = bhCheckWallRefAngle_0x261eb0; // 0x26234c - g_ps2RecompiledFunctionTable[362706] = bhCheckWallRefAngle_0x261eb0; // 0x262350 - g_ps2RecompiledFunctionTable[362707] = bhCheckWallRefAngle_0x261eb0; // 0x262354 - g_ps2RecompiledFunctionTable[362708] = bhCheckWallRefAngle_0x261eb0; // 0x262358 - g_ps2RecompiledFunctionTable[362709] = bhCheckWallRefAngle_0x261eb0; // 0x26235c - g_ps2RecompiledFunctionTable[362710] = bhCheckWallRefAngle_0x261eb0; // 0x262360 - g_ps2RecompiledFunctionTable[362711] = bhCheckWallRefAngle_0x261eb0; // 0x262364 - g_ps2RecompiledFunctionTable[362712] = bhCheckWallRefAngle_0x261eb0; // 0x262368 - g_ps2RecompiledFunctionTable[362713] = bhCheckWallRefAngle_0x261eb0; // 0x26236c - g_ps2RecompiledFunctionTable[362714] = bhCheckWallRefAngle_0x261eb0; // 0x262370 - g_ps2RecompiledFunctionTable[362715] = bhCheckWallRefAngle_0x261eb0; // 0x262374 - g_ps2RecompiledFunctionTable[362716] = bhCheckWallRefAngle_0x261eb0; // 0x262378 - g_ps2RecompiledFunctionTable[362717] = bhCheckWallRefAngle_0x261eb0; // 0x26237c - g_ps2RecompiledFunctionTable[362718] = bhCheckWallRefAngle_0x261eb0; // 0x262380 - g_ps2RecompiledFunctionTable[362719] = bhCheckWallRefAngle_0x261eb0; // 0x262384 - g_ps2RecompiledFunctionTable[362720] = bhCheckWallRefAngle_0x261eb0; // 0x262388 - g_ps2RecompiledFunctionTable[362721] = bhCheckWallRefAngle_0x261eb0; // 0x26238c - g_ps2RecompiledFunctionTable[362722] = bhCheckWallRefAngle_0x261eb0; // 0x262390 - g_ps2RecompiledFunctionTable[362723] = bhCheckWallRefAngle_0x261eb0; // 0x262394 - g_ps2RecompiledFunctionTable[362724] = bhCheckWallRefAngle_0x261eb0; // 0x262398 - g_ps2RecompiledFunctionTable[362725] = bhCheckWallRefAngle_0x261eb0; // 0x26239c - g_ps2RecompiledFunctionTable[362726] = bhCheckWallRefAngle_0x261eb0; // 0x2623a0 - g_ps2RecompiledFunctionTable[362727] = bhCheckWallRefAngle_0x261eb0; // 0x2623a4 - g_ps2RecompiledFunctionTable[362728] = bhCheckWallRefAngle_0x261eb0; // 0x2623a8 - g_ps2RecompiledFunctionTable[362729] = bhCheckWallRefAngle_0x261eb0; // 0x2623ac - g_ps2RecompiledFunctionTable[362730] = bhCheckWallRefAngle_0x261eb0; // 0x2623b0 - g_ps2RecompiledFunctionTable[362731] = bhCheckWallRefAngle_0x261eb0; // 0x2623b4 - g_ps2RecompiledFunctionTable[362732] = bhCheckWallRefAngle_0x261eb0; // 0x2623b8 - g_ps2RecompiledFunctionTable[362733] = bhCheckWallRefAngle_0x261eb0; // 0x2623bc - g_ps2RecompiledFunctionTable[362734] = bhCheckWallRefAngle_0x261eb0; // 0x2623c0 - g_ps2RecompiledFunctionTable[362735] = bhCheckWallRefAngle_0x261eb0; // 0x2623c4 - g_ps2RecompiledFunctionTable[362736] = bhCheckWallRefAngle_0x261eb0; // 0x2623c8 - g_ps2RecompiledFunctionTable[362737] = bhCheckWallRefAngle_0x261eb0; // 0x2623cc - g_ps2RecompiledFunctionTable[362738] = bhCheckWallRefAngle_0x261eb0; // 0x2623d0 - g_ps2RecompiledFunctionTable[362739] = bhCheckWallRefAngle_0x261eb0; // 0x2623d4 - g_ps2RecompiledFunctionTable[362740] = bhCheckWallRefAngle_0x261eb0; // 0x2623d8 - g_ps2RecompiledFunctionTable[362741] = bhCheckWallRefAngle_0x261eb0; // 0x2623dc - g_ps2RecompiledFunctionTable[362742] = bhCheckWallRefAngle_0x261eb0; // 0x2623e0 - g_ps2RecompiledFunctionTable[362743] = bhCheckWallRefAngle_0x261eb0; // 0x2623e4 - g_ps2RecompiledFunctionTable[362744] = bhCheckWallRefAngle_0x261eb0; // 0x2623e8 - g_ps2RecompiledFunctionTable[362745] = bhCheckWallRefAngle_0x261eb0; // 0x2623ec - g_ps2RecompiledFunctionTable[362746] = bhCheckWallRefAngle_0x261eb0; // 0x2623f0 - g_ps2RecompiledFunctionTable[362747] = bhCheckWallRefAngle_0x261eb0; // 0x2623f4 - g_ps2RecompiledFunctionTable[362748] = bhCheckWallRefAngle_0x261eb0; // 0x2623f8 - g_ps2RecompiledFunctionTable[362749] = bhCheckWallRefAngle_0x261eb0; // 0x2623fc - g_ps2RecompiledFunctionTable[362750] = bhCheckWallRefAngle_0x261eb0; // 0x262400 - g_ps2RecompiledFunctionTable[362751] = bhCheckWallRefAngle_0x261eb0; // 0x262404 - g_ps2RecompiledFunctionTable[362752] = bhCheckWallRefAngle_0x261eb0; // 0x262408 - g_ps2RecompiledFunctionTable[362753] = bhCheckWallRefAngle_0x261eb0; // 0x26240c - g_ps2RecompiledFunctionTable[362754] = bhCheckWallRefAngle_0x261eb0; // 0x262410 - g_ps2RecompiledFunctionTable[362755] = bhCheckWallRefAngle_0x261eb0; // 0x262414 - g_ps2RecompiledFunctionTable[362756] = bhCheckWallRefAngle_0x261eb0; // 0x262418 - g_ps2RecompiledFunctionTable[362757] = bhCheckWallRefAngle_0x261eb0; // 0x26241c - g_ps2RecompiledFunctionTable[362758] = bhCheckWallRefAngle_0x261eb0; // 0x262420 - g_ps2RecompiledFunctionTable[362759] = bhCheckWallRefAngle_0x261eb0; // 0x262424 - g_ps2RecompiledFunctionTable[362760] = bhCheckWallRefAngle_0x261eb0; // 0x262428 - g_ps2RecompiledFunctionTable[362761] = bhCheckWallRefAngle_0x261eb0; // 0x26242c - g_ps2RecompiledFunctionTable[362762] = bhCheckWallRefAngle_0x261eb0; // 0x262430 - g_ps2RecompiledFunctionTable[362763] = bhCheckWallRefAngle_0x261eb0; // 0x262434 - g_ps2RecompiledFunctionTable[362764] = bhCheckWallRefAngle_0x261eb0; // 0x262438 - g_ps2RecompiledFunctionTable[362765] = bhCheckWallRefAngle_0x261eb0; // 0x26243c - g_ps2RecompiledFunctionTable[362766] = bhCheckWallRefAngle_0x261eb0; // 0x262440 - g_ps2RecompiledFunctionTable[362767] = bhCheckWallRefAngle_0x261eb0; // 0x262444 - g_ps2RecompiledFunctionTable[362768] = bhCheckWallRefAngle_0x261eb0; // 0x262448 - g_ps2RecompiledFunctionTable[362769] = bhCheckWallRefAngle_0x261eb0; // 0x26244c - g_ps2RecompiledFunctionTable[362770] = bhCheckWallRefAngle_0x261eb0; // 0x262450 - g_ps2RecompiledFunctionTable[362771] = bhCheckWallRefAngle_0x261eb0; // 0x262454 - g_ps2RecompiledFunctionTable[362772] = bhCheckWallRefAngle_0x261eb0; // 0x262458 - g_ps2RecompiledFunctionTable[362773] = bhCheckWallRefAngle_0x261eb0; // 0x26245c - g_ps2RecompiledFunctionTable[362774] = bhCheckWallRefAngle_0x261eb0; // 0x262460 - g_ps2RecompiledFunctionTable[362775] = bhCheckWallRefAngle_0x261eb0; // 0x262464 - g_ps2RecompiledFunctionTable[362776] = bhCheckWallRefAngle_0x261eb0; // 0x262468 - g_ps2RecompiledFunctionTable[362777] = bhCheckWallRefAngle_0x261eb0; // 0x26246c - g_ps2RecompiledFunctionTable[362778] = bhCheckWallRefAngle_0x261eb0; // 0x262470 - g_ps2RecompiledFunctionTable[362779] = bhCheckWallRefAngle_0x261eb0; // 0x262474 - g_ps2RecompiledFunctionTable[362780] = bhCheckWallRefAngle_0x261eb0; // 0x262478 - g_ps2RecompiledFunctionTable[362781] = bhCheckWallRefAngle_0x261eb0; // 0x26247c - g_ps2RecompiledFunctionTable[362782] = bhCheckWallRefAngle_0x261eb0; // 0x262480 - g_ps2RecompiledFunctionTable[362783] = bhCheckWallRefAngle_0x261eb0; // 0x262484 - g_ps2RecompiledFunctionTable[362784] = bhCheckWallRefAngle_0x261eb0; // 0x262488 - g_ps2RecompiledFunctionTable[362785] = bhCheckWallRefAngle_0x261eb0; // 0x26248c - g_ps2RecompiledFunctionTable[362786] = bhCheckWallRefAngle_0x261eb0; // 0x262490 - g_ps2RecompiledFunctionTable[362787] = bhCheckWallRefAngle_0x261eb0; // 0x262494 - g_ps2RecompiledFunctionTable[362788] = bhCheckWallRefAngle_0x261eb0; // 0x262498 - g_ps2RecompiledFunctionTable[362789] = bhCheckWallRefAngle_0x261eb0; // 0x26249c - g_ps2RecompiledFunctionTable[362790] = bhCheckWallRefAngle_0x261eb0; // 0x2624a0 - g_ps2RecompiledFunctionTable[362791] = bhCheckWallRefAngle_0x261eb0; // 0x2624a4 - g_ps2RecompiledFunctionTable[362792] = bhCheckWallRefAngle_0x261eb0; // 0x2624a8 - g_ps2RecompiledFunctionTable[362793] = bhCheckWallRefAngle_0x261eb0; // 0x2624ac - g_ps2RecompiledFunctionTable[362794] = bhCheckWallRefAngle_0x261eb0; // 0x2624b0 - g_ps2RecompiledFunctionTable[362795] = bhCheckWallRefAngle_0x261eb0; // 0x2624b4 - g_ps2RecompiledFunctionTable[362796] = bhCheckWallRefAngle_0x261eb0; // 0x2624b8 - g_ps2RecompiledFunctionTable[362797] = bhCheckWallRefAngle_0x261eb0; // 0x2624bc - g_ps2RecompiledFunctionTable[362798] = bhCheckWallRefAngle_0x261eb0; // 0x2624c0 - g_ps2RecompiledFunctionTable[362799] = bhCheckWallRefAngle_0x261eb0; // 0x2624c4 - g_ps2RecompiledFunctionTable[362800] = bhCheckWallRefAngle_0x261eb0; // 0x2624c8 - g_ps2RecompiledFunctionTable[362801] = bhCheckWallRefAngle_0x261eb0; // 0x2624cc - g_ps2RecompiledFunctionTable[362802] = bhCheckWallRefAngle_0x261eb0; // 0x2624d0 - g_ps2RecompiledFunctionTable[362803] = bhCheckWallRefAngle_0x261eb0; // 0x2624d4 - g_ps2RecompiledFunctionTable[362804] = bhCheckWallRefAngle_0x261eb0; // 0x2624d8 - g_ps2RecompiledFunctionTable[362805] = bhCheckWallRefAngle_0x261eb0; // 0x2624dc - g_ps2RecompiledFunctionTable[362806] = bhCheckWallRefAngle_0x261eb0; // 0x2624e0 - g_ps2RecompiledFunctionTable[362807] = bhCheckWallRefAngle_0x261eb0; // 0x2624e4 - g_ps2RecompiledFunctionTable[362808] = bhCheckWallRefAngle_0x261eb0; // 0x2624e8 - g_ps2RecompiledFunctionTable[362809] = bhCheckWallRefAngle_0x261eb0; // 0x2624ec - g_ps2RecompiledFunctionTable[362810] = bhCheckWallRefAngle_0x261eb0; // 0x2624f0 - g_ps2RecompiledFunctionTable[362811] = bhCheckWallRefAngle_0x261eb0; // 0x2624f4 - g_ps2RecompiledFunctionTable[362812] = bhCheckWallRefAngle_0x261eb0; // 0x2624f8 - g_ps2RecompiledFunctionTable[362813] = bhCheckWallRefAngle_0x261eb0; // 0x2624fc - g_ps2RecompiledFunctionTable[362814] = bhCheckWallRefAngle_0x261eb0; // 0x262500 - g_ps2RecompiledFunctionTable[362815] = bhCheckWallRefAngle_0x261eb0; // 0x262504 - g_ps2RecompiledFunctionTable[362816] = bhCheckWallRefAngle_0x261eb0; // 0x262508 - g_ps2RecompiledFunctionTable[362817] = bhCheckWallRefAngle_0x261eb0; // 0x26250c - g_ps2RecompiledFunctionTable[362818] = bhCheckWallRefAngle_0x261eb0; // 0x262510 - g_ps2RecompiledFunctionTable[362819] = bhCheckWallRefAngle_0x261eb0; // 0x262514 - g_ps2RecompiledFunctionTable[362820] = bhCheckWallRefAngle_0x261eb0; // 0x262518 - g_ps2RecompiledFunctionTable[362821] = bhCheckWallRefAngle_0x261eb0; // 0x26251c - g_ps2RecompiledFunctionTable[362822] = bhCheckWallRefAngle_0x261eb0; // 0x262520 - g_ps2RecompiledFunctionTable[362823] = bhCheckWallRefAngle_0x261eb0; // 0x262524 - g_ps2RecompiledFunctionTable[362824] = bhCheckWallRefAngle_0x261eb0; // 0x262528 - g_ps2RecompiledFunctionTable[362825] = bhCheckWallRefAngle_0x261eb0; // 0x26252c - g_ps2RecompiledFunctionTable[362826] = bhCheckWallRefAngle_0x261eb0; // 0x262530 - g_ps2RecompiledFunctionTable[362827] = bhCheckWallRefAngle_0x261eb0; // 0x262534 - g_ps2RecompiledFunctionTable[362828] = bhCheckWallRefAngle_0x261eb0; // 0x262538 - g_ps2RecompiledFunctionTable[362829] = bhCheckWallRefAngle_0x261eb0; // 0x26253c - g_ps2RecompiledFunctionTable[362830] = bhCheckWallRefAngle_0x261eb0; // 0x262540 - g_ps2RecompiledFunctionTable[362831] = bhCheckWallRefAngle_0x261eb0; // 0x262544 - g_ps2RecompiledFunctionTable[362832] = bhCheckWallRefAngle_0x261eb0; // 0x262548 - g_ps2RecompiledFunctionTable[362833] = bhCheckWallRefAngle_0x261eb0; // 0x26254c - g_ps2RecompiledFunctionTable[362834] = bhCheckWallRefAngle_0x261eb0; // 0x262550 - g_ps2RecompiledFunctionTable[362835] = bhCheckWallRefAngle_0x261eb0; // 0x262554 - g_ps2RecompiledFunctionTable[362836] = bhCheckWallRefAngle_0x261eb0; // 0x262558 - g_ps2RecompiledFunctionTable[362837] = bhCheckWallRefAngle_0x261eb0; // 0x26255c - g_ps2RecompiledFunctionTable[362838] = bhCheckWallRefAngle_0x261eb0; // 0x262560 - g_ps2RecompiledFunctionTable[362839] = bhCheckWallRefAngle_0x261eb0; // 0x262564 - g_ps2RecompiledFunctionTable[362840] = bhCheckWallRefAngle_0x261eb0; // 0x262568 - g_ps2RecompiledFunctionTable[362841] = bhCheckWallRefAngle_0x261eb0; // 0x26256c - g_ps2RecompiledFunctionTable[362842] = bhCheckWallRefAngle_0x261eb0; // 0x262570 - g_ps2RecompiledFunctionTable[362843] = bhCheckWallRefAngle_0x261eb0; // 0x262574 - g_ps2RecompiledFunctionTable[362844] = bhCheckWallRefAngle_0x261eb0; // 0x262578 - g_ps2RecompiledFunctionTable[362845] = bhCheckWallRefAngle_0x261eb0; // 0x26257c - g_ps2RecompiledFunctionTable[362846] = bhCheckWallRefAngle_0x261eb0; // 0x262580 - g_ps2RecompiledFunctionTable[362847] = bhCheckWallRefAngle_0x261eb0; // 0x262584 - g_ps2RecompiledFunctionTable[362848] = bhCheckWallRefAngle_0x261eb0; // 0x262588 - g_ps2RecompiledFunctionTable[362849] = bhCheckWallRefAngle_0x261eb0; // 0x26258c - g_ps2RecompiledFunctionTable[362850] = bhCheckWallRefAngle_0x261eb0; // 0x262590 - g_ps2RecompiledFunctionTable[362851] = bhCheckWallRefAngle_0x261eb0; // 0x262594 - g_ps2RecompiledFunctionTable[362852] = bhCheckWallRefAngle_0x261eb0; // 0x262598 - g_ps2RecompiledFunctionTable[362853] = bhCheckWallRefAngle_0x261eb0; // 0x26259c - g_ps2RecompiledFunctionTable[362854] = bhCheckWallRefAngle_0x261eb0; // 0x2625a0 - g_ps2RecompiledFunctionTable[362855] = bhCheckWallRefAngle_0x261eb0; // 0x2625a4 - g_ps2RecompiledFunctionTable[362856] = bhCheckWallRefAngle_0x261eb0; // 0x2625a8 - g_ps2RecompiledFunctionTable[362857] = bhCheckWallRefAngle_0x261eb0; // 0x2625ac - g_ps2RecompiledFunctionTable[362858] = bhCheckWallRefAngle_0x261eb0; // 0x2625b0 - g_ps2RecompiledFunctionTable[362859] = bhCheckWallRefAngle_0x261eb0; // 0x2625b4 - g_ps2RecompiledFunctionTable[362860] = bhCheckWallRefAngle_0x261eb0; // 0x2625b8 - g_ps2RecompiledFunctionTable[362861] = bhCheckWallRefAngle_0x261eb0; // 0x2625bc - g_ps2RecompiledFunctionTable[362862] = bhCheckWallRefAngle_0x261eb0; // 0x2625c0 - g_ps2RecompiledFunctionTable[362863] = bhCheckWallRefAngle_0x261eb0; // 0x2625c4 - g_ps2RecompiledFunctionTable[362864] = bhCheckWallRefAngle_0x261eb0; // 0x2625c8 - g_ps2RecompiledFunctionTable[362865] = bhCheckWallRefAngle_0x261eb0; // 0x2625cc - g_ps2RecompiledFunctionTable[362866] = bhCheckWallRefAngle_0x261eb0; // 0x2625d0 - g_ps2RecompiledFunctionTable[362867] = bhCheckWallRefAngle_0x261eb0; // 0x2625d4 - g_ps2RecompiledFunctionTable[362868] = bhCheckWallRefAngle_0x261eb0; // 0x2625d8 - g_ps2RecompiledFunctionTable[362869] = bhCheckWallRefAngle_0x261eb0; // 0x2625dc - g_ps2RecompiledFunctionTable[362870] = bhCheckWallRefAngle_0x261eb0; // 0x2625e0 - g_ps2RecompiledFunctionTable[362871] = bhCheckWallRefAngle_0x261eb0; // 0x2625e4 - g_ps2RecompiledFunctionTable[362872] = bhCheckWallRefAngle_0x261eb0; // 0x2625e8 - g_ps2RecompiledFunctionTable[362873] = bhCheckWallRefAngle_0x261eb0; // 0x2625ec - g_ps2RecompiledFunctionTable[362874] = bhCheckWallRefAngle_0x261eb0; // 0x2625f0 - g_ps2RecompiledFunctionTable[362875] = bhCheckWallRefAngle_0x261eb0; // 0x2625f4 - g_ps2RecompiledFunctionTable[362876] = bhCheckWallRefAngle_0x261eb0; // 0x2625f8 - g_ps2RecompiledFunctionTable[362877] = bhCheckWallRefAngle_0x261eb0; // 0x2625fc - g_ps2RecompiledFunctionTable[362878] = bhCheckWallRefAngle_0x261eb0; // 0x262600 - g_ps2RecompiledFunctionTable[362879] = bhCheckWallRefAngle_0x261eb0; // 0x262604 - g_ps2RecompiledFunctionTable[362880] = bhCheckWallRefAngle_0x261eb0; // 0x262608 - g_ps2RecompiledFunctionTable[362881] = bhCheckWallRefAngle_0x261eb0; // 0x26260c - g_ps2RecompiledFunctionTable[362882] = bhCheckWallRefAngle_0x261eb0; // 0x262610 - g_ps2RecompiledFunctionTable[362883] = bhCheckWallRefAngle_0x261eb0; // 0x262614 - g_ps2RecompiledFunctionTable[362884] = bhCheckWallRefAngle_0x261eb0; // 0x262618 - g_ps2RecompiledFunctionTable[362885] = bhCheckWallRefAngle_0x261eb0; // 0x26261c - g_ps2RecompiledFunctionTable[362886] = bhCheckWallRefAngle_0x261eb0; // 0x262620 - g_ps2RecompiledFunctionTable[362887] = bhCheckWallRefAngle_0x261eb0; // 0x262624 - g_ps2RecompiledFunctionTable[362888] = bhCheckWallRefAngle_0x261eb0; // 0x262628 - g_ps2RecompiledFunctionTable[362889] = bhCheckWallRefAngle_0x261eb0; // 0x26262c - g_ps2RecompiledFunctionTable[362890] = bhCheckWallRefAngle_0x261eb0; // 0x262630 - g_ps2RecompiledFunctionTable[362891] = bhCheckWallRefAngle_0x261eb0; // 0x262634 - g_ps2RecompiledFunctionTable[362892] = bhCheckWallRefAngle_0x261eb0; // 0x262638 - g_ps2RecompiledFunctionTable[362893] = bhCheckWallRefAngle_0x261eb0; // 0x26263c - g_ps2RecompiledFunctionTable[362894] = bhCheckWallRefAngle_0x261eb0; // 0x262640 - g_ps2RecompiledFunctionTable[362895] = bhCheckWallRefAngle_0x261eb0; // 0x262644 - g_ps2RecompiledFunctionTable[362896] = bhCheckWallRefAngle_0x261eb0; // 0x262648 - g_ps2RecompiledFunctionTable[362897] = bhCheckWallRefAngle_0x261eb0; // 0x26264c - g_ps2RecompiledFunctionTable[362898] = bhCheckWallRefAngle_0x261eb0; // 0x262650 - g_ps2RecompiledFunctionTable[362899] = bhCheckWallRefAngle_0x261eb0; // 0x262654 - g_ps2RecompiledFunctionTable[362900] = bhCheckWallRefAngle_0x261eb0; // 0x262658 - g_ps2RecompiledFunctionTable[362901] = bhCheckWallRefAngle_0x261eb0; // 0x26265c - g_ps2RecompiledFunctionTable[362902] = bhCheckWallRefAngle_0x261eb0; // 0x262660 - g_ps2RecompiledFunctionTable[362903] = bhCheckWallRefAngle_0x261eb0; // 0x262664 - g_ps2RecompiledFunctionTable[362904] = bhCheckWallRefAngle_0x261eb0; // 0x262668 - g_ps2RecompiledFunctionTable[362905] = bhCheckWallRefAngle_0x261eb0; // 0x26266c - g_ps2RecompiledFunctionTable[362906] = bhCheckWallRefAngle_0x261eb0; // 0x262670 - g_ps2RecompiledFunctionTable[362907] = bhCheckWallRefAngle_0x261eb0; // 0x262674 - g_ps2RecompiledFunctionTable[362908] = bhCheckWallRefAngle_0x261eb0; // 0x262678 - g_ps2RecompiledFunctionTable[362909] = bhCheckWallRefAngle_0x261eb0; // 0x26267c - g_ps2RecompiledFunctionTable[362910] = bhCheckWallRefAngle_0x261eb0; // 0x262680 - g_ps2RecompiledFunctionTable[362911] = bhCheckWallRefAngle_0x261eb0; // 0x262684 - g_ps2RecompiledFunctionTable[362912] = bhCheckWallRefAngle_0x261eb0; // 0x262688 - g_ps2RecompiledFunctionTable[362913] = bhCheckWallRefAngle_0x261eb0; // 0x26268c - g_ps2RecompiledFunctionTable[362914] = bhCheckWallRefAngle_0x261eb0; // 0x262690 - g_ps2RecompiledFunctionTable[362915] = bhCheckWallRefAngle_0x261eb0; // 0x262694 - g_ps2RecompiledFunctionTable[362916] = bhCheckWallRefAngle_0x261eb0; // 0x262698 - g_ps2RecompiledFunctionTable[362917] = bhCheckWallRefAngle_0x261eb0; // 0x26269c - g_ps2RecompiledFunctionTable[362918] = bhCheckWallRefAngle_0x261eb0; // 0x2626a0 - g_ps2RecompiledFunctionTable[362919] = bhCheckWallRefAngle_0x261eb0; // 0x2626a4 - g_ps2RecompiledFunctionTable[362920] = bhCheckWallRefAngle_0x261eb0; // 0x2626a8 - g_ps2RecompiledFunctionTable[362921] = bhCheckWallRefAngle_0x261eb0; // 0x2626ac - g_ps2RecompiledFunctionTable[362922] = bhCheckWallRefAngle_0x261eb0; // 0x2626b0 - g_ps2RecompiledFunctionTable[362923] = bhCheckWallRefAngle_0x261eb0; // 0x2626b4 - g_ps2RecompiledFunctionTable[362924] = bhCheckWallRefAngle_0x261eb0; // 0x2626b8 - g_ps2RecompiledFunctionTable[362925] = bhCheckWallRefAngle_0x261eb0; // 0x2626bc - g_ps2RecompiledFunctionTable[362926] = bhCheckWallRefAngle_0x261eb0; // 0x2626c0 - g_ps2RecompiledFunctionTable[362927] = bhCheckWallRefAngle_0x261eb0; // 0x2626c4 - g_ps2RecompiledFunctionTable[362928] = bhCheckWallRefAngle_0x261eb0; // 0x2626c8 - g_ps2RecompiledFunctionTable[362929] = bhCheckWallRefAngle_0x261eb0; // 0x2626cc - g_ps2RecompiledFunctionTable[362930] = bhCheckWallRefAngle_0x261eb0; // 0x2626d0 - g_ps2RecompiledFunctionTable[362931] = bhCheckWallRefAngle_0x261eb0; // 0x2626d4 - g_ps2RecompiledFunctionTable[362932] = bhCheckWallRefAngle_0x261eb0; // 0x2626d8 - g_ps2RecompiledFunctionTable[362933] = bhCheckWallRefAngle_0x261eb0; // 0x2626dc - g_ps2RecompiledFunctionTable[362934] = bhCheckWallRefAngle_0x261eb0; // 0x2626e0 - g_ps2RecompiledFunctionTable[362935] = bhCheckWallRefAngle_0x261eb0; // 0x2626e4 - g_ps2RecompiledFunctionTable[362936] = bhCheckWallRefAngle_0x261eb0; // 0x2626e8 - g_ps2RecompiledFunctionTable[362937] = bhCheckWallRefAngle_0x261eb0; // 0x2626ec - g_ps2RecompiledFunctionTable[362938] = bhCheckWallRefAngle_0x261eb0; // 0x2626f0 - g_ps2RecompiledFunctionTable[362939] = bhCheckWallRefAngle_0x261eb0; // 0x2626f4 - g_ps2RecompiledFunctionTable[362940] = bhCheckWallRefAngle_0x261eb0; // 0x2626f8 - g_ps2RecompiledFunctionTable[362941] = bhCheckWallRefAngle_0x261eb0; // 0x2626fc - g_ps2RecompiledFunctionTable[362942] = bhCheckWallRefAngle_0x261eb0; // 0x262700 - g_ps2RecompiledFunctionTable[362943] = bhCheckWallRefAngle_0x261eb0; // 0x262704 - g_ps2RecompiledFunctionTable[362944] = bhCheckWallRefAngle_0x261eb0; // 0x262708 - g_ps2RecompiledFunctionTable[362945] = bhCheckWallRefAngle_0x261eb0; // 0x26270c - g_ps2RecompiledFunctionTable[362946] = bhCheckWallRefAngle_0x261eb0; // 0x262710 - g_ps2RecompiledFunctionTable[362947] = bhCheckWallRefAngle_0x261eb0; // 0x262714 - g_ps2RecompiledFunctionTable[362948] = bhCheckWallRefAngle_0x261eb0; // 0x262718 - g_ps2RecompiledFunctionTable[362949] = bhCheckWallRefAngle_0x261eb0; // 0x26271c - g_ps2RecompiledFunctionTable[362950] = bhCheckWallRefAngle_0x261eb0; // 0x262720 - g_ps2RecompiledFunctionTable[362951] = bhCheckWallRefAngle_0x261eb0; // 0x262724 - g_ps2RecompiledFunctionTable[362952] = bhCheckWallRefAngle_0x261eb0; // 0x262728 - g_ps2RecompiledFunctionTable[362953] = bhCheckWallRefAngle_0x261eb0; // 0x26272c - g_ps2RecompiledFunctionTable[362954] = bhCheckWallRefAngle_0x261eb0; // 0x262730 - g_ps2RecompiledFunctionTable[362955] = bhCheckWallRefAngle_0x261eb0; // 0x262734 - g_ps2RecompiledFunctionTable[362956] = bhCheckWallRefAngle_0x261eb0; // 0x262738 - g_ps2RecompiledFunctionTable[362957] = bhCheckWallRefAngle_0x261eb0; // 0x26273c - g_ps2RecompiledFunctionTable[362958] = bhCheckWallRefAngle_0x261eb0; // 0x262740 - g_ps2RecompiledFunctionTable[362959] = bhCheckWallRefAngle_0x261eb0; // 0x262744 - g_ps2RecompiledFunctionTable[362960] = bhCheckWallRefAngle_0x261eb0; // 0x262748 - g_ps2RecompiledFunctionTable[362961] = bhCheckWallRefAngle_0x261eb0; // 0x26274c - g_ps2RecompiledFunctionTable[362962] = bhCheckWallRefAngle_0x261eb0; // 0x262750 - g_ps2RecompiledFunctionTable[362963] = bhCheckWallRefAngle_0x261eb0; // 0x262754 - g_ps2RecompiledFunctionTable[362964] = bhCheckWallRefAngle_0x261eb0; // 0x262758 - g_ps2RecompiledFunctionTable[362965] = bhCheckWallRefAngle_0x261eb0; // 0x26275c - g_ps2RecompiledFunctionTable[362966] = bhCheckWallRefAngle_0x261eb0; // 0x262760 - g_ps2RecompiledFunctionTable[362967] = bhCheckWallRefAngle_0x261eb0; // 0x262764 - g_ps2RecompiledFunctionTable[362968] = bhCheckWallRefAngle_0x261eb0; // 0x262768 - g_ps2RecompiledFunctionTable[362969] = bhCheckWallRefAngle_0x261eb0; // 0x26276c - g_ps2RecompiledFunctionTable[362970] = bhCheckWallRefAngle_0x261eb0; // 0x262770 - g_ps2RecompiledFunctionTable[362971] = bhCheckWallRefAngle_0x261eb0; // 0x262774 - g_ps2RecompiledFunctionTable[362972] = bhCheckWallRefAngle_0x261eb0; // 0x262778 - g_ps2RecompiledFunctionTable[362973] = bhCheckWallRefAngle_0x261eb0; // 0x26277c - g_ps2RecompiledFunctionTable[362974] = bhCheckWallRefAngle_0x261eb0; // 0x262780 - g_ps2RecompiledFunctionTable[362975] = bhCheckWallRefAngle_0x261eb0; // 0x262784 - g_ps2RecompiledFunctionTable[362976] = bhCheckWallRefAngle_0x261eb0; // 0x262788 - g_ps2RecompiledFunctionTable[362977] = bhCheckWallRefAngle_0x261eb0; // 0x26278c - g_ps2RecompiledFunctionTable[362978] = bhCheckWallRefAngle_0x261eb0; // 0x262790 - g_ps2RecompiledFunctionTable[362979] = bhCheckWallRefAngle_0x261eb0; // 0x262794 - g_ps2RecompiledFunctionTable[362980] = bhCheckWallRefAngle_0x261eb0; // 0x262798 - g_ps2RecompiledFunctionTable[362981] = bhCheckWallRefAngle_0x261eb0; // 0x26279c - g_ps2RecompiledFunctionTable[362982] = bhCheckWallRefAngle_0x261eb0; // 0x2627a0 - g_ps2RecompiledFunctionTable[362983] = bhCheckWallRefAngle_0x261eb0; // 0x2627a4 - g_ps2RecompiledFunctionTable[362984] = bhCheckWallRefAngle_0x261eb0; // 0x2627a8 - g_ps2RecompiledFunctionTable[362985] = bhCheckWallRefAngle_0x261eb0; // 0x2627ac - g_ps2RecompiledFunctionTable[362986] = bhCheckWallRefAngle_0x261eb0; // 0x2627b0 - g_ps2RecompiledFunctionTable[362987] = bhCheckWallRefAngle_0x261eb0; // 0x2627b4 - g_ps2RecompiledFunctionTable[362988] = bhCheckWallRefAngle_0x261eb0; // 0x2627b8 - g_ps2RecompiledFunctionTable[362989] = bhCheckWallRefAngle_0x261eb0; // 0x2627bc - g_ps2RecompiledFunctionTable[362990] = bhCheckWallRefAngle_0x261eb0; // 0x2627c0 - g_ps2RecompiledFunctionTable[362991] = bhCheckWallRefAngle_0x261eb0; // 0x2627c4 - g_ps2RecompiledFunctionTable[362992] = bhCheckWallRefAngle_0x261eb0; // 0x2627c8 - g_ps2RecompiledFunctionTable[362993] = bhCheckWallRefAngle_0x261eb0; // 0x2627cc - g_ps2RecompiledFunctionTable[362994] = bhCheckWallRefAngle_0x261eb0; // 0x2627d0 - g_ps2RecompiledFunctionTable[362995] = bhCheckWallRefAngle_0x261eb0; // 0x2627d4 - g_ps2RecompiledFunctionTable[362996] = bhCheckWallRefAngle_0x261eb0; // 0x2627d8 - g_ps2RecompiledFunctionTable[362997] = bhCheckWallRefAngle_0x261eb0; // 0x2627dc - g_ps2RecompiledFunctionTable[362998] = bhCheckWallRefAngle_0x261eb0; // 0x2627e0 - g_ps2RecompiledFunctionTable[362999] = bhCheckWallRefAngle_0x261eb0; // 0x2627e4 - g_ps2RecompiledFunctionTable[363000] = bhCheckWallRefAngle_0x261eb0; // 0x2627e8 - g_ps2RecompiledFunctionTable[363001] = bhCheckWallRefAngle_0x261eb0; // 0x2627ec - g_ps2RecompiledFunctionTable[363002] = bhCheckWallRefAngle_0x261eb0; // 0x2627f0 - g_ps2RecompiledFunctionTable[363003] = bhCheckWallRefAngle_0x261eb0; // 0x2627f4 - g_ps2RecompiledFunctionTable[363004] = bhCheckWallRefAngle_0x261eb0; // 0x2627f8 - g_ps2RecompiledFunctionTable[363005] = bhCheckWallRefAngle_0x261eb0; // 0x2627fc - g_ps2RecompiledFunctionTable[363006] = bhCheckWallRefAngle_0x261eb0; // 0x262800 - g_ps2RecompiledFunctionTable[363007] = bhCheckWallRefAngle_0x261eb0; // 0x262804 - g_ps2RecompiledFunctionTable[363008] = bhCheckWallRefAngle_0x261eb0; // 0x262808 - g_ps2RecompiledFunctionTable[363009] = bhCheckWallRefAngle_0x261eb0; // 0x26280c - g_ps2RecompiledFunctionTable[363010] = bhCheckWallRefAngle_0x261eb0; // 0x262810 - g_ps2RecompiledFunctionTable[363011] = bhCheckWallRefAngle_0x261eb0; // 0x262814 - g_ps2RecompiledFunctionTable[363012] = bhCheckWallRefAngle_0x261eb0; // 0x262818 - g_ps2RecompiledFunctionTable[363013] = bhCheckWallRefAngle_0x261eb0; // 0x26281c - g_ps2RecompiledFunctionTable[363014] = bhCheckWallRefAngle_0x261eb0; // 0x262820 - g_ps2RecompiledFunctionTable[363015] = bhCheckWallRefAngle_0x261eb0; // 0x262824 - g_ps2RecompiledFunctionTable[363016] = bhCheckWallRefAngle_0x261eb0; // 0x262828 - g_ps2RecompiledFunctionTable[363017] = bhCheckWallRefAngle_0x261eb0; // 0x26282c - g_ps2RecompiledFunctionTable[363018] = bhCheckWallRefAngle_0x261eb0; // 0x262830 - g_ps2RecompiledFunctionTable[363019] = bhCheckWallRefAngle_0x261eb0; // 0x262834 - g_ps2RecompiledFunctionTable[363020] = bhCheckWallRefAngle_0x261eb0; // 0x262838 - g_ps2RecompiledFunctionTable[363021] = bhCheckWallRefAngle_0x261eb0; // 0x26283c - g_ps2RecompiledFunctionTable[363022] = bhCheckWallRefAngle_0x261eb0; // 0x262840 - g_ps2RecompiledFunctionTable[363023] = bhCheckWallRefAngle_0x261eb0; // 0x262844 - g_ps2RecompiledFunctionTable[363024] = bhCheckWallRefAngle_0x261eb0; // 0x262848 - g_ps2RecompiledFunctionTable[363025] = bhCheckWallRefAngle_0x261eb0; // 0x26284c - g_ps2RecompiledFunctionTable[363026] = bhCheckWallRefAngle_0x261eb0; // 0x262850 - g_ps2RecompiledFunctionTable[363027] = bhCheckWallRefAngle_0x261eb0; // 0x262854 - g_ps2RecompiledFunctionTable[363028] = bhCheckWallRefAngle_0x261eb0; // 0x262858 - g_ps2RecompiledFunctionTable[363029] = bhCheckWallRefAngle_0x261eb0; // 0x26285c - g_ps2RecompiledFunctionTable[363030] = bhCheckWallRefAngle_0x261eb0; // 0x262860 - g_ps2RecompiledFunctionTable[363031] = bhCheckWallRefAngle_0x261eb0; // 0x262864 - g_ps2RecompiledFunctionTable[363032] = bhCheckWallRefAngle_0x261eb0; // 0x262868 - g_ps2RecompiledFunctionTable[363033] = bhCheckWallRefAngle_0x261eb0; // 0x26286c - g_ps2RecompiledFunctionTable[363034] = bhCheckWallRefAngle_0x261eb0; // 0x262870 - g_ps2RecompiledFunctionTable[363035] = bhCheckWallRefAngle_0x261eb0; // 0x262874 - g_ps2RecompiledFunctionTable[363036] = bhCheckWallRefAngle_0x261eb0; // 0x262878 - g_ps2RecompiledFunctionTable[363037] = bhCheckWallRefAngle_0x261eb0; // 0x26287c - g_ps2RecompiledFunctionTable[363038] = bhCheckWallRefAngle_0x261eb0; // 0x262880 - g_ps2RecompiledFunctionTable[363039] = bhCheckWallRefAngle_0x261eb0; // 0x262884 - g_ps2RecompiledFunctionTable[363040] = bhCheckWallRefAngle_0x261eb0; // 0x262888 - g_ps2RecompiledFunctionTable[363041] = bhCheckWallRefAngle_0x261eb0; // 0x26288c - g_ps2RecompiledFunctionTable[363042] = bhCheckWallRefAngle_0x261eb0; // 0x262890 - g_ps2RecompiledFunctionTable[363043] = bhCheckWallRefAngle_0x261eb0; // 0x262894 - g_ps2RecompiledFunctionTable[363044] = bhCheckWallRefAngle_0x261eb0; // 0x262898 - g_ps2RecompiledFunctionTable[363045] = bhCheckWallRefAngle_0x261eb0; // 0x26289c - g_ps2RecompiledFunctionTable[363046] = bhCheckWallRefAngle_0x261eb0; // 0x2628a0 - g_ps2RecompiledFunctionTable[363047] = bhCheckWallRefAngle_0x261eb0; // 0x2628a4 - g_ps2RecompiledFunctionTable[363048] = bhCheckWallRefAngle_0x261eb0; // 0x2628a8 - g_ps2RecompiledFunctionTable[363049] = bhCheckWallRefAngle_0x261eb0; // 0x2628ac - g_ps2RecompiledFunctionTable[363050] = bhCheckWallRefAngle_0x261eb0; // 0x2628b0 - g_ps2RecompiledFunctionTable[363051] = bhCheckWallRefAngle_0x261eb0; // 0x2628b4 - g_ps2RecompiledFunctionTable[363052] = bhCheckWallRefAngle_0x261eb0; // 0x2628b8 - g_ps2RecompiledFunctionTable[363053] = bhCheckWallRefAngle_0x261eb0; // 0x2628bc - g_ps2RecompiledFunctionTable[363054] = bhCheckWallRefAngle_0x261eb0; // 0x2628c0 - g_ps2RecompiledFunctionTable[363055] = bhCheckWallRefAngle_0x261eb0; // 0x2628c4 - g_ps2RecompiledFunctionTable[363056] = bhCheckWallRefAngle_0x261eb0; // 0x2628c8 - g_ps2RecompiledFunctionTable[363057] = bhCheckWallRefAngle_0x261eb0; // 0x2628cc - g_ps2RecompiledFunctionTable[363058] = bhCheckWallRefAngle_0x261eb0; // 0x2628d0 - g_ps2RecompiledFunctionTable[363059] = bhCheckWallRefAngle_0x261eb0; // 0x2628d4 - g_ps2RecompiledFunctionTable[363060] = bhCheckWallRefAngle_0x261eb0; // 0x2628d8 - g_ps2RecompiledFunctionTable[363061] = bhCheckWallRefAngle_0x261eb0; // 0x2628dc - g_ps2RecompiledFunctionTable[363062] = bhCheckWallRefAngle_0x261eb0; // 0x2628e0 - g_ps2RecompiledFunctionTable[363063] = bhCheckWallRefAngle_0x261eb0; // 0x2628e4 - g_ps2RecompiledFunctionTable[363064] = bhCheckWallRefAngle_0x261eb0; // 0x2628e8 - g_ps2RecompiledFunctionTable[363065] = bhCheckWallRefAngle_0x261eb0; // 0x2628ec - g_ps2RecompiledFunctionTable[363066] = bhCheckWallRefAngle_0x261eb0; // 0x2628f0 - g_ps2RecompiledFunctionTable[363067] = bhCheckWallRefAngle_0x261eb0; // 0x2628f4 - g_ps2RecompiledFunctionTable[363068] = bhCheckWallRefAngle_0x261eb0; // 0x2628f8 - g_ps2RecompiledFunctionTable[363069] = bhCheckWallRefAngle_0x261eb0; // 0x2628fc - g_ps2RecompiledFunctionTable[363070] = bhCheckWallRefAngle_0x261eb0; // 0x262900 - g_ps2RecompiledFunctionTable[363071] = bhCheckWallRefAngle_0x261eb0; // 0x262904 - g_ps2RecompiledFunctionTable[363072] = bhCheckWallRefAngle_0x261eb0; // 0x262908 - g_ps2RecompiledFunctionTable[363073] = bhCheckWallRefAngle_0x261eb0; // 0x26290c - g_ps2RecompiledFunctionTable[363074] = bhCheckWallRefAngle_0x261eb0; // 0x262910 - g_ps2RecompiledFunctionTable[363075] = bhCheckWallRefAngle_0x261eb0; // 0x262914 - g_ps2RecompiledFunctionTable[363076] = bhCheckWallRefAngle_0x261eb0; // 0x262918 - g_ps2RecompiledFunctionTable[363077] = bhCheckWallRefAngle_0x261eb0; // 0x26291c - g_ps2RecompiledFunctionTable[363078] = bhCheckWallRefAngle_0x261eb0; // 0x262920 - g_ps2RecompiledFunctionTable[363079] = bhCheckWallRefAngle_0x261eb0; // 0x262924 - g_ps2RecompiledFunctionTable[363080] = bhCheckWallRefAngle_0x261eb0; // 0x262928 - g_ps2RecompiledFunctionTable[363081] = bhCheckWallRefAngle_0x261eb0; // 0x26292c - g_ps2RecompiledFunctionTable[363082] = bhCheckWallRefAngle_0x261eb0; // 0x262930 - g_ps2RecompiledFunctionTable[363083] = bhCheckWallRefAngle_0x261eb0; // 0x262934 - g_ps2RecompiledFunctionTable[363084] = bhCheckWallRefAngle_0x261eb0; // 0x262938 - g_ps2RecompiledFunctionTable[363085] = bhCheckWallRefAngle_0x261eb0; // 0x26293c - g_ps2RecompiledFunctionTable[363086] = bhCheckWallRefAngle_0x261eb0; // 0x262940 - g_ps2RecompiledFunctionTable[363087] = bhCheckWallRefAngle_0x261eb0; // 0x262944 - g_ps2RecompiledFunctionTable[363088] = bhCheckWallRefAngle_0x261eb0; // 0x262948 - g_ps2RecompiledFunctionTable[363089] = bhCheckWallRefAngle_0x261eb0; // 0x26294c - g_ps2RecompiledFunctionTable[363090] = bhCheckWallRefAngle_0x261eb0; // 0x262950 - g_ps2RecompiledFunctionTable[363091] = bhCheckWallRefAngle_0x261eb0; // 0x262954 - g_ps2RecompiledFunctionTable[363092] = bhCheckWallRefAngle_0x261eb0; // 0x262958 - g_ps2RecompiledFunctionTable[363093] = bhCheckWallRefAngle_0x261eb0; // 0x26295c - g_ps2RecompiledFunctionTable[363094] = bhCheckWallRefAngle_0x261eb0; // 0x262960 - g_ps2RecompiledFunctionTable[363095] = bhCheckWallRefAngle_0x261eb0; // 0x262964 - g_ps2RecompiledFunctionTable[363096] = bhCheckWallRefAngle_0x261eb0; // 0x262968 - g_ps2RecompiledFunctionTable[363097] = bhCheckWallRefAngle_0x261eb0; // 0x26296c - g_ps2RecompiledFunctionTable[363098] = bhCheckWallRefAngle_0x261eb0; // 0x262970 - g_ps2RecompiledFunctionTable[363099] = bhCheckWallRefAngle_0x261eb0; // 0x262974 - g_ps2RecompiledFunctionTable[363100] = bhCheckWallRefAngle_0x261eb0; // 0x262978 - g_ps2RecompiledFunctionTable[363101] = bhCheckWallRefAngle_0x261eb0; // 0x26297c - g_ps2RecompiledFunctionTable[363102] = bhCheckWallRefAngle_0x261eb0; // 0x262980 - g_ps2RecompiledFunctionTable[363103] = bhCheckWallRefAngle_0x261eb0; // 0x262984 - g_ps2RecompiledFunctionTable[363104] = bhCheckWallRefAngle_0x261eb0; // 0x262988 - g_ps2RecompiledFunctionTable[363105] = bhCheckWallRefAngle_0x261eb0; // 0x26298c - g_ps2RecompiledFunctionTable[363106] = bhCheckWallRefAngle_0x261eb0; // 0x262990 - g_ps2RecompiledFunctionTable[363107] = bhCheckWallRefAngle_0x261eb0; // 0x262994 - g_ps2RecompiledFunctionTable[363108] = bhCheckWallRefAngle_0x261eb0; // 0x262998 - g_ps2RecompiledFunctionTable[363109] = bhCheckWallRefAngle_0x261eb0; // 0x26299c - g_ps2RecompiledFunctionTable[363110] = bhCheckWallRefAngle_0x261eb0; // 0x2629a0 - g_ps2RecompiledFunctionTable[363111] = bhCheckWallRefAngle_0x261eb0; // 0x2629a4 - g_ps2RecompiledFunctionTable[363112] = bhCheckWallRefAngle_0x261eb0; // 0x2629a8 - g_ps2RecompiledFunctionTable[363113] = bhCheckWallRefAngle_0x261eb0; // 0x2629ac - g_ps2RecompiledFunctionTable[363114] = bhCheckWallRefAngle_0x261eb0; // 0x2629b0 - g_ps2RecompiledFunctionTable[363115] = bhCheckWallRefAngle_0x261eb0; // 0x2629b4 - g_ps2RecompiledFunctionTable[363116] = bhCheckWallRefAngle_0x261eb0; // 0x2629b8 - g_ps2RecompiledFunctionTable[363117] = bhCheckWallRefAngle_0x261eb0; // 0x2629bc - g_ps2RecompiledFunctionTable[363118] = bhCheckWallRefAngle_0x261eb0; // 0x2629c0 - g_ps2RecompiledFunctionTable[363119] = bhCheckWallRefAngle_0x261eb0; // 0x2629c4 - g_ps2RecompiledFunctionTable[363120] = bhCheckWallRefAngle_0x261eb0; // 0x2629c8 - g_ps2RecompiledFunctionTable[363121] = bhCheckWallRefAngle_0x261eb0; // 0x2629cc - g_ps2RecompiledFunctionTable[363122] = bhCheckWallRefAngle_0x261eb0; // 0x2629d0 - g_ps2RecompiledFunctionTable[363123] = bhCheckWallRefAngle_0x261eb0; // 0x2629d4 - g_ps2RecompiledFunctionTable[363124] = bhCheckWallRefAngle_0x261eb0; // 0x2629d8 - g_ps2RecompiledFunctionTable[363125] = bhCheckWallRefAngle_0x261eb0; // 0x2629dc - g_ps2RecompiledFunctionTable[363126] = bhCheckWallRefAngle_0x261eb0; // 0x2629e0 - g_ps2RecompiledFunctionTable[363127] = bhCheckWallRefAngle_0x261eb0; // 0x2629e4 - g_ps2RecompiledFunctionTable[363128] = bhCheckWallRefAngle_0x261eb0; // 0x2629e8 - g_ps2RecompiledFunctionTable[363129] = bhCheckWallRefAngle_0x261eb0; // 0x2629ec - g_ps2RecompiledFunctionTable[363130] = bhCheckWallRefAngle_0x261eb0; // 0x2629f0 - g_ps2RecompiledFunctionTable[363131] = bhCheckWallRefAngle_0x261eb0; // 0x2629f4 - g_ps2RecompiledFunctionTable[363132] = bhCheckWallRefAngle_0x261eb0; // 0x2629f8 - g_ps2RecompiledFunctionTable[363133] = bhCheckWallRefAngle_0x261eb0; // 0x2629fc - g_ps2RecompiledFunctionTable[363134] = bhCheckWallRefAngle_0x261eb0; // 0x262a00 - g_ps2RecompiledFunctionTable[363135] = bhCheckWallRefAngle_0x261eb0; // 0x262a04 - g_ps2RecompiledFunctionTable[363136] = bhCheckWallRefAngle_0x261eb0; // 0x262a08 - g_ps2RecompiledFunctionTable[363137] = bhCheckWallRefAngle_0x261eb0; // 0x262a0c - g_ps2RecompiledFunctionTable[363138] = bhCheckWallRefAngle_0x261eb0; // 0x262a10 - g_ps2RecompiledFunctionTable[363139] = bhCheckWallRefAngle_0x261eb0; // 0x262a14 - g_ps2RecompiledFunctionTable[363140] = bhCheckWallRefAngle_0x261eb0; // 0x262a18 - g_ps2RecompiledFunctionTable[363141] = bhCheckWallRefAngle_0x261eb0; // 0x262a1c - g_ps2RecompiledFunctionTable[363142] = bhCheckWallRefAngle_0x261eb0; // 0x262a20 - g_ps2RecompiledFunctionTable[363143] = bhCheckWallRefAngle_0x261eb0; // 0x262a24 - g_ps2RecompiledFunctionTable[363144] = bhCheckWallRefAngle_0x261eb0; // 0x262a28 - g_ps2RecompiledFunctionTable[363145] = bhCheckWallRefAngle_0x261eb0; // 0x262a2c - g_ps2RecompiledFunctionTable[363146] = bhCheckWallRefAngle_0x261eb0; // 0x262a30 - g_ps2RecompiledFunctionTable[363147] = bhCheckWallRefAngle_0x261eb0; // 0x262a34 - g_ps2RecompiledFunctionTable[363148] = bhCheckWallRefAngle_0x261eb0; // 0x262a38 - g_ps2RecompiledFunctionTable[363149] = bhCheckWallRefAngle_0x261eb0; // 0x262a3c - g_ps2RecompiledFunctionTable[363150] = bhCheckWallRefAngle_0x261eb0; // 0x262a40 - g_ps2RecompiledFunctionTable[363151] = bhCheckWallRefAngle_0x261eb0; // 0x262a44 - g_ps2RecompiledFunctionTable[363152] = bhCheckWallRefAngle_0x261eb0; // 0x262a48 - g_ps2RecompiledFunctionTable[363153] = bhCheckWallRefAngle_0x261eb0; // 0x262a4c - g_ps2RecompiledFunctionTable[363154] = bhCheckWallRefAngle_0x261eb0; // 0x262a50 - g_ps2RecompiledFunctionTable[363155] = bhCheckWallRefAngle_0x261eb0; // 0x262a54 - g_ps2RecompiledFunctionTable[363156] = bhCheckWallRefAngle_0x261eb0; // 0x262a58 - g_ps2RecompiledFunctionTable[363157] = bhCheckWallRefAngle_0x261eb0; // 0x262a5c - g_ps2RecompiledFunctionTable[363158] = bhCheckWallRefAngle_0x261eb0; // 0x262a60 - g_ps2RecompiledFunctionTable[363159] = bhCheckWallRefAngle_0x261eb0; // 0x262a64 - g_ps2RecompiledFunctionTable[363160] = bhCheckWallRefAngle_0x261eb0; // 0x262a68 - g_ps2RecompiledFunctionTable[363161] = bhCheckWallRefAngle_0x261eb0; // 0x262a6c - g_ps2RecompiledFunctionTable[363162] = bhCheckWallRefAngle_0x261eb0; // 0x262a70 - g_ps2RecompiledFunctionTable[363163] = bhCheckWallRefAngle_0x261eb0; // 0x262a74 - g_ps2RecompiledFunctionTable[363164] = bhCheckWallRefAngle_0x261eb0; // 0x262a78 - g_ps2RecompiledFunctionTable[363165] = bhCheckWallRefAngle_0x261eb0; // 0x262a7c - g_ps2RecompiledFunctionTable[363166] = bhCheckWallRefAngle_0x261eb0; // 0x262a80 - g_ps2RecompiledFunctionTable[363167] = bhCheckWallRefAngle_0x261eb0; // 0x262a84 - g_ps2RecompiledFunctionTable[363168] = bhCheckWallRefAngle_0x261eb0; // 0x262a88 - g_ps2RecompiledFunctionTable[363169] = bhCheckWallRefAngle_0x261eb0; // 0x262a8c - g_ps2RecompiledFunctionTable[363170] = bhCheckWallRefAngle_0x261eb0; // 0x262a90 - g_ps2RecompiledFunctionTable[363171] = bhCheckWallRefAngle_0x261eb0; // 0x262a94 - g_ps2RecompiledFunctionTable[363172] = bhCheckWallRefAngle_0x261eb0; // 0x262a98 - g_ps2RecompiledFunctionTable[363173] = bhCheckWallRefAngle_0x261eb0; // 0x262a9c - g_ps2RecompiledFunctionTable[363174] = bhCheckWallRefAngle_0x261eb0; // 0x262aa0 - g_ps2RecompiledFunctionTable[363175] = bhCheckWallRefAngle_0x261eb0; // 0x262aa4 - g_ps2RecompiledFunctionTable[363176] = bhCheckWallRefAngle_0x261eb0; // 0x262aa8 - g_ps2RecompiledFunctionTable[363177] = bhCheckWallRefAngle_0x261eb0; // 0x262aac - g_ps2RecompiledFunctionTable[363178] = bhCheckWallRefAngle_0x261eb0; // 0x262ab0 - g_ps2RecompiledFunctionTable[363179] = bhCheckWallRefAngle_0x261eb0; // 0x262ab4 - g_ps2RecompiledFunctionTable[363180] = bhCheckWallRefAngle_0x261eb0; // 0x262ab8 - g_ps2RecompiledFunctionTable[363181] = bhCheckWallRefAngle_0x261eb0; // 0x262abc - g_ps2RecompiledFunctionTable[363182] = bhCheckWallRefAngle_0x261eb0; // 0x262ac0 - g_ps2RecompiledFunctionTable[363183] = bhCheckWallRefAngle_0x261eb0; // 0x262ac4 - g_ps2RecompiledFunctionTable[363184] = bhCheckWallRefAngle_0x261eb0; // 0x262ac8 - g_ps2RecompiledFunctionTable[363185] = bhCheckWallRefAngle_0x261eb0; // 0x262acc - g_ps2RecompiledFunctionTable[363186] = bhCheckWallRefAngle_0x261eb0; // 0x262ad0 - g_ps2RecompiledFunctionTable[363187] = bhCheckWallRefAngle_0x261eb0; // 0x262ad4 - g_ps2RecompiledFunctionTable[363188] = bhCheckWallRefAngle_0x261eb0; // 0x262ad8 - g_ps2RecompiledFunctionTable[363189] = bhCheckWallRefAngle_0x261eb0; // 0x262adc - g_ps2RecompiledFunctionTable[363190] = bhCheckWallRefAngle_0x261eb0; // 0x262ae0 - g_ps2RecompiledFunctionTable[363191] = bhCheckWallRefAngle_0x261eb0; // 0x262ae4 - g_ps2RecompiledFunctionTable[363192] = bhCheckWallRefAngle_0x261eb0; // 0x262ae8 - g_ps2RecompiledFunctionTable[363193] = bhCheckWallRefAngle_0x261eb0; // 0x262aec - g_ps2RecompiledFunctionTable[363194] = bhCheckWallRefAngle_0x261eb0; // 0x262af0 - g_ps2RecompiledFunctionTable[363195] = bhCheckWallRefAngle_0x261eb0; // 0x262af4 - g_ps2RecompiledFunctionTable[363196] = bhCheckWallRefAngle_0x261eb0; // 0x262af8 - g_ps2RecompiledFunctionTable[363197] = bhCheckWallRefAngle_0x261eb0; // 0x262afc - g_ps2RecompiledFunctionTable[363198] = bhCheckWallRefAngle_0x261eb0; // 0x262b00 - g_ps2RecompiledFunctionTable[363199] = bhCheckWallRefAngle_0x261eb0; // 0x262b04 - g_ps2RecompiledFunctionTable[363200] = bhCheckWallRefAngle_0x261eb0; // 0x262b08 - g_ps2RecompiledFunctionTable[363201] = bhCheckWallRefAngle_0x261eb0; // 0x262b0c - g_ps2RecompiledFunctionTable[363202] = bhCheckWallRefAngle_0x261eb0; // 0x262b10 - g_ps2RecompiledFunctionTable[363203] = bhCheckWallRefAngle_0x261eb0; // 0x262b14 - g_ps2RecompiledFunctionTable[363204] = bhCheckWallRefAngle_0x261eb0; // 0x262b18 - g_ps2RecompiledFunctionTable[363205] = bhCheckWallRefAngle_0x261eb0; // 0x262b1c - g_ps2RecompiledFunctionTable[363206] = bhCheckWallRefAngle_0x261eb0; // 0x262b20 - g_ps2RecompiledFunctionTable[363207] = bhCheckWallRefAngle_0x261eb0; // 0x262b24 - g_ps2RecompiledFunctionTable[363208] = bhCheckWallRefAngle_0x261eb0; // 0x262b28 - g_ps2RecompiledFunctionTable[363209] = bhCheckWallRefAngle_0x261eb0; // 0x262b2c - g_ps2RecompiledFunctionTable[363210] = bhCheckWallRefAngle_0x261eb0; // 0x262b30 - g_ps2RecompiledFunctionTable[363211] = bhCheckWallRefAngle_0x261eb0; // 0x262b34 - g_ps2RecompiledFunctionTable[363212] = bhCheckWallRefAngle_0x261eb0; // 0x262b38 - g_ps2RecompiledFunctionTable[363213] = bhCheckWallRefAngle_0x261eb0; // 0x262b3c - g_ps2RecompiledFunctionTable[363214] = bhCheckWallRefAngle_0x261eb0; // 0x262b40 - g_ps2RecompiledFunctionTable[363215] = bhCheckWallRefAngle_0x261eb0; // 0x262b44 - g_ps2RecompiledFunctionTable[363216] = bhCheckWallRefAngle_0x261eb0; // 0x262b48 - g_ps2RecompiledFunctionTable[363217] = bhCheckWallRefAngle_0x261eb0; // 0x262b4c - g_ps2RecompiledFunctionTable[363218] = bhCheckWallRefAngle_0x261eb0; // 0x262b50 - g_ps2RecompiledFunctionTable[363219] = bhCheckWallRefAngle_0x261eb0; // 0x262b54 - g_ps2RecompiledFunctionTable[363220] = bhCheckWallRefAngle_0x261eb0; // 0x262b58 - g_ps2RecompiledFunctionTable[363221] = bhCheckWallRefAngle_0x261eb0; // 0x262b5c - g_ps2RecompiledFunctionTable[363222] = bhCheckWallRefAngle_0x261eb0; // 0x262b60 - g_ps2RecompiledFunctionTable[363223] = bhCheckWallRefAngle_0x261eb0; // 0x262b64 - g_ps2RecompiledFunctionTable[363224] = bhCheckWallRefAngle_0x261eb0; // 0x262b68 - g_ps2RecompiledFunctionTable[363225] = bhCheckWallRefAngle_0x261eb0; // 0x262b6c - g_ps2RecompiledFunctionTable[363226] = bhCheckWallRefAngle_0x261eb0; // 0x262b70 - g_ps2RecompiledFunctionTable[363227] = bhCheckWallRefAngle_0x261eb0; // 0x262b74 - g_ps2RecompiledFunctionTable[363228] = bhCheckWallRefAngle_0x261eb0; // 0x262b78 - g_ps2RecompiledFunctionTable[363229] = bhCheckWallRefAngle_0x261eb0; // 0x262b7c - g_ps2RecompiledFunctionTable[363230] = bhCheckWallRefAngle_0x261eb0; // 0x262b80 - g_ps2RecompiledFunctionTable[363231] = bhCheckWallRefAngle_0x261eb0; // 0x262b84 - g_ps2RecompiledFunctionTable[363232] = bhCheckWallRefAngle_0x261eb0; // 0x262b88 - g_ps2RecompiledFunctionTable[363233] = bhCheckWallRefAngle_0x261eb0; // 0x262b8c - g_ps2RecompiledFunctionTable[363234] = bhCheckWallRefAngle_0x261eb0; // 0x262b90 - g_ps2RecompiledFunctionTable[363235] = bhCheckWallRefAngle_0x261eb0; // 0x262b94 - g_ps2RecompiledFunctionTable[363236] = bhCheckWallRefAngle_0x261eb0; // 0x262b98 - g_ps2RecompiledFunctionTable[363237] = bhCheckWallRefAngle_0x261eb0; // 0x262b9c - g_ps2RecompiledFunctionTable[363238] = bhCheckWallRefAngle_0x261eb0; // 0x262ba0 - g_ps2RecompiledFunctionTable[363239] = bhCheckWallRefAngle_0x261eb0; // 0x262ba4 - g_ps2RecompiledFunctionTable[363240] = bhCheckWallRefAngle_0x261eb0; // 0x262ba8 - g_ps2RecompiledFunctionTable[363241] = bhCheckWallRefAngle_0x261eb0; // 0x262bac - g_ps2RecompiledFunctionTable[363242] = bhCheckWallRefAngle_0x261eb0; // 0x262bb0 - g_ps2RecompiledFunctionTable[363243] = bhCheckWallRefAngle_0x261eb0; // 0x262bb4 - g_ps2RecompiledFunctionTable[363244] = bhCheckWallRefAngle_0x261eb0; // 0x262bb8 - g_ps2RecompiledFunctionTable[363245] = bhCheckWallRefAngle_0x261eb0; // 0x262bbc - g_ps2RecompiledFunctionTable[363246] = bhCheckWallRefAngle_0x261eb0; // 0x262bc0 - g_ps2RecompiledFunctionTable[363247] = bhCheckWallRefAngle_0x261eb0; // 0x262bc4 - g_ps2RecompiledFunctionTable[363248] = bhCheckWallRefAngle_0x261eb0; // 0x262bc8 - g_ps2RecompiledFunctionTable[363249] = bhCheckWallRefAngle_0x261eb0; // 0x262bcc - g_ps2RecompiledFunctionTable[363250] = bhCheckWallRefAngle_0x261eb0; // 0x262bd0 - g_ps2RecompiledFunctionTable[363251] = bhCheckWallRefAngle_0x261eb0; // 0x262bd4 - g_ps2RecompiledFunctionTable[363252] = bhCheckWallRefAngle_0x261eb0; // 0x262bd8 - g_ps2RecompiledFunctionTable[363253] = bhCheckWallRefAngle_0x261eb0; // 0x262bdc - g_ps2RecompiledFunctionTable[363254] = bhCheckWallRefAngle_0x261eb0; // 0x262be0 - g_ps2RecompiledFunctionTable[363255] = bhCheckWallRefAngle_0x261eb0; // 0x262be4 - g_ps2RecompiledFunctionTable[363256] = bhCheckWallRefAngle_0x261eb0; // 0x262be8 - g_ps2RecompiledFunctionTable[363257] = bhCheckWallRefAngle_0x261eb0; // 0x262bec - g_ps2RecompiledFunctionTable[363258] = bhCheckWallRefAngle_0x261eb0; // 0x262bf0 - g_ps2RecompiledFunctionTable[363259] = bhCheckWallRefAngle_0x261eb0; // 0x262bf4 - g_ps2RecompiledFunctionTable[363260] = bhCheckWallRefAngle_0x261eb0; // 0x262bf8 - g_ps2RecompiledFunctionTable[363261] = bhCheckWallRefAngle_0x261eb0; // 0x262bfc - g_ps2RecompiledFunctionTable[363262] = bhCheckWallRefAngle_0x261eb0; // 0x262c00 - g_ps2RecompiledFunctionTable[363263] = bhCheckWallRefAngle_0x261eb0; // 0x262c04 - g_ps2RecompiledFunctionTable[363264] = bhCheckWallRefAngle_0x261eb0; // 0x262c08 - g_ps2RecompiledFunctionTable[363265] = bhCheckWallRefAngle_0x261eb0; // 0x262c0c - g_ps2RecompiledFunctionTable[363266] = bhCheckWallRefAngle_0x261eb0; // 0x262c10 - g_ps2RecompiledFunctionTable[363267] = bhCheckWallRefAngle_0x261eb0; // 0x262c14 - g_ps2RecompiledFunctionTable[363268] = bhCheckWallRefAngle_0x261eb0; // 0x262c18 - g_ps2RecompiledFunctionTable[363269] = bhCheckWallRefAngle_0x261eb0; // 0x262c1c - g_ps2RecompiledFunctionTable[363270] = bhCheckWallRefAngle_0x261eb0; // 0x262c20 - g_ps2RecompiledFunctionTable[363271] = bhCheckWallRefAngle_0x261eb0; // 0x262c24 - g_ps2RecompiledFunctionTable[363272] = bhCheckWallRefAngle_0x261eb0; // 0x262c28 - g_ps2RecompiledFunctionTable[363273] = bhCheckWallRefAngle_0x261eb0; // 0x262c2c - g_ps2RecompiledFunctionTable[363274] = bhCheckWallRefAngle_0x261eb0; // 0x262c30 - g_ps2RecompiledFunctionTable[363275] = bhCheckWallRefAngle_0x261eb0; // 0x262c34 - g_ps2RecompiledFunctionTable[363276] = bhCheckWallRefAngle_0x261eb0; // 0x262c38 - g_ps2RecompiledFunctionTable[363277] = bhCheckWallRefAngle_0x261eb0; // 0x262c3c - g_ps2RecompiledFunctionTable[363278] = bhCheckWallRefAngle_0x261eb0; // 0x262c40 - g_ps2RecompiledFunctionTable[363279] = bhCheckWallRefAngle_0x261eb0; // 0x262c44 - g_ps2RecompiledFunctionTable[363280] = bhCheckWallRefAngle_0x261eb0; // 0x262c48 - g_ps2RecompiledFunctionTable[363281] = bhCheckWallRefAngle_0x261eb0; // 0x262c4c - g_ps2RecompiledFunctionTable[363282] = bhCheckWallRefAngle_0x261eb0; // 0x262c50 - g_ps2RecompiledFunctionTable[363283] = bhCheckWallRefAngle_0x261eb0; // 0x262c54 - g_ps2RecompiledFunctionTable[363284] = bhCheckWallRefAngle_0x261eb0; // 0x262c58 - g_ps2RecompiledFunctionTable[363285] = bhCheckWallRefAngle_0x261eb0; // 0x262c5c - g_ps2RecompiledFunctionTable[363286] = bhCheckWallRefAngle_0x261eb0; // 0x262c60 - g_ps2RecompiledFunctionTable[363287] = bhCheckWallRefAngle_0x261eb0; // 0x262c64 - g_ps2RecompiledFunctionTable[363288] = bhCheckWallRefAngle_0x261eb0; // 0x262c68 - g_ps2RecompiledFunctionTable[363289] = bhCheckWallRefAngle_0x261eb0; // 0x262c6c - g_ps2RecompiledFunctionTable[363290] = bhCheckWallRefAngle_0x261eb0; // 0x262c70 - g_ps2RecompiledFunctionTable[363291] = bhCheckWallRefAngle_0x261eb0; // 0x262c74 - g_ps2RecompiledFunctionTable[363292] = bhCheckWallRefAngle_0x261eb0; // 0x262c78 - g_ps2RecompiledFunctionTable[363293] = bhCheckWallRefAngle_0x261eb0; // 0x262c7c - g_ps2RecompiledFunctionTable[363294] = bhCheckWallRefAngle_0x261eb0; // 0x262c80 - g_ps2RecompiledFunctionTable[363295] = bhCheckWallRefAngle_0x261eb0; // 0x262c84 - g_ps2RecompiledFunctionTable[363296] = bhCheckWallRefAngle_0x261eb0; // 0x262c88 - g_ps2RecompiledFunctionTable[363297] = bhCheckWallRefAngle_0x261eb0; // 0x262c8c - g_ps2RecompiledFunctionTable[363298] = bhCheckWallRefAngle_0x261eb0; // 0x262c90 - g_ps2RecompiledFunctionTable[363299] = bhCheckWallRefAngle_0x261eb0; // 0x262c94 - g_ps2RecompiledFunctionTable[363300] = bhCheckWallRefAngle_0x261eb0; // 0x262c98 - g_ps2RecompiledFunctionTable[363301] = bhCheckWallRefAngle_0x261eb0; // 0x262c9c - g_ps2RecompiledFunctionTable[363302] = bhCheckWallRefAngle_0x261eb0; // 0x262ca0 - g_ps2RecompiledFunctionTable[363303] = bhCheckWallRefAngle_0x261eb0; // 0x262ca4 - g_ps2RecompiledFunctionTable[363304] = bhCheckWallRefAngle_0x261eb0; // 0x262ca8 - g_ps2RecompiledFunctionTable[363305] = bhCheckWallRefAngle_0x261eb0; // 0x262cac - g_ps2RecompiledFunctionTable[363306] = bhCheckWallRefAngle_0x261eb0; // 0x262cb0 - g_ps2RecompiledFunctionTable[363307] = bhCheckWallRefAngle_0x261eb0; // 0x262cb4 - g_ps2RecompiledFunctionTable[363308] = bhCheckWallRefAngle_0x261eb0; // 0x262cb8 - g_ps2RecompiledFunctionTable[363309] = bhCheckWallRefAngle_0x261eb0; // 0x262cbc - g_ps2RecompiledFunctionTable[363310] = bhCheckWallRefAngle_0x261eb0; // 0x262cc0 - g_ps2RecompiledFunctionTable[363311] = bhCheckWallRefAngle_0x261eb0; // 0x262cc4 - g_ps2RecompiledFunctionTable[363312] = bhCheckWallRefAngle_0x261eb0; // 0x262cc8 - g_ps2RecompiledFunctionTable[363313] = bhCheckWallRefAngle_0x261eb0; // 0x262ccc - g_ps2RecompiledFunctionTable[363314] = bhCheckWallRefAngle_0x261eb0; // 0x262cd0 - g_ps2RecompiledFunctionTable[363315] = bhCheckWallRefAngle_0x261eb0; // 0x262cd4 - g_ps2RecompiledFunctionTable[363316] = bhCheckWallRefAngle_0x261eb0; // 0x262cd8 - g_ps2RecompiledFunctionTable[363317] = bhCheckWallRefAngle_0x261eb0; // 0x262cdc - g_ps2RecompiledFunctionTable[363318] = bhCheckWallRefAngle_0x261eb0; // 0x262ce0 - g_ps2RecompiledFunctionTable[363319] = bhCheckWallRefAngle_0x261eb0; // 0x262ce4 - g_ps2RecompiledFunctionTable[363320] = bhCheckWallRefAngle_0x261eb0; // 0x262ce8 - g_ps2RecompiledFunctionTable[363321] = bhCheckWallRefAngle_0x261eb0; // 0x262cec - g_ps2RecompiledFunctionTable[363322] = bhCheckWallRefAngle_0x261eb0; // 0x262cf0 - g_ps2RecompiledFunctionTable[363323] = bhCheckWallRefAngle_0x261eb0; // 0x262cf4 - g_ps2RecompiledFunctionTable[363324] = bhCheckWallRefAngle_0x261eb0; // 0x262cf8 - g_ps2RecompiledFunctionTable[363325] = bhCheckWallRefAngle_0x261eb0; // 0x262cfc - g_ps2RecompiledFunctionTable[363326] = bhCheckWallRefAngle_0x261eb0; // 0x262d00 - g_ps2RecompiledFunctionTable[363327] = bhCheckWallRefAngle_0x261eb0; // 0x262d04 - g_ps2RecompiledFunctionTable[363328] = bhCheckWallRefAngle_0x261eb0; // 0x262d08 - g_ps2RecompiledFunctionTable[363329] = bhCheckWallRefAngle_0x261eb0; // 0x262d0c - g_ps2RecompiledFunctionTable[363330] = bhCheckWallRefAngle_0x261eb0; // 0x262d10 - g_ps2RecompiledFunctionTable[363331] = bhCheckWallRefAngle_0x261eb0; // 0x262d14 - g_ps2RecompiledFunctionTable[363332] = bhCheckWallRefAngle_0x261eb0; // 0x262d18 - g_ps2RecompiledFunctionTable[363333] = bhCheckWallRefAngle_0x261eb0; // 0x262d1c - g_ps2RecompiledFunctionTable[363334] = bhCheckWallRefAngle_0x261eb0; // 0x262d20 - g_ps2RecompiledFunctionTable[363335] = bhCheckWallRefAngle_0x261eb0; // 0x262d24 - g_ps2RecompiledFunctionTable[363336] = bhCheckWallRefAngle_0x261eb0; // 0x262d28 - g_ps2RecompiledFunctionTable[363337] = bhCheckWallRefAngle_0x261eb0; // 0x262d2c - g_ps2RecompiledFunctionTable[363338] = bhCheckWallRefAngle_0x261eb0; // 0x262d30 - g_ps2RecompiledFunctionTable[363339] = bhCheckWallRefAngle_0x261eb0; // 0x262d34 - g_ps2RecompiledFunctionTable[363340] = bhCheckWallRefAngle_0x261eb0; // 0x262d38 - g_ps2RecompiledFunctionTable[363341] = bhCheckWallRefAngle_0x261eb0; // 0x262d3c - g_ps2RecompiledFunctionTable[363342] = bhCheckWallRefAngle_0x261eb0; // 0x262d40 - g_ps2RecompiledFunctionTable[363343] = bhCheckWallRefAngle_0x261eb0; // 0x262d44 - g_ps2RecompiledFunctionTable[363344] = bhCheckWallRefAngle_0x261eb0; // 0x262d48 - g_ps2RecompiledFunctionTable[363345] = bhCheckWallRefAngle_0x261eb0; // 0x262d4c - g_ps2RecompiledFunctionTable[363346] = bhCheckWallRefAngle_0x261eb0; // 0x262d50 - g_ps2RecompiledFunctionTable[363347] = bhCheckWallRefAngle_0x261eb0; // 0x262d54 - g_ps2RecompiledFunctionTable[363348] = bhCheckWallRefAngle_0x261eb0; // 0x262d58 - g_ps2RecompiledFunctionTable[363349] = bhCheckWallRefAngle_0x261eb0; // 0x262d5c - g_ps2RecompiledFunctionTable[363350] = bhCheckWallRefAngle_0x261eb0; // 0x262d60 - g_ps2RecompiledFunctionTable[363351] = bhCheckWallRefAngle_0x261eb0; // 0x262d64 - g_ps2RecompiledFunctionTable[363352] = bhCheckWallRefAngle_0x261eb0; // 0x262d68 - g_ps2RecompiledFunctionTable[363353] = bhCheckWallRefAngle_0x261eb0; // 0x262d6c - g_ps2RecompiledFunctionTable[363354] = bhCheckWallRefAngle_0x261eb0; // 0x262d70 - g_ps2RecompiledFunctionTable[363355] = bhCheckWallRefAngle_0x261eb0; // 0x262d74 - g_ps2RecompiledFunctionTable[363356] = bhCheckWallRefAngle_0x261eb0; // 0x262d78 - g_ps2RecompiledFunctionTable[363357] = bhCheckWallRefAngle_0x261eb0; // 0x262d7c - g_ps2RecompiledFunctionTable[363358] = bhCheckWallRefAngle_0x261eb0; // 0x262d80 - g_ps2RecompiledFunctionTable[363359] = bhCheckWallRefAngle_0x261eb0; // 0x262d84 - g_ps2RecompiledFunctionTable[363360] = bhCheckWallRefAngle_0x261eb0; // 0x262d88 - g_ps2RecompiledFunctionTable[363361] = bhCheckWallRefAngle_0x261eb0; // 0x262d8c - g_ps2RecompiledFunctionTable[363362] = bhCheckWallRefAngle_0x261eb0; // 0x262d90 - g_ps2RecompiledFunctionTable[363363] = bhCheckWallRefAngle_0x261eb0; // 0x262d94 - g_ps2RecompiledFunctionTable[363364] = bhCheckWallRefAngle_0x261eb0; // 0x262d98 - g_ps2RecompiledFunctionTable[363365] = bhCheckWallRefAngle_0x261eb0; // 0x262d9c - g_ps2RecompiledFunctionTable[363366] = bhCheckWallRefAngle_0x261eb0; // 0x262da0 - g_ps2RecompiledFunctionTable[363367] = bhCheckWallRefAngle_0x261eb0; // 0x262da4 - g_ps2RecompiledFunctionTable[363368] = bhCheckWallRefAngle_0x261eb0; // 0x262da8 - g_ps2RecompiledFunctionTable[363369] = bhCheckWallRefAngle_0x261eb0; // 0x262dac - g_ps2RecompiledFunctionTable[363370] = bhCheckWallRefAngle_0x261eb0; // 0x262db0 - g_ps2RecompiledFunctionTable[363371] = bhCheckWallRefAngle_0x261eb0; // 0x262db4 - g_ps2RecompiledFunctionTable[363372] = bhCheckWallRefAngle_0x261eb0; // 0x262db8 - g_ps2RecompiledFunctionTable[363373] = bhCheckWallRefAngle_0x261eb0; // 0x262dbc - g_ps2RecompiledFunctionTable[363374] = bhCheckWallRefAngle_0x261eb0; // 0x262dc0 - g_ps2RecompiledFunctionTable[363375] = bhCheckWallRefAngle_0x261eb0; // 0x262dc4 - g_ps2RecompiledFunctionTable[363376] = bhCheckWallRefAngle_0x261eb0; // 0x262dc8 - g_ps2RecompiledFunctionTable[363377] = bhCheckWallRefAngle_0x261eb0; // 0x262dcc - g_ps2RecompiledFunctionTable[363378] = bhCheckWallRefAngle_0x261eb0; // 0x262dd0 - g_ps2RecompiledFunctionTable[363379] = bhCheckWallRefAngle_0x261eb0; // 0x262dd4 - g_ps2RecompiledFunctionTable[363380] = bhCheckWallRefAngle_0x261eb0; // 0x262dd8 - g_ps2RecompiledFunctionTable[363381] = bhCheckWallRefAngle_0x261eb0; // 0x262ddc - g_ps2RecompiledFunctionTable[363382] = bhCheckWallRefAngle_0x261eb0; // 0x262de0 - g_ps2RecompiledFunctionTable[363383] = bhCheckWallRefAngle_0x261eb0; // 0x262de4 - g_ps2RecompiledFunctionTable[363384] = bhCheckWallRefAngle_0x261eb0; // 0x262de8 - g_ps2RecompiledFunctionTable[363385] = bhCheckWallRefAngle_0x261eb0; // 0x262dec - g_ps2RecompiledFunctionTable[363386] = bhCheckWallRefAngle_0x261eb0; // 0x262df0 - g_ps2RecompiledFunctionTable[363387] = bhCheckWallRefAngle_0x261eb0; // 0x262df4 - g_ps2RecompiledFunctionTable[363388] = bhCheckWallRefAngle_0x261eb0; // 0x262df8 - g_ps2RecompiledFunctionTable[363389] = bhCheckWallRefAngle_0x261eb0; // 0x262dfc - g_ps2RecompiledFunctionTable[363390] = bhCheckWallRefAngle_0x261eb0; // 0x262e00 - g_ps2RecompiledFunctionTable[363391] = bhCheckWallRefAngle_0x261eb0; // 0x262e04 - g_ps2RecompiledFunctionTable[363392] = bhCheckWallRefAngle_0x261eb0; // 0x262e08 - g_ps2RecompiledFunctionTable[363393] = bhCheckWallRefAngle_0x261eb0; // 0x262e0c - g_ps2RecompiledFunctionTable[363394] = bhCheckWallRefAngle_0x261eb0; // 0x262e10 - g_ps2RecompiledFunctionTable[363395] = bhCheckWallRefAngle_0x261eb0; // 0x262e14 - g_ps2RecompiledFunctionTable[363396] = bhCheckWallRefAngle_0x261eb0; // 0x262e18 - g_ps2RecompiledFunctionTable[363397] = bhCheckWallRefAngle_0x261eb0; // 0x262e1c - g_ps2RecompiledFunctionTable[363398] = bhCheckWallRefAngle_0x261eb0; // 0x262e20 - g_ps2RecompiledFunctionTable[363399] = bhCheckWallRefAngle_0x261eb0; // 0x262e24 - g_ps2RecompiledFunctionTable[363400] = bhCheckWallRefAngle_0x261eb0; // 0x262e28 - g_ps2RecompiledFunctionTable[363401] = bhCheckWallRefAngle_0x261eb0; // 0x262e2c - g_ps2RecompiledFunctionTable[363402] = bhCheckWallRefAngle_0x261eb0; // 0x262e30 - g_ps2RecompiledFunctionTable[363403] = bhCheckWallRefAngle_0x261eb0; // 0x262e34 - g_ps2RecompiledFunctionTable[363404] = bhCheckWallRefAngle_0x261eb0; // 0x262e38 - g_ps2RecompiledFunctionTable[363405] = bhCheckWallRefAngle_0x261eb0; // 0x262e3c - g_ps2RecompiledFunctionTable[363406] = bhCheckWallRefAngle_0x261eb0; // 0x262e40 - g_ps2RecompiledFunctionTable[363407] = bhCheckWallRefAngle_0x261eb0; // 0x262e44 - g_ps2RecompiledFunctionTable[363408] = bhCheckWallRefAngle_0x261eb0; // 0x262e48 - g_ps2RecompiledFunctionTable[363409] = bhCheckWallRefAngle_0x261eb0; // 0x262e4c - g_ps2RecompiledFunctionTable[363410] = bhCheckWallRefAngle_0x261eb0; // 0x262e50 - g_ps2RecompiledFunctionTable[363411] = bhCheckWallRefAngle_0x261eb0; // 0x262e54 - g_ps2RecompiledFunctionTable[363412] = bhCheckWallRefAngle_0x261eb0; // 0x262e58 - g_ps2RecompiledFunctionTable[363413] = bhCheckWallRefAngle_0x261eb0; // 0x262e5c - g_ps2RecompiledFunctionTable[363414] = bhCheckWallRefAngle_0x261eb0; // 0x262e60 - g_ps2RecompiledFunctionTable[363415] = bhCheckWallRefAngle_0x261eb0; // 0x262e64 - g_ps2RecompiledFunctionTable[363416] = bhCheckWallRefAngle_0x261eb0; // 0x262e68 - g_ps2RecompiledFunctionTable[363417] = bhCheckWallRefAngle_0x261eb0; // 0x262e6c - g_ps2RecompiledFunctionTable[363418] = bhCheckWallRefAngle_0x261eb0; // 0x262e70 - g_ps2RecompiledFunctionTable[363419] = bhCheckWallRefAngle_0x261eb0; // 0x262e74 - g_ps2RecompiledFunctionTable[363420] = bhCheckWallRefAngle_0x261eb0; // 0x262e78 - g_ps2RecompiledFunctionTable[363421] = bhCheckWallRefAngle_0x261eb0; // 0x262e7c - g_ps2RecompiledFunctionTable[363422] = bhCheckWallRefAngle_0x261eb0; // 0x262e80 - g_ps2RecompiledFunctionTable[363423] = bhCheckWallRefAngle_0x261eb0; // 0x262e84 - g_ps2RecompiledFunctionTable[363424] = bhCheckWallRefAngle_0x261eb0; // 0x262e88 - g_ps2RecompiledFunctionTable[363425] = bhCheckWallRefAngle_0x261eb0; // 0x262e8c - g_ps2RecompiledFunctionTable[363426] = bhCheckWallRefAngle_0x261eb0; // 0x262e90 - g_ps2RecompiledFunctionTable[363427] = bhCheckWallRefAngle_0x261eb0; // 0x262e94 - g_ps2RecompiledFunctionTable[363428] = bhCheckWallRefAngle_0x261eb0; // 0x262e98 - g_ps2RecompiledFunctionTable[363429] = bhCheckWallRefAngle_0x261eb0; // 0x262e9c - g_ps2RecompiledFunctionTable[363430] = bhCheckWallRefAngle_0x261eb0; // 0x262ea0 - g_ps2RecompiledFunctionTable[363431] = bhCheckWallRefAngle_0x261eb0; // 0x262ea4 - g_ps2RecompiledFunctionTable[363432] = bhCheckWallRefAngle_0x261eb0; // 0x262ea8 - g_ps2RecompiledFunctionTable[363433] = bhCheckWallRefAngle_0x261eb0; // 0x262eac - g_ps2RecompiledFunctionTable[363434] = bhCheckWallRefAngle_0x261eb0; // 0x262eb0 - g_ps2RecompiledFunctionTable[363435] = bhCheckWallRefAngle_0x261eb0; // 0x262eb4 - g_ps2RecompiledFunctionTable[363436] = bhCheckWallRefAngle_0x261eb0; // 0x262eb8 - g_ps2RecompiledFunctionTable[363437] = bhCheckWallRefAngle_0x261eb0; // 0x262ebc - g_ps2RecompiledFunctionTable[363438] = bhCheckWallRefAngle_0x261eb0; // 0x262ec0 - g_ps2RecompiledFunctionTable[363439] = bhCheckWallRefAngle_0x261eb0; // 0x262ec4 - g_ps2RecompiledFunctionTable[363440] = bhCheckWallRefAngle_0x261eb0; // 0x262ec8 - g_ps2RecompiledFunctionTable[363441] = bhCheckWallRefAngle_0x261eb0; // 0x262ecc - g_ps2RecompiledFunctionTable[363442] = bhCheckWallRefAngle_0x261eb0; // 0x262ed0 - g_ps2RecompiledFunctionTable[363443] = bhCheckWallRefAngle_0x261eb0; // 0x262ed4 - g_ps2RecompiledFunctionTable[363444] = bhCheckWallRefAngle_0x261eb0; // 0x262ed8 - g_ps2RecompiledFunctionTable[363445] = bhCheckWallRefAngle_0x261eb0; // 0x262edc - g_ps2RecompiledFunctionTable[363446] = bhCheckWallRefAngle_0x261eb0; // 0x262ee0 - g_ps2RecompiledFunctionTable[363447] = bhCheckWallRefAngle_0x261eb0; // 0x262ee4 - g_ps2RecompiledFunctionTable[363448] = bhCheckWallRefAngle_0x261eb0; // 0x262ee8 - g_ps2RecompiledFunctionTable[363449] = bhCheckWallRefAngle_0x261eb0; // 0x262eec - g_ps2RecompiledFunctionTable[363450] = bhCheckWallRefAngle_0x261eb0; // 0x262ef0 - g_ps2RecompiledFunctionTable[363451] = bhCheckWallRefAngle_0x261eb0; // 0x262ef4 - g_ps2RecompiledFunctionTable[363452] = bhCheckWallRefAngle_0x261eb0; // 0x262ef8 - g_ps2RecompiledFunctionTable[363453] = bhCheckWallRefAngle_0x261eb0; // 0x262efc - g_ps2RecompiledFunctionTable[363454] = bhCheckWallRefAngle_0x261eb0; // 0x262f00 - g_ps2RecompiledFunctionTable[363455] = bhCheckWallRefAngle_0x261eb0; // 0x262f04 - g_ps2RecompiledFunctionTable[363456] = bhCheckWallRefAngle_0x261eb0; // 0x262f08 - g_ps2RecompiledFunctionTable[363457] = bhCheckWallRefAngle_0x261eb0; // 0x262f0c - g_ps2RecompiledFunctionTable[363458] = bhCheckWallRefAngle_0x261eb0; // 0x262f10 - g_ps2RecompiledFunctionTable[363459] = bhCheckWallRefAngle_0x261eb0; // 0x262f14 - g_ps2RecompiledFunctionTable[363460] = bhCheckWallRefAngle_0x261eb0; // 0x262f18 - g_ps2RecompiledFunctionTable[363461] = bhCheckWallRefAngle_0x261eb0; // 0x262f1c - g_ps2RecompiledFunctionTable[363462] = bhCheckWallRefAngle_0x261eb0; // 0x262f20 - g_ps2RecompiledFunctionTable[363463] = bhCheckWallRefAngle_0x261eb0; // 0x262f24 - g_ps2RecompiledFunctionTable[363464] = bhCheckWallRefAngle_0x261eb0; // 0x262f28 - g_ps2RecompiledFunctionTable[363465] = bhCheckWallRefAngle_0x261eb0; // 0x262f2c - g_ps2RecompiledFunctionTable[363466] = bhCheckWallRefAngle_0x261eb0; // 0x262f30 - g_ps2RecompiledFunctionTable[363467] = bhCheckWallRefAngle_0x261eb0; // 0x262f34 - g_ps2RecompiledFunctionTable[363468] = bhCheckWallRefAngle_0x261eb0; // 0x262f38 - g_ps2RecompiledFunctionTable[363469] = bhCheckWallRefAngle_0x261eb0; // 0x262f3c - g_ps2RecompiledFunctionTable[363470] = bhCheckWallRefAngle_0x261eb0; // 0x262f40 - g_ps2RecompiledFunctionTable[363471] = bhCheckWallRefAngle_0x261eb0; // 0x262f44 - g_ps2RecompiledFunctionTable[363472] = bhCheckWallRefAngle_0x261eb0; // 0x262f48 - g_ps2RecompiledFunctionTable[363473] = bhCheckWallRefAngle_0x261eb0; // 0x262f4c - g_ps2RecompiledFunctionTable[363474] = bhCheckWallRefAngle_0x261eb0; // 0x262f50 - g_ps2RecompiledFunctionTable[363475] = bhCheckWallRefAngle_0x261eb0; // 0x262f54 - g_ps2RecompiledFunctionTable[363476] = bhCheckWallRefAngle_0x261eb0; // 0x262f58 - g_ps2RecompiledFunctionTable[363477] = bhCheckWallRefAngle_0x261eb0; // 0x262f5c - g_ps2RecompiledFunctionTable[363478] = bhCheckWallRefAngle_0x261eb0; // 0x262f60 - g_ps2RecompiledFunctionTable[363479] = bhCheckWallRefAngle_0x261eb0; // 0x262f64 - g_ps2RecompiledFunctionTable[363480] = bhCheckWallRefAngle_0x261eb0; // 0x262f68 - g_ps2RecompiledFunctionTable[363481] = bhCheckWallRefAngle_0x261eb0; // 0x262f6c - g_ps2RecompiledFunctionTable[363482] = bhCheckWallRefAngle_0x261eb0; // 0x262f70 - g_ps2RecompiledFunctionTable[363483] = bhCheckWallRefAngle_0x261eb0; // 0x262f74 - g_ps2RecompiledFunctionTable[363484] = bhCheckWallRefAngle_0x261eb0; // 0x262f78 - g_ps2RecompiledFunctionTable[363485] = bhCheckWallRefAngle_0x261eb0; // 0x262f7c - g_ps2RecompiledFunctionTable[363486] = bhCheckWallRefAngle_0x261eb0; // 0x262f80 - g_ps2RecompiledFunctionTable[363487] = bhCheckWallRefAngle_0x261eb0; // 0x262f84 - g_ps2RecompiledFunctionTable[363488] = bhCheckWallRefAngle_0x261eb0; // 0x262f88 - g_ps2RecompiledFunctionTable[363489] = bhCheckWallRefAngle_0x261eb0; // 0x262f8c - g_ps2RecompiledFunctionTable[363490] = bhCheckWallRefAngle_0x261eb0; // 0x262f90 - g_ps2RecompiledFunctionTable[363491] = bhCheckWallRefAngle_0x261eb0; // 0x262f94 - g_ps2RecompiledFunctionTable[363492] = bhCheckWallRefAngle_0x261eb0; // 0x262f98 - g_ps2RecompiledFunctionTable[363493] = bhCheckWallRefAngle_0x261eb0; // 0x262f9c - g_ps2RecompiledFunctionTable[363494] = bhCheckWallRefAngle_0x261eb0; // 0x262fa0 - g_ps2RecompiledFunctionTable[363495] = bhCheckWallRefAngle_0x261eb0; // 0x262fa4 - g_ps2RecompiledFunctionTable[363496] = bhCheckWallRefAngle_0x261eb0; // 0x262fa8 - g_ps2RecompiledFunctionTable[363497] = bhCheckWallRefAngle_0x261eb0; // 0x262fac - g_ps2RecompiledFunctionTable[363498] = bhCheckWallRefAngle_0x261eb0; // 0x262fb0 - g_ps2RecompiledFunctionTable[363499] = bhCheckWallRefAngle_0x261eb0; // 0x262fb4 - g_ps2RecompiledFunctionTable[363500] = bhCheckWallRefAngle_0x261eb0; // 0x262fb8 - g_ps2RecompiledFunctionTable[363501] = bhCheckWallRefAngle_0x261eb0; // 0x262fbc - g_ps2RecompiledFunctionTable[363502] = bhCheckWallRefAngle_0x261eb0; // 0x262fc0 - g_ps2RecompiledFunctionTable[363503] = bhCheckWallRefAngle_0x261eb0; // 0x262fc4 - g_ps2RecompiledFunctionTable[363504] = bhCheckWallRefAngle_0x261eb0; // 0x262fc8 - g_ps2RecompiledFunctionTable[363505] = bhCheckWallRefAngle_0x261eb0; // 0x262fcc - g_ps2RecompiledFunctionTable[363506] = bhCheckWallRefAngle_0x261eb0; // 0x262fd0 - g_ps2RecompiledFunctionTable[363507] = bhCheckWallRefAngle_0x261eb0; // 0x262fd4 - g_ps2RecompiledFunctionTable[363508] = bhCheckWallRefAngle_0x261eb0; // 0x262fd8 - g_ps2RecompiledFunctionTable[363509] = bhCheckWallRefAngle_0x261eb0; // 0x262fdc - g_ps2RecompiledFunctionTable[363510] = bhCheckWallRefAngle_0x261eb0; // 0x262fe0 - g_ps2RecompiledFunctionTable[363511] = bhCheckWallRefAngle_0x261eb0; // 0x262fe4 - g_ps2RecompiledFunctionTable[363512] = bhCheckWallRefAngle_0x261eb0; // 0x262fe8 - g_ps2RecompiledFunctionTable[363513] = bhCheckWallRefAngle_0x261eb0; // 0x262fec - g_ps2RecompiledFunctionTable[363514] = bhCheckWallRefAngle_0x261eb0; // 0x262ff0 - g_ps2RecompiledFunctionTable[363515] = bhCheckWallRefAngle_0x261eb0; // 0x262ff4 - g_ps2RecompiledFunctionTable[363516] = bhCheckWallRefAngle_0x261eb0; // 0x262ff8 - g_ps2RecompiledFunctionTable[363517] = bhCheckWallRefAngle_0x261eb0; // 0x262ffc - g_ps2RecompiledFunctionTable[363518] = bhCheckWallRefAngle_0x261eb0; // 0x263000 - g_ps2RecompiledFunctionTable[363519] = bhCheckWallRefAngle_0x261eb0; // 0x263004 - g_ps2RecompiledFunctionTable[363520] = bhCheckWallRefAngle_0x261eb0; // 0x263008 - g_ps2RecompiledFunctionTable[363521] = bhCheckWallRefAngle_0x261eb0; // 0x26300c - g_ps2RecompiledFunctionTable[363522] = bhCheckWallRefAngle_0x261eb0; // 0x263010 - g_ps2RecompiledFunctionTable[363523] = bhCheckWallRefAngle_0x261eb0; // 0x263014 - g_ps2RecompiledFunctionTable[363524] = bhCheckWallRefAngle_0x261eb0; // 0x263018 - g_ps2RecompiledFunctionTable[363525] = bhCheckWallRefAngle_0x261eb0; // 0x26301c - g_ps2RecompiledFunctionTable[363526] = bhCheckWallRefAngle_0x261eb0; // 0x263020 - g_ps2RecompiledFunctionTable[363527] = bhCheckWallRefAngle_0x261eb0; // 0x263024 - g_ps2RecompiledFunctionTable[363528] = bhCheckWallRefAngle_0x261eb0; // 0x263028 - g_ps2RecompiledFunctionTable[363529] = bhCheckWallRefAngle_0x261eb0; // 0x26302c - g_ps2RecompiledFunctionTable[363530] = bhCheckWallRefAngle_0x261eb0; // 0x263030 - g_ps2RecompiledFunctionTable[363531] = bhCheckWallRefAngle_0x261eb0; // 0x263034 - g_ps2RecompiledFunctionTable[363532] = bhCheckWallRefAngle_0x261eb0; // 0x263038 - g_ps2RecompiledFunctionTable[363533] = bhCheckWallRefAngle_0x261eb0; // 0x26303c - g_ps2RecompiledFunctionTable[363534] = bhCheckWallRefAngle_0x261eb0; // 0x263040 - g_ps2RecompiledFunctionTable[363535] = bhCheckWallRefAngle_0x261eb0; // 0x263044 - g_ps2RecompiledFunctionTable[363536] = bhCheckWallRefAngle_0x261eb0; // 0x263048 - g_ps2RecompiledFunctionTable[363537] = bhCheckWallRefAngle_0x261eb0; // 0x26304c - g_ps2RecompiledFunctionTable[363538] = bhCheckWallRefAngle_0x261eb0; // 0x263050 - g_ps2RecompiledFunctionTable[363539] = bhCheckWallRefAngle_0x261eb0; // 0x263054 - g_ps2RecompiledFunctionTable[363540] = bhCheckWallRefAngle_0x261eb0; // 0x263058 - g_ps2RecompiledFunctionTable[363541] = bhCheckWallRefAngle_0x261eb0; // 0x26305c - g_ps2RecompiledFunctionTable[363542] = bhCheckWallRefAngle_0x261eb0; // 0x263060 - g_ps2RecompiledFunctionTable[363543] = bhCheckWallRefAngle_0x261eb0; // 0x263064 - g_ps2RecompiledFunctionTable[363544] = bhCheckWallRefAngle_0x261eb0; // 0x263068 - g_ps2RecompiledFunctionTable[363545] = bhCheckWallRefAngle_0x261eb0; // 0x26306c - g_ps2RecompiledFunctionTable[363546] = bhCheckWallRefAngle_0x261eb0; // 0x263070 - g_ps2RecompiledFunctionTable[363547] = bhCheckWallRefAngle_0x261eb0; // 0x263074 - g_ps2RecompiledFunctionTable[363548] = bhCheckWallRefAngle_0x261eb0; // 0x263078 - g_ps2RecompiledFunctionTable[363549] = bhCheckWallRefAngle_0x261eb0; // 0x26307c - g_ps2RecompiledFunctionTable[363550] = bhCheckWallRefAngle_0x261eb0; // 0x263080 - g_ps2RecompiledFunctionTable[363551] = bhCheckWallRefAngle_0x261eb0; // 0x263084 - g_ps2RecompiledFunctionTable[363552] = bhCheckWallRefAngle_0x261eb0; // 0x263088 - g_ps2RecompiledFunctionTable[363553] = bhCheckWallRefAngle_0x261eb0; // 0x26308c - g_ps2RecompiledFunctionTable[363554] = bhCheckWallRefAngle_0x261eb0; // 0x263090 - g_ps2RecompiledFunctionTable[363555] = bhCheckWallRefAngle_0x261eb0; // 0x263094 - g_ps2RecompiledFunctionTable[363556] = bhCheckWallRefAngle_0x261eb0; // 0x263098 - g_ps2RecompiledFunctionTable[363557] = bhCheckWallRefAngle_0x261eb0; // 0x26309c - g_ps2RecompiledFunctionTable[363558] = bhCheckWallRefAngle_0x261eb0; // 0x2630a0 - g_ps2RecompiledFunctionTable[363559] = bhCheckWallRefAngle_0x261eb0; // 0x2630a4 - g_ps2RecompiledFunctionTable[363560] = bhCheckWallRefAngle_0x261eb0; // 0x2630a8 - g_ps2RecompiledFunctionTable[363561] = bhCheckWallRefAngle_0x261eb0; // 0x2630ac - g_ps2RecompiledFunctionTable[363562] = bhCheckWallRefAngle_0x261eb0; // 0x2630b0 - g_ps2RecompiledFunctionTable[363563] = bhCheckWallRefAngle_0x261eb0; // 0x2630b4 - g_ps2RecompiledFunctionTable[363564] = bhCheckWallRefAngle_0x261eb0; // 0x2630b8 - g_ps2RecompiledFunctionTable[363565] = bhCheckWallRefAngle_0x261eb0; // 0x2630bc - g_ps2RecompiledFunctionTable[363566] = bhCheckWallRefAngle_0x261eb0; // 0x2630c0 - g_ps2RecompiledFunctionTable[363567] = bhCheckWallRefAngle_0x261eb0; // 0x2630c4 - g_ps2RecompiledFunctionTable[363568] = bhCheckWallRefAngle_0x261eb0; // 0x2630c8 - g_ps2RecompiledFunctionTable[363569] = bhCheckWallRefAngle_0x261eb0; // 0x2630cc - g_ps2RecompiledFunctionTable[363570] = bhCheckWallRefAngle_0x261eb0; // 0x2630d0 - g_ps2RecompiledFunctionTable[363571] = bhCheckWallRefAngle_0x261eb0; // 0x2630d4 - g_ps2RecompiledFunctionTable[363572] = bhCheckWallRefAngle_0x261eb0; // 0x2630d8 - g_ps2RecompiledFunctionTable[363573] = bhCheckWallRefAngle_0x261eb0; // 0x2630dc - g_ps2RecompiledFunctionTable[363574] = bhCheckWallRefAngle_0x261eb0; // 0x2630e0 - g_ps2RecompiledFunctionTable[363575] = bhCheckWallRefAngle_0x261eb0; // 0x2630e4 - g_ps2RecompiledFunctionTable[363576] = bhCheckWallRefAngle_0x261eb0; // 0x2630e8 - g_ps2RecompiledFunctionTable[363577] = bhCheckWallRefAngle_0x261eb0; // 0x2630ec - g_ps2RecompiledFunctionTable[363578] = bhCheckWallRefAngle_0x261eb0; // 0x2630f0 - g_ps2RecompiledFunctionTable[363579] = bhCheckWallRefAngle_0x261eb0; // 0x2630f4 - g_ps2RecompiledFunctionTable[363580] = bhCheckWallRefAngle_0x261eb0; // 0x2630f8 - g_ps2RecompiledFunctionTable[363581] = bhCheckWallRefAngle_0x261eb0; // 0x2630fc - g_ps2RecompiledFunctionTable[363582] = bhCheckWallRefAngle_0x261eb0; // 0x263100 - g_ps2RecompiledFunctionTable[363583] = bhCheckWallRefAngle_0x261eb0; // 0x263104 - g_ps2RecompiledFunctionTable[363584] = bhCheckWallRefAngle_0x261eb0; // 0x263108 - g_ps2RecompiledFunctionTable[363585] = bhCheckWallRefAngle_0x261eb0; // 0x26310c - g_ps2RecompiledFunctionTable[363586] = bhCheckWallRefAngle_0x261eb0; // 0x263110 - g_ps2RecompiledFunctionTable[363587] = bhCheckWallRefAngle_0x261eb0; // 0x263114 - g_ps2RecompiledFunctionTable[363588] = bhCheckWallRefAngle_0x261eb0; // 0x263118 - g_ps2RecompiledFunctionTable[363589] = bhCheckWallRefAngle_0x261eb0; // 0x26311c - g_ps2RecompiledFunctionTable[363590] = bhCheckWallRefAngle_0x261eb0; // 0x263120 - g_ps2RecompiledFunctionTable[363591] = bhCheckWallRefAngle_0x261eb0; // 0x263124 - g_ps2RecompiledFunctionTable[363592] = bhCheckWallRefAngle_0x261eb0; // 0x263128 - g_ps2RecompiledFunctionTable[363593] = bhCheckWallRefAngle_0x261eb0; // 0x26312c - g_ps2RecompiledFunctionTable[363594] = bhCheckWallRefAngle_0x261eb0; // 0x263130 - g_ps2RecompiledFunctionTable[363595] = bhCheckWallRefAngle_0x261eb0; // 0x263134 - g_ps2RecompiledFunctionTable[363596] = bhCheckWallRefAngle_0x261eb0; // 0x263138 - g_ps2RecompiledFunctionTable[363597] = bhCheckWallRefAngle_0x261eb0; // 0x26313c - g_ps2RecompiledFunctionTable[363598] = bhCheckWallRefAngle_0x261eb0; // 0x263140 - g_ps2RecompiledFunctionTable[363599] = bhCheckWallRefAngle_0x261eb0; // 0x263144 - g_ps2RecompiledFunctionTable[363600] = bhCheckWallRefAngle_0x261eb0; // 0x263148 - g_ps2RecompiledFunctionTable[363601] = bhCheckWallRefAngle_0x261eb0; // 0x26314c - g_ps2RecompiledFunctionTable[363602] = bhCheckWallRefAngle_0x261eb0; // 0x263150 - g_ps2RecompiledFunctionTable[363603] = bhCheckWallRefAngle_0x261eb0; // 0x263154 - g_ps2RecompiledFunctionTable[363604] = bhCheckWallRefAngle_0x261eb0; // 0x263158 - g_ps2RecompiledFunctionTable[363605] = bhCheckWallRefAngle_0x261eb0; // 0x26315c - g_ps2RecompiledFunctionTable[363606] = bhCheckWallRefAngle_0x261eb0; // 0x263160 - g_ps2RecompiledFunctionTable[363607] = bhCheckWallRefAngle_0x261eb0; // 0x263164 - g_ps2RecompiledFunctionTable[363608] = bhCheckWallRefAngle_0x261eb0; // 0x263168 - g_ps2RecompiledFunctionTable[363609] = bhCheckWallRefAngle_0x261eb0; // 0x26316c - g_ps2RecompiledFunctionTable[363610] = bhCheckWallRefAngle_0x261eb0; // 0x263170 - g_ps2RecompiledFunctionTable[363611] = bhCheckWallRefAngle_0x261eb0; // 0x263174 - g_ps2RecompiledFunctionTable[363612] = bhCheckWallRefAngle_0x261eb0; // 0x263178 - g_ps2RecompiledFunctionTable[363613] = bhCheckWallRefAngle_0x261eb0; // 0x26317c - g_ps2RecompiledFunctionTable[363614] = bhCheckWallRefAngle_0x261eb0; // 0x263180 - g_ps2RecompiledFunctionTable[363615] = bhCheckWallRefAngle_0x261eb0; // 0x263184 - g_ps2RecompiledFunctionTable[363616] = bhCheckWallRefAngle_0x261eb0; // 0x263188 - g_ps2RecompiledFunctionTable[363617] = bhCheckWallRefAngle_0x261eb0; // 0x26318c - g_ps2RecompiledFunctionTable[363618] = bhCheckWallRefAngle_0x261eb0; // 0x263190 - g_ps2RecompiledFunctionTable[363619] = bhCheckWallRefAngle_0x261eb0; // 0x263194 - g_ps2RecompiledFunctionTable[363620] = bhCheckWallRefAngle_0x261eb0; // 0x263198 - g_ps2RecompiledFunctionTable[363621] = bhCheckWallRefAngle_0x261eb0; // 0x26319c - g_ps2RecompiledFunctionTable[363622] = bhCheckWallRefAngle_0x261eb0; // 0x2631a0 - g_ps2RecompiledFunctionTable[363623] = bhCheckWallRefAngle_0x261eb0; // 0x2631a4 - g_ps2RecompiledFunctionTable[363624] = bhCheckWallRefAngle_0x261eb0; // 0x2631a8 - g_ps2RecompiledFunctionTable[363625] = bhCheckWallRefAngle_0x261eb0; // 0x2631ac - g_ps2RecompiledFunctionTable[363626] = bhCheckWallRefAngle_0x261eb0; // 0x2631b0 - g_ps2RecompiledFunctionTable[363627] = bhCheckWallRefAngle_0x261eb0; // 0x2631b4 - g_ps2RecompiledFunctionTable[363628] = bhCheckWallRefAngle_0x261eb0; // 0x2631b8 - g_ps2RecompiledFunctionTable[363629] = bhCheckWallRefAngle_0x261eb0; // 0x2631bc - g_ps2RecompiledFunctionTable[363630] = bhCheckWallRefAngle_0x261eb0; // 0x2631c0 - g_ps2RecompiledFunctionTable[363631] = bhCheckWallRefAngle_0x261eb0; // 0x2631c4 - g_ps2RecompiledFunctionTable[363632] = bhCheckWallRefAngle_0x261eb0; // 0x2631c8 - g_ps2RecompiledFunctionTable[363633] = bhCheckWallRefAngle_0x261eb0; // 0x2631cc - g_ps2RecompiledFunctionTable[363634] = bhCheckWallRefAngle_0x261eb0; // 0x2631d0 - g_ps2RecompiledFunctionTable[363635] = bhCheckWallRefAngle_0x261eb0; // 0x2631d4 - g_ps2RecompiledFunctionTable[363636] = bhCheckWallRefAngle_0x261eb0; // 0x2631d8 - g_ps2RecompiledFunctionTable[363637] = bhCheckWallRefAngle_0x261eb0; // 0x2631dc - g_ps2RecompiledFunctionTable[363638] = bhCheckWallRefAngle_0x261eb0; // 0x2631e0 - g_ps2RecompiledFunctionTable[363639] = bhCheckWallRefAngle_0x261eb0; // 0x2631e4 - g_ps2RecompiledFunctionTable[363640] = bhCheckWallRefAngle_0x261eb0; // 0x2631e8 - g_ps2RecompiledFunctionTable[363641] = bhCheckWallRefAngle_0x261eb0; // 0x2631ec - g_ps2RecompiledFunctionTable[363642] = bhCheckWallRefAngle_0x261eb0; // 0x2631f0 - g_ps2RecompiledFunctionTable[363643] = bhCheckWallRefAngle_0x261eb0; // 0x2631f4 - g_ps2RecompiledFunctionTable[363644] = bhCheckWallRefAngle_0x261eb0; // 0x2631f8 - g_ps2RecompiledFunctionTable[363645] = bhCheckWallRefAngle_0x261eb0; // 0x2631fc - g_ps2RecompiledFunctionTable[363646] = bhCheckWallRefAngle_0x261eb0; // 0x263200 - g_ps2RecompiledFunctionTable[363647] = bhCheckWallRefAngle_0x261eb0; // 0x263204 - g_ps2RecompiledFunctionTable[363648] = bhCheckWallRefAngle_0x261eb0; // 0x263208 - g_ps2RecompiledFunctionTable[363649] = bhCheckWallRefAngle_0x261eb0; // 0x26320c - g_ps2RecompiledFunctionTable[363650] = bhCheckWallRefAngle_0x261eb0; // 0x263210 - g_ps2RecompiledFunctionTable[363651] = bhCheckWallRefAngle_0x261eb0; // 0x263214 - g_ps2RecompiledFunctionTable[363652] = bhCheckWallRefAngle_0x261eb0; // 0x263218 - g_ps2RecompiledFunctionTable[363653] = bhCheckWallRefAngle_0x261eb0; // 0x26321c - g_ps2RecompiledFunctionTable[363654] = bhCheckWallRefAngle_0x261eb0; // 0x263220 - g_ps2RecompiledFunctionTable[363655] = bhCheckWallRefAngle_0x261eb0; // 0x263224 - g_ps2RecompiledFunctionTable[363656] = bhCheckWallRefAngle_0x261eb0; // 0x263228 - g_ps2RecompiledFunctionTable[363657] = bhCheckWallRefAngle_0x261eb0; // 0x26322c - g_ps2RecompiledFunctionTable[363658] = bhCheckWallRefAngle_0x261eb0; // 0x263230 - g_ps2RecompiledFunctionTable[363659] = bhCheckWallRefAngle_0x261eb0; // 0x263234 - g_ps2RecompiledFunctionTable[363660] = bhCheckWallRefAngle_0x261eb0; // 0x263238 - g_ps2RecompiledFunctionTable[363661] = bhCheckWallRefAngle_0x261eb0; // 0x26323c - g_ps2RecompiledFunctionTable[363662] = bhCheckWallRefAngle_0x261eb0; // 0x263240 - g_ps2RecompiledFunctionTable[363663] = bhCheckWallRefAngle_0x261eb0; // 0x263244 - g_ps2RecompiledFunctionTable[363664] = bhCheckWallRefAngle_0x261eb0; // 0x263248 - g_ps2RecompiledFunctionTable[363665] = bhCheckWallRefAngle_0x261eb0; // 0x26324c - g_ps2RecompiledFunctionTable[363666] = bhCheckWallRefAngle_0x261eb0; // 0x263250 - g_ps2RecompiledFunctionTable[363667] = bhCheckWallRefAngle_0x261eb0; // 0x263254 - g_ps2RecompiledFunctionTable[363668] = bhCheckWallRefAngle_0x261eb0; // 0x263258 - g_ps2RecompiledFunctionTable[363669] = bhCheckWallRefAngle_0x261eb0; // 0x26325c - g_ps2RecompiledFunctionTable[363670] = bhCheckWallRefAngle_0x261eb0; // 0x263260 - g_ps2RecompiledFunctionTable[363671] = bhCheckWallRefAngle_0x261eb0; // 0x263264 - g_ps2RecompiledFunctionTable[363672] = bhCheckWallRefAngle_0x261eb0; // 0x263268 - g_ps2RecompiledFunctionTable[363673] = bhCheckWallRefAngle_0x261eb0; // 0x26326c - g_ps2RecompiledFunctionTable[363674] = bhCheckWallRefAngle_0x261eb0; // 0x263270 - g_ps2RecompiledFunctionTable[363675] = bhCheckWallRefAngle_0x261eb0; // 0x263274 - g_ps2RecompiledFunctionTable[363676] = bhCheckWallRefAngle_0x261eb0; // 0x263278 - g_ps2RecompiledFunctionTable[363677] = bhCheckWallRefAngle_0x261eb0; // 0x26327c - g_ps2RecompiledFunctionTable[363678] = bhCheckWallRefAngle_0x261eb0; // 0x263280 - g_ps2RecompiledFunctionTable[363679] = bhCheckWallRefAngle_0x261eb0; // 0x263284 - g_ps2RecompiledFunctionTable[363680] = bhCheckWallRefAngle_0x261eb0; // 0x263288 - g_ps2RecompiledFunctionTable[363681] = bhCheckWallRefAngle_0x261eb0; // 0x26328c - g_ps2RecompiledFunctionTable[363682] = bhCheckWallRefAngle_0x261eb0; // 0x263290 - g_ps2RecompiledFunctionTable[363683] = bhCheckWallRefAngle_0x261eb0; // 0x263294 - g_ps2RecompiledFunctionTable[363684] = bhCheckWallRefAngle_0x261eb0; // 0x263298 - g_ps2RecompiledFunctionTable[363685] = bhCheckWallRefAngle_0x261eb0; // 0x26329c - g_ps2RecompiledFunctionTable[363686] = bhCheckWallRefAngle_0x261eb0; // 0x2632a0 - g_ps2RecompiledFunctionTable[363687] = bhCheckWallRefAngle_0x261eb0; // 0x2632a4 - g_ps2RecompiledFunctionTable[363688] = bhCheckWallRefAngle_0x261eb0; // 0x2632a8 - g_ps2RecompiledFunctionTable[363689] = bhCheckWallRefAngle_0x261eb0; // 0x2632ac - g_ps2RecompiledFunctionTable[363690] = bhCheckWallRefAngle_0x261eb0; // 0x2632b0 - g_ps2RecompiledFunctionTable[363691] = bhCheckWallRefAngle_0x261eb0; // 0x2632b4 - g_ps2RecompiledFunctionTable[363692] = bhCheckWallRefAngle_0x261eb0; // 0x2632b8 - g_ps2RecompiledFunctionTable[363693] = bhCheckWallRefAngle_0x261eb0; // 0x2632bc - g_ps2RecompiledFunctionTable[363694] = bhCheckWallRefAngle_0x261eb0; // 0x2632c0 - g_ps2RecompiledFunctionTable[363695] = bhCheckWallRefAngle_0x261eb0; // 0x2632c4 - g_ps2RecompiledFunctionTable[363696] = bhCheckWallRefAngle_0x261eb0; // 0x2632c8 - g_ps2RecompiledFunctionTable[363697] = bhCheckWallRefAngle_0x261eb0; // 0x2632cc - g_ps2RecompiledFunctionTable[363698] = bhCheckWallRefAngle_0x261eb0; // 0x2632d0 - g_ps2RecompiledFunctionTable[363699] = bhCheckWallRefAngle_0x261eb0; // 0x2632d4 - g_ps2RecompiledFunctionTable[363700] = bhCheckWallRefAngle_0x261eb0; // 0x2632d8 - g_ps2RecompiledFunctionTable[363701] = bhCheckWallRefAngle_0x261eb0; // 0x2632dc - g_ps2RecompiledFunctionTable[363702] = bhSetWallRefAngle_0x2632e0; // 0x2632e0 - g_ps2RecompiledFunctionTable[363769] = bhSetWallRefAngle_0x2632e0; // 0x2633ec - g_ps2RecompiledFunctionTable[363781] = bhSetWallRefAngle_0x2632e0; // 0x26341c - g_ps2RecompiledFunctionTable[363785] = bhSetWallRefAngle_0x2632e0; // 0x26342c - g_ps2RecompiledFunctionTable[363819] = bhSetWallRefAngle_0x2632e0; // 0x2634b4 - g_ps2RecompiledFunctionTable[363824] = bhSetWallRefAngle_0x2632e0; // 0x2634c8 - g_ps2RecompiledFunctionTable[363863] = bhSetWallRefAngle_0x2632e0; // 0x263564 - g_ps2RecompiledFunctionTable[363867] = bhSetWallRefAngle_0x2632e0; // 0x263574 - g_ps2RecompiledFunctionTable[363901] = bhSetWallRefAngle_0x2632e0; // 0x2635fc - g_ps2RecompiledFunctionTable[363906] = bhSetWallRefAngle_0x2632e0; // 0x263610 - g_ps2RecompiledFunctionTable[363946] = bhSetWallRefAngle_0x2632e0; // 0x2636b0 - g_ps2RecompiledFunctionTable[363950] = bhSetWallRefAngle_0x2632e0; // 0x2636c0 - g_ps2RecompiledFunctionTable[363955] = bhSetWallRefAngle_0x2632e0; // 0x2636d4 - g_ps2RecompiledFunctionTable[363963] = bhSetWallRefAngle_0x2632e0; // 0x2636f4 - g_ps2RecompiledFunctionTable[363966] = bhSetWallRefAngle_0x2632e0; // 0x263700 - g_ps2RecompiledFunctionTable[363974] = bhSetWallRefAngle_0x2632e0; // 0x263720 - g_ps2RecompiledFunctionTable[364000] = bhSetWallRefAngle_0x2632e0; // 0x263788 - g_ps2RecompiledFunctionTable[364050] = bhSetWallRefAngle_0x2632e0; // 0x263850 - g_ps2RecompiledFunctionTable[364060] = bhSetWallRefAngle_0x2632e0; // 0x263878 - g_ps2RecompiledFunctionTable[364066] = bhSetWallRefAngle_0x2632e0; // 0x263890 - g_ps2RecompiledFunctionTable[364077] = bhSetWallRefAngle_0x2632e0; // 0x2638bc - g_ps2RecompiledFunctionTable[364082] = bhSetWallRefAngle_0x2632e0; // 0x2638d0 - g_ps2RecompiledFunctionTable[364127] = bhSetWallRefAngle_0x2632e0; // 0x263984 - g_ps2RecompiledFunctionTable[364144] = bhSetWallRefAngle_0x2632e0; // 0x2639c8 - g_ps2RecompiledFunctionTable[364174] = bhSetWallRefAngle_0x2632e0; // 0x263a40 - g_ps2RecompiledFunctionTable[364195] = bhSetWallRefAngle_0x2632e0; // 0x263a94 - g_ps2RecompiledFunctionTable[364223] = bhSetWallRefAngle_0x2632e0; // 0x263b04 - g_ps2RecompiledFunctionTable[364245] = bhSetWallRefAngle_0x2632e0; // 0x263b5c - g_ps2RecompiledFunctionTable[364277] = bhSetWallRefAngle_0x2632e0; // 0x263bdc - g_ps2RecompiledFunctionTable[364303] = bhSetWallRefAngle_0x2632e0; // 0x263c44 - g_ps2RecompiledFunctionTable[364367] = bhSetWallRefAngle_0x2632e0; // 0x263d44 - g_ps2RecompiledFunctionTable[364396] = bhSetWallRefAngle_0x2632e0; // 0x263db8 - g_ps2RecompiledFunctionTable[364400] = bhSetWallRefAngle_0x2632e0; // 0x263dc8 - g_ps2RecompiledFunctionTable[364430] = bhSetWallRefAngle_0x2632e0; // 0x263e40 - g_ps2RecompiledFunctionTable[364435] = bhSetWallRefAngle_0x2632e0; // 0x263e54 - g_ps2RecompiledFunctionTable[364470] = bhSetWallRefAngle_0x2632e0; // 0x263ee0 - g_ps2RecompiledFunctionTable[364474] = bhSetWallRefAngle_0x2632e0; // 0x263ef0 - g_ps2RecompiledFunctionTable[364504] = bhSetWallRefAngle_0x2632e0; // 0x263f68 - g_ps2RecompiledFunctionTable[364509] = bhSetWallRefAngle_0x2632e0; // 0x263f7c - g_ps2RecompiledFunctionTable[364557] = bhSetWallRefAngle_0x2632e0; // 0x26403c - g_ps2RecompiledFunctionTable[364569] = bhSetWallRefAngle_0x2632e0; // 0x26406c - g_ps2RecompiledFunctionTable[364573] = bhSetWallRefAngle_0x2632e0; // 0x26407c - g_ps2RecompiledFunctionTable[364605] = bhSetWallRefAngle_0x2632e0; // 0x2640fc - g_ps2RecompiledFunctionTable[364610] = bhSetWallRefAngle_0x2632e0; // 0x264110 - g_ps2RecompiledFunctionTable[364647] = bhSetWallRefAngle_0x2632e0; // 0x2641a4 - g_ps2RecompiledFunctionTable[364651] = bhSetWallRefAngle_0x2632e0; // 0x2641b4 - g_ps2RecompiledFunctionTable[364683] = bhSetWallRefAngle_0x2632e0; // 0x264234 - g_ps2RecompiledFunctionTable[364688] = bhSetWallRefAngle_0x2632e0; // 0x264248 - g_ps2RecompiledFunctionTable[364738] = bhGetGroundPosition_0x264310; // 0x264310 - g_ps2RecompiledFunctionTable[364774] = bhGetGroundPosition_0x264310; // 0x2643a0 - g_ps2RecompiledFunctionTable[364882] = bhGetGroundPosition_0x264310; // 0x264550 - g_ps2RecompiledFunctionTable[364919] = bhGetGroundPosition_0x264310; // 0x2645e4 - g_ps2RecompiledFunctionTable[365102] = bhCheckInnerTriangle_0x2648c0; // 0x2648c0 - g_ps2RecompiledFunctionTable[365205] = bhCheckInnerTriangle_0x2648c0; // 0x264a5c - g_ps2RecompiledFunctionTable[365212] = bhCheckInnerTriangle_0x2648c0; // 0x264a78 - g_ps2RecompiledFunctionTable[365265] = bhCheckInnerTriangle_0x2648c0; // 0x264b4c - g_ps2RecompiledFunctionTable[365314] = bhCheckInnerTriangle_0x2648c0; // 0x264c10 - g_ps2RecompiledFunctionTable[365359] = bhCheckInnerTriangle_0x2648c0; // 0x264cc4 - g_ps2RecompiledFunctionTable[365408] = bhCheckInnerTriangle_0x2648c0; // 0x264d88 - g_ps2RecompiledFunctionTable[365435] = bhCheckInnerTriangle_0x2648c0; // 0x264df4 - g_ps2RecompiledFunctionTable[365440] = bhCheckInnerTriangle_0x2648c0; // 0x264e08 - g_ps2RecompiledFunctionTable[365458] = bhCheckInnerTriangle2_0x264e50; // 0x264e50 - g_ps2RecompiledFunctionTable[365567] = bhCheckInnerTriangle2_0x264e50; // 0x265004 - g_ps2RecompiledFunctionTable[365574] = bhCheckInnerTriangle2_0x264e50; // 0x265020 - g_ps2RecompiledFunctionTable[365627] = bhCheckInnerTriangle2_0x264e50; // 0x2650f4 - g_ps2RecompiledFunctionTable[365676] = bhCheckInnerTriangle2_0x264e50; // 0x2651b8 - g_ps2RecompiledFunctionTable[365721] = bhCheckInnerTriangle2_0x264e50; // 0x26526c - g_ps2RecompiledFunctionTable[365770] = bhCheckInnerTriangle2_0x264e50; // 0x265330 - g_ps2RecompiledFunctionTable[365797] = bhCheckInnerTriangle2_0x264e50; // 0x26539c - g_ps2RecompiledFunctionTable[365802] = bhCheckInnerTriangle2_0x264e50; // 0x2653b0 - g_ps2RecompiledFunctionTable[365822] = bhCheckInnerTriangle3_0x265400; // 0x265400 - g_ps2RecompiledFunctionTable[365909] = bhCheckInnerTriangle3_0x265400; // 0x26555c - g_ps2RecompiledFunctionTable[365916] = bhCheckInnerTriangle3_0x265400; // 0x265578 - g_ps2RecompiledFunctionTable[365930] = bhCheckBox_0x2655b0; // 0x2655b0 - g_ps2RecompiledFunctionTable[366016] = bhCheckBox_0x2655b0; // 0x265708 - g_ps2RecompiledFunctionTable[366020] = bhCheckBox_0x2655b0; // 0x265718 - g_ps2RecompiledFunctionTable[366040] = bhCheckBox_0x2655b0; // 0x265768 - g_ps2RecompiledFunctionTable[366047] = bhCheckBox_0x2655b0; // 0x265784 - g_ps2RecompiledFunctionTable[366052] = bhCheckBox_0x2655b0; // 0x265798 - g_ps2RecompiledFunctionTable[366056] = bhCheckBox_0x2655b0; // 0x2657a8 - g_ps2RecompiledFunctionTable[366082] = bhCheckBox_0x2655b0; // 0x265810 - g_ps2RecompiledFunctionTable[366087] = bhCheckBox_0x2655b0; // 0x265824 - g_ps2RecompiledFunctionTable[366109] = bhCheckBox_0x2655b0; // 0x26587c - g_ps2RecompiledFunctionTable[366116] = bhCheckBox_0x2655b0; // 0x265898 - g_ps2RecompiledFunctionTable[366121] = bhCheckBox_0x2655b0; // 0x2658ac - g_ps2RecompiledFunctionTable[366125] = bhCheckBox_0x2655b0; // 0x2658bc - g_ps2RecompiledFunctionTable[366157] = bhCheckBox_0x2655b0; // 0x26593c - g_ps2RecompiledFunctionTable[366161] = bhCheckBox_0x2655b0; // 0x26594c - g_ps2RecompiledFunctionTable[366183] = bhCheckBox_0x2655b0; // 0x2659a4 - g_ps2RecompiledFunctionTable[366190] = bhCheckBox_0x2655b0; // 0x2659c0 - g_ps2RecompiledFunctionTable[366195] = bhCheckBox_0x2655b0; // 0x2659d4 - g_ps2RecompiledFunctionTable[366199] = bhCheckBox_0x2655b0; // 0x2659e4 - g_ps2RecompiledFunctionTable[366227] = bhCheckBox_0x2655b0; // 0x265a54 - g_ps2RecompiledFunctionTable[366232] = bhCheckBox_0x2655b0; // 0x265a68 - g_ps2RecompiledFunctionTable[366256] = bhCheckBox_0x2655b0; // 0x265ac8 - g_ps2RecompiledFunctionTable[366263] = bhCheckBox_0x2655b0; // 0x265ae4 - g_ps2RecompiledFunctionTable[366268] = bhCheckBox_0x2655b0; // 0x265af8 - g_ps2RecompiledFunctionTable[366272] = bhCheckBox_0x2655b0; // 0x265b08 - g_ps2RecompiledFunctionTable[366310] = bhCheckBox2Box_0x265ba0; // 0x265ba0 - g_ps2RecompiledFunctionTable[366391] = bhCheckBox2Box_0x265ba0; // 0x265ce4 - g_ps2RecompiledFunctionTable[366395] = bhCheckBox2Box_0x265ba0; // 0x265cf4 - g_ps2RecompiledFunctionTable[366406] = bhCheckBox2Box_0x265ba0; // 0x265d20 - g_ps2RecompiledFunctionTable[366411] = bhCheckBox2Box_0x265ba0; // 0x265d34 - g_ps2RecompiledFunctionTable[366427] = bhCheckBox2Box_0x265ba0; // 0x265d74 - g_ps2RecompiledFunctionTable[366431] = bhCheckBox2Box_0x265ba0; // 0x265d84 - g_ps2RecompiledFunctionTable[366443] = bhCheckBox2Box_0x265ba0; // 0x265db4 - g_ps2RecompiledFunctionTable[366448] = bhCheckBox2Box_0x265ba0; // 0x265dc8 - g_ps2RecompiledFunctionTable[366466] = bhCheckInnerP4_0x265e10; // 0x265e10 - g_ps2RecompiledFunctionTable[366746] = bhCheckExmAtari_0x266270; // 0x266270 - g_ps2RecompiledFunctionTable[366756] = bhCheckExmAtari_0x266270; // 0x266298 - g_ps2RecompiledFunctionTable[366830] = bhCheckExmAtari_0x266270; // 0x2663c0 - g_ps2RecompiledFunctionTable[367021] = bhCheckExmAtari_0x266270; // 0x2666bc - g_ps2RecompiledFunctionTable[367091] = bhCheckExmAtari_0x266270; // 0x2667d4 - g_ps2RecompiledFunctionTable[367110] = bhCheckExmAtari_0x266270; // 0x266820 - g_ps2RecompiledFunctionTable[367160] = bhCheckExmAtari_0x266270; // 0x2668e8 - g_ps2RecompiledFunctionTable[367190] = bhCheckExmAtari_0x266270; // 0x266960 - g_ps2RecompiledFunctionTable[367380] = bhCheckExmAtari_0x266270; // 0x266c58 - g_ps2RecompiledFunctionTable[367625] = bhCheckExmAtari_0x266270; // 0x26702c - g_ps2RecompiledFunctionTable[367655] = bhCheckExmAtari_0x266270; // 0x2670a4 - g_ps2RecompiledFunctionTable[367694] = bhSetUseKaidanFlag_0x267140; // 0x267140 - g_ps2RecompiledFunctionTable[367750] = bhClrUseKaidanFlag_0x267220; // 0x267220 - g_ps2RecompiledFunctionTable[367810] = bhSetDansaLimitAtari_0x267310; // 0x267310 - g_ps2RecompiledFunctionTable[367853] = bhSetDansaLimitAtari_0x267310; // 0x2673bc - g_ps2RecompiledFunctionTable[367925] = bhSetDansaLimitAtari_0x267310; // 0x2674dc - g_ps2RecompiledFunctionTable[367990] = bhSetDansaLimitAtari_0x267310; // 0x2675e0 - g_ps2RecompiledFunctionTable[368056] = bhSetDansaLimitAtari_0x267310; // 0x2676e8 - g_ps2RecompiledFunctionTable[368122] = bhSetDansaLimitAtari_0x267310; // 0x2677f0 - g_ps2RecompiledFunctionTable[368198] = bhCheckDansaAtari_0x267920; // 0x267920 - g_ps2RecompiledFunctionTable[368212] = bhCheckDansaAtari_0x267920; // 0x267958 - g_ps2RecompiledFunctionTable[368274] = bhCheckFloorP_0x267a50; // 0x267a50 - g_ps2RecompiledFunctionTable[368288] = bhCheckFloorP_0x267a50; // 0x267a88 - g_ps2RecompiledFunctionTable[368339] = bhCheckFloorP_0x267a50; // 0x267b54 - g_ps2RecompiledFunctionTable[368593] = bhCheckFloorP_0x267a50; // 0x267f4c - g_ps2RecompiledFunctionTable[368605] = bhCheckFloorP_0x267a50; // 0x267f7c - g_ps2RecompiledFunctionTable[368617] = bhCheckFloorP_0x267a50; // 0x267fac - g_ps2RecompiledFunctionTable[368629] = bhCheckFloorP_0x267a50; // 0x267fdc - g_ps2RecompiledFunctionTable[368641] = bhCheckFloorP_0x267a50; // 0x26800c - g_ps2RecompiledFunctionTable[368654] = bhCheckDansa_0x268040; // 0x268040 - g_ps2RecompiledFunctionTable[368676] = bhCheckDansa_0x268040; // 0x268098 - g_ps2RecompiledFunctionTable[368746] = bhCheckFloorSound_0x2681b0; // 0x2681b0 - g_ps2RecompiledFunctionTable[368761] = bhCheckFloorSound_0x2681b0; // 0x2681ec - g_ps2RecompiledFunctionTable[368830] = bhCheckFloorEnemy_0x268300; // 0x268300 - g_ps2RecompiledFunctionTable[368844] = bhCheckFloorEnemy_0x268300; // 0x268338 - g_ps2RecompiledFunctionTable[368902] = bhCheckFloorEffect_0x268420; // 0x268420 - g_ps2RecompiledFunctionTable[368916] = bhCheckFloorEffect_0x268420; // 0x268458 - g_ps2RecompiledFunctionTable[368974] = bhCheckWater_0x268540; // 0x268540 - g_ps2RecompiledFunctionTable[368989] = bhCheckWater_0x268540; // 0x26857c - g_ps2RecompiledFunctionTable[369062] = bhCheckL2Water_0x2686a0; // 0x2686a0 - g_ps2RecompiledFunctionTable[369077] = bhCheckL2Water_0x2686a0; // 0x2686dc - g_ps2RecompiledFunctionTable[369091] = bhCheckL2Water_0x2686a0; // 0x268714 - g_ps2RecompiledFunctionTable[369138] = bhCheckL2Water_0x2686a0; // 0x2687d0 - g_ps2RecompiledFunctionTable[369161] = bhCheckL2Water_0x2686a0; // 0x26882c - g_ps2RecompiledFunctionTable[369201] = bhCheckL2Water_0x2686a0; // 0x2688cc - g_ps2RecompiledFunctionTable[369234] = bhResetAtariAttr_0x268950; // 0x268950 - g_ps2RecompiledFunctionTable[369253] = bhResetAtariAttr_0x268950; // 0x26899c - g_ps2RecompiledFunctionTable[369299] = bhResetAtariAttr_0x268950; // 0x268a54 - g_ps2RecompiledFunctionTable[369310] = bhResetAtariAttr_0x268950; // 0x268a80 - g_ps2RecompiledFunctionTable[369333] = bhResetAtariAttr_0x268950; // 0x268adc - g_ps2RecompiledFunctionTable[369365] = bhResetAtariAttr_0x268950; // 0x268b5c - g_ps2RecompiledFunctionTable[369376] = bhResetAtariAttr_0x268950; // 0x268b88 - g_ps2RecompiledFunctionTable[369399] = bhResetAtariAttr_0x268950; // 0x268be4 - g_ps2RecompiledFunctionTable[369431] = bhResetAtariAttr_0x268950; // 0x268c64 - g_ps2RecompiledFunctionTable[369442] = bhResetAtariAttr_0x268950; // 0x268c90 - g_ps2RecompiledFunctionTable[369462] = bhCheckPlayer_0x268ce0; // 0x268ce0 - g_ps2RecompiledFunctionTable[369528] = bhCheckPlayer_0x268ce0; // 0x268de8 - g_ps2RecompiledFunctionTable[369559] = bhCheckPlayer_0x268ce0; // 0x268e64 - g_ps2RecompiledFunctionTable[369564] = bhCheckPlayer_0x268ce0; // 0x268e78 - g_ps2RecompiledFunctionTable[369573] = bhCheckPlayer_0x268ce0; // 0x268e9c - g_ps2RecompiledFunctionTable[369595] = bhCheckPlayer_0x268ce0; // 0x268ef4 - g_ps2RecompiledFunctionTable[369642] = bhCheckEnemies_0x268fb0; // 0x268fb0 - g_ps2RecompiledFunctionTable[369679] = bhCheckEnemies_0x268fb0; // 0x269044 - g_ps2RecompiledFunctionTable[369728] = bhCheckEnemies_0x268fb0; // 0x269108 - g_ps2RecompiledFunctionTable[369750] = bhCheckEnemies_0x268fb0; // 0x269160 - g_ps2RecompiledFunctionTable[369755] = bhCheckEnemies_0x268fb0; // 0x269174 - g_ps2RecompiledFunctionTable[369762] = bhCheckEnemies_0x268fb0; // 0x269190 - g_ps2RecompiledFunctionTable[369806] = bhCheckEnemies_0x268fb0; // 0x269240 - g_ps2RecompiledFunctionTable[369846] = bhCheckWallAttrB89_0x2692e0; // 0x2692e0 - g_ps2RecompiledFunctionTable[369868] = bhCheckWallAttrB89_0x2692e0; // 0x269338 - g_ps2RecompiledFunctionTable[369882] = bhCollisionCheckLine_0x269370; // 0x269370 - g_ps2RecompiledFunctionTable[369919] = bhCollisionCheckLine_0x269370; // 0x269404 - g_ps2RecompiledFunctionTable[369947] = bhCollisionCheckLine_0x269370; // 0x269474 - g_ps2RecompiledFunctionTable[369966] = bhCollisionCheckLine2_0x2694c0; // 0x2694c0 - g_ps2RecompiledFunctionTable[370009] = bhCollisionCheckLine2_0x2694c0; // 0x26956c - g_ps2RecompiledFunctionTable[370061] = bhCollisionCheckLine2_0x2694c0; // 0x26963c - g_ps2RecompiledFunctionTable[370082] = bhCollisionCheckLine3_0x269690; // 0x269690 - g_ps2RecompiledFunctionTable[370125] = bhCollisionCheckLine3_0x269690; // 0x26973c - g_ps2RecompiledFunctionTable[370181] = bhCollisionCheckLine3_0x269690; // 0x26981c - g_ps2RecompiledFunctionTable[370202] = bhCollisionCheckLineMain_0x269870; // 0x269870 - g_ps2RecompiledFunctionTable[370318] = bhCollisionCheckLineMain_0x269870; // 0x269a40 - g_ps2RecompiledFunctionTable[370355] = bhCollisionCheckLineMain_0x269870; // 0x269ad4 - g_ps2RecompiledFunctionTable[370390] = bhCollisionCheckLineMain_0x269870; // 0x269b60 - g_ps2RecompiledFunctionTable[370430] = bhCollisionCheckLineMain_0x269870; // 0x269c00 - g_ps2RecompiledFunctionTable[370469] = bhCollisionCheckLineMain_0x269870; // 0x269c9c - g_ps2RecompiledFunctionTable[370507] = bhCollisionCheckLineMain_0x269870; // 0x269d34 - g_ps2RecompiledFunctionTable[370590] = bhCollisionCheckLineMain_0x269870; // 0x269e80 - g_ps2RecompiledFunctionTable[370628] = bhCollisionCheckLineMain_0x269870; // 0x269f18 - g_ps2RecompiledFunctionTable[370672] = bhCollisionCheckLineMain_0x269870; // 0x269fc8 - g_ps2RecompiledFunctionTable[370715] = bhCollisionCheckLineMain_0x269870; // 0x26a074 - g_ps2RecompiledFunctionTable[370763] = bhCollisionCheckLineMain_0x269870; // 0x26a134 - g_ps2RecompiledFunctionTable[370810] = bhCollisionCheckLineMain_0x269870; // 0x26a1f0 - g_ps2RecompiledFunctionTable[370888] = bhCollisionCheckLineMain_0x269870; // 0x26a328 - g_ps2RecompiledFunctionTable[370907] = bhCollisionCheckLineMain_0x269870; // 0x26a374 - g_ps2RecompiledFunctionTable[370909] = bhCollisionCheckLineMain_0x269870; // 0x26a37c - g_ps2RecompiledFunctionTable[370918] = bhCollisionCheckLineMain_0x269870; // 0x26a3a0 - g_ps2RecompiledFunctionTable[370920] = bhCollisionCheckLineMain_0x269870; // 0x26a3a8 - g_ps2RecompiledFunctionTable[370931] = bhCollisionCheckLineMain_0x269870; // 0x26a3d4 - g_ps2RecompiledFunctionTable[370948] = bhCollisionCheckLineMain_0x269870; // 0x26a418 - g_ps2RecompiledFunctionTable[370959] = bhCollisionCheckLineMain_0x269870; // 0x26a444 - g_ps2RecompiledFunctionTable[370961] = bhCollisionCheckLineMain_0x269870; // 0x26a44c - g_ps2RecompiledFunctionTable[370971] = bhCollisionCheckLineMain_0x269870; // 0x26a474 - g_ps2RecompiledFunctionTable[370973] = bhCollisionCheckLineMain_0x269870; // 0x26a47c - g_ps2RecompiledFunctionTable[370983] = bhCollisionCheckLineMain_0x269870; // 0x26a4a4 - g_ps2RecompiledFunctionTable[371143] = bhCollisionCheckLineMain_0x269870; // 0x26a724 - g_ps2RecompiledFunctionTable[371194] = bhCollisionCheckLineMain_0x269870; // 0x26a7f0 - g_ps2RecompiledFunctionTable[371240] = bhCollisionCheckLineMain_0x269870; // 0x26a8a8 - g_ps2RecompiledFunctionTable[371290] = bhCollisionCheckLineMain_0x269870; // 0x26a970 - g_ps2RecompiledFunctionTable[371331] = bhCollisionCheckLineMain_0x269870; // 0x26aa14 - g_ps2RecompiledFunctionTable[371382] = bhCollisionCheckLineMain_0x269870; // 0x26aae0 - g_ps2RecompiledFunctionTable[371428] = bhCollisionCheckLineMain_0x269870; // 0x26ab98 - g_ps2RecompiledFunctionTable[371478] = bhCollisionCheckLineMain_0x269870; // 0x26ac60 - g_ps2RecompiledFunctionTable[371599] = bhCollisionCheckLineMain_0x269870; // 0x26ae44 - g_ps2RecompiledFunctionTable[371618] = bhCollisionCheckL2PL_0x26ae90; // 0x26ae90 - g_ps2RecompiledFunctionTable[371658] = bhCollisionCheckL2PL_0x26ae90; // 0x26af30 - g_ps2RecompiledFunctionTable[371663] = bhCollisionCheckL2PL_0x26ae90; // 0x26af44 - g_ps2RecompiledFunctionTable[371672] = bhCollisionCheckL2PL_0x26ae90; // 0x26af68 - g_ps2RecompiledFunctionTable[371682] = bhCollisionCheckL2PL_0x26ae90; // 0x26af90 - g_ps2RecompiledFunctionTable[371706] = bhCollisionCheckL2PL_0x26ae90; // 0x26aff0 - g_ps2RecompiledFunctionTable[371715] = bhCollisionCheckL2PL_0x26ae90; // 0x26b014 - g_ps2RecompiledFunctionTable[371724] = bhCollisionCheckL2PL_0x26ae90; // 0x26b038 - g_ps2RecompiledFunctionTable[371754] = bhInOutCheck_0x26b0b0; // 0x26b0b0 - g_ps2RecompiledFunctionTable[371778] = bhInOutCheck_0x26b0b0; // 0x26b110 - g_ps2RecompiledFunctionTable[371789] = bhInOutCheck_0x26b0b0; // 0x26b13c - g_ps2RecompiledFunctionTable[371838] = bhCollisionCheckL2MDL_0x26b200; // 0x26b200 - g_ps2RecompiledFunctionTable[371856] = bhCollisionCheckL2MDL_0x26b200; // 0x26b248 - g_ps2RecompiledFunctionTable[371878] = bhCollisionCheckL2MDL_0x26b200; // 0x26b2a0 - g_ps2RecompiledFunctionTable[371904] = bhCollisionCheckL2MDL_0x26b200; // 0x26b308 - g_ps2RecompiledFunctionTable[371909] = bhCollisionCheckL2MDL_0x26b200; // 0x26b31c - g_ps2RecompiledFunctionTable[371910] = bhCollisionCheckL2MDL_0x26b200; // 0x26b320 - g_ps2RecompiledFunctionTable[371931] = bhCollisionCheckL2MDL_0x26b200; // 0x26b374 - g_ps2RecompiledFunctionTable[371950] = bhCollisionCheckL2XZPL_0x26b3c0; // 0x26b3c0 - g_ps2RecompiledFunctionTable[372000] = bhCollisionCheckL2XZPL_0x26b3c0; // 0x26b488 - g_ps2RecompiledFunctionTable[372054] = bhCollisionCheckL2XYPL_0x26b560; // 0x26b560 - g_ps2RecompiledFunctionTable[372104] = bhCollisionCheckL2XYPL_0x26b560; // 0x26b628 - g_ps2RecompiledFunctionTable[372158] = bhCollisionCheckL2YZPL_0x26b700; // 0x26b700 - g_ps2RecompiledFunctionTable[372208] = bhCollisionCheckL2YZPL_0x26b700; // 0x26b7c8 - g_ps2RecompiledFunctionTable[372262] = bhGetHitCollisionNormal_0x26b8a0; // 0x26b8a0 - g_ps2RecompiledFunctionTable[372274] = bhCheckRoute_0x26b8d0; // 0x26b8d0 - g_ps2RecompiledFunctionTable[372282] = bhCheckRoute_0x26b8d0; // 0x26b8f0 - g_ps2RecompiledFunctionTable[372291] = bhCheckRoute_0x26b8d0; // 0x26b914 - g_ps2RecompiledFunctionTable[372346] = bhCheckRouteID_0x26b9f0; // 0x26b9f0 - g_ps2RecompiledFunctionTable[372352] = bhCheckRouteID_0x26b9f0; // 0x26ba08 - g_ps2RecompiledFunctionTable[372398] = bhSetScreenFade_0x26bac0; // 0x26bac0 - g_ps2RecompiledFunctionTable[372417] = bhSetScreenFade_0x26bac0; // 0x26bb0c - g_ps2RecompiledFunctionTable[372422] = bhSetScreenFade_0x26bac0; // 0x26bb20 - g_ps2RecompiledFunctionTable[372428] = bhSetScreenFade_0x26bac0; // 0x26bb38 - g_ps2RecompiledFunctionTable[372434] = bhSetScreenFade_0x26bac0; // 0x26bb50 - g_ps2RecompiledFunctionTable[372570] = bhControlScreenFade_0x26bd70; // 0x26bd70 - g_ps2RecompiledFunctionTable[372762] = bhDrawScreenFade_0x26c070; // 0x26c070 - g_ps2RecompiledFunctionTable[372770] = bhDrawScreenFade_0x26c070; // 0x26c090 - g_ps2RecompiledFunctionTable[372773] = bhDrawScreenFade_0x26c070; // 0x26c09c - g_ps2RecompiledFunctionTable[372787] = bhDrawScreenFade_0x26c070; // 0x26c0d4 - g_ps2RecompiledFunctionTable[372792] = bhDrawScreenFade_0x26c070; // 0x26c0e8 - g_ps2RecompiledFunctionTable[372798] = bhDrawScreenFade_0x26c070; // 0x26c100 - g_ps2RecompiledFunctionTable[372804] = bhDrawScreenFade_0x26c070; // 0x26c118 - g_ps2RecompiledFunctionTable[372830] = bhDrawScreenFade_0x26c070; // 0x26c180 - g_ps2RecompiledFunctionTable[372833] = bhDrawScreenFade_0x26c070; // 0x26c18c - g_ps2RecompiledFunctionTable[372836] = bhDrawScreenFade_0x26c070; // 0x26c198 - g_ps2RecompiledFunctionTable[372842] = bhInitScreenSaver_0x26c1b0; // 0x26c1b0 - g_ps2RecompiledFunctionTable[372882] = bhSetScreenSaver_0x26c250; // 0x26c250 - g_ps2RecompiledFunctionTable[372926] = bhControlScreenSaver_0x26c300; // 0x26c300 - g_ps2RecompiledFunctionTable[372986] = bhDrawScreenSaver_0x26c3f0; // 0x26c3f0 - g_ps2RecompiledFunctionTable[372991] = bhDrawScreenSaver_0x26c3f0; // 0x26c404 - g_ps2RecompiledFunctionTable[372994] = bhDrawScreenSaver_0x26c3f0; // 0x26c410 - g_ps2RecompiledFunctionTable[373000] = bhDrawScreenSaver_0x26c3f0; // 0x26c428 - g_ps2RecompiledFunctionTable[373024] = bhDrawScreenSaver_0x26c3f0; // 0x26c488 - g_ps2RecompiledFunctionTable[373027] = bhDrawScreenSaver_0x26c3f0; // 0x26c494 - g_ps2RecompiledFunctionTable[373030] = bhDrawScreenSaver_0x26c3f0; // 0x26c4a0 - g_ps2RecompiledFunctionTable[373034] = bhControlCinesco_0x26c4b0; // 0x26c4b0 - g_ps2RecompiledFunctionTable[373090] = bhDrawCinesco_0x26c590; // 0x26c590 - g_ps2RecompiledFunctionTable[373106] = bhDrawCinesco_0x26c590; // 0x26c5d0 - g_ps2RecompiledFunctionTable[373109] = bhDrawCinesco_0x26c590; // 0x26c5dc - g_ps2RecompiledFunctionTable[373126] = bhDrawCinesco_0x26c590; // 0x26c620 - g_ps2RecompiledFunctionTable[373156] = bhDrawCinesco_0x26c590; // 0x26c698 - g_ps2RecompiledFunctionTable[373169] = bhDrawCinesco_0x26c590; // 0x26c6cc - g_ps2RecompiledFunctionTable[373172] = bhDrawCinesco_0x26c590; // 0x26c6d8 - g_ps2RecompiledFunctionTable[373175] = bhDrawCinesco_0x26c590; // 0x26c6e4 - g_ps2RecompiledFunctionTable[373186] = bhDrawScope_0x26c710; // 0x26c710 - g_ps2RecompiledFunctionTable[373208] = bhDrawScope_0x26c710; // 0x26c768 - g_ps2RecompiledFunctionTable[373211] = bhDrawScope_0x26c710; // 0x26c774 - g_ps2RecompiledFunctionTable[373219] = bhDrawScope_0x26c710; // 0x26c794 - g_ps2RecompiledFunctionTable[373221] = bhDrawScope_0x26c710; // 0x26c79c - g_ps2RecompiledFunctionTable[373274] = bhDrawScope_0x26c710; // 0x26c870 - g_ps2RecompiledFunctionTable[373317] = bhDrawScope_0x26c710; // 0x26c91c - g_ps2RecompiledFunctionTable[373337] = bhDrawScope_0x26c710; // 0x26c96c - g_ps2RecompiledFunctionTable[373344] = bhDrawScope_0x26c710; // 0x26c988 - g_ps2RecompiledFunctionTable[373346] = bhDrawScope_0x26c710; // 0x26c990 - g_ps2RecompiledFunctionTable[373354] = bhDrawScope_0x26c710; // 0x26c9b0 - g_ps2RecompiledFunctionTable[373375] = bhDrawScope_0x26c710; // 0x26ca04 - g_ps2RecompiledFunctionTable[373394] = bhDrawScope_0x26c710; // 0x26ca50 - g_ps2RecompiledFunctionTable[373413] = bhDrawScope_0x26c710; // 0x26ca9c - g_ps2RecompiledFunctionTable[373431] = bhDrawScope_0x26c710; // 0x26cae4 - g_ps2RecompiledFunctionTable[373434] = bhDrawScope_0x26c710; // 0x26caf0 - g_ps2RecompiledFunctionTable[373458] = bhDrawScope_0x26c710; // 0x26cb50 - g_ps2RecompiledFunctionTable[373466] = bhDrawScope_0x26c710; // 0x26cb70 - g_ps2RecompiledFunctionTable[373468] = bhDrawScope_0x26c710; // 0x26cb78 - g_ps2RecompiledFunctionTable[373475] = bhDrawScope_0x26c710; // 0x26cb94 - g_ps2RecompiledFunctionTable[373495] = bhDrawScope_0x26c710; // 0x26cbe4 - g_ps2RecompiledFunctionTable[373514] = bhDrawScope_0x26c710; // 0x26cc30 - g_ps2RecompiledFunctionTable[373533] = bhDrawScope_0x26c710; // 0x26cc7c - g_ps2RecompiledFunctionTable[373551] = bhDrawScope_0x26c710; // 0x26ccc4 - g_ps2RecompiledFunctionTable[373554] = bhDrawScope_0x26c710; // 0x26ccd0 - g_ps2RecompiledFunctionTable[373565] = bhDrawScope_0x26c710; // 0x26ccfc - g_ps2RecompiledFunctionTable[373593] = bhDrawScope_0x26c710; // 0x26cd6c - g_ps2RecompiledFunctionTable[373597] = bhDrawScope_0x26c710; // 0x26cd7c - g_ps2RecompiledFunctionTable[373609] = bhDrawScope_0x26c710; // 0x26cdac - g_ps2RecompiledFunctionTable[373617] = bhDrawScope_0x26c710; // 0x26cdcc - g_ps2RecompiledFunctionTable[373624] = bhDrawScope_0x26c710; // 0x26cde8 - g_ps2RecompiledFunctionTable[373632] = bhDrawScope_0x26c710; // 0x26ce08 - g_ps2RecompiledFunctionTable[373635] = bhDrawScope_0x26c710; // 0x26ce14 - g_ps2RecompiledFunctionTable[373638] = bhDrawScope_0x26c710; // 0x26ce20 - g_ps2RecompiledFunctionTable[373654] = bhDrawScopeNumber_0x26ce60; // 0x26ce60 - g_ps2RecompiledFunctionTable[373734] = bhDrawScopeNumber_0x26ce60; // 0x26cfa0 - g_ps2RecompiledFunctionTable[373738] = bhDrawThermometer_0x26cfb0; // 0x26cfb0 - g_ps2RecompiledFunctionTable[373753] = bhDrawThermometer_0x26cfb0; // 0x26cfec - g_ps2RecompiledFunctionTable[373756] = bhDrawThermometer_0x26cfb0; // 0x26cff8 - g_ps2RecompiledFunctionTable[373762] = bhDrawThermometer_0x26cfb0; // 0x26d010 - g_ps2RecompiledFunctionTable[373768] = bhDrawThermometer_0x26cfb0; // 0x26d028 - g_ps2RecompiledFunctionTable[373828] = bhDrawThermometer_0x26cfb0; // 0x26d118 - g_ps2RecompiledFunctionTable[373839] = bhDrawThermometer_0x26cfb0; // 0x26d144 - g_ps2RecompiledFunctionTable[373843] = bhDrawThermometer_0x26cfb0; // 0x26d154 - g_ps2RecompiledFunctionTable[373897] = bhDrawThermometer_0x26cfb0; // 0x26d22c - g_ps2RecompiledFunctionTable[374003] = bhDrawThermometer_0x26cfb0; // 0x26d3d4 - g_ps2RecompiledFunctionTable[374024] = bhDrawThermometer_0x26cfb0; // 0x26d428 - g_ps2RecompiledFunctionTable[374045] = bhDrawThermometer_0x26cfb0; // 0x26d47c - g_ps2RecompiledFunctionTable[374066] = bhDrawThermometer_0x26cfb0; // 0x26d4d0 - g_ps2RecompiledFunctionTable[374069] = bhDrawThermometer_0x26cfb0; // 0x26d4dc - g_ps2RecompiledFunctionTable[374072] = bhDrawThermometer_0x26cfb0; // 0x26d4e8 - g_ps2RecompiledFunctionTable[374086] = bhDrawThermoNumber_0x26d520; // 0x26d520 - g_ps2RecompiledFunctionTable[374167] = bhDrawThermoNumber_0x26d520; // 0x26d664 - g_ps2RecompiledFunctionTable[374170] = bhDrawFullScreenRenderTexture_0x26d670; // 0x26d670 - g_ps2RecompiledFunctionTable[374183] = bhDrawFullScreenRenderTexture_0x26d670; // 0x26d6a4 - g_ps2RecompiledFunctionTable[374186] = bhDrawFullScreenRenderTexture_0x26d670; // 0x26d6b0 - g_ps2RecompiledFunctionTable[374207] = bhDrawFullScreenRenderTexture_0x26d670; // 0x26d704 - g_ps2RecompiledFunctionTable[374209] = bhDrawFullScreenRenderTexture_0x26d670; // 0x26d70c - g_ps2RecompiledFunctionTable[374211] = bhDrawFullScreenRenderTexture_0x26d670; // 0x26d714 - g_ps2RecompiledFunctionTable[374213] = bhDrawFullScreenRenderTexture_0x26d670; // 0x26d71c - g_ps2RecompiledFunctionTable[374215] = bhDrawFullScreenRenderTexture_0x26d670; // 0x26d724 - g_ps2RecompiledFunctionTable[374221] = bhDrawFullScreenRenderTexture_0x26d670; // 0x26d73c - g_ps2RecompiledFunctionTable[374231] = bhDrawFullScreenRenderTexture_0x26d670; // 0x26d764 - g_ps2RecompiledFunctionTable[374233] = bhDrawFullScreenRenderTexture_0x26d670; // 0x26d76c - g_ps2RecompiledFunctionTable[374235] = bhDrawFullScreenRenderTexture_0x26d670; // 0x26d774 - g_ps2RecompiledFunctionTable[374237] = bhDrawFullScreenRenderTexture_0x26d670; // 0x26d77c - g_ps2RecompiledFunctionTable[374239] = bhDrawFullScreenRenderTexture_0x26d670; // 0x26d784 - g_ps2RecompiledFunctionTable[374992] = bhDrawFullScreenRenderTexture_0x26d670; // 0x26e348 - g_ps2RecompiledFunctionTable[375001] = bhDrawFullScreenRenderTexture_0x26d670; // 0x26e36c - g_ps2RecompiledFunctionTable[375014] = bhDrawSmallScreenRenderTexture_0x26e3a0; // 0x26e3a0 - g_ps2RecompiledFunctionTable[375063] = bhDrawSmallScreenRenderTexture_0x26e3a0; // 0x26e464 - g_ps2RecompiledFunctionTable[375078] = bhDrawSmallScreenRenderTexture_0x26e3a0; // 0x26e4a0 - g_ps2RecompiledFunctionTable[375083] = bhDrawSmallScreenRenderTexture_0x26e3a0; // 0x26e4b4 - g_ps2RecompiledFunctionTable[375088] = bhDrawSmallScreenRenderTexture_0x26e3a0; // 0x26e4c8 - g_ps2RecompiledFunctionTable[375092] = bhDrawSmallScreenRenderTexture_0x26e3a0; // 0x26e4d8 - g_ps2RecompiledFunctionTable[375106] = bhDrawSmallScreenRenderTexture_0x26e3a0; // 0x26e510 - g_ps2RecompiledFunctionTable[375108] = bhDrawSmallScreenRenderTexture_0x26e3a0; // 0x26e518 - g_ps2RecompiledFunctionTable[375127] = bhDrawSmallScreenRenderTexture_0x26e3a0; // 0x26e564 - g_ps2RecompiledFunctionTable[375140] = bhDrawSmallScreenRenderTexture_0x26e3a0; // 0x26e598 - g_ps2RecompiledFunctionTable[375146] = bhDrawSmallScreenRenderTexture_0x26e3a0; // 0x26e5b0 - g_ps2RecompiledFunctionTable[375156] = bhDrawSmallScreenRenderTexture_0x26e3a0; // 0x26e5d8 - g_ps2RecompiledFunctionTable[375163] = bhDrawSmallScreenRenderTexture_0x26e3a0; // 0x26e5f4 - g_ps2RecompiledFunctionTable[375169] = bhDrawSmallScreenRenderTexture_0x26e3a0; // 0x26e60c - g_ps2RecompiledFunctionTable[375179] = bhDrawSmallScreenRenderTexture_0x26e3a0; // 0x26e634 - g_ps2RecompiledFunctionTable[375187] = bhDrawSmallScreenRenderTexture_0x26e3a0; // 0x26e654 - g_ps2RecompiledFunctionTable[375194] = bhDrawSmallScreenRenderTexture_0x26e3a0; // 0x26e670 - g_ps2RecompiledFunctionTable[375203] = bhDrawSmallScreenRenderTexture_0x26e3a0; // 0x26e694 - g_ps2RecompiledFunctionTable[375209] = bhDrawSmallScreenRenderTexture_0x26e3a0; // 0x26e6ac - g_ps2RecompiledFunctionTable[375216] = bhDrawSmallScreenRenderTexture_0x26e3a0; // 0x26e6c8 - g_ps2RecompiledFunctionTable[375225] = bhDrawSmallScreenRenderTexture_0x26e3a0; // 0x26e6ec - g_ps2RecompiledFunctionTable[375231] = bhDrawSmallScreenRenderTexture_0x26e3a0; // 0x26e704 - g_ps2RecompiledFunctionTable[375233] = bhDrawSmallScreenRenderTexture_0x26e3a0; // 0x26e70c - g_ps2RecompiledFunctionTable[375235] = bhDrawSmallScreenRenderTexture_0x26e3a0; // 0x26e714 - g_ps2RecompiledFunctionTable[375247] = bhDrawSmallScreenRenderTexture_0x26e3a0; // 0x26e744 - g_ps2RecompiledFunctionTable[375255] = bhDrawSmallScreenRenderTexture_0x26e3a0; // 0x26e764 - g_ps2RecompiledFunctionTable[375260] = bhDrawSmallScreenRenderTexture_0x26e3a0; // 0x26e778 - g_ps2RecompiledFunctionTable[375270] = bhDrawSmallScreenRenderTexture_0x26e3a0; // 0x26e7a0 - g_ps2RecompiledFunctionTable[375274] = bhDrawSmallScreenRenderTexture_0x26e3a0; // 0x26e7b0 - g_ps2RecompiledFunctionTable[375291] = bhDrawSmallScreenRenderTexture_0x26e3a0; // 0x26e7f4 - g_ps2RecompiledFunctionTable[375296] = bhDrawSmallScreenRenderTexture_0x26e3a0; // 0x26e808 - g_ps2RecompiledFunctionTable[375298] = bhDrawSmallScreenRenderTexture_0x26e3a0; // 0x26e810 - g_ps2RecompiledFunctionTable[375300] = bhDrawSmallScreenRenderTexture_0x26e3a0; // 0x26e818 - g_ps2RecompiledFunctionTable[375302] = bhDrawSmallScreenRenderTexture_0x26e3a0; // 0x26e820 - g_ps2RecompiledFunctionTable[375315] = bhDrawSmallScreenRenderTexture_0x26e3a0; // 0x26e854 - g_ps2RecompiledFunctionTable[375320] = bhDrawSmallScreenRenderTexture_0x26e3a0; // 0x26e868 - g_ps2RecompiledFunctionTable[375322] = bhDrawSmallScreenRenderTexture_0x26e3a0; // 0x26e870 - g_ps2RecompiledFunctionTable[375334] = CreateSaveScreen_0x26e8a0; // 0x26e8a0 - g_ps2RecompiledFunctionTable[375356] = CreateSaveScreen_0x26e8a0; // 0x26e8f8 - g_ps2RecompiledFunctionTable[375360] = CreateSaveScreen_0x26e8a0; // 0x26e908 - g_ps2RecompiledFunctionTable[375364] = CreateSaveScreen_0x26e8a0; // 0x26e918 - g_ps2RecompiledFunctionTable[375371] = CreateSaveScreen_0x26e8a0; // 0x26e934 - g_ps2RecompiledFunctionTable[375375] = CreateSaveScreen_0x26e8a0; // 0x26e944 - g_ps2RecompiledFunctionTable[375381] = CreateSaveScreen_0x26e8a0; // 0x26e95c - g_ps2RecompiledFunctionTable[375385] = CreateSaveScreen_0x26e8a0; // 0x26e96c - g_ps2RecompiledFunctionTable[375394] = DispMessageSelect_0x26e990; // 0x26e990 - g_ps2RecompiledFunctionTable[375405] = DispMessageSelect_0x26e990; // 0x26e9bc - g_ps2RecompiledFunctionTable[375419] = DispMessageSelect_0x26e990; // 0x26e9f4 - g_ps2RecompiledFunctionTable[375433] = DispMessageSelect_0x26e990; // 0x26ea2c - g_ps2RecompiledFunctionTable[375435] = DispMessageSelect_0x26e990; // 0x26ea34 - g_ps2RecompiledFunctionTable[375449] = DispMessageSelect_0x26e990; // 0x26ea6c - g_ps2RecompiledFunctionTable[375463] = DispMessageSelect_0x26e990; // 0x26eaa4 - g_ps2RecompiledFunctionTable[375477] = DispMessageSelect_0x26e990; // 0x26eadc - g_ps2RecompiledFunctionTable[375489] = DispMessageSelect_0x26e990; // 0x26eb0c - g_ps2RecompiledFunctionTable[375503] = DispMessageSelect_0x26e990; // 0x26eb44 - g_ps2RecompiledFunctionTable[375517] = DispMessageSelect_0x26e990; // 0x26eb7c - g_ps2RecompiledFunctionTable[375532] = DispMessageSelect_0x26e990; // 0x26ebb8 - g_ps2RecompiledFunctionTable[375544] = DispMessageSelect_0x26e990; // 0x26ebe8 - g_ps2RecompiledFunctionTable[375558] = DispMessageSelect_0x26e990; // 0x26ec20 - g_ps2RecompiledFunctionTable[375573] = DispMessageSelect_0x26e990; // 0x26ec5c - g_ps2RecompiledFunctionTable[375585] = DispMessageSelect_0x26e990; // 0x26ec8c - g_ps2RecompiledFunctionTable[375600] = DispMessageSelect_0x26e990; // 0x26ecc8 - g_ps2RecompiledFunctionTable[375612] = DispMessageSelect_0x26e990; // 0x26ecf8 - g_ps2RecompiledFunctionTable[375627] = DispMessageSelect_0x26e990; // 0x26ed34 - g_ps2RecompiledFunctionTable[375642] = DispMessageSelect_0x26e990; // 0x26ed70 - g_ps2RecompiledFunctionTable[375656] = DispMessageSelect_0x26e990; // 0x26eda8 - g_ps2RecompiledFunctionTable[375670] = DispMessageSelect_0x26e990; // 0x26ede0 - g_ps2RecompiledFunctionTable[375682] = DispMessageSelect_0x26e990; // 0x26ee10 - g_ps2RecompiledFunctionTable[375696] = DispMessageSelect_0x26e990; // 0x26ee48 - g_ps2RecompiledFunctionTable[375710] = DispMessageSelect_0x26e990; // 0x26ee80 - g_ps2RecompiledFunctionTable[375722] = DispMessageSelect_0x26e990; // 0x26eeb0 - g_ps2RecompiledFunctionTable[375736] = DispMessageSelect_0x26e990; // 0x26eee8 - g_ps2RecompiledFunctionTable[375750] = DispMessageSelect_0x26e990; // 0x26ef20 - g_ps2RecompiledFunctionTable[375764] = DispMessageSelect_0x26e990; // 0x26ef58 - g_ps2RecompiledFunctionTable[375770] = DispMessageSelect_0x26e990; // 0x26ef70 - g_ps2RecompiledFunctionTable[375774] = DispTexture_0x26ef80; // 0x26ef80 - g_ps2RecompiledFunctionTable[375790] = DispTexture_0x26ef80; // 0x26efc0 - g_ps2RecompiledFunctionTable[375800] = DispTexture_0x26ef80; // 0x26efe8 - g_ps2RecompiledFunctionTable[375810] = DispTexture_0x26ef80; // 0x26f010 - g_ps2RecompiledFunctionTable[375814] = DispTexture_0x26ef80; // 0x26f020 - g_ps2RecompiledFunctionTable[375821] = DispTexture_0x26ef80; // 0x26f03c - g_ps2RecompiledFunctionTable[375829] = DispTexture_0x26ef80; // 0x26f05c - g_ps2RecompiledFunctionTable[375833] = DispTexture_0x26ef80; // 0x26f06c - g_ps2RecompiledFunctionTable[375840] = DispTexture_0x26ef80; // 0x26f088 - g_ps2RecompiledFunctionTable[375849] = DispTexture_0x26ef80; // 0x26f0ac - g_ps2RecompiledFunctionTable[375858] = DispTexture_0x26ef80; // 0x26f0d0 - g_ps2RecompiledFunctionTable[375862] = ExecuteSaveScreen_0x26f0e0; // 0x26f0e0 - g_ps2RecompiledFunctionTable[375868] = ExecuteSaveScreen_0x26f0e0; // 0x26f0f8 - g_ps2RecompiledFunctionTable[375870] = ExecuteSaveScreen_0x26f0e0; // 0x26f100 - g_ps2RecompiledFunctionTable[375953] = ExecuteSaveScreen_0x26f0e0; // 0x26f24c - g_ps2RecompiledFunctionTable[375958] = ExecuteSaveScreen_0x26f0e0; // 0x26f260 - g_ps2RecompiledFunctionTable[375963] = ExecuteSaveScreen_0x26f0e0; // 0x26f274 - g_ps2RecompiledFunctionTable[375968] = ExecuteSaveScreen_0x26f0e0; // 0x26f288 - g_ps2RecompiledFunctionTable[375973] = ExecuteSaveScreen_0x26f0e0; // 0x26f29c - g_ps2RecompiledFunctionTable[375978] = ExecuteSaveScreen_0x26f0e0; // 0x26f2b0 - g_ps2RecompiledFunctionTable[375983] = ExecuteSaveScreen_0x26f0e0; // 0x26f2c4 - g_ps2RecompiledFunctionTable[375988] = ExecuteSaveScreen_0x26f0e0; // 0x26f2d8 - g_ps2RecompiledFunctionTable[375993] = ExecuteSaveScreen_0x26f0e0; // 0x26f2ec - g_ps2RecompiledFunctionTable[375998] = ExecuteSaveScreen_0x26f0e0; // 0x26f300 - g_ps2RecompiledFunctionTable[376003] = ExecuteSaveScreen_0x26f0e0; // 0x26f314 - g_ps2RecompiledFunctionTable[376008] = ExecuteSaveScreen_0x26f0e0; // 0x26f328 - g_ps2RecompiledFunctionTable[376013] = ExecuteSaveScreen_0x26f0e0; // 0x26f33c - g_ps2RecompiledFunctionTable[376018] = ExecuteSaveScreen_0x26f0e0; // 0x26f350 - g_ps2RecompiledFunctionTable[376023] = ExecuteSaveScreen_0x26f0e0; // 0x26f364 - g_ps2RecompiledFunctionTable[376028] = ExecuteSaveScreen_0x26f0e0; // 0x26f378 - g_ps2RecompiledFunctionTable[376033] = ExecuteSaveScreen_0x26f0e0; // 0x26f38c - g_ps2RecompiledFunctionTable[376038] = ExecuteSaveScreen_0x26f0e0; // 0x26f3a0 - g_ps2RecompiledFunctionTable[376043] = ExecuteSaveScreen_0x26f0e0; // 0x26f3b4 - g_ps2RecompiledFunctionTable[376048] = ExecuteSaveScreen_0x26f0e0; // 0x26f3c8 - g_ps2RecompiledFunctionTable[376053] = ExecuteSaveScreen_0x26f0e0; // 0x26f3dc - g_ps2RecompiledFunctionTable[376058] = ExecuteSaveScreen_0x26f0e0; // 0x26f3f0 - g_ps2RecompiledFunctionTable[376063] = ExecuteSaveScreen_0x26f0e0; // 0x26f404 - g_ps2RecompiledFunctionTable[376068] = ExecuteSaveScreen_0x26f0e0; // 0x26f418 - g_ps2RecompiledFunctionTable[376073] = ExecuteSaveScreen_0x26f0e0; // 0x26f42c - g_ps2RecompiledFunctionTable[376078] = ExecuteSaveScreen_0x26f0e0; // 0x26f440 - g_ps2RecompiledFunctionTable[376081] = ExecuteSaveScreen_0x26f0e0; // 0x26f44c - g_ps2RecompiledFunctionTable[376083] = ExecuteSaveScreen_0x26f0e0; // 0x26f454 - g_ps2RecompiledFunctionTable[376090] = SetStateSaveScreenAwarenessCard_0x26f470; // 0x26f470 - g_ps2RecompiledFunctionTable[376098] = ExecuteStateSaveScreenAwarenessCard_0x26f490; // 0x26f490 - g_ps2RecompiledFunctionTable[376120] = ExecuteStateSaveScreenAwarenessCard_0x26f490; // 0x26f4e8 - g_ps2RecompiledFunctionTable[376124] = ExecuteStateSaveScreenAwarenessCard_0x26f490; // 0x26f4f8 - g_ps2RecompiledFunctionTable[376132] = ExecuteStateSaveScreenAwarenessCard_0x26f490; // 0x26f518 - g_ps2RecompiledFunctionTable[376146] = ExecuteStateSaveScreenAwarenessCard_0x26f490; // 0x26f550 - g_ps2RecompiledFunctionTable[376151] = ExecuteStateSaveScreenAwarenessCard_0x26f490; // 0x26f564 - g_ps2RecompiledFunctionTable[376155] = ExecuteStateSaveScreenAwarenessCard_0x26f490; // 0x26f574 - g_ps2RecompiledFunctionTable[376159] = ExecuteStateSaveScreenAwarenessCard_0x26f490; // 0x26f584 - g_ps2RecompiledFunctionTable[376163] = ExecuteStateSaveScreenAwarenessCard_0x26f490; // 0x26f594 - g_ps2RecompiledFunctionTable[376170] = SetStateSaveScreenErrLostCard_0x26f5b0; // 0x26f5b0 - g_ps2RecompiledFunctionTable[376178] = ExecuteStateSaveScreenErrLostCard_0x26f5d0; // 0x26f5d0 - g_ps2RecompiledFunctionTable[376192] = ExecuteStateSaveScreenErrLostCard_0x26f5d0; // 0x26f608 - g_ps2RecompiledFunctionTable[376195] = ExecuteStateSaveScreenErrLostCard_0x26f5d0; // 0x26f614 - g_ps2RecompiledFunctionTable[376212] = ExecuteStateSaveScreenErrLostCard_0x26f5d0; // 0x26f658 - g_ps2RecompiledFunctionTable[376216] = ExecuteStateSaveScreenErrLostCard_0x26f5d0; // 0x26f668 - g_ps2RecompiledFunctionTable[376224] = ExecuteStateSaveScreenErrLostCard_0x26f5d0; // 0x26f688 - g_ps2RecompiledFunctionTable[376238] = ExecuteStateSaveScreenErrLostCard_0x26f5d0; // 0x26f6c0 - g_ps2RecompiledFunctionTable[376242] = ExecuteStateSaveScreenErrLostCard_0x26f5d0; // 0x26f6d0 - g_ps2RecompiledFunctionTable[376246] = ExecuteStateSaveScreenErrLostCard_0x26f5d0; // 0x26f6e0 - g_ps2RecompiledFunctionTable[376254] = SetStateSaveScreenErrUnPS2MemCard_0x26f700; // 0x26f700 - g_ps2RecompiledFunctionTable[376262] = ExecuteStateSaveScreenErrUnPS2MemCard_0x26f720; // 0x26f720 - g_ps2RecompiledFunctionTable[376276] = ExecuteStateSaveScreenErrUnPS2MemCard_0x26f720; // 0x26f758 - g_ps2RecompiledFunctionTable[376279] = ExecuteStateSaveScreenErrUnPS2MemCard_0x26f720; // 0x26f764 - g_ps2RecompiledFunctionTable[376296] = ExecuteStateSaveScreenErrUnPS2MemCard_0x26f720; // 0x26f7a8 - g_ps2RecompiledFunctionTable[376300] = ExecuteStateSaveScreenErrUnPS2MemCard_0x26f720; // 0x26f7b8 - g_ps2RecompiledFunctionTable[376308] = ExecuteStateSaveScreenErrUnPS2MemCard_0x26f720; // 0x26f7d8 - g_ps2RecompiledFunctionTable[376316] = ExecuteStateSaveScreenErrUnPS2MemCard_0x26f720; // 0x26f7f8 - g_ps2RecompiledFunctionTable[376320] = ExecuteStateSaveScreenErrUnPS2MemCard_0x26f720; // 0x26f808 - g_ps2RecompiledFunctionTable[376324] = ExecuteStateSaveScreenErrUnPS2MemCard_0x26f720; // 0x26f818 - g_ps2RecompiledFunctionTable[376330] = SetStateSaveScreenSelectCard_0x26f830; // 0x26f830 - g_ps2RecompiledFunctionTable[376342] = SetStateSaveScreenSelectCard_0x26f830; // 0x26f860 - g_ps2RecompiledFunctionTable[376345] = SetStateSaveScreenSelectCard_0x26f830; // 0x26f86c - g_ps2RecompiledFunctionTable[376350] = ExecuteStateSaveScreenSelectCard_0x26f880; // 0x26f880 - g_ps2RecompiledFunctionTable[376368] = ExecuteStateSaveScreenSelectCard_0x26f880; // 0x26f8c8 - g_ps2RecompiledFunctionTable[376379] = ExecuteStateSaveScreenSelectCard_0x26f880; // 0x26f8f4 - g_ps2RecompiledFunctionTable[376388] = ExecuteStateSaveScreenSelectCard_0x26f880; // 0x26f918 - g_ps2RecompiledFunctionTable[376394] = ExecuteStateSaveScreenSelectCard_0x26f880; // 0x26f930 - g_ps2RecompiledFunctionTable[376410] = ExecuteStateSaveScreenSelectCard_0x26f880; // 0x26f970 - g_ps2RecompiledFunctionTable[376420] = ExecuteStateSaveScreenSelectCard_0x26f880; // 0x26f998 - g_ps2RecompiledFunctionTable[376439] = ExecuteStateSaveScreenSelectCard_0x26f880; // 0x26f9e4 - g_ps2RecompiledFunctionTable[376444] = ExecuteStateSaveScreenSelectCard_0x26f880; // 0x26f9f8 - g_ps2RecompiledFunctionTable[376447] = ExecuteStateSaveScreenSelectCard_0x26f880; // 0x26fa04 - g_ps2RecompiledFunctionTable[376454] = ExecuteStateSaveScreenSelectCard_0x26f880; // 0x26fa20 - g_ps2RecompiledFunctionTable[376457] = ExecuteStateSaveScreenSelectCard_0x26f880; // 0x26fa2c - g_ps2RecompiledFunctionTable[376468] = ExecuteStateSaveScreenSelectCard_0x26f880; // 0x26fa58 - g_ps2RecompiledFunctionTable[376474] = SetStateSaveScreenExit_0x26fa70; // 0x26fa70 - g_ps2RecompiledFunctionTable[376486] = ExecuteStateSaveScreenExit_0x26faa0; // 0x26faa0 - g_ps2RecompiledFunctionTable[376495] = ExecuteStateSaveScreenExit_0x26faa0; // 0x26fac4 - g_ps2RecompiledFunctionTable[376507] = ExecuteStateSaveScreenExit_0x26faa0; // 0x26faf4 - g_ps2RecompiledFunctionTable[376514] = SetSaveScreenSpecialSave_0x26fb10; // 0x26fb10 - g_ps2RecompiledFunctionTable[376526] = ExecuteStateSaveScreenSpecialSave_0x26fb40; // 0x26fb40 - g_ps2RecompiledFunctionTable[376545] = ExecuteStateSaveScreenSpecialSave_0x26fb40; // 0x26fb8c - g_ps2RecompiledFunctionTable[376559] = ExecuteStateSaveScreenSpecialSave_0x26fb40; // 0x26fbc4 - g_ps2RecompiledFunctionTable[376570] = ExecuteStateSaveScreenSpecialSave_0x26fb40; // 0x26fbf0 - g_ps2RecompiledFunctionTable[376576] = ExecuteStateSaveScreenSpecialSave_0x26fb40; // 0x26fc08 - g_ps2RecompiledFunctionTable[376583] = ExecuteStateSaveScreenSpecialSave_0x26fb40; // 0x26fc24 - g_ps2RecompiledFunctionTable[376586] = ExecuteStateSaveScreenSpecialSave_0x26fb40; // 0x26fc30 - g_ps2RecompiledFunctionTable[376597] = ExecuteStateSaveScreenSpecialSave_0x26fb40; // 0x26fc5c - g_ps2RecompiledFunctionTable[376602] = SetStateSaveScreenLostDirCheck_0x26fc70; // 0x26fc70 - g_ps2RecompiledFunctionTable[376619] = SetStateSaveScreenLostDirCheck_0x26fc70; // 0x26fcb4 - g_ps2RecompiledFunctionTable[376622] = SetStateSaveScreenLostDirCheck_0x26fc70; // 0x26fcc0 - g_ps2RecompiledFunctionTable[376625] = SetStateSaveScreenLostDirCheck_0x26fc70; // 0x26fccc - g_ps2RecompiledFunctionTable[376630] = ExecuteStateSaveScreenLostDirCheck_0x26fce0; // 0x26fce0 - g_ps2RecompiledFunctionTable[376646] = ExecuteStateSaveScreenLostDirCheck_0x26fce0; // 0x26fd20 - g_ps2RecompiledFunctionTable[376655] = ExecuteStateSaveScreenLostDirCheck_0x26fce0; // 0x26fd44 - g_ps2RecompiledFunctionTable[376668] = ExecuteStateSaveScreenLostDirCheck_0x26fce0; // 0x26fd78 - g_ps2RecompiledFunctionTable[376670] = ExecuteStateSaveScreenLostDirCheck_0x26fce0; // 0x26fd80 - g_ps2RecompiledFunctionTable[376675] = ExecuteStateSaveScreenLostDirCheck_0x26fce0; // 0x26fd94 - g_ps2RecompiledFunctionTable[376687] = ExecuteStateSaveScreenLostDirCheck_0x26fce0; // 0x26fdc4 - g_ps2RecompiledFunctionTable[376695] = ExecuteStateSaveScreenLostDirCheck_0x26fce0; // 0x26fde4 - g_ps2RecompiledFunctionTable[376702] = ExecuteStateSaveScreenLostDirCheck_0x26fce0; // 0x26fe00 - g_ps2RecompiledFunctionTable[376704] = ExecuteStateSaveScreenLostDirCheck_0x26fce0; // 0x26fe08 - g_ps2RecompiledFunctionTable[376718] = ExecuteStateSaveScreenLostDirCheck_0x26fce0; // 0x26fe40 - g_ps2RecompiledFunctionTable[376728] = ExecuteStateSaveScreenLostDirCheck_0x26fce0; // 0x26fe68 - g_ps2RecompiledFunctionTable[376735] = ExecuteStateSaveScreenLostDirCheck_0x26fce0; // 0x26fe84 - g_ps2RecompiledFunctionTable[376744] = ExecuteStateSaveScreenLostDirCheck_0x26fce0; // 0x26fea8 - g_ps2RecompiledFunctionTable[376757] = ExecuteStateSaveScreenLostDirCheck_0x26fce0; // 0x26fedc - g_ps2RecompiledFunctionTable[376759] = ExecuteStateSaveScreenLostDirCheck_0x26fce0; // 0x26fee4 - g_ps2RecompiledFunctionTable[376767] = ExecuteStateSaveScreenLostDirCheck_0x26fce0; // 0x26ff04 - g_ps2RecompiledFunctionTable[376775] = ExecuteStateSaveScreenLostDirCheck_0x26fce0; // 0x26ff24 - g_ps2RecompiledFunctionTable[376784] = ExecuteStateSaveScreenLostDirCheck_0x26fce0; // 0x26ff48 - g_ps2RecompiledFunctionTable[376790] = SetStateSaveScreenFreeCapacity_0x26ff60; // 0x26ff60 - g_ps2RecompiledFunctionTable[376798] = ExecuteStateSaveScreenFreeCapacity_0x26ff80; // 0x26ff80 - g_ps2RecompiledFunctionTable[376805] = ExecuteStateSaveScreenFreeCapacity_0x26ff80; // 0x26ff9c - g_ps2RecompiledFunctionTable[376807] = ExecuteStateSaveScreenFreeCapacity_0x26ff80; // 0x26ffa4 - g_ps2RecompiledFunctionTable[376815] = ExecuteStateSaveScreenFreeCapacity_0x26ff80; // 0x26ffc4 - g_ps2RecompiledFunctionTable[376820] = ExecuteStateSaveScreenFreeCapacity_0x26ff80; // 0x26ffd8 - g_ps2RecompiledFunctionTable[376825] = ExecuteStateSaveScreenFreeCapacity_0x26ff80; // 0x26ffec - g_ps2RecompiledFunctionTable[376830] = SetStateSaveScreenErrFreeCapacity_0x270000; // 0x270000 - g_ps2RecompiledFunctionTable[376838] = ExecuteStateSaveScreenErrFreeCapacity_0x270020; // 0x270020 - g_ps2RecompiledFunctionTable[376850] = ExecuteStateSaveScreenErrFreeCapacity_0x270020; // 0x270050 - g_ps2RecompiledFunctionTable[376853] = ExecuteStateSaveScreenErrFreeCapacity_0x270020; // 0x27005c - g_ps2RecompiledFunctionTable[376864] = ExecuteStateSaveScreenErrFreeCapacity_0x270020; // 0x270088 - g_ps2RecompiledFunctionTable[376870] = SetStateSaveScreenCreateSaveFileCheck_0x2700a0; // 0x2700a0 - g_ps2RecompiledFunctionTable[376878] = ExecuteStateSaveScreenCreateSaveFileCheck_0x2700c0; // 0x2700c0 - g_ps2RecompiledFunctionTable[376897] = ExecuteStateSaveScreenCreateSaveFileCheck_0x2700c0; // 0x27010c - g_ps2RecompiledFunctionTable[376911] = ExecuteStateSaveScreenCreateSaveFileCheck_0x2700c0; // 0x270144 - g_ps2RecompiledFunctionTable[376922] = ExecuteStateSaveScreenCreateSaveFileCheck_0x2700c0; // 0x270170 - g_ps2RecompiledFunctionTable[376926] = ExecuteStateSaveScreenCreateSaveFileCheck_0x2700c0; // 0x270180 - g_ps2RecompiledFunctionTable[376929] = ExecuteStateSaveScreenCreateSaveFileCheck_0x2700c0; // 0x27018c - g_ps2RecompiledFunctionTable[376936] = ExecuteStateSaveScreenCreateSaveFileCheck_0x2700c0; // 0x2701a8 - g_ps2RecompiledFunctionTable[376939] = ExecuteStateSaveScreenCreateSaveFileCheck_0x2700c0; // 0x2701b4 - g_ps2RecompiledFunctionTable[376950] = ExecuteStateSaveScreenCreateSaveFileCheck_0x2700c0; // 0x2701e0 - g_ps2RecompiledFunctionTable[376954] = SetStateSaveScreenCreateSaveFile_0x2701f0; // 0x2701f0 - g_ps2RecompiledFunctionTable[376970] = ExecuteStateSaveScreenCreateSaveFile_0x270230; // 0x270230 - g_ps2RecompiledFunctionTable[376986] = ExecuteStateSaveScreenCreateSaveFile_0x270230; // 0x270270 - g_ps2RecompiledFunctionTable[376992] = ExecuteStateSaveScreenCreateSaveFile_0x270230; // 0x270288 - g_ps2RecompiledFunctionTable[376994] = ExecuteStateSaveScreenCreateSaveFile_0x270230; // 0x270290 - g_ps2RecompiledFunctionTable[377006] = ExecuteStateSaveScreenCreateSaveFile_0x270230; // 0x2702c0 - g_ps2RecompiledFunctionTable[377013] = ExecuteStateSaveScreenCreateSaveFile_0x270230; // 0x2702dc - g_ps2RecompiledFunctionTable[377025] = ExecuteStateSaveScreenCreateSaveFile_0x270230; // 0x27030c - g_ps2RecompiledFunctionTable[377027] = ExecuteStateSaveScreenCreateSaveFile_0x270230; // 0x270314 - g_ps2RecompiledFunctionTable[377035] = ExecuteStateSaveScreenCreateSaveFile_0x270230; // 0x270334 - g_ps2RecompiledFunctionTable[377042] = ExecuteStateSaveScreenCreateSaveFile_0x270230; // 0x270350 - g_ps2RecompiledFunctionTable[377044] = ExecuteStateSaveScreenCreateSaveFile_0x270230; // 0x270358 - g_ps2RecompiledFunctionTable[377053] = ExecuteStateSaveScreenCreateSaveFile_0x270230; // 0x27037c - g_ps2RecompiledFunctionTable[377061] = ExecuteStateSaveScreenCreateSaveFile_0x270230; // 0x27039c - g_ps2RecompiledFunctionTable[377067] = ExecuteStateSaveScreenCreateSaveFile_0x270230; // 0x2703b4 - g_ps2RecompiledFunctionTable[377069] = ExecuteStateSaveScreenCreateSaveFile_0x270230; // 0x2703bc - g_ps2RecompiledFunctionTable[377078] = ExecuteStateSaveScreenCreateSaveFile_0x270230; // 0x2703e0 - g_ps2RecompiledFunctionTable[377086] = ExecuteStateSaveScreenCreateSaveFile_0x270230; // 0x270400 - g_ps2RecompiledFunctionTable[377098] = ExecuteStateSaveScreenCreateSaveFile_0x270230; // 0x270430 - g_ps2RecompiledFunctionTable[377100] = ExecuteStateSaveScreenCreateSaveFile_0x270230; // 0x270438 - g_ps2RecompiledFunctionTable[377109] = ExecuteStateSaveScreenCreateSaveFile_0x270230; // 0x27045c - g_ps2RecompiledFunctionTable[377117] = ExecuteStateSaveScreenCreateSaveFile_0x270230; // 0x27047c - g_ps2RecompiledFunctionTable[377135] = ExecuteStateSaveScreenCreateSaveFile_0x270230; // 0x2704c4 - g_ps2RecompiledFunctionTable[377146] = ExecuteStateSaveScreenCreateSaveFile_0x270230; // 0x2704f0 - g_ps2RecompiledFunctionTable[377148] = ExecuteStateSaveScreenCreateSaveFile_0x270230; // 0x2704f8 - g_ps2RecompiledFunctionTable[377161] = ExecuteStateSaveScreenCreateSaveFile_0x270230; // 0x27052c - g_ps2RecompiledFunctionTable[377169] = ExecuteStateSaveScreenCreateSaveFile_0x270230; // 0x27054c - g_ps2RecompiledFunctionTable[377174] = SetStateSaveScreenErrCreateSaveFile_0x270560; // 0x270560 - g_ps2RecompiledFunctionTable[377186] = ExecuteStateSaveScreenErrCreateSaveFile_0x270590; // 0x270590 - g_ps2RecompiledFunctionTable[377198] = ExecuteStateSaveScreenErrCreateSaveFile_0x270590; // 0x2705c0 - g_ps2RecompiledFunctionTable[377201] = ExecuteStateSaveScreenErrCreateSaveFile_0x270590; // 0x2705cc - g_ps2RecompiledFunctionTable[377212] = ExecuteStateSaveScreenErrCreateSaveFile_0x270590; // 0x2705f8 - g_ps2RecompiledFunctionTable[377218] = SetStateSaveScreenSelectFile_0x270610; // 0x270610 - g_ps2RecompiledFunctionTable[377232] = SetStateSaveScreenSelectFile_0x270610; // 0x270648 - g_ps2RecompiledFunctionTable[377236] = SetStateSaveScreenSelectFile_0x270610; // 0x270658 - g_ps2RecompiledFunctionTable[377242] = ExecuteStateSaveScreenSelectFile_0x270670; // 0x270670 - g_ps2RecompiledFunctionTable[377301] = ExecuteStateSaveScreenSelectFile_0x270670; // 0x27075c - g_ps2RecompiledFunctionTable[377304] = ExecuteStateSaveScreenSelectFile_0x270670; // 0x270768 - g_ps2RecompiledFunctionTable[377312] = ExecuteStateSaveScreenSelectFile_0x270670; // 0x270788 - g_ps2RecompiledFunctionTable[377316] = ExecuteStateSaveScreenSelectFile_0x270670; // 0x270798 - g_ps2RecompiledFunctionTable[377321] = ExecuteStateSaveScreenSelectFile_0x270670; // 0x2707ac - g_ps2RecompiledFunctionTable[377324] = ExecuteStateSaveScreenSelectFile_0x270670; // 0x2707b8 - g_ps2RecompiledFunctionTable[377335] = ExecuteStateSaveScreenSelectFile_0x270670; // 0x2707e4 - g_ps2RecompiledFunctionTable[377338] = ExecuteStateSaveScreenSelectFile_0x270670; // 0x2707f0 - g_ps2RecompiledFunctionTable[377346] = ExecuteStateSaveScreenSelectFile_0x270670; // 0x270810 - g_ps2RecompiledFunctionTable[377350] = ExecuteStateSaveScreenSelectFile_0x270670; // 0x270820 - g_ps2RecompiledFunctionTable[377356] = ExecuteStateSaveScreenSelectFile_0x270670; // 0x270838 - g_ps2RecompiledFunctionTable[377359] = ExecuteStateSaveScreenSelectFile_0x270670; // 0x270844 - g_ps2RecompiledFunctionTable[377366] = ExecuteStateSaveScreenSelectFile_0x270670; // 0x270860 - g_ps2RecompiledFunctionTable[377369] = ExecuteStateSaveScreenSelectFile_0x270670; // 0x27086c - g_ps2RecompiledFunctionTable[377376] = ExecuteStateSaveScreenSelectFile_0x270670; // 0x270888 - g_ps2RecompiledFunctionTable[377379] = ExecuteStateSaveScreenSelectFile_0x270670; // 0x270894 - g_ps2RecompiledFunctionTable[377388] = ExecuteStateSaveScreenSelectFile_0x270670; // 0x2708b8 - g_ps2RecompiledFunctionTable[377409] = ExecuteStateSaveScreenSelectFile_0x270670; // 0x27090c - g_ps2RecompiledFunctionTable[377415] = ExecuteStateSaveScreenSelectFile_0x270670; // 0x270924 - g_ps2RecompiledFunctionTable[377422] = SetStateSaveScreenSaveCursor_0x270940; // 0x270940 - g_ps2RecompiledFunctionTable[377429] = SetStateSaveScreenSaveCursor_0x270940; // 0x27095c - g_ps2RecompiledFunctionTable[377442] = ExecuteStateSaveScreenSaveCursor_0x270990; // 0x270990 - g_ps2RecompiledFunctionTable[377448] = ExecuteStateSaveScreenSaveCursor_0x270990; // 0x2709a8 - g_ps2RecompiledFunctionTable[377451] = ExecuteStateSaveScreenSaveCursor_0x270990; // 0x2709b4 - g_ps2RecompiledFunctionTable[377455] = ExecuteStateSaveScreenSaveCursor_0x270990; // 0x2709c4 - g_ps2RecompiledFunctionTable[377460] = ExecuteStateSaveScreenSaveCursor_0x270990; // 0x2709d8 - g_ps2RecompiledFunctionTable[377466] = SetStateSaveScreenSaveCursorOld_0x2709f0; // 0x2709f0 - g_ps2RecompiledFunctionTable[377478] = ExecuteStateSaveScreenSaveCursorOld_0x270a20; // 0x270a20 - g_ps2RecompiledFunctionTable[377497] = ExecuteStateSaveScreenSaveCursorOld_0x270a20; // 0x270a6c - g_ps2RecompiledFunctionTable[377511] = ExecuteStateSaveScreenSaveCursorOld_0x270a20; // 0x270aa4 - g_ps2RecompiledFunctionTable[377522] = ExecuteStateSaveScreenSaveCursorOld_0x270a20; // 0x270ad0 - g_ps2RecompiledFunctionTable[377526] = ExecuteStateSaveScreenSaveCursorOld_0x270a20; // 0x270ae0 - g_ps2RecompiledFunctionTable[377529] = ExecuteStateSaveScreenSaveCursorOld_0x270a20; // 0x270aec - g_ps2RecompiledFunctionTable[377536] = ExecuteStateSaveScreenSaveCursorOld_0x270a20; // 0x270b08 - g_ps2RecompiledFunctionTable[377539] = ExecuteStateSaveScreenSaveCursorOld_0x270a20; // 0x270b14 - g_ps2RecompiledFunctionTable[377550] = ExecuteStateSaveScreenSaveCursorOld_0x270a20; // 0x270b40 - g_ps2RecompiledFunctionTable[377554] = SetStateSaveScreenSaveCursorNew_0x270b50; // 0x270b50 - g_ps2RecompiledFunctionTable[377562] = ExecuteStateSaveScreenSaveCursorNew_0x270b70; // 0x270b70 - g_ps2RecompiledFunctionTable[377581] = ExecuteStateSaveScreenSaveCursorNew_0x270b70; // 0x270bbc - g_ps2RecompiledFunctionTable[377595] = ExecuteStateSaveScreenSaveCursorNew_0x270b70; // 0x270bf4 - g_ps2RecompiledFunctionTable[377606] = ExecuteStateSaveScreenSaveCursorNew_0x270b70; // 0x270c20 - g_ps2RecompiledFunctionTable[377610] = ExecuteStateSaveScreenSaveCursorNew_0x270b70; // 0x270c30 - g_ps2RecompiledFunctionTable[377613] = ExecuteStateSaveScreenSaveCursorNew_0x270b70; // 0x270c3c - g_ps2RecompiledFunctionTable[377620] = ExecuteStateSaveScreenSaveCursorNew_0x270b70; // 0x270c58 - g_ps2RecompiledFunctionTable[377623] = ExecuteStateSaveScreenSaveCursorNew_0x270b70; // 0x270c64 - g_ps2RecompiledFunctionTable[377634] = ExecuteStateSaveScreenSaveCursorNew_0x270b70; // 0x270c90 - g_ps2RecompiledFunctionTable[377638] = SetStateSaveScreenSave_0x270ca0; // 0x270ca0 - g_ps2RecompiledFunctionTable[377650] = ExecuteStateSaveScreenSave_0x270cd0; // 0x270cd0 - g_ps2RecompiledFunctionTable[377669] = ExecuteStateSaveScreenSave_0x270cd0; // 0x270d1c - g_ps2RecompiledFunctionTable[377675] = ExecuteStateSaveScreenSave_0x270cd0; // 0x270d34 - g_ps2RecompiledFunctionTable[377682] = ExecuteStateSaveScreenSave_0x270cd0; // 0x270d50 - g_ps2RecompiledFunctionTable[377694] = ExecuteStateSaveScreenSave_0x270cd0; // 0x270d80 - g_ps2RecompiledFunctionTable[377696] = ExecuteStateSaveScreenSave_0x270cd0; // 0x270d88 - g_ps2RecompiledFunctionTable[377701] = ExecuteStateSaveScreenSave_0x270cd0; // 0x270d9c - g_ps2RecompiledFunctionTable[377705] = ExecuteStateSaveScreenSave_0x270cd0; // 0x270dac - g_ps2RecompiledFunctionTable[377707] = ExecuteStateSaveScreenSave_0x270cd0; // 0x270db4 - g_ps2RecompiledFunctionTable[377715] = ExecuteStateSaveScreenSave_0x270cd0; // 0x270dd4 - g_ps2RecompiledFunctionTable[377722] = SetStateSaveScreenSuccessCardWrite_0x270df0; // 0x270df0 - g_ps2RecompiledFunctionTable[377730] = ExecuteStateSaveScreenSuccessCardWrite_0x270e10; // 0x270e10 - g_ps2RecompiledFunctionTable[377737] = ExecuteStateSaveScreenSuccessCardWrite_0x270e10; // 0x270e2c - g_ps2RecompiledFunctionTable[377743] = ExecuteStateSaveScreenSuccessCardWrite_0x270e10; // 0x270e44 - g_ps2RecompiledFunctionTable[377745] = ExecuteStateSaveScreenSuccessCardWrite_0x270e10; // 0x270e4c - g_ps2RecompiledFunctionTable[377750] = SetStateSaveScreenSuccessCardWriteMessage_0x270e60; // 0x270e60 - g_ps2RecompiledFunctionTable[377765] = SetStateSaveScreenSuccessCardWriteMessage_0x270e60; // 0x270e9c - g_ps2RecompiledFunctionTable[377768] = SetStateSaveScreenSuccessCardWriteMessage_0x270e60; // 0x270ea8 - g_ps2RecompiledFunctionTable[377774] = ExecuteStateSaveScreenSuccessCardWriteMessage_0x270ec0; // 0x270ec0 - g_ps2RecompiledFunctionTable[377784] = ExecuteStateSaveScreenSuccessCardWriteMessage_0x270ec0; // 0x270ee8 - g_ps2RecompiledFunctionTable[377790] = SetStateSaveScreenErrCardWrite_0x270f00; // 0x270f00 - g_ps2RecompiledFunctionTable[377798] = ExecuteStateSaveScreenErrCardWrite_0x270f20; // 0x270f20 - g_ps2RecompiledFunctionTable[377810] = ExecuteStateSaveScreenErrCardWrite_0x270f20; // 0x270f50 - g_ps2RecompiledFunctionTable[377813] = ExecuteStateSaveScreenErrCardWrite_0x270f20; // 0x270f5c - g_ps2RecompiledFunctionTable[377824] = ExecuteStateSaveScreenErrCardWrite_0x270f20; // 0x270f88 - g_ps2RecompiledFunctionTable[377830] = SetStateSaveScreenFormat_0x270fa0; // 0x270fa0 - g_ps2RecompiledFunctionTable[377842] = ExecuteStateSaveScreenFormat_0x270fd0; // 0x270fd0 - g_ps2RecompiledFunctionTable[377861] = ExecuteStateSaveScreenFormat_0x270fd0; // 0x27101c - g_ps2RecompiledFunctionTable[377875] = ExecuteStateSaveScreenFormat_0x270fd0; // 0x271054 - g_ps2RecompiledFunctionTable[377886] = ExecuteStateSaveScreenFormat_0x270fd0; // 0x271080 - g_ps2RecompiledFunctionTable[377890] = ExecuteStateSaveScreenFormat_0x270fd0; // 0x271090 - g_ps2RecompiledFunctionTable[377893] = ExecuteStateSaveScreenFormat_0x270fd0; // 0x27109c - g_ps2RecompiledFunctionTable[377900] = ExecuteStateSaveScreenFormat_0x270fd0; // 0x2710b8 - g_ps2RecompiledFunctionTable[377903] = ExecuteStateSaveScreenFormat_0x270fd0; // 0x2710c4 - g_ps2RecompiledFunctionTable[377914] = ExecuteStateSaveScreenFormat_0x270fd0; // 0x2710f0 - g_ps2RecompiledFunctionTable[377918] = SetStateSaveScreenStartFormat_0x271100; // 0x271100 - g_ps2RecompiledFunctionTable[377930] = ExecuteStateSaveScreenStartFormat_0x271130; // 0x271130 - g_ps2RecompiledFunctionTable[377949] = ExecuteStateSaveScreenStartFormat_0x271130; // 0x27117c - g_ps2RecompiledFunctionTable[377956] = ExecuteStateSaveScreenStartFormat_0x271130; // 0x271198 - g_ps2RecompiledFunctionTable[377962] = ExecuteStateSaveScreenStartFormat_0x271130; // 0x2711b0 - g_ps2RecompiledFunctionTable[377971] = ExecuteStateSaveScreenStartFormat_0x271130; // 0x2711d4 - g_ps2RecompiledFunctionTable[377973] = ExecuteStateSaveScreenStartFormat_0x271130; // 0x2711dc - g_ps2RecompiledFunctionTable[377982] = ExecuteStateSaveScreenStartFormat_0x271130; // 0x271200 - g_ps2RecompiledFunctionTable[377990] = ExecuteStateSaveScreenStartFormat_0x271130; // 0x271220 - g_ps2RecompiledFunctionTable[377994] = SetStateSaveScreenExitFormat_0x271230; // 0x271230 - g_ps2RecompiledFunctionTable[378006] = ExecuteStateSaveScreenExitFormat_0x271260; // 0x271260 - g_ps2RecompiledFunctionTable[378025] = ExecuteStateSaveScreenExitFormat_0x271260; // 0x2712ac - g_ps2RecompiledFunctionTable[378039] = ExecuteStateSaveScreenExitFormat_0x271260; // 0x2712e4 - g_ps2RecompiledFunctionTable[378050] = ExecuteStateSaveScreenExitFormat_0x271260; // 0x271310 - g_ps2RecompiledFunctionTable[378054] = ExecuteStateSaveScreenExitFormat_0x271260; // 0x271320 - g_ps2RecompiledFunctionTable[378057] = ExecuteStateSaveScreenExitFormat_0x271260; // 0x27132c - g_ps2RecompiledFunctionTable[378064] = ExecuteStateSaveScreenExitFormat_0x271260; // 0x271348 - g_ps2RecompiledFunctionTable[378067] = ExecuteStateSaveScreenExitFormat_0x271260; // 0x271354 - g_ps2RecompiledFunctionTable[378078] = ExecuteStateSaveScreenExitFormat_0x271260; // 0x271380 - g_ps2RecompiledFunctionTable[378082] = SetStateSaveScreenSuccessFormat_0x271390; // 0x271390 - g_ps2RecompiledFunctionTable[378094] = ExecuteStateSaveScreenSuccessFormat_0x2713c0; // 0x2713c0 - g_ps2RecompiledFunctionTable[378102] = ExecuteStateSaveScreenSuccessFormat_0x2713c0; // 0x2713e0 - g_ps2RecompiledFunctionTable[378106] = SetStateSaveScreenErrFormat_0x2713f0; // 0x2713f0 - g_ps2RecompiledFunctionTable[378114] = ExecuteStateSaveScreenErrFormat_0x271410; // 0x271410 - g_ps2RecompiledFunctionTable[378125] = ExecuteStateSaveScreenErrFormat_0x271410; // 0x27143c - g_ps2RecompiledFunctionTable[378128] = ExecuteStateSaveScreenErrFormat_0x271410; // 0x271448 - g_ps2RecompiledFunctionTable[378139] = ExecuteStateSaveScreenErrFormat_0x271410; // 0x271474 - g_ps2RecompiledFunctionTable[378142] = SetStateSaveScreenErrDer_0x271480; // 0x271480 - g_ps2RecompiledFunctionTable[378150] = ExecuteStateSaveScreenErrDer_0x2714a0; // 0x2714a0 - g_ps2RecompiledFunctionTable[378162] = ExecuteStateSaveScreenErrDer_0x2714a0; // 0x2714d0 - g_ps2RecompiledFunctionTable[378165] = ExecuteStateSaveScreenErrDer_0x2714a0; // 0x2714dc - g_ps2RecompiledFunctionTable[378176] = ExecuteStateSaveScreenErrDer_0x2714a0; // 0x271508 - g_ps2RecompiledFunctionTable[378182] = SetDispSelectMessage_0x271520; // 0x271520 - g_ps2RecompiledFunctionTable[378191] = SetDispSelectMessage_0x271520; // 0x271544 - g_ps2RecompiledFunctionTable[378203] = SetDispSelectMessage_0x271520; // 0x271574 - g_ps2RecompiledFunctionTable[378215] = SetDispSelectMessage_0x271520; // 0x2715a4 - g_ps2RecompiledFunctionTable[378227] = SetDispSelectMessage_0x271520; // 0x2715d4 - g_ps2RecompiledFunctionTable[378239] = SetDispSelectMessage_0x271520; // 0x271604 - g_ps2RecompiledFunctionTable[378252] = SetDispSelectMessage_0x271520; // 0x271638 - g_ps2RecompiledFunctionTable[378265] = SetDispSelectMessage_0x271520; // 0x27166c - g_ps2RecompiledFunctionTable[378271] = SetDispSelectMessage_0x271520; // 0x271684 - g_ps2RecompiledFunctionTable[378274] = CheckDispMemoryCard_0x271690; // 0x271690 - g_ps2RecompiledFunctionTable[378283] = CheckDispMemoryCard_0x271690; // 0x2716b4 - g_ps2RecompiledFunctionTable[378287] = CheckDispMemoryCard_0x271690; // 0x2716c4 - g_ps2RecompiledFunctionTable[378341] = CheckDispMemoryCard_0x271690; // 0x27179c - g_ps2RecompiledFunctionTable[378348] = CheckDispMemoryCard_0x271690; // 0x2717b8 - g_ps2RecompiledFunctionTable[378370] = CheckDispMemoryCard_0x271690; // 0x271810 - g_ps2RecompiledFunctionTable[378378] = mcSelectFileInfoInit_0x271830; // 0x271830 - g_ps2RecompiledFunctionTable[378394] = mcCreateSaveFileInit_0x271870; // 0x271870 - g_ps2RecompiledFunctionTable[378406] = mcCreateConfigInit_0x2718a0; // 0x2718a0 - g_ps2RecompiledFunctionTable[378438] = mcGetSaveFileCapacitySize_0x271920; // 0x271920 - g_ps2RecompiledFunctionTable[378442] = mcReadStartSaveFile_0x271930; // 0x271930 - g_ps2RecompiledFunctionTable[378462] = mcCheckReadStartSaveFile_0x271980; // 0x271980 - g_ps2RecompiledFunctionTable[378514] = mcWriteStartSaveFile_0x271a50; // 0x271a50 - g_ps2RecompiledFunctionTable[378618] = mcCheckWriteStartSaveFile_0x271bf0; // 0x271bf0 - g_ps2RecompiledFunctionTable[378642] = mcNewCreateSaveFile_0x271c50; // 0x271c50 - g_ps2RecompiledFunctionTable[378674] = mcGetConfigCapacitySize_0x271cd0; // 0x271cd0 - g_ps2RecompiledFunctionTable[378678] = mcReadStartConfigFile_0x271ce0; // 0x271ce0 - g_ps2RecompiledFunctionTable[378694] = mcCheckReadStartConfigFile_0x271d20; // 0x271d20 - g_ps2RecompiledFunctionTable[378730] = mcWriteStartConfigFile_0x271db0; // 0x271db0 - g_ps2RecompiledFunctionTable[378770] = mcCheckWriteStartConfigFile_0x271e50; // 0x271e50 - g_ps2RecompiledFunctionTable[378790] = mcNewCreateConfigFile_0x271ea0; // 0x271ea0 - g_ps2RecompiledFunctionTable[378814] = mcCreateIconInit_0x271f00; // 0x271f00 - g_ps2RecompiledFunctionTable[378874] = mcGetIconCapacitySize_0x271ff0; // 0x271ff0 - g_ps2RecompiledFunctionTable[378878] = mcGetIconFileCapacitySize_0x272000; // 0x272000 - g_ps2RecompiledFunctionTable[378882] = mcNewCreateIcon_0x272010; // 0x272010 - g_ps2RecompiledFunctionTable[378902] = mcReadIconData_0x272060; // 0x272060 - g_ps2RecompiledFunctionTable[378950] = mcWriteIconData_0x272120; // 0x272120 - g_ps2RecompiledFunctionTable[378966] = mcGetFreeCapacitySize_0x272160; // 0x272160 - g_ps2RecompiledFunctionTable[378994] = mcGetPortSelectDirInfo_0x2721d0; // 0x2721d0 - g_ps2RecompiledFunctionTable[379034] = mcSelectSaveFileCheck_0x272270; // 0x272270 - g_ps2RecompiledFunctionTable[379066] = mcCreateFileSelectWindow_0x2722f0; // 0x2722f0 - g_ps2RecompiledFunctionTable[379086] = mcSetFileSelectWindowCursolInit_0x272340; // 0x272340 - g_ps2RecompiledFunctionTable[379090] = mcSetFileSelectWindowCursol_0x272350; // 0x272350 - g_ps2RecompiledFunctionTable[379118] = mcGetFileSelectWindowCursol_0x2723c0; // 0x2723c0 - g_ps2RecompiledFunctionTable[379122] = mcDisplayFileSelectWindow_0x2723d0; // 0x2723d0 - g_ps2RecompiledFunctionTable[379290] = mcMoveFileSelectWindowCursor_0x272670; // 0x272670 - g_ps2RecompiledFunctionTable[379326] = mcDisplaySelectFileInfo_0x272700; // 0x272700 - g_ps2RecompiledFunctionTable[379342] = mcDisplaySelectFileInfoMesCount_0x272740; // 0x272740 - g_ps2RecompiledFunctionTable[379574] = mcCallMessageTypeSe_0x272ae0; // 0x272ae0 - g_ps2RecompiledFunctionTable[379634] = mcDispFileNumber_0x272bd0; // 0x272bd0 - g_ps2RecompiledFunctionTable[379718] = mcDispFileName_0x272d20; // 0x272d20 - g_ps2RecompiledFunctionTable[379850] = mcSetTyepWriteMode_0x272f30; // 0x272f30 - g_ps2RecompiledFunctionTable[379854] = mcSetStringSaveFile_0x272f40; // 0x272f40 - g_ps2RecompiledFunctionTable[379866] = mcGetStringEnd_0x272f70; // 0x272f70 - g_ps2RecompiledFunctionTable[379882] = mcDispWindowCurSol_0x272fb0; // 0x272fb0 - g_ps2RecompiledFunctionTable[379894] = DispCursolTexture_0x272fe0; // 0x272fe0 - g_ps2RecompiledFunctionTable[379907] = DispCursolTexture_0x272fe0; // 0x273014 - g_ps2RecompiledFunctionTable[379909] = DispCursolTexture_0x272fe0; // 0x27301c - g_ps2RecompiledFunctionTable[379935] = DispCursolTexture_0x272fe0; // 0x273084 - g_ps2RecompiledFunctionTable[379940] = DispCursolTexture_0x272fe0; // 0x273098 - g_ps2RecompiledFunctionTable[379942] = DispCursolTexture_0x272fe0; // 0x2730a0 - g_ps2RecompiledFunctionTable[379950] = DispUpDownCursol_0x2730c0; // 0x2730c0 - g_ps2RecompiledFunctionTable[380091] = DispUpDownCursol_0x2730c0; // 0x2732f4 - g_ps2RecompiledFunctionTable[380094] = DispBackGroundTexture_0x273300; // 0x273300 - g_ps2RecompiledFunctionTable[380102] = DispBackGroundTexture_0x273300; // 0x273320 - g_ps2RecompiledFunctionTable[380104] = DispBackGroundTexture_0x273300; // 0x273328 - g_ps2RecompiledFunctionTable[380121] = DispBackGroundTexture_0x273300; // 0x27336c - g_ps2RecompiledFunctionTable[380126] = DispBackGroundTexture_0x273300; // 0x273380 - g_ps2RecompiledFunctionTable[380146] = DispBackGroundTexture_0x273300; // 0x2733d0 - g_ps2RecompiledFunctionTable[380151] = DispBackGroundTexture_0x273300; // 0x2733e4 - g_ps2RecompiledFunctionTable[380153] = DispBackGroundTexture_0x273300; // 0x2733ec - g_ps2RecompiledFunctionTable[380158] = DispMemoryCardTexture_0x273400; // 0x273400 - g_ps2RecompiledFunctionTable[380173] = DispMemoryCardTexture_0x273400; // 0x27343c - g_ps2RecompiledFunctionTable[380178] = DispMemoryCardTexture_0x273400; // 0x273450 - g_ps2RecompiledFunctionTable[380183] = DispMemoryCardTexture_0x273400; // 0x273464 - g_ps2RecompiledFunctionTable[380218] = DispMemoryCardTexture_0x273400; // 0x2734f0 - g_ps2RecompiledFunctionTable[380223] = DispMemoryCardTexture_0x273400; // 0x273504 - g_ps2RecompiledFunctionTable[380225] = DispMemoryCardTexture_0x273400; // 0x27350c - g_ps2RecompiledFunctionTable[380234] = mcDispWindowFoundtion_0x273530; // 0x273530 - g_ps2RecompiledFunctionTable[380266] = CreateMemoryCard_0x2735b0; // 0x2735b0 - g_ps2RecompiledFunctionTable[380286] = CreateMemoryCard_0x2735b0; // 0x273600 - g_ps2RecompiledFunctionTable[380290] = CreateMemoryCard_0x2735b0; // 0x273610 - g_ps2RecompiledFunctionTable[380298] = ExecuteMemoryCard_0x273630; // 0x273630 - g_ps2RecompiledFunctionTable[380330] = ExecuteMemoryCard_0x273630; // 0x2736b0 - g_ps2RecompiledFunctionTable[380334] = ExecuteMemoryCard_0x273630; // 0x2736c0 - g_ps2RecompiledFunctionTable[380338] = ExecuteMemoryCard_0x273630; // 0x2736d0 - g_ps2RecompiledFunctionTable[380342] = ExecuteMemoryCard_0x273630; // 0x2736e0 - g_ps2RecompiledFunctionTable[380346] = ExecuteMemoryCard_0x273630; // 0x2736f0 - g_ps2RecompiledFunctionTable[380350] = ExecuteMemoryCard_0x273630; // 0x273700 - g_ps2RecompiledFunctionTable[380354] = ExecuteMemoryCard_0x273630; // 0x273710 - g_ps2RecompiledFunctionTable[380358] = ExecuteMemoryCardStandby_0x273720; // 0x273720 - g_ps2RecompiledFunctionTable[380368] = ExecuteMemoryCardStandby_0x273720; // 0x273748 - g_ps2RecompiledFunctionTable[380373] = ExecuteMemoryCardStandby_0x273720; // 0x27375c - g_ps2RecompiledFunctionTable[380382] = AnalyzeMemoryCardAll_0x273780; // 0x273780 - g_ps2RecompiledFunctionTable[380394] = ExecuteAnalyzeMemoryCardAll_0x2737b0; // 0x2737b0 - g_ps2RecompiledFunctionTable[380418] = ExecuteAnalyzeMemoryCardAll_0x2737b0; // 0x273810 - g_ps2RecompiledFunctionTable[380440] = ExecuteAnalyzeMemoryCardAll_0x2737b0; // 0x273868 - g_ps2RecompiledFunctionTable[380480] = ExecuteAnalyzeMemoryCardAll_0x2737b0; // 0x273908 - g_ps2RecompiledFunctionTable[380502] = ExecuteAnalyzeMemoryCardAll_0x2737b0; // 0x273960 - g_ps2RecompiledFunctionTable[380542] = RecoveryMemoryCardAnalyzeAllEnd_0x273a00; // 0x273a00 - g_ps2RecompiledFunctionTable[380550] = RecoveryMemoryCardAnalyzeAllEnd_0x273a00; // 0x273a20 - g_ps2RecompiledFunctionTable[380562] = SetCheckMcFlag_0x273a50; // 0x273a50 - g_ps2RecompiledFunctionTable[380570] = ExecuteMemoryCardRead_0x273a70; // 0x273a70 - g_ps2RecompiledFunctionTable[380586] = ExecuteMemoryCardRead_0x273a70; // 0x273ab0 - g_ps2RecompiledFunctionTable[380601] = ExecuteMemoryCardRead_0x273a70; // 0x273aec - g_ps2RecompiledFunctionTable[380614] = ExecuteMemoryCardRead_0x273a70; // 0x273b20 - g_ps2RecompiledFunctionTable[380638] = ExecuteMemoryCardWrite_0x273b80; // 0x273b80 - g_ps2RecompiledFunctionTable[380657] = ExecuteMemoryCardWrite_0x273b80; // 0x273bcc - g_ps2RecompiledFunctionTable[380676] = ExecuteMemoryCardWrite_0x273b80; // 0x273c18 - g_ps2RecompiledFunctionTable[380691] = ExecuteMemoryCardWrite_0x273b80; // 0x273c54 - g_ps2RecompiledFunctionTable[380704] = ExecuteMemoryCardWrite_0x273b80; // 0x273c88 - g_ps2RecompiledFunctionTable[380726] = ExecuteMemoryCardFormat_0x273ce0; // 0x273ce0 - g_ps2RecompiledFunctionTable[380731] = ExecuteMemoryCardFormat_0x273ce0; // 0x273cf4 - g_ps2RecompiledFunctionTable[380754] = ExecuteMemoryCardUnFormat_0x273d50; // 0x273d50 - g_ps2RecompiledFunctionTable[380767] = ExecuteMemoryCardUnFormat_0x273d50; // 0x273d84 - g_ps2RecompiledFunctionTable[380795] = ExecuteMemoryCardUnFormat_0x273d50; // 0x273df4 - g_ps2RecompiledFunctionTable[380818] = ExecuteMemoryCardDelete_0x273e50; // 0x273e50 - g_ps2RecompiledFunctionTable[380831] = ExecuteMemoryCardDelete_0x273e50; // 0x273e84 - g_ps2RecompiledFunctionTable[380860] = ExecuteMemoryCardDelete_0x273e50; // 0x273ef8 - g_ps2RecompiledFunctionTable[380882] = GetMemoryCardError_0x273f50; // 0x273f50 - g_ps2RecompiledFunctionTable[380886] = RecoveryMemoryCardError_0x273f60; // 0x273f60 - g_ps2RecompiledFunctionTable[380890] = SetMemoryCardCurrentPort_0x273f70; // 0x273f70 - g_ps2RecompiledFunctionTable[380894] = GetMemoryCardCurrentPort_0x273f80; // 0x273f80 - g_ps2RecompiledFunctionTable[380898] = SetMemoryCardSelectPortState_0x273f90; // 0x273f90 - g_ps2RecompiledFunctionTable[380902] = SaveMemoryCardSelectPortState_0x273fa0; // 0x273fa0 - g_ps2RecompiledFunctionTable[380910] = CompMemoryCardSelectPortState_0x273fc0; // 0x273fc0 - g_ps2RecompiledFunctionTable[380922] = GetMemoryCardSelectPortState_0x273ff0; // 0x273ff0 - g_ps2RecompiledFunctionTable[380926] = GetMemoryCardFileNumber_0x274000; // 0x274000 - g_ps2RecompiledFunctionTable[380930] = SetMemoryCardFileNumber_0x274010; // 0x274010 - g_ps2RecompiledFunctionTable[380934] = SetMemoryCardCurrentDirectoryAbsolute_0x274020; // 0x274020 - g_ps2RecompiledFunctionTable[380936] = SetMemoryCardCurrentDirectoryAbsolute_0x274020; // 0x274028 - g_ps2RecompiledFunctionTable[380950] = ReadMemoryCard_0x274060; // 0x274060 - g_ps2RecompiledFunctionTable[380970] = ReadMemoryCard_0x274060; // 0x2740b0 - g_ps2RecompiledFunctionTable[380974] = ReadMemoryCard_0x274060; // 0x2740c0 - g_ps2RecompiledFunctionTable[380977] = ReadMemoryCard_0x274060; // 0x2740cc - g_ps2RecompiledFunctionTable[380980] = ReadMemoryCard_0x274060; // 0x2740d8 - g_ps2RecompiledFunctionTable[380998] = RecoveryMemoryCardReadEnd_0x274120; // 0x274120 - g_ps2RecompiledFunctionTable[381006] = RecoveryMemoryCardReadEnd_0x274120; // 0x274140 - g_ps2RecompiledFunctionTable[381018] = WriteMemoryCard_0x274170; // 0x274170 - g_ps2RecompiledFunctionTable[381038] = WriteMemoryCard_0x274170; // 0x2741c0 - g_ps2RecompiledFunctionTable[381042] = WriteMemoryCard_0x274170; // 0x2741d0 - g_ps2RecompiledFunctionTable[381045] = WriteMemoryCard_0x274170; // 0x2741dc - g_ps2RecompiledFunctionTable[381048] = WriteMemoryCard_0x274170; // 0x2741e8 - g_ps2RecompiledFunctionTable[381066] = RecoveryMemoryCardWriteEnd_0x274230; // 0x274230 - g_ps2RecompiledFunctionTable[381074] = RecoveryMemoryCardWriteEnd_0x274230; // 0x274250 - g_ps2RecompiledFunctionTable[381086] = FormatMemoryCard_0x274280; // 0x274280 - g_ps2RecompiledFunctionTable[381098] = RecoveryMemoryCardFormatEnd_0x2742b0; // 0x2742b0 - g_ps2RecompiledFunctionTable[381106] = RecoveryMemoryCardFormatEnd_0x2742b0; // 0x2742d0 - g_ps2RecompiledFunctionTable[381118] = GetMcSelectPortType_0x274300; // 0x274300 - g_ps2RecompiledFunctionTable[381131] = GetMcSelectPortType_0x274300; // 0x274334 - g_ps2RecompiledFunctionTable[381138] = GetMcSelectPortType_0x274300; // 0x274350 - g_ps2RecompiledFunctionTable[381146] = GetMcSelectPortType_0x274300; // 0x274370 - g_ps2RecompiledFunctionTable[381158] = CheckMemoryCardChangeConnectTypeAll_0x2743a0; // 0x2743a0 - g_ps2RecompiledFunctionTable[381173] = CheckMemoryCardChangeConnectTypeAll_0x2743a0; // 0x2743dc - g_ps2RecompiledFunctionTable[381175] = CheckMemoryCardChangeConnectTypeAll_0x2743a0; // 0x2743e4 - g_ps2RecompiledFunctionTable[381179] = CheckMemoryCardChangeConnectTypeAll_0x2743a0; // 0x2743f4 - g_ps2RecompiledFunctionTable[381186] = CheckMemoryCardChangeConnectTypeAll_0x2743a0; // 0x274410 - g_ps2RecompiledFunctionTable[381189] = CheckMemoryCardChangeConnectTypeAll_0x2743a0; // 0x27441c - g_ps2RecompiledFunctionTable[381192] = CheckMemoryCardChangeConnectTypeAll_0x2743a0; // 0x274428 - g_ps2RecompiledFunctionTable[381197] = CheckMemoryCardChangeConnectTypeAll_0x2743a0; // 0x27443c - g_ps2RecompiledFunctionTable[381201] = CheckMemoryCardChangeConnectTypeAll_0x2743a0; // 0x27444c - g_ps2RecompiledFunctionTable[381206] = CheckMemoryCardChangeConnectTypeAll_0x2743a0; // 0x274460 - g_ps2RecompiledFunctionTable[381238] = SetMemoryCardFreeCapacity_0x2744e0; // 0x2744e0 - g_ps2RecompiledFunctionTable[381250] = GetMemoryCardFreeCapacity_0x274510; // 0x274510 - g_ps2RecompiledFunctionTable[381260] = GetMemoryCardFreeCapacity_0x274510; // 0x274538 - g_ps2RecompiledFunctionTable[381265] = GetMemoryCardFreeCapacity_0x274510; // 0x27454c - g_ps2RecompiledFunctionTable[381278] = GetMemoryCardSelectPortFreeCapacity_0x274580; // 0x274580 - g_ps2RecompiledFunctionTable[381282] = CheckMemoryCardFormatStatus_0x274590; // 0x274590 - g_ps2RecompiledFunctionTable[381291] = CheckMemoryCardFormatStatus_0x274590; // 0x2745b4 - g_ps2RecompiledFunctionTable[381306] = CreateMemoryCardSubDirectory_0x2745f0; // 0x2745f0 - g_ps2RecompiledFunctionTable[381316] = CreateMemoryCardSubDirectory_0x2745f0; // 0x274618 - g_ps2RecompiledFunctionTable[381330] = CheckMemoryCardExistSubDirectory_0x274650; // 0x274650 - g_ps2RecompiledFunctionTable[381342] = CheckMemoryCardExistSubDirectory_0x274650; // 0x274680 - g_ps2RecompiledFunctionTable[381346] = CheckMemoryCardExistSubDirectory_0x274650; // 0x274690 - g_ps2RecompiledFunctionTable[381350] = CheckMemoryCardExistFile_0x2746a0; // 0x2746a0 - g_ps2RecompiledFunctionTable[381360] = CheckMemoryCardExistFile_0x2746a0; // 0x2746c8 - g_ps2RecompiledFunctionTable[381368] = CheckMemoryCardExistFile_0x2746a0; // 0x2746e8 - g_ps2RecompiledFunctionTable[381382] = CheckMemoryCardExistFileList_0x274720; // 0x274720 - g_ps2RecompiledFunctionTable[381403] = CheckMemoryCardExistFileList_0x274720; // 0x274774 - g_ps2RecompiledFunctionTable[381407] = CheckMemoryCardExistFileList_0x274720; // 0x274784 - g_ps2RecompiledFunctionTable[381414] = CheckMemoryCardExistFileList_0x274720; // 0x2747a0 - g_ps2RecompiledFunctionTable[381424] = CheckMemoryCardExistFileList_0x274720; // 0x2747c8 - g_ps2RecompiledFunctionTable[381427] = CheckMemoryCardExistFileList_0x274720; // 0x2747d4 - g_ps2RecompiledFunctionTable[381430] = CheckMemoryCardExistFileList_0x274720; // 0x2747e0 - g_ps2RecompiledFunctionTable[381466] = MemoryCardGetSum_0x274870; // 0x274870 - g_ps2RecompiledFunctionTable[381468] = MemoryCardGetSum_0x274870; // 0x274878 - g_ps2RecompiledFunctionTable[381478] = GetMemoryCardSelectPortFormatType_0x2748a0; // 0x2748a0 - g_ps2RecompiledFunctionTable[381482] = CheckMcSelectPortInfoType_0x2748b0; // 0x2748b0 - g_ps2RecompiledFunctionTable[381489] = CheckMcSelectPortInfoType_0x2748b0; // 0x2748cc - g_ps2RecompiledFunctionTable[381494] = CheckMcSelectPortInfoType_0x2748b0; // 0x2748e0 - g_ps2RecompiledFunctionTable[381500] = CheckMcSelectPortInfoType_0x2748b0; // 0x2748f8 - g_ps2RecompiledFunctionTable[381518] = CheckMemoryCardInfoFree_0x274940; // 0x274940 - g_ps2RecompiledFunctionTable[381524] = CheckMemoryCardInfoFree_0x274940; // 0x274958 - g_ps2RecompiledFunctionTable[381530] = CheckMemoryCardInfoFree_0x274940; // 0x274970 - g_ps2RecompiledFunctionTable[381536] = CheckMemoryCardInfoFree_0x274940; // 0x274988 - g_ps2RecompiledFunctionTable[381566] = CheckMcSelectPortInfoState_0x274a00; // 0x274a00 - g_ps2RecompiledFunctionTable[381573] = CheckMcSelectPortInfoState_0x274a00; // 0x274a1c - g_ps2RecompiledFunctionTable[381578] = CheckMcSelectPortInfoState_0x274a00; // 0x274a30 - g_ps2RecompiledFunctionTable[381584] = CheckMcSelectPortInfoState_0x274a00; // 0x274a48 - g_ps2RecompiledFunctionTable[381610] = CheckMemoryCardInfoUnformat_0x274ab0; // 0x274ab0 - g_ps2RecompiledFunctionTable[381616] = CheckMemoryCardInfoUnformat_0x274ab0; // 0x274ac8 - g_ps2RecompiledFunctionTable[381622] = CheckMemoryCardInfoUnformat_0x274ab0; // 0x274ae0 - g_ps2RecompiledFunctionTable[381628] = CheckMemoryCardInfoUnformat_0x274ab0; // 0x274af8 - g_ps2RecompiledFunctionTable[381658] = GetMemoryCardDir_0x274b70; // 0x274b70 - g_ps2RecompiledFunctionTable[381672] = GetMemoryCardDir_0x274b70; // 0x274ba8 - g_ps2RecompiledFunctionTable[381679] = GetMemoryCardDir_0x274b70; // 0x274bc4 - g_ps2RecompiledFunctionTable[381685] = GetMemoryCardDir_0x274b70; // 0x274bdc - g_ps2RecompiledFunctionTable[381714] = ChangeMemoryCardDir_0x274c50; // 0x274c50 - g_ps2RecompiledFunctionTable[381724] = ChangeMemoryCardDir_0x274c50; // 0x274c78 - g_ps2RecompiledFunctionTable[381729] = ChangeMemoryCardDir_0x274c50; // 0x274c8c - g_ps2RecompiledFunctionTable[381735] = ChangeMemoryCardDir_0x274c50; // 0x274ca4 - g_ps2RecompiledFunctionTable[381758] = MakeMemoryCardDir_0x274d00; // 0x274d00 - g_ps2RecompiledFunctionTable[381764] = MakeMemoryCardDir_0x274d00; // 0x274d18 - g_ps2RecompiledFunctionTable[381768] = MakeMemoryCardDir_0x274d00; // 0x274d28 - g_ps2RecompiledFunctionTable[381774] = MakeMemoryCardDir_0x274d00; // 0x274d40 - g_ps2RecompiledFunctionTable[381794] = MemoryCardFormat_0x274d90; // 0x274d90 - g_ps2RecompiledFunctionTable[381809] = MemoryCardFormat_0x274d90; // 0x274dcc - g_ps2RecompiledFunctionTable[381830] = MemoryCardFormat_0x274d90; // 0x274e20 - g_ps2RecompiledFunctionTable[381854] = MemoryCardUnFormat_0x274e80; // 0x274e80 - g_ps2RecompiledFunctionTable[381858] = DeleteMemoryCard_0x274e90; // 0x274e90 - g_ps2RecompiledFunctionTable[381862] = MemoryCardFileOpen_0x274ea0; // 0x274ea0 - g_ps2RecompiledFunctionTable[381879] = MemoryCardFileOpen_0x274ea0; // 0x274ee4 - g_ps2RecompiledFunctionTable[381900] = MemoryCardFileOpen_0x274ea0; // 0x274f38 - g_ps2RecompiledFunctionTable[381926] = MemoryCardFileClose_0x274fa0; // 0x274fa0 - g_ps2RecompiledFunctionTable[381940] = MemoryCardFileClose_0x274fa0; // 0x274fd8 - g_ps2RecompiledFunctionTable[381972] = MemoryCardFileClose_0x274fa0; // 0x275058 - g_ps2RecompiledFunctionTable[382002] = MemoryCardFileRead_0x2750d0; // 0x2750d0 - g_ps2RecompiledFunctionTable[382018] = MemoryCardFileRead_0x2750d0; // 0x275110 - g_ps2RecompiledFunctionTable[382050] = MemoryCardFileRead_0x2750d0; // 0x275190 - g_ps2RecompiledFunctionTable[382078] = MemoryCardFileWrite_0x275200; // 0x275200 - g_ps2RecompiledFunctionTable[382094] = MemoryCardFileWrite_0x275200; // 0x275240 - g_ps2RecompiledFunctionTable[382126] = MemoryCardFileWrite_0x275200; // 0x2752c0 - g_ps2RecompiledFunctionTable[382158] = CreateLoadScreen_0x275340; // 0x275340 - g_ps2RecompiledFunctionTable[382178] = CreateLoadScreen_0x275340; // 0x275390 - g_ps2RecompiledFunctionTable[382182] = CreateLoadScreen_0x275340; // 0x2753a0 - g_ps2RecompiledFunctionTable[382186] = CreateLoadScreen_0x275340; // 0x2753b0 - g_ps2RecompiledFunctionTable[382193] = CreateLoadScreen_0x275340; // 0x2753cc - g_ps2RecompiledFunctionTable[382197] = CreateLoadScreen_0x275340; // 0x2753dc - g_ps2RecompiledFunctionTable[382203] = CreateLoadScreen_0x275340; // 0x2753f4 - g_ps2RecompiledFunctionTable[382206] = CreateLoadScreen_0x275340; // 0x275400 - g_ps2RecompiledFunctionTable[382214] = DispLoadMessageSelect_0x275420; // 0x275420 - g_ps2RecompiledFunctionTable[382225] = DispLoadMessageSelect_0x275420; // 0x27544c - g_ps2RecompiledFunctionTable[382239] = DispLoadMessageSelect_0x275420; // 0x275484 - g_ps2RecompiledFunctionTable[382252] = DispLoadMessageSelect_0x275420; // 0x2754b8 - g_ps2RecompiledFunctionTable[382254] = DispLoadMessageSelect_0x275420; // 0x2754c0 - g_ps2RecompiledFunctionTable[382267] = DispLoadMessageSelect_0x275420; // 0x2754f4 - g_ps2RecompiledFunctionTable[382280] = DispLoadMessageSelect_0x275420; // 0x275528 - g_ps2RecompiledFunctionTable[382294] = DispLoadMessageSelect_0x275420; // 0x275560 - g_ps2RecompiledFunctionTable[382308] = DispLoadMessageSelect_0x275420; // 0x275598 - g_ps2RecompiledFunctionTable[382319] = DispLoadMessageSelect_0x275420; // 0x2755c4 - g_ps2RecompiledFunctionTable[382333] = DispLoadMessageSelect_0x275420; // 0x2755fc - g_ps2RecompiledFunctionTable[382346] = DispLoadMessageSelect_0x275420; // 0x275630 - g_ps2RecompiledFunctionTable[382359] = DispLoadMessageSelect_0x275420; // 0x275664 - g_ps2RecompiledFunctionTable[382372] = DispLoadMessageSelect_0x275420; // 0x275698 - g_ps2RecompiledFunctionTable[382378] = DispLoadMessageSelect_0x275420; // 0x2756b0 - g_ps2RecompiledFunctionTable[382382] = DispLoadTexture_0x2756c0; // 0x2756c0 - g_ps2RecompiledFunctionTable[382398] = DispLoadTexture_0x2756c0; // 0x275700 - g_ps2RecompiledFunctionTable[382402] = DispLoadTexture_0x2756c0; // 0x275710 - g_ps2RecompiledFunctionTable[382409] = DispLoadTexture_0x2756c0; // 0x27572c - g_ps2RecompiledFunctionTable[382413] = DispLoadTexture_0x2756c0; // 0x27573c - g_ps2RecompiledFunctionTable[382420] = DispLoadTexture_0x2756c0; // 0x275758 - g_ps2RecompiledFunctionTable[382427] = DispLoadTexture_0x2756c0; // 0x275774 - g_ps2RecompiledFunctionTable[382434] = ExecuteLoadScreen_0x275790; // 0x275790 - g_ps2RecompiledFunctionTable[382440] = ExecuteLoadScreen_0x275790; // 0x2757a8 - g_ps2RecompiledFunctionTable[382442] = ExecuteLoadScreen_0x275790; // 0x2757b0 - g_ps2RecompiledFunctionTable[382495] = ExecuteLoadScreen_0x275790; // 0x275884 - g_ps2RecompiledFunctionTable[382500] = ExecuteLoadScreen_0x275790; // 0x275898 - g_ps2RecompiledFunctionTable[382505] = ExecuteLoadScreen_0x275790; // 0x2758ac - g_ps2RecompiledFunctionTable[382510] = ExecuteLoadScreen_0x275790; // 0x2758c0 - g_ps2RecompiledFunctionTable[382515] = ExecuteLoadScreen_0x275790; // 0x2758d4 - g_ps2RecompiledFunctionTable[382520] = ExecuteLoadScreen_0x275790; // 0x2758e8 - g_ps2RecompiledFunctionTable[382525] = ExecuteLoadScreen_0x275790; // 0x2758fc - g_ps2RecompiledFunctionTable[382530] = ExecuteLoadScreen_0x275790; // 0x275910 - g_ps2RecompiledFunctionTable[382535] = ExecuteLoadScreen_0x275790; // 0x275924 - g_ps2RecompiledFunctionTable[382540] = ExecuteLoadScreen_0x275790; // 0x275938 - g_ps2RecompiledFunctionTable[382545] = ExecuteLoadScreen_0x275790; // 0x27594c - g_ps2RecompiledFunctionTable[382550] = ExecuteLoadScreen_0x275790; // 0x275960 - g_ps2RecompiledFunctionTable[382555] = ExecuteLoadScreen_0x275790; // 0x275974 - g_ps2RecompiledFunctionTable[382560] = ExecuteLoadScreen_0x275790; // 0x275988 - g_ps2RecompiledFunctionTable[382565] = ExecuteLoadScreen_0x275790; // 0x27599c - g_ps2RecompiledFunctionTable[382570] = ExecuteLoadScreen_0x275790; // 0x2759b0 - g_ps2RecompiledFunctionTable[382573] = ExecuteLoadScreen_0x275790; // 0x2759bc - g_ps2RecompiledFunctionTable[382575] = ExecuteLoadScreen_0x275790; // 0x2759c4 - g_ps2RecompiledFunctionTable[382582] = SetStateLoadScreenAwarenessCard_0x2759e0; // 0x2759e0 - g_ps2RecompiledFunctionTable[382590] = ExecuteStateLoadScreenAwarenessCard_0x275a00; // 0x275a00 - g_ps2RecompiledFunctionTable[382612] = ExecuteStateLoadScreenAwarenessCard_0x275a00; // 0x275a58 - g_ps2RecompiledFunctionTable[382616] = ExecuteStateLoadScreenAwarenessCard_0x275a00; // 0x275a68 - g_ps2RecompiledFunctionTable[382624] = ExecuteStateLoadScreenAwarenessCard_0x275a00; // 0x275a88 - g_ps2RecompiledFunctionTable[382638] = ExecuteStateLoadScreenAwarenessCard_0x275a00; // 0x275ac0 - g_ps2RecompiledFunctionTable[382643] = ExecuteStateLoadScreenAwarenessCard_0x275a00; // 0x275ad4 - g_ps2RecompiledFunctionTable[382647] = ExecuteStateLoadScreenAwarenessCard_0x275a00; // 0x275ae4 - g_ps2RecompiledFunctionTable[382651] = ExecuteStateLoadScreenAwarenessCard_0x275a00; // 0x275af4 - g_ps2RecompiledFunctionTable[382655] = ExecuteStateLoadScreenAwarenessCard_0x275a00; // 0x275b04 - g_ps2RecompiledFunctionTable[382662] = SetStateLoadScreenErrLostCard_0x275b20; // 0x275b20 - g_ps2RecompiledFunctionTable[382670] = ExecuteStateLoadScreenErrLostCard_0x275b40; // 0x275b40 - g_ps2RecompiledFunctionTable[382684] = ExecuteStateLoadScreenErrLostCard_0x275b40; // 0x275b78 - g_ps2RecompiledFunctionTable[382687] = ExecuteStateLoadScreenErrLostCard_0x275b40; // 0x275b84 - g_ps2RecompiledFunctionTable[382704] = ExecuteStateLoadScreenErrLostCard_0x275b40; // 0x275bc8 - g_ps2RecompiledFunctionTable[382708] = ExecuteStateLoadScreenErrLostCard_0x275b40; // 0x275bd8 - g_ps2RecompiledFunctionTable[382716] = ExecuteStateLoadScreenErrLostCard_0x275b40; // 0x275bf8 - g_ps2RecompiledFunctionTable[382730] = ExecuteStateLoadScreenErrLostCard_0x275b40; // 0x275c30 - g_ps2RecompiledFunctionTable[382734] = ExecuteStateLoadScreenErrLostCard_0x275b40; // 0x275c40 - g_ps2RecompiledFunctionTable[382738] = ExecuteStateLoadScreenErrLostCard_0x275b40; // 0x275c50 - g_ps2RecompiledFunctionTable[382746] = SetStateLoadScreenErrUnPS2MemCard_0x275c70; // 0x275c70 - g_ps2RecompiledFunctionTable[382754] = ExecuteStateLoadScreenErrUnPS2MemCard_0x275c90; // 0x275c90 - g_ps2RecompiledFunctionTable[382768] = ExecuteStateLoadScreenErrUnPS2MemCard_0x275c90; // 0x275cc8 - g_ps2RecompiledFunctionTable[382771] = ExecuteStateLoadScreenErrUnPS2MemCard_0x275c90; // 0x275cd4 - g_ps2RecompiledFunctionTable[382788] = ExecuteStateLoadScreenErrUnPS2MemCard_0x275c90; // 0x275d18 - g_ps2RecompiledFunctionTable[382792] = ExecuteStateLoadScreenErrUnPS2MemCard_0x275c90; // 0x275d28 - g_ps2RecompiledFunctionTable[382800] = ExecuteStateLoadScreenErrUnPS2MemCard_0x275c90; // 0x275d48 - g_ps2RecompiledFunctionTable[382808] = ExecuteStateLoadScreenErrUnPS2MemCard_0x275c90; // 0x275d68 - g_ps2RecompiledFunctionTable[382812] = ExecuteStateLoadScreenErrUnPS2MemCard_0x275c90; // 0x275d78 - g_ps2RecompiledFunctionTable[382816] = ExecuteStateLoadScreenErrUnPS2MemCard_0x275c90; // 0x275d88 - g_ps2RecompiledFunctionTable[382822] = SetStateLoadScreenSelectCard_0x275da0; // 0x275da0 - g_ps2RecompiledFunctionTable[382835] = SetStateLoadScreenSelectCard_0x275da0; // 0x275dd4 - g_ps2RecompiledFunctionTable[382837] = SetStateLoadScreenSelectCard_0x275da0; // 0x275ddc - g_ps2RecompiledFunctionTable[382842] = ExecuteStateLoadScreenSelectCard_0x275df0; // 0x275df0 - g_ps2RecompiledFunctionTable[382860] = ExecuteStateLoadScreenSelectCard_0x275df0; // 0x275e38 - g_ps2RecompiledFunctionTable[382871] = ExecuteStateLoadScreenSelectCard_0x275df0; // 0x275e64 - g_ps2RecompiledFunctionTable[382880] = ExecuteStateLoadScreenSelectCard_0x275df0; // 0x275e88 - g_ps2RecompiledFunctionTable[382886] = ExecuteStateLoadScreenSelectCard_0x275df0; // 0x275ea0 - g_ps2RecompiledFunctionTable[382902] = ExecuteStateLoadScreenSelectCard_0x275df0; // 0x275ee0 - g_ps2RecompiledFunctionTable[382912] = ExecuteStateLoadScreenSelectCard_0x275df0; // 0x275f08 - g_ps2RecompiledFunctionTable[382931] = ExecuteStateLoadScreenSelectCard_0x275df0; // 0x275f54 - g_ps2RecompiledFunctionTable[382936] = ExecuteStateLoadScreenSelectCard_0x275df0; // 0x275f68 - g_ps2RecompiledFunctionTable[382939] = ExecuteStateLoadScreenSelectCard_0x275df0; // 0x275f74 - g_ps2RecompiledFunctionTable[382946] = ExecuteStateLoadScreenSelectCard_0x275df0; // 0x275f90 - g_ps2RecompiledFunctionTable[382949] = ExecuteStateLoadScreenSelectCard_0x275df0; // 0x275f9c - g_ps2RecompiledFunctionTable[382960] = ExecuteStateLoadScreenSelectCard_0x275df0; // 0x275fc8 - g_ps2RecompiledFunctionTable[382966] = SetStateLoadScreenTitleExit_0x275fe0; // 0x275fe0 - g_ps2RecompiledFunctionTable[382974] = ExecuteStateLoadScreenTitleExit_0x276000; // 0x276000 - g_ps2RecompiledFunctionTable[382982] = SetStateLoadScreenErrUnFormat_0x276020; // 0x276020 - g_ps2RecompiledFunctionTable[382994] = ExecuteStateLoadScreenErrUnFormat_0x276050; // 0x276050 - g_ps2RecompiledFunctionTable[383006] = ExecuteStateLoadScreenErrUnFormat_0x276050; // 0x276080 - g_ps2RecompiledFunctionTable[383009] = ExecuteStateLoadScreenErrUnFormat_0x276050; // 0x27608c - g_ps2RecompiledFunctionTable[383020] = ExecuteStateLoadScreenErrUnFormat_0x276050; // 0x2760b8 - g_ps2RecompiledFunctionTable[383026] = SetStateLoadScreenErrLostDirCheck_0x2760d0; // 0x2760d0 - g_ps2RecompiledFunctionTable[383034] = ExecuteStateLoadScreenErrLostDirCheck_0x2760f0; // 0x2760f0 - g_ps2RecompiledFunctionTable[383046] = ExecuteStateLoadScreenErrLostDirCheck_0x2760f0; // 0x276120 - g_ps2RecompiledFunctionTable[383049] = ExecuteStateLoadScreenErrLostDirCheck_0x2760f0; // 0x27612c - g_ps2RecompiledFunctionTable[383060] = ExecuteStateLoadScreenErrLostDirCheck_0x2760f0; // 0x276158 - g_ps2RecompiledFunctionTable[383066] = SetStateLoadScreenDirCheck_0x276170; // 0x276170 - g_ps2RecompiledFunctionTable[383083] = SetStateLoadScreenDirCheck_0x276170; // 0x2761b4 - g_ps2RecompiledFunctionTable[383086] = SetStateLoadScreenDirCheck_0x276170; // 0x2761c0 - g_ps2RecompiledFunctionTable[383089] = SetStateLoadScreenDirCheck_0x276170; // 0x2761cc - g_ps2RecompiledFunctionTable[383094] = ExecuteStateLoadScreenDirCheck_0x2761e0; // 0x2761e0 - g_ps2RecompiledFunctionTable[383110] = ExecuteStateLoadScreenDirCheck_0x2761e0; // 0x276220 - g_ps2RecompiledFunctionTable[383119] = ExecuteStateLoadScreenDirCheck_0x2761e0; // 0x276244 - g_ps2RecompiledFunctionTable[383130] = ExecuteStateLoadScreenDirCheck_0x2761e0; // 0x276270 - g_ps2RecompiledFunctionTable[383132] = ExecuteStateLoadScreenDirCheck_0x2761e0; // 0x276278 - g_ps2RecompiledFunctionTable[383137] = ExecuteStateLoadScreenDirCheck_0x2761e0; // 0x27628c - g_ps2RecompiledFunctionTable[383148] = ExecuteStateLoadScreenDirCheck_0x2761e0; // 0x2762b8 - g_ps2RecompiledFunctionTable[383156] = ExecuteStateLoadScreenDirCheck_0x2761e0; // 0x2762d8 - g_ps2RecompiledFunctionTable[383163] = ExecuteStateLoadScreenDirCheck_0x2761e0; // 0x2762f4 - g_ps2RecompiledFunctionTable[383165] = ExecuteStateLoadScreenDirCheck_0x2761e0; // 0x2762fc - g_ps2RecompiledFunctionTable[383177] = ExecuteStateLoadScreenDirCheck_0x2761e0; // 0x27632c - g_ps2RecompiledFunctionTable[383186] = ExecuteStateLoadScreenDirCheck_0x2761e0; // 0x276350 - g_ps2RecompiledFunctionTable[383193] = ExecuteStateLoadScreenDirCheck_0x2761e0; // 0x27636c - g_ps2RecompiledFunctionTable[383202] = ExecuteStateLoadScreenDirCheck_0x2761e0; // 0x276390 - g_ps2RecompiledFunctionTable[383213] = ExecuteStateLoadScreenDirCheck_0x2761e0; // 0x2763bc - g_ps2RecompiledFunctionTable[383215] = ExecuteStateLoadScreenDirCheck_0x2761e0; // 0x2763c4 - g_ps2RecompiledFunctionTable[383223] = ExecuteStateLoadScreenDirCheck_0x2761e0; // 0x2763e4 - g_ps2RecompiledFunctionTable[383231] = ExecuteStateLoadScreenDirCheck_0x2761e0; // 0x276404 - g_ps2RecompiledFunctionTable[383239] = ExecuteStateLoadScreenDirCheck_0x2761e0; // 0x276424 - g_ps2RecompiledFunctionTable[383246] = SetStateLoadScreenDirFileBroken_0x276440; // 0x276440 - g_ps2RecompiledFunctionTable[383254] = ExecuteStateLoadScreenDirFileBroken_0x276460; // 0x276460 - g_ps2RecompiledFunctionTable[383266] = ExecuteStateLoadScreenDirFileBroken_0x276460; // 0x276490 - g_ps2RecompiledFunctionTable[383269] = ExecuteStateLoadScreenDirFileBroken_0x276460; // 0x27649c - g_ps2RecompiledFunctionTable[383280] = ExecuteStateLoadScreenDirFileBroken_0x276460; // 0x2764c8 - g_ps2RecompiledFunctionTable[383286] = SetStateLoadScreenSelectFile_0x2764e0; // 0x2764e0 - g_ps2RecompiledFunctionTable[383299] = SetStateLoadScreenSelectFile_0x2764e0; // 0x276514 - g_ps2RecompiledFunctionTable[383304] = SetStateLoadScreenSelectFile_0x2764e0; // 0x276528 - g_ps2RecompiledFunctionTable[383310] = ExecuteStateLoadScreenSelectFile_0x276540; // 0x276540 - g_ps2RecompiledFunctionTable[383369] = ExecuteStateLoadScreenSelectFile_0x276540; // 0x27662c - g_ps2RecompiledFunctionTable[383372] = ExecuteStateLoadScreenSelectFile_0x276540; // 0x276638 - g_ps2RecompiledFunctionTable[383380] = ExecuteStateLoadScreenSelectFile_0x276540; // 0x276658 - g_ps2RecompiledFunctionTable[383384] = ExecuteStateLoadScreenSelectFile_0x276540; // 0x276668 - g_ps2RecompiledFunctionTable[383389] = ExecuteStateLoadScreenSelectFile_0x276540; // 0x27667c - g_ps2RecompiledFunctionTable[383392] = ExecuteStateLoadScreenSelectFile_0x276540; // 0x276688 - g_ps2RecompiledFunctionTable[383403] = ExecuteStateLoadScreenSelectFile_0x276540; // 0x2766b4 - g_ps2RecompiledFunctionTable[383406] = ExecuteStateLoadScreenSelectFile_0x276540; // 0x2766c0 - g_ps2RecompiledFunctionTable[383414] = ExecuteStateLoadScreenSelectFile_0x276540; // 0x2766e0 - g_ps2RecompiledFunctionTable[383418] = ExecuteStateLoadScreenSelectFile_0x276540; // 0x2766f0 - g_ps2RecompiledFunctionTable[383424] = ExecuteStateLoadScreenSelectFile_0x276540; // 0x276708 - g_ps2RecompiledFunctionTable[383427] = ExecuteStateLoadScreenSelectFile_0x276540; // 0x276714 - g_ps2RecompiledFunctionTable[383434] = ExecuteStateLoadScreenSelectFile_0x276540; // 0x276730 - g_ps2RecompiledFunctionTable[383441] = ExecuteStateLoadScreenSelectFile_0x276540; // 0x27674c - g_ps2RecompiledFunctionTable[383444] = ExecuteStateLoadScreenSelectFile_0x276540; // 0x276758 - g_ps2RecompiledFunctionTable[383453] = ExecuteStateLoadScreenSelectFile_0x276540; // 0x27677c - g_ps2RecompiledFunctionTable[383474] = ExecuteStateLoadScreenSelectFile_0x276540; // 0x2767d0 - g_ps2RecompiledFunctionTable[383480] = ExecuteStateLoadScreenSelectFile_0x276540; // 0x2767e8 - g_ps2RecompiledFunctionTable[383486] = LoadScreenCheckSave_0x276800; // 0x276800 - g_ps2RecompiledFunctionTable[383493] = LoadScreenCheckSave_0x276800; // 0x27681c - g_ps2RecompiledFunctionTable[383496] = LoadScreenCheckSave_0x276800; // 0x276828 - g_ps2RecompiledFunctionTable[383500] = LoadScreenCheckSave_0x276800; // 0x276838 - g_ps2RecompiledFunctionTable[383503] = LoadScreenCheckSave_0x276800; // 0x276844 - g_ps2RecompiledFunctionTable[383508] = LoadScreenCheckSave_0x276800; // 0x276858 - g_ps2RecompiledFunctionTable[383511] = LoadScreenCheckSave_0x276800; // 0x276864 - g_ps2RecompiledFunctionTable[383518] = SetStateLoadScreenNoSave_0x276880; // 0x276880 - g_ps2RecompiledFunctionTable[383526] = ExecuteStateLoadScreenNoSave_0x2768a0; // 0x2768a0 - g_ps2RecompiledFunctionTable[383538] = ExecuteStateLoadScreenNoSave_0x2768a0; // 0x2768d0 - g_ps2RecompiledFunctionTable[383541] = ExecuteStateLoadScreenNoSave_0x2768a0; // 0x2768dc - g_ps2RecompiledFunctionTable[383552] = ExecuteStateLoadScreenNoSave_0x2768a0; // 0x276908 - g_ps2RecompiledFunctionTable[383558] = SetStateLoadScreenLoadCursor_0x276920; // 0x276920 - g_ps2RecompiledFunctionTable[383566] = ExecuteStateLoadScreenLoadCursor_0x276940; // 0x276940 - g_ps2RecompiledFunctionTable[383585] = ExecuteStateLoadScreenLoadCursor_0x276940; // 0x27698c - g_ps2RecompiledFunctionTable[383599] = ExecuteStateLoadScreenLoadCursor_0x276940; // 0x2769c4 - g_ps2RecompiledFunctionTable[383610] = ExecuteStateLoadScreenLoadCursor_0x276940; // 0x2769f0 - g_ps2RecompiledFunctionTable[383613] = ExecuteStateLoadScreenLoadCursor_0x276940; // 0x2769fc - g_ps2RecompiledFunctionTable[383617] = ExecuteStateLoadScreenLoadCursor_0x276940; // 0x276a0c - g_ps2RecompiledFunctionTable[383620] = ExecuteStateLoadScreenLoadCursor_0x276940; // 0x276a18 - g_ps2RecompiledFunctionTable[383627] = ExecuteStateLoadScreenLoadCursor_0x276940; // 0x276a34 - g_ps2RecompiledFunctionTable[383630] = ExecuteStateLoadScreenLoadCursor_0x276940; // 0x276a40 - g_ps2RecompiledFunctionTable[383641] = ExecuteStateLoadScreenLoadCursor_0x276940; // 0x276a6c - g_ps2RecompiledFunctionTable[383646] = SetStateLoadScreenLoad_0x276a80; // 0x276a80 - g_ps2RecompiledFunctionTable[383658] = ExecuteStateLoadScreenLoad_0x276ab0; // 0x276ab0 - g_ps2RecompiledFunctionTable[383677] = ExecuteStateLoadScreenLoad_0x276ab0; // 0x276afc - g_ps2RecompiledFunctionTable[383683] = ExecuteStateLoadScreenLoad_0x276ab0; // 0x276b14 - g_ps2RecompiledFunctionTable[383691] = ExecuteStateLoadScreenLoad_0x276ab0; // 0x276b34 - g_ps2RecompiledFunctionTable[383696] = ExecuteStateLoadScreenLoad_0x276ab0; // 0x276b48 - g_ps2RecompiledFunctionTable[383704] = ExecuteStateLoadScreenLoad_0x276ab0; // 0x276b68 - g_ps2RecompiledFunctionTable[383706] = ExecuteStateLoadScreenLoad_0x276ab0; // 0x276b70 - g_ps2RecompiledFunctionTable[383715] = ExecuteStateLoadScreenLoad_0x276ab0; // 0x276b94 - g_ps2RecompiledFunctionTable[383717] = ExecuteStateLoadScreenLoad_0x276ab0; // 0x276b9c - g_ps2RecompiledFunctionTable[383726] = ExecuteStateLoadScreenLoad_0x276ab0; // 0x276bc0 - g_ps2RecompiledFunctionTable[383734] = ExecuteStateLoadScreenLoad_0x276ab0; // 0x276be0 - g_ps2RecompiledFunctionTable[383738] = SetStateLoadScreenFileBroken_0x276bf0; // 0x276bf0 - g_ps2RecompiledFunctionTable[383746] = ExecuteStateLoadScreenFileBroken_0x276c10; // 0x276c10 - g_ps2RecompiledFunctionTable[383758] = ExecuteStateLoadScreenFileBroken_0x276c10; // 0x276c40 - g_ps2RecompiledFunctionTable[383761] = ExecuteStateLoadScreenFileBroken_0x276c10; // 0x276c4c - g_ps2RecompiledFunctionTable[383772] = ExecuteStateLoadScreenFileBroken_0x276c10; // 0x276c78 - g_ps2RecompiledFunctionTable[383778] = SetStateLoadScreenErrCardRead_0x276c90; // 0x276c90 - g_ps2RecompiledFunctionTable[383786] = ExecuteStateLoadScreenErrCardRead_0x276cb0; // 0x276cb0 - g_ps2RecompiledFunctionTable[383798] = ExecuteStateLoadScreenErrCardRead_0x276cb0; // 0x276ce0 - g_ps2RecompiledFunctionTable[383801] = ExecuteStateLoadScreenErrCardRead_0x276cb0; // 0x276cec - g_ps2RecompiledFunctionTable[383812] = ExecuteStateLoadScreenErrCardRead_0x276cb0; // 0x276d18 - g_ps2RecompiledFunctionTable[383818] = SetStateLoadScreenLoadExit_0x276d30; // 0x276d30 - g_ps2RecompiledFunctionTable[383830] = ExecuteStateLoadScreenLoadExit_0x276d60; // 0x276d60 - g_ps2RecompiledFunctionTable[383841] = ExecuteStateLoadScreenLoadExit_0x276d60; // 0x276d8c - g_ps2RecompiledFunctionTable[383854] = SetDispLoadSelectMessage_0x276dc0; // 0x276dc0 - g_ps2RecompiledFunctionTable[383863] = SetDispLoadSelectMessage_0x276dc0; // 0x276de4 - g_ps2RecompiledFunctionTable[383874] = SetDispLoadSelectMessage_0x276dc0; // 0x276e10 - g_ps2RecompiledFunctionTable[383885] = SetDispLoadSelectMessage_0x276dc0; // 0x276e3c - g_ps2RecompiledFunctionTable[383896] = SetDispLoadSelectMessage_0x276dc0; // 0x276e68 - g_ps2RecompiledFunctionTable[383907] = SetDispLoadSelectMessage_0x276dc0; // 0x276e94 - g_ps2RecompiledFunctionTable[383919] = SetDispLoadSelectMessage_0x276dc0; // 0x276ec4 - g_ps2RecompiledFunctionTable[383931] = SetDispLoadSelectMessage_0x276dc0; // 0x276ef4 - g_ps2RecompiledFunctionTable[383937] = SetDispLoadSelectMessage_0x276dc0; // 0x276f0c - g_ps2RecompiledFunctionTable[383942] = CheckDispLoadMemoryCard_0x276f20; // 0x276f20 - g_ps2RecompiledFunctionTable[383951] = CheckDispLoadMemoryCard_0x276f20; // 0x276f44 - g_ps2RecompiledFunctionTable[383955] = CheckDispLoadMemoryCard_0x276f20; // 0x276f54 - g_ps2RecompiledFunctionTable[384009] = CheckDispLoadMemoryCard_0x276f20; // 0x27702c - g_ps2RecompiledFunctionTable[384016] = CheckDispLoadMemoryCard_0x276f20; // 0x277048 - g_ps2RecompiledFunctionTable[384038] = CheckDispLoadMemoryCard_0x276f20; // 0x2770a0 - g_ps2RecompiledFunctionTable[384046] = CreateSysLoadScreen_0x2770c0; // 0x2770c0 - g_ps2RecompiledFunctionTable[384063] = CreateSysLoadScreen_0x2770c0; // 0x277104 - g_ps2RecompiledFunctionTable[384067] = CreateSysLoadScreen_0x2770c0; // 0x277114 - g_ps2RecompiledFunctionTable[384071] = CreateSysLoadScreen_0x2770c0; // 0x277124 - g_ps2RecompiledFunctionTable[384078] = CreateSysLoadScreen_0x2770c0; // 0x277140 - g_ps2RecompiledFunctionTable[384082] = CreateSysLoadScreen_0x2770c0; // 0x277150 - g_ps2RecompiledFunctionTable[384088] = CreateSysLoadScreen_0x2770c0; // 0x277168 - g_ps2RecompiledFunctionTable[384092] = CreateSysLoadScreen_0x2770c0; // 0x277178 - g_ps2RecompiledFunctionTable[384098] = DispSysLoadMessageSelect_0x277190; // 0x277190 - g_ps2RecompiledFunctionTable[384109] = DispSysLoadMessageSelect_0x277190; // 0x2771bc - g_ps2RecompiledFunctionTable[384127] = DispSysLoadMessageSelect_0x277190; // 0x277204 - g_ps2RecompiledFunctionTable[384137] = DispSysLoadMessageSelect_0x277190; // 0x27722c - g_ps2RecompiledFunctionTable[384147] = DispSysLoadMessageSelect_0x277190; // 0x277254 - g_ps2RecompiledFunctionTable[384157] = DispSysLoadMessageSelect_0x277190; // 0x27727c - g_ps2RecompiledFunctionTable[384167] = DispSysLoadMessageSelect_0x277190; // 0x2772a4 - g_ps2RecompiledFunctionTable[384177] = DispSysLoadMessageSelect_0x277190; // 0x2772cc - g_ps2RecompiledFunctionTable[384187] = DispSysLoadMessageSelect_0x277190; // 0x2772f4 - g_ps2RecompiledFunctionTable[384197] = DispSysLoadMessageSelect_0x277190; // 0x27731c - g_ps2RecompiledFunctionTable[384207] = DispSysLoadMessageSelect_0x277190; // 0x277344 - g_ps2RecompiledFunctionTable[384217] = DispSysLoadMessageSelect_0x277190; // 0x27736c - g_ps2RecompiledFunctionTable[384227] = DispSysLoadMessageSelect_0x277190; // 0x277394 - g_ps2RecompiledFunctionTable[384233] = DispSysLoadMessageSelect_0x277190; // 0x2773ac - g_ps2RecompiledFunctionTable[384238] = ExecuteSysLoadScreen_0x2773c0; // 0x2773c0 - g_ps2RecompiledFunctionTable[384244] = ExecuteSysLoadScreen_0x2773c0; // 0x2773d8 - g_ps2RecompiledFunctionTable[384280] = ExecuteSysLoadScreen_0x2773c0; // 0x277468 - g_ps2RecompiledFunctionTable[384285] = ExecuteSysLoadScreen_0x2773c0; // 0x27747c - g_ps2RecompiledFunctionTable[384290] = ExecuteSysLoadScreen_0x2773c0; // 0x277490 - g_ps2RecompiledFunctionTable[384295] = ExecuteSysLoadScreen_0x2773c0; // 0x2774a4 - g_ps2RecompiledFunctionTable[384300] = ExecuteSysLoadScreen_0x2773c0; // 0x2774b8 - g_ps2RecompiledFunctionTable[384305] = ExecuteSysLoadScreen_0x2773c0; // 0x2774cc - g_ps2RecompiledFunctionTable[384310] = ExecuteSysLoadScreen_0x2773c0; // 0x2774e0 - g_ps2RecompiledFunctionTable[384315] = ExecuteSysLoadScreen_0x2773c0; // 0x2774f4 - g_ps2RecompiledFunctionTable[384320] = ExecuteSysLoadScreen_0x2773c0; // 0x277508 - g_ps2RecompiledFunctionTable[384324] = ExecuteSysLoadScreen_0x2773c0; // 0x277518 - g_ps2RecompiledFunctionTable[384327] = ExecuteSysLoadScreen_0x2773c0; // 0x277524 - g_ps2RecompiledFunctionTable[384334] = SetStateSysLoadScreenAwarenessCard_0x277540; // 0x277540 - g_ps2RecompiledFunctionTable[384342] = SetStateSysLoadScreenAwarenessCard_0x277540; // 0x277560 - g_ps2RecompiledFunctionTable[384344] = SetStateSysLoadScreenAwarenessCard_0x277540; // 0x277568 - g_ps2RecompiledFunctionTable[384350] = ExecuteStateSysLoadScreenAwarenessCard_0x277580; // 0x277580 - g_ps2RecompiledFunctionTable[384356] = ExecuteStateSysLoadScreenAwarenessCard_0x277580; // 0x277598 - g_ps2RecompiledFunctionTable[384361] = ExecuteStateSysLoadScreenAwarenessCard_0x277580; // 0x2775ac - g_ps2RecompiledFunctionTable[384368] = ExecuteStateSysLoadScreenAwarenessCard_0x277580; // 0x2775c8 - g_ps2RecompiledFunctionTable[384374] = ExecuteStateSysLoadScreenAwarenessCard_0x277580; // 0x2775e0 - g_ps2RecompiledFunctionTable[384379] = ExecuteStateSysLoadScreenAwarenessCard_0x277580; // 0x2775f4 - g_ps2RecompiledFunctionTable[384384] = ExecuteStateSysLoadScreenAwarenessCard_0x277580; // 0x277608 - g_ps2RecompiledFunctionTable[384390] = SetStateSysLoadScreenErrAwareness_0x277620; // 0x277620 - g_ps2RecompiledFunctionTable[384402] = SetStateSysLoadScreenErrAwareness_0x277620; // 0x277650 - g_ps2RecompiledFunctionTable[384406] = SetStateSysLoadScreenErrAwareness_0x277620; // 0x277660 - g_ps2RecompiledFunctionTable[384410] = SetStateSysLoadScreenErrAwareness_0x277620; // 0x277670 - g_ps2RecompiledFunctionTable[384415] = SetStateSysLoadScreenErrAwareness_0x277620; // 0x277684 - g_ps2RecompiledFunctionTable[384420] = SetStateSysLoadScreenErrAwareness_0x277620; // 0x277698 - g_ps2RecompiledFunctionTable[384424] = SetStateSysLoadScreenErrAwareness_0x277620; // 0x2776a8 - g_ps2RecompiledFunctionTable[384426] = SetStateSysLoadScreenErrAwareness_0x277620; // 0x2776b0 - g_ps2RecompiledFunctionTable[384466] = SetStateSysLoadScreenErrAwareness_0x277620; // 0x277750 - g_ps2RecompiledFunctionTable[384473] = SetStateSysLoadScreenErrAwareness_0x277620; // 0x27776c - g_ps2RecompiledFunctionTable[384498] = ExecuteStateSysLoadScreenErrAwareness_0x2777d0; // 0x2777d0 - g_ps2RecompiledFunctionTable[384508] = ExecuteStateSysLoadScreenErrAwareness_0x2777d0; // 0x2777f8 - g_ps2RecompiledFunctionTable[384519] = ExecuteStateSysLoadScreenErrAwareness_0x2777d0; // 0x277824 - g_ps2RecompiledFunctionTable[384522] = SetStateSysLoadScreenDirCheck_0x277830; // 0x277830 - g_ps2RecompiledFunctionTable[384534] = SetStateSysLoadScreenDirCheck_0x277830; // 0x277860 - g_ps2RecompiledFunctionTable[384537] = SetStateSysLoadScreenDirCheck_0x277830; // 0x27786c - g_ps2RecompiledFunctionTable[384542] = ExecuteStateSysLoadScreenDirCheck_0x277880; // 0x277880 - g_ps2RecompiledFunctionTable[384561] = ExecuteStateSysLoadScreenDirCheck_0x277880; // 0x2778cc - g_ps2RecompiledFunctionTable[384571] = ExecuteStateSysLoadScreenDirCheck_0x277880; // 0x2778f4 - g_ps2RecompiledFunctionTable[384579] = ExecuteStateSysLoadScreenDirCheck_0x277880; // 0x277914 - g_ps2RecompiledFunctionTable[384584] = ExecuteStateSysLoadScreenDirCheck_0x277880; // 0x277928 - g_ps2RecompiledFunctionTable[384592] = ExecuteStateSysLoadScreenDirCheck_0x277880; // 0x277948 - g_ps2RecompiledFunctionTable[384600] = ExecuteStateSysLoadScreenDirCheck_0x277880; // 0x277968 - g_ps2RecompiledFunctionTable[384608] = ExecuteStateSysLoadScreenDirCheck_0x277880; // 0x277988 - g_ps2RecompiledFunctionTable[384617] = ExecuteStateSysLoadScreenDirCheck_0x277880; // 0x2779ac - g_ps2RecompiledFunctionTable[384622] = SetStateSysLoadScreenFreeCapacity_0x2779c0; // 0x2779c0 - g_ps2RecompiledFunctionTable[384626] = ExecuteStateSysLoadScreenFreeCapacity_0x2779d0; // 0x2779d0 - g_ps2RecompiledFunctionTable[384634] = ExecuteStateSysLoadScreenFreeCapacity_0x2779d0; // 0x2779f0 - g_ps2RecompiledFunctionTable[384636] = ExecuteStateSysLoadScreenFreeCapacity_0x2779d0; // 0x2779f8 - g_ps2RecompiledFunctionTable[384641] = ExecuteStateSysLoadScreenFreeCapacity_0x2779d0; // 0x277a0c - g_ps2RecompiledFunctionTable[384646] = ExecuteStateSysLoadScreenFreeCapacity_0x2779d0; // 0x277a20 - g_ps2RecompiledFunctionTable[384654] = SetStateSysLoadScreenErrFreeCapacity_0x277a40; // 0x277a40 - g_ps2RecompiledFunctionTable[384664] = SetStateSysLoadScreenErrFreeCapacity_0x277a40; // 0x277a68 - g_ps2RecompiledFunctionTable[384668] = SetStateSysLoadScreenErrFreeCapacity_0x277a40; // 0x277a78 - g_ps2RecompiledFunctionTable[384672] = SetStateSysLoadScreenErrFreeCapacity_0x277a40; // 0x277a88 - g_ps2RecompiledFunctionTable[384677] = SetStateSysLoadScreenErrFreeCapacity_0x277a40; // 0x277a9c - g_ps2RecompiledFunctionTable[384679] = SetStateSysLoadScreenErrFreeCapacity_0x277a40; // 0x277aa4 - g_ps2RecompiledFunctionTable[384704] = SetStateSysLoadScreenErrFreeCapacity_0x277a40; // 0x277b08 - g_ps2RecompiledFunctionTable[384711] = SetStateSysLoadScreenErrFreeCapacity_0x277a40; // 0x277b24 - g_ps2RecompiledFunctionTable[384730] = ExecuteStateSysLoadScreenErrFreeCapacity_0x277b70; // 0x277b70 - g_ps2RecompiledFunctionTable[384740] = ExecuteStateSysLoadScreenErrFreeCapacity_0x277b70; // 0x277b98 - g_ps2RecompiledFunctionTable[384751] = ExecuteStateSysLoadScreenErrFreeCapacity_0x277b70; // 0x277bc4 - g_ps2RecompiledFunctionTable[384754] = SetStateSysLoadScreenNoSysFile_0x277bd0; // 0x277bd0 - g_ps2RecompiledFunctionTable[384762] = ExecuteStateSysLoadScreenNoSysFile_0x277bf0; // 0x277bf0 - g_ps2RecompiledFunctionTable[384772] = ExecuteStateSysLoadScreenNoSysFile_0x277bf0; // 0x277c18 - g_ps2RecompiledFunctionTable[384783] = ExecuteStateSysLoadScreenNoSysFile_0x277bf0; // 0x277c44 - g_ps2RecompiledFunctionTable[384786] = SetStateSysLoadScreenSysLoad_0x277c50; // 0x277c50 - g_ps2RecompiledFunctionTable[384794] = ExecuteStateSysLoadScreenSysLoad_0x277c70; // 0x277c70 - g_ps2RecompiledFunctionTable[384814] = ExecuteStateSysLoadScreenSysLoad_0x277c70; // 0x277cc0 - g_ps2RecompiledFunctionTable[384822] = ExecuteStateSysLoadScreenSysLoad_0x277c70; // 0x277ce0 - g_ps2RecompiledFunctionTable[384829] = ExecuteStateSysLoadScreenSysLoad_0x277c70; // 0x277cfc - g_ps2RecompiledFunctionTable[384834] = ExecuteStateSysLoadScreenSysLoad_0x277c70; // 0x277d10 - g_ps2RecompiledFunctionTable[384836] = ExecuteStateSysLoadScreenSysLoad_0x277c70; // 0x277d18 - g_ps2RecompiledFunctionTable[384844] = ExecuteStateSysLoadScreenSysLoad_0x277c70; // 0x277d38 - g_ps2RecompiledFunctionTable[384846] = ExecuteStateSysLoadScreenSysLoad_0x277c70; // 0x277d40 - g_ps2RecompiledFunctionTable[384855] = ExecuteStateSysLoadScreenSysLoad_0x277c70; // 0x277d64 - g_ps2RecompiledFunctionTable[384857] = ExecuteStateSysLoadScreenSysLoad_0x277c70; // 0x277d6c - g_ps2RecompiledFunctionTable[384866] = ExecuteStateSysLoadScreenSysLoad_0x277c70; // 0x277d90 - g_ps2RecompiledFunctionTable[384874] = ExecuteStateSysLoadScreenSysLoad_0x277c70; // 0x277db0 - g_ps2RecompiledFunctionTable[384878] = SetStateSysLoadScreenFileBroken_0x277dc0; // 0x277dc0 - g_ps2RecompiledFunctionTable[384886] = ExecuteStateSysLoadScreenFileBroken_0x277de0; // 0x277de0 - g_ps2RecompiledFunctionTable[384896] = ExecuteStateSysLoadScreenFileBroken_0x277de0; // 0x277e08 - g_ps2RecompiledFunctionTable[384907] = ExecuteStateSysLoadScreenFileBroken_0x277de0; // 0x277e34 - g_ps2RecompiledFunctionTable[384910] = SetStateSysLoadScreenErrCardRead_0x277e40; // 0x277e40 - g_ps2RecompiledFunctionTable[384918] = ExecuteStateSysLoadScreenErrCardRead_0x277e60; // 0x277e60 - g_ps2RecompiledFunctionTable[384928] = ExecuteStateSysLoadScreenErrCardRead_0x277e60; // 0x277e88 - g_ps2RecompiledFunctionTable[384939] = ExecuteStateSysLoadScreenErrCardRead_0x277e60; // 0x277eb4 - g_ps2RecompiledFunctionTable[384942] = SetStateSysLoadScreenTitleExit_0x277ec0; // 0x277ec0 - g_ps2RecompiledFunctionTable[384953] = SetStateSysLoadScreenTitleExit_0x277ec0; // 0x277eec - g_ps2RecompiledFunctionTable[384955] = SetStateSysLoadScreenTitleExit_0x277ec0; // 0x277ef4 - g_ps2RecompiledFunctionTable[384962] = ExecuteStateSysLoadScreenTitleExit_0x277f10; // 0x277f10 - g_ps2RecompiledFunctionTable[384974] = CreateSysSaveScreen_0x277f40; // 0x277f40 - g_ps2RecompiledFunctionTable[384994] = CreateSysSaveScreen_0x277f40; // 0x277f90 - g_ps2RecompiledFunctionTable[384998] = CreateSysSaveScreen_0x277f40; // 0x277fa0 - g_ps2RecompiledFunctionTable[385002] = CreateSysSaveScreen_0x277f40; // 0x277fb0 - g_ps2RecompiledFunctionTable[385009] = CreateSysSaveScreen_0x277f40; // 0x277fcc - g_ps2RecompiledFunctionTable[385013] = CreateSysSaveScreen_0x277f40; // 0x277fdc - g_ps2RecompiledFunctionTable[385019] = CreateSysSaveScreen_0x277f40; // 0x277ff4 - g_ps2RecompiledFunctionTable[385023] = CreateSysSaveScreen_0x277f40; // 0x278004 - g_ps2RecompiledFunctionTable[385030] = DispSysSaveMessageSelect_0x278020; // 0x278020 - g_ps2RecompiledFunctionTable[385039] = DispSysSaveMessageSelect_0x278020; // 0x278044 - g_ps2RecompiledFunctionTable[385058] = DispSysSaveMessageSelect_0x278020; // 0x278090 - g_ps2RecompiledFunctionTable[385068] = DispSysSaveMessageSelect_0x278020; // 0x2780b8 - g_ps2RecompiledFunctionTable[385078] = DispSysSaveMessageSelect_0x278020; // 0x2780e0 - g_ps2RecompiledFunctionTable[385088] = DispSysSaveMessageSelect_0x278020; // 0x278108 - g_ps2RecompiledFunctionTable[385096] = DispSysSaveMessageSelect_0x278020; // 0x278128 - g_ps2RecompiledFunctionTable[385106] = DispSysSaveMessageSelect_0x278020; // 0x278150 - g_ps2RecompiledFunctionTable[385116] = DispSysSaveMessageSelect_0x278020; // 0x278178 - g_ps2RecompiledFunctionTable[385126] = DispSysSaveMessageSelect_0x278020; // 0x2781a0 - g_ps2RecompiledFunctionTable[385136] = DispSysSaveMessageSelect_0x278020; // 0x2781c8 - g_ps2RecompiledFunctionTable[385143] = DispSysSaveMessageSelect_0x278020; // 0x2781e4 - g_ps2RecompiledFunctionTable[385153] = DispSysSaveMessageSelect_0x278020; // 0x27820c - g_ps2RecompiledFunctionTable[385163] = DispSysSaveMessageSelect_0x278020; // 0x278234 - g_ps2RecompiledFunctionTable[385173] = DispSysSaveMessageSelect_0x278020; // 0x27825c - g_ps2RecompiledFunctionTable[385183] = DispSysSaveMessageSelect_0x278020; // 0x278284 - g_ps2RecompiledFunctionTable[385193] = DispSysSaveMessageSelect_0x278020; // 0x2782ac - g_ps2RecompiledFunctionTable[385203] = DispSysSaveMessageSelect_0x278020; // 0x2782d4 - g_ps2RecompiledFunctionTable[385213] = DispSysSaveMessageSelect_0x278020; // 0x2782fc - g_ps2RecompiledFunctionTable[385223] = DispSysSaveMessageSelect_0x278020; // 0x278324 - g_ps2RecompiledFunctionTable[385230] = DispSysSaveMessageSelect_0x278020; // 0x278340 - g_ps2RecompiledFunctionTable[385236] = DispSysSaveMessageSelect_0x278020; // 0x278358 - g_ps2RecompiledFunctionTable[385242] = ExecuteSysSaveScreen_0x278370; // 0x278370 - g_ps2RecompiledFunctionTable[385248] = ExecuteSysSaveScreen_0x278370; // 0x278388 - g_ps2RecompiledFunctionTable[385320] = ExecuteSysSaveScreen_0x278370; // 0x2784a8 - g_ps2RecompiledFunctionTable[385325] = ExecuteSysSaveScreen_0x278370; // 0x2784bc - g_ps2RecompiledFunctionTable[385330] = ExecuteSysSaveScreen_0x278370; // 0x2784d0 - g_ps2RecompiledFunctionTable[385335] = ExecuteSysSaveScreen_0x278370; // 0x2784e4 - g_ps2RecompiledFunctionTable[385340] = ExecuteSysSaveScreen_0x278370; // 0x2784f8 - g_ps2RecompiledFunctionTable[385345] = ExecuteSysSaveScreen_0x278370; // 0x27850c - g_ps2RecompiledFunctionTable[385350] = ExecuteSysSaveScreen_0x278370; // 0x278520 - g_ps2RecompiledFunctionTable[385355] = ExecuteSysSaveScreen_0x278370; // 0x278534 - g_ps2RecompiledFunctionTable[385360] = ExecuteSysSaveScreen_0x278370; // 0x278548 - g_ps2RecompiledFunctionTable[385365] = ExecuteSysSaveScreen_0x278370; // 0x27855c - g_ps2RecompiledFunctionTable[385370] = ExecuteSysSaveScreen_0x278370; // 0x278570 - g_ps2RecompiledFunctionTable[385375] = ExecuteSysSaveScreen_0x278370; // 0x278584 - g_ps2RecompiledFunctionTable[385380] = ExecuteSysSaveScreen_0x278370; // 0x278598 - g_ps2RecompiledFunctionTable[385385] = ExecuteSysSaveScreen_0x278370; // 0x2785ac - g_ps2RecompiledFunctionTable[385390] = ExecuteSysSaveScreen_0x278370; // 0x2785c0 - g_ps2RecompiledFunctionTable[385395] = ExecuteSysSaveScreen_0x278370; // 0x2785d4 - g_ps2RecompiledFunctionTable[385400] = ExecuteSysSaveScreen_0x278370; // 0x2785e8 - g_ps2RecompiledFunctionTable[385405] = ExecuteSysSaveScreen_0x278370; // 0x2785fc - g_ps2RecompiledFunctionTable[385410] = ExecuteSysSaveScreen_0x278370; // 0x278610 - g_ps2RecompiledFunctionTable[385415] = ExecuteSysSaveScreen_0x278370; // 0x278624 - g_ps2RecompiledFunctionTable[385420] = ExecuteSysSaveScreen_0x278370; // 0x278638 - g_ps2RecompiledFunctionTable[385424] = ExecuteSysSaveScreen_0x278370; // 0x278648 - g_ps2RecompiledFunctionTable[385427] = ExecuteSysSaveScreen_0x278370; // 0x278654 - g_ps2RecompiledFunctionTable[385434] = SetStateSysSaveAwarenessCard_0x278670; // 0x278670 - g_ps2RecompiledFunctionTable[385442] = SetStateSysSaveAwarenessCard_0x278670; // 0x278690 - g_ps2RecompiledFunctionTable[385444] = SetStateSysSaveAwarenessCard_0x278670; // 0x278698 - g_ps2RecompiledFunctionTable[385450] = ExecuteStateSysSaveAwarenessCard_0x2786b0; // 0x2786b0 - g_ps2RecompiledFunctionTable[385472] = ExecuteStateSysSaveAwarenessCard_0x2786b0; // 0x278708 - g_ps2RecompiledFunctionTable[385476] = ExecuteStateSysSaveAwarenessCard_0x2786b0; // 0x278718 - g_ps2RecompiledFunctionTable[385481] = ExecuteStateSysSaveAwarenessCard_0x2786b0; // 0x27872c - g_ps2RecompiledFunctionTable[385486] = ExecuteStateSysSaveAwarenessCard_0x2786b0; // 0x278740 - g_ps2RecompiledFunctionTable[385493] = ExecuteStateSysSaveAwarenessCard_0x2786b0; // 0x27875c - g_ps2RecompiledFunctionTable[385499] = ExecuteStateSysSaveAwarenessCard_0x2786b0; // 0x278774 - g_ps2RecompiledFunctionTable[385513] = ExecuteStateSysSaveAwarenessCard_0x2786b0; // 0x2787ac - g_ps2RecompiledFunctionTable[385518] = ExecuteStateSysSaveAwarenessCard_0x2786b0; // 0x2787c0 - g_ps2RecompiledFunctionTable[385522] = ExecuteStateSysSaveAwarenessCard_0x2786b0; // 0x2787d0 - g_ps2RecompiledFunctionTable[385526] = ExecuteStateSysSaveAwarenessCard_0x2786b0; // 0x2787e0 - g_ps2RecompiledFunctionTable[385534] = SetStateSysSaveErrUnPS2MemCard_0x278800; // 0x278800 - g_ps2RecompiledFunctionTable[385538] = ExecuteStateSysSaveErrUnPS2MemCard_0x278810; // 0x278810 - g_ps2RecompiledFunctionTable[385550] = ExecuteStateSysSaveErrUnPS2MemCard_0x278810; // 0x278840 - g_ps2RecompiledFunctionTable[385567] = ExecuteStateSysSaveErrUnPS2MemCard_0x278810; // 0x278884 - g_ps2RecompiledFunctionTable[385571] = ExecuteStateSysSaveErrUnPS2MemCard_0x278810; // 0x278894 - g_ps2RecompiledFunctionTable[385576] = ExecuteStateSysSaveErrUnPS2MemCard_0x278810; // 0x2788a8 - g_ps2RecompiledFunctionTable[385582] = ExecuteStateSysSaveErrUnPS2MemCard_0x278810; // 0x2788c0 - g_ps2RecompiledFunctionTable[385590] = ExecuteStateSysSaveErrUnPS2MemCard_0x278810; // 0x2788e0 - g_ps2RecompiledFunctionTable[385594] = ExecuteStateSysSaveErrUnPS2MemCard_0x278810; // 0x2788f0 - g_ps2RecompiledFunctionTable[385602] = SetStateSysSaveErrLostCard_0x278910; // 0x278910 - g_ps2RecompiledFunctionTable[385610] = ExecuteStateSysSaveErrLostCard_0x278930; // 0x278930 - g_ps2RecompiledFunctionTable[385622] = ExecuteStateSysSaveErrLostCard_0x278930; // 0x278960 - g_ps2RecompiledFunctionTable[385639] = ExecuteStateSysSaveErrLostCard_0x278930; // 0x2789a4 - g_ps2RecompiledFunctionTable[385643] = ExecuteStateSysSaveErrLostCard_0x278930; // 0x2789b4 - g_ps2RecompiledFunctionTable[385648] = ExecuteStateSysSaveErrLostCard_0x278930; // 0x2789c8 - g_ps2RecompiledFunctionTable[385654] = ExecuteStateSysSaveErrLostCard_0x278930; // 0x2789e0 - g_ps2RecompiledFunctionTable[385668] = ExecuteStateSysSaveErrLostCard_0x278930; // 0x278a18 - g_ps2RecompiledFunctionTable[385672] = ExecuteStateSysSaveErrLostCard_0x278930; // 0x278a28 - g_ps2RecompiledFunctionTable[385678] = SetStateSysSaveErrPort2_0x278a40; // 0x278a40 - g_ps2RecompiledFunctionTable[385686] = ExecuteStateSysSaveErrPort2_0x278a60; // 0x278a60 - g_ps2RecompiledFunctionTable[385696] = ExecuteStateSysSaveErrPort2_0x278a60; // 0x278a88 - g_ps2RecompiledFunctionTable[385707] = ExecuteStateSysSaveErrPort2_0x278a60; // 0x278ab4 - g_ps2RecompiledFunctionTable[385710] = SetStateSysSaveDirCheck_0x278ac0; // 0x278ac0 - g_ps2RecompiledFunctionTable[385720] = SetStateSysSaveDirCheck_0x278ac0; // 0x278ae8 - g_ps2RecompiledFunctionTable[385723] = SetStateSysSaveDirCheck_0x278ac0; // 0x278af4 - g_ps2RecompiledFunctionTable[385730] = ExecuteStateSysSaveDirCheck_0x278b10; // 0x278b10 - g_ps2RecompiledFunctionTable[385749] = ExecuteStateSysSaveDirCheck_0x278b10; // 0x278b5c - g_ps2RecompiledFunctionTable[385759] = ExecuteStateSysSaveDirCheck_0x278b10; // 0x278b84 - g_ps2RecompiledFunctionTable[385761] = ExecuteStateSysSaveDirCheck_0x278b10; // 0x278b8c - g_ps2RecompiledFunctionTable[385769] = ExecuteStateSysSaveDirCheck_0x278b10; // 0x278bac - g_ps2RecompiledFunctionTable[385776] = ExecuteStateSysSaveDirCheck_0x278b10; // 0x278bc8 - g_ps2RecompiledFunctionTable[385778] = ExecuteStateSysSaveDirCheck_0x278b10; // 0x278bd0 - g_ps2RecompiledFunctionTable[385788] = ExecuteStateSysSaveDirCheck_0x278b10; // 0x278bf8 - g_ps2RecompiledFunctionTable[385793] = ExecuteStateSysSaveDirCheck_0x278b10; // 0x278c0c - g_ps2RecompiledFunctionTable[385801] = ExecuteStateSysSaveDirCheck_0x278b10; // 0x278c2c - g_ps2RecompiledFunctionTable[385809] = ExecuteStateSysSaveDirCheck_0x278b10; // 0x278c4c - g_ps2RecompiledFunctionTable[385818] = ExecuteStateSysSaveDirCheck_0x278b10; // 0x278c70 - g_ps2RecompiledFunctionTable[385822] = SetStateSysSaveFreeCapacity_0x278c80; // 0x278c80 - g_ps2RecompiledFunctionTable[385826] = ExecuteStateSysSaveFreeCapacity_0x278c90; // 0x278c90 - g_ps2RecompiledFunctionTable[385833] = ExecuteStateSysSaveFreeCapacity_0x278c90; // 0x278cac - g_ps2RecompiledFunctionTable[385835] = ExecuteStateSysSaveFreeCapacity_0x278c90; // 0x278cb4 - g_ps2RecompiledFunctionTable[385843] = ExecuteStateSysSaveFreeCapacity_0x278c90; // 0x278cd4 - g_ps2RecompiledFunctionTable[385848] = ExecuteStateSysSaveFreeCapacity_0x278c90; // 0x278ce8 - g_ps2RecompiledFunctionTable[385853] = ExecuteStateSysSaveFreeCapacity_0x278c90; // 0x278cfc - g_ps2RecompiledFunctionTable[385858] = SetStateSysSaveErrFreeCapacity_0x278d10; // 0x278d10 - g_ps2RecompiledFunctionTable[385866] = ExecuteStateSysSaveErrFreeCapacity_0x278d30; // 0x278d30 - g_ps2RecompiledFunctionTable[385876] = ExecuteStateSysSaveErrFreeCapacity_0x278d30; // 0x278d58 - g_ps2RecompiledFunctionTable[385887] = ExecuteStateSysSaveErrFreeCapacity_0x278d30; // 0x278d84 - g_ps2RecompiledFunctionTable[385890] = SetStateSysSaveCheckWriteSysData_0x278d90; // 0x278d90 - g_ps2RecompiledFunctionTable[385898] = ExecuteStateSysSaveCheckWriteSysData_0x278db0; // 0x278db0 - g_ps2RecompiledFunctionTable[385915] = ExecuteStateSysSaveCheckWriteSysData_0x278db0; // 0x278df4 - g_ps2RecompiledFunctionTable[385929] = ExecuteStateSysSaveCheckWriteSysData_0x278db0; // 0x278e2c - g_ps2RecompiledFunctionTable[385933] = ExecuteStateSysSaveCheckWriteSysData_0x278db0; // 0x278e3c - g_ps2RecompiledFunctionTable[385943] = ExecuteStateSysSaveCheckWriteSysData_0x278db0; // 0x278e64 - g_ps2RecompiledFunctionTable[385948] = ExecuteStateSysSaveCheckWriteSysData_0x278db0; // 0x278e78 - g_ps2RecompiledFunctionTable[385951] = ExecuteStateSysSaveCheckWriteSysData_0x278db0; // 0x278e84 - g_ps2RecompiledFunctionTable[385955] = ExecuteStateSysSaveCheckWriteSysData_0x278db0; // 0x278e94 - g_ps2RecompiledFunctionTable[385962] = ExecuteStateSysSaveCheckWriteSysData_0x278db0; // 0x278eb0 - g_ps2RecompiledFunctionTable[385965] = ExecuteStateSysSaveCheckWriteSysData_0x278db0; // 0x278ebc - g_ps2RecompiledFunctionTable[385976] = ExecuteStateSysSaveCheckWriteSysData_0x278db0; // 0x278ee8 - g_ps2RecompiledFunctionTable[385982] = SetStateSysSaveWriteSysData_0x278f00; // 0x278f00 - g_ps2RecompiledFunctionTable[385994] = ExecuteStateSysSaveWriteSysData_0x278f30; // 0x278f30 - g_ps2RecompiledFunctionTable[386010] = ExecuteStateSysSaveWriteSysData_0x278f30; // 0x278f70 - g_ps2RecompiledFunctionTable[386016] = ExecuteStateSysSaveWriteSysData_0x278f30; // 0x278f88 - g_ps2RecompiledFunctionTable[386018] = ExecuteStateSysSaveWriteSysData_0x278f30; // 0x278f90 - g_ps2RecompiledFunctionTable[386030] = ExecuteStateSysSaveWriteSysData_0x278f30; // 0x278fc0 - g_ps2RecompiledFunctionTable[386037] = ExecuteStateSysSaveWriteSysData_0x278f30; // 0x278fdc - g_ps2RecompiledFunctionTable[386049] = ExecuteStateSysSaveWriteSysData_0x278f30; // 0x27900c - g_ps2RecompiledFunctionTable[386051] = ExecuteStateSysSaveWriteSysData_0x278f30; // 0x279014 - g_ps2RecompiledFunctionTable[386059] = ExecuteStateSysSaveWriteSysData_0x278f30; // 0x279034 - g_ps2RecompiledFunctionTable[386066] = ExecuteStateSysSaveWriteSysData_0x278f30; // 0x279050 - g_ps2RecompiledFunctionTable[386068] = ExecuteStateSysSaveWriteSysData_0x278f30; // 0x279058 - g_ps2RecompiledFunctionTable[386077] = ExecuteStateSysSaveWriteSysData_0x278f30; // 0x27907c - g_ps2RecompiledFunctionTable[386085] = ExecuteStateSysSaveWriteSysData_0x278f30; // 0x27909c - g_ps2RecompiledFunctionTable[386091] = ExecuteStateSysSaveWriteSysData_0x278f30; // 0x2790b4 - g_ps2RecompiledFunctionTable[386093] = ExecuteStateSysSaveWriteSysData_0x278f30; // 0x2790bc - g_ps2RecompiledFunctionTable[386102] = ExecuteStateSysSaveWriteSysData_0x278f30; // 0x2790e0 - g_ps2RecompiledFunctionTable[386110] = ExecuteStateSysSaveWriteSysData_0x278f30; // 0x279100 - g_ps2RecompiledFunctionTable[386122] = ExecuteStateSysSaveWriteSysData_0x278f30; // 0x279130 - g_ps2RecompiledFunctionTable[386124] = ExecuteStateSysSaveWriteSysData_0x278f30; // 0x279138 - g_ps2RecompiledFunctionTable[386133] = ExecuteStateSysSaveWriteSysData_0x278f30; // 0x27915c - g_ps2RecompiledFunctionTable[386140] = ExecuteStateSysSaveWriteSysData_0x278f30; // 0x279178 - g_ps2RecompiledFunctionTable[386158] = ExecuteStateSysSaveWriteSysData_0x278f30; // 0x2791c0 - g_ps2RecompiledFunctionTable[386169] = ExecuteStateSysSaveWriteSysData_0x278f30; // 0x2791ec - g_ps2RecompiledFunctionTable[386171] = ExecuteStateSysSaveWriteSysData_0x278f30; // 0x2791f4 - g_ps2RecompiledFunctionTable[386180] = ExecuteStateSysSaveWriteSysData_0x278f30; // 0x279218 - g_ps2RecompiledFunctionTable[386188] = ExecuteStateSysSaveWriteSysData_0x278f30; // 0x279238 - g_ps2RecompiledFunctionTable[386194] = SetStateSysSaveSuccessWriteSysData_0x279250; // 0x279250 - g_ps2RecompiledFunctionTable[386202] = ExecuteStateSysSaveSuccessWriteSysData_0x279270; // 0x279270 - g_ps2RecompiledFunctionTable[386210] = ExecuteStateSysSaveSuccessWriteSysData_0x279270; // 0x279290 - g_ps2RecompiledFunctionTable[386221] = ExecuteStateSysSaveSuccessWriteSysData_0x279270; // 0x2792bc - g_ps2RecompiledFunctionTable[386226] = SetStateSysSaveErrWriteSysData_0x2792d0; // 0x2792d0 - g_ps2RecompiledFunctionTable[386234] = ExecuteStateSysSaveErrWriteSysData_0x2792f0; // 0x2792f0 - g_ps2RecompiledFunctionTable[386244] = ExecuteStateSysSaveErrWriteSysData_0x2792f0; // 0x279318 - g_ps2RecompiledFunctionTable[386255] = ExecuteStateSysSaveErrWriteSysData_0x2792f0; // 0x279344 - g_ps2RecompiledFunctionTable[386258] = SetStateSysSaveFileBroken_0x279350; // 0x279350 - g_ps2RecompiledFunctionTable[386266] = ExecuteStateSysSaveFileBroken_0x279370; // 0x279370 - g_ps2RecompiledFunctionTable[386276] = ExecuteStateSysSaveFileBroken_0x279370; // 0x279398 - g_ps2RecompiledFunctionTable[386287] = ExecuteStateSysSaveFileBroken_0x279370; // 0x2793c4 - g_ps2RecompiledFunctionTable[386290] = SetStateSysSaveExitWriteSysData_0x2793d0; // 0x2793d0 - g_ps2RecompiledFunctionTable[386298] = ExecuteStateSysSaveExitWriteSysData_0x2793f0; // 0x2793f0 - g_ps2RecompiledFunctionTable[386315] = ExecuteStateSysSaveExitWriteSysData_0x2793f0; // 0x279434 - g_ps2RecompiledFunctionTable[386329] = ExecuteStateSysSaveExitWriteSysData_0x2793f0; // 0x27946c - g_ps2RecompiledFunctionTable[386333] = ExecuteStateSysSaveExitWriteSysData_0x2793f0; // 0x27947c - g_ps2RecompiledFunctionTable[386344] = ExecuteStateSysSaveExitWriteSysData_0x2793f0; // 0x2794a8 - g_ps2RecompiledFunctionTable[386349] = ExecuteStateSysSaveExitWriteSysData_0x2793f0; // 0x2794bc - g_ps2RecompiledFunctionTable[386352] = ExecuteStateSysSaveExitWriteSysData_0x2793f0; // 0x2794c8 - g_ps2RecompiledFunctionTable[386356] = ExecuteStateSysSaveExitWriteSysData_0x2793f0; // 0x2794d8 - g_ps2RecompiledFunctionTable[386363] = ExecuteStateSysSaveExitWriteSysData_0x2793f0; // 0x2794f4 - g_ps2RecompiledFunctionTable[386366] = ExecuteStateSysSaveExitWriteSysData_0x2793f0; // 0x279500 - g_ps2RecompiledFunctionTable[386377] = ExecuteStateSysSaveExitWriteSysData_0x2793f0; // 0x27952c - g_ps2RecompiledFunctionTable[386382] = SetStateWriteRankingData_0x279540; // 0x279540 - g_ps2RecompiledFunctionTable[386392] = SetStateWriteRankingData_0x279540; // 0x279568 - g_ps2RecompiledFunctionTable[386394] = SetStateWriteRankingData_0x279540; // 0x279570 - g_ps2RecompiledFunctionTable[386398] = ExecuteStateWriteRankingData_0x279580; // 0x279580 - g_ps2RecompiledFunctionTable[386417] = ExecuteStateWriteRankingData_0x279580; // 0x2795cc - g_ps2RecompiledFunctionTable[386425] = ExecuteStateWriteRankingData_0x279580; // 0x2795ec - g_ps2RecompiledFunctionTable[386433] = ExecuteStateWriteRankingData_0x279580; // 0x27960c - g_ps2RecompiledFunctionTable[386438] = ExecuteStateWriteRankingData_0x279580; // 0x279620 - g_ps2RecompiledFunctionTable[386440] = ExecuteStateWriteRankingData_0x279580; // 0x279628 - g_ps2RecompiledFunctionTable[386447] = ExecuteStateWriteRankingData_0x279580; // 0x279644 - g_ps2RecompiledFunctionTable[386450] = ExecuteStateWriteRankingData_0x279580; // 0x279650 - g_ps2RecompiledFunctionTable[386457] = ExecuteStateWriteRankingData_0x279580; // 0x27966c - g_ps2RecompiledFunctionTable[386459] = ExecuteStateWriteRankingData_0x279580; // 0x279674 - g_ps2RecompiledFunctionTable[386468] = ExecuteStateWriteRankingData_0x279580; // 0x279698 - g_ps2RecompiledFunctionTable[386474] = SetStateSysSave_0x2796b0; // 0x2796b0 - g_ps2RecompiledFunctionTable[386482] = ExecuteStateSysSave_0x2796d0; // 0x2796d0 - g_ps2RecompiledFunctionTable[386499] = ExecuteStateSysSave_0x2796d0; // 0x279714 - g_ps2RecompiledFunctionTable[386506] = ExecuteStateSysSave_0x2796d0; // 0x279730 - g_ps2RecompiledFunctionTable[386512] = ExecuteStateSysSave_0x2796d0; // 0x279748 - g_ps2RecompiledFunctionTable[386516] = ExecuteStateSysSave_0x2796d0; // 0x279758 - g_ps2RecompiledFunctionTable[386523] = ExecuteStateSysSave_0x2796d0; // 0x279774 - g_ps2RecompiledFunctionTable[386525] = ExecuteStateSysSave_0x2796d0; // 0x27977c - g_ps2RecompiledFunctionTable[386534] = ExecuteStateSysSave_0x2796d0; // 0x2797a0 - g_ps2RecompiledFunctionTable[386538] = SetStateSysSaveErrCardWrite_0x2797b0; // 0x2797b0 - g_ps2RecompiledFunctionTable[386546] = ExecuteStateSysSaveErrCardWrite_0x2797d0; // 0x2797d0 - g_ps2RecompiledFunctionTable[386556] = ExecuteStateSysSaveErrCardWrite_0x2797d0; // 0x2797f8 - g_ps2RecompiledFunctionTable[386567] = ExecuteStateSysSaveErrCardWrite_0x2797d0; // 0x279824 - g_ps2RecompiledFunctionTable[386570] = SetStateSysSaveFormat_0x279830; // 0x279830 - g_ps2RecompiledFunctionTable[386578] = ExecuteStateSysSaveFormat_0x279850; // 0x279850 - g_ps2RecompiledFunctionTable[386595] = ExecuteStateSysSaveFormat_0x279850; // 0x279894 - g_ps2RecompiledFunctionTable[386609] = ExecuteStateSysSaveFormat_0x279850; // 0x2798cc - g_ps2RecompiledFunctionTable[386613] = ExecuteStateSysSaveFormat_0x279850; // 0x2798dc - g_ps2RecompiledFunctionTable[386624] = ExecuteStateSysSaveFormat_0x279850; // 0x279908 - g_ps2RecompiledFunctionTable[386629] = ExecuteStateSysSaveFormat_0x279850; // 0x27991c - g_ps2RecompiledFunctionTable[386632] = ExecuteStateSysSaveFormat_0x279850; // 0x279928 - g_ps2RecompiledFunctionTable[386636] = ExecuteStateSysSaveFormat_0x279850; // 0x279938 - g_ps2RecompiledFunctionTable[386643] = ExecuteStateSysSaveFormat_0x279850; // 0x279954 - g_ps2RecompiledFunctionTable[386646] = ExecuteStateSysSaveFormat_0x279850; // 0x279960 - g_ps2RecompiledFunctionTable[386657] = ExecuteStateSysSaveFormat_0x279850; // 0x27998c - g_ps2RecompiledFunctionTable[386662] = SetStateSysSaveStartFormat_0x2799a0; // 0x2799a0 - g_ps2RecompiledFunctionTable[386670] = ExecuteStateSysSaveStartFormat_0x2799c0; // 0x2799c0 - g_ps2RecompiledFunctionTable[386689] = ExecuteStateSysSaveStartFormat_0x2799c0; // 0x279a0c - g_ps2RecompiledFunctionTable[386696] = ExecuteStateSysSaveStartFormat_0x2799c0; // 0x279a28 - g_ps2RecompiledFunctionTable[386702] = ExecuteStateSysSaveStartFormat_0x2799c0; // 0x279a40 - g_ps2RecompiledFunctionTable[386711] = ExecuteStateSysSaveStartFormat_0x2799c0; // 0x279a64 - g_ps2RecompiledFunctionTable[386713] = ExecuteStateSysSaveStartFormat_0x2799c0; // 0x279a6c - g_ps2RecompiledFunctionTable[386722] = ExecuteStateSysSaveStartFormat_0x2799c0; // 0x279a90 - g_ps2RecompiledFunctionTable[386730] = ExecuteStateSysSaveStartFormat_0x2799c0; // 0x279ab0 - g_ps2RecompiledFunctionTable[386734] = SetStateSysSaveExitFormat_0x279ac0; // 0x279ac0 - g_ps2RecompiledFunctionTable[386742] = ExecuteStateSysSaveExitFormat_0x279ae0; // 0x279ae0 - g_ps2RecompiledFunctionTable[386759] = ExecuteStateSysSaveExitFormat_0x279ae0; // 0x279b24 - g_ps2RecompiledFunctionTable[386773] = ExecuteStateSysSaveExitFormat_0x279ae0; // 0x279b5c - g_ps2RecompiledFunctionTable[386777] = ExecuteStateSysSaveExitFormat_0x279ae0; // 0x279b6c - g_ps2RecompiledFunctionTable[386788] = ExecuteStateSysSaveExitFormat_0x279ae0; // 0x279b98 - g_ps2RecompiledFunctionTable[386793] = ExecuteStateSysSaveExitFormat_0x279ae0; // 0x279bac - g_ps2RecompiledFunctionTable[386796] = ExecuteStateSysSaveExitFormat_0x279ae0; // 0x279bb8 - g_ps2RecompiledFunctionTable[386800] = ExecuteStateSysSaveExitFormat_0x279ae0; // 0x279bc8 - g_ps2RecompiledFunctionTable[386807] = ExecuteStateSysSaveExitFormat_0x279ae0; // 0x279be4 - g_ps2RecompiledFunctionTable[386810] = ExecuteStateSysSaveExitFormat_0x279ae0; // 0x279bf0 - g_ps2RecompiledFunctionTable[386821] = ExecuteStateSysSaveExitFormat_0x279ae0; // 0x279c1c - g_ps2RecompiledFunctionTable[386826] = SetStateSysSaveSuccessFormat_0x279c30; // 0x279c30 - g_ps2RecompiledFunctionTable[386834] = ExecuteStateSysSaveSuccessFormat_0x279c50; // 0x279c50 - g_ps2RecompiledFunctionTable[386844] = ExecuteStateSysSaveSuccessFormat_0x279c50; // 0x279c78 - g_ps2RecompiledFunctionTable[386855] = ExecuteStateSysSaveSuccessFormat_0x279c50; // 0x279ca4 - g_ps2RecompiledFunctionTable[386858] = SetStateSysSaveErrFormat_0x279cb0; // 0x279cb0 - g_ps2RecompiledFunctionTable[386866] = ExecuteStateSysSaveErrFormat_0x279cd0; // 0x279cd0 - g_ps2RecompiledFunctionTable[386875] = ExecuteStateSysSaveErrFormat_0x279cd0; // 0x279cf4 - g_ps2RecompiledFunctionTable[386886] = ExecuteStateSysSaveErrFormat_0x279cd0; // 0x279d20 - g_ps2RecompiledFunctionTable[386890] = SetStateSysSaveTitleExit_0x279d30; // 0x279d30 - g_ps2RecompiledFunctionTable[386894] = ExecuteStateSysSaveTitleExit_0x279d40; // 0x279d40 - g_ps2RecompiledFunctionTable[386906] = SysSaveHikaku_0x279d70; // 0x279d70 - g_ps2RecompiledFunctionTable[386916] = SysSaveHikaku_0x279d70; // 0x279d98 - g_ps2RecompiledFunctionTable[386937] = SysSaveHikaku_0x279d70; // 0x279dec - g_ps2RecompiledFunctionTable[386950] = GetOkButton_0x279e20; // 0x279e20 - g_ps2RecompiledFunctionTable[386966] = GetCancelButton_0x279e60; // 0x279e60 - g_ps2RecompiledFunctionTable[386982] = bhInitCamera_0x279ea0; // 0x279ea0 - g_ps2RecompiledFunctionTable[386989] = bhInitCamera_0x279ea0; // 0x279ebc - g_ps2RecompiledFunctionTable[387017] = bhInitCamera_0x279ea0; // 0x279f2c - g_ps2RecompiledFunctionTable[387020] = bhInitCamera_0x279ea0; // 0x279f38 - g_ps2RecompiledFunctionTable[387026] = bhControlCamera_0x279f50; // 0x279f50 - g_ps2RecompiledFunctionTable[387038] = bhControlCamera_0x279f50; // 0x279f80 - g_ps2RecompiledFunctionTable[387042] = bhControlCamera_0x279f50; // 0x279f90 - g_ps2RecompiledFunctionTable[387049] = bhControlCamera_0x279f50; // 0x279fac - g_ps2RecompiledFunctionTable[387053] = bhControlCamera_0x279f50; // 0x279fbc - g_ps2RecompiledFunctionTable[387057] = bhControlCamera_0x279f50; // 0x279fcc - g_ps2RecompiledFunctionTable[387061] = bhControlCamera_0x279f50; // 0x279fdc - g_ps2RecompiledFunctionTable[387081] = bhControlCamera_0x279f50; // 0x27a02c - g_ps2RecompiledFunctionTable[387084] = bhControlCamera_0x279f50; // 0x27a038 - g_ps2RecompiledFunctionTable[387086] = bhControlCamera_0x279f50; // 0x27a040 - g_ps2RecompiledFunctionTable[387090] = bhControlCamera_0x279f50; // 0x27a050 - g_ps2RecompiledFunctionTable[387094] = bhControlCamera_0x279f50; // 0x27a060 - g_ps2RecompiledFunctionTable[387098] = bhControlCamera_0x279f50; // 0x27a070 - g_ps2RecompiledFunctionTable[387103] = bhControlCamera_0x279f50; // 0x27a084 - g_ps2RecompiledFunctionTable[387115] = bhControlCamera_0x279f50; // 0x27a0b4 - g_ps2RecompiledFunctionTable[387132] = bhControlCamera_0x279f50; // 0x27a0f8 - g_ps2RecompiledFunctionTable[387136] = bhControlCamera_0x279f50; // 0x27a108 - g_ps2RecompiledFunctionTable[387140] = bhControlCamera_0x279f50; // 0x27a118 - g_ps2RecompiledFunctionTable[387144] = bhControlCamera_0x279f50; // 0x27a128 - g_ps2RecompiledFunctionTable[387155] = bhControlCamera_0x279f50; // 0x27a154 - g_ps2RecompiledFunctionTable[387158] = bhMakeCameraVector_0x27a160; // 0x27a160 - g_ps2RecompiledFunctionTable[387169] = bhMakeCameraVector_0x27a160; // 0x27a18c - g_ps2RecompiledFunctionTable[387173] = bhMakeCameraVector_0x27a160; // 0x27a19c - g_ps2RecompiledFunctionTable[387177] = bhMakeCameraVector_0x27a160; // 0x27a1ac - g_ps2RecompiledFunctionTable[387181] = bhMakeCameraVector_0x27a160; // 0x27a1bc - g_ps2RecompiledFunctionTable[387186] = bhMakeCameraVector_0x27a160; // 0x27a1d0 - g_ps2RecompiledFunctionTable[387202] = bhGetCameraPosition_0x27a210; // 0x27a210 - g_ps2RecompiledFunctionTable[387206] = bhGetCameraPosition_0x27a210; // 0x27a220 - g_ps2RecompiledFunctionTable[387223] = bhGetCameraPosition_0x27a210; // 0x27a264 - g_ps2RecompiledFunctionTable[387227] = bhGetCameraPosition_0x27a210; // 0x27a274 - g_ps2RecompiledFunctionTable[387231] = bhGetCameraPosition_0x27a210; // 0x27a284 - g_ps2RecompiledFunctionTable[387235] = bhGetCameraPosition_0x27a210; // 0x27a294 - g_ps2RecompiledFunctionTable[387246] = bhGetCameraPosition_0x27a210; // 0x27a2c0 - g_ps2RecompiledFunctionTable[387250] = bhCheckCut_0x27a2d0; // 0x27a2d0 - g_ps2RecompiledFunctionTable[387355] = bhCheckCut_0x27a2d0; // 0x27a474 - g_ps2RecompiledFunctionTable[387398] = bhCheckCut_0x27a2d0; // 0x27a520 - g_ps2RecompiledFunctionTable[387407] = bhCheckCut_0x27a2d0; // 0x27a544 - g_ps2RecompiledFunctionTable[387435] = bhCheckCut_0x27a2d0; // 0x27a5b4 - g_ps2RecompiledFunctionTable[387467] = bhCheckCut_0x27a2d0; // 0x27a634 - g_ps2RecompiledFunctionTable[387476] = bhCheckCut_0x27a2d0; // 0x27a658 - g_ps2RecompiledFunctionTable[387485] = bhCheckCut_0x27a2d0; // 0x27a67c - g_ps2RecompiledFunctionTable[387494] = bhCheckCut_0x27a2d0; // 0x27a6a0 - g_ps2RecompiledFunctionTable[387534] = bhCheckCut_0x27a2d0; // 0x27a740 - g_ps2RecompiledFunctionTable[387542] = bhCheckCut_0x27a2d0; // 0x27a760 - g_ps2RecompiledFunctionTable[387558] = bhCheckCut_0x27a2d0; // 0x27a7a0 - g_ps2RecompiledFunctionTable[387562] = bhCheckCut_0x27a2d0; // 0x27a7b0 - g_ps2RecompiledFunctionTable[387566] = bhCheckCut_0x27a2d0; // 0x27a7c0 - g_ps2RecompiledFunctionTable[387578] = bhCheckCutArea_0x27a7f0; // 0x27a7f0 - g_ps2RecompiledFunctionTable[387596] = bhCheckCutArea_0x27a7f0; // 0x27a838 - g_ps2RecompiledFunctionTable[387603] = bhCheckCutArea_0x27a7f0; // 0x27a854 - g_ps2RecompiledFunctionTable[387635] = bhCheckCutArea_0x27a7f0; // 0x27a8d4 - g_ps2RecompiledFunctionTable[387666] = bhCheckCutAreaInnerTriangle_0x27a950; // 0x27a950 - g_ps2RecompiledFunctionTable[387739] = bhCheckCutAreaInnerTriangle_0x27a950; // 0x27aa74 - g_ps2RecompiledFunctionTable[387743] = bhCheckCutAreaInnerTriangle_0x27a950; // 0x27aa84 - g_ps2RecompiledFunctionTable[387758] = bhCheckCutAttribute_0x27aac0; // 0x27aac0 - g_ps2RecompiledFunctionTable[387766] = bhCheckCutAttribute_0x27aac0; // 0x27aae0 - g_ps2RecompiledFunctionTable[387776] = bhCheckCutAttribute_0x27aac0; // 0x27ab08 - g_ps2RecompiledFunctionTable[387818] = bhSetCut_0x27abb0; // 0x27abb0 - g_ps2RecompiledFunctionTable[387834] = bhSetCut_0x27abb0; // 0x27abf0 - g_ps2RecompiledFunctionTable[387836] = bhSetCut_0x27abb0; // 0x27abf8 - g_ps2RecompiledFunctionTable[387838] = bhSetCut_0x27abb0; // 0x27ac00 - g_ps2RecompiledFunctionTable[387862] = bhSetCut_0x27abb0; // 0x27ac60 - g_ps2RecompiledFunctionTable[387894] = bhSetCut_0x27abb0; // 0x27ace0 - g_ps2RecompiledFunctionTable[387902] = bhSetCut_0x27abb0; // 0x27ad00 - g_ps2RecompiledFunctionTable[387925] = bhSetCut_0x27abb0; // 0x27ad5c - g_ps2RecompiledFunctionTable[387927] = bhSetCut_0x27abb0; // 0x27ad64 - g_ps2RecompiledFunctionTable[388160] = bhSetCut_0x27abb0; // 0x27b108 - g_ps2RecompiledFunctionTable[388162] = bhSetCut_0x27abb0; // 0x27b110 - g_ps2RecompiledFunctionTable[388170] = bhSetFixedCut_0x27b130; // 0x27b130 - g_ps2RecompiledFunctionTable[388216] = bhSetFixedCut_0x27b130; // 0x27b1e8 - g_ps2RecompiledFunctionTable[388387] = bhSetFixedCut_0x27b130; // 0x27b494 - g_ps2RecompiledFunctionTable[388389] = bhSetFixedCut_0x27b130; // 0x27b49c - g_ps2RecompiledFunctionTable[388391] = bhSetFixedCut_0x27b130; // 0x27b4a4 - g_ps2RecompiledFunctionTable[388398] = bhSetRenderCut_0x27b4c0; // 0x27b4c0 - g_ps2RecompiledFunctionTable[388416] = bhSetRenderCut_0x27b4c0; // 0x27b508 - g_ps2RecompiledFunctionTable[388458] = bhSetHideObjLgt_0x27b5b0; // 0x27b5b0 - g_ps2RecompiledFunctionTable[388485] = bhSetHideObjLgt_0x27b5b0; // 0x27b61c - g_ps2RecompiledFunctionTable[388493] = bhSetHideObjLgt_0x27b5b0; // 0x27b63c - g_ps2RecompiledFunctionTable[388517] = bhSetHideObjLgt_0x27b5b0; // 0x27b69c - g_ps2RecompiledFunctionTable[388519] = bhSetHideObjLgt_0x27b5b0; // 0x27b6a4 - g_ps2RecompiledFunctionTable[388546] = bhSetHideObject_0x27b710; // 0x27b710 - g_ps2RecompiledFunctionTable[388582] = bhSetHideObject_0x27b710; // 0x27b7a0 - g_ps2RecompiledFunctionTable[388590] = bhSetHideObject_0x27b710; // 0x27b7c0 - g_ps2RecompiledFunctionTable[388635] = bhSetHideObject_0x27b710; // 0x27b874 - g_ps2RecompiledFunctionTable[388643] = bhSetHideObject_0x27b710; // 0x27b894 - g_ps2RecompiledFunctionTable[388670] = bhInitActiveCamera_0x27b900; // 0x27b900 - g_ps2RecompiledFunctionTable[388728] = bhInitActiveCamera_0x27b900; // 0x27b9e8 - g_ps2RecompiledFunctionTable[388748] = bhInitActiveCamera_0x27b900; // 0x27ba38 - g_ps2RecompiledFunctionTable[388827] = bhInitActiveCamera_0x27b900; // 0x27bb74 - g_ps2RecompiledFunctionTable[388916] = bhInitActiveCamera_0x27b900; // 0x27bcd8 - g_ps2RecompiledFunctionTable[388952] = bhInitActiveCamera_0x27b900; // 0x27bd68 - g_ps2RecompiledFunctionTable[388960] = bhInitActiveCamera_0x27b900; // 0x27bd88 - g_ps2RecompiledFunctionTable[388986] = bhInitActiveCamera_0x27b900; // 0x27bdf0 - g_ps2RecompiledFunctionTable[389022] = bhInitActiveCamera_0x27b900; // 0x27be80 - g_ps2RecompiledFunctionTable[389032] = bhInitActiveCamera_0x27b900; // 0x27bea8 - g_ps2RecompiledFunctionTable[389052] = bhInitActiveCamera_0x27b900; // 0x27bef8 - g_ps2RecompiledFunctionTable[389088] = bhInitActiveCamera_0x27b900; // 0x27bf88 - g_ps2RecompiledFunctionTable[389096] = bhInitActiveCamera_0x27b900; // 0x27bfa8 - g_ps2RecompiledFunctionTable[389114] = bhInitActiveCamera_0x27b900; // 0x27bff0 - g_ps2RecompiledFunctionTable[389142] = bhInitActiveCamera_0x27b900; // 0x27c060 - g_ps2RecompiledFunctionTable[389149] = bhInitActiveCamera_0x27b900; // 0x27c07c - g_ps2RecompiledFunctionTable[389154] = bhInitActiveCamera_0x27b900; // 0x27c090 - g_ps2RecompiledFunctionTable[389191] = bhInitActiveCamera_0x27b900; // 0x27c124 - g_ps2RecompiledFunctionTable[389217] = bhInitActiveCamera_0x27b900; // 0x27c18c - g_ps2RecompiledFunctionTable[389222] = bhInitActiveCamera_0x27b900; // 0x27c1a0 - g_ps2RecompiledFunctionTable[389268] = bhInitActiveCamera_0x27b900; // 0x27c258 - g_ps2RecompiledFunctionTable[389296] = bhInitActiveCamera_0x27b900; // 0x27c2c8 - g_ps2RecompiledFunctionTable[389303] = bhInitActiveCamera_0x27b900; // 0x27c2e4 - g_ps2RecompiledFunctionTable[389308] = bhInitActiveCamera_0x27b900; // 0x27c2f8 - g_ps2RecompiledFunctionTable[389368] = bhInitActiveCamera_0x27b900; // 0x27c3e8 - g_ps2RecompiledFunctionTable[389394] = bhInitActiveCamera_0x27b900; // 0x27c450 - g_ps2RecompiledFunctionTable[389399] = bhInitActiveCamera_0x27b900; // 0x27c464 - g_ps2RecompiledFunctionTable[389462] = bhInitActiveCamera_0x27b900; // 0x27c560 - g_ps2RecompiledFunctionTable[389490] = bhInitActiveCamera_0x27b900; // 0x27c5d0 - g_ps2RecompiledFunctionTable[389497] = bhInitActiveCamera_0x27b900; // 0x27c5ec - g_ps2RecompiledFunctionTable[389502] = bhInitActiveCamera_0x27b900; // 0x27c600 - g_ps2RecompiledFunctionTable[389563] = bhInitActiveCamera_0x27b900; // 0x27c6f4 - g_ps2RecompiledFunctionTable[389589] = bhInitActiveCamera_0x27b900; // 0x27c75c - g_ps2RecompiledFunctionTable[389594] = bhInitActiveCamera_0x27b900; // 0x27c770 - g_ps2RecompiledFunctionTable[389652] = bhInitActiveCamera_0x27b900; // 0x27c858 - g_ps2RecompiledFunctionTable[389669] = bhInitActiveCamera_0x27b900; // 0x27c89c - g_ps2RecompiledFunctionTable[389672] = bhInitActiveCamera_0x27b900; // 0x27c8a8 - g_ps2RecompiledFunctionTable[389682] = bhInitActiveCamera_0x27b900; // 0x27c8d0 - g_ps2RecompiledFunctionTable[389714] = bhCheckNearAttrOffCutRange_0x27c950; // 0x27c950 - g_ps2RecompiledFunctionTable[389735] = bhCheckNearAttrOffCutRange_0x27c950; // 0x27c9a4 - g_ps2RecompiledFunctionTable[389761] = bhCheckNearAttrOffCutRange_0x27c950; // 0x27ca0c - g_ps2RecompiledFunctionTable[389780] = bhCheckNearAttrOffCutRange_0x27c950; // 0x27ca58 - g_ps2RecompiledFunctionTable[389798] = bhCheckNearAttrOffCutRange_0x27c950; // 0x27caa0 - g_ps2RecompiledFunctionTable[389816] = bhCheckNearAttrOffCutRange_0x27c950; // 0x27cae8 - g_ps2RecompiledFunctionTable[389846] = bhControlActiveCamera_0x27cb60; // 0x27cb60 - g_ps2RecompiledFunctionTable[389971] = bhControlActiveCamera_0x27cb60; // 0x27cd54 - g_ps2RecompiledFunctionTable[390079] = bhControlActiveCamera_0x27cb60; // 0x27cf04 - g_ps2RecompiledFunctionTable[390103] = bhControlActiveCamera_0x27cb60; // 0x27cf64 - g_ps2RecompiledFunctionTable[390110] = bhControlActiveCamera_0x27cb60; // 0x27cf80 - g_ps2RecompiledFunctionTable[390115] = bhControlActiveCamera_0x27cb60; // 0x27cf94 - g_ps2RecompiledFunctionTable[390135] = bhControlActiveCamera_0x27cb60; // 0x27cfe4 - g_ps2RecompiledFunctionTable[390140] = bhControlActiveCamera_0x27cb60; // 0x27cff8 - g_ps2RecompiledFunctionTable[390172] = bhControlActiveCamera_0x27cb60; // 0x27d078 - g_ps2RecompiledFunctionTable[390179] = bhControlActiveCamera_0x27cb60; // 0x27d094 - g_ps2RecompiledFunctionTable[390184] = bhControlActiveCamera_0x27cb60; // 0x27d0a8 - g_ps2RecompiledFunctionTable[390227] = bhControlActiveCamera_0x27cb60; // 0x27d154 - g_ps2RecompiledFunctionTable[390232] = bhControlActiveCamera_0x27cb60; // 0x27d168 - g_ps2RecompiledFunctionTable[390280] = bhControlActiveCamera_0x27cb60; // 0x27d228 - g_ps2RecompiledFunctionTable[390287] = bhControlActiveCamera_0x27cb60; // 0x27d244 - g_ps2RecompiledFunctionTable[390292] = bhControlActiveCamera_0x27cb60; // 0x27d258 - g_ps2RecompiledFunctionTable[390358] = bhControlActiveCamera_0x27cb60; // 0x27d360 - g_ps2RecompiledFunctionTable[390363] = bhControlActiveCamera_0x27cb60; // 0x27d374 - g_ps2RecompiledFunctionTable[390430] = bhControlActiveCamera_0x27cb60; // 0x27d480 - g_ps2RecompiledFunctionTable[390445] = bhControlActiveCamera_0x27cb60; // 0x27d4bc - g_ps2RecompiledFunctionTable[390510] = bhControlActiveCamera_0x27cb60; // 0x27d5c0 - g_ps2RecompiledFunctionTable[390536] = bhControlActiveCamera_0x27cb60; // 0x27d628 - g_ps2RecompiledFunctionTable[390561] = bhControlActiveCamera_0x27cb60; // 0x27d68c - g_ps2RecompiledFunctionTable[390604] = bhControlActiveCamera_0x27cb60; // 0x27d738 - g_ps2RecompiledFunctionTable[390682] = bhControlActiveCamera_0x27cb60; // 0x27d870 - g_ps2RecompiledFunctionTable[390708] = bhControlActiveCamera_0x27cb60; // 0x27d8d8 - g_ps2RecompiledFunctionTable[390733] = bhControlActiveCamera_0x27cb60; // 0x27d93c - g_ps2RecompiledFunctionTable[390764] = bhControlActiveCamera_0x27cb60; // 0x27d9b8 - g_ps2RecompiledFunctionTable[390794] = bhControlActiveCamera_0x27cb60; // 0x27da30 - g_ps2RecompiledFunctionTable[390822] = bhControlActiveCamera_0x27cb60; // 0x27daa0 - g_ps2RecompiledFunctionTable[390863] = bhControlActiveCamera_0x27cb60; // 0x27db44 - g_ps2RecompiledFunctionTable[390911] = bhControlActiveCamera_0x27cb60; // 0x27dc04 - g_ps2RecompiledFunctionTable[390914] = bhControlActiveCamera_0x27cb60; // 0x27dc10 - g_ps2RecompiledFunctionTable[390924] = bhControlActiveCamera_0x27cb60; // 0x27dc38 - g_ps2RecompiledFunctionTable[390958] = bhSetEventCamera_0x27dcc0; // 0x27dcc0 - g_ps2RecompiledFunctionTable[391057] = bhSetEventCamera_0x27dcc0; // 0x27de4c - g_ps2RecompiledFunctionTable[391069] = bhSetEventCamera_0x27dcc0; // 0x27de7c - g_ps2RecompiledFunctionTable[391075] = bhSetEventCamera_0x27dcc0; // 0x27de94 - g_ps2RecompiledFunctionTable[391080] = bhSetEventCamera_0x27dcc0; // 0x27dea8 - g_ps2RecompiledFunctionTable[391094] = bhSetEventCamera_0x27dcc0; // 0x27dee0 - g_ps2RecompiledFunctionTable[391099] = bhSetEventCamera_0x27dcc0; // 0x27def4 - g_ps2RecompiledFunctionTable[391122] = bhSetEventCamera_0x27dcc0; // 0x27df50 - g_ps2RecompiledFunctionTable[391182] = bhSetEventCamera_0x27dcc0; // 0x27e040 - g_ps2RecompiledFunctionTable[391190] = bhSetEventFixedCut_0x27e060; // 0x27e060 - g_ps2RecompiledFunctionTable[391295] = bhSetEventFixedCut_0x27e060; // 0x27e204 - g_ps2RecompiledFunctionTable[391362] = bhSetEventFixedCut_0x27e060; // 0x27e310 - g_ps2RecompiledFunctionTable[391370] = bhSetEventFixedCut_0x27e060; // 0x27e330 - g_ps2RecompiledFunctionTable[391372] = bhSetEventFixedCut_0x27e060; // 0x27e338 - g_ps2RecompiledFunctionTable[391378] = bhSetEventHideObjLgt_0x27e350; // 0x27e350 - g_ps2RecompiledFunctionTable[391397] = bhSetEventHideObjLgt_0x27e350; // 0x27e39c - g_ps2RecompiledFunctionTable[391405] = bhSetEventHideObjLgt_0x27e350; // 0x27e3bc - g_ps2RecompiledFunctionTable[391428] = bhSetEventHideObjLgt_0x27e350; // 0x27e418 - g_ps2RecompiledFunctionTable[391430] = bhSetEventHideObjLgt_0x27e350; // 0x27e420 - g_ps2RecompiledFunctionTable[391458] = bhInitEventCamera_0x27e490; // 0x27e490 - g_ps2RecompiledFunctionTable[391600] = bhInitEventCamera_0x27e490; // 0x27e6c8 - g_ps2RecompiledFunctionTable[391746] = bhControlEventCamera_0x27e910; // 0x27e910 - g_ps2RecompiledFunctionTable[391809] = bhControlEventCamera_0x27e910; // 0x27ea0c - g_ps2RecompiledFunctionTable[391819] = bhControlEventCamera_0x27e910; // 0x27ea34 - g_ps2RecompiledFunctionTable[391834] = bhControlEventCamera_0x27e910; // 0x27ea70 - g_ps2RecompiledFunctionTable[391865] = bhControlEventCamera_0x27e910; // 0x27eaec - g_ps2RecompiledFunctionTable[391890] = bhControlEventCamera_0x27e910; // 0x27eb50 - g_ps2RecompiledFunctionTable[391896] = bhControlEventCamera_0x27e910; // 0x27eb68 - g_ps2RecompiledFunctionTable[391904] = bhControlEventCamera_0x27e910; // 0x27eb88 - g_ps2RecompiledFunctionTable[391912] = bhControlEventCamera_0x27e910; // 0x27eba8 - g_ps2RecompiledFunctionTable[391957] = bhControlEventCamera_0x27e910; // 0x27ec5c - g_ps2RecompiledFunctionTable[391969] = bhControlEventCamera_0x27e910; // 0x27ec8c - g_ps2RecompiledFunctionTable[391975] = bhControlEventCamera_0x27e910; // 0x27eca4 - g_ps2RecompiledFunctionTable[391980] = bhControlEventCamera_0x27e910; // 0x27ecb8 - g_ps2RecompiledFunctionTable[391992] = bhControlEventCamera_0x27e910; // 0x27ece8 - g_ps2RecompiledFunctionTable[391997] = bhControlEventCamera_0x27e910; // 0x27ecfc - g_ps2RecompiledFunctionTable[392016] = bhControlEventCamera_0x27e910; // 0x27ed48 - g_ps2RecompiledFunctionTable[392022] = bhControlEventCamera_0x27e910; // 0x27ed60 - g_ps2RecompiledFunctionTable[392044] = bhControlEventCamera_0x27e910; // 0x27edb8 - g_ps2RecompiledFunctionTable[392097] = bhControlEventCamera_0x27e910; // 0x27ee8c - g_ps2RecompiledFunctionTable[392100] = bhControlEventCamera_0x27e910; // 0x27ee98 - g_ps2RecompiledFunctionTable[392104] = bhControlEventCamera_0x27e910; // 0x27eea8 - g_ps2RecompiledFunctionTable[392163] = bhControlEventCamera_0x27e910; // 0x27ef94 - g_ps2RecompiledFunctionTable[392168] = bhControlEventCamera_0x27e910; // 0x27efa8 - g_ps2RecompiledFunctionTable[392195] = bhControlEventCamera_0x27e910; // 0x27f014 - g_ps2RecompiledFunctionTable[392211] = bhControlEventCamera_0x27e910; // 0x27f054 - g_ps2RecompiledFunctionTable[392236] = bhControlEventCamera_0x27e910; // 0x27f0b8 - g_ps2RecompiledFunctionTable[392242] = bhControlEventCamera_0x27e910; // 0x27f0d0 - g_ps2RecompiledFunctionTable[392250] = bhControlEventCamera_0x27e910; // 0x27f0f0 - g_ps2RecompiledFunctionTable[392258] = bhControlEventCamera_0x27e910; // 0x27f110 - g_ps2RecompiledFunctionTable[392297] = bhControlEventCamera_0x27e910; // 0x27f1ac - g_ps2RecompiledFunctionTable[392309] = bhControlEventCamera_0x27e910; // 0x27f1dc - g_ps2RecompiledFunctionTable[392315] = bhControlEventCamera_0x27e910; // 0x27f1f4 - g_ps2RecompiledFunctionTable[392320] = bhControlEventCamera_0x27e910; // 0x27f208 - g_ps2RecompiledFunctionTable[392332] = bhControlEventCamera_0x27e910; // 0x27f238 - g_ps2RecompiledFunctionTable[392337] = bhControlEventCamera_0x27e910; // 0x27f24c - g_ps2RecompiledFunctionTable[392356] = bhControlEventCamera_0x27e910; // 0x27f298 - g_ps2RecompiledFunctionTable[392362] = bhControlEventCamera_0x27e910; // 0x27f2b0 - g_ps2RecompiledFunctionTable[392384] = bhControlEventCamera_0x27e910; // 0x27f308 - g_ps2RecompiledFunctionTable[392437] = bhControlEventCamera_0x27e910; // 0x27f3dc - g_ps2RecompiledFunctionTable[392440] = bhControlEventCamera_0x27e910; // 0x27f3e8 - g_ps2RecompiledFunctionTable[392444] = bhControlEventCamera_0x27e910; // 0x27f3f8 - g_ps2RecompiledFunctionTable[392458] = bhCheckEvtCamLockPosition_0x27f430; // 0x27f430 - g_ps2RecompiledFunctionTable[392515] = bhCheckEvtCamLockPosition_0x27f430; // 0x27f514 - g_ps2RecompiledFunctionTable[392525] = bhCheckEvtCamLockPosition_0x27f430; // 0x27f53c - g_ps2RecompiledFunctionTable[392530] = bhCheckEvtCamLockPosition_0x27f430; // 0x27f550 - g_ps2RecompiledFunctionTable[392535] = bhCheckEvtCamLockPosition_0x27f430; // 0x27f564 - g_ps2RecompiledFunctionTable[392545] = bhCheckEvtCamLockPosition_0x27f430; // 0x27f58c - g_ps2RecompiledFunctionTable[392550] = bhCheckEvtCamLockPosition_0x27f430; // 0x27f5a0 - g_ps2RecompiledFunctionTable[392587] = bhCheckEvtCamLockPosition_0x27f430; // 0x27f634 - g_ps2RecompiledFunctionTable[392597] = bhCheckEvtCamLockPosition_0x27f430; // 0x27f65c - g_ps2RecompiledFunctionTable[392602] = bhCheckEvtCamLockPosition_0x27f430; // 0x27f670 - g_ps2RecompiledFunctionTable[392607] = bhCheckEvtCamLockPosition_0x27f430; // 0x27f684 - g_ps2RecompiledFunctionTable[392617] = bhCheckEvtCamLockPosition_0x27f430; // 0x27f6ac - g_ps2RecompiledFunctionTable[392622] = bhCheckEvtCamLockPosition_0x27f430; // 0x27f6c0 - g_ps2RecompiledFunctionTable[392647] = bhCheckEvtCamLockPosition_0x27f430; // 0x27f724 - g_ps2RecompiledFunctionTable[392667] = bhCheckEvtCamLockPosition_0x27f430; // 0x27f774 - g_ps2RecompiledFunctionTable[392677] = bhCheckEvtCamLockPosition_0x27f430; // 0x27f79c - g_ps2RecompiledFunctionTable[392682] = bhCheckEvtCamLockPosition_0x27f430; // 0x27f7b0 - g_ps2RecompiledFunctionTable[392687] = bhCheckEvtCamLockPosition_0x27f430; // 0x27f7c4 - g_ps2RecompiledFunctionTable[392698] = bhCheckEvtCamLockPosition_0x27f430; // 0x27f7f0 - g_ps2RecompiledFunctionTable[392703] = bhCheckEvtCamLockPosition_0x27f430; // 0x27f804 - g_ps2RecompiledFunctionTable[392770] = bhCheckEvtCamLockPosition_0x27f430; // 0x27f910 - g_ps2RecompiledFunctionTable[392780] = bhCheckEvtCamLockPosition_0x27f430; // 0x27f938 - g_ps2RecompiledFunctionTable[392785] = bhCheckEvtCamLockPosition_0x27f430; // 0x27f94c - g_ps2RecompiledFunctionTable[392790] = bhCheckEvtCamLockPosition_0x27f430; // 0x27f960 - g_ps2RecompiledFunctionTable[392801] = bhCheckEvtCamLockPosition_0x27f430; // 0x27f98c - g_ps2RecompiledFunctionTable[392806] = bhCheckEvtCamLockPosition_0x27f430; // 0x27f9a0 - g_ps2RecompiledFunctionTable[392870] = bhGetEvtCamLockPosition_0x27faa0; // 0x27faa0 - g_ps2RecompiledFunctionTable[393016] = bhGetEvtCamLockPosition_0x27faa0; // 0x27fce8 - g_ps2RecompiledFunctionTable[393029] = bhGetEvtCamLockPosition_0x27faa0; // 0x27fd1c - g_ps2RecompiledFunctionTable[393034] = bhControlPlEyeCamera_0x27fd30; // 0x27fd30 - g_ps2RecompiledFunctionTable[393357] = bhControlPlEyeCamera_0x27fd30; // 0x28023c - g_ps2RecompiledFunctionTable[393522] = bhInitPlEyeCamera_0x2804d0; // 0x2804d0 - g_ps2RecompiledFunctionTable[393653] = bhInitPlEyeCamera_0x2804d0; // 0x2806dc - g_ps2RecompiledFunctionTable[393675] = bhInitPlEyeCamera_0x2804d0; // 0x280734 - g_ps2RecompiledFunctionTable[393752] = bhInitPlEyeCamera_0x2804d0; // 0x280868 - g_ps2RecompiledFunctionTable[393761] = bhInitPlEyeCamera_0x2804d0; // 0x28088c - g_ps2RecompiledFunctionTable[393766] = bhSetPlEyeCamera_0x2808a0; // 0x2808a0 - g_ps2RecompiledFunctionTable[393792] = bhSetPlEyeCamera_0x2808a0; // 0x280908 - g_ps2RecompiledFunctionTable[393867] = bhSetPlEyeCamera_0x2808a0; // 0x280a34 - g_ps2RecompiledFunctionTable[393914] = bhControlMonitorCamera_0x280af0; // 0x280af0 - g_ps2RecompiledFunctionTable[393918] = bhCalcActiveYpos_0x280b00; // 0x280b00 - g_ps2RecompiledFunctionTable[393954] = bhCalcActiveZang_0x280b90; // 0x280b90 - g_ps2RecompiledFunctionTable[393998] = bhCalcActivePers_0x280c40; // 0x280c40 - g_ps2RecompiledFunctionTable[394033] = bhCalcActivePers_0x280c40; // 0x280ccc - g_ps2RecompiledFunctionTable[394052] = bhCalcActivePers_0x280c40; // 0x280d18 - g_ps2RecompiledFunctionTable[394071] = bhCalcActivePers_0x280c40; // 0x280d64 - g_ps2RecompiledFunctionTable[394100] = bhCalcActivePers_0x280c40; // 0x280dd8 - g_ps2RecompiledFunctionTable[394117] = bhCalcActivePers_0x280c40; // 0x280e1c - g_ps2RecompiledFunctionTable[394126] = bhStFlg_0x280e40; // 0x280e40 - g_ps2RecompiledFunctionTable[394138] = bhCrFlg_0x280e70; // 0x280e70 - g_ps2RecompiledFunctionTable[394150] = bhCkFlg_0x280ea0; // 0x280ea0 - g_ps2RecompiledFunctionTable[394162] = bhInitLight_0x280ed0; // 0x280ed0 - g_ps2RecompiledFunctionTable[394169] = bhInitLight_0x280ed0; // 0x280eec - g_ps2RecompiledFunctionTable[394190] = bhSetLightTab_0x280f40; // 0x280f40 - g_ps2RecompiledFunctionTable[394294] = bhSetEasyDirLight_0x2810e0; // 0x2810e0 - g_ps2RecompiledFunctionTable[394334] = bhSetEasyDirLight_0x2810e0; // 0x281180 - g_ps2RecompiledFunctionTable[394355] = bhSetEasyDirLight_0x2810e0; // 0x2811d4 - g_ps2RecompiledFunctionTable[394360] = bhSetEasyDirLight_0x2810e0; // 0x2811e8 - g_ps2RecompiledFunctionTable[394369] = bhSetEasyDirLight_0x2810e0; // 0x28120c - g_ps2RecompiledFunctionTable[394375] = bhSetEasyDirLight_0x2810e0; // 0x281224 - g_ps2RecompiledFunctionTable[394380] = bhSetEasyDirLight_0x2810e0; // 0x281238 - g_ps2RecompiledFunctionTable[394389] = bhSetEasyDirLight_0x2810e0; // 0x28125c - g_ps2RecompiledFunctionTable[394394] = bhControlLight_0x281270; // 0x281270 - g_ps2RecompiledFunctionTable[394467] = bhControlLight_0x281270; // 0x281394 - g_ps2RecompiledFunctionTable[394509] = bhControlLight_0x281270; // 0x28143c - g_ps2RecompiledFunctionTable[394611] = bhControlLight_0x281270; // 0x2815d4 - g_ps2RecompiledFunctionTable[394634] = bhControlLight_0x281270; // 0x281630 - g_ps2RecompiledFunctionTable[394655] = bhControlLight_0x281270; // 0x281684 - g_ps2RecompiledFunctionTable[394670] = bhControlLight_0x281270; // 0x2816c0 - g_ps2RecompiledFunctionTable[394686] = bhControlLight_0x281270; // 0x281700 - g_ps2RecompiledFunctionTable[394699] = bhControlLight_0x281270; // 0x281734 - g_ps2RecompiledFunctionTable[394706] = bhControlLight_0x281270; // 0x281750 - g_ps2RecompiledFunctionTable[394719] = bhControlLight_0x281270; // 0x281784 - g_ps2RecompiledFunctionTable[394732] = bhControlLight_0x281270; // 0x2817b8 - g_ps2RecompiledFunctionTable[394739] = bhControlLight_0x281270; // 0x2817d4 - g_ps2RecompiledFunctionTable[394746] = bhControlLight_0x281270; // 0x2817f0 - g_ps2RecompiledFunctionTable[394759] = bhControlLight_0x281270; // 0x281824 - g_ps2RecompiledFunctionTable[394769] = bhControlLight_0x281270; // 0x28184c - g_ps2RecompiledFunctionTable[394771] = bhControlLight_0x281270; // 0x281854 - g_ps2RecompiledFunctionTable[394785] = bhControlLight_0x281270; // 0x28188c - g_ps2RecompiledFunctionTable[394794] = bhControlLight_0x281270; // 0x2818b0 - g_ps2RecompiledFunctionTable[394808] = bhControlLight_0x281270; // 0x2818e8 - g_ps2RecompiledFunctionTable[394817] = bhControlLight_0x281270; // 0x28190c - g_ps2RecompiledFunctionTable[394850] = bhControlLight_0x281270; // 0x281990 - g_ps2RecompiledFunctionTable[394862] = bhControlLight_0x281270; // 0x2819c0 - g_ps2RecompiledFunctionTable[394866] = bhControlLight_0x281270; // 0x2819d0 - g_ps2RecompiledFunctionTable[394874] = bhControlLight_0x281270; // 0x2819f0 - g_ps2RecompiledFunctionTable[394877] = bhControlLight_0x281270; // 0x2819fc - g_ps2RecompiledFunctionTable[394881] = bhControlLight_0x281270; // 0x281a0c - g_ps2RecompiledFunctionTable[394894] = bhControlLight_0x281270; // 0x281a40 - g_ps2RecompiledFunctionTable[394939] = bhControlLight_0x281270; // 0x281af4 - g_ps2RecompiledFunctionTable[394952] = bhControlLight_0x281270; // 0x281b28 - g_ps2RecompiledFunctionTable[395049] = bhControlLight_0x281270; // 0x281cac - g_ps2RecompiledFunctionTable[395061] = bhControlLight_0x281270; // 0x281cdc - g_ps2RecompiledFunctionTable[395065] = bhControlLight_0x281270; // 0x281cec - g_ps2RecompiledFunctionTable[395073] = bhControlLight_0x281270; // 0x281d0c - g_ps2RecompiledFunctionTable[395076] = bhControlLight_0x281270; // 0x281d18 - g_ps2RecompiledFunctionTable[395085] = bhControlLight_0x281270; // 0x281d3c - g_ps2RecompiledFunctionTable[395098] = bhControlLight_0x281270; // 0x281d70 - g_ps2RecompiledFunctionTable[395164] = bhControlLight_0x281270; // 0x281e78 - g_ps2RecompiledFunctionTable[395177] = bhControlLight_0x281270; // 0x281eac - g_ps2RecompiledFunctionTable[395195] = bhControlLight_0x281270; // 0x281ef4 - g_ps2RecompiledFunctionTable[395208] = bhControlLight_0x281270; // 0x281f28 - g_ps2RecompiledFunctionTable[395214] = bhControlLight_0x281270; // 0x281f40 - g_ps2RecompiledFunctionTable[395250] = bhControlLight_0x281270; // 0x281fd0 - g_ps2RecompiledFunctionTable[395379] = bhControlLight_0x281270; // 0x2821d4 - g_ps2RecompiledFunctionTable[395391] = bhControlLight_0x281270; // 0x282204 - g_ps2RecompiledFunctionTable[395477] = bhControlLight_0x281270; // 0x28235c - g_ps2RecompiledFunctionTable[395525] = bhControlLight_0x281270; // 0x28241c - g_ps2RecompiledFunctionTable[395529] = bhControlLight_0x281270; // 0x28242c - g_ps2RecompiledFunctionTable[395534] = bhControlLight_0x281270; // 0x282440 - g_ps2RecompiledFunctionTable[395537] = bhControlLight_0x281270; // 0x28244c - g_ps2RecompiledFunctionTable[395542] = bhControlLight_0x281270; // 0x282460 - g_ps2RecompiledFunctionTable[395546] = bhControlLight_0x281270; // 0x282470 - g_ps2RecompiledFunctionTable[395551] = bhControlLight_0x281270; // 0x282484 - g_ps2RecompiledFunctionTable[395554] = bhControlLight_0x281270; // 0x282490 - g_ps2RecompiledFunctionTable[395602] = bhControlLight_0x281270; // 0x282550 - g_ps2RecompiledFunctionTable[395616] = bhControlLight_0x281270; // 0x282588 - g_ps2RecompiledFunctionTable[395619] = bhControlLight_0x281270; // 0x282594 - g_ps2RecompiledFunctionTable[395624] = bhControlLight_0x281270; // 0x2825a8 - g_ps2RecompiledFunctionTable[395627] = bhControlLight_0x281270; // 0x2825b4 - g_ps2RecompiledFunctionTable[395632] = bhControlLight_0x281270; // 0x2825c8 - g_ps2RecompiledFunctionTable[395635] = bhControlLight_0x281270; // 0x2825d4 - g_ps2RecompiledFunctionTable[395640] = bhControlLight_0x281270; // 0x2825e8 - g_ps2RecompiledFunctionTable[395645] = bhControlLight_0x281270; // 0x2825fc - g_ps2RecompiledFunctionTable[395648] = bhControlLight_0x281270; // 0x282608 - g_ps2RecompiledFunctionTable[395653] = bhControlLight_0x281270; // 0x28261c - g_ps2RecompiledFunctionTable[395703] = bhControlLight_0x281270; // 0x2826e4 - g_ps2RecompiledFunctionTable[395715] = bhControlLight_0x281270; // 0x282714 - g_ps2RecompiledFunctionTable[395718] = bhControlLight_0x281270; // 0x282720 - g_ps2RecompiledFunctionTable[395731] = bhControlLight_0x281270; // 0x282754 - g_ps2RecompiledFunctionTable[395743] = bhControlLight_0x281270; // 0x282784 - g_ps2RecompiledFunctionTable[395746] = bhControlLight_0x281270; // 0x282790 - g_ps2RecompiledFunctionTable[395755] = bhControlLight_0x281270; // 0x2827b4 - g_ps2RecompiledFunctionTable[395767] = bhControlLight_0x281270; // 0x2827e4 - g_ps2RecompiledFunctionTable[395772] = bhControlLight_0x281270; // 0x2827f8 - g_ps2RecompiledFunctionTable[395778] = bhControlLight_0x281270; // 0x282810 - g_ps2RecompiledFunctionTable[395790] = bhControlLight_0x281270; // 0x282840 - g_ps2RecompiledFunctionTable[395795] = bhControlLight_0x281270; // 0x282854 - g_ps2RecompiledFunctionTable[395799] = bhControlLight_0x281270; // 0x282864 - g_ps2RecompiledFunctionTable[395806] = bhControlLight_0x281270; // 0x282880 - g_ps2RecompiledFunctionTable[395808] = bhControlLight_0x281270; // 0x282888 - g_ps2RecompiledFunctionTable[395811] = bhControlLight_0x281270; // 0x282894 - g_ps2RecompiledFunctionTable[395819] = bhControlLight_0x281270; // 0x2828b4 - g_ps2RecompiledFunctionTable[395821] = bhControlLight_0x281270; // 0x2828bc - g_ps2RecompiledFunctionTable[395823] = bhControlLight_0x281270; // 0x2828c4 - g_ps2RecompiledFunctionTable[395825] = bhControlLight_0x281270; // 0x2828cc - g_ps2RecompiledFunctionTable[395850] = bhSetLight_0x282930; // 0x282930 - g_ps2RecompiledFunctionTable[395864] = bhSetLight_0x282930; // 0x282968 - g_ps2RecompiledFunctionTable[395876] = bhSetLight_0x282930; // 0x282998 - g_ps2RecompiledFunctionTable[395879] = bhSetLight_0x282930; // 0x2829a4 - g_ps2RecompiledFunctionTable[395884] = bhSetLight_0x282930; // 0x2829b8 - g_ps2RecompiledFunctionTable[395887] = bhSetLight_0x282930; // 0x2829c4 - g_ps2RecompiledFunctionTable[395892] = bhSetLight_0x282930; // 0x2829d8 - g_ps2RecompiledFunctionTable[395895] = bhSetLight_0x282930; // 0x2829e4 - g_ps2RecompiledFunctionTable[395900] = bhSetLight_0x282930; // 0x2829f8 - g_ps2RecompiledFunctionTable[395905] = bhSetLight_0x282930; // 0x282a0c - g_ps2RecompiledFunctionTable[395908] = bhSetLight_0x282930; // 0x282a18 - g_ps2RecompiledFunctionTable[395913] = bhSetLight_0x282930; // 0x282a2c - g_ps2RecompiledFunctionTable[395926] = bhSetLight_0x282930; // 0x282a60 - g_ps2RecompiledFunctionTable[395938] = bhSetLight_0x282930; // 0x282a90 - g_ps2RecompiledFunctionTable[395941] = bhSetLight_0x282930; // 0x282a9c - g_ps2RecompiledFunctionTable[395954] = bhSetLight_0x282930; // 0x282ad0 - g_ps2RecompiledFunctionTable[395966] = bhSetLight_0x282930; // 0x282b00 - g_ps2RecompiledFunctionTable[395969] = bhSetLight_0x282930; // 0x282b0c - g_ps2RecompiledFunctionTable[395978] = bhSetLight_0x282930; // 0x282b30 - g_ps2RecompiledFunctionTable[395990] = bhSetLight_0x282930; // 0x282b60 - g_ps2RecompiledFunctionTable[395995] = bhSetLight_0x282930; // 0x282b74 - g_ps2RecompiledFunctionTable[396001] = bhSetLight_0x282930; // 0x282b8c - g_ps2RecompiledFunctionTable[396013] = bhSetLight_0x282930; // 0x282bbc - g_ps2RecompiledFunctionTable[396018] = bhSetLight_0x282930; // 0x282bd0 - g_ps2RecompiledFunctionTable[396022] = bhSetLight_0x282930; // 0x282be0 - g_ps2RecompiledFunctionTable[396029] = bhSetLight_0x282930; // 0x282bfc - g_ps2RecompiledFunctionTable[396034] = bhSetLight_0x282930; // 0x282c10 - g_ps2RecompiledFunctionTable[396039] = bhSetLight_0x282930; // 0x282c24 - g_ps2RecompiledFunctionTable[396054] = bhSetLight_0x282930; // 0x282c60 - g_ps2RecompiledFunctionTable[396056] = bhSetLight_0x282930; // 0x282c68 - g_ps2RecompiledFunctionTable[396058] = bhSetLight_0x282930; // 0x282c70 - g_ps2RecompiledFunctionTable[396066] = bhSetHalfLight_0x282c90; // 0x282c90 - g_ps2RecompiledFunctionTable[396084] = bhSetHalfLight_0x282c90; // 0x282cd8 - g_ps2RecompiledFunctionTable[396096] = bhSetHalfLight_0x282c90; // 0x282d08 - g_ps2RecompiledFunctionTable[396099] = bhSetHalfLight_0x282c90; // 0x282d14 - g_ps2RecompiledFunctionTable[396104] = bhSetHalfLight_0x282c90; // 0x282d28 - g_ps2RecompiledFunctionTable[396107] = bhSetHalfLight_0x282c90; // 0x282d34 - g_ps2RecompiledFunctionTable[396112] = bhSetHalfLight_0x282c90; // 0x282d48 - g_ps2RecompiledFunctionTable[396115] = bhSetHalfLight_0x282c90; // 0x282d54 - g_ps2RecompiledFunctionTable[396120] = bhSetHalfLight_0x282c90; // 0x282d68 - g_ps2RecompiledFunctionTable[396125] = bhSetHalfLight_0x282c90; // 0x282d7c - g_ps2RecompiledFunctionTable[396128] = bhSetHalfLight_0x282c90; // 0x282d88 - g_ps2RecompiledFunctionTable[396133] = bhSetHalfLight_0x282c90; // 0x282d9c - g_ps2RecompiledFunctionTable[396154] = bhSetHalfLight_0x282c90; // 0x282df0 - g_ps2RecompiledFunctionTable[396166] = bhSetHalfLight_0x282c90; // 0x282e20 - g_ps2RecompiledFunctionTable[396169] = bhSetHalfLight_0x282c90; // 0x282e2c - g_ps2RecompiledFunctionTable[396174] = bhSetHalfLight_0x282c90; // 0x282e40 - g_ps2RecompiledFunctionTable[396186] = bhSetHalfLight_0x282c90; // 0x282e70 - g_ps2RecompiledFunctionTable[396189] = bhSetHalfLight_0x282c90; // 0x282e7c - g_ps2RecompiledFunctionTable[396198] = bhSetHalfLight_0x282c90; // 0x282ea0 - g_ps2RecompiledFunctionTable[396202] = bhSetHalfLight_0x282c90; // 0x282eb0 - g_ps2RecompiledFunctionTable[396207] = bhSetHalfLight_0x282c90; // 0x282ec4 - g_ps2RecompiledFunctionTable[396213] = bhSetHalfLight_0x282c90; // 0x282edc - g_ps2RecompiledFunctionTable[396217] = bhSetHalfLight_0x282c90; // 0x282eec - g_ps2RecompiledFunctionTable[396222] = bhSetHalfLight_0x282c90; // 0x282f00 - g_ps2RecompiledFunctionTable[396226] = bhSetHalfLight_0x282c90; // 0x282f10 - g_ps2RecompiledFunctionTable[396233] = bhSetHalfLight_0x282c90; // 0x282f2c - g_ps2RecompiledFunctionTable[396246] = bhSetHalfLight_0x282c90; // 0x282f60 - g_ps2RecompiledFunctionTable[396251] = bhSetHalfLight_0x282c90; // 0x282f74 - g_ps2RecompiledFunctionTable[396266] = bhSetHalfLight_0x282c90; // 0x282fb0 - g_ps2RecompiledFunctionTable[396268] = bhSetHalfLight_0x282c90; // 0x282fb8 - g_ps2RecompiledFunctionTable[396270] = bhSetHalfLight_0x282c90; // 0x282fc0 - g_ps2RecompiledFunctionTable[396278] = bhGetLightVector_0x282fe0; // 0x282fe0 - g_ps2RecompiledFunctionTable[396297] = bhGetLightVector_0x282fe0; // 0x28302c - g_ps2RecompiledFunctionTable[396300] = bhGetLightVector_0x282fe0; // 0x283038 - g_ps2RecompiledFunctionTable[396303] = bhGetLightVector_0x282fe0; // 0x283044 - g_ps2RecompiledFunctionTable[396306] = bhGetLightVector_0x282fe0; // 0x283050 - g_ps2RecompiledFunctionTable[396310] = bhGetLightVector_0x282fe0; // 0x283060 - g_ps2RecompiledFunctionTable[396318] = bhInitObjItm_0x283080; // 0x283080 - g_ps2RecompiledFunctionTable[396328] = bhInitObjItm_0x283080; // 0x2830a8 - g_ps2RecompiledFunctionTable[396336] = bhInitObjItm_0x283080; // 0x2830c8 - g_ps2RecompiledFunctionTable[396342] = bhSetObject_0x2830e0; // 0x2830e0 - g_ps2RecompiledFunctionTable[396366] = bhSetObject_0x2830e0; // 0x283140 - g_ps2RecompiledFunctionTable[396442] = bhSetItem_0x283270; // 0x283270 - g_ps2RecompiledFunctionTable[396466] = bhSetItem_0x283270; // 0x2832d0 - g_ps2RecompiledFunctionTable[396542] = bhControlObjItm_0x283400; // 0x283400 - g_ps2RecompiledFunctionTable[396543] = bhControlObjItm_0x283400; // 0x283404 - g_ps2RecompiledFunctionTable[396544] = bhControlObjItm_0x283400; // 0x283408 - g_ps2RecompiledFunctionTable[396545] = bhControlObjItm_0x283400; // 0x28340c - g_ps2RecompiledFunctionTable[396546] = bhControlObjItm_0x283400; // 0x283410 - g_ps2RecompiledFunctionTable[396547] = bhControlObjItm_0x283400; // 0x283414 - g_ps2RecompiledFunctionTable[396548] = bhControlObjItm_0x283400; // 0x283418 - g_ps2RecompiledFunctionTable[396549] = bhControlObjItm_0x283400; // 0x28341c - g_ps2RecompiledFunctionTable[396550] = bhControlObjItm_0x283400; // 0x283420 - g_ps2RecompiledFunctionTable[396551] = bhControlObjItm_0x283400; // 0x283424 - g_ps2RecompiledFunctionTable[396552] = bhControlObjItm_0x283400; // 0x283428 - g_ps2RecompiledFunctionTable[396553] = bhControlObjItm_0x283400; // 0x28342c - g_ps2RecompiledFunctionTable[396554] = bhControlObjItm_0x283400; // 0x283430 - g_ps2RecompiledFunctionTable[396555] = bhControlObjItm_0x283400; // 0x283434 - g_ps2RecompiledFunctionTable[396556] = bhControlObjItm_0x283400; // 0x283438 - g_ps2RecompiledFunctionTable[396557] = bhControlObjItm_0x283400; // 0x28343c - g_ps2RecompiledFunctionTable[396558] = bhControlObjItm_0x283400; // 0x283440 - g_ps2RecompiledFunctionTable[396559] = bhControlObjItm_0x283400; // 0x283444 - g_ps2RecompiledFunctionTable[396560] = bhControlObjItm_0x283400; // 0x283448 - g_ps2RecompiledFunctionTable[396561] = bhControlObjItm_0x283400; // 0x28344c - g_ps2RecompiledFunctionTable[396562] = bhControlObjItm_0x283400; // 0x283450 - g_ps2RecompiledFunctionTable[396563] = bhControlObjItm_0x283400; // 0x283454 - g_ps2RecompiledFunctionTable[396564] = bhControlObjItm_0x283400; // 0x283458 - g_ps2RecompiledFunctionTable[396565] = bhControlObjItm_0x283400; // 0x28345c - g_ps2RecompiledFunctionTable[396566] = bhControlObjItm_0x283400; // 0x283460 - g_ps2RecompiledFunctionTable[396567] = bhControlObjItm_0x283400; // 0x283464 - g_ps2RecompiledFunctionTable[396568] = bhControlObjItm_0x283400; // 0x283468 - g_ps2RecompiledFunctionTable[396569] = bhControlObjItm_0x283400; // 0x28346c - g_ps2RecompiledFunctionTable[396570] = bhControlObjItm_0x283400; // 0x283470 - g_ps2RecompiledFunctionTable[396571] = bhControlObjItm_0x283400; // 0x283474 - g_ps2RecompiledFunctionTable[396572] = bhControlObjItm_0x283400; // 0x283478 - g_ps2RecompiledFunctionTable[396573] = bhControlObjItm_0x283400; // 0x28347c - g_ps2RecompiledFunctionTable[396574] = bhControlObjItm_0x283400; // 0x283480 - g_ps2RecompiledFunctionTable[396575] = bhControlObjItm_0x283400; // 0x283484 - g_ps2RecompiledFunctionTable[396576] = bhControlObjItm_0x283400; // 0x283488 - g_ps2RecompiledFunctionTable[396577] = bhControlObjItm_0x283400; // 0x28348c - g_ps2RecompiledFunctionTable[396578] = bhControlObjItm_0x283400; // 0x283490 - g_ps2RecompiledFunctionTable[396579] = bhControlObjItm_0x283400; // 0x283494 - g_ps2RecompiledFunctionTable[396580] = bhControlObjItm_0x283400; // 0x283498 - g_ps2RecompiledFunctionTable[396581] = bhControlObjItm_0x283400; // 0x28349c - g_ps2RecompiledFunctionTable[396582] = bhControlObjItm_0x283400; // 0x2834a0 - g_ps2RecompiledFunctionTable[396583] = bhControlObjItm_0x283400; // 0x2834a4 - g_ps2RecompiledFunctionTable[396584] = bhControlObjItm_0x283400; // 0x2834a8 - g_ps2RecompiledFunctionTable[396585] = bhControlObjItm_0x283400; // 0x2834ac - g_ps2RecompiledFunctionTable[396586] = bhControlObjItm_0x283400; // 0x2834b0 - g_ps2RecompiledFunctionTable[396587] = bhControlObjItm_0x283400; // 0x2834b4 - g_ps2RecompiledFunctionTable[396588] = bhControlObjItm_0x283400; // 0x2834b8 - g_ps2RecompiledFunctionTable[396589] = bhControlObjItm_0x283400; // 0x2834bc - g_ps2RecompiledFunctionTable[396590] = bhControlObjItm_0x283400; // 0x2834c0 - g_ps2RecompiledFunctionTable[396591] = bhControlObjItm_0x283400; // 0x2834c4 - g_ps2RecompiledFunctionTable[396592] = bhControlObjItm_0x283400; // 0x2834c8 - g_ps2RecompiledFunctionTable[396593] = bhControlObjItm_0x283400; // 0x2834cc - g_ps2RecompiledFunctionTable[396594] = bhControlObjItm_0x283400; // 0x2834d0 - g_ps2RecompiledFunctionTable[396595] = bhControlObjItm_0x283400; // 0x2834d4 - g_ps2RecompiledFunctionTable[396596] = bhControlObjItm_0x283400; // 0x2834d8 - g_ps2RecompiledFunctionTable[396597] = bhControlObjItm_0x283400; // 0x2834dc - g_ps2RecompiledFunctionTable[396598] = bhControlObjItm_0x283400; // 0x2834e0 - g_ps2RecompiledFunctionTable[396599] = bhControlObjItm_0x283400; // 0x2834e4 - g_ps2RecompiledFunctionTable[396600] = bhControlObjItm_0x283400; // 0x2834e8 - g_ps2RecompiledFunctionTable[396601] = bhControlObjItm_0x283400; // 0x2834ec - g_ps2RecompiledFunctionTable[396602] = bhControlObjItm_0x283400; // 0x2834f0 - g_ps2RecompiledFunctionTable[396603] = bhControlObjItm_0x283400; // 0x2834f4 - g_ps2RecompiledFunctionTable[396604] = bhControlObjItm_0x283400; // 0x2834f8 - g_ps2RecompiledFunctionTable[396605] = bhControlObjItm_0x283400; // 0x2834fc - g_ps2RecompiledFunctionTable[396606] = bhControlObjItm_0x283400; // 0x283500 - g_ps2RecompiledFunctionTable[396607] = bhControlObjItm_0x283400; // 0x283504 - g_ps2RecompiledFunctionTable[396608] = bhControlObjItm_0x283400; // 0x283508 - g_ps2RecompiledFunctionTable[396609] = bhControlObjItm_0x283400; // 0x28350c - g_ps2RecompiledFunctionTable[396610] = bhControlObjItm_0x283400; // 0x283510 - g_ps2RecompiledFunctionTable[396611] = bhControlObjItm_0x283400; // 0x283514 - g_ps2RecompiledFunctionTable[396612] = bhControlObjItm_0x283400; // 0x283518 - g_ps2RecompiledFunctionTable[396613] = bhControlObjItm_0x283400; // 0x28351c - g_ps2RecompiledFunctionTable[396614] = bhControlObjItm_0x283400; // 0x283520 - g_ps2RecompiledFunctionTable[396615] = bhControlObjItm_0x283400; // 0x283524 - g_ps2RecompiledFunctionTable[396616] = bhControlObjItm_0x283400; // 0x283528 - g_ps2RecompiledFunctionTable[396617] = bhControlObjItm_0x283400; // 0x28352c - g_ps2RecompiledFunctionTable[396618] = bhControlObjItm_0x283400; // 0x283530 - g_ps2RecompiledFunctionTable[396619] = bhControlObjItm_0x283400; // 0x283534 - g_ps2RecompiledFunctionTable[396620] = bhControlObjItm_0x283400; // 0x283538 - g_ps2RecompiledFunctionTable[396621] = bhControlObjItm_0x283400; // 0x28353c - g_ps2RecompiledFunctionTable[396622] = bhControlObjItm_0x283400; // 0x283540 - g_ps2RecompiledFunctionTable[396623] = bhControlObjItm_0x283400; // 0x283544 - g_ps2RecompiledFunctionTable[396624] = bhControlObjItm_0x283400; // 0x283548 - g_ps2RecompiledFunctionTable[396625] = bhControlObjItm_0x283400; // 0x28354c - g_ps2RecompiledFunctionTable[396626] = bhControlObjItm_0x283400; // 0x283550 - g_ps2RecompiledFunctionTable[396627] = bhControlObjItm_0x283400; // 0x283554 - g_ps2RecompiledFunctionTable[396628] = bhControlObjItm_0x283400; // 0x283558 - g_ps2RecompiledFunctionTable[396629] = bhControlObjItm_0x283400; // 0x28355c - g_ps2RecompiledFunctionTable[396630] = bhControlObjItm_0x283400; // 0x283560 - g_ps2RecompiledFunctionTable[396631] = bhControlObjItm_0x283400; // 0x283564 - g_ps2RecompiledFunctionTable[396632] = bhControlObjItm_0x283400; // 0x283568 - g_ps2RecompiledFunctionTable[396633] = bhControlObjItm_0x283400; // 0x28356c - g_ps2RecompiledFunctionTable[396634] = bhControlObjItm_0x283400; // 0x283570 - g_ps2RecompiledFunctionTable[396635] = bhControlObjItm_0x283400; // 0x283574 - g_ps2RecompiledFunctionTable[396636] = bhControlObjItm_0x283400; // 0x283578 - g_ps2RecompiledFunctionTable[396637] = bhControlObjItm_0x283400; // 0x28357c - g_ps2RecompiledFunctionTable[396638] = bhControlObjItm_0x283400; // 0x283580 - g_ps2RecompiledFunctionTable[396639] = bhControlObjItm_0x283400; // 0x283584 - g_ps2RecompiledFunctionTable[396640] = bhControlObjItm_0x283400; // 0x283588 - g_ps2RecompiledFunctionTable[396641] = bhControlObjItm_0x283400; // 0x28358c - g_ps2RecompiledFunctionTable[396642] = bhControlObjItm_0x283400; // 0x283590 - g_ps2RecompiledFunctionTable[396643] = bhControlObjItm_0x283400; // 0x283594 - g_ps2RecompiledFunctionTable[396644] = bhControlObjItm_0x283400; // 0x283598 - g_ps2RecompiledFunctionTable[396645] = bhControlObjItm_0x283400; // 0x28359c - g_ps2RecompiledFunctionTable[396646] = bhControlObjItm_0x283400; // 0x2835a0 - g_ps2RecompiledFunctionTable[396647] = bhControlObjItm_0x283400; // 0x2835a4 - g_ps2RecompiledFunctionTable[396648] = bhControlObjItm_0x283400; // 0x2835a8 - g_ps2RecompiledFunctionTable[396649] = bhControlObjItm_0x283400; // 0x2835ac - g_ps2RecompiledFunctionTable[396650] = bhControlObjItm_0x283400; // 0x2835b0 - g_ps2RecompiledFunctionTable[396651] = bhControlObjItm_0x283400; // 0x2835b4 - g_ps2RecompiledFunctionTable[396652] = bhControlObjItm_0x283400; // 0x2835b8 - g_ps2RecompiledFunctionTable[396653] = bhControlObjItm_0x283400; // 0x2835bc - g_ps2RecompiledFunctionTable[396654] = bhControlObjItm_0x283400; // 0x2835c0 - g_ps2RecompiledFunctionTable[396655] = bhControlObjItm_0x283400; // 0x2835c4 - g_ps2RecompiledFunctionTable[396656] = bhControlObjItm_0x283400; // 0x2835c8 - g_ps2RecompiledFunctionTable[396657] = bhControlObjItm_0x283400; // 0x2835cc - g_ps2RecompiledFunctionTable[396658] = bhControlObjItm_0x283400; // 0x2835d0 - g_ps2RecompiledFunctionTable[396659] = bhControlObjItm_0x283400; // 0x2835d4 - g_ps2RecompiledFunctionTable[396660] = bhControlObjItm_0x283400; // 0x2835d8 - g_ps2RecompiledFunctionTable[396661] = bhControlObjItm_0x283400; // 0x2835dc - g_ps2RecompiledFunctionTable[396662] = bhControlObjItm_0x283400; // 0x2835e0 - g_ps2RecompiledFunctionTable[396663] = bhControlObjItm_0x283400; // 0x2835e4 - g_ps2RecompiledFunctionTable[396664] = bhControlObjItm_0x283400; // 0x2835e8 - g_ps2RecompiledFunctionTable[396665] = bhControlObjItm_0x283400; // 0x2835ec - g_ps2RecompiledFunctionTable[396666] = bhControlObjItm_0x283400; // 0x2835f0 - g_ps2RecompiledFunctionTable[396667] = bhControlObjItm_0x283400; // 0x2835f4 - g_ps2RecompiledFunctionTable[396668] = bhControlObjItm_0x283400; // 0x2835f8 - g_ps2RecompiledFunctionTable[396669] = bhControlObjItm_0x283400; // 0x2835fc - g_ps2RecompiledFunctionTable[396670] = bhControlObjItm_0x283400; // 0x283600 - g_ps2RecompiledFunctionTable[396671] = bhControlObjItm_0x283400; // 0x283604 - g_ps2RecompiledFunctionTable[396672] = bhControlObjItm_0x283400; // 0x283608 - g_ps2RecompiledFunctionTable[396673] = bhControlObjItm_0x283400; // 0x28360c - g_ps2RecompiledFunctionTable[396674] = bhControlObjItm_0x283400; // 0x283610 - g_ps2RecompiledFunctionTable[396675] = bhControlObjItm_0x283400; // 0x283614 - g_ps2RecompiledFunctionTable[396676] = bhControlObjItm_0x283400; // 0x283618 - g_ps2RecompiledFunctionTable[396677] = bhControlObjItm_0x283400; // 0x28361c - g_ps2RecompiledFunctionTable[396678] = bhControlObjItm_0x283400; // 0x283620 - g_ps2RecompiledFunctionTable[396679] = bhControlObjItm_0x283400; // 0x283624 - g_ps2RecompiledFunctionTable[396680] = bhControlObjItm_0x283400; // 0x283628 - g_ps2RecompiledFunctionTable[396681] = bhControlObjItm_0x283400; // 0x28362c - g_ps2RecompiledFunctionTable[396682] = bhControlObjItm_0x283400; // 0x283630 - g_ps2RecompiledFunctionTable[396683] = bhControlObjItm_0x283400; // 0x283634 - g_ps2RecompiledFunctionTable[396684] = bhControlObjItm_0x283400; // 0x283638 - g_ps2RecompiledFunctionTable[396685] = bhControlObjItm_0x283400; // 0x28363c - g_ps2RecompiledFunctionTable[396686] = bhControlObjItm_0x283400; // 0x283640 - g_ps2RecompiledFunctionTable[396687] = bhControlObjItm_0x283400; // 0x283644 - g_ps2RecompiledFunctionTable[396688] = bhControlObjItm_0x283400; // 0x283648 - g_ps2RecompiledFunctionTable[396689] = bhControlObjItm_0x283400; // 0x28364c - g_ps2RecompiledFunctionTable[396690] = bhControlObjItm_0x283400; // 0x283650 - g_ps2RecompiledFunctionTable[396691] = bhControlObjItm_0x283400; // 0x283654 - g_ps2RecompiledFunctionTable[396692] = bhControlObjItm_0x283400; // 0x283658 - g_ps2RecompiledFunctionTable[396693] = bhControlObjItm_0x283400; // 0x28365c - g_ps2RecompiledFunctionTable[396694] = bhControlObjItm_0x283400; // 0x283660 - g_ps2RecompiledFunctionTable[396695] = bhControlObjItm_0x283400; // 0x283664 - g_ps2RecompiledFunctionTable[396696] = bhControlObjItm_0x283400; // 0x283668 - g_ps2RecompiledFunctionTable[396697] = bhControlObjItm_0x283400; // 0x28366c - g_ps2RecompiledFunctionTable[396698] = bhControlObjItm_0x283400; // 0x283670 - g_ps2RecompiledFunctionTable[396699] = bhControlObjItm_0x283400; // 0x283674 - g_ps2RecompiledFunctionTable[396700] = bhControlObjItm_0x283400; // 0x283678 - g_ps2RecompiledFunctionTable[396701] = bhControlObjItm_0x283400; // 0x28367c - g_ps2RecompiledFunctionTable[396702] = bhControlObjItm_0x283400; // 0x283680 - g_ps2RecompiledFunctionTable[396703] = bhControlObjItm_0x283400; // 0x283684 - g_ps2RecompiledFunctionTable[396704] = bhControlObjItm_0x283400; // 0x283688 - g_ps2RecompiledFunctionTable[396705] = bhControlObjItm_0x283400; // 0x28368c - g_ps2RecompiledFunctionTable[396706] = bhControlObjItm_0x283400; // 0x283690 - g_ps2RecompiledFunctionTable[396707] = bhControlObjItm_0x283400; // 0x283694 - g_ps2RecompiledFunctionTable[396708] = bhControlObjItm_0x283400; // 0x283698 - g_ps2RecompiledFunctionTable[396709] = bhControlObjItm_0x283400; // 0x28369c - g_ps2RecompiledFunctionTable[396710] = bhControlObjItm_0x283400; // 0x2836a0 - g_ps2RecompiledFunctionTable[396711] = bhControlObjItm_0x283400; // 0x2836a4 - g_ps2RecompiledFunctionTable[396712] = bhControlObjItm_0x283400; // 0x2836a8 - g_ps2RecompiledFunctionTable[396713] = bhControlObjItm_0x283400; // 0x2836ac - g_ps2RecompiledFunctionTable[396714] = bhControlObjItm_0x283400; // 0x2836b0 - g_ps2RecompiledFunctionTable[396715] = bhControlObjItm_0x283400; // 0x2836b4 - g_ps2RecompiledFunctionTable[396716] = bhControlObjItm_0x283400; // 0x2836b8 - g_ps2RecompiledFunctionTable[396717] = bhControlObjItm_0x283400; // 0x2836bc - g_ps2RecompiledFunctionTable[396718] = bhControlObjItm_0x283400; // 0x2836c0 - g_ps2RecompiledFunctionTable[396719] = bhControlObjItm_0x283400; // 0x2836c4 - g_ps2RecompiledFunctionTable[396720] = bhControlObjItm_0x283400; // 0x2836c8 - g_ps2RecompiledFunctionTable[396721] = bhControlObjItm_0x283400; // 0x2836cc - g_ps2RecompiledFunctionTable[396722] = bhControlObjItm_0x283400; // 0x2836d0 - g_ps2RecompiledFunctionTable[396723] = bhControlObjItm_0x283400; // 0x2836d4 - g_ps2RecompiledFunctionTable[396724] = bhControlObjItm_0x283400; // 0x2836d8 - g_ps2RecompiledFunctionTable[396725] = bhControlObjItm_0x283400; // 0x2836dc - g_ps2RecompiledFunctionTable[396726] = bhControlObjItm_0x283400; // 0x2836e0 - g_ps2RecompiledFunctionTable[396727] = bhControlObjItm_0x283400; // 0x2836e4 - g_ps2RecompiledFunctionTable[396728] = bhControlObjItm_0x283400; // 0x2836e8 - g_ps2RecompiledFunctionTable[396729] = bhControlObjItm_0x283400; // 0x2836ec - g_ps2RecompiledFunctionTable[396730] = bhControlObjItm_0x283400; // 0x2836f0 - g_ps2RecompiledFunctionTable[396731] = bhControlObjItm_0x283400; // 0x2836f4 - g_ps2RecompiledFunctionTable[396732] = bhControlObjItm_0x283400; // 0x2836f8 - g_ps2RecompiledFunctionTable[396733] = bhControlObjItm_0x283400; // 0x2836fc - g_ps2RecompiledFunctionTable[396734] = bhControlObjItm_0x283400; // 0x283700 - g_ps2RecompiledFunctionTable[396735] = bhControlObjItm_0x283400; // 0x283704 - g_ps2RecompiledFunctionTable[396736] = bhControlObjItm_0x283400; // 0x283708 - g_ps2RecompiledFunctionTable[396737] = bhControlObjItm_0x283400; // 0x28370c - g_ps2RecompiledFunctionTable[396738] = bhControlObjItm_0x283400; // 0x283710 - g_ps2RecompiledFunctionTable[396739] = bhControlObjItm_0x283400; // 0x283714 - g_ps2RecompiledFunctionTable[396740] = bhControlObjItm_0x283400; // 0x283718 - g_ps2RecompiledFunctionTable[396741] = bhControlObjItm_0x283400; // 0x28371c - g_ps2RecompiledFunctionTable[396742] = bhControlObjItm_0x283400; // 0x283720 - g_ps2RecompiledFunctionTable[396743] = bhControlObjItm_0x283400; // 0x283724 - g_ps2RecompiledFunctionTable[396744] = bhControlObjItm_0x283400; // 0x283728 - g_ps2RecompiledFunctionTable[396745] = bhControlObjItm_0x283400; // 0x28372c - g_ps2RecompiledFunctionTable[396746] = bhControlObjItm_0x283400; // 0x283730 - g_ps2RecompiledFunctionTable[396747] = bhControlObjItm_0x283400; // 0x283734 - g_ps2RecompiledFunctionTable[396748] = bhControlObjItm_0x283400; // 0x283738 - g_ps2RecompiledFunctionTable[396749] = bhControlObjItm_0x283400; // 0x28373c - g_ps2RecompiledFunctionTable[396750] = bhControlObjItm_0x283400; // 0x283740 - g_ps2RecompiledFunctionTable[396751] = bhControlObjItm_0x283400; // 0x283744 - g_ps2RecompiledFunctionTable[396752] = bhControlObjItm_0x283400; // 0x283748 - g_ps2RecompiledFunctionTable[396753] = bhControlObjItm_0x283400; // 0x28374c - g_ps2RecompiledFunctionTable[396754] = bhControlObjItm_0x283400; // 0x283750 - g_ps2RecompiledFunctionTable[396755] = bhControlObjItm_0x283400; // 0x283754 - g_ps2RecompiledFunctionTable[396756] = bhControlObjItm_0x283400; // 0x283758 - g_ps2RecompiledFunctionTable[396757] = bhControlObjItm_0x283400; // 0x28375c - g_ps2RecompiledFunctionTable[396758] = bhControlObjItm_0x283400; // 0x283760 - g_ps2RecompiledFunctionTable[396759] = bhControlObjItm_0x283400; // 0x283764 - g_ps2RecompiledFunctionTable[396760] = bhControlObjItm_0x283400; // 0x283768 - g_ps2RecompiledFunctionTable[396761] = bhControlObjItm_0x283400; // 0x28376c - g_ps2RecompiledFunctionTable[396762] = bhControlObjItm_0x283400; // 0x283770 - g_ps2RecompiledFunctionTable[396763] = bhControlObjItm_0x283400; // 0x283774 - g_ps2RecompiledFunctionTable[396764] = bhControlObjItm_0x283400; // 0x283778 - g_ps2RecompiledFunctionTable[396765] = bhControlObjItm_0x283400; // 0x28377c - g_ps2RecompiledFunctionTable[396766] = bhControlObjItm_0x283400; // 0x283780 - g_ps2RecompiledFunctionTable[396767] = bhControlObjItm_0x283400; // 0x283784 - g_ps2RecompiledFunctionTable[396768] = bhControlObjItm_0x283400; // 0x283788 - g_ps2RecompiledFunctionTable[396769] = bhControlObjItm_0x283400; // 0x28378c - g_ps2RecompiledFunctionTable[396770] = bhControlObjItm_0x283400; // 0x283790 - g_ps2RecompiledFunctionTable[396771] = bhControlObjItm_0x283400; // 0x283794 - g_ps2RecompiledFunctionTable[396772] = bhControlObjItm_0x283400; // 0x283798 - g_ps2RecompiledFunctionTable[396773] = bhControlObjItm_0x283400; // 0x28379c - g_ps2RecompiledFunctionTable[396774] = bhControlObjItm_0x283400; // 0x2837a0 - g_ps2RecompiledFunctionTable[396775] = bhControlObjItm_0x283400; // 0x2837a4 - g_ps2RecompiledFunctionTable[396776] = bhControlObjItm_0x283400; // 0x2837a8 - g_ps2RecompiledFunctionTable[396777] = bhControlObjItm_0x283400; // 0x2837ac - g_ps2RecompiledFunctionTable[396778] = bhControlObjItm_0x283400; // 0x2837b0 - g_ps2RecompiledFunctionTable[396779] = bhControlObjItm_0x283400; // 0x2837b4 - g_ps2RecompiledFunctionTable[396780] = bhControlObjItm_0x283400; // 0x2837b8 - g_ps2RecompiledFunctionTable[396781] = bhControlObjItm_0x283400; // 0x2837bc - g_ps2RecompiledFunctionTable[396782] = bhControlObjItm_0x283400; // 0x2837c0 - g_ps2RecompiledFunctionTable[396783] = bhControlObjItm_0x283400; // 0x2837c4 - g_ps2RecompiledFunctionTable[396784] = bhControlObjItm_0x283400; // 0x2837c8 - g_ps2RecompiledFunctionTable[396785] = bhControlObjItm_0x283400; // 0x2837cc - g_ps2RecompiledFunctionTable[396786] = bhControlObjItm_0x283400; // 0x2837d0 - g_ps2RecompiledFunctionTable[396787] = bhControlObjItm_0x283400; // 0x2837d4 - g_ps2RecompiledFunctionTable[396788] = bhControlObjItm_0x283400; // 0x2837d8 - g_ps2RecompiledFunctionTable[396789] = bhControlObjItm_0x283400; // 0x2837dc - g_ps2RecompiledFunctionTable[396790] = bhControlObjItm_0x283400; // 0x2837e0 - g_ps2RecompiledFunctionTable[396791] = bhControlObjItm_0x283400; // 0x2837e4 - g_ps2RecompiledFunctionTable[396792] = bhControlObjItm_0x283400; // 0x2837e8 - g_ps2RecompiledFunctionTable[396793] = bhControlObjItm_0x283400; // 0x2837ec - g_ps2RecompiledFunctionTable[396794] = bhControlObjItm_0x283400; // 0x2837f0 - g_ps2RecompiledFunctionTable[396795] = bhControlObjItm_0x283400; // 0x2837f4 - g_ps2RecompiledFunctionTable[396796] = bhControlObjItm_0x283400; // 0x2837f8 - g_ps2RecompiledFunctionTable[396797] = bhControlObjItm_0x283400; // 0x2837fc - g_ps2RecompiledFunctionTable[396798] = bhControlObjItm_0x283400; // 0x283800 - g_ps2RecompiledFunctionTable[396799] = bhControlObjItm_0x283400; // 0x283804 - g_ps2RecompiledFunctionTable[396800] = bhControlObjItm_0x283400; // 0x283808 - g_ps2RecompiledFunctionTable[396801] = bhControlObjItm_0x283400; // 0x28380c - g_ps2RecompiledFunctionTable[396802] = bhControlObjItm_0x283400; // 0x283810 - g_ps2RecompiledFunctionTable[396803] = bhControlObjItm_0x283400; // 0x283814 - g_ps2RecompiledFunctionTable[396804] = bhControlObjItm_0x283400; // 0x283818 - g_ps2RecompiledFunctionTable[396805] = bhControlObjItm_0x283400; // 0x28381c - g_ps2RecompiledFunctionTable[396806] = bhControlObjItm_0x283400; // 0x283820 - g_ps2RecompiledFunctionTable[396807] = bhControlObjItm_0x283400; // 0x283824 - g_ps2RecompiledFunctionTable[396808] = bhControlObjItm_0x283400; // 0x283828 - g_ps2RecompiledFunctionTable[396809] = bhControlObjItm_0x283400; // 0x28382c - g_ps2RecompiledFunctionTable[396810] = bhControlObjItm_0x283400; // 0x283830 - g_ps2RecompiledFunctionTable[396811] = bhControlObjItm_0x283400; // 0x283834 - g_ps2RecompiledFunctionTable[396812] = bhControlObjItm_0x283400; // 0x283838 - g_ps2RecompiledFunctionTable[396813] = bhControlObjItm_0x283400; // 0x28383c - g_ps2RecompiledFunctionTable[396814] = bhControlObjItm_0x283400; // 0x283840 - g_ps2RecompiledFunctionTable[396815] = bhControlObjItm_0x283400; // 0x283844 - g_ps2RecompiledFunctionTable[396816] = bhControlObjItm_0x283400; // 0x283848 - g_ps2RecompiledFunctionTable[396817] = bhControlObjItm_0x283400; // 0x28384c - g_ps2RecompiledFunctionTable[396818] = bhControlObjItm_0x283400; // 0x283850 - g_ps2RecompiledFunctionTable[396819] = bhControlObjItm_0x283400; // 0x283854 - g_ps2RecompiledFunctionTable[396820] = bhControlObjItm_0x283400; // 0x283858 - g_ps2RecompiledFunctionTable[396821] = bhControlObjItm_0x283400; // 0x28385c - g_ps2RecompiledFunctionTable[396822] = bhControlObjItm_0x283400; // 0x283860 - g_ps2RecompiledFunctionTable[396823] = bhControlObjItm_0x283400; // 0x283864 - g_ps2RecompiledFunctionTable[396824] = bhControlObjItm_0x283400; // 0x283868 - g_ps2RecompiledFunctionTable[396825] = bhControlObjItm_0x283400; // 0x28386c - g_ps2RecompiledFunctionTable[396826] = bhControlObjItm_0x283400; // 0x283870 - g_ps2RecompiledFunctionTable[396827] = bhControlObjItm_0x283400; // 0x283874 - g_ps2RecompiledFunctionTable[396828] = bhControlObjItm_0x283400; // 0x283878 - g_ps2RecompiledFunctionTable[396829] = bhControlObjItm_0x283400; // 0x28387c - g_ps2RecompiledFunctionTable[396830] = bhControlObjItm_0x283400; // 0x283880 - g_ps2RecompiledFunctionTable[396831] = bhControlObjItm_0x283400; // 0x283884 - g_ps2RecompiledFunctionTable[396832] = bhControlObjItm_0x283400; // 0x283888 - g_ps2RecompiledFunctionTable[396833] = bhControlObjItm_0x283400; // 0x28388c - g_ps2RecompiledFunctionTable[396834] = bhControlObjItm_0x283400; // 0x283890 - g_ps2RecompiledFunctionTable[396835] = bhControlObjItm_0x283400; // 0x283894 - g_ps2RecompiledFunctionTable[396836] = bhControlObjItm_0x283400; // 0x283898 - g_ps2RecompiledFunctionTable[396837] = bhControlObjItm_0x283400; // 0x28389c - g_ps2RecompiledFunctionTable[396838] = bhControlObjItm_0x283400; // 0x2838a0 - g_ps2RecompiledFunctionTable[396839] = bhControlObjItm_0x283400; // 0x2838a4 - g_ps2RecompiledFunctionTable[396840] = bhControlObjItm_0x283400; // 0x2838a8 - g_ps2RecompiledFunctionTable[396841] = bhControlObjItm_0x283400; // 0x2838ac - g_ps2RecompiledFunctionTable[396842] = bhControlObjItm_0x283400; // 0x2838b0 - g_ps2RecompiledFunctionTable[396843] = bhControlObjItm_0x283400; // 0x2838b4 - g_ps2RecompiledFunctionTable[396844] = bhControlObjItm_0x283400; // 0x2838b8 - g_ps2RecompiledFunctionTable[396845] = bhControlObjItm_0x283400; // 0x2838bc - g_ps2RecompiledFunctionTable[396846] = bhControlObjItm_0x283400; // 0x2838c0 - g_ps2RecompiledFunctionTable[396847] = bhControlObjItm_0x283400; // 0x2838c4 - g_ps2RecompiledFunctionTable[396848] = bhControlObjItm_0x283400; // 0x2838c8 - g_ps2RecompiledFunctionTable[396849] = bhControlObjItm_0x283400; // 0x2838cc - g_ps2RecompiledFunctionTable[396850] = bhControlObjItm_0x283400; // 0x2838d0 - g_ps2RecompiledFunctionTable[396851] = bhControlObjItm_0x283400; // 0x2838d4 - g_ps2RecompiledFunctionTable[396852] = bhControlObjItm_0x283400; // 0x2838d8 - g_ps2RecompiledFunctionTable[396853] = bhControlObjItm_0x283400; // 0x2838dc - g_ps2RecompiledFunctionTable[396854] = bhControlObjItm_0x283400; // 0x2838e0 - g_ps2RecompiledFunctionTable[396855] = bhControlObjItm_0x283400; // 0x2838e4 - g_ps2RecompiledFunctionTable[396856] = bhControlObjItm_0x283400; // 0x2838e8 - g_ps2RecompiledFunctionTable[396857] = bhControlObjItm_0x283400; // 0x2838ec - g_ps2RecompiledFunctionTable[396858] = bhControlObjItm_0x283400; // 0x2838f0 - g_ps2RecompiledFunctionTable[396859] = bhControlObjItm_0x283400; // 0x2838f4 - g_ps2RecompiledFunctionTable[396860] = bhControlObjItm_0x283400; // 0x2838f8 - g_ps2RecompiledFunctionTable[396861] = bhControlObjItm_0x283400; // 0x2838fc - g_ps2RecompiledFunctionTable[396862] = bhControlObjItm_0x283400; // 0x283900 - g_ps2RecompiledFunctionTable[396863] = bhControlObjItm_0x283400; // 0x283904 - g_ps2RecompiledFunctionTable[396864] = bhControlObjItm_0x283400; // 0x283908 - g_ps2RecompiledFunctionTable[396865] = bhControlObjItm_0x283400; // 0x28390c - g_ps2RecompiledFunctionTable[396866] = bhControlObjItm_0x283400; // 0x283910 - g_ps2RecompiledFunctionTable[396867] = bhControlObjItm_0x283400; // 0x283914 - g_ps2RecompiledFunctionTable[396868] = bhControlObjItm_0x283400; // 0x283918 - g_ps2RecompiledFunctionTable[396869] = bhControlObjItm_0x283400; // 0x28391c - g_ps2RecompiledFunctionTable[396870] = bhControlObjItm_0x283400; // 0x283920 - g_ps2RecompiledFunctionTable[396871] = bhControlObjItm_0x283400; // 0x283924 - g_ps2RecompiledFunctionTable[396872] = bhControlObjItm_0x283400; // 0x283928 - g_ps2RecompiledFunctionTable[396873] = bhControlObjItm_0x283400; // 0x28392c - g_ps2RecompiledFunctionTable[396874] = bhControlObjItm_0x283400; // 0x283930 - g_ps2RecompiledFunctionTable[396875] = bhControlObjItm_0x283400; // 0x283934 - g_ps2RecompiledFunctionTable[396876] = bhControlObjItm_0x283400; // 0x283938 - g_ps2RecompiledFunctionTable[396877] = bhControlObjItm_0x283400; // 0x28393c - g_ps2RecompiledFunctionTable[396878] = bhControlObjItm_0x283400; // 0x283940 - g_ps2RecompiledFunctionTable[396879] = bhControlObjItm_0x283400; // 0x283944 - g_ps2RecompiledFunctionTable[396880] = bhControlObjItm_0x283400; // 0x283948 - g_ps2RecompiledFunctionTable[396881] = bhControlObjItm_0x283400; // 0x28394c - g_ps2RecompiledFunctionTable[396882] = bhControlObjItm_0x283400; // 0x283950 - g_ps2RecompiledFunctionTable[396883] = bhControlObjItm_0x283400; // 0x283954 - g_ps2RecompiledFunctionTable[396884] = bhControlObjItm_0x283400; // 0x283958 - g_ps2RecompiledFunctionTable[396885] = bhControlObjItm_0x283400; // 0x28395c - g_ps2RecompiledFunctionTable[396886] = bhControlObjItm_0x283400; // 0x283960 - g_ps2RecompiledFunctionTable[396887] = bhControlObjItm_0x283400; // 0x283964 - g_ps2RecompiledFunctionTable[396888] = bhControlObjItm_0x283400; // 0x283968 - g_ps2RecompiledFunctionTable[396889] = bhControlObjItm_0x283400; // 0x28396c - g_ps2RecompiledFunctionTable[396890] = bhControlObjItm_0x283400; // 0x283970 - g_ps2RecompiledFunctionTable[396891] = bhControlObjItm_0x283400; // 0x283974 - g_ps2RecompiledFunctionTable[396892] = bhControlObjItm_0x283400; // 0x283978 - g_ps2RecompiledFunctionTable[396893] = bhControlObjItm_0x283400; // 0x28397c - g_ps2RecompiledFunctionTable[396894] = bhControlObjItm_0x283400; // 0x283980 - g_ps2RecompiledFunctionTable[396895] = bhControlObjItm_0x283400; // 0x283984 - g_ps2RecompiledFunctionTable[396896] = bhControlObjItm_0x283400; // 0x283988 - g_ps2RecompiledFunctionTable[396897] = bhControlObjItm_0x283400; // 0x28398c - g_ps2RecompiledFunctionTable[396898] = bhControlObjItm_0x283400; // 0x283990 - g_ps2RecompiledFunctionTable[396899] = bhControlObjItm_0x283400; // 0x283994 - g_ps2RecompiledFunctionTable[396900] = bhControlObjItm_0x283400; // 0x283998 - g_ps2RecompiledFunctionTable[396901] = bhControlObjItm_0x283400; // 0x28399c - g_ps2RecompiledFunctionTable[396902] = bhControlObjItm_0x283400; // 0x2839a0 - g_ps2RecompiledFunctionTable[396903] = bhControlObjItm_0x283400; // 0x2839a4 - g_ps2RecompiledFunctionTable[396904] = bhControlObjItm_0x283400; // 0x2839a8 - g_ps2RecompiledFunctionTable[396905] = bhControlObjItm_0x283400; // 0x2839ac - g_ps2RecompiledFunctionTable[396906] = bhControlObjItm_0x283400; // 0x2839b0 - g_ps2RecompiledFunctionTable[396907] = bhControlObjItm_0x283400; // 0x2839b4 - g_ps2RecompiledFunctionTable[396908] = bhControlObjItm_0x283400; // 0x2839b8 - g_ps2RecompiledFunctionTable[396909] = bhControlObjItm_0x283400; // 0x2839bc - g_ps2RecompiledFunctionTable[396910] = bhControlObjItm_0x283400; // 0x2839c0 - g_ps2RecompiledFunctionTable[396911] = bhControlObjItm_0x283400; // 0x2839c4 - g_ps2RecompiledFunctionTable[396912] = bhControlObjItm_0x283400; // 0x2839c8 - g_ps2RecompiledFunctionTable[396913] = bhControlObjItm_0x283400; // 0x2839cc - g_ps2RecompiledFunctionTable[396914] = bhControlObjItm_0x283400; // 0x2839d0 - g_ps2RecompiledFunctionTable[396915] = bhControlObjItm_0x283400; // 0x2839d4 - g_ps2RecompiledFunctionTable[396916] = bhControlObjItm_0x283400; // 0x2839d8 - g_ps2RecompiledFunctionTable[396917] = bhControlObjItm_0x283400; // 0x2839dc - g_ps2RecompiledFunctionTable[396918] = bhControlObjItm_0x283400; // 0x2839e0 - g_ps2RecompiledFunctionTable[396919] = bhControlObjItm_0x283400; // 0x2839e4 - g_ps2RecompiledFunctionTable[396920] = bhControlObjItm_0x283400; // 0x2839e8 - g_ps2RecompiledFunctionTable[396921] = bhControlObjItm_0x283400; // 0x2839ec - g_ps2RecompiledFunctionTable[396922] = bhControlObjItm_0x283400; // 0x2839f0 - g_ps2RecompiledFunctionTable[396923] = bhControlObjItm_0x283400; // 0x2839f4 - g_ps2RecompiledFunctionTable[396924] = bhControlObjItm_0x283400; // 0x2839f8 - g_ps2RecompiledFunctionTable[396925] = bhControlObjItm_0x283400; // 0x2839fc - g_ps2RecompiledFunctionTable[396926] = bhControlObjItm_0x283400; // 0x283a00 - g_ps2RecompiledFunctionTable[396927] = bhControlObjItm_0x283400; // 0x283a04 - g_ps2RecompiledFunctionTable[396928] = bhControlObjItm_0x283400; // 0x283a08 - g_ps2RecompiledFunctionTable[396929] = bhControlObjItm_0x283400; // 0x283a0c - g_ps2RecompiledFunctionTable[396930] = bhControlObjItm_0x283400; // 0x283a10 - g_ps2RecompiledFunctionTable[396931] = bhControlObjItm_0x283400; // 0x283a14 - g_ps2RecompiledFunctionTable[396932] = bhControlObjItm_0x283400; // 0x283a18 - g_ps2RecompiledFunctionTable[396933] = bhControlObjItm_0x283400; // 0x283a1c - g_ps2RecompiledFunctionTable[396934] = bhControlObjItm_0x283400; // 0x283a20 - g_ps2RecompiledFunctionTable[396938] = bhDrawGeneralPurposeWater_0x283a30; // 0x283a30 - g_ps2RecompiledFunctionTable[396951] = bhDrawGeneralPurposeWater_0x283a30; // 0x283a64 - g_ps2RecompiledFunctionTable[397010] = bhDrawGeneralPurposeWater_0x283a30; // 0x283b50 - g_ps2RecompiledFunctionTable[397030] = bhDrawObjItm_0x283ba0; // 0x283ba0 - g_ps2RecompiledFunctionTable[397049] = bhDrawObjItm_0x283ba0; // 0x283bec - g_ps2RecompiledFunctionTable[397058] = bhDrawObjItm_0x283ba0; // 0x283c10 - g_ps2RecompiledFunctionTable[397067] = bhDrawObjItm_0x283ba0; // 0x283c34 - g_ps2RecompiledFunctionTable[397071] = bhDrawObjItm_0x283ba0; // 0x283c44 - g_ps2RecompiledFunctionTable[397075] = bhDrawObjItm_0x283ba0; // 0x283c54 - g_ps2RecompiledFunctionTable[397092] = bhDrawObjItm_0x283ba0; // 0x283c98 - g_ps2RecompiledFunctionTable[397101] = bhDrawObjItm_0x283ba0; // 0x283cbc - g_ps2RecompiledFunctionTable[397110] = bhDrawObjItm_0x283ba0; // 0x283ce0 - g_ps2RecompiledFunctionTable[397114] = bhDrawObjItm_0x283ba0; // 0x283cf0 - g_ps2RecompiledFunctionTable[397118] = bhDrawObjItm_0x283ba0; // 0x283d00 - g_ps2RecompiledFunctionTable[397131] = bhDrawObjItm_0x283ba0; // 0x283d34 - g_ps2RecompiledFunctionTable[397187] = bhDrawObjItm_0x283ba0; // 0x283e14 - g_ps2RecompiledFunctionTable[397206] = bhDrawObjItm_0x283ba0; // 0x283e60 - g_ps2RecompiledFunctionTable[397215] = bhDrawObjItm_0x283ba0; // 0x283e84 - g_ps2RecompiledFunctionTable[397224] = bhDrawObjItm_0x283ba0; // 0x283ea8 - g_ps2RecompiledFunctionTable[397226] = bhDrawObjItm_0x283ba0; // 0x283eb0 - g_ps2RecompiledFunctionTable[397237] = bhDrawObjItm_0x283ba0; // 0x283edc - g_ps2RecompiledFunctionTable[397291] = bhDrawObjItm_0x283ba0; // 0x283fb4 - g_ps2RecompiledFunctionTable[397307] = bhDrawObjItm_0x283ba0; // 0x283ff4 - g_ps2RecompiledFunctionTable[397311] = bhDrawObjItm_0x283ba0; // 0x284004 - g_ps2RecompiledFunctionTable[397317] = bhDrawObjItm_0x283ba0; // 0x28401c - g_ps2RecompiledFunctionTable[397322] = bhDrawObjItm_0x283ba0; // 0x284030 - g_ps2RecompiledFunctionTable[397325] = bhDrawObjItm_0x283ba0; // 0x28403c - g_ps2RecompiledFunctionTable[397327] = bhDrawObjItm_0x283ba0; // 0x284044 - g_ps2RecompiledFunctionTable[397331] = bhDrawObjItm_0x283ba0; // 0x284054 - g_ps2RecompiledFunctionTable[397336] = bhDrawObjItm_0x283ba0; // 0x284068 - g_ps2RecompiledFunctionTable[397339] = bhDrawObjItm_0x283ba0; // 0x284074 - g_ps2RecompiledFunctionTable[397341] = bhDrawObjItm_0x283ba0; // 0x28407c - g_ps2RecompiledFunctionTable[397347] = bhDrawObjItm_0x283ba0; // 0x284094 - g_ps2RecompiledFunctionTable[397359] = bhDrawObjItm_0x283ba0; // 0x2840c4 - g_ps2RecompiledFunctionTable[397362] = bhDrawObjItm_0x283ba0; // 0x2840d0 - g_ps2RecompiledFunctionTable[397367] = bhDrawObjItm_0x283ba0; // 0x2840e4 - g_ps2RecompiledFunctionTable[397370] = bhDrawObjItm_0x283ba0; // 0x2840f0 - g_ps2RecompiledFunctionTable[397383] = bhDrawObjItm_0x283ba0; // 0x284124 - g_ps2RecompiledFunctionTable[397395] = bhDrawObjItm_0x283ba0; // 0x284154 - g_ps2RecompiledFunctionTable[397398] = bhDrawObjItm_0x283ba0; // 0x284160 - g_ps2RecompiledFunctionTable[397400] = bhDrawObjItm_0x283ba0; // 0x284168 - g_ps2RecompiledFunctionTable[397413] = bhDrawObjItm_0x283ba0; // 0x28419c - g_ps2RecompiledFunctionTable[397425] = bhDrawObjItm_0x283ba0; // 0x2841cc - g_ps2RecompiledFunctionTable[397428] = bhDrawObjItm_0x283ba0; // 0x2841d8 - g_ps2RecompiledFunctionTable[397430] = bhDrawObjItm_0x283ba0; // 0x2841e0 - g_ps2RecompiledFunctionTable[397436] = bhDrawObjItm_0x283ba0; // 0x2841f8 - g_ps2RecompiledFunctionTable[397448] = bhDrawObjItm_0x283ba0; // 0x284228 - g_ps2RecompiledFunctionTable[397466] = bhDrawObject_0x284270; // 0x284270 - g_ps2RecompiledFunctionTable[397548] = bhDrawObject_0x284270; // 0x2843b8 - g_ps2RecompiledFunctionTable[397560] = bhDrawObject_0x284270; // 0x2843e8 - g_ps2RecompiledFunctionTable[397563] = bhDrawObject_0x284270; // 0x2843f4 - g_ps2RecompiledFunctionTable[397565] = bhDrawObject_0x284270; // 0x2843fc - g_ps2RecompiledFunctionTable[397576] = bhDrawObject_0x284270; // 0x284428 - g_ps2RecompiledFunctionTable[397582] = bhDrawSpObject_0x284440; // 0x284440 - g_ps2RecompiledFunctionTable[397637] = bhDrawSpObject_0x284440; // 0x28451c - g_ps2RecompiledFunctionTable[397641] = bhDrawSpObject_0x284440; // 0x28452c - g_ps2RecompiledFunctionTable[397646] = bhDrawSpObject_0x284440; // 0x284540 - g_ps2RecompiledFunctionTable[397649] = bhDrawSpObject_0x284440; // 0x28454c - g_ps2RecompiledFunctionTable[397651] = bhDrawSpObject_0x284440; // 0x284554 - g_ps2RecompiledFunctionTable[397658] = bhDrawSpObject_0x284440; // 0x284570 - g_ps2RecompiledFunctionTable[397662] = bhDrawSpObject_0x284440; // 0x284580 - g_ps2RecompiledFunctionTable[397669] = bhDrawSpObject_0x284440; // 0x28459c - g_ps2RecompiledFunctionTable[397673] = bhDrawSpObject_0x284440; // 0x2845ac - g_ps2RecompiledFunctionTable[397676] = bhDrawSpObject_0x284440; // 0x2845b8 - g_ps2RecompiledFunctionTable[397682] = bhSetAlphaFadeObject_0x2845d0; // 0x2845d0 - g_ps2RecompiledFunctionTable[397698] = bhControlAlphaFadeObject_0x284610; // 0x284610 - g_ps2RecompiledFunctionTable[397724] = bhControlAlphaFadeObject_0x284610; // 0x284678 - g_ps2RecompiledFunctionTable[397766] = bhControlAlphaFadeObject_0x284610; // 0x284720 - g_ps2RecompiledFunctionTable[397770] = bhControlAlphaFadeObject_0x284610; // 0x284730 - g_ps2RecompiledFunctionTable[397802] = bhObjDmy_0x2847b0; // 0x2847b0 - g_ps2RecompiledFunctionTable[397806] = bhObjItmBox_0x2847c0; // 0x2847c0 - g_ps2RecompiledFunctionTable[397830] = bhObjItmBox_0x2847c0; // 0x284820 - g_ps2RecompiledFunctionTable[397841] = bhObjItmBox_0x2847c0; // 0x28484c - g_ps2RecompiledFunctionTable[397850] = bhObjItmBox_0x2847c0; // 0x284870 - g_ps2RecompiledFunctionTable[397878] = bhObj001_0x2848e0; // 0x2848e0 - g_ps2RecompiledFunctionTable[398066] = bhObj001_0x2848e0; // 0x284bd0 - g_ps2RecompiledFunctionTable[398183] = bhObj001_0x2848e0; // 0x284da4 - g_ps2RecompiledFunctionTable[398242] = bhObj001_0x2848e0; // 0x284e90 - g_ps2RecompiledFunctionTable[398322] = bhObj001_0x2848e0; // 0x284fd0 - g_ps2RecompiledFunctionTable[398350] = bhObj001_0x2848e0; // 0x285040 - g_ps2RecompiledFunctionTable[398378] = bhObj001_0x2848e0; // 0x2850b0 - g_ps2RecompiledFunctionTable[398406] = bhObj001_0x2848e0; // 0x285120 - g_ps2RecompiledFunctionTable[398499] = bhObj001_0x2848e0; // 0x285294 - g_ps2RecompiledFunctionTable[398510] = bhObj001_0x2848e0; // 0x2852c0 - g_ps2RecompiledFunctionTable[398519] = bhObj001_0x2848e0; // 0x2852e4 - g_ps2RecompiledFunctionTable[398670] = bhObj002_0x285540; // 0x285540 - g_ps2RecompiledFunctionTable[398684] = bhObj002_0x285540; // 0x285578 - g_ps2RecompiledFunctionTable[398694] = bhObj003_0x2855a0; // 0x2855a0 - g_ps2RecompiledFunctionTable[398700] = bhObj003_0x2855a0; // 0x2855b8 - g_ps2RecompiledFunctionTable[398704] = bhObj003_0x2855a0; // 0x2855c8 - g_ps2RecompiledFunctionTable[398714] = bhObj004_0x2855f0; // 0x2855f0 - g_ps2RecompiledFunctionTable[398734] = bhObj004_0x2855f0; // 0x285640 - g_ps2RecompiledFunctionTable[398746] = bhObj004_0x2855f0; // 0x285670 - g_ps2RecompiledFunctionTable[398750] = bhObj005_0x285680; // 0x285680 - g_ps2RecompiledFunctionTable[398780] = bhObj005_0x285680; // 0x2856f8 - g_ps2RecompiledFunctionTable[398798] = bhObj005_0x285680; // 0x285740 - g_ps2RecompiledFunctionTable[398833] = bhObj005_0x285680; // 0x2857cc - g_ps2RecompiledFunctionTable[398838] = bhObj005_0x285680; // 0x2857e0 - g_ps2RecompiledFunctionTable[398891] = bhObj005_0x285680; // 0x2858b4 - g_ps2RecompiledFunctionTable[398904] = bhObj005_0x285680; // 0x2858e8 - g_ps2RecompiledFunctionTable[398912] = bhObj005_0x285680; // 0x285908 - g_ps2RecompiledFunctionTable[398916] = bhObj005_0x285680; // 0x285918 - g_ps2RecompiledFunctionTable[398923] = bhObj005_0x285680; // 0x285934 - g_ps2RecompiledFunctionTable[398926] = bhObj005_0x285680; // 0x285940 - g_ps2RecompiledFunctionTable[398969] = bhObj005_0x285680; // 0x2859ec - g_ps2RecompiledFunctionTable[398977] = bhObj005_0x285680; // 0x285a0c - g_ps2RecompiledFunctionTable[398985] = bhObj005_0x285680; // 0x285a2c - g_ps2RecompiledFunctionTable[398993] = bhObj005_0x285680; // 0x285a4c - g_ps2RecompiledFunctionTable[399001] = bhObj005_0x285680; // 0x285a6c - g_ps2RecompiledFunctionTable[399009] = bhObj005_0x285680; // 0x285a8c - g_ps2RecompiledFunctionTable[399017] = bhObj005_0x285680; // 0x285aac - g_ps2RecompiledFunctionTable[399025] = bhObj005_0x285680; // 0x285acc - g_ps2RecompiledFunctionTable[399033] = bhObj005_0x285680; // 0x285aec - g_ps2RecompiledFunctionTable[399041] = bhObj005_0x285680; // 0x285b0c - g_ps2RecompiledFunctionTable[399049] = bhObj005_0x285680; // 0x285b2c - g_ps2RecompiledFunctionTable[399057] = bhObj005_0x285680; // 0x285b4c - g_ps2RecompiledFunctionTable[399065] = bhObj005_0x285680; // 0x285b6c - g_ps2RecompiledFunctionTable[399073] = bhObj005_0x285680; // 0x285b8c - g_ps2RecompiledFunctionTable[399081] = bhObj005_0x285680; // 0x285bac - g_ps2RecompiledFunctionTable[399089] = bhObj005_0x285680; // 0x285bcc - g_ps2RecompiledFunctionTable[399129] = bhObj005_0x285680; // 0x285c6c - g_ps2RecompiledFunctionTable[399173] = bhObj005_0x285680; // 0x285d1c - g_ps2RecompiledFunctionTable[399193] = bhObj005_0x285680; // 0x285d6c - g_ps2RecompiledFunctionTable[399210] = bhObj006_0x285db0; // 0x285db0 - g_ps2RecompiledFunctionTable[399236] = bhObj006_0x285db0; // 0x285e18 - g_ps2RecompiledFunctionTable[399241] = bhObj006_0x285db0; // 0x285e2c - g_ps2RecompiledFunctionTable[399248] = bhObj006_0x285db0; // 0x285e48 - g_ps2RecompiledFunctionTable[399253] = bhObj006_0x285db0; // 0x285e5c - g_ps2RecompiledFunctionTable[399258] = bhObj006_0x285db0; // 0x285e70 - g_ps2RecompiledFunctionTable[399280] = bhObj006_0x285db0; // 0x285ec8 - g_ps2RecompiledFunctionTable[399282] = bhObj006_0x285db0; // 0x285ed0 - g_ps2RecompiledFunctionTable[399284] = bhObj006_0x285db0; // 0x285ed8 - g_ps2RecompiledFunctionTable[399289] = bhObj006_0x285db0; // 0x285eec - g_ps2RecompiledFunctionTable[399294] = bhObj006_0x285db0; // 0x285f00 - g_ps2RecompiledFunctionTable[399301] = bhObj006_0x285db0; // 0x285f1c - g_ps2RecompiledFunctionTable[399306] = bhObj006_0x285db0; // 0x285f30 - g_ps2RecompiledFunctionTable[399308] = bhObj006_0x285db0; // 0x285f38 - g_ps2RecompiledFunctionTable[399310] = bhObj006_0x285db0; // 0x285f40 - g_ps2RecompiledFunctionTable[399314] = bhObj006_0x285db0; // 0x285f50 - g_ps2RecompiledFunctionTable[399319] = bhObj006_0x285db0; // 0x285f64 - g_ps2RecompiledFunctionTable[399324] = bhObj006_0x285db0; // 0x285f78 - g_ps2RecompiledFunctionTable[399356] = bhObj006_0x285db0; // 0x285ff8 - g_ps2RecompiledFunctionTable[399398] = bhObj006_0x285db0; // 0x2860a0 - g_ps2RecompiledFunctionTable[399403] = bhObj006_0x285db0; // 0x2860b4 - g_ps2RecompiledFunctionTable[399410] = bhObj006_0x285db0; // 0x2860d0 - g_ps2RecompiledFunctionTable[399415] = bhObj006_0x285db0; // 0x2860e4 - g_ps2RecompiledFunctionTable[399419] = bhObj006_0x285db0; // 0x2860f4 - g_ps2RecompiledFunctionTable[399446] = bhObj007_0x286160; // 0x286160 - g_ps2RecompiledFunctionTable[399496] = bhObj007_0x286160; // 0x286228 - g_ps2RecompiledFunctionTable[399504] = bhObj007_0x286160; // 0x286248 - g_ps2RecompiledFunctionTable[399513] = bhObj007_0x286160; // 0x28626c - g_ps2RecompiledFunctionTable[399531] = bhObj007_0x286160; // 0x2862b4 - g_ps2RecompiledFunctionTable[399534] = bhObj007_0x286160; // 0x2862c0 - g_ps2RecompiledFunctionTable[399567] = bhObj007_0x286160; // 0x286344 - g_ps2RecompiledFunctionTable[399570] = bhObj007_0x286160; // 0x286350 - g_ps2RecompiledFunctionTable[399573] = bhObj007_0x286160; // 0x28635c - g_ps2RecompiledFunctionTable[399587] = bhObj007_0x286160; // 0x286394 - g_ps2RecompiledFunctionTable[399590] = bhObj007_0x286160; // 0x2863a0 - g_ps2RecompiledFunctionTable[399632] = bhObj007_0x286160; // 0x286448 - g_ps2RecompiledFunctionTable[399639] = bhObj007_0x286160; // 0x286464 - g_ps2RecompiledFunctionTable[399644] = bhObj007_0x286160; // 0x286478 - g_ps2RecompiledFunctionTable[399692] = bhObj007_0x286160; // 0x286538 - g_ps2RecompiledFunctionTable[399698] = bhObj007_0x286160; // 0x286550 - g_ps2RecompiledFunctionTable[399703] = bhObj007_0x286160; // 0x286564 - g_ps2RecompiledFunctionTable[399764] = bhObj007_0x286160; // 0x286658 - g_ps2RecompiledFunctionTable[399769] = bhObj007_0x286160; // 0x28666c - g_ps2RecompiledFunctionTable[399782] = bhObj007_0x286160; // 0x2866a0 - g_ps2RecompiledFunctionTable[399791] = bhObj007_0x286160; // 0x2866c4 - g_ps2RecompiledFunctionTable[399802] = bhObj007_0x286160; // 0x2866f0 - g_ps2RecompiledFunctionTable[399816] = bhObj007_0x286160; // 0x286728 - g_ps2RecompiledFunctionTable[399844] = bhObj007_0x286160; // 0x286798 - g_ps2RecompiledFunctionTable[399878] = bhObj007_0x286160; // 0x286820 - g_ps2RecompiledFunctionTable[399883] = bhObj007_0x286160; // 0x286834 - g_ps2RecompiledFunctionTable[399896] = bhObj007_0x286160; // 0x286868 - g_ps2RecompiledFunctionTable[399905] = bhObj007_0x286160; // 0x28688c - g_ps2RecompiledFunctionTable[399916] = bhObj007_0x286160; // 0x2868b8 - g_ps2RecompiledFunctionTable[399930] = bhObj007_0x286160; // 0x2868f0 - g_ps2RecompiledFunctionTable[399958] = bhObj007_0x286160; // 0x286960 - g_ps2RecompiledFunctionTable[399982] = bhObj008_0x2869c0; // 0x2869c0 - g_ps2RecompiledFunctionTable[400090] = bhObj009_0x286b70; // 0x286b70 - g_ps2RecompiledFunctionTable[400102] = bhObj009_0x286b70; // 0x286ba0 - g_ps2RecompiledFunctionTable[400144] = bhObj009_0x286b70; // 0x286c48 - g_ps2RecompiledFunctionTable[400147] = bhObj009_0x286b70; // 0x286c54 - g_ps2RecompiledFunctionTable[400220] = bhObj009_0x286b70; // 0x286d78 - g_ps2RecompiledFunctionTable[400227] = bhObj009_0x286b70; // 0x286d94 - g_ps2RecompiledFunctionTable[400241] = bhObj009_0x286b70; // 0x286dcc - g_ps2RecompiledFunctionTable[400243] = bhObj009_0x286b70; // 0x286dd4 - g_ps2RecompiledFunctionTable[400259] = bhObj009_0x286b70; // 0x286e14 - g_ps2RecompiledFunctionTable[400316] = bhObj009_0x286b70; // 0x286ef8 - g_ps2RecompiledFunctionTable[400336] = bhObj009_0x286b70; // 0x286f48 - g_ps2RecompiledFunctionTable[400363] = bhObj009_0x286b70; // 0x286fb4 - g_ps2RecompiledFunctionTable[400410] = bhObj009_0x286b70; // 0x287070 - g_ps2RecompiledFunctionTable[400418] = bhObj010_0x287090; // 0x287090 - g_ps2RecompiledFunctionTable[400427] = bhObj010_0x287090; // 0x2870b4 - g_ps2RecompiledFunctionTable[400435] = bhObj010_0x287090; // 0x2870d4 - g_ps2RecompiledFunctionTable[400448] = bhObj010_0x287090; // 0x287108 - g_ps2RecompiledFunctionTable[400454] = bhObj011_0x287120; // 0x287120 - g_ps2RecompiledFunctionTable[400458] = bhObj012_0x287130; // 0x287130 - g_ps2RecompiledFunctionTable[400554] = bhObjClpn_0x2872b0; // 0x2872b0 - g_ps2RecompiledFunctionTable[400614] = bhObjClpn_0x2872b0; // 0x2873a0 - g_ps2RecompiledFunctionTable[400618] = bhObjClpn_0x2872b0; // 0x2873b0 - g_ps2RecompiledFunctionTable[400628] = bhObjClpn_0x2872b0; // 0x2873d8 - g_ps2RecompiledFunctionTable[400660] = bhObjClpn_0x2872b0; // 0x287458 - g_ps2RecompiledFunctionTable[400664] = bhObjClpn_0x2872b0; // 0x287468 - g_ps2RecompiledFunctionTable[400669] = bhObjClpn_0x2872b0; // 0x28747c - g_ps2RecompiledFunctionTable[400686] = bhObjClpn_0x2872b0; // 0x2874c0 - g_ps2RecompiledFunctionTable[400744] = bhObjClpn_0x2872b0; // 0x2875a8 - g_ps2RecompiledFunctionTable[400755] = bhObjClpn_0x2872b0; // 0x2875d4 - g_ps2RecompiledFunctionTable[400759] = bhObjClpn_0x2872b0; // 0x2875e4 - g_ps2RecompiledFunctionTable[400763] = bhObjClpn_0x2872b0; // 0x2875f4 - g_ps2RecompiledFunctionTable[400822] = bhObjClpn_0x2872b0; // 0x2876e0 - g_ps2RecompiledFunctionTable[400842] = bhObjClpn_0x2872b0; // 0x287730 - g_ps2RecompiledFunctionTable[400853] = bhObjClpn_0x2872b0; // 0x28775c - g_ps2RecompiledFunctionTable[400896] = bhObjClpn_0x2872b0; // 0x287808 - g_ps2RecompiledFunctionTable[400905] = bhObjClpn_0x2872b0; // 0x28782c - g_ps2RecompiledFunctionTable[400939] = bhObjClpn_0x2872b0; // 0x2878b4 - g_ps2RecompiledFunctionTable[400962] = bhObjClpn_0x2872b0; // 0x287910 - g_ps2RecompiledFunctionTable[400974] = bhObjClpn_0x2872b0; // 0x287940 - g_ps2RecompiledFunctionTable[400999] = bhObjClpn_0x2872b0; // 0x2879a4 - g_ps2RecompiledFunctionTable[401008] = bhObjClpn_0x2872b0; // 0x2879c8 - g_ps2RecompiledFunctionTable[401033] = bhObjClpn_0x2872b0; // 0x287a2c - g_ps2RecompiledFunctionTable[401037] = bhObjClpn_0x2872b0; // 0x287a3c - g_ps2RecompiledFunctionTable[401041] = bhObjClpn_0x2872b0; // 0x287a4c - g_ps2RecompiledFunctionTable[401045] = bhObjClpn_0x2872b0; // 0x287a5c - g_ps2RecompiledFunctionTable[401053] = bhObjClpn_0x2872b0; // 0x287a7c - g_ps2RecompiledFunctionTable[401058] = bhObjClpn_0x2872b0; // 0x287a90 - g_ps2RecompiledFunctionTable[401078] = bhObjClpn_0x2872b0; // 0x287ae0 - g_ps2RecompiledFunctionTable[401126] = bhObjWssg_0x287ba0; // 0x287ba0 - g_ps2RecompiledFunctionTable[401130] = bhInitRoom_0x287bb0; // 0x287bb0 - g_ps2RecompiledFunctionTable[401138] = bhInitReadRDT_0x287bd0; // 0x287bd0 - g_ps2RecompiledFunctionTable[401146] = bhInitReadRDT_0x287bd0; // 0x287bf0 - g_ps2RecompiledFunctionTable[401148] = bhInitReadRDT_0x287bd0; // 0x287bf8 - g_ps2RecompiledFunctionTable[401150] = bhInitReadRDT_0x287bd0; // 0x287c00 - g_ps2RecompiledFunctionTable[401152] = bhInitReadRDT_0x287bd0; // 0x287c08 - g_ps2RecompiledFunctionTable[401154] = bhInitReadRDT_0x287bd0; // 0x287c10 - g_ps2RecompiledFunctionTable[401158] = bhSetRDT_0x287c20; // 0x287c20 - g_ps2RecompiledFunctionTable[401162] = bhSetRoom_0x287c30; // 0x287c30 - g_ps2RecompiledFunctionTable[401192] = bhSetRoom_0x287c30; // 0x287ca8 - g_ps2RecompiledFunctionTable[401195] = bhSetRoom_0x287c30; // 0x287cb4 - g_ps2RecompiledFunctionTable[401213] = bhSetRoom_0x287c30; // 0x287cfc - g_ps2RecompiledFunctionTable[401244] = bhSetRoom_0x287c30; // 0x287d78 - g_ps2RecompiledFunctionTable[401256] = bhSetRoom_0x287c30; // 0x287da8 - g_ps2RecompiledFunctionTable[401260] = bhSetRoom_0x287c30; // 0x287db8 - g_ps2RecompiledFunctionTable[401262] = bhSetRoom_0x287c30; // 0x287dc0 - g_ps2RecompiledFunctionTable[401264] = bhSetRoom_0x287c30; // 0x287dc8 - g_ps2RecompiledFunctionTable[401266] = bhSetRoom_0x287c30; // 0x287dd0 - g_ps2RecompiledFunctionTable[401288] = bhSetRoom_0x287c30; // 0x287e28 - g_ps2RecompiledFunctionTable[401304] = bhSetRoom_0x287c30; // 0x287e68 - g_ps2RecompiledFunctionTable[401316] = bhSetRoom_0x287c30; // 0x287e98 - g_ps2RecompiledFunctionTable[401328] = bhSetRoom_0x287c30; // 0x287ec8 - g_ps2RecompiledFunctionTable[401339] = bhSetRoom_0x287c30; // 0x287ef4 - g_ps2RecompiledFunctionTable[401351] = bhSetRoom_0x287c30; // 0x287f24 - g_ps2RecompiledFunctionTable[401437] = bhSetRoom_0x287c30; // 0x28807c - g_ps2RecompiledFunctionTable[401439] = bhSetRoom_0x287c30; // 0x288084 - g_ps2RecompiledFunctionTable[401508] = bhSetRoom_0x287c30; // 0x288198 - g_ps2RecompiledFunctionTable[401527] = bhSetRoom_0x287c30; // 0x2881e4 - g_ps2RecompiledFunctionTable[401626] = bhSetRoom_0x287c30; // 0x288370 - g_ps2RecompiledFunctionTable[401644] = bhSetRoom_0x287c30; // 0x2883b8 - g_ps2RecompiledFunctionTable[401746] = bhSetRoom_0x287c30; // 0x288550 - g_ps2RecompiledFunctionTable[401783] = bhSetRoom_0x287c30; // 0x2885e4 - g_ps2RecompiledFunctionTable[401795] = bhSetRoom_0x287c30; // 0x288614 - g_ps2RecompiledFunctionTable[401807] = bhSetRoom_0x287c30; // 0x288644 - g_ps2RecompiledFunctionTable[401849] = bhSetRoom_0x287c30; // 0x2886ec - g_ps2RecompiledFunctionTable[401946] = bhFinishRoom_0x288870; // 0x288870 - g_ps2RecompiledFunctionTable[401960] = bhFinishRoom_0x288870; // 0x2888a8 - g_ps2RecompiledFunctionTable[401991] = bhFinishRoom_0x288870; // 0x288924 - g_ps2RecompiledFunctionTable[401999] = bhFinishRoom_0x288870; // 0x288944 - g_ps2RecompiledFunctionTable[402010] = bhFinishRoom_0x288870; // 0x288970 - g_ps2RecompiledFunctionTable[402053] = bhFinishRoom_0x288870; // 0x288a1c - g_ps2RecompiledFunctionTable[402085] = bhFinishRoom_0x288870; // 0x288a9c - g_ps2RecompiledFunctionTable[402114] = bhFinishRoom_0x288870; // 0x288b10 - g_ps2RecompiledFunctionTable[402166] = bhFinishRoom_0x288870; // 0x288be0 - g_ps2RecompiledFunctionTable[402168] = bhFinishRoom_0x288870; // 0x288be8 - g_ps2RecompiledFunctionTable[402175] = bhFinishRoom_0x288870; // 0x288c04 - g_ps2RecompiledFunctionTable[402182] = bhFinishRoom_0x288870; // 0x288c20 - g_ps2RecompiledFunctionTable[402194] = bhFinishRoom_0x288870; // 0x288c50 - g_ps2RecompiledFunctionTable[402210] = bhFinishRoom_0x288870; // 0x288c90 - g_ps2RecompiledFunctionTable[402217] = bhFinishRoom_0x288870; // 0x288cac - g_ps2RecompiledFunctionTable[402237] = bhFinishRoom_0x288870; // 0x288cfc - g_ps2RecompiledFunctionTable[402244] = bhFinishRoom_0x288870; // 0x288d18 - g_ps2RecompiledFunctionTable[402260] = bhFinishRoom_0x288870; // 0x288d58 - g_ps2RecompiledFunctionTable[402262] = bhFinishRoom_0x288870; // 0x288d60 - g_ps2RecompiledFunctionTable[402279] = bhFinishRoom_0x288870; // 0x288da4 - g_ps2RecompiledFunctionTable[402531] = bhFinishRoom_0x288870; // 0x289194 - g_ps2RecompiledFunctionTable[402580] = bhFinishRoom_0x288870; // 0x289258 - g_ps2RecompiledFunctionTable[402596] = bhFinishRoom_0x288870; // 0x289298 - g_ps2RecompiledFunctionTable[402634] = bhSetEneMdl_0x289330; // 0x289330 - g_ps2RecompiledFunctionTable[402649] = bhSetEneMdl_0x289330; // 0x28936c - g_ps2RecompiledFunctionTable[402657] = bhSetEneMdl_0x289330; // 0x28938c - g_ps2RecompiledFunctionTable[402683] = bhSetEneMdl_0x289330; // 0x2893f4 - g_ps2RecompiledFunctionTable[402686] = bhSetEneMdl_0x289330; // 0x289400 - g_ps2RecompiledFunctionTable[402695] = bhSetEneMdl_0x289330; // 0x289424 - g_ps2RecompiledFunctionTable[402794] = bhSetEneMtn_0x2895b0; // 0x2895b0 - g_ps2RecompiledFunctionTable[402835] = bhSetEneMtn_0x2895b0; // 0x289654 - g_ps2RecompiledFunctionTable[402845] = bhSetEneMtn_0x2895b0; // 0x28967c - g_ps2RecompiledFunctionTable[402851] = bhSetEneMtn_0x2895b0; // 0x289694 - g_ps2RecompiledFunctionTable[402870] = bhSetRoomMtn_0x2896e0; // 0x2896e0 - g_ps2RecompiledFunctionTable[402915] = bhSetRoomMtn_0x2896e0; // 0x289794 - g_ps2RecompiledFunctionTable[402917] = bhSetRoomMtn_0x2896e0; // 0x28979c - g_ps2RecompiledFunctionTable[402923] = bhSetRoomMtn_0x2896e0; // 0x2897b4 - g_ps2RecompiledFunctionTable[402942] = bhSetObjMdl_0x289800; // 0x289800 - g_ps2RecompiledFunctionTable[402951] = bhSetObjMdl_0x289800; // 0x289824 - g_ps2RecompiledFunctionTable[402957] = bhSetObjMdl_0x289800; // 0x28983c - g_ps2RecompiledFunctionTable[402972] = bhSetObjMdl_0x289800; // 0x289878 - g_ps2RecompiledFunctionTable[402982] = bhSetObjMdl_0x289800; // 0x2898a0 - g_ps2RecompiledFunctionTable[402985] = bhSetObjMdl_0x289800; // 0x2898ac - g_ps2RecompiledFunctionTable[402994] = bhSetItmMdl_0x2898d0; // 0x2898d0 - g_ps2RecompiledFunctionTable[403003] = bhSetItmMdl_0x2898d0; // 0x2898f4 - g_ps2RecompiledFunctionTable[403009] = bhSetItmMdl_0x2898d0; // 0x28990c - g_ps2RecompiledFunctionTable[403012] = bhSetItmMdl_0x2898d0; // 0x289918 - g_ps2RecompiledFunctionTable[403022] = bhSetEffectTable_0x289940; // 0x289940 - g_ps2RecompiledFunctionTable[403034] = bhSetEffectTable_0x289940; // 0x289970 - g_ps2RecompiledFunctionTable[403038] = bhSetEffectTable_0x289940; // 0x289980 - g_ps2RecompiledFunctionTable[403047] = bhSetEffectTable_0x289940; // 0x2899a4 - g_ps2RecompiledFunctionTable[403062] = bhSetEffectLink_0x2899e0; // 0x2899e0 - g_ps2RecompiledFunctionTable[403219] = bhSetEffectLink_0x2899e0; // 0x289c54 - g_ps2RecompiledFunctionTable[403231] = bhSetEffectLink_0x2899e0; // 0x289c84 - g_ps2RecompiledFunctionTable[403242] = bhSetDoorDemo_0x289cb0; // 0x289cb0 - g_ps2RecompiledFunctionTable[403362] = bhStartDoorDemo_0x289e90; // 0x289e90 - g_ps2RecompiledFunctionTable[403384] = bhStartDoorDemo_0x289e90; // 0x289ee8 - g_ps2RecompiledFunctionTable[403386] = bhStartDoorDemo_0x289e90; // 0x289ef0 - g_ps2RecompiledFunctionTable[403497] = bhStartDoorDemo_0x289e90; // 0x28a0ac - g_ps2RecompiledFunctionTable[403514] = bhStartDoorDemo_0x289e90; // 0x28a0f0 - g_ps2RecompiledFunctionTable[403518] = bhPushGameData_0x28a100; // 0x28a100 - g_ps2RecompiledFunctionTable[403590] = bhPopGameData_0x28a220; // 0x28a220 - g_ps2RecompiledFunctionTable[403599] = bhPopGameData_0x28a220; // 0x28a244 - g_ps2RecompiledFunctionTable[403607] = bhPopGameData_0x28a220; // 0x28a264 - g_ps2RecompiledFunctionTable[403646] = bhSetWeapon_0x28a300; // 0x28a300 - g_ps2RecompiledFunctionTable[403657] = bhSetWeapon_0x28a300; // 0x28a32c - g_ps2RecompiledFunctionTable[403794] = bhObjWpn_0x28a550; // 0x28a550 - g_ps2RecompiledFunctionTable[403842] = bhActionWeapon_0x28a610; // 0x28a610 - g_ps2RecompiledFunctionTable[403843] = bhActionWeapon_0x28a610; // 0x28a614 - g_ps2RecompiledFunctionTable[403844] = bhActionWeapon_0x28a610; // 0x28a618 - g_ps2RecompiledFunctionTable[403845] = bhActionWeapon_0x28a610; // 0x28a61c - g_ps2RecompiledFunctionTable[403846] = bhActionWeapon_0x28a610; // 0x28a620 - g_ps2RecompiledFunctionTable[403847] = bhActionWeapon_0x28a610; // 0x28a624 - g_ps2RecompiledFunctionTable[403848] = bhActionWeapon_0x28a610; // 0x28a628 - g_ps2RecompiledFunctionTable[403849] = bhActionWeapon_0x28a610; // 0x28a62c - g_ps2RecompiledFunctionTable[403850] = bhActionWeapon_0x28a610; // 0x28a630 - g_ps2RecompiledFunctionTable[403851] = bhActionWeapon_0x28a610; // 0x28a634 - g_ps2RecompiledFunctionTable[403852] = bhActionWeapon_0x28a610; // 0x28a638 - g_ps2RecompiledFunctionTable[403853] = bhActionWeapon_0x28a610; // 0x28a63c - g_ps2RecompiledFunctionTable[403854] = bhActionWeapon_0x28a610; // 0x28a640 - g_ps2RecompiledFunctionTable[403855] = bhActionWeapon_0x28a610; // 0x28a644 - g_ps2RecompiledFunctionTable[403856] = bhActionWeapon_0x28a610; // 0x28a648 - g_ps2RecompiledFunctionTable[403857] = bhActionWeapon_0x28a610; // 0x28a64c - g_ps2RecompiledFunctionTable[403858] = bhActionWeapon_0x28a610; // 0x28a650 - g_ps2RecompiledFunctionTable[403859] = bhActionWeapon_0x28a610; // 0x28a654 - g_ps2RecompiledFunctionTable[403860] = bhActionWeapon_0x28a610; // 0x28a658 - g_ps2RecompiledFunctionTable[403861] = bhActionWeapon_0x28a610; // 0x28a65c - g_ps2RecompiledFunctionTable[403862] = bhActionWeapon_0x28a610; // 0x28a660 - g_ps2RecompiledFunctionTable[403863] = bhActionWeapon_0x28a610; // 0x28a664 - g_ps2RecompiledFunctionTable[403864] = bhActionWeapon_0x28a610; // 0x28a668 - g_ps2RecompiledFunctionTable[403865] = bhActionWeapon_0x28a610; // 0x28a66c - g_ps2RecompiledFunctionTable[403866] = bhActionWeapon_0x28a610; // 0x28a670 - g_ps2RecompiledFunctionTable[403867] = bhActionWeapon_0x28a610; // 0x28a674 - g_ps2RecompiledFunctionTable[403868] = bhActionWeapon_0x28a610; // 0x28a678 - g_ps2RecompiledFunctionTable[403869] = bhActionWeapon_0x28a610; // 0x28a67c - g_ps2RecompiledFunctionTable[403870] = bhActionWeapon_0x28a610; // 0x28a680 - g_ps2RecompiledFunctionTable[403871] = bhActionWeapon_0x28a610; // 0x28a684 - g_ps2RecompiledFunctionTable[403872] = bhActionWeapon_0x28a610; // 0x28a688 - g_ps2RecompiledFunctionTable[403873] = bhActionWeapon_0x28a610; // 0x28a68c - g_ps2RecompiledFunctionTable[403874] = bhActionWeapon_0x28a610; // 0x28a690 - g_ps2RecompiledFunctionTable[403875] = bhActionWeapon_0x28a610; // 0x28a694 - g_ps2RecompiledFunctionTable[403876] = bhActionWeapon_0x28a610; // 0x28a698 - g_ps2RecompiledFunctionTable[403877] = bhActionWeapon_0x28a610; // 0x28a69c - g_ps2RecompiledFunctionTable[403878] = bhActionWeapon_0x28a610; // 0x28a6a0 - g_ps2RecompiledFunctionTable[403879] = bhActionWeapon_0x28a610; // 0x28a6a4 - g_ps2RecompiledFunctionTable[403880] = bhActionWeapon_0x28a610; // 0x28a6a8 - g_ps2RecompiledFunctionTable[403881] = bhActionWeapon_0x28a610; // 0x28a6ac - g_ps2RecompiledFunctionTable[403882] = bhActionWeapon_0x28a610; // 0x28a6b0 - g_ps2RecompiledFunctionTable[403883] = bhActionWeapon_0x28a610; // 0x28a6b4 - g_ps2RecompiledFunctionTable[403884] = bhActionWeapon_0x28a610; // 0x28a6b8 - g_ps2RecompiledFunctionTable[403885] = bhActionWeapon_0x28a610; // 0x28a6bc - g_ps2RecompiledFunctionTable[403886] = bhActionWeapon_0x28a610; // 0x28a6c0 - g_ps2RecompiledFunctionTable[403887] = bhActionWeapon_0x28a610; // 0x28a6c4 - g_ps2RecompiledFunctionTable[403888] = bhActionWeapon_0x28a610; // 0x28a6c8 - g_ps2RecompiledFunctionTable[403889] = bhActionWeapon_0x28a610; // 0x28a6cc - g_ps2RecompiledFunctionTable[403890] = bhActionWeapon_0x28a610; // 0x28a6d0 - g_ps2RecompiledFunctionTable[403891] = bhActionWeapon_0x28a610; // 0x28a6d4 - g_ps2RecompiledFunctionTable[403892] = bhActionWeapon_0x28a610; // 0x28a6d8 - g_ps2RecompiledFunctionTable[403893] = bhActionWeapon_0x28a610; // 0x28a6dc - g_ps2RecompiledFunctionTable[403894] = bhActionWeapon_0x28a610; // 0x28a6e0 - g_ps2RecompiledFunctionTable[403895] = bhActionWeapon_0x28a610; // 0x28a6e4 - g_ps2RecompiledFunctionTable[403896] = bhActionWeapon_0x28a610; // 0x28a6e8 - g_ps2RecompiledFunctionTable[403897] = bhActionWeapon_0x28a610; // 0x28a6ec - g_ps2RecompiledFunctionTable[403898] = bhActionWeapon_0x28a610; // 0x28a6f0 - g_ps2RecompiledFunctionTable[403899] = bhActionWeapon_0x28a610; // 0x28a6f4 - g_ps2RecompiledFunctionTable[403900] = bhActionWeapon_0x28a610; // 0x28a6f8 - g_ps2RecompiledFunctionTable[403901] = bhActionWeapon_0x28a610; // 0x28a6fc - g_ps2RecompiledFunctionTable[403902] = bhActionWeapon_0x28a610; // 0x28a700 - g_ps2RecompiledFunctionTable[403903] = bhActionWeapon_0x28a610; // 0x28a704 - g_ps2RecompiledFunctionTable[403904] = bhActionWeapon_0x28a610; // 0x28a708 - g_ps2RecompiledFunctionTable[403905] = bhActionWeapon_0x28a610; // 0x28a70c - g_ps2RecompiledFunctionTable[403906] = bhActionWeapon_0x28a610; // 0x28a710 - g_ps2RecompiledFunctionTable[403907] = bhActionWeapon_0x28a610; // 0x28a714 - g_ps2RecompiledFunctionTable[403908] = bhActionWeapon_0x28a610; // 0x28a718 - g_ps2RecompiledFunctionTable[403909] = bhActionWeapon_0x28a610; // 0x28a71c - g_ps2RecompiledFunctionTable[403910] = bhActionWeapon_0x28a610; // 0x28a720 - g_ps2RecompiledFunctionTable[403911] = bhActionWeapon_0x28a610; // 0x28a724 - g_ps2RecompiledFunctionTable[403912] = bhActionWeapon_0x28a610; // 0x28a728 - g_ps2RecompiledFunctionTable[403913] = bhActionWeapon_0x28a610; // 0x28a72c - g_ps2RecompiledFunctionTable[403914] = bhActionWeapon_0x28a610; // 0x28a730 - g_ps2RecompiledFunctionTable[403915] = bhActionWeapon_0x28a610; // 0x28a734 - g_ps2RecompiledFunctionTable[403916] = bhActionWeapon_0x28a610; // 0x28a738 - g_ps2RecompiledFunctionTable[403917] = bhActionWeapon_0x28a610; // 0x28a73c - g_ps2RecompiledFunctionTable[403918] = bhActionWeapon_0x28a610; // 0x28a740 - g_ps2RecompiledFunctionTable[403919] = bhActionWeapon_0x28a610; // 0x28a744 - g_ps2RecompiledFunctionTable[403920] = bhActionWeapon_0x28a610; // 0x28a748 - g_ps2RecompiledFunctionTable[403921] = bhActionWeapon_0x28a610; // 0x28a74c - g_ps2RecompiledFunctionTable[403922] = bhActionWeapon_0x28a610; // 0x28a750 - g_ps2RecompiledFunctionTable[403923] = bhActionWeapon_0x28a610; // 0x28a754 - g_ps2RecompiledFunctionTable[403924] = bhActionWeapon_0x28a610; // 0x28a758 - g_ps2RecompiledFunctionTable[403925] = bhActionWeapon_0x28a610; // 0x28a75c - g_ps2RecompiledFunctionTable[403926] = bhActionWeapon_0x28a610; // 0x28a760 - g_ps2RecompiledFunctionTable[403927] = bhActionWeapon_0x28a610; // 0x28a764 - g_ps2RecompiledFunctionTable[403928] = bhActionWeapon_0x28a610; // 0x28a768 - g_ps2RecompiledFunctionTable[403929] = bhActionWeapon_0x28a610; // 0x28a76c - g_ps2RecompiledFunctionTable[403930] = bhActionWeapon_0x28a610; // 0x28a770 - g_ps2RecompiledFunctionTable[403931] = bhActionWeapon_0x28a610; // 0x28a774 - g_ps2RecompiledFunctionTable[403932] = bhActionWeapon_0x28a610; // 0x28a778 - g_ps2RecompiledFunctionTable[403933] = bhActionWeapon_0x28a610; // 0x28a77c - g_ps2RecompiledFunctionTable[403934] = bhActionWeapon_0x28a610; // 0x28a780 - g_ps2RecompiledFunctionTable[403935] = bhActionWeapon_0x28a610; // 0x28a784 - g_ps2RecompiledFunctionTable[403936] = bhActionWeapon_0x28a610; // 0x28a788 - g_ps2RecompiledFunctionTable[403937] = bhActionWeapon_0x28a610; // 0x28a78c - g_ps2RecompiledFunctionTable[403938] = bhActionWeapon_0x28a610; // 0x28a790 - g_ps2RecompiledFunctionTable[403939] = bhActionWeapon_0x28a610; // 0x28a794 - g_ps2RecompiledFunctionTable[403940] = bhActionWeapon_0x28a610; // 0x28a798 - g_ps2RecompiledFunctionTable[403941] = bhActionWeapon_0x28a610; // 0x28a79c - g_ps2RecompiledFunctionTable[403942] = bhActionWeapon_0x28a610; // 0x28a7a0 - g_ps2RecompiledFunctionTable[403943] = bhActionWeapon_0x28a610; // 0x28a7a4 - g_ps2RecompiledFunctionTable[403944] = bhActionWeapon_0x28a610; // 0x28a7a8 - g_ps2RecompiledFunctionTable[403945] = bhActionWeapon_0x28a610; // 0x28a7ac - g_ps2RecompiledFunctionTable[403946] = bhActionWeapon_0x28a610; // 0x28a7b0 - g_ps2RecompiledFunctionTable[403947] = bhActionWeapon_0x28a610; // 0x28a7b4 - g_ps2RecompiledFunctionTable[403948] = bhActionWeapon_0x28a610; // 0x28a7b8 - g_ps2RecompiledFunctionTable[403949] = bhActionWeapon_0x28a610; // 0x28a7bc - g_ps2RecompiledFunctionTable[403950] = bhActionWeapon_0x28a610; // 0x28a7c0 - g_ps2RecompiledFunctionTable[403951] = bhActionWeapon_0x28a610; // 0x28a7c4 - g_ps2RecompiledFunctionTable[403952] = bhActionWeapon_0x28a610; // 0x28a7c8 - g_ps2RecompiledFunctionTable[403953] = bhActionWeapon_0x28a610; // 0x28a7cc - g_ps2RecompiledFunctionTable[403954] = bhActionWeapon_0x28a610; // 0x28a7d0 - g_ps2RecompiledFunctionTable[403955] = bhActionWeapon_0x28a610; // 0x28a7d4 - g_ps2RecompiledFunctionTable[403956] = bhActionWeapon_0x28a610; // 0x28a7d8 - g_ps2RecompiledFunctionTable[403957] = bhActionWeapon_0x28a610; // 0x28a7dc - g_ps2RecompiledFunctionTable[403958] = bhActionWeapon_0x28a610; // 0x28a7e0 - g_ps2RecompiledFunctionTable[403959] = bhActionWeapon_0x28a610; // 0x28a7e4 - g_ps2RecompiledFunctionTable[403960] = bhActionWeapon_0x28a610; // 0x28a7e8 - g_ps2RecompiledFunctionTable[403961] = bhActionWeapon_0x28a610; // 0x28a7ec - g_ps2RecompiledFunctionTable[403962] = bhActionWeapon_0x28a610; // 0x28a7f0 - g_ps2RecompiledFunctionTable[403963] = bhActionWeapon_0x28a610; // 0x28a7f4 - g_ps2RecompiledFunctionTable[403964] = bhActionWeapon_0x28a610; // 0x28a7f8 - g_ps2RecompiledFunctionTable[403965] = bhActionWeapon_0x28a610; // 0x28a7fc - g_ps2RecompiledFunctionTable[403966] = bhActionWeapon_0x28a610; // 0x28a800 - g_ps2RecompiledFunctionTable[403967] = bhActionWeapon_0x28a610; // 0x28a804 - g_ps2RecompiledFunctionTable[403968] = bhActionWeapon_0x28a610; // 0x28a808 - g_ps2RecompiledFunctionTable[403969] = bhActionWeapon_0x28a610; // 0x28a80c - g_ps2RecompiledFunctionTable[403970] = bhActionWeapon_0x28a610; // 0x28a810 - g_ps2RecompiledFunctionTable[403971] = bhActionWeapon_0x28a610; // 0x28a814 - g_ps2RecompiledFunctionTable[403972] = bhActionWeapon_0x28a610; // 0x28a818 - g_ps2RecompiledFunctionTable[403973] = bhActionWeapon_0x28a610; // 0x28a81c - g_ps2RecompiledFunctionTable[403974] = bhActionWeapon_0x28a610; // 0x28a820 - g_ps2RecompiledFunctionTable[403975] = bhActionWeapon_0x28a610; // 0x28a824 - g_ps2RecompiledFunctionTable[403976] = bhActionWeapon_0x28a610; // 0x28a828 - g_ps2RecompiledFunctionTable[403977] = bhActionWeapon_0x28a610; // 0x28a82c - g_ps2RecompiledFunctionTable[403978] = bhActionWeapon_0x28a610; // 0x28a830 - g_ps2RecompiledFunctionTable[403979] = bhActionWeapon_0x28a610; // 0x28a834 - g_ps2RecompiledFunctionTable[403980] = bhActionWeapon_0x28a610; // 0x28a838 - g_ps2RecompiledFunctionTable[403981] = bhActionWeapon_0x28a610; // 0x28a83c - g_ps2RecompiledFunctionTable[403982] = bhActionWeapon_0x28a610; // 0x28a840 - g_ps2RecompiledFunctionTable[403983] = bhActionWeapon_0x28a610; // 0x28a844 - g_ps2RecompiledFunctionTable[403984] = bhActionWeapon_0x28a610; // 0x28a848 - g_ps2RecompiledFunctionTable[403985] = bhActionWeapon_0x28a610; // 0x28a84c - g_ps2RecompiledFunctionTable[403986] = bhActionWeapon_0x28a610; // 0x28a850 - g_ps2RecompiledFunctionTable[403987] = bhActionWeapon_0x28a610; // 0x28a854 - g_ps2RecompiledFunctionTable[403988] = bhActionWeapon_0x28a610; // 0x28a858 - g_ps2RecompiledFunctionTable[403989] = bhActionWeapon_0x28a610; // 0x28a85c - g_ps2RecompiledFunctionTable[403990] = bhActionWeapon_0x28a610; // 0x28a860 - g_ps2RecompiledFunctionTable[403991] = bhActionWeapon_0x28a610; // 0x28a864 - g_ps2RecompiledFunctionTable[403992] = bhActionWeapon_0x28a610; // 0x28a868 - g_ps2RecompiledFunctionTable[403993] = bhActionWeapon_0x28a610; // 0x28a86c - g_ps2RecompiledFunctionTable[403994] = bhActionWeapon_0x28a610; // 0x28a870 - g_ps2RecompiledFunctionTable[403995] = bhActionWeapon_0x28a610; // 0x28a874 - g_ps2RecompiledFunctionTable[403996] = bhActionWeapon_0x28a610; // 0x28a878 - g_ps2RecompiledFunctionTable[403997] = bhActionWeapon_0x28a610; // 0x28a87c - g_ps2RecompiledFunctionTable[403998] = bhActionWeapon_0x28a610; // 0x28a880 - g_ps2RecompiledFunctionTable[403999] = bhActionWeapon_0x28a610; // 0x28a884 - g_ps2RecompiledFunctionTable[404000] = bhActionWeapon_0x28a610; // 0x28a888 - g_ps2RecompiledFunctionTable[404001] = bhActionWeapon_0x28a610; // 0x28a88c - g_ps2RecompiledFunctionTable[404002] = bhActionWeapon_0x28a610; // 0x28a890 - g_ps2RecompiledFunctionTable[404003] = bhActionWeapon_0x28a610; // 0x28a894 - g_ps2RecompiledFunctionTable[404004] = bhActionWeapon_0x28a610; // 0x28a898 - g_ps2RecompiledFunctionTable[404005] = bhActionWeapon_0x28a610; // 0x28a89c - g_ps2RecompiledFunctionTable[404006] = bhActionWeapon_0x28a610; // 0x28a8a0 - g_ps2RecompiledFunctionTable[404007] = bhActionWeapon_0x28a610; // 0x28a8a4 - g_ps2RecompiledFunctionTable[404008] = bhActionWeapon_0x28a610; // 0x28a8a8 - g_ps2RecompiledFunctionTable[404009] = bhActionWeapon_0x28a610; // 0x28a8ac - g_ps2RecompiledFunctionTable[404010] = bhActionWeapon_0x28a610; // 0x28a8b0 - g_ps2RecompiledFunctionTable[404011] = bhActionWeapon_0x28a610; // 0x28a8b4 - g_ps2RecompiledFunctionTable[404012] = bhActionWeapon_0x28a610; // 0x28a8b8 - g_ps2RecompiledFunctionTable[404013] = bhActionWeapon_0x28a610; // 0x28a8bc - g_ps2RecompiledFunctionTable[404014] = bhActionWeapon_0x28a610; // 0x28a8c0 - g_ps2RecompiledFunctionTable[404015] = bhActionWeapon_0x28a610; // 0x28a8c4 - g_ps2RecompiledFunctionTable[404016] = bhActionWeapon_0x28a610; // 0x28a8c8 - g_ps2RecompiledFunctionTable[404017] = bhActionWeapon_0x28a610; // 0x28a8cc - g_ps2RecompiledFunctionTable[404018] = bhActionWeapon_0x28a610; // 0x28a8d0 - g_ps2RecompiledFunctionTable[404019] = bhActionWeapon_0x28a610; // 0x28a8d4 - g_ps2RecompiledFunctionTable[404020] = bhActionWeapon_0x28a610; // 0x28a8d8 - g_ps2RecompiledFunctionTable[404021] = bhActionWeapon_0x28a610; // 0x28a8dc - g_ps2RecompiledFunctionTable[404022] = bhActionWeapon_0x28a610; // 0x28a8e0 - g_ps2RecompiledFunctionTable[404023] = bhActionWeapon_0x28a610; // 0x28a8e4 - g_ps2RecompiledFunctionTable[404024] = bhActionWeapon_0x28a610; // 0x28a8e8 - g_ps2RecompiledFunctionTable[404025] = bhActionWeapon_0x28a610; // 0x28a8ec - g_ps2RecompiledFunctionTable[404026] = bhActionWeapon_0x28a610; // 0x28a8f0 - g_ps2RecompiledFunctionTable[404027] = bhActionWeapon_0x28a610; // 0x28a8f4 - g_ps2RecompiledFunctionTable[404028] = bhActionWeapon_0x28a610; // 0x28a8f8 - g_ps2RecompiledFunctionTable[404029] = bhActionWeapon_0x28a610; // 0x28a8fc - g_ps2RecompiledFunctionTable[404030] = bhActionWeapon_0x28a610; // 0x28a900 - g_ps2RecompiledFunctionTable[404031] = bhActionWeapon_0x28a610; // 0x28a904 - g_ps2RecompiledFunctionTable[404032] = bhActionWeapon_0x28a610; // 0x28a908 - g_ps2RecompiledFunctionTable[404033] = bhActionWeapon_0x28a610; // 0x28a90c - g_ps2RecompiledFunctionTable[404034] = bhActionWeapon_0x28a610; // 0x28a910 - g_ps2RecompiledFunctionTable[404035] = bhActionWeapon_0x28a610; // 0x28a914 - g_ps2RecompiledFunctionTable[404036] = bhActionWeapon_0x28a610; // 0x28a918 - g_ps2RecompiledFunctionTable[404037] = bhActionWeapon_0x28a610; // 0x28a91c - g_ps2RecompiledFunctionTable[404038] = bhActionWeapon_0x28a610; // 0x28a920 - g_ps2RecompiledFunctionTable[404039] = bhActionWeapon_0x28a610; // 0x28a924 - g_ps2RecompiledFunctionTable[404040] = bhActionWeapon_0x28a610; // 0x28a928 - g_ps2RecompiledFunctionTable[404041] = bhActionWeapon_0x28a610; // 0x28a92c - g_ps2RecompiledFunctionTable[404042] = bhActionWeapon_0x28a610; // 0x28a930 - g_ps2RecompiledFunctionTable[404043] = bhActionWeapon_0x28a610; // 0x28a934 - g_ps2RecompiledFunctionTable[404044] = bhActionWeapon_0x28a610; // 0x28a938 - g_ps2RecompiledFunctionTable[404045] = bhActionWeapon_0x28a610; // 0x28a93c - g_ps2RecompiledFunctionTable[404046] = bhActionWeapon_0x28a610; // 0x28a940 - g_ps2RecompiledFunctionTable[404047] = bhActionWeapon_0x28a610; // 0x28a944 - g_ps2RecompiledFunctionTable[404048] = bhActionWeapon_0x28a610; // 0x28a948 - g_ps2RecompiledFunctionTable[404049] = bhActionWeapon_0x28a610; // 0x28a94c - g_ps2RecompiledFunctionTable[404050] = bhActionWeapon_0x28a610; // 0x28a950 - g_ps2RecompiledFunctionTable[404051] = bhActionWeapon_0x28a610; // 0x28a954 - g_ps2RecompiledFunctionTable[404052] = bhActionWeapon_0x28a610; // 0x28a958 - g_ps2RecompiledFunctionTable[404053] = bhActionWeapon_0x28a610; // 0x28a95c - g_ps2RecompiledFunctionTable[404054] = bhActionWeapon_0x28a610; // 0x28a960 - g_ps2RecompiledFunctionTable[404055] = bhActionWeapon_0x28a610; // 0x28a964 - g_ps2RecompiledFunctionTable[404056] = bhActionWeapon_0x28a610; // 0x28a968 - g_ps2RecompiledFunctionTable[404057] = bhActionWeapon_0x28a610; // 0x28a96c - g_ps2RecompiledFunctionTable[404058] = bhActionWeapon_0x28a610; // 0x28a970 - g_ps2RecompiledFunctionTable[404059] = bhActionWeapon_0x28a610; // 0x28a974 - g_ps2RecompiledFunctionTable[404060] = bhActionWeapon_0x28a610; // 0x28a978 - g_ps2RecompiledFunctionTable[404061] = bhActionWeapon_0x28a610; // 0x28a97c - g_ps2RecompiledFunctionTable[404062] = bhActionWeapon_0x28a610; // 0x28a980 - g_ps2RecompiledFunctionTable[404063] = bhActionWeapon_0x28a610; // 0x28a984 - g_ps2RecompiledFunctionTable[404064] = bhActionWeapon_0x28a610; // 0x28a988 - g_ps2RecompiledFunctionTable[404065] = bhActionWeapon_0x28a610; // 0x28a98c - g_ps2RecompiledFunctionTable[404066] = bhActionWeapon_0x28a610; // 0x28a990 - g_ps2RecompiledFunctionTable[404067] = bhActionWeapon_0x28a610; // 0x28a994 - g_ps2RecompiledFunctionTable[404068] = bhActionWeapon_0x28a610; // 0x28a998 - g_ps2RecompiledFunctionTable[404069] = bhActionWeapon_0x28a610; // 0x28a99c - g_ps2RecompiledFunctionTable[404070] = bhActionWeapon_0x28a610; // 0x28a9a0 - g_ps2RecompiledFunctionTable[404071] = bhActionWeapon_0x28a610; // 0x28a9a4 - g_ps2RecompiledFunctionTable[404072] = bhActionWeapon_0x28a610; // 0x28a9a8 - g_ps2RecompiledFunctionTable[404073] = bhActionWeapon_0x28a610; // 0x28a9ac - g_ps2RecompiledFunctionTable[404074] = bhActionWeapon_0x28a610; // 0x28a9b0 - g_ps2RecompiledFunctionTable[404075] = bhActionWeapon_0x28a610; // 0x28a9b4 - g_ps2RecompiledFunctionTable[404076] = bhActionWeapon_0x28a610; // 0x28a9b8 - g_ps2RecompiledFunctionTable[404077] = bhActionWeapon_0x28a610; // 0x28a9bc - g_ps2RecompiledFunctionTable[404078] = bhActionWeapon_0x28a610; // 0x28a9c0 - g_ps2RecompiledFunctionTable[404079] = bhActionWeapon_0x28a610; // 0x28a9c4 - g_ps2RecompiledFunctionTable[404080] = bhActionWeapon_0x28a610; // 0x28a9c8 - g_ps2RecompiledFunctionTable[404081] = bhActionWeapon_0x28a610; // 0x28a9cc - g_ps2RecompiledFunctionTable[404082] = bhActionWeapon_0x28a610; // 0x28a9d0 - g_ps2RecompiledFunctionTable[404083] = bhActionWeapon_0x28a610; // 0x28a9d4 - g_ps2RecompiledFunctionTable[404084] = bhActionWeapon_0x28a610; // 0x28a9d8 - g_ps2RecompiledFunctionTable[404085] = bhActionWeapon_0x28a610; // 0x28a9dc - g_ps2RecompiledFunctionTable[404086] = bhActionWeapon_0x28a610; // 0x28a9e0 - g_ps2RecompiledFunctionTable[404087] = bhActionWeapon_0x28a610; // 0x28a9e4 - g_ps2RecompiledFunctionTable[404088] = bhActionWeapon_0x28a610; // 0x28a9e8 - g_ps2RecompiledFunctionTable[404089] = bhActionWeapon_0x28a610; // 0x28a9ec - g_ps2RecompiledFunctionTable[404090] = bhActionWeapon_0x28a610; // 0x28a9f0 - g_ps2RecompiledFunctionTable[404091] = bhActionWeapon_0x28a610; // 0x28a9f4 - g_ps2RecompiledFunctionTable[404092] = bhActionWeapon_0x28a610; // 0x28a9f8 - g_ps2RecompiledFunctionTable[404093] = bhActionWeapon_0x28a610; // 0x28a9fc - g_ps2RecompiledFunctionTable[404094] = bhActionWeapon_0x28a610; // 0x28aa00 - g_ps2RecompiledFunctionTable[404095] = bhActionWeapon_0x28a610; // 0x28aa04 - g_ps2RecompiledFunctionTable[404096] = bhActionWeapon_0x28a610; // 0x28aa08 - g_ps2RecompiledFunctionTable[404097] = bhActionWeapon_0x28a610; // 0x28aa0c - g_ps2RecompiledFunctionTable[404098] = bhActionWeapon_0x28a610; // 0x28aa10 - g_ps2RecompiledFunctionTable[404099] = bhActionWeapon_0x28a610; // 0x28aa14 - g_ps2RecompiledFunctionTable[404100] = bhActionWeapon_0x28a610; // 0x28aa18 - g_ps2RecompiledFunctionTable[404101] = bhActionWeapon_0x28a610; // 0x28aa1c - g_ps2RecompiledFunctionTable[404102] = bhActionWeapon_0x28a610; // 0x28aa20 - g_ps2RecompiledFunctionTable[404103] = bhActionWeapon_0x28a610; // 0x28aa24 - g_ps2RecompiledFunctionTable[404104] = bhActionWeapon_0x28a610; // 0x28aa28 - g_ps2RecompiledFunctionTable[404105] = bhActionWeapon_0x28a610; // 0x28aa2c - g_ps2RecompiledFunctionTable[404106] = bhActionWeapon_0x28a610; // 0x28aa30 - g_ps2RecompiledFunctionTable[404107] = bhActionWeapon_0x28a610; // 0x28aa34 - g_ps2RecompiledFunctionTable[404108] = bhActionWeapon_0x28a610; // 0x28aa38 - g_ps2RecompiledFunctionTable[404109] = bhActionWeapon_0x28a610; // 0x28aa3c - g_ps2RecompiledFunctionTable[404110] = bhActionWeapon_0x28a610; // 0x28aa40 - g_ps2RecompiledFunctionTable[404111] = bhActionWeapon_0x28a610; // 0x28aa44 - g_ps2RecompiledFunctionTable[404112] = bhActionWeapon_0x28a610; // 0x28aa48 - g_ps2RecompiledFunctionTable[404113] = bhActionWeapon_0x28a610; // 0x28aa4c - g_ps2RecompiledFunctionTable[404114] = bhActionWeapon_0x28a610; // 0x28aa50 - g_ps2RecompiledFunctionTable[404115] = bhActionWeapon_0x28a610; // 0x28aa54 - g_ps2RecompiledFunctionTable[404116] = bhActionWeapon_0x28a610; // 0x28aa58 - g_ps2RecompiledFunctionTable[404117] = bhActionWeapon_0x28a610; // 0x28aa5c - g_ps2RecompiledFunctionTable[404118] = bhActionWeapon_0x28a610; // 0x28aa60 - g_ps2RecompiledFunctionTable[404119] = bhActionWeapon_0x28a610; // 0x28aa64 - g_ps2RecompiledFunctionTable[404120] = bhActionWeapon_0x28a610; // 0x28aa68 - g_ps2RecompiledFunctionTable[404121] = bhActionWeapon_0x28a610; // 0x28aa6c - g_ps2RecompiledFunctionTable[404122] = bhActionWeapon_0x28a610; // 0x28aa70 - g_ps2RecompiledFunctionTable[404123] = bhActionWeapon_0x28a610; // 0x28aa74 - g_ps2RecompiledFunctionTable[404124] = bhActionWeapon_0x28a610; // 0x28aa78 - g_ps2RecompiledFunctionTable[404125] = bhActionWeapon_0x28a610; // 0x28aa7c - g_ps2RecompiledFunctionTable[404126] = bhActionWeapon_0x28a610; // 0x28aa80 - g_ps2RecompiledFunctionTable[404127] = bhActionWeapon_0x28a610; // 0x28aa84 - g_ps2RecompiledFunctionTable[404128] = bhActionWeapon_0x28a610; // 0x28aa88 - g_ps2RecompiledFunctionTable[404129] = bhActionWeapon_0x28a610; // 0x28aa8c - g_ps2RecompiledFunctionTable[404130] = bhActionWeapon_0x28a610; // 0x28aa90 - g_ps2RecompiledFunctionTable[404131] = bhActionWeapon_0x28a610; // 0x28aa94 - g_ps2RecompiledFunctionTable[404132] = bhActionWeapon_0x28a610; // 0x28aa98 - g_ps2RecompiledFunctionTable[404133] = bhActionWeapon_0x28a610; // 0x28aa9c - g_ps2RecompiledFunctionTable[404134] = bhActionWeapon_0x28a610; // 0x28aaa0 - g_ps2RecompiledFunctionTable[404135] = bhActionWeapon_0x28a610; // 0x28aaa4 - g_ps2RecompiledFunctionTable[404136] = bhActionWeapon_0x28a610; // 0x28aaa8 - g_ps2RecompiledFunctionTable[404137] = bhActionWeapon_0x28a610; // 0x28aaac - g_ps2RecompiledFunctionTable[404138] = bhActionWeapon_0x28a610; // 0x28aab0 - g_ps2RecompiledFunctionTable[404139] = bhActionWeapon_0x28a610; // 0x28aab4 - g_ps2RecompiledFunctionTable[404140] = bhActionWeapon_0x28a610; // 0x28aab8 - g_ps2RecompiledFunctionTable[404141] = bhActionWeapon_0x28a610; // 0x28aabc - g_ps2RecompiledFunctionTable[404142] = bhActionWeapon_0x28a610; // 0x28aac0 - g_ps2RecompiledFunctionTable[404143] = bhActionWeapon_0x28a610; // 0x28aac4 - g_ps2RecompiledFunctionTable[404144] = bhActionWeapon_0x28a610; // 0x28aac8 - g_ps2RecompiledFunctionTable[404145] = bhActionWeapon_0x28a610; // 0x28aacc - g_ps2RecompiledFunctionTable[404146] = bhActionWeapon_0x28a610; // 0x28aad0 - g_ps2RecompiledFunctionTable[404147] = bhActionWeapon_0x28a610; // 0x28aad4 - g_ps2RecompiledFunctionTable[404148] = bhActionWeapon_0x28a610; // 0x28aad8 - g_ps2RecompiledFunctionTable[404149] = bhActionWeapon_0x28a610; // 0x28aadc - g_ps2RecompiledFunctionTable[404150] = bhActionWeapon_0x28a610; // 0x28aae0 - g_ps2RecompiledFunctionTable[404151] = bhActionWeapon_0x28a610; // 0x28aae4 - g_ps2RecompiledFunctionTable[404152] = bhActionWeapon_0x28a610; // 0x28aae8 - g_ps2RecompiledFunctionTable[404153] = bhActionWeapon_0x28a610; // 0x28aaec - g_ps2RecompiledFunctionTable[404154] = bhActionWeapon_0x28a610; // 0x28aaf0 - g_ps2RecompiledFunctionTable[404155] = bhActionWeapon_0x28a610; // 0x28aaf4 - g_ps2RecompiledFunctionTable[404156] = bhActionWeapon_0x28a610; // 0x28aaf8 - g_ps2RecompiledFunctionTable[404157] = bhActionWeapon_0x28a610; // 0x28aafc - g_ps2RecompiledFunctionTable[404158] = bhActionWeapon_0x28a610; // 0x28ab00 - g_ps2RecompiledFunctionTable[404159] = bhActionWeapon_0x28a610; // 0x28ab04 - g_ps2RecompiledFunctionTable[404160] = bhActionWeapon_0x28a610; // 0x28ab08 - g_ps2RecompiledFunctionTable[404161] = bhActionWeapon_0x28a610; // 0x28ab0c - g_ps2RecompiledFunctionTable[404162] = bhActionWeapon_0x28a610; // 0x28ab10 - g_ps2RecompiledFunctionTable[404163] = bhActionWeapon_0x28a610; // 0x28ab14 - g_ps2RecompiledFunctionTable[404164] = bhActionWeapon_0x28a610; // 0x28ab18 - g_ps2RecompiledFunctionTable[404165] = bhActionWeapon_0x28a610; // 0x28ab1c - g_ps2RecompiledFunctionTable[404166] = bhActionWeapon_0x28a610; // 0x28ab20 - g_ps2RecompiledFunctionTable[404167] = bhActionWeapon_0x28a610; // 0x28ab24 - g_ps2RecompiledFunctionTable[404168] = bhActionWeapon_0x28a610; // 0x28ab28 - g_ps2RecompiledFunctionTable[404169] = bhActionWeapon_0x28a610; // 0x28ab2c - g_ps2RecompiledFunctionTable[404170] = bhActionWeapon_0x28a610; // 0x28ab30 - g_ps2RecompiledFunctionTable[404171] = bhActionWeapon_0x28a610; // 0x28ab34 - g_ps2RecompiledFunctionTable[404172] = bhActionWeapon_0x28a610; // 0x28ab38 - g_ps2RecompiledFunctionTable[404173] = bhActionWeapon_0x28a610; // 0x28ab3c - g_ps2RecompiledFunctionTable[404174] = bhActionWeapon_0x28a610; // 0x28ab40 - g_ps2RecompiledFunctionTable[404175] = bhActionWeapon_0x28a610; // 0x28ab44 - g_ps2RecompiledFunctionTable[404176] = bhActionWeapon_0x28a610; // 0x28ab48 - g_ps2RecompiledFunctionTable[404177] = bhActionWeapon_0x28a610; // 0x28ab4c - g_ps2RecompiledFunctionTable[404178] = bhActionWeapon_0x28a610; // 0x28ab50 - g_ps2RecompiledFunctionTable[404179] = bhActionWeapon_0x28a610; // 0x28ab54 - g_ps2RecompiledFunctionTable[404180] = bhActionWeapon_0x28a610; // 0x28ab58 - g_ps2RecompiledFunctionTable[404181] = bhActionWeapon_0x28a610; // 0x28ab5c - g_ps2RecompiledFunctionTable[404182] = bhActionWeapon_0x28a610; // 0x28ab60 - g_ps2RecompiledFunctionTable[404183] = bhActionWeapon_0x28a610; // 0x28ab64 - g_ps2RecompiledFunctionTable[404184] = bhActionWeapon_0x28a610; // 0x28ab68 - g_ps2RecompiledFunctionTable[404185] = bhActionWeapon_0x28a610; // 0x28ab6c - g_ps2RecompiledFunctionTable[404186] = bhActionWeapon_0x28a610; // 0x28ab70 - g_ps2RecompiledFunctionTable[404187] = bhActionWeapon_0x28a610; // 0x28ab74 - g_ps2RecompiledFunctionTable[404188] = bhActionWeapon_0x28a610; // 0x28ab78 - g_ps2RecompiledFunctionTable[404189] = bhActionWeapon_0x28a610; // 0x28ab7c - g_ps2RecompiledFunctionTable[404190] = bhActionWeapon_0x28a610; // 0x28ab80 - g_ps2RecompiledFunctionTable[404191] = bhActionWeapon_0x28a610; // 0x28ab84 - g_ps2RecompiledFunctionTable[404192] = bhActionWeapon_0x28a610; // 0x28ab88 - g_ps2RecompiledFunctionTable[404193] = bhActionWeapon_0x28a610; // 0x28ab8c - g_ps2RecompiledFunctionTable[404194] = bhActionWeapon_0x28a610; // 0x28ab90 - g_ps2RecompiledFunctionTable[404195] = bhActionWeapon_0x28a610; // 0x28ab94 - g_ps2RecompiledFunctionTable[404196] = bhActionWeapon_0x28a610; // 0x28ab98 - g_ps2RecompiledFunctionTable[404197] = bhActionWeapon_0x28a610; // 0x28ab9c - g_ps2RecompiledFunctionTable[404198] = bhActionWeapon_0x28a610; // 0x28aba0 - g_ps2RecompiledFunctionTable[404199] = bhActionWeapon_0x28a610; // 0x28aba4 - g_ps2RecompiledFunctionTable[404200] = bhActionWeapon_0x28a610; // 0x28aba8 - g_ps2RecompiledFunctionTable[404201] = bhActionWeapon_0x28a610; // 0x28abac - g_ps2RecompiledFunctionTable[404202] = bhActionWeapon_0x28a610; // 0x28abb0 - g_ps2RecompiledFunctionTable[404203] = bhActionWeapon_0x28a610; // 0x28abb4 - g_ps2RecompiledFunctionTable[404204] = bhActionWeapon_0x28a610; // 0x28abb8 - g_ps2RecompiledFunctionTable[404205] = bhActionWeapon_0x28a610; // 0x28abbc - g_ps2RecompiledFunctionTable[404206] = bhActionWeapon_0x28a610; // 0x28abc0 - g_ps2RecompiledFunctionTable[404207] = bhActionWeapon_0x28a610; // 0x28abc4 - g_ps2RecompiledFunctionTable[404208] = bhActionWeapon_0x28a610; // 0x28abc8 - g_ps2RecompiledFunctionTable[404209] = bhActionWeapon_0x28a610; // 0x28abcc - g_ps2RecompiledFunctionTable[404210] = bhActionWeapon_0x28a610; // 0x28abd0 - g_ps2RecompiledFunctionTable[404211] = bhActionWeapon_0x28a610; // 0x28abd4 - g_ps2RecompiledFunctionTable[404212] = bhActionWeapon_0x28a610; // 0x28abd8 - g_ps2RecompiledFunctionTable[404213] = bhActionWeapon_0x28a610; // 0x28abdc - g_ps2RecompiledFunctionTable[404214] = bhActionWeapon_0x28a610; // 0x28abe0 - g_ps2RecompiledFunctionTable[404215] = bhActionWeapon_0x28a610; // 0x28abe4 - g_ps2RecompiledFunctionTable[404216] = bhActionWeapon_0x28a610; // 0x28abe8 - g_ps2RecompiledFunctionTable[404217] = bhActionWeapon_0x28a610; // 0x28abec - g_ps2RecompiledFunctionTable[404218] = bhActionWeapon_0x28a610; // 0x28abf0 - g_ps2RecompiledFunctionTable[404219] = bhActionWeapon_0x28a610; // 0x28abf4 - g_ps2RecompiledFunctionTable[404220] = bhActionWeapon_0x28a610; // 0x28abf8 - g_ps2RecompiledFunctionTable[404221] = bhActionWeapon_0x28a610; // 0x28abfc - g_ps2RecompiledFunctionTable[404222] = bhActionWeapon_0x28a610; // 0x28ac00 - g_ps2RecompiledFunctionTable[404223] = bhActionWeapon_0x28a610; // 0x28ac04 - g_ps2RecompiledFunctionTable[404224] = bhActionWeapon_0x28a610; // 0x28ac08 - g_ps2RecompiledFunctionTable[404225] = bhActionWeapon_0x28a610; // 0x28ac0c - g_ps2RecompiledFunctionTable[404226] = bhActionWeapon_0x28a610; // 0x28ac10 - g_ps2RecompiledFunctionTable[404227] = bhActionWeapon_0x28a610; // 0x28ac14 - g_ps2RecompiledFunctionTable[404228] = bhActionWeapon_0x28a610; // 0x28ac18 - g_ps2RecompiledFunctionTable[404229] = bhActionWeapon_0x28a610; // 0x28ac1c - g_ps2RecompiledFunctionTable[404230] = bhActionWeapon_0x28a610; // 0x28ac20 - g_ps2RecompiledFunctionTable[404231] = bhActionWeapon_0x28a610; // 0x28ac24 - g_ps2RecompiledFunctionTable[404232] = bhActionWeapon_0x28a610; // 0x28ac28 - g_ps2RecompiledFunctionTable[404233] = bhActionWeapon_0x28a610; // 0x28ac2c - g_ps2RecompiledFunctionTable[404234] = bhActionWeapon_0x28a610; // 0x28ac30 - g_ps2RecompiledFunctionTable[404238] = bhCheckBullet_0x28ac40; // 0x28ac40 - g_ps2RecompiledFunctionTable[404262] = bhCountBullet_0x28aca0; // 0x28aca0 - g_ps2RecompiledFunctionTable[404322] = bhCheckGunAtari_0x28ad90; // 0x28ad90 - g_ps2RecompiledFunctionTable[404401] = bhCheckGunAtari_0x28ad90; // 0x28aecc - g_ps2RecompiledFunctionTable[404427] = bhCheckGunAtari_0x28ad90; // 0x28af34 - g_ps2RecompiledFunctionTable[404466] = bhCheckGunAtari_0x28ad90; // 0x28afd0 - g_ps2RecompiledFunctionTable[404532] = bhCheckGunAtari_0x28ad90; // 0x28b0d8 - g_ps2RecompiledFunctionTable[404592] = bhCheckGunAtari_0x28ad90; // 0x28b1c8 - g_ps2RecompiledFunctionTable[404640] = bhCheckGunAtari_0x28ad90; // 0x28b288 - g_ps2RecompiledFunctionTable[404656] = bhCheckGunAtari_0x28ad90; // 0x28b2c8 - g_ps2RecompiledFunctionTable[404694] = bhCheckGunAtari_0x28ad90; // 0x28b360 - g_ps2RecompiledFunctionTable[404696] = bhCheckGunAtari_0x28ad90; // 0x28b368 - g_ps2RecompiledFunctionTable[404699] = bhCheckGunAtari_0x28ad90; // 0x28b374 - g_ps2RecompiledFunctionTable[404713] = bhCheckGunAtari_0x28ad90; // 0x28b3ac - g_ps2RecompiledFunctionTable[404719] = bhCheckGunAtari_0x28ad90; // 0x28b3c4 - g_ps2RecompiledFunctionTable[404739] = bhCheckGunAtari_0x28ad90; // 0x28b414 - g_ps2RecompiledFunctionTable[404760] = bhCheckGunAtari_0x28ad90; // 0x28b468 - g_ps2RecompiledFunctionTable[404776] = bhCheckGunAtari_0x28ad90; // 0x28b4a8 - g_ps2RecompiledFunctionTable[404831] = bhCheckGunAtari_0x28ad90; // 0x28b584 - g_ps2RecompiledFunctionTable[404850] = bhCheckGunAtari_0x28ad90; // 0x28b5d0 - g_ps2RecompiledFunctionTable[404997] = bhCheckGunAtari_0x28ad90; // 0x28b81c - g_ps2RecompiledFunctionTable[405016] = bhCheckGunAtari_0x28ad90; // 0x28b868 - g_ps2RecompiledFunctionTable[405148] = bhCheckGunAtari_0x28ad90; // 0x28ba78 - g_ps2RecompiledFunctionTable[405150] = bhCheckGunAtari_0x28ad90; // 0x28ba80 - g_ps2RecompiledFunctionTable[405154] = bhCheckGunAtari_0x28ad90; // 0x28ba90 - g_ps2RecompiledFunctionTable[405158] = bhCheckGunAtari_0x28ad90; // 0x28baa0 - g_ps2RecompiledFunctionTable[405164] = bhCheckGunAtari_0x28ad90; // 0x28bab8 - g_ps2RecompiledFunctionTable[405169] = bhCheckGunAtari_0x28ad90; // 0x28bacc - g_ps2RecompiledFunctionTable[405178] = bhCheckGunAtari_0x28ad90; // 0x28baf0 - g_ps2RecompiledFunctionTable[405181] = bhCheckGunAtari_0x28ad90; // 0x28bafc - g_ps2RecompiledFunctionTable[405186] = bhCheckGunAtari_0x28ad90; // 0x28bb10 - g_ps2RecompiledFunctionTable[405226] = bhCheckGunAtari_0x28ad90; // 0x28bbb0 - g_ps2RecompiledFunctionTable[405238] = bhCheckGunAtari_0x28ad90; // 0x28bbe0 - g_ps2RecompiledFunctionTable[405286] = bhCheckGunAtari_0x28ad90; // 0x28bca0 - g_ps2RecompiledFunctionTable[405291] = bhCheckGunAtari_0x28ad90; // 0x28bcb4 - g_ps2RecompiledFunctionTable[405310] = bhCheckGunAtari_0x28ad90; // 0x28bd00 - g_ps2RecompiledFunctionTable[405341] = bhCheckGunAtari_0x28ad90; // 0x28bd7c - g_ps2RecompiledFunctionTable[405356] = bhCheckGunAtari_0x28ad90; // 0x28bdb8 - g_ps2RecompiledFunctionTable[405393] = bhCheckGunAtari_0x28ad90; // 0x28be4c - g_ps2RecompiledFunctionTable[405397] = bhCheckGunAtari_0x28ad90; // 0x28be5c - g_ps2RecompiledFunctionTable[405415] = bhCheckGunAtari_0x28ad90; // 0x28bea4 - g_ps2RecompiledFunctionTable[405467] = bhCheckGunAtari_0x28ad90; // 0x28bf74 - g_ps2RecompiledFunctionTable[405502] = bhCheckGunAtari_0x28ad90; // 0x28c000 - g_ps2RecompiledFunctionTable[405515] = bhCheckGunAtari_0x28ad90; // 0x28c034 - g_ps2RecompiledFunctionTable[405525] = bhCheckGunAtari_0x28ad90; // 0x28c05c - g_ps2RecompiledFunctionTable[405560] = bhCheckGunAtari_0x28ad90; // 0x28c0e8 - g_ps2RecompiledFunctionTable[405573] = bhCheckGunAtari_0x28ad90; // 0x28c11c - g_ps2RecompiledFunctionTable[405630] = bhCheckGunAtari_0x28ad90; // 0x28c200 - g_ps2RecompiledFunctionTable[405653] = bhCheckGunAtari_0x28ad90; // 0x28c25c - g_ps2RecompiledFunctionTable[405658] = bhCheckGunAtari_0x28ad90; // 0x28c270 - g_ps2RecompiledFunctionTable[405686] = bhCheckKnifeAtari_0x28c2e0; // 0x28c2e0 - g_ps2RecompiledFunctionTable[405730] = bhCheckKnifeAtari_0x28c2e0; // 0x28c390 - g_ps2RecompiledFunctionTable[405776] = bhCheckKnifeAtari_0x28c2e0; // 0x28c448 - g_ps2RecompiledFunctionTable[405794] = bhCheckKnifeAtari_0x28c2e0; // 0x28c490 - g_ps2RecompiledFunctionTable[405833] = bhCheckKnifeAtari_0x28c2e0; // 0x28c52c - g_ps2RecompiledFunctionTable[405864] = bhCheckKnifeAtari_0x28c2e0; // 0x28c5a8 - g_ps2RecompiledFunctionTable[405868] = bhCheckKnifeAtari_0x28c2e0; // 0x28c5b8 - g_ps2RecompiledFunctionTable[405886] = bhCheckKnifeAtari_0x28c2e0; // 0x28c600 - g_ps2RecompiledFunctionTable[405902] = bhCheckKnifeAtari_0x28c2e0; // 0x28c640 - g_ps2RecompiledFunctionTable[405920] = bhCheckKnifeAtari_0x28c2e0; // 0x28c688 - g_ps2RecompiledFunctionTable[405924] = bhCheckKnifeAtari_0x28c2e0; // 0x28c698 - g_ps2RecompiledFunctionTable[405943] = bhCheckKnifeAtari_0x28c2e0; // 0x28c6e4 - g_ps2RecompiledFunctionTable[405972] = bhCheckKnifeAtari_0x28c2e0; // 0x28c758 - g_ps2RecompiledFunctionTable[405981] = bhCheckKnifeAtari_0x28c2e0; // 0x28c77c - g_ps2RecompiledFunctionTable[406008] = bhCheckKnifeAtari_0x28c2e0; // 0x28c7e8 - g_ps2RecompiledFunctionTable[406030] = bhCheckKnifeAtari_0x28c2e0; // 0x28c840 - g_ps2RecompiledFunctionTable[406094] = bhCheckFlyAtari_0x28c940; // 0x28c940 - g_ps2RecompiledFunctionTable[406120] = bhCheckFlyAtari_0x28c940; // 0x28c9a8 - g_ps2RecompiledFunctionTable[406149] = bhCheckFlyAtari_0x28c940; // 0x28ca1c - g_ps2RecompiledFunctionTable[406155] = bhCheckFlyAtari_0x28c940; // 0x28ca34 - g_ps2RecompiledFunctionTable[406173] = bhCheckFlyAtari_0x28c940; // 0x28ca7c - g_ps2RecompiledFunctionTable[406202] = bhCheckFlyAtari_0x28c940; // 0x28caf0 - g_ps2RecompiledFunctionTable[406224] = bhCheckFlyAtari_0x28c940; // 0x28cb48 - g_ps2RecompiledFunctionTable[406284] = bhCheckFlyAtari_0x28c940; // 0x28cc38 - g_ps2RecompiledFunctionTable[406358] = bhSetBowDamage_0x28cd60; // 0x28cd60 - g_ps2RecompiledFunctionTable[406373] = bhSetBowDamage_0x28cd60; // 0x28cd9c - g_ps2RecompiledFunctionTable[406441] = bhSetBowDamage_0x28cd60; // 0x28ceac - g_ps2RecompiledFunctionTable[406460] = bhSetBowDamage_0x28cd60; // 0x28cef8 - g_ps2RecompiledFunctionTable[406487] = bhSetBowDamage_0x28cd60; // 0x28cf64 - g_ps2RecompiledFunctionTable[406518] = bhCheckBombAtari_0x28cfe0; // 0x28cfe0 - g_ps2RecompiledFunctionTable[406563] = bhCheckBombAtari_0x28cfe0; // 0x28d094 - g_ps2RecompiledFunctionTable[406571] = bhCheckBombAtari_0x28cfe0; // 0x28d0b4 - g_ps2RecompiledFunctionTable[406591] = bhCheckBombAtari_0x28cfe0; // 0x28d104 - g_ps2RecompiledFunctionTable[406633] = bhCheckBombAtari_0x28cfe0; // 0x28d1ac - g_ps2RecompiledFunctionTable[406638] = bhCheckBombAtari_0x28cfe0; // 0x28d1c0 - g_ps2RecompiledFunctionTable[406645] = bhCheckBombAtari_0x28cfe0; // 0x28d1dc - g_ps2RecompiledFunctionTable[406652] = bhCheckBombAtari_0x28cfe0; // 0x28d1f8 - g_ps2RecompiledFunctionTable[406665] = bhCheckBombAtari_0x28cfe0; // 0x28d22c - g_ps2RecompiledFunctionTable[406668] = bhCheckBombAtari_0x28cfe0; // 0x28d238 - g_ps2RecompiledFunctionTable[406718] = bhCheckBombAtari_0x28cfe0; // 0x28d300 - g_ps2RecompiledFunctionTable[406746] = bhCheckBombAtari_0x28cfe0; // 0x28d370 - g_ps2RecompiledFunctionTable[406773] = bhCheckBombAtari_0x28cfe0; // 0x28d3dc - g_ps2RecompiledFunctionTable[406779] = bhCheckBombAtari_0x28cfe0; // 0x28d3f4 - g_ps2RecompiledFunctionTable[406799] = bhCheckBombAtari_0x28cfe0; // 0x28d444 - g_ps2RecompiledFunctionTable[406831] = bhCheckBombAtari_0x28cfe0; // 0x28d4c4 - g_ps2RecompiledFunctionTable[406836] = bhCheckBombAtari_0x28cfe0; // 0x28d4d8 - g_ps2RecompiledFunctionTable[406844] = bhCheckBombAtari_0x28cfe0; // 0x28d4f8 - g_ps2RecompiledFunctionTable[406866] = bhCheckBombAtari_0x28cfe0; // 0x28d550 - g_ps2RecompiledFunctionTable[406900] = bhCheckBombAtari_0x28cfe0; // 0x28d5d8 - g_ps2RecompiledFunctionTable[406946] = bhCheckCapCol2Capsule_0x28d690; // 0x28d690 - g_ps2RecompiledFunctionTable[406993] = bhCheckCapCol2Capsule_0x28d690; // 0x28d74c - g_ps2RecompiledFunctionTable[407028] = bhCheckCapCol2Capsule_0x28d690; // 0x28d7d8 - g_ps2RecompiledFunctionTable[407039] = bhCheckCapCol2Capsule_0x28d690; // 0x28d804 - g_ps2RecompiledFunctionTable[407045] = bhCheckCapCol2Capsule_0x28d690; // 0x28d81c - g_ps2RecompiledFunctionTable[407063] = bhCheckCapCol2Capsule_0x28d690; // 0x28d864 - g_ps2RecompiledFunctionTable[407125] = bhCheckCapCol2Capsule_0x28d690; // 0x28d95c - g_ps2RecompiledFunctionTable[407145] = bhCheckCapCol2Capsule_0x28d690; // 0x28d9ac - g_ps2RecompiledFunctionTable[407182] = bhSetGunSplash_0x28da40; // 0x28da40 - g_ps2RecompiledFunctionTable[407203] = bhSetGunSplash_0x28da40; // 0x28da94 - g_ps2RecompiledFunctionTable[407336] = bhSetGunSplash_0x28da40; // 0x28dca8 - g_ps2RecompiledFunctionTable[407405] = bhSetGunSplash_0x28da40; // 0x28ddbc - g_ps2RecompiledFunctionTable[407421] = bhSetGunSplash_0x28da40; // 0x28ddfc - g_ps2RecompiledFunctionTable[407534] = bhSetGunSplash_0x28da40; // 0x28dfc0 - g_ps2RecompiledFunctionTable[407542] = bhSetExplosion_0x28dfe0; // 0x28dfe0 - g_ps2RecompiledFunctionTable[407549] = bhSetExplosion_0x28dfe0; // 0x28dffc - g_ps2RecompiledFunctionTable[407599] = bhSetExplosion_0x28dfe0; // 0x28e0c4 - g_ps2RecompiledFunctionTable[407693] = bhSetExplosion_0x28dfe0; // 0x28e23c - g_ps2RecompiledFunctionTable[407694] = bhSetExplosion_0x28dfe0; // 0x28e240 - g_ps2RecompiledFunctionTable[407727] = bhSetExplosion_0x28dfe0; // 0x28e2c4 - g_ps2RecompiledFunctionTable[407756] = bhSetExplosion_0x28dfe0; // 0x28e338 - g_ps2RecompiledFunctionTable[407771] = bhSetExplosion_0x28dfe0; // 0x28e374 - g_ps2RecompiledFunctionTable[407777] = bhSetExplosion_0x28dfe0; // 0x28e38c - g_ps2RecompiledFunctionTable[407792] = bhSetExplosion_0x28dfe0; // 0x28e3c8 - g_ps2RecompiledFunctionTable[407799] = bhSetExplosion_0x28dfe0; // 0x28e3e4 - g_ps2RecompiledFunctionTable[407810] = bhSetExplosion_0x28dfe0; // 0x28e410 - g_ps2RecompiledFunctionTable[407814] = bhSetExplosion_0x28dfe0; // 0x28e420 - g_ps2RecompiledFunctionTable[407823] = bhSetExplosion_0x28dfe0; // 0x28e444 - g_ps2RecompiledFunctionTable[407834] = bhSetExplosionEffect_0x28e470; // 0x28e470 - g_ps2RecompiledFunctionTable[407931] = bhSetExplosionEffect_0x28e470; // 0x28e5f4 - g_ps2RecompiledFunctionTable[407932] = bhSetExplosionEffect_0x28e470; // 0x28e5f8 - g_ps2RecompiledFunctionTable[407965] = bhSetExplosionEffect_0x28e470; // 0x28e67c - g_ps2RecompiledFunctionTable[407994] = bhSetExplosionEffect_0x28e470; // 0x28e6f0 - g_ps2RecompiledFunctionTable[408009] = bhSetExplosionEffect_0x28e470; // 0x28e72c - g_ps2RecompiledFunctionTable[408015] = bhSetExplosionEffect_0x28e470; // 0x28e744 - g_ps2RecompiledFunctionTable[408030] = bhSetExplosionEffect_0x28e470; // 0x28e780 - g_ps2RecompiledFunctionTable[408037] = bhSetExplosionEffect_0x28e470; // 0x28e79c - g_ps2RecompiledFunctionTable[408048] = bhSetExplosionEffect_0x28e470; // 0x28e7c8 - g_ps2RecompiledFunctionTable[408052] = bhSetExplosionEffect_0x28e470; // 0x28e7d8 - g_ps2RecompiledFunctionTable[408061] = bhSetExplosionEffect_0x28e470; // 0x28e7fc - g_ps2RecompiledFunctionTable[408070] = bhSetExplosionEffectEx_0x28e820; // 0x28e820 - g_ps2RecompiledFunctionTable[408166] = LfInitLib_0x28e9a0; // 0x28e9a0 - g_ps2RecompiledFunctionTable[408169] = LfInitLib_0x28e9a0; // 0x28e9ac - g_ps2RecompiledFunctionTable[408178] = CallbackGdErrorFunc_0x28e9d0; // 0x28e9d0 - g_ps2RecompiledFunctionTable[408190] = InitGdSystem_0x28ea00; // 0x28ea00 - g_ps2RecompiledFunctionTable[408195] = InitGdSystem_0x28ea00; // 0x28ea14 - g_ps2RecompiledFunctionTable[408206] = InitGdSystem_0x28ea00; // 0x28ea40 - g_ps2RecompiledFunctionTable[408215] = InitGdSystem_0x28ea00; // 0x28ea64 - g_ps2RecompiledFunctionTable[408216] = InitGdSystem_0x28ea00; // 0x28ea68 - g_ps2RecompiledFunctionTable[408224] = InitGdSystem_0x28ea00; // 0x28ea88 - g_ps2RecompiledFunctionTable[408237] = InitGdSystem_0x28ea00; // 0x28eabc - g_ps2RecompiledFunctionTable[408244] = InitGdSystem_0x28ea00; // 0x28ead8 - g_ps2RecompiledFunctionTable[408247] = InitGdSystem_0x28ea00; // 0x28eae4 - g_ps2RecompiledFunctionTable[408251] = InitGdSystem_0x28ea00; // 0x28eaf4 - g_ps2RecompiledFunctionTable[408266] = InitGdSystemEx_0x28eb30; // 0x28eb30 - g_ps2RecompiledFunctionTable[408270] = ExitGdSystem_0x28eb40; // 0x28eb40 - g_ps2RecompiledFunctionTable[408275] = ExitGdSystem_0x28eb40; // 0x28eb54 - g_ps2RecompiledFunctionTable[408278] = ExitGdSystem_0x28eb40; // 0x28eb60 - g_ps2RecompiledFunctionTable[408280] = ExitGdSystem_0x28eb40; // 0x28eb68 - g_ps2RecompiledFunctionTable[408286] = GetFileSize_0x28eb80; // 0x28eb80 - g_ps2RecompiledFunctionTable[408290] = GetFileSize_0x28eb80; // 0x28eb90 - g_ps2RecompiledFunctionTable[408298] = ReadFileEx_0x28ebb0; // 0x28ebb0 - g_ps2RecompiledFunctionTable[408312] = ReadFileEx_0x28ebb0; // 0x28ebe8 - g_ps2RecompiledFunctionTable[408319] = ReadFileEx_0x28ebb0; // 0x28ec04 - g_ps2RecompiledFunctionTable[408325] = ReadFileEx_0x28ebb0; // 0x28ec1c - g_ps2RecompiledFunctionTable[408332] = ReadFileEx_0x28ebb0; // 0x28ec38 - g_ps2RecompiledFunctionTable[408338] = CheckOpenTray_0x28ec50; // 0x28ec50 - g_ps2RecompiledFunctionTable[408342] = CheckOpenTray_0x28ec50; // 0x28ec60 - g_ps2RecompiledFunctionTable[408364] = CheckOpenTray_0x28ec50; // 0x28ecb8 - g_ps2RecompiledFunctionTable[408370] = TransWaitCallBackFunction_0x28ecd0; // 0x28ecd0 - g_ps2RecompiledFunctionTable[408375] = TransWaitCallBackFunction_0x28ecd0; // 0x28ece4 - g_ps2RecompiledFunctionTable[408382] = CheckTransComplete_0x28ed00; // 0x28ed00 - g_ps2RecompiledFunctionTable[408386] = SetupSoundDriver_0x28ed10; // 0x28ed10 - g_ps2RecompiledFunctionTable[408396] = SetupSoundDriver_0x28ed10; // 0x28ed38 - g_ps2RecompiledFunctionTable[408399] = SetupSoundDriver_0x28ed10; // 0x28ed44 - g_ps2RecompiledFunctionTable[408410] = SetupSoundDriver_0x28ed10; // 0x28ed70 - g_ps2RecompiledFunctionTable[408413] = SetupSoundDriver_0x28ed10; // 0x28ed7c - g_ps2RecompiledFunctionTable[408416] = SetupSoundDriver_0x28ed10; // 0x28ed88 - g_ps2RecompiledFunctionTable[408418] = SetupSoundDriver_0x28ed10; // 0x28ed90 - g_ps2RecompiledFunctionTable[408426] = SetupSoundDriver_0x28ed10; // 0x28edb0 - g_ps2RecompiledFunctionTable[408434] = ExitSoundDriver_0x28edd0; // 0x28edd0 - g_ps2RecompiledFunctionTable[408438] = ExitSoundDriver_0x28edd0; // 0x28ede0 - g_ps2RecompiledFunctionTable[408440] = ExitSoundDriver_0x28edd0; // 0x28ede8 - g_ps2RecompiledFunctionTable[408442] = ExitSoundDriver_0x28edd0; // 0x28edf0 - g_ps2RecompiledFunctionTable[408446] = SetMultiUnit_0x28ee00; // 0x28ee00 - g_ps2RecompiledFunctionTable[408455] = SetMultiUnit_0x28ee00; // 0x28ee24 - g_ps2RecompiledFunctionTable[408465] = SetMultiUnit_0x28ee00; // 0x28ee4c - g_ps2RecompiledFunctionTable[408468] = SetMultiUnit_0x28ee00; // 0x28ee58 - g_ps2RecompiledFunctionTable[408471] = SetMultiUnit_0x28ee00; // 0x28ee64 - g_ps2RecompiledFunctionTable[408478] = SetSoundData_0x28ee80; // 0x28ee80 - g_ps2RecompiledFunctionTable[408491] = SetSoundData_0x28ee80; // 0x28eeb4 - g_ps2RecompiledFunctionTable[408502] = SetSoundData_0x28ee80; // 0x28eee0 - g_ps2RecompiledFunctionTable[408508] = SetSoundData_0x28ee80; // 0x28eef8 - g_ps2RecompiledFunctionTable[408518] = SetSoundModeEx_0x28ef20; // 0x28ef20 - g_ps2RecompiledFunctionTable[408527] = SetSoundModeEx_0x28ef20; // 0x28ef44 - g_ps2RecompiledFunctionTable[408530] = SetSoundModeEx_0x28ef20; // 0x28ef50 - g_ps2RecompiledFunctionTable[408534] = SetSoundModeEx_0x28ef20; // 0x28ef60 - g_ps2RecompiledFunctionTable[408537] = SetSoundModeEx_0x28ef20; // 0x28ef6c - g_ps2RecompiledFunctionTable[408542] = SetSoundModeEx_0x28ef20; // 0x28ef80 - g_ps2RecompiledFunctionTable[408550] = SetSoundMode_0x28efa0; // 0x28efa0 - g_ps2RecompiledFunctionTable[408554] = GetSoundMode_0x28efb0; // 0x28efb0 - g_ps2RecompiledFunctionTable[408563] = GetSoundMode_0x28efb0; // 0x28efd4 - g_ps2RecompiledFunctionTable[408574] = SetMasterVolume_0x28f000; // 0x28f000 - g_ps2RecompiledFunctionTable[408579] = SetMasterVolume_0x28f000; // 0x28f014 - g_ps2RecompiledFunctionTable[408586] = SetGdDaVolume_0x28f030; // 0x28f030 - g_ps2RecompiledFunctionTable[408590] = InitMidiInfo_0x28f040; // 0x28f040 - g_ps2RecompiledFunctionTable[408597] = InitMidiInfo_0x28f040; // 0x28f05c - g_ps2RecompiledFunctionTable[408606] = InitMidiInfo_0x28f040; // 0x28f080 - g_ps2RecompiledFunctionTable[408622] = RegistMidiSlot_0x28f0c0; // 0x28f0c0 - g_ps2RecompiledFunctionTable[408641] = RegistMidiSlot_0x28f0c0; // 0x28f10c - g_ps2RecompiledFunctionTable[408650] = FreeMidiSlot_0x28f130; // 0x28f130 - g_ps2RecompiledFunctionTable[408668] = FreeMidiSlot_0x28f130; // 0x28f178 - g_ps2RecompiledFunctionTable[408674] = CheckPlayMidi_0x28f190; // 0x28f190 - g_ps2RecompiledFunctionTable[408683] = CheckPlayMidi_0x28f190; // 0x28f1b4 - g_ps2RecompiledFunctionTable[408690] = PlayMidi_0x28f1d0; // 0x28f1d0 - g_ps2RecompiledFunctionTable[408712] = PlayMidi_0x28f1d0; // 0x28f228 - g_ps2RecompiledFunctionTable[408718] = ExPlayMidi_0x28f240; // 0x28f240 - g_ps2RecompiledFunctionTable[408744] = ExPlayMidi_0x28f240; // 0x28f2a8 - g_ps2RecompiledFunctionTable[408749] = ExPlayMidi_0x28f240; // 0x28f2bc - g_ps2RecompiledFunctionTable[408763] = ExPlayMidi_0x28f240; // 0x28f2f4 - g_ps2RecompiledFunctionTable[408768] = ExPlayMidi_0x28f240; // 0x28f308 - g_ps2RecompiledFunctionTable[408781] = ExPlayMidi_0x28f240; // 0x28f33c - g_ps2RecompiledFunctionTable[408786] = ExPlayMidi_0x28f240; // 0x28f350 - g_ps2RecompiledFunctionTable[408799] = ExPlayMidi_0x28f240; // 0x28f384 - g_ps2RecompiledFunctionTable[408804] = ExPlayMidi_0x28f240; // 0x28f398 - g_ps2RecompiledFunctionTable[408816] = ExPlayMidi_0x28f240; // 0x28f3c8 - g_ps2RecompiledFunctionTable[408821] = ExPlayMidi_0x28f240; // 0x28f3dc - g_ps2RecompiledFunctionTable[408826] = StopMidi_0x28f3f0; // 0x28f3f0 - g_ps2RecompiledFunctionTable[408843] = StopMidi_0x28f3f0; // 0x28f434 - g_ps2RecompiledFunctionTable[408846] = SetPanMidi2_0x28f440; // 0x28f440 - g_ps2RecompiledFunctionTable[408879] = SetPanMidi2_0x28f440; // 0x28f4c4 - g_ps2RecompiledFunctionTable[408888] = SetPanMidi2_0x28f440; // 0x28f4e8 - g_ps2RecompiledFunctionTable[408902] = SetPanMidi_0x28f520; // 0x28f520 - g_ps2RecompiledFunctionTable[408910] = SetVolumeMidiEx_0x28f540; // 0x28f540 - g_ps2RecompiledFunctionTable[408943] = SetVolumeMidiEx_0x28f540; // 0x28f5c4 - g_ps2RecompiledFunctionTable[408952] = SetVolumeMidiEx_0x28f540; // 0x28f5e8 - g_ps2RecompiledFunctionTable[408969] = SetVolumeMidiEx_0x28f540; // 0x28f62c - g_ps2RecompiledFunctionTable[408977] = SetVolumeMidiEx_0x28f540; // 0x28f64c - g_ps2RecompiledFunctionTable[408986] = SetVolumeMidiEx_0x28f540; // 0x28f670 - g_ps2RecompiledFunctionTable[408994] = SetVolumeMidiEx_0x28f540; // 0x28f690 - g_ps2RecompiledFunctionTable[409002] = SetVolumeMidi_0x28f6b0; // 0x28f6b0 - g_ps2RecompiledFunctionTable[409010] = SetVolumeMidi2_0x28f6d0; // 0x28f6d0 - g_ps2RecompiledFunctionTable[409014] = SetPitchMidi_0x28f6e0; // 0x28f6e0 - g_ps2RecompiledFunctionTable[409033] = SetPitchMidi_0x28f6e0; // 0x28f72c - g_ps2RecompiledFunctionTable[409038] = SetSpeedMidi_0x28f740; // 0x28f740 - g_ps2RecompiledFunctionTable[409057] = SetSpeedMidi_0x28f740; // 0x28f78c - g_ps2RecompiledFunctionTable[409062] = SetFxLevelMidi_0x28f7a0; // 0x28f7a0 - g_ps2RecompiledFunctionTable[409079] = SetFxLevelMidi_0x28f7a0; // 0x28f7e4 - g_ps2RecompiledFunctionTable[409082] = SetMidiDefaultVolume_0x28f7f0; // 0x28f7f0 - g_ps2RecompiledFunctionTable[409086] = InitSeInfo_0x28f800; // 0x28f800 - g_ps2RecompiledFunctionTable[409093] = InitSeInfo_0x28f800; // 0x28f81c - g_ps2RecompiledFunctionTable[409102] = InitSeInfo_0x28f800; // 0x28f840 - g_ps2RecompiledFunctionTable[409118] = RegistSeSlot_0x28f880; // 0x28f880 - g_ps2RecompiledFunctionTable[409137] = RegistSeSlot_0x28f880; // 0x28f8cc - g_ps2RecompiledFunctionTable[409146] = FreeSeSlot_0x28f8f0; // 0x28f8f0 - g_ps2RecompiledFunctionTable[409164] = FreeSeSlot_0x28f8f0; // 0x28f938 - g_ps2RecompiledFunctionTable[409170] = CheckPlaySe_0x28f950; // 0x28f950 - g_ps2RecompiledFunctionTable[409179] = CheckPlaySe_0x28f950; // 0x28f974 - g_ps2RecompiledFunctionTable[409186] = PlaySe_0x28f990; // 0x28f990 - g_ps2RecompiledFunctionTable[409208] = PlaySe_0x28f990; // 0x28f9e8 - g_ps2RecompiledFunctionTable[409214] = ExPlaySe_0x28fa00; // 0x28fa00 - g_ps2RecompiledFunctionTable[409240] = ExPlaySe_0x28fa00; // 0x28fa68 - g_ps2RecompiledFunctionTable[409245] = ExPlaySe_0x28fa00; // 0x28fa7c - g_ps2RecompiledFunctionTable[409259] = ExPlaySe_0x28fa00; // 0x28fab4 - g_ps2RecompiledFunctionTable[409264] = ExPlaySe_0x28fa00; // 0x28fac8 - g_ps2RecompiledFunctionTable[409277] = ExPlaySe_0x28fa00; // 0x28fafc - g_ps2RecompiledFunctionTable[409282] = ExPlaySe_0x28fa00; // 0x28fb10 - g_ps2RecompiledFunctionTable[409299] = ExPlaySe_0x28fa00; // 0x28fb54 - g_ps2RecompiledFunctionTable[409309] = ExPlaySe_0x28fa00; // 0x28fb7c - g_ps2RecompiledFunctionTable[409314] = ExPlaySe_0x28fa00; // 0x28fb90 - g_ps2RecompiledFunctionTable[409318] = StopSe_0x28fba0; // 0x28fba0 - g_ps2RecompiledFunctionTable[409335] = StopSe_0x28fba0; // 0x28fbe4 - g_ps2RecompiledFunctionTable[409338] = SetPanSe2_0x28fbf0; // 0x28fbf0 - g_ps2RecompiledFunctionTable[409357] = SetPanSe2_0x28fbf0; // 0x28fc3c - g_ps2RecompiledFunctionTable[409366] = SetPanSe2_0x28fbf0; // 0x28fc60 - g_ps2RecompiledFunctionTable[409378] = SetPanSe_0x28fc90; // 0x28fc90 - g_ps2RecompiledFunctionTable[409386] = SetVolumeSeEx_0x28fcb0; // 0x28fcb0 - g_ps2RecompiledFunctionTable[409419] = SetVolumeSeEx_0x28fcb0; // 0x28fd34 - g_ps2RecompiledFunctionTable[409428] = SetVolumeSeEx_0x28fcb0; // 0x28fd58 - g_ps2RecompiledFunctionTable[409445] = SetVolumeSeEx_0x28fcb0; // 0x28fd9c - g_ps2RecompiledFunctionTable[409453] = SetVolumeSeEx_0x28fcb0; // 0x28fdbc - g_ps2RecompiledFunctionTable[409462] = SetVolumeSeEx_0x28fcb0; // 0x28fde0 - g_ps2RecompiledFunctionTable[409470] = SetVolumeSeEx_0x28fcb0; // 0x28fe00 - g_ps2RecompiledFunctionTable[409478] = SetVolumeSe_0x28fe20; // 0x28fe20 - g_ps2RecompiledFunctionTable[409486] = SetVolumeSe2_0x28fe40; // 0x28fe40 - g_ps2RecompiledFunctionTable[409490] = SetPitchSe_0x28fe50; // 0x28fe50 - g_ps2RecompiledFunctionTable[409509] = SetPitchSe_0x28fe50; // 0x28fe9c - g_ps2RecompiledFunctionTable[409514] = SetFxLevelSe_0x28feb0; // 0x28feb0 - g_ps2RecompiledFunctionTable[409531] = SetFxLevelSe_0x28feb0; // 0x28fef4 - g_ps2RecompiledFunctionTable[409534] = SetSeDefaultVolume_0x28ff00; // 0x28ff00 - g_ps2RecompiledFunctionTable[409538] = SetFxProgram_0x28ff10; // 0x28ff10 - g_ps2RecompiledFunctionTable[409542] = SetFxProgram_0x28ff10; // 0x28ff20 - g_ps2RecompiledFunctionTable[409550] = StopFxProgram_0x28ff40; // 0x28ff40 - g_ps2RecompiledFunctionTable[409558] = StopFxProgram_0x28ff40; // 0x28ff60 - g_ps2RecompiledFunctionTable[409566] = RequestMidiFadeFunction_0x28ff80; // 0x28ff80 - g_ps2RecompiledFunctionTable[409634] = RequestMidiFadeFunctionEx_0x290090; // 0x290090 - g_ps2RecompiledFunctionTable[409651] = RequestMidiFadeFunctionEx_0x290090; // 0x2900d4 - g_ps2RecompiledFunctionTable[409686] = StopFadeMidi_0x290160; // 0x290160 - g_ps2RecompiledFunctionTable[409694] = RequestSeFadeFunction_0x290180; // 0x290180 - g_ps2RecompiledFunctionTable[409762] = RequestSeFadeFunctionEx_0x290290; // 0x290290 - g_ps2RecompiledFunctionTable[409779] = RequestSeFadeFunctionEx_0x290290; // 0x2902d4 - g_ps2RecompiledFunctionTable[409814] = StopFadeSe_0x290360; // 0x290360 - g_ps2RecompiledFunctionTable[409822] = CheckFadeEndSe_0x290380; // 0x290380 - g_ps2RecompiledFunctionTable[409834] = ExecSoundFadeManager_0x2903b0; // 0x2903b0 - g_ps2RecompiledFunctionTable[409843] = ExecSoundFadeManager_0x2903b0; // 0x2903d4 - g_ps2RecompiledFunctionTable[409867] = ExecSoundFadeManager_0x2903b0; // 0x290434 - g_ps2RecompiledFunctionTable[409872] = ExecSoundFadeManager_0x2903b0; // 0x290448 - g_ps2RecompiledFunctionTable[409881] = ExecSoundFadeManager_0x2903b0; // 0x29046c - g_ps2RecompiledFunctionTable[409889] = ExecSoundFadeManager_0x2903b0; // 0x29048c - g_ps2RecompiledFunctionTable[409913] = ExecSoundFadeManager_0x2903b0; // 0x2904ec - g_ps2RecompiledFunctionTable[409918] = ExecSoundFadeManager_0x2903b0; // 0x290500 - g_ps2RecompiledFunctionTable[409927] = ExecSoundFadeManager_0x2903b0; // 0x290524 - g_ps2RecompiledFunctionTable[409942] = RequestMidiPanFunctionEx_0x290560; // 0x290560 - g_ps2RecompiledFunctionTable[409959] = RequestMidiPanFunctionEx_0x290560; // 0x2905a4 - g_ps2RecompiledFunctionTable[409990] = RequestSePanFunctionEx_0x290620; // 0x290620 - g_ps2RecompiledFunctionTable[410007] = RequestSePanFunctionEx_0x290620; // 0x290664 - g_ps2RecompiledFunctionTable[410038] = ExecSoundPanManager_0x2906e0; // 0x2906e0 - g_ps2RecompiledFunctionTable[410047] = ExecSoundPanManager_0x2906e0; // 0x290704 - g_ps2RecompiledFunctionTable[410070] = ExecSoundPanManager_0x2906e0; // 0x290760 - g_ps2RecompiledFunctionTable[410077] = ExecSoundPanManager_0x2906e0; // 0x29077c - g_ps2RecompiledFunctionTable[410100] = ExecSoundPanManager_0x2906e0; // 0x2907d8 - g_ps2RecompiledFunctionTable[410114] = InitSdcParameter_0x290810; // 0x290810 - g_ps2RecompiledFunctionTable[410118] = InitSdcParameter_0x290810; // 0x290820 - g_ps2RecompiledFunctionTable[410120] = InitSdcParameter_0x290810; // 0x290828 - g_ps2RecompiledFunctionTable[410122] = InitSdcParameter_0x290810; // 0x290830 - g_ps2RecompiledFunctionTable[410124] = InitSdcParameter_0x290810; // 0x290838 - g_ps2RecompiledFunctionTable[410126] = InitSdcParameter_0x290810; // 0x290840 - g_ps2RecompiledFunctionTable[410128] = InitSdcParameter_0x290810; // 0x290848 - g_ps2RecompiledFunctionTable[410130] = InitSdcParameter_0x290810; // 0x290850 - g_ps2RecompiledFunctionTable[410132] = InitSdcParameter_0x290810; // 0x290858 - g_ps2RecompiledFunctionTable[410138] = InitSoundDriver_0x290870; // 0x290870 - g_ps2RecompiledFunctionTable[410147] = InitSoundDriver_0x290870; // 0x290894 - g_ps2RecompiledFunctionTable[410150] = InitSoundDriver_0x290870; // 0x2908a0 - g_ps2RecompiledFunctionTable[410152] = InitSoundDriver_0x290870; // 0x2908a8 - g_ps2RecompiledFunctionTable[410155] = InitSoundDriver_0x290870; // 0x2908b4 - g_ps2RecompiledFunctionTable[410159] = InitSoundDriver_0x290870; // 0x2908c4 - g_ps2RecompiledFunctionTable[410162] = InitSoundDriver_0x290870; // 0x2908d0 - g_ps2RecompiledFunctionTable[410164] = InitSoundDriver_0x290870; // 0x2908d8 - g_ps2RecompiledFunctionTable[410168] = InitSoundDriver_0x290870; // 0x2908e8 - g_ps2RecompiledFunctionTable[410171] = InitSoundDriver_0x290870; // 0x2908f4 - g_ps2RecompiledFunctionTable[410173] = InitSoundDriver_0x290870; // 0x2908fc - g_ps2RecompiledFunctionTable[410176] = InitSoundDriver_0x290870; // 0x290908 - g_ps2RecompiledFunctionTable[410180] = InitSoundDriver_0x290870; // 0x290918 - g_ps2RecompiledFunctionTable[410183] = InitSoundDriver_0x290870; // 0x290924 - g_ps2RecompiledFunctionTable[410185] = InitSoundDriver_0x290870; // 0x29092c - g_ps2RecompiledFunctionTable[410187] = InitSoundDriver_0x290870; // 0x290934 - g_ps2RecompiledFunctionTable[410198] = InitMwSystem_0x290960; // 0x290960 - g_ps2RecompiledFunctionTable[410212] = InitMwSystem_0x290960; // 0x290998 - g_ps2RecompiledFunctionTable[410217] = InitMwSystem_0x290960; // 0x2909ac - g_ps2RecompiledFunctionTable[410226] = ReinitMwSystem_0x2909d0; // 0x2909d0 - g_ps2RecompiledFunctionTable[410243] = ReinitMwSystem_0x2909d0; // 0x290a14 - g_ps2RecompiledFunctionTable[410246] = ExitMwSystem_0x290a20; // 0x290a20 - g_ps2RecompiledFunctionTable[410259] = ExitMwSystem_0x290a20; // 0x290a54 - g_ps2RecompiledFunctionTable[410263] = ExitMwSystem_0x290a20; // 0x290a64 - g_ps2RecompiledFunctionTable[410270] = SetMwSoundMode_0x290a80; // 0x290a80 - g_ps2RecompiledFunctionTable[410274] = GetMwPlayTime_0x290a90; // 0x290a90 - g_ps2RecompiledFunctionTable[410275] = GetMwPlayTime_0x290a90; // 0x290a94 - g_ps2RecompiledFunctionTable[410276] = GetMwPlayTime_0x290a90; // 0x290a98 - g_ps2RecompiledFunctionTable[410277] = GetMwPlayTime_0x290a90; // 0x290a9c - g_ps2RecompiledFunctionTable[410278] = GetMwPlayTime_0x290a90; // 0x290aa0 - g_ps2RecompiledFunctionTable[410279] = GetMwPlayTime_0x290a90; // 0x290aa4 - g_ps2RecompiledFunctionTable[410280] = GetMwPlayTime_0x290a90; // 0x290aa8 - g_ps2RecompiledFunctionTable[410281] = GetMwPlayTime_0x290a90; // 0x290aac - g_ps2RecompiledFunctionTable[410282] = GetMwPlayTimeEx_0x290ab0; // 0x290ab0 - g_ps2RecompiledFunctionTable[410288] = GetMwPlayTimeEx_0x290ab0; // 0x290ac8 - g_ps2RecompiledFunctionTable[410290] = GetMwPlayTimeEx_0x290ab0; // 0x290ad0 - g_ps2RecompiledFunctionTable[410293] = GetMwPlayTimeEx_0x290ab0; // 0x290adc - g_ps2RecompiledFunctionTable[410296] = GetMwPlayTimeEx_0x290ab0; // 0x290ae8 - g_ps2RecompiledFunctionTable[410300] = GetMwPlayTimeEx_0x290ab0; // 0x290af8 - g_ps2RecompiledFunctionTable[410302] = GetMwPlayTimeEx_0x290ab0; // 0x290b00 - g_ps2RecompiledFunctionTable[410306] = CreateSfdHandle_0x290b10; // 0x290b10 - g_ps2RecompiledFunctionTable[410319] = CreateSfdHandle_0x290b10; // 0x290b44 - g_ps2RecompiledFunctionTable[410350] = CreateSfdHandle_0x290b10; // 0x290bc0 - g_ps2RecompiledFunctionTable[410379] = CreateSfdHandle_0x290b10; // 0x290c34 - g_ps2RecompiledFunctionTable[410391] = CreateSfdHandle_0x290b10; // 0x290c64 - g_ps2RecompiledFunctionTable[410397] = CreateSfdHandle_0x290b10; // 0x290c7c - g_ps2RecompiledFunctionTable[410406] = CreateWaveHandle_0x290ca0; // 0x290ca0 - g_ps2RecompiledFunctionTable[410410] = CreateTmHandle_0x290cb0; // 0x290cb0 - g_ps2RecompiledFunctionTable[410414] = PlayMwOpenMain_0x290cc0; // 0x290cc0 - g_ps2RecompiledFunctionTable[410415] = PlayMwOpenMain_0x290cc0; // 0x290cc4 - g_ps2RecompiledFunctionTable[410416] = PlayMwOpenMain_0x290cc0; // 0x290cc8 - g_ps2RecompiledFunctionTable[410417] = PlayMwOpenMain_0x290cc0; // 0x290ccc - g_ps2RecompiledFunctionTable[410418] = PlayMwOpenMain_0x290cc0; // 0x290cd0 - g_ps2RecompiledFunctionTable[410419] = PlayMwOpenMain_0x290cc0; // 0x290cd4 - g_ps2RecompiledFunctionTable[410420] = PlayMwOpenMain_0x290cc0; // 0x290cd8 - g_ps2RecompiledFunctionTable[410421] = PlayMwOpenMain_0x290cc0; // 0x290cdc - g_ps2RecompiledFunctionTable[410422] = PlayMwOpenMain_0x290cc0; // 0x290ce0 - g_ps2RecompiledFunctionTable[410423] = PlayMwOpenMain_0x290cc0; // 0x290ce4 - g_ps2RecompiledFunctionTable[410424] = PlayMwOpenMain_0x290cc0; // 0x290ce8 - g_ps2RecompiledFunctionTable[410425] = PlayMwOpenMain_0x290cc0; // 0x290cec - g_ps2RecompiledFunctionTable[410426] = PlayMwOpenMain_0x290cc0; // 0x290cf0 - g_ps2RecompiledFunctionTable[410427] = PlayMwOpenMain_0x290cc0; // 0x290cf4 - g_ps2RecompiledFunctionTable[410428] = PlayMwOpenMain_0x290cc0; // 0x290cf8 - g_ps2RecompiledFunctionTable[410429] = PlayMwOpenMain_0x290cc0; // 0x290cfc - g_ps2RecompiledFunctionTable[410430] = PlayMwOpenMain_0x290cc0; // 0x290d00 - g_ps2RecompiledFunctionTable[410431] = PlayMwOpenMain_0x290cc0; // 0x290d04 - g_ps2RecompiledFunctionTable[410432] = PlayMwOpenMain_0x290cc0; // 0x290d08 - g_ps2RecompiledFunctionTable[410433] = PlayMwOpenMain_0x290cc0; // 0x290d0c - g_ps2RecompiledFunctionTable[410434] = PlayMwOpenMain_0x290cc0; // 0x290d10 - g_ps2RecompiledFunctionTable[410435] = PlayMwOpenMain_0x290cc0; // 0x290d14 - g_ps2RecompiledFunctionTable[410436] = PlayMwOpenMain_0x290cc0; // 0x290d18 - g_ps2RecompiledFunctionTable[410437] = PlayMwOpenMain_0x290cc0; // 0x290d1c - g_ps2RecompiledFunctionTable[410438] = PlayMwOpenMain_0x290cc0; // 0x290d20 - g_ps2RecompiledFunctionTable[410439] = PlayMwOpenMain_0x290cc0; // 0x290d24 - g_ps2RecompiledFunctionTable[410440] = PlayMwOpenMain_0x290cc0; // 0x290d28 - g_ps2RecompiledFunctionTable[410441] = PlayMwOpenMain_0x290cc0; // 0x290d2c - g_ps2RecompiledFunctionTable[410442] = PlayMwOpenMain_0x290cc0; // 0x290d30 - g_ps2RecompiledFunctionTable[410443] = PlayMwOpenMain_0x290cc0; // 0x290d34 - g_ps2RecompiledFunctionTable[410444] = PlayMwOpenMain_0x290cc0; // 0x290d38 - g_ps2RecompiledFunctionTable[410445] = PlayMwOpenMain_0x290cc0; // 0x290d3c - g_ps2RecompiledFunctionTable[410446] = PlayMwOpenMain_0x290cc0; // 0x290d40 - g_ps2RecompiledFunctionTable[410447] = PlayMwOpenMain_0x290cc0; // 0x290d44 - g_ps2RecompiledFunctionTable[410448] = PlayMwOpenMain_0x290cc0; // 0x290d48 - g_ps2RecompiledFunctionTable[410449] = PlayMwOpenMain_0x290cc0; // 0x290d4c - g_ps2RecompiledFunctionTable[410450] = PlayMwOpenMain_0x290cc0; // 0x290d50 - g_ps2RecompiledFunctionTable[410451] = PlayMwOpenMain_0x290cc0; // 0x290d54 - g_ps2RecompiledFunctionTable[410452] = PlayMwOpenMain_0x290cc0; // 0x290d58 - g_ps2RecompiledFunctionTable[410453] = PlayMwOpenMain_0x290cc0; // 0x290d5c - g_ps2RecompiledFunctionTable[410454] = PlayMwOpenMain_0x290cc0; // 0x290d60 - g_ps2RecompiledFunctionTable[410455] = PlayMwOpenMain_0x290cc0; // 0x290d64 - g_ps2RecompiledFunctionTable[410456] = PlayMwOpenMain_0x290cc0; // 0x290d68 - g_ps2RecompiledFunctionTable[410457] = PlayMwOpenMain_0x290cc0; // 0x290d6c - g_ps2RecompiledFunctionTable[410458] = PlayMwOpenMain_0x290cc0; // 0x290d70 - g_ps2RecompiledFunctionTable[410459] = PlayMwOpenMain_0x290cc0; // 0x290d74 - g_ps2RecompiledFunctionTable[410460] = PlayMwOpenMain_0x290cc0; // 0x290d78 - g_ps2RecompiledFunctionTable[410461] = PlayMwOpenMain_0x290cc0; // 0x290d7c - g_ps2RecompiledFunctionTable[410462] = PlayMwOpenMain_0x290cc0; // 0x290d80 - g_ps2RecompiledFunctionTable[410463] = PlayMwOpenMain_0x290cc0; // 0x290d84 - g_ps2RecompiledFunctionTable[410464] = PlayMwOpenMain_0x290cc0; // 0x290d88 - g_ps2RecompiledFunctionTable[410465] = PlayMwOpenMain_0x290cc0; // 0x290d8c - g_ps2RecompiledFunctionTable[410466] = PlayMwOpenMain_0x290cc0; // 0x290d90 - g_ps2RecompiledFunctionTable[410467] = PlayMwOpenMain_0x290cc0; // 0x290d94 - g_ps2RecompiledFunctionTable[410468] = PlayMwOpenMain_0x290cc0; // 0x290d98 - g_ps2RecompiledFunctionTable[410469] = PlayMwOpenMain_0x290cc0; // 0x290d9c - g_ps2RecompiledFunctionTable[410470] = PlayMwOpenMain_0x290cc0; // 0x290da0 - g_ps2RecompiledFunctionTable[410471] = PlayMwOpenMain_0x290cc0; // 0x290da4 - g_ps2RecompiledFunctionTable[410472] = PlayMwOpenMain_0x290cc0; // 0x290da8 - g_ps2RecompiledFunctionTable[410473] = PlayMwOpenMain_0x290cc0; // 0x290dac - g_ps2RecompiledFunctionTable[410474] = PlayMwOpenMain_0x290cc0; // 0x290db0 - g_ps2RecompiledFunctionTable[410475] = PlayMwOpenMain_0x290cc0; // 0x290db4 - g_ps2RecompiledFunctionTable[410476] = PlayMwOpenMain_0x290cc0; // 0x290db8 - g_ps2RecompiledFunctionTable[410477] = PlayMwOpenMain_0x290cc0; // 0x290dbc - g_ps2RecompiledFunctionTable[410478] = PlayMwOpenMain_0x290cc0; // 0x290dc0 - g_ps2RecompiledFunctionTable[410479] = PlayMwOpenMain_0x290cc0; // 0x290dc4 - g_ps2RecompiledFunctionTable[410480] = PlayMwOpenMain_0x290cc0; // 0x290dc8 - g_ps2RecompiledFunctionTable[410481] = PlayMwOpenMain_0x290cc0; // 0x290dcc - g_ps2RecompiledFunctionTable[410482] = PlayMwOpenMain_0x290cc0; // 0x290dd0 - g_ps2RecompiledFunctionTable[410483] = PlayMwOpenMain_0x290cc0; // 0x290dd4 - g_ps2RecompiledFunctionTable[410484] = PlayMwOpenMain_0x290cc0; // 0x290dd8 - g_ps2RecompiledFunctionTable[410485] = PlayMwOpenMain_0x290cc0; // 0x290ddc - g_ps2RecompiledFunctionTable[410486] = PlayMwOpenMain_0x290cc0; // 0x290de0 - g_ps2RecompiledFunctionTable[410487] = PlayMwOpenMain_0x290cc0; // 0x290de4 - g_ps2RecompiledFunctionTable[410488] = PlayMwOpenMain_0x290cc0; // 0x290de8 - g_ps2RecompiledFunctionTable[410489] = PlayMwOpenMain_0x290cc0; // 0x290dec - g_ps2RecompiledFunctionTable[410490] = PlayMwOpenMain_0x290cc0; // 0x290df0 - g_ps2RecompiledFunctionTable[410491] = PlayMwOpenMain_0x290cc0; // 0x290df4 - g_ps2RecompiledFunctionTable[410492] = PlayMwOpenMain_0x290cc0; // 0x290df8 - g_ps2RecompiledFunctionTable[410493] = PlayMwOpenMain_0x290cc0; // 0x290dfc - g_ps2RecompiledFunctionTable[410494] = PlayMwOpenMain_0x290cc0; // 0x290e00 - g_ps2RecompiledFunctionTable[410495] = PlayMwOpenMain_0x290cc0; // 0x290e04 - g_ps2RecompiledFunctionTable[410496] = PlayMwOpenMain_0x290cc0; // 0x290e08 - g_ps2RecompiledFunctionTable[410497] = PlayMwOpenMain_0x290cc0; // 0x290e0c - g_ps2RecompiledFunctionTable[410498] = PlayMwOpenMain_0x290cc0; // 0x290e10 - g_ps2RecompiledFunctionTable[410499] = PlayMwOpenMain_0x290cc0; // 0x290e14 - g_ps2RecompiledFunctionTable[410500] = PlayMwOpenMain_0x290cc0; // 0x290e18 - g_ps2RecompiledFunctionTable[410502] = PlayMw2_0x290e20; // 0x290e20 - g_ps2RecompiledFunctionTable[410506] = StopMw_0x290e30; // 0x290e30 - g_ps2RecompiledFunctionTable[410507] = StopMw_0x290e30; // 0x290e34 - g_ps2RecompiledFunctionTable[410508] = StopMw_0x290e30; // 0x290e38 - g_ps2RecompiledFunctionTable[410509] = StopMw_0x290e30; // 0x290e3c - g_ps2RecompiledFunctionTable[410510] = StopMw_0x290e30; // 0x290e40 - g_ps2RecompiledFunctionTable[410511] = StopMw_0x290e30; // 0x290e44 - g_ps2RecompiledFunctionTable[410512] = StopMw_0x290e30; // 0x290e48 - g_ps2RecompiledFunctionTable[410513] = StopMw_0x290e30; // 0x290e4c - g_ps2RecompiledFunctionTable[410514] = StopMw_0x290e30; // 0x290e50 - g_ps2RecompiledFunctionTable[410515] = StopMw_0x290e30; // 0x290e54 - g_ps2RecompiledFunctionTable[410516] = StopMw_0x290e30; // 0x290e58 - g_ps2RecompiledFunctionTable[410517] = StopMw_0x290e30; // 0x290e5c - g_ps2RecompiledFunctionTable[410518] = StopMw_0x290e30; // 0x290e60 - g_ps2RecompiledFunctionTable[410519] = StopMw_0x290e30; // 0x290e64 - g_ps2RecompiledFunctionTable[410520] = StopMw_0x290e30; // 0x290e68 - g_ps2RecompiledFunctionTable[410521] = StopMw_0x290e30; // 0x290e6c - g_ps2RecompiledFunctionTable[410522] = StopMw_0x290e30; // 0x290e70 - g_ps2RecompiledFunctionTable[410523] = StopMw_0x290e30; // 0x290e74 - g_ps2RecompiledFunctionTable[410524] = StopMw_0x290e30; // 0x290e78 - g_ps2RecompiledFunctionTable[410525] = StopMw_0x290e30; // 0x290e7c - g_ps2RecompiledFunctionTable[410526] = StopMw_0x290e30; // 0x290e80 - g_ps2RecompiledFunctionTable[410527] = StopMw_0x290e30; // 0x290e84 - g_ps2RecompiledFunctionTable[410528] = StopMw_0x290e30; // 0x290e88 - g_ps2RecompiledFunctionTable[410529] = StopMw_0x290e30; // 0x290e8c - g_ps2RecompiledFunctionTable[410530] = StopMw_0x290e30; // 0x290e90 - g_ps2RecompiledFunctionTable[410531] = StopMw_0x290e30; // 0x290e94 - g_ps2RecompiledFunctionTable[410532] = StopMw_0x290e30; // 0x290e98 - g_ps2RecompiledFunctionTable[410533] = StopMw_0x290e30; // 0x290e9c - g_ps2RecompiledFunctionTable[410534] = StopMw_0x290e30; // 0x290ea0 - g_ps2RecompiledFunctionTable[410535] = StopMw_0x290e30; // 0x290ea4 - g_ps2RecompiledFunctionTable[410536] = StopMw_0x290e30; // 0x290ea8 - g_ps2RecompiledFunctionTable[410537] = StopMw_0x290e30; // 0x290eac - g_ps2RecompiledFunctionTable[410538] = StopMw_0x290e30; // 0x290eb0 - g_ps2RecompiledFunctionTable[410539] = StopMw_0x290e30; // 0x290eb4 - g_ps2RecompiledFunctionTable[410540] = StopMw_0x290e30; // 0x290eb8 - g_ps2RecompiledFunctionTable[410541] = StopMw_0x290e30; // 0x290ebc - g_ps2RecompiledFunctionTable[410542] = GetMwStatus_0x290ec0; // 0x290ec0 - g_ps2RecompiledFunctionTable[410543] = GetMwStatus_0x290ec0; // 0x290ec4 - g_ps2RecompiledFunctionTable[410544] = GetMwStatus_0x290ec0; // 0x290ec8 - g_ps2RecompiledFunctionTable[410545] = GetMwStatus_0x290ec0; // 0x290ecc - g_ps2RecompiledFunctionTable[410546] = GetMwStatus_0x290ec0; // 0x290ed0 - g_ps2RecompiledFunctionTable[410547] = GetMwStatus_0x290ec0; // 0x290ed4 - g_ps2RecompiledFunctionTable[410550] = PlayMwMain2_0x290ee0; // 0x290ee0 - g_ps2RecompiledFunctionTable[410551] = PlayMwMain2_0x290ee0; // 0x290ee4 - g_ps2RecompiledFunctionTable[410552] = PlayMwMain2_0x290ee0; // 0x290ee8 - g_ps2RecompiledFunctionTable[410553] = PlayMwMain2_0x290ee0; // 0x290eec - g_ps2RecompiledFunctionTable[410554] = PlayMwMain2_0x290ee0; // 0x290ef0 - g_ps2RecompiledFunctionTable[410555] = PlayMwMain2_0x290ee0; // 0x290ef4 - g_ps2RecompiledFunctionTable[410556] = PlayMwMain2_0x290ee0; // 0x290ef8 - g_ps2RecompiledFunctionTable[410557] = PlayMwMain2_0x290ee0; // 0x290efc - g_ps2RecompiledFunctionTable[410558] = PlayMwMain2_0x290ee0; // 0x290f00 - g_ps2RecompiledFunctionTable[410559] = PlayMwMain2_0x290ee0; // 0x290f04 - g_ps2RecompiledFunctionTable[410560] = PlayMwMain2_0x290ee0; // 0x290f08 - g_ps2RecompiledFunctionTable[410561] = PlayMwMain2_0x290ee0; // 0x290f0c - g_ps2RecompiledFunctionTable[410562] = PlayMwMain2_0x290ee0; // 0x290f10 - g_ps2RecompiledFunctionTable[410563] = PlayMwMain2_0x290ee0; // 0x290f14 - g_ps2RecompiledFunctionTable[410564] = PlayMwMain2_0x290ee0; // 0x290f18 - g_ps2RecompiledFunctionTable[410565] = PlayMwMain2_0x290ee0; // 0x290f1c - g_ps2RecompiledFunctionTable[410566] = PlayMwMain2_0x290ee0; // 0x290f20 - g_ps2RecompiledFunctionTable[410567] = PlayMwMain2_0x290ee0; // 0x290f24 - g_ps2RecompiledFunctionTable[410568] = PlayMwMain2_0x290ee0; // 0x290f28 - g_ps2RecompiledFunctionTable[410569] = PlayMwMain2_0x290ee0; // 0x290f2c - g_ps2RecompiledFunctionTable[410570] = PlayMwMain2_0x290ee0; // 0x290f30 - g_ps2RecompiledFunctionTable[410571] = PlayMwMain2_0x290ee0; // 0x290f34 - g_ps2RecompiledFunctionTable[410572] = PlayMwMain2_0x290ee0; // 0x290f38 - g_ps2RecompiledFunctionTable[410573] = PlayMwMain2_0x290ee0; // 0x290f3c - g_ps2RecompiledFunctionTable[410574] = PlayMwMain2_0x290ee0; // 0x290f40 - g_ps2RecompiledFunctionTable[410575] = PlayMwMain2_0x290ee0; // 0x290f44 - g_ps2RecompiledFunctionTable[410576] = PlayMwMain2_0x290ee0; // 0x290f48 - g_ps2RecompiledFunctionTable[410578] = PlayMwMain_0x290f50; // 0x290f50 - g_ps2RecompiledFunctionTable[410582] = PauseMw_0x290f60; // 0x290f60 - g_ps2RecompiledFunctionTable[410583] = PauseMw_0x290f60; // 0x290f64 - g_ps2RecompiledFunctionTable[410584] = PauseMw_0x290f60; // 0x290f68 - g_ps2RecompiledFunctionTable[410585] = PauseMw_0x290f60; // 0x290f6c - g_ps2RecompiledFunctionTable[410586] = PauseMw_0x290f60; // 0x290f70 - g_ps2RecompiledFunctionTable[410587] = PauseMw_0x290f60; // 0x290f74 - g_ps2RecompiledFunctionTable[410588] = PauseMw_0x290f60; // 0x290f78 - g_ps2RecompiledFunctionTable[410590] = RestartMw_0x290f80; // 0x290f80 - g_ps2RecompiledFunctionTable[410591] = RestartMw_0x290f80; // 0x290f84 - g_ps2RecompiledFunctionTable[410592] = RestartMw_0x290f80; // 0x290f88 - g_ps2RecompiledFunctionTable[410593] = RestartMw_0x290f80; // 0x290f8c - g_ps2RecompiledFunctionTable[410594] = RestartMw_0x290f80; // 0x290f90 - g_ps2RecompiledFunctionTable[410595] = RestartMw_0x290f80; // 0x290f94 - g_ps2RecompiledFunctionTable[410596] = RestartMw_0x290f80; // 0x290f98 - g_ps2RecompiledFunctionTable[410598] = SetMwVolume_0x290fa0; // 0x290fa0 - g_ps2RecompiledFunctionTable[410599] = SetMwVolume_0x290fa0; // 0x290fa4 - g_ps2RecompiledFunctionTable[410600] = SetMwVolume_0x290fa0; // 0x290fa8 - g_ps2RecompiledFunctionTable[410601] = SetMwVolume_0x290fa0; // 0x290fac - g_ps2RecompiledFunctionTable[410602] = SetMwVolume_0x290fa0; // 0x290fb0 - g_ps2RecompiledFunctionTable[410603] = SetMwVolume_0x290fa0; // 0x290fb4 - g_ps2RecompiledFunctionTable[410604] = SetMwVolume_0x290fa0; // 0x290fb8 - g_ps2RecompiledFunctionTable[410606] = GetSfdFadeRate_0x290fc0; // 0x290fc0 - g_ps2RecompiledFunctionTable[410610] = SetSfdDislpaySize_0x290fd0; // 0x290fd0 - g_ps2RecompiledFunctionTable[410619] = SetSfdDislpaySize_0x290fd0; // 0x290ff4 - g_ps2RecompiledFunctionTable[410624] = SetSfdDislpaySize_0x290fd0; // 0x291008 - g_ps2RecompiledFunctionTable[410630] = InitAdx_0x291020; // 0x291020 - g_ps2RecompiledFunctionTable[410635] = InitAdx_0x291020; // 0x291034 - g_ps2RecompiledFunctionTable[410638] = InitAdx_0x291020; // 0x291040 - g_ps2RecompiledFunctionTable[410641] = InitAdx_0x291020; // 0x29104c - g_ps2RecompiledFunctionTable[410643] = InitAdx_0x291020; // 0x291054 - g_ps2RecompiledFunctionTable[410645] = InitAdx_0x291020; // 0x29105c - g_ps2RecompiledFunctionTable[410647] = InitAdx_0x291020; // 0x291064 - g_ps2RecompiledFunctionTable[410650] = InitAdx_0x291020; // 0x291070 - g_ps2RecompiledFunctionTable[410660] = InitAdx_0x291020; // 0x291098 - g_ps2RecompiledFunctionTable[410670] = InitAdx_0x291020; // 0x2910c0 - g_ps2RecompiledFunctionTable[410686] = ExitAdx_0x291100; // 0x291100 - g_ps2RecompiledFunctionTable[410690] = DeletePartition_0x291110; // 0x291110 - g_ps2RecompiledFunctionTable[410707] = DeletePartition_0x291110; // 0x291154 - g_ps2RecompiledFunctionTable[410714] = CreatePartitionEx_0x291170; // 0x291170 - g_ps2RecompiledFunctionTable[410720] = CreatePartitionEx_0x291170; // 0x291188 - g_ps2RecompiledFunctionTable[410728] = CreatePartitionEx_0x291170; // 0x2911a8 - g_ps2RecompiledFunctionTable[410740] = CreatePartitionEx_0x291170; // 0x2911d8 - g_ps2RecompiledFunctionTable[410745] = CreatePartitionEx_0x291170; // 0x2911ec - g_ps2RecompiledFunctionTable[410747] = CreatePartitionEx_0x291170; // 0x2911f4 - g_ps2RecompiledFunctionTable[410748] = CreatePartitionEx_0x291170; // 0x2911f8 - g_ps2RecompiledFunctionTable[410750] = CreatePartitionEx_0x291170; // 0x291200 - g_ps2RecompiledFunctionTable[410752] = CreatePartitionEx_0x291170; // 0x291208 - g_ps2RecompiledFunctionTable[410754] = CreatePartitionEx_0x291170; // 0x291210 - g_ps2RecompiledFunctionTable[410764] = CreatePartitionEx_0x291170; // 0x291238 - g_ps2RecompiledFunctionTable[410769] = CreatePartitionEx_0x291170; // 0x29124c - g_ps2RecompiledFunctionTable[410785] = CreatePartitionEx_0x291170; // 0x29128c - g_ps2RecompiledFunctionTable[410792] = CreatePartitionEx_0x291170; // 0x2912a8 - g_ps2RecompiledFunctionTable[410794] = CreatePartitionEx_0x291170; // 0x2912b0 - g_ps2RecompiledFunctionTable[410796] = CreatePartitionEx_0x291170; // 0x2912b8 - g_ps2RecompiledFunctionTable[410798] = CreatePartitionEx_0x291170; // 0x2912c0 - g_ps2RecompiledFunctionTable[410800] = CreatePartitionEx_0x291170; // 0x2912c8 - g_ps2RecompiledFunctionTable[410810] = CreatePartitionEx_0x291170; // 0x2912f0 - g_ps2RecompiledFunctionTable[410815] = CreatePartitionEx_0x291170; // 0x291304 - g_ps2RecompiledFunctionTable[410826] = DeletePartitionEx_0x291330; // 0x291330 - g_ps2RecompiledFunctionTable[410828] = DeletePartitionEx_0x291330; // 0x291338 - g_ps2RecompiledFunctionTable[410842] = SearchAdxFSlot_0x291370; // 0x291370 - g_ps2RecompiledFunctionTable[410845] = SearchAdxFSlot_0x291370; // 0x29137c - g_ps2RecompiledFunctionTable[410858] = OpenAfsInsideFile_0x2913b0; // 0x2913b0 - g_ps2RecompiledFunctionTable[410866] = OpenAfsInsideFile_0x2913b0; // 0x2913d0 - g_ps2RecompiledFunctionTable[410868] = OpenAfsInsideFile_0x2913b0; // 0x2913d8 - g_ps2RecompiledFunctionTable[410871] = OpenAfsInsideFile_0x2913b0; // 0x2913e4 - g_ps2RecompiledFunctionTable[410877] = OpenAfsInsideFile_0x2913b0; // 0x2913fc - g_ps2RecompiledFunctionTable[410902] = OpenAfsIsoFile_0x291460; // 0x291460 - g_ps2RecompiledFunctionTable[410910] = OpenAfsIsoFile_0x291460; // 0x291480 - g_ps2RecompiledFunctionTable[410913] = OpenAfsIsoFile_0x291460; // 0x29148c - g_ps2RecompiledFunctionTable[410920] = OpenAfsIsoFile_0x291460; // 0x2914a8 - g_ps2RecompiledFunctionTable[410927] = OpenAfsIsoFile_0x291460; // 0x2914c4 - g_ps2RecompiledFunctionTable[410934] = OpenAfsIsoFile_0x291460; // 0x2914e0 - g_ps2RecompiledFunctionTable[410942] = OpenAfsIsoFile_0x291460; // 0x291500 - g_ps2RecompiledFunctionTable[410947] = OpenAfsIsoFile_0x291460; // 0x291514 - g_ps2RecompiledFunctionTable[410962] = OpenAfsIsoFile_0x291460; // 0x291550 - g_ps2RecompiledFunctionTable[410972] = OpenAfsIsoFile_0x291460; // 0x291578 - g_ps2RecompiledFunctionTable[410975] = OpenAfsIsoFile_0x291460; // 0x291584 - g_ps2RecompiledFunctionTable[410993] = OpenAfsIsoFile_0x291460; // 0x2915cc - g_ps2RecompiledFunctionTable[410997] = OpenAfsIsoFile_0x291460; // 0x2915dc - g_ps2RecompiledFunctionTable[411003] = OpenAfsIsoFile_0x291460; // 0x2915f4 - g_ps2RecompiledFunctionTable[411005] = OpenAfsIsoFile_0x291460; // 0x2915fc - g_ps2RecompiledFunctionTable[411008] = OpenAfsIsoFile_0x291460; // 0x291608 - g_ps2RecompiledFunctionTable[411014] = OpenAfsIsoFile_0x291460; // 0x291620 - g_ps2RecompiledFunctionTable[411038] = OpenAfsIsoFile_0x291460; // 0x291680 - g_ps2RecompiledFunctionTable[411040] = OpenAfsIsoFile_0x291460; // 0x291688 - g_ps2RecompiledFunctionTable[411043] = OpenAfsIsoFile_0x291460; // 0x291694 - g_ps2RecompiledFunctionTable[411049] = OpenAfsIsoFile_0x291460; // 0x2916ac - g_ps2RecompiledFunctionTable[411074] = GetAfsInsideFileSize_0x291710; // 0x291710 - g_ps2RecompiledFunctionTable[411088] = GetAfsInsideFileSize_0x291710; // 0x291748 - g_ps2RecompiledFunctionTable[411094] = RequestReadAfsInsideFile_0x291760; // 0x291760 - g_ps2RecompiledFunctionTable[411108] = RequestReadAfsInsideFile_0x291760; // 0x291798 - g_ps2RecompiledFunctionTable[411110] = RequestReadAfsInsideFile_0x291760; // 0x2917a0 - g_ps2RecompiledFunctionTable[411115] = RequestReadAfsInsideFile_0x291760; // 0x2917b4 - g_ps2RecompiledFunctionTable[411119] = RequestReadAfsInsideFile_0x291760; // 0x2917c4 - g_ps2RecompiledFunctionTable[411121] = RequestReadAfsInsideFile_0x291760; // 0x2917cc - g_ps2RecompiledFunctionTable[411134] = CheckReadEndAfsInsideFile_0x291800; // 0x291800 - g_ps2RecompiledFunctionTable[411150] = CheckReadEndAfsInsideFile_0x291800; // 0x291840 - g_ps2RecompiledFunctionTable[411161] = CheckReadEndAfsInsideFile_0x291800; // 0x29186c - g_ps2RecompiledFunctionTable[411170] = CloseAfsInsideFile_0x291890; // 0x291890 - g_ps2RecompiledFunctionTable[411183] = CloseAfsInsideFile_0x291890; // 0x2918c4 - g_ps2RecompiledFunctionTable[411188] = CloseAfsInsideFile_0x291890; // 0x2918d8 - g_ps2RecompiledFunctionTable[411190] = CloseAfsInsideFile_0x291890; // 0x2918e0 - g_ps2RecompiledFunctionTable[411198] = StopAfsInsideFile_0x291900; // 0x291900 - g_ps2RecompiledFunctionTable[411211] = StopAfsInsideFile_0x291900; // 0x291934 - g_ps2RecompiledFunctionTable[411216] = StopAfsInsideFile_0x291900; // 0x291948 - g_ps2RecompiledFunctionTable[411218] = StopAfsInsideFile_0x291900; // 0x291950 - g_ps2RecompiledFunctionTable[411220] = StopAfsInsideFile_0x291900; // 0x291958 - g_ps2RecompiledFunctionTable[411226] = RegistAdxStreamEx_0x291970; // 0x291970 - g_ps2RecompiledFunctionTable[411245] = RegistAdxStreamEx_0x291970; // 0x2919bc - g_ps2RecompiledFunctionTable[411252] = RegistAdxStreamEx_0x291970; // 0x2919d8 - g_ps2RecompiledFunctionTable[411287] = RegistAdxStreamEx_0x291970; // 0x291a64 - g_ps2RecompiledFunctionTable[411291] = RegistAdxStreamEx_0x291970; // 0x291a74 - g_ps2RecompiledFunctionTable[411293] = RegistAdxStreamEx_0x291970; // 0x291a7c - g_ps2RecompiledFunctionTable[411299] = RegistAdxStreamEx_0x291970; // 0x291a94 - g_ps2RecompiledFunctionTable[411305] = RegistAdxStreamEx_0x291970; // 0x291aac - g_ps2RecompiledFunctionTable[411330] = FreeAdxStream_0x291b10; // 0x291b10 - g_ps2RecompiledFunctionTable[411343] = FreeAdxStream_0x291b10; // 0x291b44 - g_ps2RecompiledFunctionTable[411350] = FreeAdxStream_0x291b10; // 0x291b60 - g_ps2RecompiledFunctionTable[411352] = FreeAdxStream_0x291b10; // 0x291b68 - g_ps2RecompiledFunctionTable[411354] = FreeAdxStream_0x291b10; // 0x291b70 - g_ps2RecompiledFunctionTable[411356] = FreeAdxStream_0x291b10; // 0x291b78 - g_ps2RecompiledFunctionTable[411358] = FreeAdxStream_0x291b10; // 0x291b80 - g_ps2RecompiledFunctionTable[411360] = FreeAdxStream_0x291b10; // 0x291b88 - g_ps2RecompiledFunctionTable[411362] = FreeAdxStream_0x291b10; // 0x291b90 - g_ps2RecompiledFunctionTable[411364] = FreeAdxStream_0x291b10; // 0x291b98 - g_ps2RecompiledFunctionTable[411378] = SleepAdxStream_0x291bd0; // 0x291bd0 - g_ps2RecompiledFunctionTable[411390] = SleepAdxStream_0x291bd0; // 0x291c00 - g_ps2RecompiledFunctionTable[411392] = SleepAdxStream_0x291bd0; // 0x291c08 - g_ps2RecompiledFunctionTable[411395] = SleepAdxStream_0x291bd0; // 0x291c14 - g_ps2RecompiledFunctionTable[411397] = SleepAdxStream_0x291bd0; // 0x291c1c - g_ps2RecompiledFunctionTable[411399] = SleepAdxStream_0x291bd0; // 0x291c24 - g_ps2RecompiledFunctionTable[411401] = SleepAdxStream_0x291bd0; // 0x291c2c - g_ps2RecompiledFunctionTable[411403] = SleepAdxStream_0x291bd0; // 0x291c34 - g_ps2RecompiledFunctionTable[411405] = SleepAdxStream_0x291bd0; // 0x291c3c - g_ps2RecompiledFunctionTable[411407] = SleepAdxStream_0x291bd0; // 0x291c44 - g_ps2RecompiledFunctionTable[411409] = SleepAdxStream_0x291bd0; // 0x291c4c - g_ps2RecompiledFunctionTable[411426] = WakeupAdxStream_0x291c90; // 0x291c90 - g_ps2RecompiledFunctionTable[411439] = WakeupAdxStream_0x291c90; // 0x291cc4 - g_ps2RecompiledFunctionTable[411441] = WakeupAdxStream_0x291c90; // 0x291ccc - g_ps2RecompiledFunctionTable[411445] = WakeupAdxStream_0x291c90; // 0x291cdc - g_ps2RecompiledFunctionTable[411447] = WakeupAdxStream_0x291c90; // 0x291ce4 - g_ps2RecompiledFunctionTable[411453] = WakeupAdxStream_0x291c90; // 0x291cfc - g_ps2RecompiledFunctionTable[411459] = WakeupAdxStream_0x291c90; // 0x291d14 - g_ps2RecompiledFunctionTable[411482] = PlayAdxEx_0x291d70; // 0x291d70 - g_ps2RecompiledFunctionTable[411494] = PlayAdxEx_0x291d70; // 0x291da0 - g_ps2RecompiledFunctionTable[411496] = PlayAdxEx_0x291d70; // 0x291da8 - g_ps2RecompiledFunctionTable[411503] = PlayAdxEx_0x291d70; // 0x291dc4 - g_ps2RecompiledFunctionTable[411507] = PlayAdxEx_0x291d70; // 0x291dd4 - g_ps2RecompiledFunctionTable[411509] = PlayAdxEx_0x291d70; // 0x291ddc - g_ps2RecompiledFunctionTable[411522] = PlayAdx_0x291e10; // 0x291e10 - g_ps2RecompiledFunctionTable[411526] = StopAdx_0x291e20; // 0x291e20 - g_ps2RecompiledFunctionTable[411539] = StopAdx_0x291e20; // 0x291e54 - g_ps2RecompiledFunctionTable[411544] = StopAdx_0x291e20; // 0x291e68 - g_ps2RecompiledFunctionTable[411546] = StopAdx_0x291e20; // 0x291e70 - g_ps2RecompiledFunctionTable[411554] = PauseAdx_0x291e90; // 0x291e90 - g_ps2RecompiledFunctionTable[411559] = PauseAdx_0x291e90; // 0x291ea4 - g_ps2RecompiledFunctionTable[411566] = PauseAdx_0x291e90; // 0x291ec0 - g_ps2RecompiledFunctionTable[411568] = PauseAdx_0x291e90; // 0x291ec8 - g_ps2RecompiledFunctionTable[411574] = ContinueAdx_0x291ee0; // 0x291ee0 - g_ps2RecompiledFunctionTable[411579] = ContinueAdx_0x291ee0; // 0x291ef4 - g_ps2RecompiledFunctionTable[411586] = ContinueAdx_0x291ee0; // 0x291f10 - g_ps2RecompiledFunctionTable[411588] = ContinueAdx_0x291ee0; // 0x291f18 - g_ps2RecompiledFunctionTable[411594] = GetAdxStatus_0x291f30; // 0x291f30 - g_ps2RecompiledFunctionTable[411602] = SetVolumeAdx_0x291f50; // 0x291f50 - g_ps2RecompiledFunctionTable[411606] = SetVolumeAdxEx_0x291f60; // 0x291f60 - g_ps2RecompiledFunctionTable[411626] = SetVolumeAdx2_0x291fb0; // 0x291fb0 - g_ps2RecompiledFunctionTable[411641] = SetVolumeAdx2_0x291fb0; // 0x291fec - g_ps2RecompiledFunctionTable[411643] = SetVolumeAdx2_0x291fb0; // 0x291ff4 - g_ps2RecompiledFunctionTable[411650] = SetVolumeAdx2_0x291fb0; // 0x292010 - g_ps2RecompiledFunctionTable[411652] = SetVolumeAdx2_0x291fb0; // 0x292018 - g_ps2RecompiledFunctionTable[411662] = SetPanAdx2_0x292040; // 0x292040 - g_ps2RecompiledFunctionTable[411670] = SetPanAdx_0x292060; // 0x292060 - g_ps2RecompiledFunctionTable[411674] = GetAdxPlayTime_0x292070; // 0x292070 - g_ps2RecompiledFunctionTable[411679] = GetAdxPlayTime_0x292070; // 0x292084 - g_ps2RecompiledFunctionTable[411687] = GetAdxPlayTime_0x292070; // 0x2920a4 - g_ps2RecompiledFunctionTable[411689] = GetAdxPlayTime_0x292070; // 0x2920ac - g_ps2RecompiledFunctionTable[411691] = GetAdxPlayTime_0x292070; // 0x2920b4 - g_ps2RecompiledFunctionTable[411694] = GetAdxPlayTime_0x292070; // 0x2920c0 - g_ps2RecompiledFunctionTable[411697] = GetAdxPlayTime_0x292070; // 0x2920cc - g_ps2RecompiledFunctionTable[411701] = GetAdxPlayTime_0x292070; // 0x2920dc - g_ps2RecompiledFunctionTable[411703] = GetAdxPlayTime_0x292070; // 0x2920e4 - g_ps2RecompiledFunctionTable[411710] = RequestAdxFadeFunction2_0x292100; // 0x292100 - g_ps2RecompiledFunctionTable[411786] = RequestAdxFadeFunction_0x292230; // 0x292230 - g_ps2RecompiledFunctionTable[411790] = RequestAdxFadeFunctionEx_0x292240; // 0x292240 - g_ps2RecompiledFunctionTable[411805] = RequestAdxFadeFunctionEx_0x292240; // 0x29227c - g_ps2RecompiledFunctionTable[411834] = ExecAdxFadeManager_0x2922f0; // 0x2922f0 - g_ps2RecompiledFunctionTable[411843] = ExecAdxFadeManager_0x2922f0; // 0x292314 - g_ps2RecompiledFunctionTable[411859] = ExecAdxFadeManager_0x2922f0; // 0x292354 - g_ps2RecompiledFunctionTable[411864] = ExecAdxFadeManager_0x2922f0; // 0x292368 - g_ps2RecompiledFunctionTable[411871] = ExecAdxFadeManager_0x2922f0; // 0x292384 - g_ps2RecompiledFunctionTable[411894] = ExecAdxFadeManager_0x2922f0; // 0x2923e0 - g_ps2RecompiledFunctionTable[411906] = bhReleaseFreeMemory_0x292410; // 0x292410 - g_ps2RecompiledFunctionTable[411914] = ExitApplication_0x292430; // 0x292430 - g_ps2RecompiledFunctionTable[411918] = QuickGetDiscTrayStatus_0x292440; // 0x292440 - g_ps2RecompiledFunctionTable[411924] = QuickGetDiscTrayStatus_0x292440; // 0x292458 - g_ps2RecompiledFunctionTable[411931] = QuickGetDiscTrayStatus_0x292440; // 0x292474 - g_ps2RecompiledFunctionTable[411934] = InitFirstSofdec_0x292480; // 0x292480 - g_ps2RecompiledFunctionTable[411938] = GetBootDiscId_0x292490; // 0x292490 - g_ps2RecompiledFunctionTable[411945] = GetBootDiscId_0x292490; // 0x2924ac - g_ps2RecompiledFunctionTable[411947] = GetBootDiscId_0x292490; // 0x2924b4 - g_ps2RecompiledFunctionTable[411949] = GetBootDiscId_0x292490; // 0x2924bc - g_ps2RecompiledFunctionTable[411953] = GetBootDiscId_0x292490; // 0x2924cc - g_ps2RecompiledFunctionTable[411957] = GetBootDiscId_0x292490; // 0x2924dc - g_ps2RecompiledFunctionTable[411960] = GetBootDiscId_0x292490; // 0x2924e8 - g_ps2RecompiledFunctionTable[411966] = InitSofdecSystem_0x292500; // 0x292500 - g_ps2RecompiledFunctionTable[411974] = InitSofdecSystem_0x292500; // 0x292520 - g_ps2RecompiledFunctionTable[412013] = InitSofdecSystem_0x292500; // 0x2925bc - g_ps2RecompiledFunctionTable[412017] = InitSofdecSystem_0x292500; // 0x2925cc - g_ps2RecompiledFunctionTable[412022] = ExitSofdecSystem_0x2925e0; // 0x2925e0 - g_ps2RecompiledFunctionTable[412030] = ExitSofdecSystem_0x2925e0; // 0x292600 - g_ps2RecompiledFunctionTable[412034] = InitSoundProgram_0x292610; // 0x292610 - g_ps2RecompiledFunctionTable[412038] = InitSoundProgram_0x292610; // 0x292620 - g_ps2RecompiledFunctionTable[412060] = InitSoundProgram_0x292610; // 0x292678 - g_ps2RecompiledFunctionTable[412065] = InitSoundProgram_0x292610; // 0x29268c - g_ps2RecompiledFunctionTable[412073] = InitSoundProgram_0x292610; // 0x2926ac - g_ps2RecompiledFunctionTable[412077] = InitSoundProgram_0x292610; // 0x2926bc - g_ps2RecompiledFunctionTable[412079] = InitSoundProgram_0x292610; // 0x2926c4 - g_ps2RecompiledFunctionTable[412085] = InitSoundProgram_0x292610; // 0x2926dc - g_ps2RecompiledFunctionTable[412087] = InitSoundProgram_0x292610; // 0x2926e4 - g_ps2RecompiledFunctionTable[412095] = InitSoundProgram_0x292610; // 0x292704 - g_ps2RecompiledFunctionTable[412097] = InitSoundProgram_0x292610; // 0x29270c - g_ps2RecompiledFunctionTable[412103] = InitSoundProgram_0x292610; // 0x292724 - g_ps2RecompiledFunctionTable[412108] = InitSoundProgram_0x292610; // 0x292738 - g_ps2RecompiledFunctionTable[412110] = InitSoundProgram_0x292610; // 0x292740 - g_ps2RecompiledFunctionTable[412114] = InitSoundProgram_0x292610; // 0x292750 - g_ps2RecompiledFunctionTable[412119] = InitSoundProgram_0x292610; // 0x292764 - g_ps2RecompiledFunctionTable[412122] = InitSoundProgram_0x292610; // 0x292770 - g_ps2RecompiledFunctionTable[412124] = InitSoundProgram_0x292610; // 0x292778 - g_ps2RecompiledFunctionTable[412126] = InitSoundProgram_0x292610; // 0x292780 - g_ps2RecompiledFunctionTable[412129] = InitSoundProgram_0x292610; // 0x29278c - g_ps2RecompiledFunctionTable[412131] = InitSoundProgram_0x292610; // 0x292794 - g_ps2RecompiledFunctionTable[412133] = InitSoundProgram_0x292610; // 0x29279c - g_ps2RecompiledFunctionTable[412138] = InitSoundProgram_0x292610; // 0x2927b0 - g_ps2RecompiledFunctionTable[412140] = InitSoundProgram_0x292610; // 0x2927b8 - g_ps2RecompiledFunctionTable[412150] = ExitSoundProgram_0x2927e0; // 0x2927e0 - g_ps2RecompiledFunctionTable[412173] = ExitSoundProgram_0x2927e0; // 0x29283c - g_ps2RecompiledFunctionTable[412175] = ExitSoundProgram_0x2927e0; // 0x292844 - g_ps2RecompiledFunctionTable[412177] = ExitSoundProgram_0x2927e0; // 0x29284c - g_ps2RecompiledFunctionTable[412179] = ExitSoundProgram_0x2927e0; // 0x292854 - g_ps2RecompiledFunctionTable[412181] = ExitSoundProgram_0x2927e0; // 0x29285c - g_ps2RecompiledFunctionTable[412183] = ExitSoundProgram_0x2927e0; // 0x292864 - g_ps2RecompiledFunctionTable[412185] = ExitSoundProgram_0x2927e0; // 0x29286c - g_ps2RecompiledFunctionTable[412187] = ExitSoundProgram_0x2927e0; // 0x292874 - g_ps2RecompiledFunctionTable[412190] = ExitSoundProgram_0x2927e0; // 0x292880 - g_ps2RecompiledFunctionTable[412194] = MountSoundAfs_0x292890; // 0x292890 - g_ps2RecompiledFunctionTable[412235] = MountSoundAfs_0x292890; // 0x292934 - g_ps2RecompiledFunctionTable[412249] = MountSoundAfs_0x292890; // 0x29296c - g_ps2RecompiledFunctionTable[412257] = MountSoundAfs_0x292890; // 0x29298c - g_ps2RecompiledFunctionTable[412268] = MountSoundAfs_0x292890; // 0x2929b8 - g_ps2RecompiledFunctionTable[412272] = MountSoundAfs_0x292890; // 0x2929c8 - g_ps2RecompiledFunctionTable[412279] = MountSoundAfs_0x292890; // 0x2929e4 - g_ps2RecompiledFunctionTable[412283] = MountSoundAfs_0x292890; // 0x2929f4 - g_ps2RecompiledFunctionTable[412287] = MountSoundAfs_0x292890; // 0x292a04 - g_ps2RecompiledFunctionTable[412303] = MountSoundAfs_0x292890; // 0x292a44 - g_ps2RecompiledFunctionTable[412306] = MountSoundAfs_0x292890; // 0x292a50 - g_ps2RecompiledFunctionTable[412310] = MountSoundAfs_0x292890; // 0x292a60 - g_ps2RecompiledFunctionTable[412346] = UnmountSoundAfs_0x292af0; // 0x292af0 - g_ps2RecompiledFunctionTable[412356] = UnmountSoundAfs_0x292af0; // 0x292b18 - g_ps2RecompiledFunctionTable[412359] = UnmountSoundAfs_0x292af0; // 0x292b24 - g_ps2RecompiledFunctionTable[412374] = ExecSoundSynchProgram_0x292b60; // 0x292b60 - g_ps2RecompiledFunctionTable[412382] = ExecSoundSynchProgram_0x292b60; // 0x292b80 - g_ps2RecompiledFunctionTable[412389] = ExecSoundSynchProgram_0x292b60; // 0x292b9c - g_ps2RecompiledFunctionTable[412395] = ExecSoundSynchProgram_0x292b60; // 0x292bb4 - g_ps2RecompiledFunctionTable[412397] = ExecSoundSynchProgram_0x292b60; // 0x292bbc - g_ps2RecompiledFunctionTable[412399] = ExecSoundSynchProgram_0x292b60; // 0x292bc4 - g_ps2RecompiledFunctionTable[412408] = ExecSoundSynchProgram_0x292b60; // 0x292be8 - g_ps2RecompiledFunctionTable[412415] = ExecSoundSynchProgram_0x292b60; // 0x292c04 - g_ps2RecompiledFunctionTable[412417] = ExecSoundSynchProgram_0x292b60; // 0x292c0c - g_ps2RecompiledFunctionTable[412422] = InitGameSoundSystem_0x292c20; // 0x292c20 - g_ps2RecompiledFunctionTable[412429] = InitGameSoundSystem_0x292c20; // 0x292c3c - g_ps2RecompiledFunctionTable[412434] = InitGameSoundSystem_0x292c20; // 0x292c50 - g_ps2RecompiledFunctionTable[412449] = InitGameSoundSystem_0x292c20; // 0x292c8c - g_ps2RecompiledFunctionTable[412461] = InitGameSoundSystem_0x292c20; // 0x292cbc - g_ps2RecompiledFunctionTable[412463] = InitGameSoundSystem_0x292c20; // 0x292cc4 - g_ps2RecompiledFunctionTable[412465] = InitGameSoundSystem_0x292c20; // 0x292ccc - g_ps2RecompiledFunctionTable[412470] = InitGameSoundSystem_0x292c20; // 0x292ce0 - g_ps2RecompiledFunctionTable[412473] = InitGameSoundSystem_0x292c20; // 0x292cec - g_ps2RecompiledFunctionTable[412475] = InitGameSoundSystem_0x292c20; // 0x292cf4 - g_ps2RecompiledFunctionTable[412477] = InitGameSoundSystem_0x292c20; // 0x292cfc - g_ps2RecompiledFunctionTable[412482] = SearchAfsInsideFileId_0x292d10; // 0x292d10 - g_ps2RecompiledFunctionTable[412487] = SearchAfsInsideFileId_0x292d10; // 0x292d24 - g_ps2RecompiledFunctionTable[412506] = StopThePsgSound_0x292d70; // 0x292d70 - g_ps2RecompiledFunctionTable[412510] = StopThePsgSound_0x292d70; // 0x292d80 - g_ps2RecompiledFunctionTable[412515] = StopThePsgSound_0x292d70; // 0x292d94 - g_ps2RecompiledFunctionTable[412518] = StopThePsgSound_0x292d70; // 0x292da0 - g_ps2RecompiledFunctionTable[412523] = StopThePsgSound_0x292d70; // 0x292db4 - g_ps2RecompiledFunctionTable[412526] = CheckSpecialBank_0x292dc0; // 0x292dc0 - g_ps2RecompiledFunctionTable[412550] = CheckSpecialBank_0x292dc0; // 0x292e20 - g_ps2RecompiledFunctionTable[412563] = CheckSpecialBank_0x292dc0; // 0x292e54 - g_ps2RecompiledFunctionTable[412574] = LoadSoundPackFile_0x292e80; // 0x292e80 - g_ps2RecompiledFunctionTable[412600] = LoadSoundPackFile_0x292e80; // 0x292ee8 - g_ps2RecompiledFunctionTable[412606] = LoadSoundPackFile_0x292e80; // 0x292f00 - g_ps2RecompiledFunctionTable[412614] = LoadSoundPackFile_0x292e80; // 0x292f20 - g_ps2RecompiledFunctionTable[412621] = LoadSoundPackFile_0x292e80; // 0x292f3c - g_ps2RecompiledFunctionTable[412632] = LoadSoundPackFile_0x292e80; // 0x292f68 - g_ps2RecompiledFunctionTable[412640] = LoadSoundPackFile_0x292e80; // 0x292f88 - g_ps2RecompiledFunctionTable[412647] = LoadSoundPackFile_0x292e80; // 0x292fa4 - g_ps2RecompiledFunctionTable[412670] = LoadSoundPackFile_0x292e80; // 0x293000 - g_ps2RecompiledFunctionTable[412682] = LoadSoundPackFile_0x292e80; // 0x293030 - g_ps2RecompiledFunctionTable[412699] = LoadSoundPackFile_0x292e80; // 0x293074 - g_ps2RecompiledFunctionTable[412709] = LoadSoundPackFile_0x292e80; // 0x29309c - g_ps2RecompiledFunctionTable[412739] = LoadSoundPackFile_0x292e80; // 0x293114 - g_ps2RecompiledFunctionTable[412743] = LoadSoundPackFile_0x292e80; // 0x293124 - g_ps2RecompiledFunctionTable[412758] = LoadSoundPackFile_0x292e80; // 0x293160 - g_ps2RecompiledFunctionTable[412760] = LoadSoundPackFile_0x292e80; // 0x293168 - g_ps2RecompiledFunctionTable[412779] = LoadSoundPackFile_0x292e80; // 0x2931b4 - g_ps2RecompiledFunctionTable[412781] = LoadSoundPackFile_0x292e80; // 0x2931bc - g_ps2RecompiledFunctionTable[412794] = ExecTransSoundData_0x2931f0; // 0x2931f0 - g_ps2RecompiledFunctionTable[412822] = ExecTransSoundData_0x2931f0; // 0x293260 - g_ps2RecompiledFunctionTable[412830] = ExecTransSoundData_0x2931f0; // 0x293280 - g_ps2RecompiledFunctionTable[412850] = RequestRoomSoundBank_0x2932d0; // 0x2932d0 - g_ps2RecompiledFunctionTable[412859] = RequestRoomSoundBank_0x2932d0; // 0x2932f4 - g_ps2RecompiledFunctionTable[412867] = RequestRoomSoundBank_0x2932d0; // 0x293314 - g_ps2RecompiledFunctionTable[412890] = RequestArmsSoundBank_0x293370; // 0x293370 - g_ps2RecompiledFunctionTable[412900] = RequestArmsSoundBank_0x293370; // 0x293398 - g_ps2RecompiledFunctionTable[412910] = RequestDoorSoundBank_0x2933c0; // 0x2933c0 - g_ps2RecompiledFunctionTable[412920] = RequestDoorSoundBank_0x2933c0; // 0x2933e8 - g_ps2RecompiledFunctionTable[412934] = RequestPlayerVoiceSoundBank_0x293420; // 0x293420 - g_ps2RecompiledFunctionTable[412944] = RequestPlayerVoiceSoundBank_0x293420; // 0x293448 - g_ps2RecompiledFunctionTable[412954] = CheckTransEndSoundBank_0x293470; // 0x293470 - g_ps2RecompiledFunctionTable[412958] = SetRoomSoundCaseNo_0x293480; // 0x293480 - g_ps2RecompiledFunctionTable[412962] = GetRoomSoundCaseNo_0x293490; // 0x293490 - g_ps2RecompiledFunctionTable[412970] = CustomMidiSlotDef_0x2934b0; // 0x2934b0 - g_ps2RecompiledFunctionTable[412998] = ResetRoomSoundEnvParam_0x293520; // 0x293520 - g_ps2RecompiledFunctionTable[413006] = wadGetAngle_0x293540; // 0x293540 - g_ps2RecompiledFunctionTable[413017] = wadGetAngle_0x293540; // 0x29356c - g_ps2RecompiledFunctionTable[413022] = wadGetAngle_0x293540; // 0x293580 - g_ps2RecompiledFunctionTable[413030] = CheckCollision4Sound_0x2935a0; // 0x2935a0 - g_ps2RecompiledFunctionTable[413059] = CheckCollision4Sound_0x2935a0; // 0x293614 - g_ps2RecompiledFunctionTable[413070] = Get3DSoundParameter_0x293640; // 0x293640 - g_ps2RecompiledFunctionTable[413087] = Get3DSoundParameter_0x293640; // 0x293684 - g_ps2RecompiledFunctionTable[413093] = Get3DSoundParameter_0x293640; // 0x29369c - g_ps2RecompiledFunctionTable[413097] = Get3DSoundParameter_0x293640; // 0x2936ac - g_ps2RecompiledFunctionTable[413100] = Get3DSoundParameter_0x293640; // 0x2936b8 - g_ps2RecompiledFunctionTable[413114] = Get3DSoundParameter_0x293640; // 0x2936f0 - g_ps2RecompiledFunctionTable[413124] = Get3DSoundParameter_0x293640; // 0x293718 - g_ps2RecompiledFunctionTable[413134] = Get3DSoundParameter_0x293640; // 0x293740 - g_ps2RecompiledFunctionTable[413178] = SetupSeGenericParm_0x2937f0; // 0x2937f0 - g_ps2RecompiledFunctionTable[413198] = SetupSeGenericParm_0x2937f0; // 0x293840 - g_ps2RecompiledFunctionTable[413246] = Set3dSoundFlag_0x293900; // 0x293900 - g_ps2RecompiledFunctionTable[413268] = Set3dSoundFlag_0x293900; // 0x293958 - g_ps2RecompiledFunctionTable[413275] = Set3dSoundFlag_0x293900; // 0x293974 - g_ps2RecompiledFunctionTable[413293] = Set3dSoundFlag_0x293900; // 0x2939bc - g_ps2RecompiledFunctionTable[413297] = Set3dSoundFlag_0x293900; // 0x2939cc - g_ps2RecompiledFunctionTable[413304] = Set3dSoundFlag_0x293900; // 0x2939e8 - g_ps2RecompiledFunctionTable[413308] = Set3dSoundFlag_0x293900; // 0x2939f8 - g_ps2RecompiledFunctionTable[413318] = Set3dSoundFlag_0x293900; // 0x293a20 - g_ps2RecompiledFunctionTable[413325] = Set3dSoundFlag_0x293900; // 0x293a3c - g_ps2RecompiledFunctionTable[413339] = Set3dSoundFlag_0x293900; // 0x293a74 - g_ps2RecompiledFunctionTable[413343] = Set3dSoundFlag_0x293900; // 0x293a84 - g_ps2RecompiledFunctionTable[413347] = Set3dSoundFlag_0x293900; // 0x293a94 - g_ps2RecompiledFunctionTable[413354] = Set3dSoundFlag_0x293900; // 0x293ab0 - g_ps2RecompiledFunctionTable[413358] = Set3dSoundFlag_0x293900; // 0x293ac0 - g_ps2RecompiledFunctionTable[413362] = Set3dSoundFlag_0x293900; // 0x293ad0 - g_ps2RecompiledFunctionTable[413372] = Set3dSoundFlag_0x293900; // 0x293af8 - g_ps2RecompiledFunctionTable[413379] = Set3dSoundFlag_0x293900; // 0x293b14 - g_ps2RecompiledFunctionTable[413397] = Set3dSoundFlag_0x293900; // 0x293b5c - g_ps2RecompiledFunctionTable[413404] = Set3dSoundFlag_0x293900; // 0x293b78 - g_ps2RecompiledFunctionTable[413422] = Set3dSoundFlag_0x293900; // 0x293bc0 - g_ps2RecompiledFunctionTable[413440] = Set3dSoundFlag_0x293900; // 0x293c08 - g_ps2RecompiledFunctionTable[413447] = Set3dSoundFlag_0x293900; // 0x293c24 - g_ps2RecompiledFunctionTable[413459] = Set3dSoundFlag_0x293900; // 0x293c54 - g_ps2RecompiledFunctionTable[413472] = Set3dSoundFlag_0x293900; // 0x293c88 - g_ps2RecompiledFunctionTable[413483] = Set3dSoundFlag_0x293900; // 0x293cb4 - g_ps2RecompiledFunctionTable[413491] = Set3dSoundFlag_0x293900; // 0x293cd4 - g_ps2RecompiledFunctionTable[413498] = Reset3dSoundFlag_0x293cf0; // 0x293cf0 - g_ps2RecompiledFunctionTable[413505] = Reset3dSoundFlag_0x293cf0; // 0x293d0c - g_ps2RecompiledFunctionTable[413507] = Reset3dSoundFlag_0x293cf0; // 0x293d14 - g_ps2RecompiledFunctionTable[413510] = Reset3dSoundFlag_0x293cf0; // 0x293d20 - g_ps2RecompiledFunctionTable[413518] = Reset3dSoundFlag_0x293cf0; // 0x293d40 - g_ps2RecompiledFunctionTable[413522] = Reset3dSoundFlag_0x293cf0; // 0x293d50 - g_ps2RecompiledFunctionTable[413526] = Reset3dSoundFlag_0x293cf0; // 0x293d60 - g_ps2RecompiledFunctionTable[413528] = Reset3dSoundFlag_0x293cf0; // 0x293d68 - g_ps2RecompiledFunctionTable[413531] = Reset3dSoundFlag_0x293cf0; // 0x293d74 - g_ps2RecompiledFunctionTable[413539] = Reset3dSoundFlag_0x293cf0; // 0x293d94 - g_ps2RecompiledFunctionTable[413543] = Reset3dSoundFlag_0x293cf0; // 0x293da4 - g_ps2RecompiledFunctionTable[413547] = Reset3dSoundFlag_0x293cf0; // 0x293db4 - g_ps2RecompiledFunctionTable[413550] = Reset3dSoundFlag_0x293cf0; // 0x293dc0 - g_ps2RecompiledFunctionTable[413553] = Reset3dSoundFlag_0x293cf0; // 0x293dcc - g_ps2RecompiledFunctionTable[413562] = Reset3dSoundFlag_0x293cf0; // 0x293df0 - g_ps2RecompiledFunctionTable[413565] = Reset3dSoundFlag_0x293cf0; // 0x293dfc - g_ps2RecompiledFunctionTable[413575] = Reset3dSoundFlag_0x293cf0; // 0x293e24 - g_ps2RecompiledFunctionTable[413579] = Reset3dSoundFlag_0x293cf0; // 0x293e34 - g_ps2RecompiledFunctionTable[413583] = Reset3dSoundFlag_0x293cf0; // 0x293e44 - g_ps2RecompiledFunctionTable[413590] = SetUserSoundVolume_0x293e60; // 0x293e60 - g_ps2RecompiledFunctionTable[413618] = SetUserSoundVolume_0x293e60; // 0x293ed0 - g_ps2RecompiledFunctionTable[413633] = SetUserSoundVolume_0x293e60; // 0x293f0c - g_ps2RecompiledFunctionTable[413638] = SetUserSoundVolume_0x293e60; // 0x293f20 - g_ps2RecompiledFunctionTable[413650] = SetUserSoundVolume_0x293e60; // 0x293f50 - g_ps2RecompiledFunctionTable[413662] = SetUserSoundVolume_0x293e60; // 0x293f80 - g_ps2RecompiledFunctionTable[413667] = SetUserSoundVolume_0x293e60; // 0x293f94 - g_ps2RecompiledFunctionTable[413672] = SetUserSoundVolume_0x293e60; // 0x293fa8 - g_ps2RecompiledFunctionTable[413684] = SetUserSoundVolume_0x293e60; // 0x293fd8 - g_ps2RecompiledFunctionTable[413702] = SetUserSoundVolume_0x293e60; // 0x294020 - g_ps2RecompiledFunctionTable[413720] = SetUserSoundVolume_0x293e60; // 0x294068 - g_ps2RecompiledFunctionTable[413738] = SetUserSoundVolume_0x293e60; // 0x2940b0 - g_ps2RecompiledFunctionTable[413776] = SetUserSoundVolume_0x293e60; // 0x294148 - g_ps2RecompiledFunctionTable[413786] = SetUserSoundPan_0x294170; // 0x294170 - g_ps2RecompiledFunctionTable[413814] = SetUserSoundPan_0x294170; // 0x2941e0 - g_ps2RecompiledFunctionTable[413829] = SetUserSoundPan_0x294170; // 0x29421c - g_ps2RecompiledFunctionTable[413834] = SetUserSoundPan_0x294170; // 0x294230 - g_ps2RecompiledFunctionTable[413846] = SetUserSoundPan_0x294170; // 0x294260 - g_ps2RecompiledFunctionTable[413858] = SetUserSoundPan_0x294170; // 0x294290 - g_ps2RecompiledFunctionTable[413863] = SetUserSoundPan_0x294170; // 0x2942a4 - g_ps2RecompiledFunctionTable[413868] = SetUserSoundPan_0x294170; // 0x2942b8 - g_ps2RecompiledFunctionTable[413880] = SetUserSoundPan_0x294170; // 0x2942e8 - g_ps2RecompiledFunctionTable[413898] = SetUserSoundPan_0x294170; // 0x294330 - g_ps2RecompiledFunctionTable[413916] = SetUserSoundPan_0x294170; // 0x294378 - g_ps2RecompiledFunctionTable[413950] = PlayGameSe4Event_0x294400; // 0x294400 - g_ps2RecompiledFunctionTable[413973] = PlayGameSe4Event_0x294400; // 0x29445c - g_ps2RecompiledFunctionTable[413982] = PlayGameSe4Event_0x294400; // 0x294480 - g_ps2RecompiledFunctionTable[413991] = PlayGameSe4Event_0x294400; // 0x2944a4 - g_ps2RecompiledFunctionTable[414004] = PlayGameSe4Event_0x294400; // 0x2944d8 - g_ps2RecompiledFunctionTable[414012] = PlayGameSe4Event_0x294400; // 0x2944f8 - g_ps2RecompiledFunctionTable[414017] = PlayGameSe4Event_0x294400; // 0x29450c - g_ps2RecompiledFunctionTable[414023] = PlayGameSe4Event_0x294400; // 0x294524 - g_ps2RecompiledFunctionTable[414028] = PlayGameSe4Event_0x294400; // 0x294538 - g_ps2RecompiledFunctionTable[414034] = PlayGameSe4Event_0x294400; // 0x294550 - g_ps2RecompiledFunctionTable[414039] = PlayGameSe4Event_0x294400; // 0x294564 - g_ps2RecompiledFunctionTable[414046] = PlayGameSe4Event_0x294400; // 0x294580 - g_ps2RecompiledFunctionTable[414054] = CallSystemSeBasic_0x2945a0; // 0x2945a0 - g_ps2RecompiledFunctionTable[414097] = CallSystemSeBasic_0x2945a0; // 0x29464c - g_ps2RecompiledFunctionTable[414103] = CallSystemSeBasic_0x2945a0; // 0x294664 - g_ps2RecompiledFunctionTable[414119] = CallSystemSeBasic_0x2945a0; // 0x2946a4 - g_ps2RecompiledFunctionTable[414122] = CallSystemSeEx_0x2946b0; // 0x2946b0 - g_ps2RecompiledFunctionTable[414126] = CallSystemSe_0x2946c0; // 0x2946c0 - g_ps2RecompiledFunctionTable[414130] = StopSystemSe_0x2946d0; // 0x2946d0 - g_ps2RecompiledFunctionTable[414134] = SetSyukanModeSoundParam_0x2946e0; // 0x2946e0 - g_ps2RecompiledFunctionTable[414154] = CallPlayerVoice_0x294730; // 0x294730 - g_ps2RecompiledFunctionTable[414164] = CallPlayerVoice_0x294730; // 0x294758 - g_ps2RecompiledFunctionTable[414181] = CallPlayerVoice_0x294730; // 0x29479c - g_ps2RecompiledFunctionTable[414186] = GetPlayerActionSeSlotNo_0x2947b0; // 0x2947b0 - g_ps2RecompiledFunctionTable[414222] = CallPlayerFootStepSeEx_0x294840; // 0x294840 - g_ps2RecompiledFunctionTable[414259] = CallPlayerFootStepSeEx_0x294840; // 0x2948d4 - g_ps2RecompiledFunctionTable[414261] = CallPlayerFootStepSeEx_0x294840; // 0x2948dc - g_ps2RecompiledFunctionTable[414276] = CallPlayerFootStepSeEx_0x294840; // 0x294918 - g_ps2RecompiledFunctionTable[414304] = CallPlayerFootStepSeEx_0x294840; // 0x294988 - g_ps2RecompiledFunctionTable[414317] = CallPlayerFootStepSeEx_0x294840; // 0x2949bc - g_ps2RecompiledFunctionTable[414333] = CallPlayerFootStepSeEx_0x294840; // 0x2949fc - g_ps2RecompiledFunctionTable[414346] = CallPlayerFootStepSeEx_0x294840; // 0x294a30 - g_ps2RecompiledFunctionTable[414430] = CallPlayerFootStepSeEx_0x294840; // 0x294b80 - g_ps2RecompiledFunctionTable[414438] = CallPlayerFootStepSe_0x294ba0; // 0x294ba0 - g_ps2RecompiledFunctionTable[414442] = CallPlayerActionSe_0x294bb0; // 0x294bb0 - g_ps2RecompiledFunctionTable[414450] = CallPlayerWeaponSeEx_0x294bd0; // 0x294bd0 - g_ps2RecompiledFunctionTable[414487] = CallPlayerWeaponSeEx_0x294bd0; // 0x294c64 - g_ps2RecompiledFunctionTable[414489] = CallPlayerWeaponSeEx_0x294bd0; // 0x294c6c - g_ps2RecompiledFunctionTable[414506] = CallPlayerWeaponSeEx_0x294bd0; // 0x294cb0 - g_ps2RecompiledFunctionTable[414510] = CallYakkyouSe_0x294cc0; // 0x294cc0 - g_ps2RecompiledFunctionTable[414527] = CallYakkyouSe_0x294cc0; // 0x294d04 - g_ps2RecompiledFunctionTable[414559] = CallYakkyouSe_0x294cc0; // 0x294d84 - g_ps2RecompiledFunctionTable[414562] = CallBackGroundSeEx_0x294d90; // 0x294d90 - g_ps2RecompiledFunctionTable[414608] = CallBackGroundSeEx_0x294d90; // 0x294e48 - g_ps2RecompiledFunctionTable[414618] = CallBackGroundSeEx_0x294d90; // 0x294e70 - g_ps2RecompiledFunctionTable[414649] = CallBackGroundSeEx_0x294d90; // 0x294eec - g_ps2RecompiledFunctionTable[414662] = CallBackGroundSe_0x294f20; // 0x294f20 - g_ps2RecompiledFunctionTable[414666] = CallBackGroundSe2_0x294f30; // 0x294f30 - g_ps2RecompiledFunctionTable[414682] = StopBackGroundSeEx_0x294f70; // 0x294f70 - g_ps2RecompiledFunctionTable[414702] = StopBackGroundSeEx_0x294f70; // 0x294fc0 - g_ps2RecompiledFunctionTable[414708] = StopBackGroundSeEx_0x294f70; // 0x294fd8 - g_ps2RecompiledFunctionTable[414718] = StopBackGroundSe2_0x295000; // 0x295000 - g_ps2RecompiledFunctionTable[414730] = CallDoorSe_0x295030; // 0x295030 - g_ps2RecompiledFunctionTable[414781] = CallDoorSe_0x295030; // 0x2950fc - g_ps2RecompiledFunctionTable[414786] = RequestEnemySeBasic_0x295110; // 0x295110 - g_ps2RecompiledFunctionTable[414819] = RequestEnemySeBasic_0x295110; // 0x295194 - g_ps2RecompiledFunctionTable[414862] = RequestEnemySe_0x295240; // 0x295240 - g_ps2RecompiledFunctionTable[414866] = RequestEnemySeEx_0x295250; // 0x295250 - g_ps2RecompiledFunctionTable[414870] = ChechPlayEnemySe_0x295260; // 0x295260 - g_ps2RecompiledFunctionTable[414873] = ChechPlayEnemySe_0x295260; // 0x29526c - g_ps2RecompiledFunctionTable[414898] = AllStopEnemySe_0x2952d0; // 0x2952d0 - g_ps2RecompiledFunctionTable[414908] = AllStopEnemySe_0x2952d0; // 0x2952f8 - g_ps2RecompiledFunctionTable[414915] = AllStopEnemySe_0x2952d0; // 0x295314 - g_ps2RecompiledFunctionTable[414920] = AllStopEnemySe_0x2952d0; // 0x295328 - g_ps2RecompiledFunctionTable[414930] = AllStopEnemySe_0x2952d0; // 0x295350 - g_ps2RecompiledFunctionTable[414938] = CallEnemySe_0x295370; // 0x295370 - g_ps2RecompiledFunctionTable[414964] = CallEnemySe_0x295370; // 0x2953d8 - g_ps2RecompiledFunctionTable[414978] = CallEnemySe_0x295370; // 0x295410 - g_ps2RecompiledFunctionTable[414982] = StopEnemySe_0x295420; // 0x295420 - g_ps2RecompiledFunctionTable[414990] = CallNativeEventSe_0x295440; // 0x295440 - g_ps2RecompiledFunctionTable[415047] = CallNativeEventSe_0x295440; // 0x295524 - g_ps2RecompiledFunctionTable[415070] = CallNativeEventSe_0x295440; // 0x295580 - g_ps2RecompiledFunctionTable[415074] = StopNativeEventSe_0x295590; // 0x295590 - g_ps2RecompiledFunctionTable[415094] = StopNativeEventSe_0x295590; // 0x2955e0 - g_ps2RecompiledFunctionTable[415098] = RequestObjectSeEx_0x2955f0; // 0x2955f0 - g_ps2RecompiledFunctionTable[415117] = RequestObjectSeEx_0x2955f0; // 0x29563c - g_ps2RecompiledFunctionTable[415126] = RequestObjectSeEx_0x2955f0; // 0x295660 - g_ps2RecompiledFunctionTable[415142] = RegistObjectSe_0x2956a0; // 0x2956a0 - g_ps2RecompiledFunctionTable[415171] = RegistObjectSe_0x2956a0; // 0x295714 - g_ps2RecompiledFunctionTable[415190] = FreeObjectSe_0x295760; // 0x295760 - g_ps2RecompiledFunctionTable[415208] = FreeObjectSe_0x295760; // 0x2957a8 - g_ps2RecompiledFunctionTable[415231] = FreeObjectSe_0x295760; // 0x295804 - g_ps2RecompiledFunctionTable[415239] = FreeObjectSe_0x295760; // 0x295824 - g_ps2RecompiledFunctionTable[415242] = PlayBgmEx2_0x295830; // 0x295830 - g_ps2RecompiledFunctionTable[415260] = PlayBgmEx2_0x295830; // 0x295878 - g_ps2RecompiledFunctionTable[415265] = PlayBgmEx2_0x295830; // 0x29588c - g_ps2RecompiledFunctionTable[415276] = PlayBgmEx2_0x295830; // 0x2958b8 - g_ps2RecompiledFunctionTable[415280] = PlayBgmEx2_0x295830; // 0x2958c8 - g_ps2RecompiledFunctionTable[415284] = PlayBgmEx2_0x295830; // 0x2958d8 - g_ps2RecompiledFunctionTable[415298] = PlayBgmEx_0x295910; // 0x295910 - g_ps2RecompiledFunctionTable[415306] = PlayBgm_0x295930; // 0x295930 - g_ps2RecompiledFunctionTable[415310] = PlayBgm2_0x295940; // 0x295940 - g_ps2RecompiledFunctionTable[415330] = StopBgm_0x295990; // 0x295990 - g_ps2RecompiledFunctionTable[415337] = StopBgm_0x295990; // 0x2959ac - g_ps2RecompiledFunctionTable[415341] = StopBgm_0x295990; // 0x2959bc - g_ps2RecompiledFunctionTable[415354] = StopBgm2_0x2959f0; // 0x2959f0 - g_ps2RecompiledFunctionTable[415366] = PlayVoiceEx2_0x295a20; // 0x295a20 - g_ps2RecompiledFunctionTable[415384] = PlayVoiceEx2_0x295a20; // 0x295a68 - g_ps2RecompiledFunctionTable[415389] = PlayVoiceEx2_0x295a20; // 0x295a7c - g_ps2RecompiledFunctionTable[415408] = PlayVoiceEx2_0x295a20; // 0x295ac8 - g_ps2RecompiledFunctionTable[415412] = PlayVoiceEx2_0x295a20; // 0x295ad8 - g_ps2RecompiledFunctionTable[415415] = PlayVoiceEx2_0x295a20; // 0x295ae4 - g_ps2RecompiledFunctionTable[415420] = PlayVoiceEx2_0x295a20; // 0x295af8 - g_ps2RecompiledFunctionTable[415428] = PlayVoiceEx2_0x295a20; // 0x295b18 - g_ps2RecompiledFunctionTable[415433] = PlayVoiceEx2_0x295a20; // 0x295b2c - g_ps2RecompiledFunctionTable[415437] = PlayVoiceEx2_0x295a20; // 0x295b3c - g_ps2RecompiledFunctionTable[415442] = PlayVoiceEx2_0x295a20; // 0x295b50 - g_ps2RecompiledFunctionTable[415452] = PlayVoiceEx2_0x295a20; // 0x295b78 - g_ps2RecompiledFunctionTable[415456] = PlayVoiceEx2_0x295a20; // 0x295b88 - g_ps2RecompiledFunctionTable[415459] = PlayVoiceEx2_0x295a20; // 0x295b94 - g_ps2RecompiledFunctionTable[415474] = PlayVoiceEx_0x295bd0; // 0x295bd0 - g_ps2RecompiledFunctionTable[415486] = PlayVoice_0x295c00; // 0x295c00 - g_ps2RecompiledFunctionTable[415490] = ContinuePlayVoice_0x295c10; // 0x295c10 - g_ps2RecompiledFunctionTable[415494] = StopVoice_0x295c20; // 0x295c20 - g_ps2RecompiledFunctionTable[415501] = StopVoice_0x295c20; // 0x295c3c - g_ps2RecompiledFunctionTable[415505] = StopVoice_0x295c20; // 0x295c4c - g_ps2RecompiledFunctionTable[415510] = CheckPlayEndAdx_0x295c60; // 0x295c60 - g_ps2RecompiledFunctionTable[415518] = GetTimeAdx_0x295c80; // 0x295c80 - g_ps2RecompiledFunctionTable[415522] = SetRoomSoundFxLevel_0x295c90; // 0x295c90 - g_ps2RecompiledFunctionTable[415530] = SetRoomSoundFxLevel_0x295c90; // 0x295cb0 - g_ps2RecompiledFunctionTable[415533] = SetRoomSoundFxLevel_0x295c90; // 0x295cbc - g_ps2RecompiledFunctionTable[415536] = SetRoomSoundFxLevel_0x295c90; // 0x295cc8 - g_ps2RecompiledFunctionTable[415539] = SetRoomSoundFxLevel_0x295c90; // 0x295cd4 - g_ps2RecompiledFunctionTable[415542] = SetRoomSoundFxLevel_0x295c90; // 0x295ce0 - g_ps2RecompiledFunctionTable[415545] = SetRoomSoundFxLevel_0x295c90; // 0x295cec - g_ps2RecompiledFunctionTable[415548] = SetRoomSoundFxLevel_0x295c90; // 0x295cf8 - g_ps2RecompiledFunctionTable[415551] = SetRoomSoundFxLevel_0x295c90; // 0x295d04 - g_ps2RecompiledFunctionTable[415554] = SetRoomSoundFxLevel_0x295c90; // 0x295d10 - g_ps2RecompiledFunctionTable[415557] = SetRoomSoundFxLevel_0x295c90; // 0x295d1c - g_ps2RecompiledFunctionTable[415560] = SetRoomSoundFxLevel_0x295c90; // 0x295d28 - g_ps2RecompiledFunctionTable[415563] = SetRoomSoundFxLevel_0x295c90; // 0x295d34 - g_ps2RecompiledFunctionTable[415566] = SetRoomSoundFxLevel_0x295c90; // 0x295d40 - g_ps2RecompiledFunctionTable[415569] = SetRoomSoundFxLevel_0x295c90; // 0x295d4c - g_ps2RecompiledFunctionTable[415572] = SetRoomSoundFxLevel_0x295c90; // 0x295d58 - g_ps2RecompiledFunctionTable[415575] = SetRoomSoundFxLevel_0x295c90; // 0x295d64 - g_ps2RecompiledFunctionTable[415578] = SetRoomSoundFxLevel_0x295c90; // 0x295d70 - g_ps2RecompiledFunctionTable[415581] = SetRoomSoundFxLevel_0x295c90; // 0x295d7c - g_ps2RecompiledFunctionTable[415584] = SetRoomSoundFxLevel_0x295c90; // 0x295d88 - g_ps2RecompiledFunctionTable[415587] = SetRoomSoundFxLevel_0x295c90; // 0x295d94 - g_ps2RecompiledFunctionTable[415590] = SetRoomSoundFxLevel_0x295c90; // 0x295da0 - g_ps2RecompiledFunctionTable[415593] = SetRoomSoundFxLevel_0x295c90; // 0x295dac - g_ps2RecompiledFunctionTable[415602] = SetRoomSoundFxLevelEx_0x295dd0; // 0x295dd0 - g_ps2RecompiledFunctionTable[415606] = SearchPlayingEnemySe_0x295de0; // 0x295de0 - g_ps2RecompiledFunctionTable[415609] = SearchPlayingEnemySe_0x295de0; // 0x295dec - g_ps2RecompiledFunctionTable[415630] = SearchFreeEnemySeSlot_0x295e40; // 0x295e40 - g_ps2RecompiledFunctionTable[415633] = SearchFreeEnemySeSlot_0x295e40; // 0x295e4c - g_ps2RecompiledFunctionTable[415646] = CheckPlaySameSe_0x295e80; // 0x295e80 - g_ps2RecompiledFunctionTable[415650] = CheckPlaySameSe_0x295e80; // 0x295e90 - g_ps2RecompiledFunctionTable[415678] = CallEnemySeMain_0x295f00; // 0x295f00 - g_ps2RecompiledFunctionTable[415701] = CallEnemySeMain_0x295f00; // 0x295f5c - g_ps2RecompiledFunctionTable[415714] = CallEnemySeMain_0x295f00; // 0x295f90 - g_ps2RecompiledFunctionTable[415723] = CallEnemySeMain_0x295f00; // 0x295fb4 - g_ps2RecompiledFunctionTable[415743] = CallEnemySeMain_0x295f00; // 0x296004 - g_ps2RecompiledFunctionTable[415753] = CallEnemySeMain_0x295f00; // 0x29602c - g_ps2RecompiledFunctionTable[415762] = RegistEnemySlot_0x296050; // 0x296050 - g_ps2RecompiledFunctionTable[415782] = ResetEnemySeInfo_0x2960a0; // 0x2960a0 - g_ps2RecompiledFunctionTable[415786] = ExecEnemySeManager_0x2960b0; // 0x2960b0 - g_ps2RecompiledFunctionTable[415800] = ExecEnemySeManager_0x2960b0; // 0x2960e8 - g_ps2RecompiledFunctionTable[415802] = ExecEnemySeManager_0x2960b0; // 0x2960f0 - g_ps2RecompiledFunctionTable[415821] = ExecEnemySeManager_0x2960b0; // 0x29613c - g_ps2RecompiledFunctionTable[415851] = ExecEnemySeManager_0x2960b0; // 0x2961b4 - g_ps2RecompiledFunctionTable[415854] = ExecEnemySeManager_0x2960b0; // 0x2961c0 - g_ps2RecompiledFunctionTable[415904] = ExecEnemySeManager_0x2960b0; // 0x296288 - g_ps2RecompiledFunctionTable[415913] = ExecEnemySeManager_0x2960b0; // 0x2962ac - g_ps2RecompiledFunctionTable[415925] = ExecEnemySeManager_0x2960b0; // 0x2962dc - g_ps2RecompiledFunctionTable[415930] = ExecEnemySeManager_0x2960b0; // 0x2962f0 - g_ps2RecompiledFunctionTable[415934] = ExecEnemySeManager_0x2960b0; // 0x296300 - g_ps2RecompiledFunctionTable[415940] = ExecEnemySeManager_0x2960b0; // 0x296318 - g_ps2RecompiledFunctionTable[415947] = ExecEnemySeManager_0x2960b0; // 0x296334 - g_ps2RecompiledFunctionTable[415953] = ExecEnemySeManager_0x2960b0; // 0x29634c - g_ps2RecompiledFunctionTable[415960] = ExecEnemySeManager_0x2960b0; // 0x296368 - g_ps2RecompiledFunctionTable[415969] = ExecEnemySeManager_0x2960b0; // 0x29638c - g_ps2RecompiledFunctionTable[415974] = ExecEnemySeManager_0x2960b0; // 0x2963a0 - g_ps2RecompiledFunctionTable[415978] = ExecEnemySeManager_0x2960b0; // 0x2963b0 - g_ps2RecompiledFunctionTable[415984] = ExecEnemySeManager_0x2960b0; // 0x2963c8 - g_ps2RecompiledFunctionTable[415991] = ExecEnemySeManager_0x2960b0; // 0x2963e4 - g_ps2RecompiledFunctionTable[415997] = ExecEnemySeManager_0x2960b0; // 0x2963fc - g_ps2RecompiledFunctionTable[416004] = ExecEnemySeManager_0x2960b0; // 0x296418 - g_ps2RecompiledFunctionTable[416026] = SearchPlayingObjectSeEx_0x296470; // 0x296470 - g_ps2RecompiledFunctionTable[416032] = SearchPlayingObjectSeEx_0x296470; // 0x296488 - g_ps2RecompiledFunctionTable[416050] = SearchPlayingObjectSe_0x2964d0; // 0x2964d0 - g_ps2RecompiledFunctionTable[416054] = SearchFreeObjectSeSlot_0x2964e0; // 0x2964e0 - g_ps2RecompiledFunctionTable[416060] = SearchFreeObjectSeSlot_0x2964e0; // 0x2964f8 - g_ps2RecompiledFunctionTable[416074] = CallObjectSe2_0x296530; // 0x296530 - g_ps2RecompiledFunctionTable[416122] = CallObjectSe2_0x296530; // 0x2965f0 - g_ps2RecompiledFunctionTable[416132] = CallObjectSe2_0x296530; // 0x296618 - g_ps2RecompiledFunctionTable[416157] = CallObjectSe2_0x296530; // 0x29667c - g_ps2RecompiledFunctionTable[416177] = CallObjectSe2_0x296530; // 0x2966cc - g_ps2RecompiledFunctionTable[416183] = CallObjectSe2_0x296530; // 0x2966e4 - g_ps2RecompiledFunctionTable[416186] = CallObjectSe2_0x296530; // 0x2966f0 - g_ps2RecompiledFunctionTable[416193] = CallObjectSe2_0x296530; // 0x29670c - g_ps2RecompiledFunctionTable[416202] = RegistObjectSlot_0x296730; // 0x296730 - g_ps2RecompiledFunctionTable[416214] = ResetObjectSeInfo_0x296760; // 0x296760 - g_ps2RecompiledFunctionTable[416221] = ResetObjectSeInfo_0x296760; // 0x29677c - g_ps2RecompiledFunctionTable[416226] = ResetObjectSeInfo_0x296760; // 0x296790 - g_ps2RecompiledFunctionTable[416234] = ExecObjectSeManager_0x2967b0; // 0x2967b0 - g_ps2RecompiledFunctionTable[416249] = ExecObjectSeManager_0x2967b0; // 0x2967ec - g_ps2RecompiledFunctionTable[416260] = ExecObjectSeManager_0x2967b0; // 0x296818 - g_ps2RecompiledFunctionTable[416271] = ExecObjectSeManager_0x2967b0; // 0x296844 - g_ps2RecompiledFunctionTable[416283] = ExecObjectSeManager_0x2967b0; // 0x296874 - g_ps2RecompiledFunctionTable[416297] = ExecObjectSeManager_0x2967b0; // 0x2968ac - g_ps2RecompiledFunctionTable[416312] = ExecObjectSeManager_0x2967b0; // 0x2968e8 - g_ps2RecompiledFunctionTable[416318] = ExecObjectSeManager_0x2967b0; // 0x296900 - g_ps2RecompiledFunctionTable[416322] = ExecObjectSeManager_0x2967b0; // 0x296910 - g_ps2RecompiledFunctionTable[416329] = ExecObjectSeManager_0x2967b0; // 0x29692c - g_ps2RecompiledFunctionTable[416333] = ExecObjectSeManager_0x2967b0; // 0x29693c - g_ps2RecompiledFunctionTable[416347] = ExecObjectSeManager_0x2967b0; // 0x296974 - g_ps2RecompiledFunctionTable[416366] = RequestSoundFade_0x2969c0; // 0x2969c0 - g_ps2RecompiledFunctionTable[416382] = RequestSoundFade_0x2969c0; // 0x296a00 - g_ps2RecompiledFunctionTable[416386] = RequestSoundFade_0x2969c0; // 0x296a10 - g_ps2RecompiledFunctionTable[416393] = RequestSoundFade_0x2969c0; // 0x296a2c - g_ps2RecompiledFunctionTable[416397] = RequestSoundFade_0x2969c0; // 0x296a3c - g_ps2RecompiledFunctionTable[416401] = RequestSoundFade_0x2969c0; // 0x296a4c - g_ps2RecompiledFunctionTable[416405] = RequestSoundFade_0x2969c0; // 0x296a5c - g_ps2RecompiledFunctionTable[416409] = RequestSoundFade_0x2969c0; // 0x296a6c - g_ps2RecompiledFunctionTable[416413] = RequestSoundFade_0x2969c0; // 0x296a7c - g_ps2RecompiledFunctionTable[416420] = RequestSoundFade_0x2969c0; // 0x296a98 - g_ps2RecompiledFunctionTable[416427] = RequestSoundFade_0x2969c0; // 0x296ab4 - g_ps2RecompiledFunctionTable[416461] = RequestSoundFade_0x2969c0; // 0x296b3c - g_ps2RecompiledFunctionTable[416468] = RequestSoundFade_0x2969c0; // 0x296b58 - g_ps2RecompiledFunctionTable[416474] = RequestSoundFade_0x2969c0; // 0x296b70 - g_ps2RecompiledFunctionTable[416485] = RequestSoundFade_0x2969c0; // 0x296b9c - g_ps2RecompiledFunctionTable[416489] = RequestSoundFade_0x2969c0; // 0x296bac - g_ps2RecompiledFunctionTable[416506] = RequestSoundFade_0x2969c0; // 0x296bf0 - g_ps2RecompiledFunctionTable[416514] = RequestSoundFade_0x2969c0; // 0x296c10 - g_ps2RecompiledFunctionTable[416526] = RequestAllStopSoundEx_0x296c40; // 0x296c40 - g_ps2RecompiledFunctionTable[416542] = RequestAllStopSoundEx_0x296c40; // 0x296c80 - g_ps2RecompiledFunctionTable[416546] = RequestAllStopSoundEx_0x296c40; // 0x296c90 - g_ps2RecompiledFunctionTable[416553] = RequestAllStopSoundEx_0x296c40; // 0x296cac - g_ps2RecompiledFunctionTable[416573] = RequestAllStopSoundEx_0x296c40; // 0x296cfc - g_ps2RecompiledFunctionTable[416574] = RequestAllStopSoundEx_0x296c40; // 0x296d00 - g_ps2RecompiledFunctionTable[416578] = RequestAllStopSoundEx_0x296c40; // 0x296d10 - g_ps2RecompiledFunctionTable[416580] = RequestAllStopSoundEx_0x296c40; // 0x296d18 - g_ps2RecompiledFunctionTable[416587] = RequestAllStopSoundEx_0x296c40; // 0x296d34 - g_ps2RecompiledFunctionTable[416593] = RequestAllStopSoundEx_0x296c40; // 0x296d4c - g_ps2RecompiledFunctionTable[416597] = RequestAllStopSoundEx_0x296c40; // 0x296d5c - g_ps2RecompiledFunctionTable[416599] = RequestAllStopSoundEx_0x296c40; // 0x296d64 - g_ps2RecompiledFunctionTable[416606] = RequestAllStopSoundEx_0x296c40; // 0x296d80 - g_ps2RecompiledFunctionTable[416616] = RequestAllStopSoundEx_0x296c40; // 0x296da8 - g_ps2RecompiledFunctionTable[416634] = ResetSoundComInfo_0x296df0; // 0x296df0 - g_ps2RecompiledFunctionTable[416638] = Com_ExecRoomFadeIn_0x296e00; // 0x296e00 - g_ps2RecompiledFunctionTable[416657] = Com_ExecRoomFadeIn_0x296e00; // 0x296e4c - g_ps2RecompiledFunctionTable[416668] = Com_ExecRoomFadeIn_0x296e00; // 0x296e78 - g_ps2RecompiledFunctionTable[416677] = Com_ExecRoomFadeIn_0x296e00; // 0x296e9c - g_ps2RecompiledFunctionTable[416685] = Com_ExecRoomFadeIn_0x296e00; // 0x296ebc - g_ps2RecompiledFunctionTable[416694] = Com_ExecRoomFadeIn_0x296e00; // 0x296ee0 - g_ps2RecompiledFunctionTable[416706] = Com_ExecRoomFadeIn_0x296e00; // 0x296f10 - g_ps2RecompiledFunctionTable[416708] = Com_ExecRoomFadeIn_0x296e00; // 0x296f18 - g_ps2RecompiledFunctionTable[416712] = Com_ExecRoomFadeIn_0x296e00; // 0x296f28 - g_ps2RecompiledFunctionTable[416722] = Com_ExecRoomFadeOut_0x296f50; // 0x296f50 - g_ps2RecompiledFunctionTable[416740] = Com_ExecRoomFadeOut_0x296f50; // 0x296f98 - g_ps2RecompiledFunctionTable[416754] = Com_ExecRoomFadeOut_0x296f50; // 0x296fd0 - g_ps2RecompiledFunctionTable[416756] = Com_ExecRoomFadeOut_0x296f50; // 0x296fd8 - g_ps2RecompiledFunctionTable[416762] = Com_ExecCallBgm_And_BgSe_0x296ff0; // 0x296ff0 - g_ps2RecompiledFunctionTable[416766] = Com_StartInitScript_0x297000; // 0x297000 - g_ps2RecompiledFunctionTable[416772] = Com_StartInitScript_0x297000; // 0x297018 - g_ps2RecompiledFunctionTable[416774] = Com_StartInitScript_0x297000; // 0x297020 - g_ps2RecompiledFunctionTable[416776] = Com_StartInitScript_0x297000; // 0x297028 - g_ps2RecompiledFunctionTable[416778] = Com_StartInitScript_0x297000; // 0x297030 - g_ps2RecompiledFunctionTable[416780] = Com_StartInitScript_0x297000; // 0x297038 - g_ps2RecompiledFunctionTable[416782] = Com_StartInitScript_0x297000; // 0x297040 - g_ps2RecompiledFunctionTable[416784] = Com_StartInitScript_0x297000; // 0x297048 - g_ps2RecompiledFunctionTable[416789] = Com_StartInitScript_0x297000; // 0x29705c - g_ps2RecompiledFunctionTable[416794] = Com_StartInitScript_0x297000; // 0x297070 - g_ps2RecompiledFunctionTable[416799] = Com_StartInitScript_0x297000; // 0x297084 - g_ps2RecompiledFunctionTable[416802] = Com_StartInitScript_0x297000; // 0x297090 - g_ps2RecompiledFunctionTable[416806] = Com_FinishInitScript_0x2970a0; // 0x2970a0 - g_ps2RecompiledFunctionTable[416810] = ExecuteSoundCommand_0x2970b0; // 0x2970b0 - g_ps2RecompiledFunctionTable[416811] = ExecuteSoundCommand_0x2970b0; // 0x2970b4 - g_ps2RecompiledFunctionTable[416812] = ExecuteSoundCommand_0x2970b0; // 0x2970b8 - g_ps2RecompiledFunctionTable[416813] = ExecuteSoundCommand_0x2970b0; // 0x2970bc - g_ps2RecompiledFunctionTable[416814] = ExecuteSoundCommand_0x2970b0; // 0x2970c0 - g_ps2RecompiledFunctionTable[416815] = ExecuteSoundCommand_0x2970b0; // 0x2970c4 - g_ps2RecompiledFunctionTable[416816] = ExecuteSoundCommand_0x2970b0; // 0x2970c8 - g_ps2RecompiledFunctionTable[416817] = ExecuteSoundCommand_0x2970b0; // 0x2970cc - g_ps2RecompiledFunctionTable[416818] = ExecuteSoundCommand_0x2970b0; // 0x2970d0 - g_ps2RecompiledFunctionTable[416819] = ExecuteSoundCommand_0x2970b0; // 0x2970d4 - g_ps2RecompiledFunctionTable[416820] = ExecuteSoundCommand_0x2970b0; // 0x2970d8 - g_ps2RecompiledFunctionTable[416821] = ExecuteSoundCommand_0x2970b0; // 0x2970dc - g_ps2RecompiledFunctionTable[416822] = ExecuteSoundCommand_0x2970b0; // 0x2970e0 - g_ps2RecompiledFunctionTable[416823] = ExecuteSoundCommand_0x2970b0; // 0x2970e4 - g_ps2RecompiledFunctionTable[416824] = ExecuteSoundCommand_0x2970b0; // 0x2970e8 - g_ps2RecompiledFunctionTable[416825] = ExecuteSoundCommand_0x2970b0; // 0x2970ec - g_ps2RecompiledFunctionTable[416826] = ExecuteSoundCommand_0x2970b0; // 0x2970f0 - g_ps2RecompiledFunctionTable[416827] = ExecuteSoundCommand_0x2970b0; // 0x2970f4 - g_ps2RecompiledFunctionTable[416828] = ExecuteSoundCommand_0x2970b0; // 0x2970f8 - g_ps2RecompiledFunctionTable[416829] = ExecuteSoundCommand_0x2970b0; // 0x2970fc - g_ps2RecompiledFunctionTable[416830] = ExecuteSoundCommand_0x2970b0; // 0x297100 - g_ps2RecompiledFunctionTable[416831] = ExecuteSoundCommand_0x2970b0; // 0x297104 - g_ps2RecompiledFunctionTable[416832] = ExecuteSoundCommand_0x2970b0; // 0x297108 - g_ps2RecompiledFunctionTable[416833] = ExecuteSoundCommand_0x2970b0; // 0x29710c - g_ps2RecompiledFunctionTable[416834] = ExecuteSoundCommand_0x2970b0; // 0x297110 - g_ps2RecompiledFunctionTable[416835] = ExecuteSoundCommand_0x2970b0; // 0x297114 - g_ps2RecompiledFunctionTable[416836] = ExecuteSoundCommand_0x2970b0; // 0x297118 - g_ps2RecompiledFunctionTable[416837] = ExecuteSoundCommand_0x2970b0; // 0x29711c - g_ps2RecompiledFunctionTable[416838] = ExecuteSoundCommand_0x2970b0; // 0x297120 - g_ps2RecompiledFunctionTable[416839] = ExecuteSoundCommand_0x2970b0; // 0x297124 - g_ps2RecompiledFunctionTable[416840] = ExecuteSoundCommand_0x2970b0; // 0x297128 - g_ps2RecompiledFunctionTable[416841] = ExecuteSoundCommand_0x2970b0; // 0x29712c - g_ps2RecompiledFunctionTable[416842] = ExecuteSoundCommand_0x2970b0; // 0x297130 - g_ps2RecompiledFunctionTable[416843] = ExecuteSoundCommand_0x2970b0; // 0x297134 - g_ps2RecompiledFunctionTable[416846] = SendSoundCommand_0x297140; // 0x297140 - g_ps2RecompiledFunctionTable[416863] = SendSoundCommand_0x297140; // 0x297184 - g_ps2RecompiledFunctionTable[416866] = ExecSoundSystemMonitor_0x297190; // 0x297190 - g_ps2RecompiledFunctionTable[416896] = ExecSoundSystemMonitor_0x297190; // 0x297208 - g_ps2RecompiledFunctionTable[416901] = ExecSoundSystemMonitor_0x297190; // 0x29721c - g_ps2RecompiledFunctionTable[416906] = ExecSoundSystemMonitor_0x297190; // 0x297230 - g_ps2RecompiledFunctionTable[416911] = ExecSoundSystemMonitor_0x297190; // 0x297244 - g_ps2RecompiledFunctionTable[416918] = ExecSoundSystemMonitor_0x297190; // 0x297260 - g_ps2RecompiledFunctionTable[416920] = ExecSoundSystemMonitor_0x297190; // 0x297268 - g_ps2RecompiledFunctionTable[416926] = RequestReadIsoFile_0x297280; // 0x297280 - g_ps2RecompiledFunctionTable[416937] = RequestReadIsoFile_0x297280; // 0x2972ac - g_ps2RecompiledFunctionTable[416946] = RequestReadIsoFile_0x297280; // 0x2972d0 - g_ps2RecompiledFunctionTable[416958] = RequestReadInsideFile_0x297300; // 0x297300 - g_ps2RecompiledFunctionTable[416969] = RequestReadInsideFile_0x297300; // 0x29732c - g_ps2RecompiledFunctionTable[416978] = RequestReadInsideFile_0x297300; // 0x297350 - g_ps2RecompiledFunctionTable[416990] = GetIsoFileSize_0x297380; // 0x297380 - g_ps2RecompiledFunctionTable[416994] = GetInsideFileSize_0x297390; // 0x297390 - g_ps2RecompiledFunctionTable[416999] = GetInsideFileSize_0x297390; // 0x2973a4 - g_ps2RecompiledFunctionTable[417005] = GetInsideFileSize_0x297390; // 0x2973bc - g_ps2RecompiledFunctionTable[417008] = GetInsideFileSize_0x297390; // 0x2973c8 - g_ps2RecompiledFunctionTable[417014] = GetReadFileStatus_0x2973e0; // 0x2973e0 - g_ps2RecompiledFunctionTable[417018] = ExecFileManager_0x2973f0; // 0x2973f0 - g_ps2RecompiledFunctionTable[417022] = ExecFileManager_0x2973f0; // 0x297400 - g_ps2RecompiledFunctionTable[417034] = ExecFileManager_0x2973f0; // 0x297430 - g_ps2RecompiledFunctionTable[417039] = ExecFileManager_0x2973f0; // 0x297444 - g_ps2RecompiledFunctionTable[417053] = ExecFileManager_0x2973f0; // 0x29747c - g_ps2RecompiledFunctionTable[417062] = PlayStartMovieEx_0x2974a0; // 0x2974a0 - g_ps2RecompiledFunctionTable[417119] = PlayStartMovieEx_0x2974a0; // 0x297584 - g_ps2RecompiledFunctionTable[417124] = PlayStartMovieEx_0x2974a0; // 0x297598 - g_ps2RecompiledFunctionTable[417133] = PlayStartMovieEx_0x2974a0; // 0x2975bc - g_ps2RecompiledFunctionTable[417135] = PlayStartMovieEx_0x2974a0; // 0x2975c4 - g_ps2RecompiledFunctionTable[417137] = PlayStartMovieEx_0x2974a0; // 0x2975cc - g_ps2RecompiledFunctionTable[417142] = PlayStartMovieEx_0x2974a0; // 0x2975e0 - g_ps2RecompiledFunctionTable[417149] = PlayStartMovieEx_0x2974a0; // 0x2975fc - g_ps2RecompiledFunctionTable[417217] = PlayStartMovieEx_0x2974a0; // 0x29770c - g_ps2RecompiledFunctionTable[417274] = PlayStartMovieEx_0x2974a0; // 0x2977f0 - g_ps2RecompiledFunctionTable[417302] = PlayStopMovieEx_0x297860; // 0x297860 - g_ps2RecompiledFunctionTable[417312] = PlayStopMovieEx_0x297860; // 0x297888 - g_ps2RecompiledFunctionTable[417315] = PlayStopMovieEx_0x297860; // 0x297894 - g_ps2RecompiledFunctionTable[417318] = PlayStopMovieEx_0x297860; // 0x2978a0 - g_ps2RecompiledFunctionTable[417334] = PlayStopMovie_0x2978e0; // 0x2978e0 - g_ps2RecompiledFunctionTable[417338] = CheckPlayEndMovie_0x2978f0; // 0x2978f0 - g_ps2RecompiledFunctionTable[417342] = GetTimeMoive_0x297900; // 0x297900 - g_ps2RecompiledFunctionTable[417350] = GetTimeMoive_0x297900; // 0x297920 - g_ps2RecompiledFunctionTable[417358] = WaitPrePlayMovie_0x297940; // 0x297940 - g_ps2RecompiledFunctionTable[417370] = WaitPrePlayMovie_0x297940; // 0x297970 - g_ps2RecompiledFunctionTable[417375] = WaitPrePlayMovie_0x297940; // 0x297984 - g_ps2RecompiledFunctionTable[417379] = WaitPrePlayMovie_0x297940; // 0x297994 - g_ps2RecompiledFunctionTable[417401] = WaitPrePlayMovie_0x297940; // 0x2979ec - g_ps2RecompiledFunctionTable[417405] = WaitPrePlayMovie_0x297940; // 0x2979fc - g_ps2RecompiledFunctionTable[417407] = WaitPrePlayMovie_0x297940; // 0x297a04 - g_ps2RecompiledFunctionTable[417412] = WaitPrePlayMovie_0x297940; // 0x297a18 - g_ps2RecompiledFunctionTable[417422] = PlayMovieMain_0x297a40; // 0x297a40 - g_ps2RecompiledFunctionTable[417434] = PlayMovieMain_0x297a40; // 0x297a70 - g_ps2RecompiledFunctionTable[417439] = PlayMovieMain_0x297a40; // 0x297a84 - g_ps2RecompiledFunctionTable[417443] = PlayMovieMain_0x297a40; // 0x297a94 - g_ps2RecompiledFunctionTable[417447] = PlayMovieMain_0x297a40; // 0x297aa4 - g_ps2RecompiledFunctionTable[417471] = PlayMovieMain_0x297a40; // 0x297b04 - g_ps2RecompiledFunctionTable[417486] = PlayMovieMain_0x297a40; // 0x297b40 - g_ps2RecompiledFunctionTable[417498] = PlayMovieMain_0x297a40; // 0x297b70 - g_ps2RecompiledFunctionTable[417502] = PlayMovieMain_0x297a40; // 0x297b80 - g_ps2RecompiledFunctionTable[417514] = PlayMovieMain_0x297a40; // 0x297bb0 - g_ps2RecompiledFunctionTable[417522] = PlayMovieMain_0x297a40; // 0x297bd0 - g_ps2RecompiledFunctionTable[417524] = PlayMovieMain_0x297a40; // 0x297bd8 - g_ps2RecompiledFunctionTable[417526] = PlayMovieMain_0x297a40; // 0x297be0 - g_ps2RecompiledFunctionTable[417530] = PlayMovieMain_0x297a40; // 0x297bf0 - g_ps2RecompiledFunctionTable[417538] = SetEventVibrationMode_0x297c10; // 0x297c10 - g_ps2RecompiledFunctionTable[417542] = StartVibrationBasic_0x297c20; // 0x297c20 - g_ps2RecompiledFunctionTable[417589] = StartVibrationBasic_0x297c20; // 0x297cdc - g_ps2RecompiledFunctionTable[417594] = StartVibrationEx_0x297cf0; // 0x297cf0 - g_ps2RecompiledFunctionTable[417602] = StopVibrationBasic_0x297d10; // 0x297d10 - g_ps2RecompiledFunctionTable[417610] = StopVibrationEx_0x297d30; // 0x297d30 - g_ps2RecompiledFunctionTable[417614] = SetAdjustDisplay_0x297d40; // 0x297d40 - g_ps2RecompiledFunctionTable[417618] = RequestAdjustDisplay_0x297d50; // 0x297d50 - g_ps2RecompiledFunctionTable[417626] = ExecAdjustDisplay_0x297d70; // 0x297d70 - g_ps2RecompiledFunctionTable[417638] = ExecAdjustDisplay_0x297d70; // 0x297da0 - g_ps2RecompiledFunctionTable[417646] = InitPlayLogSystem_0x297dc0; // 0x297dc0 - g_ps2RecompiledFunctionTable[417650] = ExitPlayLogSystem_0x297dd0; // 0x297dd0 - g_ps2RecompiledFunctionTable[417654] = ReadPlayLog_0x297de0; // 0x297de0 - g_ps2RecompiledFunctionTable[417658] = WritePlayLog_0x297df0; // 0x297df0 - g_ps2RecompiledFunctionTable[417662] = InitReadKeyEx_0x297e00; // 0x297e00 - g_ps2RecompiledFunctionTable[417675] = InitReadKeyEx_0x297e00; // 0x297e34 - g_ps2RecompiledFunctionTable[417684] = InitReadKeyEx_0x297e00; // 0x297e58 - g_ps2RecompiledFunctionTable[417708] = InitReadKeyEx_0x297e00; // 0x297eb8 - g_ps2RecompiledFunctionTable[417722] = SetRepeatKeyTimer_0x297ef0; // 0x297ef0 - g_ps2RecompiledFunctionTable[417730] = CheckSoftResetKeyFlag_0x297f10; // 0x297f10 - g_ps2RecompiledFunctionTable[417754] = ClearSoftResetKeyFlag_0x297f70; // 0x297f70 - g_ps2RecompiledFunctionTable[417759] = ClearSoftResetKeyFlag_0x297f70; // 0x297f84 - g_ps2RecompiledFunctionTable[417778] = bhInitMask_0x297fd0; // 0x297fd0 - g_ps2RecompiledFunctionTable[417786] = bhInitMask_0x297fd0; // 0x297ff0 - g_ps2RecompiledFunctionTable[417790] = bhInitMask_0x297fd0; // 0x298000 - g_ps2RecompiledFunctionTable[417794] = bhInitMask_0x297fd0; // 0x298010 - g_ps2RecompiledFunctionTable[417830] = bhInitMask_0x297fd0; // 0x2980a0 - g_ps2RecompiledFunctionTable[417847] = bhInitMask_0x297fd0; // 0x2980e4 - g_ps2RecompiledFunctionTable[417850] = bhInitMask_0x297fd0; // 0x2980f0 - g_ps2RecompiledFunctionTable[417919] = bhInitMask_0x297fd0; // 0x298204 - g_ps2RecompiledFunctionTable[417938] = bhControlMask_0x298250; // 0x298250 - g_ps2RecompiledFunctionTable[418021] = bhControlMask_0x298250; // 0x29839c - g_ps2RecompiledFunctionTable[418054] = bhControlMask_0x298250; // 0x298420 - g_ps2RecompiledFunctionTable[418081] = bhControlMask_0x298250; // 0x29848c - g_ps2RecompiledFunctionTable[418166] = bhControlMask_0x298250; // 0x2985e0 - g_ps2RecompiledFunctionTable[418187] = bhControlMask_0x298250; // 0x298634 - g_ps2RecompiledFunctionTable[418230] = bhSetMask_0x2986e0; // 0x2986e0 - g_ps2RecompiledFunctionTable[418250] = bhSetMask_0x2986e0; // 0x298730 - g_ps2RecompiledFunctionTable[418274] = bhSetLip_0x298790; // 0x298790 - g_ps2RecompiledFunctionTable[418290] = bhSetLip_0x298790; // 0x2987d0 - g_ps2RecompiledFunctionTable[418310] = fmSetLipSyncParam_0x298820; // 0x298820 - g_ps2RecompiledFunctionTable[418396] = fmSetLipSyncParam_0x298820; // 0x298978 - g_ps2RecompiledFunctionTable[418407] = fmSetLipSyncParam_0x298820; // 0x2989a4 - g_ps2RecompiledFunctionTable[418418] = _fmSetObjP_0x2989d0; // 0x2989d0 - g_ps2RecompiledFunctionTable[418433] = _fmSetObjP_0x2989d0; // 0x298a0c - g_ps2RecompiledFunctionTable[418441] = _fmSetObjP_0x2989d0; // 0x298a2c - g_ps2RecompiledFunctionTable[418445] = _fmSetObjP_0x2989d0; // 0x298a3c - g_ps2RecompiledFunctionTable[418448] = _fmSetObjP_0x2989d0; // 0x298a48 - g_ps2RecompiledFunctionTable[418478] = _fmCnkSearchObject_0x298ac0; // 0x298ac0 - g_ps2RecompiledFunctionTable[418488] = _fmCnkSearchObject_0x298ac0; // 0x298ae8 - g_ps2RecompiledFunctionTable[418512] = _fmCnkSearchObject_0x298ac0; // 0x298b48 - g_ps2RecompiledFunctionTable[418542] = _fmGetVChunkType_0x298bc0; // 0x298bc0 - g_ps2RecompiledFunctionTable[418638] = _fmCnkSetFaceObject_0x298d40; // 0x298d40 - g_ps2RecompiledFunctionTable[418651] = _fmCnkSetFaceObject_0x298d40; // 0x298d74 - g_ps2RecompiledFunctionTable[418656] = _fmCnkSetFaceObject_0x298d40; // 0x298d88 - g_ps2RecompiledFunctionTable[418660] = _fmCnkSetFaceObject_0x298d40; // 0x298d98 - g_ps2RecompiledFunctionTable[418670] = _fmCnkSetFaceObject_0x298d40; // 0x298dc0 - g_ps2RecompiledFunctionTable[418683] = _fmCnkSetFaceObject_0x298d40; // 0x298df4 - g_ps2RecompiledFunctionTable[418690] = _fmCnkSetEyeballObject_0x298e10; // 0x298e10 - g_ps2RecompiledFunctionTable[418719] = _fmCnkSetEyeballObject_0x298e10; // 0x298e84 - g_ps2RecompiledFunctionTable[418744] = _fmCnkSetEyeballObject_0x298e10; // 0x298ee8 - g_ps2RecompiledFunctionTable[418762] = _fmCnkSetEyeballObject_0x298e10; // 0x298f30 - g_ps2RecompiledFunctionTable[418764] = _fmCnkSetEyeballObject_0x298e10; // 0x298f38 - g_ps2RecompiledFunctionTable[418766] = _fmCnkSetEyeballObject_0x298e10; // 0x298f40 - g_ps2RecompiledFunctionTable[418767] = _fmCnkSetEyeballObject_0x298e10; // 0x298f44 - g_ps2RecompiledFunctionTable[418771] = _fmCnkSetEyeballObject_0x298e10; // 0x298f54 - g_ps2RecompiledFunctionTable[418781] = _fmCnkSetEyeballObject_0x298e10; // 0x298f7c - g_ps2RecompiledFunctionTable[418786] = _fmCnkSetEyeballObject_0x298e10; // 0x298f90 - g_ps2RecompiledFunctionTable[418791] = _fmCnkSetEyeballObject_0x298e10; // 0x298fa4 - g_ps2RecompiledFunctionTable[418797] = _fmCnkSetEyeballObject_0x298e10; // 0x298fbc - g_ps2RecompiledFunctionTable[418808] = _fmCnkSetEyeballObject_0x298e10; // 0x298fe8 - g_ps2RecompiledFunctionTable[418816] = _fmCnkSetEyeballObject_0x298e10; // 0x299008 - g_ps2RecompiledFunctionTable[418826] = _fmCnkSetTangObject_0x299030; // 0x299030 - g_ps2RecompiledFunctionTable[418838] = _fmCnkSetTangObject_0x299030; // 0x299060 - g_ps2RecompiledFunctionTable[418843] = _fmCnkSetTangObject_0x299030; // 0x299074 - g_ps2RecompiledFunctionTable[418855] = _fmCnkSetTangObject_0x299030; // 0x2990a4 - g_ps2RecompiledFunctionTable[418870] = _fmCnkSetTangObject_0x299030; // 0x2990e0 - g_ps2RecompiledFunctionTable[418882] = _fmCnkSetTangObject_0x299030; // 0x299110 - g_ps2RecompiledFunctionTable[418904] = _fmCnkSetTangObject_0x299030; // 0x299168 - g_ps2RecompiledFunctionTable[418922] = _fmCnkSetToothObject_0x2991b0; // 0x2991b0 - g_ps2RecompiledFunctionTable[418932] = _fmCnkSetToothObject_0x2991b0; // 0x2991d8 - g_ps2RecompiledFunctionTable[418954] = _fmCnkSetToothObject_0x2991b0; // 0x299230 - g_ps2RecompiledFunctionTable[418974] = _fmCnkSetJaw_0x299280; // 0x299280 - g_ps2RecompiledFunctionTable[419016] = _fmCnkSetJaw_0x299280; // 0x299328 - g_ps2RecompiledFunctionTable[419021] = _fmCnkSetJaw_0x299280; // 0x29933c - g_ps2RecompiledFunctionTable[419025] = _fmCnkSetJaw_0x299280; // 0x29934c - g_ps2RecompiledFunctionTable[419027] = _fmCnkSetJaw_0x299280; // 0x299354 - g_ps2RecompiledFunctionTable[419032] = _fmCnkSetJaw_0x299280; // 0x299368 - g_ps2RecompiledFunctionTable[419034] = _fmCnkSetJaw_0x299280; // 0x299370 - g_ps2RecompiledFunctionTable[419036] = _fmCnkSetJaw_0x299280; // 0x299378 - g_ps2RecompiledFunctionTable[419039] = _fmCnkSetJaw_0x299280; // 0x299384 - g_ps2RecompiledFunctionTable[419042] = _fmCnkSetJaw_0x299280; // 0x299390 - g_ps2RecompiledFunctionTable[419050] = _fmCnkSetJaw_0x299280; // 0x2993b0 - g_ps2RecompiledFunctionTable[419052] = _fmCnkSetJaw_0x299280; // 0x2993b8 - g_ps2RecompiledFunctionTable[419057] = _fmCnkSetJaw_0x299280; // 0x2993cc - g_ps2RecompiledFunctionTable[419060] = _fmCnkSetJaw_0x299280; // 0x2993d8 - g_ps2RecompiledFunctionTable[419063] = _fmCnkSetJaw_0x299280; // 0x2993e4 - g_ps2RecompiledFunctionTable[419065] = _fmCnkSetJaw_0x299280; // 0x2993ec - g_ps2RecompiledFunctionTable[419090] = fmCnkInitContext_0x299450; // 0x299450 - g_ps2RecompiledFunctionTable[419103] = fmCnkInitContext_0x299450; // 0x299484 - g_ps2RecompiledFunctionTable[419109] = fmCnkInitContext_0x299450; // 0x29949c - g_ps2RecompiledFunctionTable[419112] = fmCnkInitContext_0x299450; // 0x2994a8 - g_ps2RecompiledFunctionTable[419117] = fmCnkInitContext_0x299450; // 0x2994bc - g_ps2RecompiledFunctionTable[419122] = fmCnkInitContext_0x299450; // 0x2994d0 - g_ps2RecompiledFunctionTable[419130] = fmCnkInitContext_0x299450; // 0x2994f0 - g_ps2RecompiledFunctionTable[419135] = fmCnkInitContext_0x299450; // 0x299504 - g_ps2RecompiledFunctionTable[419139] = fmCnkInitContext_0x299450; // 0x299514 - g_ps2RecompiledFunctionTable[419145] = fmCnkInitContext_0x299450; // 0x29952c - g_ps2RecompiledFunctionTable[419152] = fmCnkInitContext_0x299450; // 0x299548 - g_ps2RecompiledFunctionTable[419179] = fmCnkInitContext_0x299450; // 0x2995b4 - g_ps2RecompiledFunctionTable[419181] = fmCnkInitContext_0x299450; // 0x2995bc - g_ps2RecompiledFunctionTable[419238] = fmCnkInitContext_0x299450; // 0x2996a0 - g_ps2RecompiledFunctionTable[419240] = fmCnkInitContext_0x299450; // 0x2996a8 - g_ps2RecompiledFunctionTable[419250] = fmCnkSetParam_0x2996d0; // 0x2996d0 - g_ps2RecompiledFunctionTable[419254] = fmCnkSetParamLip_0x2996e0; // 0x2996e0 - g_ps2RecompiledFunctionTable[419258] = fmCnkSetParamLip_0x2996e0; // 0x2996f0 - g_ps2RecompiledFunctionTable[419290] = fmCnkSetInterParam_0x299770; // 0x299770 - g_ps2RecompiledFunctionTable[419321] = fmCnkSetInterParam_0x299770; // 0x2997ec - g_ps2RecompiledFunctionTable[419326] = fmCnkSetInterParam_0x299770; // 0x299800 - g_ps2RecompiledFunctionTable[419328] = fmCnkSetInterParam_0x299770; // 0x299808 - g_ps2RecompiledFunctionTable[419340] = fmCnkSetInterParam_0x299770; // 0x299838 - g_ps2RecompiledFunctionTable[419422] = fmCnkSetInterParamLip_0x299980; // 0x299980 - g_ps2RecompiledFunctionTable[419453] = fmCnkSetInterParamLip_0x299980; // 0x2999fc - g_ps2RecompiledFunctionTable[419458] = fmCnkSetInterParamLip_0x299980; // 0x299a10 - g_ps2RecompiledFunctionTable[419460] = fmCnkSetInterParamLip_0x299980; // 0x299a18 - g_ps2RecompiledFunctionTable[419472] = fmCnkSetInterParamLip_0x299980; // 0x299a48 - g_ps2RecompiledFunctionTable[419554] = fmCnkSetCurrentFrame_0x299b90; // 0x299b90 - g_ps2RecompiledFunctionTable[419568] = fmCnkSetCurrentFrame_0x299b90; // 0x299bc8 - g_ps2RecompiledFunctionTable[419573] = fmCnkSetCurrentFrame_0x299b90; // 0x299bdc - g_ps2RecompiledFunctionTable[419587] = fmCnkSetCurrentFrame_0x299b90; // 0x299c14 - g_ps2RecompiledFunctionTable[419601] = fmCnkSetCurrentFrame_0x299b90; // 0x299c4c - g_ps2RecompiledFunctionTable[419636] = fmCnkSetCurrentFrame_0x299b90; // 0x299cd8 - g_ps2RecompiledFunctionTable[419646] = fmCnkGetLastFrame_0x299d00; // 0x299d00 - g_ps2RecompiledFunctionTable[419658] = _fmCnkCalcMuscle_0x299d30; // 0x299d30 - g_ps2RecompiledFunctionTable[419681] = _fmCnkCalcMuscle_0x299d30; // 0x299d8c - g_ps2RecompiledFunctionTable[419701] = _fmCnkCalcMuscle_0x299d30; // 0x299ddc - g_ps2RecompiledFunctionTable[419715] = _fmCnkCalcMuscle_0x299d30; // 0x299e14 - g_ps2RecompiledFunctionTable[419774] = _fmCnkCalcMuscle_0x299d30; // 0x299f00 - g_ps2RecompiledFunctionTable[419802] = _fmCnkCalcJaw_0x299f70; // 0x299f70 - g_ps2RecompiledFunctionTable[419828] = _fmCnkCalcJaw_0x299f70; // 0x299fd8 - g_ps2RecompiledFunctionTable[419833] = _fmCnkCalcJaw_0x299f70; // 0x299fec - g_ps2RecompiledFunctionTable[419836] = _fmCnkCalcJaw_0x299f70; // 0x299ff8 - g_ps2RecompiledFunctionTable[419841] = _fmCnkCalcJaw_0x299f70; // 0x29a00c - g_ps2RecompiledFunctionTable[419844] = _fmCnkCalcJaw_0x299f70; // 0x29a018 - g_ps2RecompiledFunctionTable[419854] = _fmCnkCalcJaw_0x299f70; // 0x29a040 - g_ps2RecompiledFunctionTable[419888] = _fmCnkCalcJaw_0x299f70; // 0x29a0c8 - g_ps2RecompiledFunctionTable[419896] = _fmCnkCalcJaw_0x299f70; // 0x29a0e8 - g_ps2RecompiledFunctionTable[419899] = _fmCnkCalcJaw_0x299f70; // 0x29a0f4 - g_ps2RecompiledFunctionTable[419958] = _fmCnkCalcJaw_0x299f70; // 0x29a1e0 - g_ps2RecompiledFunctionTable[419969] = _fmCnkCalcJaw_0x299f70; // 0x29a20c - g_ps2RecompiledFunctionTable[419986] = _fmCnkCalcEye_0x29a250; // 0x29a250 - g_ps2RecompiledFunctionTable[420002] = _fmCnkCalcEye_0x29a250; // 0x29a290 - g_ps2RecompiledFunctionTable[420008] = _fmCnkCalcEye_0x29a250; // 0x29a2a8 - g_ps2RecompiledFunctionTable[420066] = _fmCnkCalcEye_0x29a250; // 0x29a390 - g_ps2RecompiledFunctionTable[420068] = _fmCnkCalcEye_0x29a250; // 0x29a398 - g_ps2RecompiledFunctionTable[420073] = _fmCnkCalcEye_0x29a250; // 0x29a3ac - g_ps2RecompiledFunctionTable[420078] = _fmCnkCalcEye_0x29a250; // 0x29a3c0 - g_ps2RecompiledFunctionTable[420080] = _fmCnkCalcEye_0x29a250; // 0x29a3c8 - g_ps2RecompiledFunctionTable[420085] = _fmCnkCalcEye_0x29a250; // 0x29a3dc - g_ps2RecompiledFunctionTable[420101] = _fmCnkCalcEye_0x29a250; // 0x29a41c - g_ps2RecompiledFunctionTable[420106] = _fmCnkCalcEye_0x29a250; // 0x29a430 - g_ps2RecompiledFunctionTable[420115] = _fmCnkCalcEye_0x29a250; // 0x29a454 - g_ps2RecompiledFunctionTable[420120] = _fmCnkCalcEye_0x29a250; // 0x29a468 - g_ps2RecompiledFunctionTable[420127] = _fmCnkCalcEye_0x29a250; // 0x29a484 - g_ps2RecompiledFunctionTable[420142] = _fmCnkCalcTang_0x29a4c0; // 0x29a4c0 - g_ps2RecompiledFunctionTable[420170] = _fmCnkCalcTang_0x29a4c0; // 0x29a530 - g_ps2RecompiledFunctionTable[420186] = _fmCnkCalcTang_0x29a4c0; // 0x29a570 - g_ps2RecompiledFunctionTable[420189] = _fmCnkCalcTang_0x29a4c0; // 0x29a57c - g_ps2RecompiledFunctionTable[420197] = _fmCnkCalcTang_0x29a4c0; // 0x29a59c - g_ps2RecompiledFunctionTable[420200] = _fmCnkCalcTang_0x29a4c0; // 0x29a5a8 - g_ps2RecompiledFunctionTable[420242] = _fmCnkCalcNormal_0x29a650; // 0x29a650 - g_ps2RecompiledFunctionTable[420268] = _fmCnkCalcNormal_0x29a650; // 0x29a6b8 - g_ps2RecompiledFunctionTable[420279] = _fmCnkCalcNormal_0x29a650; // 0x29a6e4 - g_ps2RecompiledFunctionTable[420284] = _fmCnkCalcNormal_0x29a650; // 0x29a6f8 - g_ps2RecompiledFunctionTable[420286] = _fmCnkCalcNormal_0x29a650; // 0x29a700 - g_ps2RecompiledFunctionTable[420307] = _fmCnkCalcNormal_0x29a650; // 0x29a754 - g_ps2RecompiledFunctionTable[420326] = fmCnkCalcFace_0x29a7a0; // 0x29a7a0 - g_ps2RecompiledFunctionTable[420334] = fmCnkCalcFace_0x29a7a0; // 0x29a7c0 - g_ps2RecompiledFunctionTable[420336] = fmCnkCalcFace_0x29a7a0; // 0x29a7c8 - g_ps2RecompiledFunctionTable[420338] = fmCnkCalcFace_0x29a7a0; // 0x29a7d0 - g_ps2RecompiledFunctionTable[420340] = fmCnkCalcFace_0x29a7a0; // 0x29a7d8 - g_ps2RecompiledFunctionTable[420346] = fmCnkCalcFace_0x29a7a0; // 0x29a7f0 - g_ps2RecompiledFunctionTable[420350] = fmCnkSetMode_0x29a800; // 0x29a800 - g_ps2RecompiledFunctionTable[420369] = fmCnkSetMode_0x29a800; // 0x29a84c - g_ps2RecompiledFunctionTable[420378] = Ps2ZbuffOffI_0x29a870; // 0x29a870 - g_ps2RecompiledFunctionTable[420382] = Ps2ZbuffOffI_0x29a870; // 0x29a880 - g_ps2RecompiledFunctionTable[420406] = Ps2ZbuffOffI_0x29a870; // 0x29a8e0 - g_ps2RecompiledFunctionTable[420408] = Ps2ZbuffOffI_0x29a870; // 0x29a8e8 - g_ps2RecompiledFunctionTable[420414] = Ps2DrawOTagI_0x29a900; // 0x29a900 - g_ps2RecompiledFunctionTable[420418] = Ps2DrawOTagI_0x29a900; // 0x29a910 - g_ps2RecompiledFunctionTable[420419] = Ps2DrawOTagI_0x29a900; // 0x29a914 - g_ps2RecompiledFunctionTable[420421] = Ps2DrawOTagI_0x29a900; // 0x29a91c - g_ps2RecompiledFunctionTable[420429] = Ps2DrawOTagI_0x29a900; // 0x29a93c - g_ps2RecompiledFunctionTable[420431] = Ps2DrawOTagI_0x29a900; // 0x29a944 - g_ps2RecompiledFunctionTable[420432] = Ps2DrawOTagI_0x29a900; // 0x29a948 - g_ps2RecompiledFunctionTable[420434] = Ps2DrawOTagI_0x29a900; // 0x29a950 - g_ps2RecompiledFunctionTable[420442] = Ps2DrawOTagI_0x29a900; // 0x29a970 - g_ps2RecompiledFunctionTable[420450] = StatusInit_0x29a990; // 0x29a990 - g_ps2RecompiledFunctionTable[420457] = StatusInit_0x29a990; // 0x29a9ac - g_ps2RecompiledFunctionTable[420463] = StatusInit_0x29a990; // 0x29a9c4 - g_ps2RecompiledFunctionTable[420491] = StatusInit_0x29a990; // 0x29aa34 - g_ps2RecompiledFunctionTable[420511] = StatusInit_0x29a990; // 0x29aa84 - g_ps2RecompiledFunctionTable[420612] = StatusInit_0x29a990; // 0x29ac18 - g_ps2RecompiledFunctionTable[420631] = StatusInit_0x29a990; // 0x29ac64 - g_ps2RecompiledFunctionTable[420660] = StatusInit_0x29a990; // 0x29acd8 - g_ps2RecompiledFunctionTable[420662] = StatusInit_0x29a990; // 0x29ace0 - g_ps2RecompiledFunctionTable[420688] = StatusInit_0x29a990; // 0x29ad48 - g_ps2RecompiledFunctionTable[420709] = StatusInit_0x29a990; // 0x29ad9c - g_ps2RecompiledFunctionTable[420728] = StatusInit_0x29a990; // 0x29ade8 - g_ps2RecompiledFunctionTable[420738] = StatusInit_0x29a990; // 0x29ae10 - g_ps2RecompiledFunctionTable[420741] = StatusInit_0x29a990; // 0x29ae1c - g_ps2RecompiledFunctionTable[420748] = StatusInit_0x29a990; // 0x29ae38 - g_ps2RecompiledFunctionTable[420773] = StatusInit_0x29a990; // 0x29ae9c - g_ps2RecompiledFunctionTable[420806] = ItemBoxInit_0x29af20; // 0x29af20 - g_ps2RecompiledFunctionTable[420817] = ItemBoxInit_0x29af20; // 0x29af4c - g_ps2RecompiledFunctionTable[420846] = ItemBoxInit_0x29af20; // 0x29afc0 - g_ps2RecompiledFunctionTable[420848] = ItemBoxInit_0x29af20; // 0x29afc8 - g_ps2RecompiledFunctionTable[420869] = ItemBoxInit_0x29af20; // 0x29b01c - g_ps2RecompiledFunctionTable[420881] = ItemBoxInit_0x29af20; // 0x29b04c - g_ps2RecompiledFunctionTable[420894] = ItemBoxInit_0x29af20; // 0x29b080 - g_ps2RecompiledFunctionTable[420911] = ItemBoxInit_0x29af20; // 0x29b0c4 - g_ps2RecompiledFunctionTable[420923] = ItemBoxInit_0x29af20; // 0x29b0f4 - g_ps2RecompiledFunctionTable[420973] = ItemBoxInit_0x29af20; // 0x29b1bc - g_ps2RecompiledFunctionTable[420989] = ItemBoxInit_0x29af20; // 0x29b1fc - g_ps2RecompiledFunctionTable[421014] = CursorMove_0x29b260; // 0x29b260 - g_ps2RecompiledFunctionTable[421046] = CursorMove_0x29b260; // 0x29b2e0 - g_ps2RecompiledFunctionTable[421167] = CursorMove_0x29b260; // 0x29b4c4 - g_ps2RecompiledFunctionTable[421200] = CursorMove_0x29b260; // 0x29b548 - g_ps2RecompiledFunctionTable[421240] = CursorMove_0x29b260; // 0x29b5e8 - g_ps2RecompiledFunctionTable[421286] = CursorMove_0x29b260; // 0x29b6a0 - g_ps2RecompiledFunctionTable[421320] = CursorMove_0x29b260; // 0x29b728 - g_ps2RecompiledFunctionTable[421349] = CursorMove_0x29b260; // 0x29b79c - g_ps2RecompiledFunctionTable[421382] = CursorMove_0x29b260; // 0x29b820 - g_ps2RecompiledFunctionTable[421398] = CursorMove_0x29b260; // 0x29b860 - g_ps2RecompiledFunctionTable[421408] = CursorMove_0x29b260; // 0x29b888 - g_ps2RecompiledFunctionTable[421411] = CursorMove_0x29b260; // 0x29b894 - g_ps2RecompiledFunctionTable[421422] = CursorSet_0x29b8c0; // 0x29b8c0 - g_ps2RecompiledFunctionTable[421774] = SpriteSet2D_0x29be40; // 0x29be40 - g_ps2RecompiledFunctionTable[421828] = SpriteSet2D_0x29be40; // 0x29bf18 - g_ps2RecompiledFunctionTable[421832] = SpriteSet2D_0x29be40; // 0x29bf28 - g_ps2RecompiledFunctionTable[421835] = SpriteSet2D_0x29be40; // 0x29bf34 - g_ps2RecompiledFunctionTable[421867] = SpriteSet2D_0x29be40; // 0x29bfb4 - g_ps2RecompiledFunctionTable[421874] = ItemSort_0x29bfd0; // 0x29bfd0 - g_ps2RecompiledFunctionTable[421881] = ItemSort_0x29bfd0; // 0x29bfec - g_ps2RecompiledFunctionTable[421897] = ItemSort_0x29bfd0; // 0x29c02c - g_ps2RecompiledFunctionTable[421934] = ItemSort_0x29bfd0; // 0x29c0c0 - g_ps2RecompiledFunctionTable[421982] = ItemSort_0x29bfd0; // 0x29c180 - g_ps2RecompiledFunctionTable[421994] = ItemSort_0x29bfd0; // 0x29c1b0 - g_ps2RecompiledFunctionTable[422022] = ItemSet_0x29c220; // 0x29c220 - g_ps2RecompiledFunctionTable[422052] = ItemSet_0x29c220; // 0x29c298 - g_ps2RecompiledFunctionTable[422358] = KazuSet_0x29c760; // 0x29c760 - g_ps2RecompiledFunctionTable[422425] = KazuSet_0x29c760; // 0x29c86c - g_ps2RecompiledFunctionTable[422489] = KazuSet_0x29c760; // 0x29c96c - g_ps2RecompiledFunctionTable[422496] = KazuSet_0x29c760; // 0x29c988 - g_ps2RecompiledFunctionTable[422518] = ItemUse_0x29c9e0; // 0x29c9e0 - g_ps2RecompiledFunctionTable[422576] = ItemUse_0x29c9e0; // 0x29cac8 - g_ps2RecompiledFunctionTable[422581] = ItemUse_0x29c9e0; // 0x29cadc - g_ps2RecompiledFunctionTable[422586] = ItemUse_0x29c9e0; // 0x29caf0 - g_ps2RecompiledFunctionTable[422591] = ItemUse_0x29c9e0; // 0x29cb04 - g_ps2RecompiledFunctionTable[422596] = ItemUse_0x29c9e0; // 0x29cb18 - g_ps2RecompiledFunctionTable[422602] = ItemUse_0x29c9e0; // 0x29cb30 - g_ps2RecompiledFunctionTable[422650] = SpriteH_0x29cbf0; // 0x29cbf0 - g_ps2RecompiledFunctionTable[422673] = SpriteH_0x29cbf0; // 0x29cc4c - g_ps2RecompiledFunctionTable[422712] = SpriteH_0x29cbf0; // 0x29cce8 - g_ps2RecompiledFunctionTable[422910] = SpriteUV_0x29d000; // 0x29d000 - g_ps2RecompiledFunctionTable[423076] = SpriteUV_0x29d000; // 0x29d298 - g_ps2RecompiledFunctionTable[423194] = BGFadeIn_0x29d470; // 0x29d470 - g_ps2RecompiledFunctionTable[423206] = BGFadeIn_0x29d470; // 0x29d4a0 - g_ps2RecompiledFunctionTable[423226] = BGFadeOut_0x29d4f0; // 0x29d4f0 - g_ps2RecompiledFunctionTable[423238] = BGFadeOut_0x29d4f0; // 0x29d520 - g_ps2RecompiledFunctionTable[423258] = ItemTaskCheck_0x29d570; // 0x29d570 - g_ps2RecompiledFunctionTable[423275] = ItemTaskCheck_0x29d570; // 0x29d5b4 - g_ps2RecompiledFunctionTable[423304] = ItemTaskCheck_0x29d570; // 0x29d628 - g_ps2RecompiledFunctionTable[423308] = ItemTaskCheck_0x29d570; // 0x29d638 - g_ps2RecompiledFunctionTable[423358] = ItemTaskCheck_0x29d570; // 0x29d700 - g_ps2RecompiledFunctionTable[423463] = ItemTaskCheck_0x29d570; // 0x29d8a4 - g_ps2RecompiledFunctionTable[423473] = ItemTaskCheck_0x29d570; // 0x29d8cc - g_ps2RecompiledFunctionTable[423611] = ItemTaskCheck_0x29d570; // 0x29daf4 - g_ps2RecompiledFunctionTable[423624] = ItemTaskCheck_0x29d570; // 0x29db28 - g_ps2RecompiledFunctionTable[423626] = ItemTaskCheck_0x29d570; // 0x29db30 - g_ps2RecompiledFunctionTable[423659] = ItemTaskCheck_0x29d570; // 0x29dbb4 - g_ps2RecompiledFunctionTable[423668] = ItemTaskCheck_0x29d570; // 0x29dbd8 - g_ps2RecompiledFunctionTable[423683] = ItemTaskCheck_0x29d570; // 0x29dc14 - g_ps2RecompiledFunctionTable[423690] = ItemTaskCheck_0x29d570; // 0x29dc30 - g_ps2RecompiledFunctionTable[423700] = ItemTaskCheck_0x29d570; // 0x29dc58 - g_ps2RecompiledFunctionTable[423708] = ItemTaskCheck_0x29d570; // 0x29dc78 - g_ps2RecompiledFunctionTable[423710] = ItemTaskCheck_0x29d570; // 0x29dc80 - g_ps2RecompiledFunctionTable[423740] = ItemTaskCheck_0x29d570; // 0x29dcf8 - g_ps2RecompiledFunctionTable[423755] = ItemTaskCheck_0x29d570; // 0x29dd34 - g_ps2RecompiledFunctionTable[423758] = ItemTaskCheck_0x29d570; // 0x29dd40 - g_ps2RecompiledFunctionTable[423766] = StatusMain_0x29dd60; // 0x29dd60 - g_ps2RecompiledFunctionTable[423815] = StatusMain_0x29dd60; // 0x29de24 - g_ps2RecompiledFunctionTable[423828] = StatusMain_0x29dd60; // 0x29de58 - g_ps2RecompiledFunctionTable[423852] = StatusMain_0x29dd60; // 0x29deb8 - g_ps2RecompiledFunctionTable[423877] = StatusMain_0x29dd60; // 0x29df1c - g_ps2RecompiledFunctionTable[423879] = StatusMain_0x29dd60; // 0x29df24 - g_ps2RecompiledFunctionTable[423893] = StatusMain_0x29dd60; // 0x29df5c - g_ps2RecompiledFunctionTable[423978] = StatusMain_0x29dd60; // 0x29e0b0 - g_ps2RecompiledFunctionTable[423989] = StatusMain_0x29dd60; // 0x29e0dc - g_ps2RecompiledFunctionTable[424009] = StatusMain_0x29dd60; // 0x29e12c - g_ps2RecompiledFunctionTable[424020] = StatusMain_0x29dd60; // 0x29e158 - g_ps2RecompiledFunctionTable[424026] = StatusMain_0x29dd60; // 0x29e170 - g_ps2RecompiledFunctionTable[424039] = StatusMain_0x29dd60; // 0x29e1a4 - g_ps2RecompiledFunctionTable[424041] = StatusMain_0x29dd60; // 0x29e1ac - g_ps2RecompiledFunctionTable[424065] = StatusMain_0x29dd60; // 0x29e20c - g_ps2RecompiledFunctionTable[424070] = StatusMain_0x29dd60; // 0x29e220 - g_ps2RecompiledFunctionTable[424075] = StatusMain_0x29dd60; // 0x29e234 - g_ps2RecompiledFunctionTable[424084] = StatusMain_0x29dd60; // 0x29e258 - g_ps2RecompiledFunctionTable[424087] = StatusMain_0x29dd60; // 0x29e264 - g_ps2RecompiledFunctionTable[424089] = StatusMain_0x29dd60; // 0x29e26c - g_ps2RecompiledFunctionTable[424106] = StatusMain_0x29dd60; // 0x29e2b0 - g_ps2RecompiledFunctionTable[424108] = StatusMain_0x29dd60; // 0x29e2b8 - g_ps2RecompiledFunctionTable[424115] = StatusMain_0x29dd60; // 0x29e2d4 - g_ps2RecompiledFunctionTable[424120] = StatusMain_0x29dd60; // 0x29e2e8 - g_ps2RecompiledFunctionTable[424122] = StatusMain_0x29dd60; // 0x29e2f0 - g_ps2RecompiledFunctionTable[424136] = StatusMain_0x29dd60; // 0x29e328 - g_ps2RecompiledFunctionTable[424138] = StatusMain_0x29dd60; // 0x29e330 - g_ps2RecompiledFunctionTable[424143] = StatusMain_0x29dd60; // 0x29e344 - g_ps2RecompiledFunctionTable[424151] = StatusMain_0x29dd60; // 0x29e364 - g_ps2RecompiledFunctionTable[424161] = StatusMain_0x29dd60; // 0x29e38c - g_ps2RecompiledFunctionTable[424164] = StatusMain_0x29dd60; // 0x29e398 - g_ps2RecompiledFunctionTable[424166] = StatusMain_0x29dd60; // 0x29e3a0 - g_ps2RecompiledFunctionTable[424194] = StatusMain_0x29dd60; // 0x29e410 - g_ps2RecompiledFunctionTable[424200] = StatusMain_0x29dd60; // 0x29e428 - g_ps2RecompiledFunctionTable[424202] = StatusMain_0x29dd60; // 0x29e430 - g_ps2RecompiledFunctionTable[424204] = StatusMain_0x29dd60; // 0x29e438 - g_ps2RecompiledFunctionTable[424214] = StatusMain_0x29dd60; // 0x29e460 - g_ps2RecompiledFunctionTable[424224] = StatusMain_0x29dd60; // 0x29e488 - g_ps2RecompiledFunctionTable[424226] = StatusMain_0x29dd60; // 0x29e490 - g_ps2RecompiledFunctionTable[424233] = StatusMain_0x29dd60; // 0x29e4ac - g_ps2RecompiledFunctionTable[424249] = StatusMain_0x29dd60; // 0x29e4ec - g_ps2RecompiledFunctionTable[424289] = StatusMain_0x29dd60; // 0x29e58c - g_ps2RecompiledFunctionTable[424291] = StatusMain_0x29dd60; // 0x29e594 - g_ps2RecompiledFunctionTable[424293] = StatusMain_0x29dd60; // 0x29e59c - g_ps2RecompiledFunctionTable[424295] = StatusMain_0x29dd60; // 0x29e5a4 - g_ps2RecompiledFunctionTable[424298] = StatusMain_0x29dd60; // 0x29e5b0 - g_ps2RecompiledFunctionTable[424302] = StatusMain_0x29dd60; // 0x29e5c0 - g_ps2RecompiledFunctionTable[424309] = StatusMain_0x29dd60; // 0x29e5dc - g_ps2RecompiledFunctionTable[424315] = StatusMain_0x29dd60; // 0x29e5f4 - g_ps2RecompiledFunctionTable[424319] = StatusMain_0x29dd60; // 0x29e604 - g_ps2RecompiledFunctionTable[424321] = StatusMain_0x29dd60; // 0x29e60c - g_ps2RecompiledFunctionTable[424323] = StatusMain_0x29dd60; // 0x29e614 - g_ps2RecompiledFunctionTable[424326] = StatusMain_0x29dd60; // 0x29e620 - g_ps2RecompiledFunctionTable[424335] = StatusMain_0x29dd60; // 0x29e644 - g_ps2RecompiledFunctionTable[424338] = StatusMain_0x29dd60; // 0x29e650 - g_ps2RecompiledFunctionTable[424347] = StatusMain_0x29dd60; // 0x29e674 - g_ps2RecompiledFunctionTable[424357] = StatusMain_0x29dd60; // 0x29e69c - g_ps2RecompiledFunctionTable[424408] = StatusMain_0x29dd60; // 0x29e768 - g_ps2RecompiledFunctionTable[424448] = StatusMain_0x29dd60; // 0x29e808 - g_ps2RecompiledFunctionTable[424506] = StatusMain_0x29dd60; // 0x29e8f0 - g_ps2RecompiledFunctionTable[424511] = StatusMain_0x29dd60; // 0x29e904 - g_ps2RecompiledFunctionTable[424516] = StatusMain_0x29dd60; // 0x29e918 - g_ps2RecompiledFunctionTable[424521] = StatusMain_0x29dd60; // 0x29e92c - g_ps2RecompiledFunctionTable[424532] = StatusMain_0x29dd60; // 0x29e958 - g_ps2RecompiledFunctionTable[424571] = StatusMain_0x29dd60; // 0x29e9f4 - g_ps2RecompiledFunctionTable[424586] = StatusMain_0x29dd60; // 0x29ea30 - g_ps2RecompiledFunctionTable[424591] = StatusMain_0x29dd60; // 0x29ea44 - g_ps2RecompiledFunctionTable[424598] = StatusMain_0x29dd60; // 0x29ea60 - g_ps2RecompiledFunctionTable[424603] = StatusMain_0x29dd60; // 0x29ea74 - g_ps2RecompiledFunctionTable[424617] = StatusMain_0x29dd60; // 0x29eaac - g_ps2RecompiledFunctionTable[424622] = StatusMain_0x29dd60; // 0x29eac0 - g_ps2RecompiledFunctionTable[424625] = StatusMain_0x29dd60; // 0x29eacc - g_ps2RecompiledFunctionTable[424630] = StatusMain_0x29dd60; // 0x29eae0 - g_ps2RecompiledFunctionTable[424690] = GetItem_0x29ebd0; // 0x29ebd0 - g_ps2RecompiledFunctionTable[424742] = GetItem_0x29ebd0; // 0x29eca0 - g_ps2RecompiledFunctionTable[424926] = GetItem_0x29ebd0; // 0x29ef80 - g_ps2RecompiledFunctionTable[424936] = GetItem_0x29ebd0; // 0x29efa8 - g_ps2RecompiledFunctionTable[424943] = GetItem_0x29ebd0; // 0x29efc4 - g_ps2RecompiledFunctionTable[424969] = GetItem_0x29ebd0; // 0x29f02c - g_ps2RecompiledFunctionTable[425017] = GetItem_0x29ebd0; // 0x29f0ec - g_ps2RecompiledFunctionTable[425036] = GetItem_0x29ebd0; // 0x29f138 - g_ps2RecompiledFunctionTable[425042] = GetItem_0x29ebd0; // 0x29f150 - g_ps2RecompiledFunctionTable[425069] = GetItem_0x29ebd0; // 0x29f1bc - g_ps2RecompiledFunctionTable[425104] = GetItem_0x29ebd0; // 0x29f248 - g_ps2RecompiledFunctionTable[425147] = GetItem_0x29ebd0; // 0x29f2f4 - g_ps2RecompiledFunctionTable[425512] = GetItem_0x29ebd0; // 0x29f8a8 - g_ps2RecompiledFunctionTable[425618] = MainCommand_0x29fa50; // 0x29fa50 - g_ps2RecompiledFunctionTable[425746] = MainCommand_0x29fa50; // 0x29fc50 - g_ps2RecompiledFunctionTable[425773] = MainCommand_0x29fa50; // 0x29fcbc - g_ps2RecompiledFunctionTable[425812] = MainCommand_0x29fa50; // 0x29fd58 - g_ps2RecompiledFunctionTable[425817] = MainCommand_0x29fa50; // 0x29fd6c - g_ps2RecompiledFunctionTable[425825] = MainCommand_0x29fa50; // 0x29fd8c - g_ps2RecompiledFunctionTable[425837] = MainCommand_0x29fa50; // 0x29fdbc - g_ps2RecompiledFunctionTable[425839] = MainCommand_0x29fa50; // 0x29fdc4 - g_ps2RecompiledFunctionTable[425874] = MainCommand_0x29fa50; // 0x29fe50 - g_ps2RecompiledFunctionTable[425882] = MainCommand_0x29fa50; // 0x29fe70 - g_ps2RecompiledFunctionTable[425918] = MainCommand_0x29fa50; // 0x29ff00 - g_ps2RecompiledFunctionTable[425925] = MainCommand_0x29fa50; // 0x29ff1c - g_ps2RecompiledFunctionTable[425960] = MainCommand_0x29fa50; // 0x29ffa8 - g_ps2RecompiledFunctionTable[425975] = MainCommand_0x29fa50; // 0x29ffe4 - g_ps2RecompiledFunctionTable[426026] = StatusCancel_0x2a00b0; // 0x2a00b0 - g_ps2RecompiledFunctionTable[426092] = StatusCancel_0x2a00b0; // 0x2a01b8 - g_ps2RecompiledFunctionTable[426118] = WeaponSet_0x2a0220; // 0x2a0220 - g_ps2RecompiledFunctionTable[426260] = WeaponSet_0x2a0220; // 0x2a0458 - g_ps2RecompiledFunctionTable[426267] = WeaponSet_0x2a0220; // 0x2a0474 - g_ps2RecompiledFunctionTable[426342] = ItemCommand_0x2a05a0; // 0x2a05a0 - g_ps2RecompiledFunctionTable[426368] = ItemCommand_0x2a05a0; // 0x2a0608 - g_ps2RecompiledFunctionTable[426419] = ItemCommand_0x2a05a0; // 0x2a06d4 - g_ps2RecompiledFunctionTable[426556] = ItemCommand_0x2a05a0; // 0x2a08f8 - g_ps2RecompiledFunctionTable[426572] = ItemCommand_0x2a05a0; // 0x2a0938 - g_ps2RecompiledFunctionTable[426587] = ItemCommand_0x2a05a0; // 0x2a0974 - g_ps2RecompiledFunctionTable[426600] = ItemCommand_0x2a05a0; // 0x2a09a8 - g_ps2RecompiledFunctionTable[426646] = ItemCommand_0x2a05a0; // 0x2a0a60 - g_ps2RecompiledFunctionTable[426702] = ItemCommand_0x2a05a0; // 0x2a0b40 - g_ps2RecompiledFunctionTable[426707] = ItemCommand_0x2a05a0; // 0x2a0b54 - g_ps2RecompiledFunctionTable[426751] = ItemCommand_0x2a05a0; // 0x2a0c04 - g_ps2RecompiledFunctionTable[426824] = ItemCommand_0x2a05a0; // 0x2a0d28 - g_ps2RecompiledFunctionTable[426870] = ItemCommand_0x2a05a0; // 0x2a0de0 - g_ps2RecompiledFunctionTable[426877] = ItemCommand_0x2a05a0; // 0x2a0dfc - g_ps2RecompiledFunctionTable[426886] = ItemCommand_0x2a05a0; // 0x2a0e20 - g_ps2RecompiledFunctionTable[426901] = ItemCommand_0x2a05a0; // 0x2a0e5c - g_ps2RecompiledFunctionTable[426905] = ItemCommand_0x2a05a0; // 0x2a0e6c - g_ps2RecompiledFunctionTable[426928] = ItemCommand_0x2a05a0; // 0x2a0ec8 - g_ps2RecompiledFunctionTable[426966] = ArmsSet_0x2a0f60; // 0x2a0f60 - g_ps2RecompiledFunctionTable[427107] = ArmsSet_0x2a0f60; // 0x2a1194 - g_ps2RecompiledFunctionTable[427126] = ArmsSet_0x2a0f60; // 0x2a11e0 - g_ps2RecompiledFunctionTable[427141] = ArmsSet_0x2a0f60; // 0x2a121c - g_ps2RecompiledFunctionTable[427164] = ArmsSet_0x2a0f60; // 0x2a1278 - g_ps2RecompiledFunctionTable[427186] = WindowJyoutai_0x2a12d0; // 0x2a12d0 - g_ps2RecompiledFunctionTable[427250] = ItemCommandErase_0x2a13d0; // 0x2a13d0 - g_ps2RecompiledFunctionTable[427295] = ItemCommandErase_0x2a13d0; // 0x2a1484 - g_ps2RecompiledFunctionTable[427316] = ItemCommandErase_0x2a13d0; // 0x2a14d8 - g_ps2RecompiledFunctionTable[427359] = ItemCommandErase_0x2a13d0; // 0x2a1584 - g_ps2RecompiledFunctionTable[427386] = ItemCombination_0x2a15f0; // 0x2a15f0 - g_ps2RecompiledFunctionTable[427567] = ItemCombination_0x2a15f0; // 0x2a18c4 - g_ps2RecompiledFunctionTable[427577] = ItemCombination_0x2a15f0; // 0x2a18ec - g_ps2RecompiledFunctionTable[427590] = ItemCombination_0x2a15f0; // 0x2a1920 - g_ps2RecompiledFunctionTable[427630] = ItemCombination_0x2a15f0; // 0x2a19c0 - g_ps2RecompiledFunctionTable[427676] = ItemCombination_0x2a15f0; // 0x2a1a78 - g_ps2RecompiledFunctionTable[427710] = ItemCombination_0x2a15f0; // 0x2a1b00 - g_ps2RecompiledFunctionTable[427843] = ItemCombination_0x2a15f0; // 0x2a1d14 - g_ps2RecompiledFunctionTable[427869] = ItemCombination_0x2a15f0; // 0x2a1d7c - g_ps2RecompiledFunctionTable[427874] = ItemCombination_0x2a15f0; // 0x2a1d90 - g_ps2RecompiledFunctionTable[427907] = ItemCombination_0x2a15f0; // 0x2a1e14 - g_ps2RecompiledFunctionTable[427941] = ItemCombination_0x2a15f0; // 0x2a1e9c - g_ps2RecompiledFunctionTable[427951] = ItemCombination_0x2a15f0; // 0x2a1ec4 - g_ps2RecompiledFunctionTable[427986] = ItemCombination_0x2a15f0; // 0x2a1f50 - g_ps2RecompiledFunctionTable[427994] = ItemCombination_0x2a15f0; // 0x2a1f70 - g_ps2RecompiledFunctionTable[428004] = ItemCombination_0x2a15f0; // 0x2a1f98 - g_ps2RecompiledFunctionTable[428039] = ItemCombination_0x2a15f0; // 0x2a2024 - g_ps2RecompiledFunctionTable[428049] = ItemCombination_0x2a15f0; // 0x2a204c - g_ps2RecompiledFunctionTable[428075] = ItemCombination_0x2a15f0; // 0x2a20b4 - g_ps2RecompiledFunctionTable[428088] = ItemCombination_0x2a15f0; // 0x2a20e8 - g_ps2RecompiledFunctionTable[428120] = ItemCombination_0x2a15f0; // 0x2a2168 - g_ps2RecompiledFunctionTable[428133] = ItemCombination_0x2a15f0; // 0x2a219c - g_ps2RecompiledFunctionTable[428167] = ItemCombination_0x2a15f0; // 0x2a2224 - g_ps2RecompiledFunctionTable[428198] = ItemCombination_0x2a15f0; // 0x2a22a0 - g_ps2RecompiledFunctionTable[428201] = ItemCombination_0x2a15f0; // 0x2a22ac - g_ps2RecompiledFunctionTable[428238] = ItemCombination_0x2a15f0; // 0x2a2340 - g_ps2RecompiledFunctionTable[428263] = ItemCombination_0x2a15f0; // 0x2a23a4 - g_ps2RecompiledFunctionTable[428318] = ItemCombination_0x2a15f0; // 0x2a2480 - g_ps2RecompiledFunctionTable[428373] = ItemCombination_0x2a15f0; // 0x2a255c - g_ps2RecompiledFunctionTable[428394] = ItemCombination_0x2a15f0; // 0x2a25b0 - g_ps2RecompiledFunctionTable[428415] = ItemCombination_0x2a15f0; // 0x2a2604 - g_ps2RecompiledFunctionTable[428506] = ItemCombination_0x2a15f0; // 0x2a2770 - g_ps2RecompiledFunctionTable[428517] = ItemCombination_0x2a15f0; // 0x2a279c - g_ps2RecompiledFunctionTable[428682] = SidePackSet_0x2a2a30; // 0x2a2a30 - g_ps2RecompiledFunctionTable[428718] = TrigerSet_0x2a2ac0; // 0x2a2ac0 - g_ps2RecompiledFunctionTable[428758] = TrigerSet_0x2a2ac0; // 0x2a2b60 - g_ps2RecompiledFunctionTable[428830] = BulletSet_0x2a2c80; // 0x2a2c80 - g_ps2RecompiledFunctionTable[428988] = BulletSet_0x2a2c80; // 0x2a2ef8 - g_ps2RecompiledFunctionTable[429162] = Use_00_0x2a31b0; // 0x2a31b0 - g_ps2RecompiledFunctionTable[429363] = Use_00_0x2a31b0; // 0x2a34d4 - g_ps2RecompiledFunctionTable[429374] = Use_00_0x2a31b0; // 0x2a3500 - g_ps2RecompiledFunctionTable[429395] = Use_00_0x2a31b0; // 0x2a3554 - g_ps2RecompiledFunctionTable[429413] = Use_00_0x2a31b0; // 0x2a359c - g_ps2RecompiledFunctionTable[429430] = Use_01_0x2a35e0; // 0x2a35e0 - g_ps2RecompiledFunctionTable[429467] = Use_01_0x2a35e0; // 0x2a3674 - g_ps2RecompiledFunctionTable[429493] = Use_01_0x2a35e0; // 0x2a36dc - g_ps2RecompiledFunctionTable[429498] = Use_01_0x2a35e0; // 0x2a36f0 - g_ps2RecompiledFunctionTable[429513] = Use_01_0x2a35e0; // 0x2a372c - g_ps2RecompiledFunctionTable[429535] = Use_01_0x2a35e0; // 0x2a3784 - g_ps2RecompiledFunctionTable[429540] = Use_01_0x2a35e0; // 0x2a3798 - g_ps2RecompiledFunctionTable[429554] = Use_02_0x2a37d0; // 0x2a37d0 - g_ps2RecompiledFunctionTable[429565] = Use_02_0x2a37d0; // 0x2a37fc - g_ps2RecompiledFunctionTable[429578] = Use_04_0x2a3830; // 0x2a3830 - g_ps2RecompiledFunctionTable[429582] = Use_05_0x2a3840; // 0x2a3840 - g_ps2RecompiledFunctionTable[429628] = Use_05_0x2a3840; // 0x2a38f8 - g_ps2RecompiledFunctionTable[429646] = Use_05_0x2a3840; // 0x2a3940 - g_ps2RecompiledFunctionTable[429651] = Use_05_0x2a3840; // 0x2a3954 - g_ps2RecompiledFunctionTable[429668] = Use_05_0x2a3840; // 0x2a3998 - g_ps2RecompiledFunctionTable[429677] = Use_05_0x2a3840; // 0x2a39bc - g_ps2RecompiledFunctionTable[429696] = Use_05_0x2a3840; // 0x2a3a08 - g_ps2RecompiledFunctionTable[429701] = Use_05_0x2a3840; // 0x2a3a1c - g_ps2RecompiledFunctionTable[429711] = Use_05_0x2a3840; // 0x2a3a44 - g_ps2RecompiledFunctionTable[429716] = Use_05_0x2a3840; // 0x2a3a58 - g_ps2RecompiledFunctionTable[429721] = Use_05_0x2a3840; // 0x2a3a6c - g_ps2RecompiledFunctionTable[429736] = Use_05_0x2a3840; // 0x2a3aa8 - g_ps2RecompiledFunctionTable[429750] = Combi_00_0x2a3ae0; // 0x2a3ae0 - g_ps2RecompiledFunctionTable[429818] = Combi_00_0x2a3ae0; // 0x2a3bf0 - g_ps2RecompiledFunctionTable[429950] = Combi_01_0x2a3e00; // 0x2a3e00 - g_ps2RecompiledFunctionTable[430078] = Combi_02_0x2a4000; // 0x2a4000 - g_ps2RecompiledFunctionTable[430258] = Combi_03_0x2a42d0; // 0x2a42d0 - g_ps2RecompiledFunctionTable[430286] = Combi_04_0x2a4340; // 0x2a4340 - g_ps2RecompiledFunctionTable[430338] = Combi_05_0x2a4410; // 0x2a4410 - g_ps2RecompiledFunctionTable[430398] = Combi_99_0x2a4500; // 0x2a4500 - g_ps2RecompiledFunctionTable[430494] = ItemBox_0x2a4680; // 0x2a4680 - g_ps2RecompiledFunctionTable[430513] = ItemBox_0x2a4680; // 0x2a46cc - g_ps2RecompiledFunctionTable[430563] = ItemBox_0x2a4680; // 0x2a4794 - g_ps2RecompiledFunctionTable[430649] = ItemBox_0x2a4680; // 0x2a48ec - g_ps2RecompiledFunctionTable[430664] = ItemBox_0x2a4680; // 0x2a4928 - g_ps2RecompiledFunctionTable[430678] = ItemBox_0x2a4680; // 0x2a4960 - g_ps2RecompiledFunctionTable[430700] = ItemBox_0x2a4680; // 0x2a49b8 - g_ps2RecompiledFunctionTable[430747] = ItemBox_0x2a4680; // 0x2a4a74 - g_ps2RecompiledFunctionTable[430793] = ItemBox_0x2a4680; // 0x2a4b2c - g_ps2RecompiledFunctionTable[430827] = ItemBox_0x2a4680; // 0x2a4bb4 - g_ps2RecompiledFunctionTable[430844] = ItemBox_0x2a4680; // 0x2a4bf8 - g_ps2RecompiledFunctionTable[430856] = ItemBox_0x2a4680; // 0x2a4c28 - g_ps2RecompiledFunctionTable[430859] = ItemBox_0x2a4680; // 0x2a4c34 - g_ps2RecompiledFunctionTable[430964] = ItemBox_0x2a4680; // 0x2a4dd8 - g_ps2RecompiledFunctionTable[431004] = ItemBox_0x2a4680; // 0x2a4e78 - g_ps2RecompiledFunctionTable[431054] = ItemBox_0x2a4680; // 0x2a4f40 - g_ps2RecompiledFunctionTable[431096] = ItemBox_0x2a4680; // 0x2a4fe8 - g_ps2RecompiledFunctionTable[431141] = ItemBox_0x2a4680; // 0x2a509c - g_ps2RecompiledFunctionTable[431152] = ItemBox_0x2a4680; // 0x2a50c8 - g_ps2RecompiledFunctionTable[431162] = ItemBox_0x2a4680; // 0x2a50f0 - g_ps2RecompiledFunctionTable[431178] = ItemBox_0x2a4680; // 0x2a5130 - g_ps2RecompiledFunctionTable[431192] = ItemBox_0x2a4680; // 0x2a5168 - g_ps2RecompiledFunctionTable[431200] = ItemBox_0x2a4680; // 0x2a5188 - g_ps2RecompiledFunctionTable[431225] = ItemBox_0x2a4680; // 0x2a51ec - g_ps2RecompiledFunctionTable[431308] = ItemBox_0x2a4680; // 0x2a5338 - g_ps2RecompiledFunctionTable[431350] = ItemBoxChange_0x2a53e0; // 0x2a53e0 - g_ps2RecompiledFunctionTable[431418] = ItemBoxChange_0x2a53e0; // 0x2a54f0 - g_ps2RecompiledFunctionTable[431450] = ItemBoxChange_0x2a53e0; // 0x2a5570 - g_ps2RecompiledFunctionTable[431474] = ItemBoxChange_0x2a53e0; // 0x2a55d0 - g_ps2RecompiledFunctionTable[431490] = ItemBoxChange_0x2a53e0; // 0x2a5610 - g_ps2RecompiledFunctionTable[431658] = ItemBoxChange_0x2a53e0; // 0x2a58b0 - g_ps2RecompiledFunctionTable[431993] = ItemBoxChange_0x2a53e0; // 0x2a5dec - g_ps2RecompiledFunctionTable[432003] = ItemBoxChange_0x2a53e0; // 0x2a5e14 - g_ps2RecompiledFunctionTable[432021] = ItemBoxChange_0x2a53e0; // 0x2a5e5c - g_ps2RecompiledFunctionTable[432042] = BorderLineSet_0x2a5eb0; // 0x2a5eb0 - g_ps2RecompiledFunctionTable[432107] = BorderLineSet_0x2a5eb0; // 0x2a5fb4 - g_ps2RecompiledFunctionTable[432116] = BorderLineSet_0x2a5eb0; // 0x2a5fd8 - g_ps2RecompiledFunctionTable[432149] = BorderLineSet_0x2a5eb0; // 0x2a605c - g_ps2RecompiledFunctionTable[432164] = BorderLineSet_0x2a5eb0; // 0x2a6098 - g_ps2RecompiledFunctionTable[432258] = BorderLineSet_0x2a5eb0; // 0x2a6210 - g_ps2RecompiledFunctionTable[432274] = BorderLineSet_0x2a5eb0; // 0x2a6250 - g_ps2RecompiledFunctionTable[432366] = BorderLineSet_0x2a5eb0; // 0x2a63c0 - g_ps2RecompiledFunctionTable[432378] = SpriteOnOff_0x2a63f0; // 0x2a63f0 - g_ps2RecompiledFunctionTable[432414] = SpriteOnOff_0x2a63f0; // 0x2a6480 - g_ps2RecompiledFunctionTable[432512] = SpriteOnOff_0x2a63f0; // 0x2a6608 - g_ps2RecompiledFunctionTable[432540] = SpriteOnOff_0x2a63f0; // 0x2a6678 - g_ps2RecompiledFunctionTable[432546] = SpriteOnOff_0x2a63f0; // 0x2a6690 - g_ps2RecompiledFunctionTable[432549] = SpriteOnOff_0x2a63f0; // 0x2a669c - g_ps2RecompiledFunctionTable[432553] = SpriteOnOff_0x2a63f0; // 0x2a66ac - g_ps2RecompiledFunctionTable[432556] = SpriteOnOff_0x2a63f0; // 0x2a66b8 - g_ps2RecompiledFunctionTable[432559] = SpriteOnOff_0x2a63f0; // 0x2a66c4 - g_ps2RecompiledFunctionTable[432564] = SpriteOnOff_0x2a63f0; // 0x2a66d8 - g_ps2RecompiledFunctionTable[432586] = SpriteOnOff_0x2a63f0; // 0x2a6730 - g_ps2RecompiledFunctionTable[432604] = SpriteOnOff_0x2a63f0; // 0x2a6778 - g_ps2RecompiledFunctionTable[432693] = SpriteOnOff_0x2a63f0; // 0x2a68dc - g_ps2RecompiledFunctionTable[432700] = SpriteOnOff_0x2a63f0; // 0x2a68f8 - g_ps2RecompiledFunctionTable[432706] = SpriteOnOff_0x2a63f0; // 0x2a6910 - g_ps2RecompiledFunctionTable[432764] = SpriteOnOff_0x2a63f0; // 0x2a69f8 - g_ps2RecompiledFunctionTable[432814] = NameChangeSet_0x2a6ac0; // 0x2a6ac0 - g_ps2RecompiledFunctionTable[432822] = AllItemInit_0x2a6ae0; // 0x2a6ae0 - g_ps2RecompiledFunctionTable[432827] = AllItemInit_0x2a6ae0; // 0x2a6af4 - g_ps2RecompiledFunctionTable[432839] = AllItemInit_0x2a6ae0; // 0x2a6b24 - g_ps2RecompiledFunctionTable[432854] = AllItemInit_0x2a6ae0; // 0x2a6b60 - g_ps2RecompiledFunctionTable[432879] = AllItemInit_0x2a6ae0; // 0x2a6bc4 - g_ps2RecompiledFunctionTable[432896] = AllItemInit_0x2a6ae0; // 0x2a6c08 - g_ps2RecompiledFunctionTable[432914] = AllItemInit_0x2a6ae0; // 0x2a6c50 - g_ps2RecompiledFunctionTable[432932] = AllItemInit_0x2a6ae0; // 0x2a6c98 - g_ps2RecompiledFunctionTable[433070] = ExtraGameItemInit_0x2a6ec0; // 0x2a6ec0 - g_ps2RecompiledFunctionTable[433077] = ExtraGameItemInit_0x2a6ec0; // 0x2a6edc - g_ps2RecompiledFunctionTable[433130] = ExtraGameItemInit_0x2a6ec0; // 0x2a6fb0 - g_ps2RecompiledFunctionTable[433158] = ItemBoxIconSet_0x2a7020; // 0x2a7020 - g_ps2RecompiledFunctionTable[433177] = ItemBoxIconSet_0x2a7020; // 0x2a706c - g_ps2RecompiledFunctionTable[433491] = ItemBoxIconSet_0x2a7020; // 0x2a7554 - g_ps2RecompiledFunctionTable[433514] = ItemBoxIconSet_0x2a7020; // 0x2a75b0 - g_ps2RecompiledFunctionTable[433530] = ItemBoxIconSet_0x2a7020; // 0x2a75f0 - g_ps2RecompiledFunctionTable[433546] = ItemBoxIconSet_0x2a7020; // 0x2a7630 - g_ps2RecompiledFunctionTable[433602] = ItemBoxIconSet_0x2a7020; // 0x2a7710 - g_ps2RecompiledFunctionTable[433610] = ItemBoxIconSet_0x2a7020; // 0x2a7730 - g_ps2RecompiledFunctionTable[433622] = ItemBoxIconSet_0x2a7020; // 0x2a7760 - g_ps2RecompiledFunctionTable[433630] = ItemBoxIconSet_0x2a7020; // 0x2a7780 - g_ps2RecompiledFunctionTable[433670] = bhSearchBullet_0x2a7820; // 0x2a7820 - g_ps2RecompiledFunctionTable[433709] = bhSearchBullet_0x2a7820; // 0x2a78bc - g_ps2RecompiledFunctionTable[433736] = bhSearchBullet_0x2a7820; // 0x2a7928 - g_ps2RecompiledFunctionTable[433749] = bhSearchBullet_0x2a7820; // 0x2a795c - g_ps2RecompiledFunctionTable[433764] = bhSearchBullet_0x2a7820; // 0x2a7998 - g_ps2RecompiledFunctionTable[433790] = CenterPositionInit_0x2a7a00; // 0x2a7a00 - g_ps2RecompiledFunctionTable[433795] = CenterPositionInit_0x2a7a00; // 0x2a7a14 - g_ps2RecompiledFunctionTable[433806] = CenterPositionInit_0x2a7a00; // 0x2a7a40 - g_ps2RecompiledFunctionTable[433822] = BgColorInit_0x2a7a80; // 0x2a7a80 - g_ps2RecompiledFunctionTable[433826] = BgColorInit_0x2a7a80; // 0x2a7a90 - g_ps2RecompiledFunctionTable[433838] = CursorInit_0x2a7ac0; // 0x2a7ac0 - g_ps2RecompiledFunctionTable[433890] = ItemSearch_0x2a7b90; // 0x2a7b90 - g_ps2RecompiledFunctionTable[433896] = ItemSearch_0x2a7b90; // 0x2a7ba8 - g_ps2RecompiledFunctionTable[433914] = EraseItem_0x2a7bf0; // 0x2a7bf0 - g_ps2RecompiledFunctionTable[433932] = EraseItem_0x2a7bf0; // 0x2a7c38 - g_ps2RecompiledFunctionTable[433938] = PushPalletBuffer_0x2a7c50; // 0x2a7c50 - g_ps2RecompiledFunctionTable[433946] = PushPalletBuffer_0x2a7c50; // 0x2a7c70 - g_ps2RecompiledFunctionTable[433948] = PushPalletBuffer_0x2a7c50; // 0x2a7c78 - g_ps2RecompiledFunctionTable[433954] = PopPalletBuffer_0x2a7c90; // 0x2a7c90 - g_ps2RecompiledFunctionTable[433958] = PopPalletBuffer_0x2a7c90; // 0x2a7ca0 - g_ps2RecompiledFunctionTable[433964] = PopPalletBuffer_0x2a7c90; // 0x2a7cb8 - g_ps2RecompiledFunctionTable[433970] = SbsTextureInit_0x2a7cd0; // 0x2a7cd0 - g_ps2RecompiledFunctionTable[433974] = SbsTextureInit_0x2a7cd0; // 0x2a7ce0 - g_ps2RecompiledFunctionTable[433987] = SbsTextureInit_0x2a7cd0; // 0x2a7d14 - g_ps2RecompiledFunctionTable[433994] = PulseInit_0x2a7d30; // 0x2a7d30 - g_ps2RecompiledFunctionTable[434007] = PulseInit_0x2a7d30; // 0x2a7d64 - g_ps2RecompiledFunctionTable[434039] = PulseInit_0x2a7d30; // 0x2a7de4 - g_ps2RecompiledFunctionTable[434130] = PulseMain_0x2a7f50; // 0x2a7f50 - g_ps2RecompiledFunctionTable[434202] = PulseMain_0x2a7f50; // 0x2a8070 - g_ps2RecompiledFunctionTable[434205] = PulseMain_0x2a7f50; // 0x2a807c - g_ps2RecompiledFunctionTable[434226] = PulseMain_0x2a7f50; // 0x2a80d0 - g_ps2RecompiledFunctionTable[434246] = PulseMain_0x2a7f50; // 0x2a8120 - g_ps2RecompiledFunctionTable[434253] = PulseMain_0x2a7f50; // 0x2a813c - g_ps2RecompiledFunctionTable[434290] = PulseMain_0x2a7f50; // 0x2a81d0 - g_ps2RecompiledFunctionTable[434294] = PulseAnim_0x2a81e0; // 0x2a81e0 - g_ps2RecompiledFunctionTable[434330] = PulseAnim_0x2a81e0; // 0x2a8270 - g_ps2RecompiledFunctionTable[434359] = PulseAnim_0x2a81e0; // 0x2a82e4 - g_ps2RecompiledFunctionTable[434406] = PulseAnim_0x2a81e0; // 0x2a83a0 - g_ps2RecompiledFunctionTable[434435] = PulseAnim_0x2a81e0; // 0x2a8414 - g_ps2RecompiledFunctionTable[434482] = PulseAnim_0x2a81e0; // 0x2a84d0 - g_ps2RecompiledFunctionTable[434511] = PulseAnim_0x2a81e0; // 0x2a8544 - g_ps2RecompiledFunctionTable[434558] = PulseAnim_0x2a81e0; // 0x2a8600 - g_ps2RecompiledFunctionTable[434587] = PulseAnim_0x2a81e0; // 0x2a8674 - g_ps2RecompiledFunctionTable[434606] = PulseAnim_0x2a81e0; // 0x2a86c0 - g_ps2RecompiledFunctionTable[434612] = PulseAnim_0x2a81e0; // 0x2a86d8 - g_ps2RecompiledFunctionTable[434618] = PulseFadeAnim_0x2a86f0; // 0x2a86f0 - g_ps2RecompiledFunctionTable[434646] = PulseFadeAnim_0x2a86f0; // 0x2a8760 - g_ps2RecompiledFunctionTable[434757] = PulseFadeAnim_0x2a86f0; // 0x2a891c - g_ps2RecompiledFunctionTable[434890] = PulseHealAnim_0x2a8b30; // 0x2a8b30 - g_ps2RecompiledFunctionTable[435019] = PulseHealAnim_0x2a8b30; // 0x2a8d34 - g_ps2RecompiledFunctionTable[435022] = PulsePoisonHealAnim_0x2a8d40; // 0x2a8d40 - g_ps2RecompiledFunctionTable[435155] = PulsePoisonHealAnim_0x2a8d40; // 0x2a8f54 - g_ps2RecompiledFunctionTable[435158] = Pulse00_0x2a8f60; // 0x2a8f60 - g_ps2RecompiledFunctionTable[435173] = Pulse00_0x2a8f60; // 0x2a8f9c - g_ps2RecompiledFunctionTable[435290] = Pulse00_0x2a8f60; // 0x2a9170 - g_ps2RecompiledFunctionTable[435306] = MultiWindowBack_0x2a91b0; // 0x2a91b0 - g_ps2RecompiledFunctionTable[435357] = MultiWindowBack_0x2a91b0; // 0x2a927c - g_ps2RecompiledFunctionTable[435362] = KazariAnim_0x2a9290; // 0x2a9290 - g_ps2RecompiledFunctionTable[435423] = KazariAnim_0x2a9290; // 0x2a9384 - g_ps2RecompiledFunctionTable[435506] = KazariAnim_0x2a9290; // 0x2a94d0 - g_ps2RecompiledFunctionTable[435522] = DrawPoly2D_0x2a9510; // 0x2a9510 - g_ps2RecompiledFunctionTable[435539] = DrawPoly2D_0x2a9510; // 0x2a9554 - g_ps2RecompiledFunctionTable[435541] = DrawPoly2D_0x2a9510; // 0x2a955c - g_ps2RecompiledFunctionTable[435560] = DrawPoly2D_0x2a9510; // 0x2a95a8 - g_ps2RecompiledFunctionTable[435590] = DrawPoly2D_0x2a9510; // 0x2a9620 - g_ps2RecompiledFunctionTable[435602] = DispFadeInit_0x2a9650; // 0x2a9650 - g_ps2RecompiledFunctionTable[435618] = FadePolyDisp_0x2a9690; // 0x2a9690 - g_ps2RecompiledFunctionTable[435699] = FadePolyDisp_0x2a9690; // 0x2a97d4 - g_ps2RecompiledFunctionTable[435703] = FadePolyDisp_0x2a9690; // 0x2a97e4 - g_ps2RecompiledFunctionTable[435707] = FadePolyDisp_0x2a9690; // 0x2a97f4 - g_ps2RecompiledFunctionTable[435711] = FadePolyDisp_0x2a9690; // 0x2a9804 - g_ps2RecompiledFunctionTable[435719] = FadePolyDisp_0x2a9690; // 0x2a9824 - g_ps2RecompiledFunctionTable[435726] = StatusMapFlagInit_0x2a9840; // 0x2a9840 - g_ps2RecompiledFunctionTable[435738] = DrawSubItem_0x2a9870; // 0x2a9870 - g_ps2RecompiledFunctionTable[435758] = DrawSubItem_0x2a9870; // 0x2a98c0 - g_ps2RecompiledFunctionTable[435762] = DrawSubItem_0x2a9870; // 0x2a98d0 - g_ps2RecompiledFunctionTable[435764] = DrawSubItem_0x2a9870; // 0x2a98d8 - g_ps2RecompiledFunctionTable[435790] = DrawSubItem_0x2a9870; // 0x2a9940 - g_ps2RecompiledFunctionTable[435793] = DrawSubItem_0x2a9870; // 0x2a994c - g_ps2RecompiledFunctionTable[435803] = DrawSubItem_0x2a9870; // 0x2a9974 - g_ps2RecompiledFunctionTable[435806] = DrawSubItem_0x2a9870; // 0x2a9980 - g_ps2RecompiledFunctionTable[435816] = DrawSubItem_0x2a9870; // 0x2a99a8 - g_ps2RecompiledFunctionTable[435819] = DrawSubItem_0x2a9870; // 0x2a99b4 - g_ps2RecompiledFunctionTable[435824] = DrawSubItem_0x2a9870; // 0x2a99c8 - g_ps2RecompiledFunctionTable[435827] = DrawSubItem_0x2a9870; // 0x2a99d4 - g_ps2RecompiledFunctionTable[435830] = DrawSubItem_0x2a9870; // 0x2a99e0 - g_ps2RecompiledFunctionTable[435841] = DrawSubItem_0x2a9870; // 0x2a9a0c - g_ps2RecompiledFunctionTable[435844] = DrawSubItem_0x2a9870; // 0x2a9a18 - g_ps2RecompiledFunctionTable[435847] = DrawSubItem_0x2a9870; // 0x2a9a24 - g_ps2RecompiledFunctionTable[435855] = DrawSubItem_0x2a9870; // 0x2a9a44 - g_ps2RecompiledFunctionTable[435858] = DrawSubItem_0x2a9870; // 0x2a9a50 - g_ps2RecompiledFunctionTable[435861] = DrawSubItem_0x2a9870; // 0x2a9a5c - g_ps2RecompiledFunctionTable[435866] = DrawSubItem_0x2a9870; // 0x2a9a70 - g_ps2RecompiledFunctionTable[435869] = DrawSubItem_0x2a9870; // 0x2a9a7c - g_ps2RecompiledFunctionTable[435872] = DrawSubItem_0x2a9870; // 0x2a9a88 - g_ps2RecompiledFunctionTable[435875] = DrawSubItem_0x2a9870; // 0x2a9a94 - g_ps2RecompiledFunctionTable[435877] = DrawSubItem_0x2a9870; // 0x2a9a9c - g_ps2RecompiledFunctionTable[435880] = DrawSubItem_0x2a9870; // 0x2a9aa8 - g_ps2RecompiledFunctionTable[435882] = DrawSubItem_0x2a9870; // 0x2a9ab0 - g_ps2RecompiledFunctionTable[435887] = DrawSubItem_0x2a9870; // 0x2a9ac4 - g_ps2RecompiledFunctionTable[435892] = DrawSubItem_0x2a9870; // 0x2a9ad8 - g_ps2RecompiledFunctionTable[435901] = DrawSubItem_0x2a9870; // 0x2a9afc - g_ps2RecompiledFunctionTable[435906] = DrawSubItem_0x2a9870; // 0x2a9b10 - g_ps2RecompiledFunctionTable[435916] = DrawSubItem_0x2a9870; // 0x2a9b38 - g_ps2RecompiledFunctionTable[435921] = DrawSubItem_0x2a9870; // 0x2a9b4c - g_ps2RecompiledFunctionTable[435971] = DrawSubItem_0x2a9870; // 0x2a9c14 - g_ps2RecompiledFunctionTable[435976] = DrawSubItem_0x2a9870; // 0x2a9c28 - g_ps2RecompiledFunctionTable[435981] = DrawSubItem_0x2a9870; // 0x2a9c3c - g_ps2RecompiledFunctionTable[435986] = DrawSubItem_0x2a9870; // 0x2a9c50 - g_ps2RecompiledFunctionTable[435991] = DrawSubItem_0x2a9870; // 0x2a9c64 - g_ps2RecompiledFunctionTable[435996] = DrawSubItem_0x2a9870; // 0x2a9c78 - g_ps2RecompiledFunctionTable[436033] = DrawSubItem_0x2a9870; // 0x2a9d0c - g_ps2RecompiledFunctionTable[436038] = DrawSubItem_0x2a9870; // 0x2a9d20 - g_ps2RecompiledFunctionTable[436041] = DrawSubItem_0x2a9870; // 0x2a9d2c - g_ps2RecompiledFunctionTable[436043] = DrawSubItem_0x2a9870; // 0x2a9d34 - g_ps2RecompiledFunctionTable[436045] = DrawSubItem_0x2a9870; // 0x2a9d3c - g_ps2RecompiledFunctionTable[436047] = DrawSubItem_0x2a9870; // 0x2a9d44 - g_ps2RecompiledFunctionTable[436049] = DrawSubItem_0x2a9870; // 0x2a9d4c - g_ps2RecompiledFunctionTable[436051] = DrawSubItem_0x2a9870; // 0x2a9d54 - g_ps2RecompiledFunctionTable[436057] = DrawSubItem_0x2a9870; // 0x2a9d6c - g_ps2RecompiledFunctionTable[436063] = DrawSubItem_0x2a9870; // 0x2a9d84 - g_ps2RecompiledFunctionTable[436070] = DrawSubItem_0x2a9870; // 0x2a9da0 - g_ps2RecompiledFunctionTable[436076] = DrawSubItem_0x2a9870; // 0x2a9db8 - g_ps2RecompiledFunctionTable[436078] = DrawSubItem_0x2a9870; // 0x2a9dc0 - g_ps2RecompiledFunctionTable[436080] = DrawSubItem_0x2a9870; // 0x2a9dc8 - g_ps2RecompiledFunctionTable[436082] = DrawSubItem_0x2a9870; // 0x2a9dd0 - g_ps2RecompiledFunctionTable[436085] = DrawSubItem_0x2a9870; // 0x2a9ddc - g_ps2RecompiledFunctionTable[436088] = DrawSubItem_0x2a9870; // 0x2a9de8 - g_ps2RecompiledFunctionTable[436091] = DrawSubItem_0x2a9870; // 0x2a9df4 - g_ps2RecompiledFunctionTable[436094] = DrawSubItem_0x2a9870; // 0x2a9e00 - g_ps2RecompiledFunctionTable[436096] = DrawSubItem_0x2a9870; // 0x2a9e08 - g_ps2RecompiledFunctionTable[436101] = DrawSubItem_0x2a9870; // 0x2a9e1c - g_ps2RecompiledFunctionTable[436112] = DrawSubItem_0x2a9870; // 0x2a9e48 - g_ps2RecompiledFunctionTable[436120] = DrawSubItem_0x2a9870; // 0x2a9e68 - g_ps2RecompiledFunctionTable[436123] = DrawSubItem_0x2a9870; // 0x2a9e74 - g_ps2RecompiledFunctionTable[436129] = DrawSubItem_0x2a9870; // 0x2a9e8c - g_ps2RecompiledFunctionTable[436140] = DrawSubItem_0x2a9870; // 0x2a9eb8 - g_ps2RecompiledFunctionTable[436142] = DrawSubItem_0x2a9870; // 0x2a9ec0 - g_ps2RecompiledFunctionTable[436147] = DrawSubItem_0x2a9870; // 0x2a9ed4 - g_ps2RecompiledFunctionTable[436152] = DrawSubItem_0x2a9870; // 0x2a9ee8 - g_ps2RecompiledFunctionTable[436157] = DrawSubItem_0x2a9870; // 0x2a9efc - g_ps2RecompiledFunctionTable[436163] = DrawSubItem_0x2a9870; // 0x2a9f14 - g_ps2RecompiledFunctionTable[436165] = DrawSubItem_0x2a9870; // 0x2a9f1c - g_ps2RecompiledFunctionTable[436170] = DrawSubItem_0x2a9870; // 0x2a9f30 - g_ps2RecompiledFunctionTable[436176] = DrawSubItem_0x2a9870; // 0x2a9f48 - g_ps2RecompiledFunctionTable[436180] = DrawSubItem_0x2a9870; // 0x2a9f58 - g_ps2RecompiledFunctionTable[436184] = DrawSubItem_0x2a9870; // 0x2a9f68 - g_ps2RecompiledFunctionTable[436187] = DrawSubItem_0x2a9870; // 0x2a9f74 - g_ps2RecompiledFunctionTable[436189] = DrawSubItem_0x2a9870; // 0x2a9f7c - g_ps2RecompiledFunctionTable[436201] = DrawSubItem_0x2a9870; // 0x2a9fac - g_ps2RecompiledFunctionTable[436203] = DrawSubItem_0x2a9870; // 0x2a9fb4 - g_ps2RecompiledFunctionTable[436209] = DrawSubItem_0x2a9870; // 0x2a9fcc - g_ps2RecompiledFunctionTable[436215] = DrawSubItem_0x2a9870; // 0x2a9fe4 - g_ps2RecompiledFunctionTable[436221] = DrawSubItem_0x2a9870; // 0x2a9ffc - g_ps2RecompiledFunctionTable[436228] = DrawSubItem_0x2a9870; // 0x2aa018 - g_ps2RecompiledFunctionTable[436230] = DrawSubItem_0x2a9870; // 0x2aa020 - g_ps2RecompiledFunctionTable[436235] = DrawSubItem_0x2a9870; // 0x2aa034 - g_ps2RecompiledFunctionTable[436242] = DrawSubItem_0x2a9870; // 0x2aa050 - g_ps2RecompiledFunctionTable[436247] = DrawSubItem_0x2a9870; // 0x2aa064 - g_ps2RecompiledFunctionTable[436252] = DrawSubItem_0x2a9870; // 0x2aa078 - g_ps2RecompiledFunctionTable[436255] = DrawSubItem_0x2a9870; // 0x2aa084 - g_ps2RecompiledFunctionTable[436257] = DrawSubItem_0x2a9870; // 0x2aa08c - g_ps2RecompiledFunctionTable[436269] = DrawSubItem_0x2a9870; // 0x2aa0bc - g_ps2RecompiledFunctionTable[436271] = DrawSubItem_0x2a9870; // 0x2aa0c4 - g_ps2RecompiledFunctionTable[436278] = DrawSubItem_0x2a9870; // 0x2aa0e0 - g_ps2RecompiledFunctionTable[436285] = DrawSubItem_0x2a9870; // 0x2aa0fc - g_ps2RecompiledFunctionTable[436292] = DrawSubItem_0x2a9870; // 0x2aa118 - g_ps2RecompiledFunctionTable[436300] = DrawSubItem_0x2a9870; // 0x2aa138 - g_ps2RecompiledFunctionTable[436302] = DrawSubItem_0x2a9870; // 0x2aa140 - g_ps2RecompiledFunctionTable[436307] = DrawSubItem_0x2a9870; // 0x2aa154 - g_ps2RecompiledFunctionTable[436314] = DrawSubItem_0x2a9870; // 0x2aa170 - g_ps2RecompiledFunctionTable[436320] = DrawSubItem_0x2a9870; // 0x2aa188 - g_ps2RecompiledFunctionTable[436326] = DrawSubItem_0x2a9870; // 0x2aa1a0 - g_ps2RecompiledFunctionTable[436329] = DrawSubItem_0x2a9870; // 0x2aa1ac - g_ps2RecompiledFunctionTable[436341] = DrawSubItem_0x2a9870; // 0x2aa1dc - g_ps2RecompiledFunctionTable[436361] = DrawSubItem_0x2a9870; // 0x2aa22c - g_ps2RecompiledFunctionTable[436363] = DrawSubItem_0x2a9870; // 0x2aa234 - g_ps2RecompiledFunctionTable[436365] = DrawSubItem_0x2a9870; // 0x2aa23c - g_ps2RecompiledFunctionTable[436367] = DrawSubItem_0x2a9870; // 0x2aa244 - g_ps2RecompiledFunctionTable[436370] = DrawSubItem_0x2a9870; // 0x2aa250 - g_ps2RecompiledFunctionTable[436372] = DrawSubItem_0x2a9870; // 0x2aa258 - g_ps2RecompiledFunctionTable[436374] = DrawSubItem_0x2a9870; // 0x2aa260 - g_ps2RecompiledFunctionTable[436382] = Model_Read_Start_0x2aa280; // 0x2aa280 - g_ps2RecompiledFunctionTable[436458] = Model_Read_Set_0x2aa3b0; // 0x2aa3b0 - g_ps2RecompiledFunctionTable[436473] = Model_Read_Set_0x2aa3b0; // 0x2aa3ec - g_ps2RecompiledFunctionTable[436477] = Model_Read_Set_0x2aa3b0; // 0x2aa3fc - g_ps2RecompiledFunctionTable[436480] = Model_Read_Set_0x2aa3b0; // 0x2aa408 - g_ps2RecompiledFunctionTable[436494] = Model_Read_Set_0x2aa3b0; // 0x2aa440 - g_ps2RecompiledFunctionTable[436507] = Model_Read_Set_0x2aa3b0; // 0x2aa474 - g_ps2RecompiledFunctionTable[436512] = Model_Read_Set_0x2aa3b0; // 0x2aa488 - g_ps2RecompiledFunctionTable[436520] = Model_Read_Set_0x2aa3b0; // 0x2aa4a8 - g_ps2RecompiledFunctionTable[436527] = Model_Read_Set_0x2aa3b0; // 0x2aa4c4 - g_ps2RecompiledFunctionTable[436535] = Model_Read_Set_0x2aa3b0; // 0x2aa4e4 - g_ps2RecompiledFunctionTable[436642] = CameraInit_0x2aa690; // 0x2aa690 - g_ps2RecompiledFunctionTable[436647] = CameraInit_0x2aa690; // 0x2aa6a4 - g_ps2RecompiledFunctionTable[436650] = CameraInit_0x2aa690; // 0x2aa6b0 - g_ps2RecompiledFunctionTable[436682] = CameraSet_0x2aa730; // 0x2aa730 - g_ps2RecompiledFunctionTable[436686] = CameraSet_0x2aa730; // 0x2aa740 - g_ps2RecompiledFunctionTable[436688] = CameraSet_0x2aa730; // 0x2aa748 - g_ps2RecompiledFunctionTable[436700] = CameraSet_0x2aa730; // 0x2aa778 - g_ps2RecompiledFunctionTable[436704] = CameraSet_0x2aa730; // 0x2aa788 - g_ps2RecompiledFunctionTable[436708] = CameraSet_0x2aa730; // 0x2aa798 - g_ps2RecompiledFunctionTable[436712] = CameraSet_0x2aa730; // 0x2aa7a8 - g_ps2RecompiledFunctionTable[436718] = CameraSet_0x2aa730; // 0x2aa7c0 - g_ps2RecompiledFunctionTable[436721] = CameraSet_0x2aa730; // 0x2aa7cc - g_ps2RecompiledFunctionTable[436726] = ItemView_0x2aa7e0; // 0x2aa7e0 - g_ps2RecompiledFunctionTable[436759] = ItemView_0x2aa7e0; // 0x2aa864 - g_ps2RecompiledFunctionTable[436763] = ItemView_0x2aa7e0; // 0x2aa874 - g_ps2RecompiledFunctionTable[436767] = ItemView_0x2aa7e0; // 0x2aa884 - g_ps2RecompiledFunctionTable[436771] = ItemView_0x2aa7e0; // 0x2aa894 - g_ps2RecompiledFunctionTable[436775] = ItemView_0x2aa7e0; // 0x2aa8a4 - g_ps2RecompiledFunctionTable[436786] = ItemView_0x2aa7e0; // 0x2aa8d0 - g_ps2RecompiledFunctionTable[436788] = ItemView_0x2aa7e0; // 0x2aa8d8 - g_ps2RecompiledFunctionTable[436790] = ItemView_0x2aa7e0; // 0x2aa8e0 - g_ps2RecompiledFunctionTable[436794] = ItemView_0x2aa7e0; // 0x2aa8f0 - g_ps2RecompiledFunctionTable[436798] = ItemView_0x2aa7e0; // 0x2aa900 - g_ps2RecompiledFunctionTable[436802] = ItemModelChangeZoomIn_0x2aa910; // 0x2aa910 - g_ps2RecompiledFunctionTable[436861] = ItemModelChangeZoomIn_0x2aa910; // 0x2aa9fc - g_ps2RecompiledFunctionTable[436874] = ItemModelCheck_0x2aaa30; // 0x2aaa30 - g_ps2RecompiledFunctionTable[437097] = ItemModelCheck_0x2aaa30; // 0x2aadac - g_ps2RecompiledFunctionTable[437107] = ItemModelCheck_0x2aaa30; // 0x2aadd4 - g_ps2RecompiledFunctionTable[437110] = ItemModelCheck_0x2aaa30; // 0x2aade0 - g_ps2RecompiledFunctionTable[437177] = ItemModelCheck_0x2aaa30; // 0x2aaeec - g_ps2RecompiledFunctionTable[437182] = ItemModelCheck_0x2aaa30; // 0x2aaf00 - g_ps2RecompiledFunctionTable[437187] = ItemModelCheck_0x2aaa30; // 0x2aaf14 - g_ps2RecompiledFunctionTable[437196] = ItemModelCheck_0x2aaa30; // 0x2aaf38 - g_ps2RecompiledFunctionTable[437235] = ItemModelCheck_0x2aaa30; // 0x2aafd4 - g_ps2RecompiledFunctionTable[437246] = ItemModelCheck_0x2aaa30; // 0x2ab000 - g_ps2RecompiledFunctionTable[437251] = ItemModelCheck_0x2aaa30; // 0x2ab014 - g_ps2RecompiledFunctionTable[437261] = ItemModelCheck_0x2aaa30; // 0x2ab03c - g_ps2RecompiledFunctionTable[437274] = ItemModelCheck_0x2aaa30; // 0x2ab070 - g_ps2RecompiledFunctionTable[437306] = ItemModelActionSet_0x2ab0f0; // 0x2ab0f0 - g_ps2RecompiledFunctionTable[437307] = ItemModelActionSet_0x2ab0f0; // 0x2ab0f4 - g_ps2RecompiledFunctionTable[437308] = ItemModelActionSet_0x2ab0f0; // 0x2ab0f8 - g_ps2RecompiledFunctionTable[437309] = ItemModelActionSet_0x2ab0f0; // 0x2ab0fc - g_ps2RecompiledFunctionTable[437310] = ItemModelActionSet_0x2ab0f0; // 0x2ab100 - g_ps2RecompiledFunctionTable[437311] = ItemModelActionSet_0x2ab0f0; // 0x2ab104 - g_ps2RecompiledFunctionTable[437312] = ItemModelActionSet_0x2ab0f0; // 0x2ab108 - g_ps2RecompiledFunctionTable[437313] = ItemModelActionSet_0x2ab0f0; // 0x2ab10c - g_ps2RecompiledFunctionTable[437314] = ItemModelActionSet_0x2ab0f0; // 0x2ab110 - g_ps2RecompiledFunctionTable[437315] = ItemModelActionSet_0x2ab0f0; // 0x2ab114 - g_ps2RecompiledFunctionTable[437316] = ItemModelActionSet_0x2ab0f0; // 0x2ab118 - g_ps2RecompiledFunctionTable[437317] = ItemModelActionSet_0x2ab0f0; // 0x2ab11c - g_ps2RecompiledFunctionTable[437318] = ItemModelActionSet_0x2ab0f0; // 0x2ab120 - g_ps2RecompiledFunctionTable[437319] = ItemModelActionSet_0x2ab0f0; // 0x2ab124 - g_ps2RecompiledFunctionTable[437320] = ItemModelActionSet_0x2ab0f0; // 0x2ab128 - g_ps2RecompiledFunctionTable[437321] = ItemModelActionSet_0x2ab0f0; // 0x2ab12c - g_ps2RecompiledFunctionTable[437322] = ItemModelActionSet_0x2ab0f0; // 0x2ab130 - g_ps2RecompiledFunctionTable[437323] = ItemModelActionSet_0x2ab0f0; // 0x2ab134 - g_ps2RecompiledFunctionTable[437324] = ItemModelActionSet_0x2ab0f0; // 0x2ab138 - g_ps2RecompiledFunctionTable[437325] = ItemModelActionSet_0x2ab0f0; // 0x2ab13c - g_ps2RecompiledFunctionTable[437326] = ItemModelActionSet_0x2ab0f0; // 0x2ab140 - g_ps2RecompiledFunctionTable[437327] = ItemModelActionSet_0x2ab0f0; // 0x2ab144 - g_ps2RecompiledFunctionTable[437328] = ItemModelActionSet_0x2ab0f0; // 0x2ab148 - g_ps2RecompiledFunctionTable[437329] = ItemModelActionSet_0x2ab0f0; // 0x2ab14c - g_ps2RecompiledFunctionTable[437330] = ItemModelActionSet_0x2ab0f0; // 0x2ab150 - g_ps2RecompiledFunctionTable[437331] = ItemModelActionSet_0x2ab0f0; // 0x2ab154 - g_ps2RecompiledFunctionTable[437332] = ItemModelActionSet_0x2ab0f0; // 0x2ab158 - g_ps2RecompiledFunctionTable[437333] = ItemModelActionSet_0x2ab0f0; // 0x2ab15c - g_ps2RecompiledFunctionTable[437334] = ItemModelActionSet_0x2ab0f0; // 0x2ab160 - g_ps2RecompiledFunctionTable[437335] = ItemModelActionSet_0x2ab0f0; // 0x2ab164 - g_ps2RecompiledFunctionTable[437336] = ItemModelActionSet_0x2ab0f0; // 0x2ab168 - g_ps2RecompiledFunctionTable[437337] = ItemModelActionSet_0x2ab0f0; // 0x2ab16c - g_ps2RecompiledFunctionTable[437338] = ItemModelActionSet_0x2ab0f0; // 0x2ab170 - g_ps2RecompiledFunctionTable[437339] = ItemModelActionSet_0x2ab0f0; // 0x2ab174 - g_ps2RecompiledFunctionTable[437340] = ItemModelActionSet_0x2ab0f0; // 0x2ab178 - g_ps2RecompiledFunctionTable[437341] = ItemModelActionSet_0x2ab0f0; // 0x2ab17c - g_ps2RecompiledFunctionTable[437342] = ItemModelActionSet_0x2ab0f0; // 0x2ab180 - g_ps2RecompiledFunctionTable[437343] = ItemModelActionSet_0x2ab0f0; // 0x2ab184 - g_ps2RecompiledFunctionTable[437344] = ItemModelActionSet_0x2ab0f0; // 0x2ab188 - g_ps2RecompiledFunctionTable[437345] = ItemModelActionSet_0x2ab0f0; // 0x2ab18c - g_ps2RecompiledFunctionTable[437346] = ItemModelActionSet_0x2ab0f0; // 0x2ab190 - g_ps2RecompiledFunctionTable[437347] = ItemModelActionSet_0x2ab0f0; // 0x2ab194 - g_ps2RecompiledFunctionTable[437350] = ItemModelChangeZoomOut_0x2ab1a0; // 0x2ab1a0 - g_ps2RecompiledFunctionTable[437423] = ItemModelChangeZoomOut_0x2ab1a0; // 0x2ab2c4 - g_ps2RecompiledFunctionTable[437436] = ItemModelChangeZoomOut_0x2ab1a0; // 0x2ab2f8 - g_ps2RecompiledFunctionTable[437486] = ItemModelChangeZoomOut_0x2ab1a0; // 0x2ab3c0 - g_ps2RecompiledFunctionTable[437488] = ItemModelChangeZoomOut_0x2ab1a0; // 0x2ab3c8 - g_ps2RecompiledFunctionTable[437522] = ItemModelMessageWait_0x2ab450; // 0x2ab450 - g_ps2RecompiledFunctionTable[437586] = MdlDirChk_0x2ab550; // 0x2ab550 - g_ps2RecompiledFunctionTable[437606] = MdlAction00_0x2ab5a0; // 0x2ab5a0 - g_ps2RecompiledFunctionTable[437674] = MdlAction01_0x2ab6b0; // 0x2ab6b0 - g_ps2RecompiledFunctionTable[437830] = MdlAction02_0x2ab920; // 0x2ab920 - g_ps2RecompiledFunctionTable[437894] = MdlEvalflagsSet_0x2aba20; // 0x2aba20 - g_ps2RecompiledFunctionTable[437906] = MdlHideCheck_0x2aba50; // 0x2aba50 - g_ps2RecompiledFunctionTable[437933] = MdlHideCheck_0x2aba50; // 0x2ababc - g_ps2RecompiledFunctionTable[437941] = MdlHideCheck_0x2aba50; // 0x2abadc - g_ps2RecompiledFunctionTable[437951] = MdlHideCheck_0x2aba50; // 0x2abb04 - g_ps2RecompiledFunctionTable[437957] = MdlHideCheck_0x2aba50; // 0x2abb1c - g_ps2RecompiledFunctionTable[437966] = ModelScaleSet_0x2abb40; // 0x2abb40 - g_ps2RecompiledFunctionTable[437990] = ModelScaleSet_0x2abb40; // 0x2abba0 - g_ps2RecompiledFunctionTable[437993] = ModelScaleSet_0x2abb40; // 0x2abbac - g_ps2RecompiledFunctionTable[438038] = FlagErase_0x2abc60; // 0x2abc60 - g_ps2RecompiledFunctionTable[438055] = FlagErase_0x2abc60; // 0x2abca4 - g_ps2RecompiledFunctionTable[438060] = FlagErase_0x2abc60; // 0x2abcb8 - g_ps2RecompiledFunctionTable[438066] = LighterOpen_0x2abcd0; // 0x2abcd0 - g_ps2RecompiledFunctionTable[438070] = FileSyu_0x2abce0; // 0x2abce0 - g_ps2RecompiledFunctionTable[438086] = MakeTag_0x2abd20; // 0x2abd20 - g_ps2RecompiledFunctionTable[438122] = MakeTag_0x2abd20; // 0x2abdb0 - g_ps2RecompiledFunctionTable[438150] = MakeTag_0x2abd20; // 0x2abe20 - g_ps2RecompiledFunctionTable[438225] = MakeTag_0x2abd20; // 0x2abf4c - g_ps2RecompiledFunctionTable[438229] = MakeTag_0x2abd20; // 0x2abf5c - g_ps2RecompiledFunctionTable[438231] = MakeTag_0x2abd20; // 0x2abf64 - g_ps2RecompiledFunctionTable[438254] = ControlFileView_0x2abfc0; // 0x2abfc0 - g_ps2RecompiledFunctionTable[438255] = ControlFileView_0x2abfc0; // 0x2abfc4 - g_ps2RecompiledFunctionTable[438256] = ControlFileView_0x2abfc0; // 0x2abfc8 - g_ps2RecompiledFunctionTable[438257] = ControlFileView_0x2abfc0; // 0x2abfcc - g_ps2RecompiledFunctionTable[438258] = ControlFileView_0x2abfc0; // 0x2abfd0 - g_ps2RecompiledFunctionTable[438259] = ControlFileView_0x2abfc0; // 0x2abfd4 - g_ps2RecompiledFunctionTable[438260] = ControlFileView_0x2abfc0; // 0x2abfd8 - g_ps2RecompiledFunctionTable[438261] = ControlFileView_0x2abfc0; // 0x2abfdc - g_ps2RecompiledFunctionTable[438262] = ControlFileView_0x2abfc0; // 0x2abfe0 - g_ps2RecompiledFunctionTable[438263] = ControlFileView_0x2abfc0; // 0x2abfe4 - g_ps2RecompiledFunctionTable[438264] = ControlFileView_0x2abfc0; // 0x2abfe8 - g_ps2RecompiledFunctionTable[438265] = ControlFileView_0x2abfc0; // 0x2abfec - g_ps2RecompiledFunctionTable[438266] = ControlFileView_0x2abfc0; // 0x2abff0 - g_ps2RecompiledFunctionTable[438267] = ControlFileView_0x2abfc0; // 0x2abff4 - g_ps2RecompiledFunctionTable[438268] = ControlFileView_0x2abfc0; // 0x2abff8 - g_ps2RecompiledFunctionTable[438269] = ControlFileView_0x2abfc0; // 0x2abffc - g_ps2RecompiledFunctionTable[438270] = FileSelect_0x2ac000; // 0x2ac000 - g_ps2RecompiledFunctionTable[438289] = FileSelect_0x2ac000; // 0x2ac04c - g_ps2RecompiledFunctionTable[438293] = FileSelect_0x2ac000; // 0x2ac05c - g_ps2RecompiledFunctionTable[438297] = FileSelect_0x2ac000; // 0x2ac06c - g_ps2RecompiledFunctionTable[438302] = FileFlagInit01_0x2ac080; // 0x2ac080 - g_ps2RecompiledFunctionTable[438330] = FileFlagInit_0x2ac0f0; // 0x2ac0f0 - g_ps2RecompiledFunctionTable[438354] = GetFile_0x2ac150; // 0x2ac150 - g_ps2RecompiledFunctionTable[438376] = GetFile_0x2ac150; // 0x2ac1a8 - g_ps2RecompiledFunctionTable[438390] = FileViewInit_0x2ac1e0; // 0x2ac1e0 - g_ps2RecompiledFunctionTable[438423] = FileViewInit_0x2ac1e0; // 0x2ac264 - g_ps2RecompiledFunctionTable[438427] = FileViewInit_0x2ac1e0; // 0x2ac274 - g_ps2RecompiledFunctionTable[438447] = FileViewInit_0x2ac1e0; // 0x2ac2c4 - g_ps2RecompiledFunctionTable[438451] = FileViewInit_0x2ac1e0; // 0x2ac2d4 - g_ps2RecompiledFunctionTable[438468] = FileViewInit_0x2ac1e0; // 0x2ac318 - g_ps2RecompiledFunctionTable[438471] = FileViewInit_0x2ac1e0; // 0x2ac324 - g_ps2RecompiledFunctionTable[438498] = FileViewMain_0x2ac390; // 0x2ac390 - g_ps2RecompiledFunctionTable[438514] = FileViewMain_0x2ac390; // 0x2ac3d0 - g_ps2RecompiledFunctionTable[438516] = FileViewMain_0x2ac390; // 0x2ac3d8 - g_ps2RecompiledFunctionTable[438518] = FileViewMain_0x2ac390; // 0x2ac3e0 - g_ps2RecompiledFunctionTable[438522] = FileViewExit_0x2ac3f0; // 0x2ac3f0 - g_ps2RecompiledFunctionTable[438533] = FileViewExit_0x2ac3f0; // 0x2ac41c - g_ps2RecompiledFunctionTable[438537] = FileViewExit_0x2ac3f0; // 0x2ac42c - g_ps2RecompiledFunctionTable[438542] = FileExit00_0x2ac440; // 0x2ac440 - g_ps2RecompiledFunctionTable[438550] = FileExit01_0x2ac460; // 0x2ac460 - g_ps2RecompiledFunctionTable[438657] = FileExit01_0x2ac460; // 0x2ac60c - g_ps2RecompiledFunctionTable[438659] = FileExit01_0x2ac460; // 0x2ac614 - g_ps2RecompiledFunctionTable[438672] = FileExit01_0x2ac460; // 0x2ac648 - g_ps2RecompiledFunctionTable[438703] = FileExit01_0x2ac460; // 0x2ac6c4 - g_ps2RecompiledFunctionTable[438722] = SearchTag_0x2ac710; // 0x2ac710 - g_ps2RecompiledFunctionTable[438727] = SearchTag_0x2ac710; // 0x2ac724 - g_ps2RecompiledFunctionTable[438750] = SelectFile_0x2ac780; // 0x2ac780 - g_ps2RecompiledFunctionTable[438842] = SelectFile_0x2ac780; // 0x2ac8f0 - g_ps2RecompiledFunctionTable[438856] = SelectFile_0x2ac780; // 0x2ac928 - g_ps2RecompiledFunctionTable[438887] = SelectFile_0x2ac780; // 0x2ac9a4 - g_ps2RecompiledFunctionTable[438902] = SelectFile_0x2ac780; // 0x2ac9e0 - g_ps2RecompiledFunctionTable[438917] = SelectFile_0x2ac780; // 0x2aca1c - g_ps2RecompiledFunctionTable[438924] = SelectFile_0x2ac780; // 0x2aca38 - g_ps2RecompiledFunctionTable[438929] = SelectFile_0x2ac780; // 0x2aca4c - g_ps2RecompiledFunctionTable[438966] = SelectFile_0x2ac780; // 0x2acae0 - g_ps2RecompiledFunctionTable[438976] = SelectFile_0x2ac780; // 0x2acb08 - g_ps2RecompiledFunctionTable[439060] = SelectFile_0x2ac780; // 0x2acc58 - g_ps2RecompiledFunctionTable[439153] = SelectFile_0x2ac780; // 0x2acdcc - g_ps2RecompiledFunctionTable[439192] = SelectFile_0x2ac780; // 0x2ace68 - g_ps2RecompiledFunctionTable[439205] = SelectFile_0x2ac780; // 0x2ace9c - g_ps2RecompiledFunctionTable[439234] = SelectTag_0x2acf10; // 0x2acf10 - g_ps2RecompiledFunctionTable[439273] = SelectTag_0x2acf10; // 0x2acfac - g_ps2RecompiledFunctionTable[439296] = SelectTag_0x2acf10; // 0x2ad008 - g_ps2RecompiledFunctionTable[439304] = SelectTag_0x2acf10; // 0x2ad028 - g_ps2RecompiledFunctionTable[439328] = SelectTag_0x2acf10; // 0x2ad088 - g_ps2RecompiledFunctionTable[439353] = SelectTag_0x2acf10; // 0x2ad0ec - g_ps2RecompiledFunctionTable[439377] = SelectTag_0x2acf10; // 0x2ad14c - g_ps2RecompiledFunctionTable[439379] = SelectTag_0x2acf10; // 0x2ad154 - g_ps2RecompiledFunctionTable[439381] = SelectTag_0x2acf10; // 0x2ad15c - g_ps2RecompiledFunctionTable[439407] = SelectTag_0x2acf10; // 0x2ad1c4 - g_ps2RecompiledFunctionTable[439412] = SelectTag_0x2acf10; // 0x2ad1d8 - g_ps2RecompiledFunctionTable[439449] = SelectTag_0x2acf10; // 0x2ad26c - g_ps2RecompiledFunctionTable[439551] = SelectTag_0x2acf10; // 0x2ad404 - g_ps2RecompiledFunctionTable[439570] = FileScreenCancel_0x2ad450; // 0x2ad450 - g_ps2RecompiledFunctionTable[439582] = FileScreenCancel_0x2ad450; // 0x2ad480 - g_ps2RecompiledFunctionTable[439586] = FileScreenCancel_0x2ad450; // 0x2ad490 - g_ps2RecompiledFunctionTable[439611] = FileScreenCancel_0x2ad450; // 0x2ad4f4 - g_ps2RecompiledFunctionTable[439614] = FileScreenCancel_0x2ad450; // 0x2ad500 - g_ps2RecompiledFunctionTable[439694] = FileScrollSet_0x2ad640; // 0x2ad640 - g_ps2RecompiledFunctionTable[439708] = FileScrollSet_0x2ad640; // 0x2ad678 - g_ps2RecompiledFunctionTable[439790] = FileScrollSet_0x2ad640; // 0x2ad7c0 - g_ps2RecompiledFunctionTable[439848] = FileScrollSet_0x2ad640; // 0x2ad8a8 - g_ps2RecompiledFunctionTable[439897] = FileScrollSet_0x2ad640; // 0x2ad96c - g_ps2RecompiledFunctionTable[439902] = FileScrollSet_0x2ad640; // 0x2ad980 - g_ps2RecompiledFunctionTable[439904] = FileScrollSet_0x2ad640; // 0x2ad988 - g_ps2RecompiledFunctionTable[439924] = FileScrollSet_0x2ad640; // 0x2ad9d8 - g_ps2RecompiledFunctionTable[439928] = FileScrollSet_0x2ad640; // 0x2ad9e8 - g_ps2RecompiledFunctionTable[439931] = FileScrollSet_0x2ad640; // 0x2ad9f4 - g_ps2RecompiledFunctionTable[439942] = FileGetWait_0x2ada20; // 0x2ada20 - g_ps2RecompiledFunctionTable[439965] = FileGetWait_0x2ada20; // 0x2ada7c - g_ps2RecompiledFunctionTable[440020] = FileGetWait_0x2ada20; // 0x2adb58 - g_ps2RecompiledFunctionTable[440027] = FileGetWait_0x2ada20; // 0x2adb74 - g_ps2RecompiledFunctionTable[440034] = PageScroll_0x2adb90; // 0x2adb90 - g_ps2RecompiledFunctionTable[440045] = PageScroll_0x2adb90; // 0x2adbbc - g_ps2RecompiledFunctionTable[440315] = PageScroll_0x2adb90; // 0x2adff4 - g_ps2RecompiledFunctionTable[440343] = PageScroll_0x2adb90; // 0x2ae064 - g_ps2RecompiledFunctionTable[440350] = FileEtcDisplay_0x2ae080; // 0x2ae080 - g_ps2RecompiledFunctionTable[440375] = FileEtcDisplay_0x2ae080; // 0x2ae0e4 - g_ps2RecompiledFunctionTable[440534] = StatusToFileView_0x2ae360; // 0x2ae360 - g_ps2RecompiledFunctionTable[440579] = StatusToFileView_0x2ae360; // 0x2ae414 - g_ps2RecompiledFunctionTable[440618] = ReadFstx_0x2ae4b0; // 0x2ae4b0 - g_ps2RecompiledFunctionTable[440665] = ReadFstx_0x2ae4b0; // 0x2ae56c - g_ps2RecompiledFunctionTable[440674] = ReadFstx_0x2ae4b0; // 0x2ae590 - g_ps2RecompiledFunctionTable[440684] = ReadFstx_0x2ae4b0; // 0x2ae5b8 - g_ps2RecompiledFunctionTable[440689] = ReadFstx_0x2ae4b0; // 0x2ae5cc - g_ps2RecompiledFunctionTable[440712] = ReadFstx_0x2ae4b0; // 0x2ae628 - g_ps2RecompiledFunctionTable[440742] = ReadFstx_0x2ae4b0; // 0x2ae6a0 - g_ps2RecompiledFunctionTable[440758] = ReadFstx_0x2ae4b0; // 0x2ae6e0 - g_ps2RecompiledFunctionTable[440761] = ReadFstx_0x2ae4b0; // 0x2ae6ec - g_ps2RecompiledFunctionTable[440773] = ReadFstx_0x2ae4b0; // 0x2ae71c - g_ps2RecompiledFunctionTable[440778] = ReadFstx_0x2ae4b0; // 0x2ae730 - g_ps2RecompiledFunctionTable[440787] = ReadFstx_0x2ae4b0; // 0x2ae754 - g_ps2RecompiledFunctionTable[440790] = ReadFstx_0x2ae4b0; // 0x2ae760 - g_ps2RecompiledFunctionTable[440838] = FileNumberSwitch_0x2ae820; // 0x2ae820 - g_ps2RecompiledFunctionTable[441046] = PlayPageCheck_0x2aeb60; // 0x2aeb60 - g_ps2RecompiledFunctionTable[441053] = PlayPageCheck_0x2aeb60; // 0x2aeb7c - g_ps2RecompiledFunctionTable[441062] = PlayPageCheck_0x2aeb60; // 0x2aeba0 - g_ps2RecompiledFunctionTable[441071] = PlayPageCheck_0x2aeb60; // 0x2aebc4 - g_ps2RecompiledFunctionTable[441080] = PlayPageCheck_0x2aeb60; // 0x2aebe8 - g_ps2RecompiledFunctionTable[441089] = PlayPageCheck_0x2aeb60; // 0x2aec0c - g_ps2RecompiledFunctionTable[441098] = bhInitDoor_0x2aec30; // 0x2aec30 - g_ps2RecompiledFunctionTable[441105] = bhInitDoor_0x2aec30; // 0x2aec4c - g_ps2RecompiledFunctionTable[441121] = bhInitDoor_0x2aec30; // 0x2aec8c - g_ps2RecompiledFunctionTable[441146] = bhReadDoorData_0x2aecf0; // 0x2aecf0 - g_ps2RecompiledFunctionTable[441174] = bhReadDoorData_0x2aecf0; // 0x2aed60 - g_ps2RecompiledFunctionTable[441183] = bhReadDoorData_0x2aecf0; // 0x2aed84 - g_ps2RecompiledFunctionTable[441192] = bhReadDoorData_0x2aecf0; // 0x2aeda8 - g_ps2RecompiledFunctionTable[441206] = bhReadDoorData_0x2aecf0; // 0x2aede0 - g_ps2RecompiledFunctionTable[441220] = bhReadDoorData_0x2aecf0; // 0x2aee18 - g_ps2RecompiledFunctionTable[441250] = bhReadDoorData_0x2aecf0; // 0x2aee90 - g_ps2RecompiledFunctionTable[441262] = bhSetDoor_0x2aeec0; // 0x2aeec0 - g_ps2RecompiledFunctionTable[441290] = bhSetDoor_0x2aeec0; // 0x2aef30 - g_ps2RecompiledFunctionTable[441322] = bhSetDoor_0x2aeec0; // 0x2aefb0 - g_ps2RecompiledFunctionTable[441329] = bhSetDoor_0x2aeec0; // 0x2aefcc - g_ps2RecompiledFunctionTable[441333] = bhSetDoor_0x2aeec0; // 0x2aefdc - g_ps2RecompiledFunctionTable[441337] = bhSetDoor_0x2aeec0; // 0x2aefec - g_ps2RecompiledFunctionTable[441343] = bhSetDoor_0x2aeec0; // 0x2af004 - g_ps2RecompiledFunctionTable[441346] = bhSetDoor_0x2aeec0; // 0x2af010 - g_ps2RecompiledFunctionTable[441349] = bhSetDoor_0x2aeec0; // 0x2af01c - g_ps2RecompiledFunctionTable[441490] = bhSetDoor_0x2aeec0; // 0x2af250 - g_ps2RecompiledFunctionTable[441510] = bhExitDoor_0x2af2a0; // 0x2af2a0 - g_ps2RecompiledFunctionTable[441522] = bhExitDoor_0x2af2a0; // 0x2af2d0 - g_ps2RecompiledFunctionTable[441527] = bhExitDoor_0x2af2a0; // 0x2af2e4 - g_ps2RecompiledFunctionTable[441533] = bhExitDoor_0x2af2a0; // 0x2af2fc - g_ps2RecompiledFunctionTable[441536] = bhExitDoor_0x2af2a0; // 0x2af308 - g_ps2RecompiledFunctionTable[441538] = bhExitDoor_0x2af2a0; // 0x2af310 - g_ps2RecompiledFunctionTable[441550] = bhExitDoor_0x2af2a0; // 0x2af340 - g_ps2RecompiledFunctionTable[441554] = AnalyzeDoor_0x2af350; // 0x2af350 - g_ps2RecompiledFunctionTable[441562] = bhControlDoor_0x2af370; // 0x2af370 - g_ps2RecompiledFunctionTable[441563] = bhControlDoor_0x2af370; // 0x2af374 - g_ps2RecompiledFunctionTable[441564] = bhControlDoor_0x2af370; // 0x2af378 - g_ps2RecompiledFunctionTable[441565] = bhControlDoor_0x2af370; // 0x2af37c - g_ps2RecompiledFunctionTable[441566] = bhControlDoor_0x2af370; // 0x2af380 - g_ps2RecompiledFunctionTable[441567] = bhControlDoor_0x2af370; // 0x2af384 - g_ps2RecompiledFunctionTable[441568] = bhControlDoor_0x2af370; // 0x2af388 - g_ps2RecompiledFunctionTable[441569] = bhControlDoor_0x2af370; // 0x2af38c - g_ps2RecompiledFunctionTable[441570] = bhControlDoor_0x2af370; // 0x2af390 - g_ps2RecompiledFunctionTable[441571] = bhControlDoor_0x2af370; // 0x2af394 - g_ps2RecompiledFunctionTable[441572] = bhControlDoor_0x2af370; // 0x2af398 - g_ps2RecompiledFunctionTable[441573] = bhControlDoor_0x2af370; // 0x2af39c - g_ps2RecompiledFunctionTable[441574] = bhControlDoor_0x2af370; // 0x2af3a0 - g_ps2RecompiledFunctionTable[441575] = bhControlDoor_0x2af370; // 0x2af3a4 - g_ps2RecompiledFunctionTable[441576] = bhControlDoor_0x2af370; // 0x2af3a8 - g_ps2RecompiledFunctionTable[441577] = bhControlDoor_0x2af370; // 0x2af3ac - g_ps2RecompiledFunctionTable[441578] = bhControlDoor_0x2af370; // 0x2af3b0 - g_ps2RecompiledFunctionTable[441579] = bhControlDoor_0x2af370; // 0x2af3b4 - g_ps2RecompiledFunctionTable[441580] = bhControlDoor_0x2af370; // 0x2af3b8 - g_ps2RecompiledFunctionTable[441581] = bhControlDoor_0x2af370; // 0x2af3bc - g_ps2RecompiledFunctionTable[441582] = bhControlDoor_0x2af370; // 0x2af3c0 - g_ps2RecompiledFunctionTable[441583] = bhControlDoor_0x2af370; // 0x2af3c4 - g_ps2RecompiledFunctionTable[441584] = bhControlDoor_0x2af370; // 0x2af3c8 - g_ps2RecompiledFunctionTable[441585] = bhControlDoor_0x2af370; // 0x2af3cc - g_ps2RecompiledFunctionTable[441586] = bhControlDoor_0x2af370; // 0x2af3d0 - g_ps2RecompiledFunctionTable[441587] = bhControlDoor_0x2af370; // 0x2af3d4 - g_ps2RecompiledFunctionTable[441588] = bhControlDoor_0x2af370; // 0x2af3d8 - g_ps2RecompiledFunctionTable[441589] = bhControlDoor_0x2af370; // 0x2af3dc - g_ps2RecompiledFunctionTable[441590] = bhControlDoor_0x2af370; // 0x2af3e0 - g_ps2RecompiledFunctionTable[441591] = bhControlDoor_0x2af370; // 0x2af3e4 - g_ps2RecompiledFunctionTable[441592] = bhControlDoor_0x2af370; // 0x2af3e8 - g_ps2RecompiledFunctionTable[441593] = bhControlDoor_0x2af370; // 0x2af3ec - g_ps2RecompiledFunctionTable[441594] = bhControlDoor_0x2af370; // 0x2af3f0 - g_ps2RecompiledFunctionTable[441595] = bhControlDoor_0x2af370; // 0x2af3f4 - g_ps2RecompiledFunctionTable[441596] = bhControlDoor_0x2af370; // 0x2af3f8 - g_ps2RecompiledFunctionTable[441597] = bhControlDoor_0x2af370; // 0x2af3fc - g_ps2RecompiledFunctionTable[441598] = bhControlDoor_0x2af370; // 0x2af400 - g_ps2RecompiledFunctionTable[441599] = bhControlDoor_0x2af370; // 0x2af404 - g_ps2RecompiledFunctionTable[441600] = bhControlDoor_0x2af370; // 0x2af408 - g_ps2RecompiledFunctionTable[441601] = bhControlDoor_0x2af370; // 0x2af40c - g_ps2RecompiledFunctionTable[441602] = bhControlDoor_0x2af370; // 0x2af410 - g_ps2RecompiledFunctionTable[441603] = bhControlDoor_0x2af370; // 0x2af414 - g_ps2RecompiledFunctionTable[441604] = bhControlDoor_0x2af370; // 0x2af418 - g_ps2RecompiledFunctionTable[441605] = bhControlDoor_0x2af370; // 0x2af41c - g_ps2RecompiledFunctionTable[441606] = bhControlDoor_0x2af370; // 0x2af420 - g_ps2RecompiledFunctionTable[441607] = bhControlDoor_0x2af370; // 0x2af424 - g_ps2RecompiledFunctionTable[441608] = bhControlDoor_0x2af370; // 0x2af428 - g_ps2RecompiledFunctionTable[441609] = bhControlDoor_0x2af370; // 0x2af42c - g_ps2RecompiledFunctionTable[441610] = bhControlDoor_0x2af370; // 0x2af430 - g_ps2RecompiledFunctionTable[441611] = bhControlDoor_0x2af370; // 0x2af434 - g_ps2RecompiledFunctionTable[441612] = bhControlDoor_0x2af370; // 0x2af438 - g_ps2RecompiledFunctionTable[441613] = bhControlDoor_0x2af370; // 0x2af43c - g_ps2RecompiledFunctionTable[441614] = bhControlDoor_0x2af370; // 0x2af440 - g_ps2RecompiledFunctionTable[441615] = bhControlDoor_0x2af370; // 0x2af444 - g_ps2RecompiledFunctionTable[441616] = bhControlDoor_0x2af370; // 0x2af448 - g_ps2RecompiledFunctionTable[441617] = bhControlDoor_0x2af370; // 0x2af44c - g_ps2RecompiledFunctionTable[441618] = bhControlDoor_0x2af370; // 0x2af450 - g_ps2RecompiledFunctionTable[441619] = bhControlDoor_0x2af370; // 0x2af454 - g_ps2RecompiledFunctionTable[441620] = bhControlDoor_0x2af370; // 0x2af458 - g_ps2RecompiledFunctionTable[441621] = bhControlDoor_0x2af370; // 0x2af45c - g_ps2RecompiledFunctionTable[441622] = bhControlDoor_0x2af370; // 0x2af460 - g_ps2RecompiledFunctionTable[441623] = bhControlDoor_0x2af370; // 0x2af464 - g_ps2RecompiledFunctionTable[441624] = bhControlDoor_0x2af370; // 0x2af468 - g_ps2RecompiledFunctionTable[441625] = bhControlDoor_0x2af370; // 0x2af46c - g_ps2RecompiledFunctionTable[441626] = bhControlDoor_0x2af370; // 0x2af470 - g_ps2RecompiledFunctionTable[441627] = bhControlDoor_0x2af370; // 0x2af474 - g_ps2RecompiledFunctionTable[441628] = bhControlDoor_0x2af370; // 0x2af478 - g_ps2RecompiledFunctionTable[441629] = bhControlDoor_0x2af370; // 0x2af47c - g_ps2RecompiledFunctionTable[441630] = bhControlDoor_0x2af370; // 0x2af480 - g_ps2RecompiledFunctionTable[441631] = bhControlDoor_0x2af370; // 0x2af484 - g_ps2RecompiledFunctionTable[441632] = bhControlDoor_0x2af370; // 0x2af488 - g_ps2RecompiledFunctionTable[441633] = bhControlDoor_0x2af370; // 0x2af48c - g_ps2RecompiledFunctionTable[441634] = bhControlDoor_0x2af370; // 0x2af490 - g_ps2RecompiledFunctionTable[441635] = bhControlDoor_0x2af370; // 0x2af494 - g_ps2RecompiledFunctionTable[441636] = bhControlDoor_0x2af370; // 0x2af498 - g_ps2RecompiledFunctionTable[441637] = bhControlDoor_0x2af370; // 0x2af49c - g_ps2RecompiledFunctionTable[441638] = bhControlDoor_0x2af370; // 0x2af4a0 - g_ps2RecompiledFunctionTable[441639] = bhControlDoor_0x2af370; // 0x2af4a4 - g_ps2RecompiledFunctionTable[441640] = bhControlDoor_0x2af370; // 0x2af4a8 - g_ps2RecompiledFunctionTable[441641] = bhControlDoor_0x2af370; // 0x2af4ac - g_ps2RecompiledFunctionTable[441642] = bhControlDoor_0x2af370; // 0x2af4b0 - g_ps2RecompiledFunctionTable[441643] = bhControlDoor_0x2af370; // 0x2af4b4 - g_ps2RecompiledFunctionTable[441644] = bhControlDoor_0x2af370; // 0x2af4b8 - g_ps2RecompiledFunctionTable[441645] = bhControlDoor_0x2af370; // 0x2af4bc - g_ps2RecompiledFunctionTable[441646] = bhControlDoor_0x2af370; // 0x2af4c0 - g_ps2RecompiledFunctionTable[441647] = bhControlDoor_0x2af370; // 0x2af4c4 - g_ps2RecompiledFunctionTable[441648] = bhControlDoor_0x2af370; // 0x2af4c8 - g_ps2RecompiledFunctionTable[441649] = bhControlDoor_0x2af370; // 0x2af4cc - g_ps2RecompiledFunctionTable[441650] = bhControlDoor_0x2af370; // 0x2af4d0 - g_ps2RecompiledFunctionTable[441651] = bhControlDoor_0x2af370; // 0x2af4d4 - g_ps2RecompiledFunctionTable[441652] = bhControlDoor_0x2af370; // 0x2af4d8 - g_ps2RecompiledFunctionTable[441653] = bhControlDoor_0x2af370; // 0x2af4dc - g_ps2RecompiledFunctionTable[441654] = bhControlDoor_0x2af370; // 0x2af4e0 - g_ps2RecompiledFunctionTable[441655] = bhControlDoor_0x2af370; // 0x2af4e4 - g_ps2RecompiledFunctionTable[441656] = bhControlDoor_0x2af370; // 0x2af4e8 - g_ps2RecompiledFunctionTable[441657] = bhControlDoor_0x2af370; // 0x2af4ec - g_ps2RecompiledFunctionTable[441658] = bhControlDoor_0x2af370; // 0x2af4f0 - g_ps2RecompiledFunctionTable[441659] = bhControlDoor_0x2af370; // 0x2af4f4 - g_ps2RecompiledFunctionTable[441660] = bhControlDoor_0x2af370; // 0x2af4f8 - g_ps2RecompiledFunctionTable[441661] = bhControlDoor_0x2af370; // 0x2af4fc - g_ps2RecompiledFunctionTable[441662] = bhControlDoor_0x2af370; // 0x2af500 - g_ps2RecompiledFunctionTable[441663] = bhControlDoor_0x2af370; // 0x2af504 - g_ps2RecompiledFunctionTable[441664] = bhControlDoor_0x2af370; // 0x2af508 - g_ps2RecompiledFunctionTable[441665] = bhControlDoor_0x2af370; // 0x2af50c - g_ps2RecompiledFunctionTable[441666] = bhControlDoor_0x2af370; // 0x2af510 - g_ps2RecompiledFunctionTable[441667] = bhControlDoor_0x2af370; // 0x2af514 - g_ps2RecompiledFunctionTable[441668] = bhControlDoor_0x2af370; // 0x2af518 - g_ps2RecompiledFunctionTable[441669] = bhControlDoor_0x2af370; // 0x2af51c - g_ps2RecompiledFunctionTable[441670] = bhControlDoor_0x2af370; // 0x2af520 - g_ps2RecompiledFunctionTable[441671] = bhControlDoor_0x2af370; // 0x2af524 - g_ps2RecompiledFunctionTable[441672] = bhControlDoor_0x2af370; // 0x2af528 - g_ps2RecompiledFunctionTable[441673] = bhControlDoor_0x2af370; // 0x2af52c - g_ps2RecompiledFunctionTable[441674] = bhControlDoor_0x2af370; // 0x2af530 - g_ps2RecompiledFunctionTable[441675] = bhControlDoor_0x2af370; // 0x2af534 - g_ps2RecompiledFunctionTable[441676] = bhControlDoor_0x2af370; // 0x2af538 - g_ps2RecompiledFunctionTable[441677] = bhControlDoor_0x2af370; // 0x2af53c - g_ps2RecompiledFunctionTable[441678] = bhControlDoor_0x2af370; // 0x2af540 - g_ps2RecompiledFunctionTable[441679] = bhControlDoor_0x2af370; // 0x2af544 - g_ps2RecompiledFunctionTable[441680] = bhControlDoor_0x2af370; // 0x2af548 - g_ps2RecompiledFunctionTable[441681] = bhControlDoor_0x2af370; // 0x2af54c - g_ps2RecompiledFunctionTable[441682] = bhControlDoor_0x2af370; // 0x2af550 - g_ps2RecompiledFunctionTable[441683] = bhControlDoor_0x2af370; // 0x2af554 - g_ps2RecompiledFunctionTable[441684] = bhControlDoor_0x2af370; // 0x2af558 - g_ps2RecompiledFunctionTable[441685] = bhControlDoor_0x2af370; // 0x2af55c - g_ps2RecompiledFunctionTable[441686] = bhControlDoor_0x2af370; // 0x2af560 - g_ps2RecompiledFunctionTable[441687] = bhControlDoor_0x2af370; // 0x2af564 - g_ps2RecompiledFunctionTable[441688] = bhControlDoor_0x2af370; // 0x2af568 - g_ps2RecompiledFunctionTable[441689] = bhControlDoor_0x2af370; // 0x2af56c - g_ps2RecompiledFunctionTable[441690] = bhControlDoor_0x2af370; // 0x2af570 - g_ps2RecompiledFunctionTable[441691] = bhControlDoor_0x2af370; // 0x2af574 - g_ps2RecompiledFunctionTable[441692] = bhControlDoor_0x2af370; // 0x2af578 - g_ps2RecompiledFunctionTable[441693] = bhControlDoor_0x2af370; // 0x2af57c - g_ps2RecompiledFunctionTable[441694] = bhControlDoor_0x2af370; // 0x2af580 - g_ps2RecompiledFunctionTable[441695] = bhControlDoor_0x2af370; // 0x2af584 - g_ps2RecompiledFunctionTable[441696] = bhControlDoor_0x2af370; // 0x2af588 - g_ps2RecompiledFunctionTable[441697] = bhControlDoor_0x2af370; // 0x2af58c - g_ps2RecompiledFunctionTable[441698] = bhControlDoor_0x2af370; // 0x2af590 - g_ps2RecompiledFunctionTable[441699] = bhControlDoor_0x2af370; // 0x2af594 - g_ps2RecompiledFunctionTable[441700] = bhControlDoor_0x2af370; // 0x2af598 - g_ps2RecompiledFunctionTable[441701] = bhControlDoor_0x2af370; // 0x2af59c - g_ps2RecompiledFunctionTable[441702] = bhControlDoor_0x2af370; // 0x2af5a0 - g_ps2RecompiledFunctionTable[441703] = bhControlDoor_0x2af370; // 0x2af5a4 - g_ps2RecompiledFunctionTable[441704] = bhControlDoor_0x2af370; // 0x2af5a8 - g_ps2RecompiledFunctionTable[441705] = bhControlDoor_0x2af370; // 0x2af5ac - g_ps2RecompiledFunctionTable[441706] = bhControlDoor_0x2af370; // 0x2af5b0 - g_ps2RecompiledFunctionTable[441707] = bhControlDoor_0x2af370; // 0x2af5b4 - g_ps2RecompiledFunctionTable[441708] = bhControlDoor_0x2af370; // 0x2af5b8 - g_ps2RecompiledFunctionTable[441709] = bhControlDoor_0x2af370; // 0x2af5bc - g_ps2RecompiledFunctionTable[441710] = bhControlDoor_0x2af370; // 0x2af5c0 - g_ps2RecompiledFunctionTable[441711] = bhControlDoor_0x2af370; // 0x2af5c4 - g_ps2RecompiledFunctionTable[441712] = bhControlDoor_0x2af370; // 0x2af5c8 - g_ps2RecompiledFunctionTable[441713] = bhControlDoor_0x2af370; // 0x2af5cc - g_ps2RecompiledFunctionTable[441714] = bhControlDoor_0x2af370; // 0x2af5d0 - g_ps2RecompiledFunctionTable[441715] = bhControlDoor_0x2af370; // 0x2af5d4 - g_ps2RecompiledFunctionTable[441716] = bhControlDoor_0x2af370; // 0x2af5d8 - g_ps2RecompiledFunctionTable[441717] = bhControlDoor_0x2af370; // 0x2af5dc - g_ps2RecompiledFunctionTable[441718] = bhControlDoor_0x2af370; // 0x2af5e0 - g_ps2RecompiledFunctionTable[441719] = bhControlDoor_0x2af370; // 0x2af5e4 - g_ps2RecompiledFunctionTable[441720] = bhControlDoor_0x2af370; // 0x2af5e8 - g_ps2RecompiledFunctionTable[441721] = bhControlDoor_0x2af370; // 0x2af5ec - g_ps2RecompiledFunctionTable[441722] = bhControlDoor_0x2af370; // 0x2af5f0 - g_ps2RecompiledFunctionTable[441723] = bhControlDoor_0x2af370; // 0x2af5f4 - g_ps2RecompiledFunctionTable[441724] = bhControlDoor_0x2af370; // 0x2af5f8 - g_ps2RecompiledFunctionTable[441725] = bhControlDoor_0x2af370; // 0x2af5fc - g_ps2RecompiledFunctionTable[441726] = bhControlDoor_0x2af370; // 0x2af600 - g_ps2RecompiledFunctionTable[441727] = bhControlDoor_0x2af370; // 0x2af604 - g_ps2RecompiledFunctionTable[441728] = bhControlDoor_0x2af370; // 0x2af608 - g_ps2RecompiledFunctionTable[441729] = bhControlDoor_0x2af370; // 0x2af60c - g_ps2RecompiledFunctionTable[441730] = bhControlDoor_0x2af370; // 0x2af610 - g_ps2RecompiledFunctionTable[441731] = bhControlDoor_0x2af370; // 0x2af614 - g_ps2RecompiledFunctionTable[441732] = bhControlDoor_0x2af370; // 0x2af618 - g_ps2RecompiledFunctionTable[441733] = bhControlDoor_0x2af370; // 0x2af61c - g_ps2RecompiledFunctionTable[441734] = bhControlDoor_0x2af370; // 0x2af620 - g_ps2RecompiledFunctionTable[441735] = bhControlDoor_0x2af370; // 0x2af624 - g_ps2RecompiledFunctionTable[441736] = bhControlDoor_0x2af370; // 0x2af628 - g_ps2RecompiledFunctionTable[441737] = bhControlDoor_0x2af370; // 0x2af62c - g_ps2RecompiledFunctionTable[441738] = bhControlDoor_0x2af370; // 0x2af630 - g_ps2RecompiledFunctionTable[441739] = bhControlDoor_0x2af370; // 0x2af634 - g_ps2RecompiledFunctionTable[441740] = bhControlDoor_0x2af370; // 0x2af638 - g_ps2RecompiledFunctionTable[441741] = bhControlDoor_0x2af370; // 0x2af63c - g_ps2RecompiledFunctionTable[441742] = bhControlDoor_0x2af370; // 0x2af640 - g_ps2RecompiledFunctionTable[441743] = bhControlDoor_0x2af370; // 0x2af644 - g_ps2RecompiledFunctionTable[441744] = bhControlDoor_0x2af370; // 0x2af648 - g_ps2RecompiledFunctionTable[441745] = bhControlDoor_0x2af370; // 0x2af64c - g_ps2RecompiledFunctionTable[441746] = bhControlDoor_0x2af370; // 0x2af650 - g_ps2RecompiledFunctionTable[441747] = bhControlDoor_0x2af370; // 0x2af654 - g_ps2RecompiledFunctionTable[441748] = bhControlDoor_0x2af370; // 0x2af658 - g_ps2RecompiledFunctionTable[441749] = bhControlDoor_0x2af370; // 0x2af65c - g_ps2RecompiledFunctionTable[441750] = bhControlDoor_0x2af370; // 0x2af660 - g_ps2RecompiledFunctionTable[441751] = bhControlDoor_0x2af370; // 0x2af664 - g_ps2RecompiledFunctionTable[441752] = bhControlDoor_0x2af370; // 0x2af668 - g_ps2RecompiledFunctionTable[441753] = bhControlDoor_0x2af370; // 0x2af66c - g_ps2RecompiledFunctionTable[441754] = bhControlDoor_0x2af370; // 0x2af670 - g_ps2RecompiledFunctionTable[441755] = bhControlDoor_0x2af370; // 0x2af674 - g_ps2RecompiledFunctionTable[441756] = bhControlDoor_0x2af370; // 0x2af678 - g_ps2RecompiledFunctionTable[441757] = bhControlDoor_0x2af370; // 0x2af67c - g_ps2RecompiledFunctionTable[441758] = bhControlDoor_0x2af370; // 0x2af680 - g_ps2RecompiledFunctionTable[441759] = bhControlDoor_0x2af370; // 0x2af684 - g_ps2RecompiledFunctionTable[441760] = bhControlDoor_0x2af370; // 0x2af688 - g_ps2RecompiledFunctionTable[441761] = bhControlDoor_0x2af370; // 0x2af68c - g_ps2RecompiledFunctionTable[441762] = bhControlDoor_0x2af370; // 0x2af690 - g_ps2RecompiledFunctionTable[441763] = bhControlDoor_0x2af370; // 0x2af694 - g_ps2RecompiledFunctionTable[441764] = bhControlDoor_0x2af370; // 0x2af698 - g_ps2RecompiledFunctionTable[441765] = bhControlDoor_0x2af370; // 0x2af69c - g_ps2RecompiledFunctionTable[441766] = bhControlDoor_0x2af370; // 0x2af6a0 - g_ps2RecompiledFunctionTable[441767] = bhControlDoor_0x2af370; // 0x2af6a4 - g_ps2RecompiledFunctionTable[441768] = bhControlDoor_0x2af370; // 0x2af6a8 - g_ps2RecompiledFunctionTable[441769] = bhControlDoor_0x2af370; // 0x2af6ac - g_ps2RecompiledFunctionTable[441770] = bhControlDoor_0x2af370; // 0x2af6b0 - g_ps2RecompiledFunctionTable[441771] = bhControlDoor_0x2af370; // 0x2af6b4 - g_ps2RecompiledFunctionTable[441772] = bhControlDoor_0x2af370; // 0x2af6b8 - g_ps2RecompiledFunctionTable[441773] = bhControlDoor_0x2af370; // 0x2af6bc - g_ps2RecompiledFunctionTable[441774] = bhControlDoor_0x2af370; // 0x2af6c0 - g_ps2RecompiledFunctionTable[441775] = bhControlDoor_0x2af370; // 0x2af6c4 - g_ps2RecompiledFunctionTable[441776] = bhControlDoor_0x2af370; // 0x2af6c8 - g_ps2RecompiledFunctionTable[441777] = bhControlDoor_0x2af370; // 0x2af6cc - g_ps2RecompiledFunctionTable[441778] = bhControlDoor_0x2af370; // 0x2af6d0 - g_ps2RecompiledFunctionTable[441779] = bhControlDoor_0x2af370; // 0x2af6d4 - g_ps2RecompiledFunctionTable[441780] = bhControlDoor_0x2af370; // 0x2af6d8 - g_ps2RecompiledFunctionTable[441781] = bhControlDoor_0x2af370; // 0x2af6dc - g_ps2RecompiledFunctionTable[441782] = bhControlDoor_0x2af370; // 0x2af6e0 - g_ps2RecompiledFunctionTable[441783] = bhControlDoor_0x2af370; // 0x2af6e4 - g_ps2RecompiledFunctionTable[441784] = bhControlDoor_0x2af370; // 0x2af6e8 - g_ps2RecompiledFunctionTable[441785] = bhControlDoor_0x2af370; // 0x2af6ec - g_ps2RecompiledFunctionTable[441786] = bhControlDoor_0x2af370; // 0x2af6f0 - g_ps2RecompiledFunctionTable[441787] = bhControlDoor_0x2af370; // 0x2af6f4 - g_ps2RecompiledFunctionTable[441788] = bhControlDoor_0x2af370; // 0x2af6f8 - g_ps2RecompiledFunctionTable[441789] = bhControlDoor_0x2af370; // 0x2af6fc - g_ps2RecompiledFunctionTable[441790] = bhControlDoor_0x2af370; // 0x2af700 - g_ps2RecompiledFunctionTable[441791] = bhControlDoor_0x2af370; // 0x2af704 - g_ps2RecompiledFunctionTable[441792] = bhControlDoor_0x2af370; // 0x2af708 - g_ps2RecompiledFunctionTable[441793] = bhControlDoor_0x2af370; // 0x2af70c - g_ps2RecompiledFunctionTable[441794] = bhControlDoor_0x2af370; // 0x2af710 - g_ps2RecompiledFunctionTable[441795] = bhControlDoor_0x2af370; // 0x2af714 - g_ps2RecompiledFunctionTable[441796] = bhControlDoor_0x2af370; // 0x2af718 - g_ps2RecompiledFunctionTable[441797] = bhControlDoor_0x2af370; // 0x2af71c - g_ps2RecompiledFunctionTable[441798] = bhControlDoor_0x2af370; // 0x2af720 - g_ps2RecompiledFunctionTable[441799] = bhControlDoor_0x2af370; // 0x2af724 - g_ps2RecompiledFunctionTable[441800] = bhControlDoor_0x2af370; // 0x2af728 - g_ps2RecompiledFunctionTable[441801] = bhControlDoor_0x2af370; // 0x2af72c - g_ps2RecompiledFunctionTable[441802] = bhControlDoor_0x2af370; // 0x2af730 - g_ps2RecompiledFunctionTable[441803] = bhControlDoor_0x2af370; // 0x2af734 - g_ps2RecompiledFunctionTable[441804] = bhControlDoor_0x2af370; // 0x2af738 - g_ps2RecompiledFunctionTable[441805] = bhControlDoor_0x2af370; // 0x2af73c - g_ps2RecompiledFunctionTable[441806] = bhControlDoor_0x2af370; // 0x2af740 - g_ps2RecompiledFunctionTable[441807] = bhControlDoor_0x2af370; // 0x2af744 - g_ps2RecompiledFunctionTable[441810] = ControlSoundTiming_0x2af750; // 0x2af750 - g_ps2RecompiledFunctionTable[441820] = ControlSoundTiming_0x2af750; // 0x2af778 - g_ps2RecompiledFunctionTable[441824] = ControlSoundTiming_0x2af750; // 0x2af788 - g_ps2RecompiledFunctionTable[441838] = SetSoundTiming_0x2af7c0; // 0x2af7c0 - g_ps2RecompiledFunctionTable[441842] = SetSoundTiming_0x2af7c0; // 0x2af7d0 - g_ps2RecompiledFunctionTable[441854] = FadeProc1_0x2af800; // 0x2af800 - g_ps2RecompiledFunctionTable[441899] = FadeProc1_0x2af800; // 0x2af8b4 - g_ps2RecompiledFunctionTable[441932] = FadeProc1_0x2af800; // 0x2af938 - g_ps2RecompiledFunctionTable[441966] = ViewProc1_0x2af9c0; // 0x2af9c0 - g_ps2RecompiledFunctionTable[442048] = ViewProc1_0x2af9c0; // 0x2afb08 - g_ps2RecompiledFunctionTable[442055] = ViewProc1_0x2af9c0; // 0x2afb24 - g_ps2RecompiledFunctionTable[442065] = ViewProc1_0x2af9c0; // 0x2afb4c - g_ps2RecompiledFunctionTable[442082] = ViewProc2_0x2afb90; // 0x2afb90 - g_ps2RecompiledFunctionTable[442148] = ViewProc2_0x2afb90; // 0x2afc98 - g_ps2RecompiledFunctionTable[442161] = ViewProc2_0x2afb90; // 0x2afccc - g_ps2RecompiledFunctionTable[442168] = ViewProc2_0x2afb90; // 0x2afce8 - g_ps2RecompiledFunctionTable[442171] = ViewProc2_0x2afb90; // 0x2afcf4 - g_ps2RecompiledFunctionTable[442176] = ViewProc2_0x2afb90; // 0x2afd08 - g_ps2RecompiledFunctionTable[442182] = ViewProc2_0x2afb90; // 0x2afd20 - g_ps2RecompiledFunctionTable[442187] = ViewProc2_0x2afb90; // 0x2afd34 - g_ps2RecompiledFunctionTable[442194] = ViewProc3_0x2afd50; // 0x2afd50 - g_ps2RecompiledFunctionTable[442272] = ViewProc3_0x2afd50; // 0x2afe88 - g_ps2RecompiledFunctionTable[442292] = ViewProc3_0x2afd50; // 0x2afed8 - g_ps2RecompiledFunctionTable[442302] = ViewProc3_0x2afd50; // 0x2aff00 - g_ps2RecompiledFunctionTable[442336] = ViewProc3_0x2afd50; // 0x2aff88 - g_ps2RecompiledFunctionTable[442348] = ViewProc3_0x2afd50; // 0x2affb8 - g_ps2RecompiledFunctionTable[442360] = ViewProc3_0x2afd50; // 0x2affe8 - g_ps2RecompiledFunctionTable[442370] = ViewProc4_0x2b0010; // 0x2b0010 - g_ps2RecompiledFunctionTable[442418] = ViewProc5_0x2b00d0; // 0x2b00d0 - g_ps2RecompiledFunctionTable[442465] = ViewProc5_0x2b00d0; // 0x2b018c - g_ps2RecompiledFunctionTable[442510] = ViewProc5_0x2b00d0; // 0x2b0240 - g_ps2RecompiledFunctionTable[442534] = ViewProc6_0x2b02a0; // 0x2b02a0 - g_ps2RecompiledFunctionTable[442654] = ViewProc6_0x2b02a0; // 0x2b0480 - g_ps2RecompiledFunctionTable[442674] = ViewProc6_0x2b02a0; // 0x2b04d0 - g_ps2RecompiledFunctionTable[442690] = ViewProc6_0x2b02a0; // 0x2b0510 - g_ps2RecompiledFunctionTable[442705] = ViewProc6_0x2b02a0; // 0x2b054c - g_ps2RecompiledFunctionTable[442734] = ViewProc7_0x2b05c0; // 0x2b05c0 - g_ps2RecompiledFunctionTable[442771] = ViewProc7_0x2b05c0; // 0x2b0654 - g_ps2RecompiledFunctionTable[442774] = DoorProc1_0x2b0660; // 0x2b0660 - g_ps2RecompiledFunctionTable[442851] = DoorProc1_0x2b0660; // 0x2b0794 - g_ps2RecompiledFunctionTable[442895] = DoorProc1_0x2b0660; // 0x2b0844 - g_ps2RecompiledFunctionTable[442946] = DoorProc1_0x2b0660; // 0x2b0910 - g_ps2RecompiledFunctionTable[442972] = DoorProc1_0x2b0660; // 0x2b0978 - g_ps2RecompiledFunctionTable[443002] = DoorProc2_0x2b09f0; // 0x2b09f0 - g_ps2RecompiledFunctionTable[443033] = DoorProc2_0x2b09f0; // 0x2b0a6c - g_ps2RecompiledFunctionTable[443047] = DoorProc2_0x2b09f0; // 0x2b0aa4 - g_ps2RecompiledFunctionTable[443048] = DoorProc2_0x2b09f0; // 0x2b0aa8 - g_ps2RecompiledFunctionTable[443081] = DoorProc2_0x2b09f0; // 0x2b0b2c - g_ps2RecompiledFunctionTable[443097] = DoorProc2_0x2b09f0; // 0x2b0b6c - g_ps2RecompiledFunctionTable[443102] = DoorProc2_0x2b09f0; // 0x2b0b80 - g_ps2RecompiledFunctionTable[443109] = DoorProc2_0x2b09f0; // 0x2b0b9c - g_ps2RecompiledFunctionTable[443114] = DoorProc2_0x2b09f0; // 0x2b0bb0 - g_ps2RecompiledFunctionTable[443142] = DoorProc3_0x2b0c20; // 0x2b0c20 - g_ps2RecompiledFunctionTable[443207] = DoorProc3_0x2b0c20; // 0x2b0d24 - g_ps2RecompiledFunctionTable[443262] = DoorProc3_0x2b0c20; // 0x2b0e00 - g_ps2RecompiledFunctionTable[443269] = DoorProc3_0x2b0c20; // 0x2b0e1c - g_ps2RecompiledFunctionTable[443282] = DoorProc3_0x2b0c20; // 0x2b0e50 - g_ps2RecompiledFunctionTable[443318] = DoorProc4_0x2b0ee0; // 0x2b0ee0 - g_ps2RecompiledFunctionTable[443377] = DoorProc4_0x2b0ee0; // 0x2b0fcc - g_ps2RecompiledFunctionTable[443410] = DoorProc4_0x2b0ee0; // 0x2b1050 - g_ps2RecompiledFunctionTable[443417] = DoorProc4_0x2b0ee0; // 0x2b106c - g_ps2RecompiledFunctionTable[443430] = DoorProc5_0x2b10a0; // 0x2b10a0 - g_ps2RecompiledFunctionTable[443475] = DoorProc5_0x2b10a0; // 0x2b1154 - g_ps2RecompiledFunctionTable[443518] = DoorProc5_0x2b10a0; // 0x2b1200 - g_ps2RecompiledFunctionTable[443541] = DoorProc5_0x2b10a0; // 0x2b125c - g_ps2RecompiledFunctionTable[443562] = DoorProc6_0x2b12b0; // 0x2b12b0 - g_ps2RecompiledFunctionTable[443586] = DoorProc7_0x2b1310; // 0x2b1310 - g_ps2RecompiledFunctionTable[443677] = DoorProc7_0x2b1310; // 0x2b147c - g_ps2RecompiledFunctionTable[443721] = DoorProc7_0x2b1310; // 0x2b152c - g_ps2RecompiledFunctionTable[443772] = DoorProc7_0x2b1310; // 0x2b15f8 - g_ps2RecompiledFunctionTable[443798] = DoorProc7_0x2b1310; // 0x2b1660 - g_ps2RecompiledFunctionTable[443838] = LightProc1_0x2b1700; // 0x2b1700 - g_ps2RecompiledFunctionTable[443856] = LightProc1_0x2b1700; // 0x2b1748 - g_ps2RecompiledFunctionTable[443863] = LightProc1_0x2b1700; // 0x2b1764 - g_ps2RecompiledFunctionTable[443867] = LightProc1_0x2b1700; // 0x2b1774 - g_ps2RecompiledFunctionTable[443882] = LightProc2_0x2b17b0; // 0x2b17b0 - g_ps2RecompiledFunctionTable[443906] = LightProc2_0x2b17b0; // 0x2b1810 - g_ps2RecompiledFunctionTable[443913] = LightProc2_0x2b17b0; // 0x2b182c - g_ps2RecompiledFunctionTable[443917] = LightProc2_0x2b17b0; // 0x2b183c - g_ps2RecompiledFunctionTable[443934] = CompareSint32_0x2b1880; // 0x2b1880 - g_ps2RecompiledFunctionTable[443966] = CompareFloat_0x2b1900; // 0x2b1900 - g_ps2RecompiledFunctionTable[444010] = VectorMove_0x2b19b0; // 0x2b19b0 - g_ps2RecompiledFunctionTable[444023] = VectorMove_0x2b19b0; // 0x2b19e4 - g_ps2RecompiledFunctionTable[444035] = VectorMove_0x2b19b0; // 0x2b1a14 - g_ps2RecompiledFunctionTable[444039] = VectorMove_0x2b19b0; // 0x2b1a24 - g_ps2RecompiledFunctionTable[444045] = VectorMove_0x2b19b0; // 0x2b1a3c - g_ps2RecompiledFunctionTable[444062] = LightSubAmb_0x2b1a80; // 0x2b1a80 - g_ps2RecompiledFunctionTable[444074] = LightSubAmb_0x2b1a80; // 0x2b1ab0 - g_ps2RecompiledFunctionTable[444110] = LightSubAmb_0x2b1a80; // 0x2b1b40 - g_ps2RecompiledFunctionTable[444114] = LightSubPnt_0x2b1b50; // 0x2b1b50 - g_ps2RecompiledFunctionTable[444134] = LightSubPnt_0x2b1b50; // 0x2b1ba0 - g_ps2RecompiledFunctionTable[444139] = LightSubPnt_0x2b1b50; // 0x2b1bb4 - g_ps2RecompiledFunctionTable[444150] = LightSubPnt_0x2b1b50; // 0x2b1be0 - g_ps2RecompiledFunctionTable[444154] = LightSubPnt_0x2b1b50; // 0x2b1bf0 - g_ps2RecompiledFunctionTable[444157] = LightSubPnt_0x2b1b50; // 0x2b1bfc - g_ps2RecompiledFunctionTable[444166] = ryExcuteFade_0x2b1c20; // 0x2b1c20 - g_ps2RecompiledFunctionTable[444179] = ryExcuteFade_0x2b1c20; // 0x2b1c54 - g_ps2RecompiledFunctionTable[444187] = ryExcuteFade_0x2b1c20; // 0x2b1c74 - g_ps2RecompiledFunctionTable[444202] = ryExcuteFade_0x2b1c20; // 0x2b1cb0 - g_ps2RecompiledFunctionTable[444205] = ryExcuteFade_0x2b1c20; // 0x2b1cbc - g_ps2RecompiledFunctionTable[444220] = ryExcuteFade_0x2b1c20; // 0x2b1cf8 - g_ps2RecompiledFunctionTable[444230] = PuruProc1_0x2b1d20; // 0x2b1d20 - g_ps2RecompiledFunctionTable[444282] = PuruProc1_0x2b1d20; // 0x2b1df0 - g_ps2RecompiledFunctionTable[444285] = PuruProc1_0x2b1d20; // 0x2b1dfc - g_ps2RecompiledFunctionTable[444296] = PuruProc1_0x2b1d20; // 0x2b1e28 - g_ps2RecompiledFunctionTable[444302] = DokiProcLgt_0x2b1e40; // 0x2b1e40 - g_ps2RecompiledFunctionTable[444329] = DokiProcLgt_0x2b1e40; // 0x2b1eac - g_ps2RecompiledFunctionTable[444331] = DokiProcLgt_0x2b1e40; // 0x2b1eb4 - g_ps2RecompiledFunctionTable[444335] = DokiProcLgt_0x2b1e40; // 0x2b1ec4 - g_ps2RecompiledFunctionTable[444337] = DokiProcLgt_0x2b1e40; // 0x2b1ecc - g_ps2RecompiledFunctionTable[444346] = bhInitMap_0x2b1ef0; // 0x2b1ef0 - g_ps2RecompiledFunctionTable[444356] = bhInitMap_0x2b1ef0; // 0x2b1f18 - g_ps2RecompiledFunctionTable[444363] = bhInitMap_0x2b1ef0; // 0x2b1f34 - g_ps2RecompiledFunctionTable[444367] = bhInitMap_0x2b1ef0; // 0x2b1f44 - g_ps2RecompiledFunctionTable[444372] = bhInitMap_0x2b1ef0; // 0x2b1f58 - g_ps2RecompiledFunctionTable[444576] = bhInitMap_0x2b1ef0; // 0x2b2288 - g_ps2RecompiledFunctionTable[444584] = bhInitMap_0x2b1ef0; // 0x2b22a8 - g_ps2RecompiledFunctionTable[444586] = bhInitMap_0x2b1ef0; // 0x2b22b0 - g_ps2RecompiledFunctionTable[444598] = bhInitMap_0x2b1ef0; // 0x2b22e0 - g_ps2RecompiledFunctionTable[444601] = bhInitMap_0x2b1ef0; // 0x2b22ec - g_ps2RecompiledFunctionTable[444605] = bhInitMap_0x2b1ef0; // 0x2b22fc - g_ps2RecompiledFunctionTable[444614] = bhInitMap_0x2b1ef0; // 0x2b2320 - g_ps2RecompiledFunctionTable[444618] = bhInitMap_0x2b1ef0; // 0x2b2330 - g_ps2RecompiledFunctionTable[444626] = bhInitMap_0x2b1ef0; // 0x2b2350 - g_ps2RecompiledFunctionTable[444628] = bhInitMap_0x2b1ef0; // 0x2b2358 - g_ps2RecompiledFunctionTable[444630] = bhInitMap_0x2b1ef0; // 0x2b2360 - g_ps2RecompiledFunctionTable[444645] = bhInitMap_0x2b1ef0; // 0x2b239c - g_ps2RecompiledFunctionTable[444650] = bhSetMap_0x2b23b0; // 0x2b23b0 - g_ps2RecompiledFunctionTable[444654] = bhExitMap_0x2b23c0; // 0x2b23c0 - g_ps2RecompiledFunctionTable[444661] = bhExitMap_0x2b23c0; // 0x2b23dc - g_ps2RecompiledFunctionTable[444666] = bhExitMap_0x2b23c0; // 0x2b23f0 - g_ps2RecompiledFunctionTable[444674] = bhExitMap_0x2b23c0; // 0x2b2410 - g_ps2RecompiledFunctionTable[444682] = bhExitMap_0x2b23c0; // 0x2b2430 - g_ps2RecompiledFunctionTable[444685] = bhExitMap_0x2b23c0; // 0x2b243c - g_ps2RecompiledFunctionTable[444692] = bhExitMap_0x2b23c0; // 0x2b2458 - g_ps2RecompiledFunctionTable[444696] = bhExitMap_0x2b23c0; // 0x2b2468 - g_ps2RecompiledFunctionTable[444706] = bhReadMapData_0x2b2490; // 0x2b2490 - g_ps2RecompiledFunctionTable[444729] = bhReadMapData_0x2b2490; // 0x2b24ec - g_ps2RecompiledFunctionTable[444734] = bhReadMapData_0x2b2490; // 0x2b2500 - g_ps2RecompiledFunctionTable[444737] = bhReadMapData_0x2b2490; // 0x2b250c - g_ps2RecompiledFunctionTable[444746] = bhReadMapData_0x2b2490; // 0x2b2530 - g_ps2RecompiledFunctionTable[444762] = bhReadMapData_0x2b2490; // 0x2b2570 - g_ps2RecompiledFunctionTable[444778] = MapCnvStatus2Flag_0x2b25b0; // 0x2b25b0 - g_ps2RecompiledFunctionTable[444804] = MapCnvStatus2Flag_0x2b25b0; // 0x2b2618 - g_ps2RecompiledFunctionTable[444808] = MapCnvStatus2Flag_0x2b25b0; // 0x2b2628 - g_ps2RecompiledFunctionTable[444812] = MapCnvStatus2Flag_0x2b25b0; // 0x2b2638 - g_ps2RecompiledFunctionTable[444816] = MapCnvStatus2Flag_0x2b25b0; // 0x2b2648 - g_ps2RecompiledFunctionTable[444825] = MapCnvStatus2Flag_0x2b25b0; // 0x2b266c - g_ps2RecompiledFunctionTable[444829] = MapCnvStatus2Flag_0x2b25b0; // 0x2b267c - g_ps2RecompiledFunctionTable[444835] = MapCnvStatus2Flag_0x2b25b0; // 0x2b2694 - g_ps2RecompiledFunctionTable[444838] = MapCnvStatus2Flag_0x2b25b0; // 0x2b26a0 - g_ps2RecompiledFunctionTable[444848] = MapCnvStatus2Flag_0x2b25b0; // 0x2b26c8 - g_ps2RecompiledFunctionTable[444866] = bhControlMap_0x2b2710; // 0x2b2710 - g_ps2RecompiledFunctionTable[444894] = bhControlMap_0x2b2710; // 0x2b2780 - g_ps2RecompiledFunctionTable[444898] = bhControlMap_0x2b2710; // 0x2b2790 - g_ps2RecompiledFunctionTable[444902] = bhControlMap_0x2b2710; // 0x2b27a0 - g_ps2RecompiledFunctionTable[444907] = bhControlMap_0x2b2710; // 0x2b27b4 - g_ps2RecompiledFunctionTable[444914] = bhControlMap_0x2b2710; // 0x2b27d0 - g_ps2RecompiledFunctionTable[444916] = bhControlMap_0x2b2710; // 0x2b27d8 - g_ps2RecompiledFunctionTable[444922] = bhControlMap_0x2b2710; // 0x2b27f0 - g_ps2RecompiledFunctionTable[444927] = bhControlMap_0x2b2710; // 0x2b2804 - g_ps2RecompiledFunctionTable[444936] = bhControlMap_0x2b2710; // 0x2b2828 - g_ps2RecompiledFunctionTable[444943] = bhControlMap_0x2b2710; // 0x2b2844 - g_ps2RecompiledFunctionTable[444947] = bhControlMap_0x2b2710; // 0x2b2854 - g_ps2RecompiledFunctionTable[444959] = bhControlMap_0x2b2710; // 0x2b2884 - g_ps2RecompiledFunctionTable[444966] = bhControlMap_0x2b2710; // 0x2b28a0 - g_ps2RecompiledFunctionTable[444984] = bhControlMap_0x2b2710; // 0x2b28e8 - g_ps2RecompiledFunctionTable[444986] = bhControlMap_0x2b2710; // 0x2b28f0 - g_ps2RecompiledFunctionTable[445008] = bhControlMap_0x2b2710; // 0x2b2948 - g_ps2RecompiledFunctionTable[445017] = bhControlMap_0x2b2710; // 0x2b296c - g_ps2RecompiledFunctionTable[445041] = bhControlMap_0x2b2710; // 0x2b29cc - g_ps2RecompiledFunctionTable[445052] = bhControlMap_0x2b2710; // 0x2b29f8 - g_ps2RecompiledFunctionTable[445056] = bhControlMap_0x2b2710; // 0x2b2a08 - g_ps2RecompiledFunctionTable[445060] = bhControlMap_0x2b2710; // 0x2b2a18 - g_ps2RecompiledFunctionTable[445116] = bhControlMap_0x2b2710; // 0x2b2af8 - g_ps2RecompiledFunctionTable[445119] = bhControlMap_0x2b2710; // 0x2b2b04 - g_ps2RecompiledFunctionTable[445132] = bhControlMap_0x2b2710; // 0x2b2b38 - g_ps2RecompiledFunctionTable[445157] = bhControlMap_0x2b2710; // 0x2b2b9c - g_ps2RecompiledFunctionTable[445161] = bhControlMap_0x2b2710; // 0x2b2bac - g_ps2RecompiledFunctionTable[445180] = bhControlMap_0x2b2710; // 0x2b2bf8 - g_ps2RecompiledFunctionTable[445184] = bhControlMap_0x2b2710; // 0x2b2c08 - g_ps2RecompiledFunctionTable[445186] = bhControlMap_0x2b2710; // 0x2b2c10 - g_ps2RecompiledFunctionTable[445199] = bhControlMap_0x2b2710; // 0x2b2c44 - g_ps2RecompiledFunctionTable[445209] = bhControlMap_0x2b2710; // 0x2b2c6c - g_ps2RecompiledFunctionTable[445220] = bhControlMap_0x2b2710; // 0x2b2c98 - g_ps2RecompiledFunctionTable[445253] = bhControlMap_0x2b2710; // 0x2b2d1c - g_ps2RecompiledFunctionTable[445257] = bhControlMap_0x2b2710; // 0x2b2d2c - g_ps2RecompiledFunctionTable[445266] = bhControlMap_0x2b2710; // 0x2b2d50 - g_ps2RecompiledFunctionTable[445279] = bhControlMap_0x2b2710; // 0x2b2d84 - g_ps2RecompiledFunctionTable[445281] = bhControlMap_0x2b2710; // 0x2b2d8c - g_ps2RecompiledFunctionTable[445283] = bhControlMap_0x2b2710; // 0x2b2d94 - g_ps2RecompiledFunctionTable[445285] = bhControlMap_0x2b2710; // 0x2b2d9c - g_ps2RecompiledFunctionTable[445287] = bhControlMap_0x2b2710; // 0x2b2da4 - g_ps2RecompiledFunctionTable[445298] = MapPadMain_0x2b2dd0; // 0x2b2dd0 - g_ps2RecompiledFunctionTable[445430] = MapViewMain_0x2b2fe0; // 0x2b2fe0 - g_ps2RecompiledFunctionTable[445438] = MapViewMain_0x2b2fe0; // 0x2b3000 - g_ps2RecompiledFunctionTable[445441] = MapViewMain_0x2b2fe0; // 0x2b300c - g_ps2RecompiledFunctionTable[445449] = MapViewMain_0x2b2fe0; // 0x2b302c - g_ps2RecompiledFunctionTable[445455] = MapViewMain_0x2b2fe0; // 0x2b3044 - g_ps2RecompiledFunctionTable[445461] = MapViewMain_0x2b2fe0; // 0x2b305c - g_ps2RecompiledFunctionTable[445467] = MapViewMain_0x2b2fe0; // 0x2b3074 - g_ps2RecompiledFunctionTable[445477] = MapViewMain_0x2b2fe0; // 0x2b309c - g_ps2RecompiledFunctionTable[445482] = MapLightMain_0x2b30b0; // 0x2b30b0 - g_ps2RecompiledFunctionTable[445493] = MapLightMain_0x2b30b0; // 0x2b30dc - g_ps2RecompiledFunctionTable[445499] = MapLightMain_0x2b30b0; // 0x2b30f4 - g_ps2RecompiledFunctionTable[445516] = MapLightMain_0x2b30b0; // 0x2b3138 - g_ps2RecompiledFunctionTable[445519] = MapLightMain_0x2b30b0; // 0x2b3144 - g_ps2RecompiledFunctionTable[445522] = MapLightMain_0x2b30b0; // 0x2b3150 - g_ps2RecompiledFunctionTable[445525] = MapLightMain_0x2b30b0; // 0x2b315c - g_ps2RecompiledFunctionTable[445528] = MapLightMain_0x2b30b0; // 0x2b3168 - g_ps2RecompiledFunctionTable[445532] = MapLightMain_0x2b30b0; // 0x2b3178 - g_ps2RecompiledFunctionTable[445542] = MapLightMain_0x2b30b0; // 0x2b31a0 - g_ps2RecompiledFunctionTable[445546] = MapLightMain_0x2b30b0; // 0x2b31b0 - g_ps2RecompiledFunctionTable[445548] = MapLightMain_0x2b30b0; // 0x2b31b8 - g_ps2RecompiledFunctionTable[445550] = MapLightMain_0x2b30b0; // 0x2b31c0 - g_ps2RecompiledFunctionTable[445562] = MapPaletteMain_0x2b31f0; // 0x2b31f0 - g_ps2RecompiledFunctionTable[445575] = MapPaletteMain_0x2b31f0; // 0x2b3224 - g_ps2RecompiledFunctionTable[445582] = MapPaletteMain_0x2b31f0; // 0x2b3240 - g_ps2RecompiledFunctionTable[445589] = MapPaletteMain_0x2b31f0; // 0x2b325c - g_ps2RecompiledFunctionTable[445595] = MapPaletteMain_0x2b31f0; // 0x2b3274 - g_ps2RecompiledFunctionTable[445621] = MapPaletteMain_0x2b31f0; // 0x2b32dc - g_ps2RecompiledFunctionTable[445627] = MapPaletteMain_0x2b31f0; // 0x2b32f4 - g_ps2RecompiledFunctionTable[445653] = MapPaletteMain_0x2b31f0; // 0x2b335c - g_ps2RecompiledFunctionTable[445659] = MapPaletteMain_0x2b31f0; // 0x2b3374 - g_ps2RecompiledFunctionTable[445684] = MapPaletteMain_0x2b31f0; // 0x2b33d8 - g_ps2RecompiledFunctionTable[445689] = MapPaletteMain_0x2b31f0; // 0x2b33ec - g_ps2RecompiledFunctionTable[445722] = MapCodeProcess_0x2b3470; // 0x2b3470 - g_ps2RecompiledFunctionTable[445733] = MapCodeProcess_0x2b3470; // 0x2b349c - g_ps2RecompiledFunctionTable[445736] = MapCodeProcess_0x2b3470; // 0x2b34a8 - g_ps2RecompiledFunctionTable[445738] = MapCodeProcess_0x2b3470; // 0x2b34b0 - g_ps2RecompiledFunctionTable[445740] = MapCodeProcess_0x2b3470; // 0x2b34b8 - g_ps2RecompiledFunctionTable[445748] = MapCodeProcess_0x2b3470; // 0x2b34d8 - g_ps2RecompiledFunctionTable[445751] = MapCodeProcess_0x2b3470; // 0x2b34e4 - g_ps2RecompiledFunctionTable[445775] = MapCodeProcess_0x2b3470; // 0x2b3544 - g_ps2RecompiledFunctionTable[445780] = MapCodeProcess_0x2b3470; // 0x2b3558 - g_ps2RecompiledFunctionTable[445785] = MapCodeProcess_0x2b3470; // 0x2b356c - g_ps2RecompiledFunctionTable[445789] = MapCodeProcess_0x2b3470; // 0x2b357c - g_ps2RecompiledFunctionTable[445791] = MapCodeProcess_0x2b3470; // 0x2b3584 - g_ps2RecompiledFunctionTable[445799] = MapCodeProcess_0x2b3470; // 0x2b35a4 - g_ps2RecompiledFunctionTable[445804] = MapCodeProcess_0x2b3470; // 0x2b35b8 - g_ps2RecompiledFunctionTable[445842] = MapCodeProcess_0x2b3470; // 0x2b3650 - g_ps2RecompiledFunctionTable[445847] = MapCodeProcess_0x2b3470; // 0x2b3664 - g_ps2RecompiledFunctionTable[445850] = MapCodeProcess_0x2b3470; // 0x2b3670 - g_ps2RecompiledFunctionTable[445877] = MapCodeProcess_0x2b3470; // 0x2b36dc - g_ps2RecompiledFunctionTable[445887] = MapCodeProcess_0x2b3470; // 0x2b3704 - g_ps2RecompiledFunctionTable[445913] = MapCodeProcess_0x2b3470; // 0x2b376c - g_ps2RecompiledFunctionTable[445930] = MapCodeProcess_0x2b3470; // 0x2b37b0 - g_ps2RecompiledFunctionTable[445935] = MapCodeProcess_0x2b3470; // 0x2b37c4 - g_ps2RecompiledFunctionTable[445946] = MapCodeProcess_0x2b3470; // 0x2b37f0 - g_ps2RecompiledFunctionTable[445949] = MapCodeProcess_0x2b3470; // 0x2b37fc - g_ps2RecompiledFunctionTable[446014] = MapCodeProcess_0x2b3470; // 0x2b3900 - g_ps2RecompiledFunctionTable[446019] = MapCodeProcess_0x2b3470; // 0x2b3914 - g_ps2RecompiledFunctionTable[446058] = MapCodeProcess_0x2b3470; // 0x2b39b0 - g_ps2RecompiledFunctionTable[446061] = MapCodeProcess_0x2b3470; // 0x2b39bc - g_ps2RecompiledFunctionTable[446123] = MapCodeProcess_0x2b3470; // 0x2b3ab4 - g_ps2RecompiledFunctionTable[446203] = MapCodeProcess_0x2b3470; // 0x2b3bf4 - g_ps2RecompiledFunctionTable[446234] = MapCodeProcess_0x2b3470; // 0x2b3c70 - g_ps2RecompiledFunctionTable[446257] = MapCodeProcess_0x2b3470; // 0x2b3ccc - g_ps2RecompiledFunctionTable[446264] = MapCodeProcess_0x2b3470; // 0x2b3ce8 - g_ps2RecompiledFunctionTable[446266] = MapCodeProcess_0x2b3470; // 0x2b3cf0 - g_ps2RecompiledFunctionTable[446274] = MapBoolSet_0x2b3d10; // 0x2b3d10 - g_ps2RecompiledFunctionTable[446302] = MapDrawMarker_0x2b3d80; // 0x2b3d80 - g_ps2RecompiledFunctionTable[446303] = MapDrawMarker_0x2b3d80; // 0x2b3d84 - g_ps2RecompiledFunctionTable[446304] = MapDrawMarker_0x2b3d80; // 0x2b3d88 - g_ps2RecompiledFunctionTable[446305] = MapDrawMarker_0x2b3d80; // 0x2b3d8c - g_ps2RecompiledFunctionTable[446306] = MapDrawMarker_0x2b3d80; // 0x2b3d90 - g_ps2RecompiledFunctionTable[446307] = MapDrawMarker_0x2b3d80; // 0x2b3d94 - g_ps2RecompiledFunctionTable[446308] = MapDrawMarker_0x2b3d80; // 0x2b3d98 - g_ps2RecompiledFunctionTable[446309] = MapDrawMarker_0x2b3d80; // 0x2b3d9c - g_ps2RecompiledFunctionTable[446310] = MapDrawMarker_0x2b3d80; // 0x2b3da0 - g_ps2RecompiledFunctionTable[446311] = MapDrawMarker_0x2b3d80; // 0x2b3da4 - g_ps2RecompiledFunctionTable[446312] = MapDrawMarker_0x2b3d80; // 0x2b3da8 - g_ps2RecompiledFunctionTable[446313] = MapDrawMarker_0x2b3d80; // 0x2b3dac - g_ps2RecompiledFunctionTable[446314] = MapDrawMarker_0x2b3d80; // 0x2b3db0 - g_ps2RecompiledFunctionTable[446315] = MapDrawMarker_0x2b3d80; // 0x2b3db4 - g_ps2RecompiledFunctionTable[446316] = MapDrawMarker_0x2b3d80; // 0x2b3db8 - g_ps2RecompiledFunctionTable[446317] = MapDrawMarker_0x2b3d80; // 0x2b3dbc - g_ps2RecompiledFunctionTable[446318] = MapDrawMarker_0x2b3d80; // 0x2b3dc0 - g_ps2RecompiledFunctionTable[446319] = MapDrawMarker_0x2b3d80; // 0x2b3dc4 - g_ps2RecompiledFunctionTable[446320] = MapDrawMarker_0x2b3d80; // 0x2b3dc8 - g_ps2RecompiledFunctionTable[446321] = MapDrawMarker_0x2b3d80; // 0x2b3dcc - g_ps2RecompiledFunctionTable[446322] = MapDrawMarker_0x2b3d80; // 0x2b3dd0 - g_ps2RecompiledFunctionTable[446323] = MapDrawMarker_0x2b3d80; // 0x2b3dd4 - g_ps2RecompiledFunctionTable[446324] = MapDrawMarker_0x2b3d80; // 0x2b3dd8 - g_ps2RecompiledFunctionTable[446325] = MapDrawMarker_0x2b3d80; // 0x2b3ddc - g_ps2RecompiledFunctionTable[446326] = MapDrawMarker_0x2b3d80; // 0x2b3de0 - g_ps2RecompiledFunctionTable[446327] = MapDrawMarker_0x2b3d80; // 0x2b3de4 - g_ps2RecompiledFunctionTable[446328] = MapDrawMarker_0x2b3d80; // 0x2b3de8 - g_ps2RecompiledFunctionTable[446329] = MapDrawMarker_0x2b3d80; // 0x2b3dec - g_ps2RecompiledFunctionTable[446330] = MapDrawMarker_0x2b3d80; // 0x2b3df0 - g_ps2RecompiledFunctionTable[446331] = MapDrawMarker_0x2b3d80; // 0x2b3df4 - g_ps2RecompiledFunctionTable[446332] = MapDrawMarker_0x2b3d80; // 0x2b3df8 - g_ps2RecompiledFunctionTable[446333] = MapDrawMarker_0x2b3d80; // 0x2b3dfc - g_ps2RecompiledFunctionTable[446334] = MapDrawMarker_0x2b3d80; // 0x2b3e00 - g_ps2RecompiledFunctionTable[446335] = MapDrawMarker_0x2b3d80; // 0x2b3e04 - g_ps2RecompiledFunctionTable[446336] = MapDrawMarker_0x2b3d80; // 0x2b3e08 - g_ps2RecompiledFunctionTable[446337] = MapDrawMarker_0x2b3d80; // 0x2b3e0c - g_ps2RecompiledFunctionTable[446338] = MapDrawMarker_0x2b3d80; // 0x2b3e10 - g_ps2RecompiledFunctionTable[446339] = MapDrawMarker_0x2b3d80; // 0x2b3e14 - g_ps2RecompiledFunctionTable[446340] = MapDrawMarker_0x2b3d80; // 0x2b3e18 - g_ps2RecompiledFunctionTable[446341] = MapDrawMarker_0x2b3d80; // 0x2b3e1c - g_ps2RecompiledFunctionTable[446342] = MapDrawMarker_0x2b3d80; // 0x2b3e20 - g_ps2RecompiledFunctionTable[446343] = MapDrawMarker_0x2b3d80; // 0x2b3e24 - g_ps2RecompiledFunctionTable[446344] = MapDrawMarker_0x2b3d80; // 0x2b3e28 - g_ps2RecompiledFunctionTable[446345] = MapDrawMarker_0x2b3d80; // 0x2b3e2c - g_ps2RecompiledFunctionTable[446346] = MapDrawMarker_0x2b3d80; // 0x2b3e30 - g_ps2RecompiledFunctionTable[446347] = MapDrawMarker_0x2b3d80; // 0x2b3e34 - g_ps2RecompiledFunctionTable[446348] = MapDrawMarker_0x2b3d80; // 0x2b3e38 - g_ps2RecompiledFunctionTable[446349] = MapDrawMarker_0x2b3d80; // 0x2b3e3c - g_ps2RecompiledFunctionTable[446350] = MapDrawMarker_0x2b3d80; // 0x2b3e40 - g_ps2RecompiledFunctionTable[446351] = MapDrawMarker_0x2b3d80; // 0x2b3e44 - g_ps2RecompiledFunctionTable[446352] = MapDrawMarker_0x2b3d80; // 0x2b3e48 - g_ps2RecompiledFunctionTable[446353] = MapDrawMarker_0x2b3d80; // 0x2b3e4c - g_ps2RecompiledFunctionTable[446354] = MapDrawMarker_0x2b3d80; // 0x2b3e50 - g_ps2RecompiledFunctionTable[446355] = MapDrawMarker_0x2b3d80; // 0x2b3e54 - g_ps2RecompiledFunctionTable[446356] = MapDrawMarker_0x2b3d80; // 0x2b3e58 - g_ps2RecompiledFunctionTable[446357] = MapDrawMarker_0x2b3d80; // 0x2b3e5c - g_ps2RecompiledFunctionTable[446358] = MapDrawMarker_0x2b3d80; // 0x2b3e60 - g_ps2RecompiledFunctionTable[446359] = MapDrawMarker_0x2b3d80; // 0x2b3e64 - g_ps2RecompiledFunctionTable[446360] = MapDrawMarker_0x2b3d80; // 0x2b3e68 - g_ps2RecompiledFunctionTable[446361] = MapDrawMarker_0x2b3d80; // 0x2b3e6c - g_ps2RecompiledFunctionTable[446362] = MapDrawMarker_0x2b3d80; // 0x2b3e70 - g_ps2RecompiledFunctionTable[446363] = MapDrawMarker_0x2b3d80; // 0x2b3e74 - g_ps2RecompiledFunctionTable[446364] = MapDrawMarker_0x2b3d80; // 0x2b3e78 - g_ps2RecompiledFunctionTable[446365] = MapDrawMarker_0x2b3d80; // 0x2b3e7c - g_ps2RecompiledFunctionTable[446366] = MapDrawMarker_0x2b3d80; // 0x2b3e80 - g_ps2RecompiledFunctionTable[446367] = MapDrawMarker_0x2b3d80; // 0x2b3e84 - g_ps2RecompiledFunctionTable[446368] = MapDrawMarker_0x2b3d80; // 0x2b3e88 - g_ps2RecompiledFunctionTable[446369] = MapDrawMarker_0x2b3d80; // 0x2b3e8c - g_ps2RecompiledFunctionTable[446370] = MapDrawMarker_0x2b3d80; // 0x2b3e90 - g_ps2RecompiledFunctionTable[446371] = MapDrawMarker_0x2b3d80; // 0x2b3e94 - g_ps2RecompiledFunctionTable[446372] = MapDrawMarker_0x2b3d80; // 0x2b3e98 - g_ps2RecompiledFunctionTable[446373] = MapDrawMarker_0x2b3d80; // 0x2b3e9c - g_ps2RecompiledFunctionTable[446374] = MapDrawMarker_0x2b3d80; // 0x2b3ea0 - g_ps2RecompiledFunctionTable[446375] = MapDrawMarker_0x2b3d80; // 0x2b3ea4 - g_ps2RecompiledFunctionTable[446376] = MapDrawMarker_0x2b3d80; // 0x2b3ea8 - g_ps2RecompiledFunctionTable[446377] = MapDrawMarker_0x2b3d80; // 0x2b3eac - g_ps2RecompiledFunctionTable[446378] = MapDrawMarker_0x2b3d80; // 0x2b3eb0 - g_ps2RecompiledFunctionTable[446379] = MapDrawMarker_0x2b3d80; // 0x2b3eb4 - g_ps2RecompiledFunctionTable[446380] = MapDrawMarker_0x2b3d80; // 0x2b3eb8 - g_ps2RecompiledFunctionTable[446381] = MapDrawMarker_0x2b3d80; // 0x2b3ebc - g_ps2RecompiledFunctionTable[446382] = MapDrawMarker_0x2b3d80; // 0x2b3ec0 - g_ps2RecompiledFunctionTable[446383] = MapDrawMarker_0x2b3d80; // 0x2b3ec4 - g_ps2RecompiledFunctionTable[446384] = MapDrawMarker_0x2b3d80; // 0x2b3ec8 - g_ps2RecompiledFunctionTable[446385] = MapDrawMarker_0x2b3d80; // 0x2b3ecc - g_ps2RecompiledFunctionTable[446386] = MapDrawMarker_0x2b3d80; // 0x2b3ed0 - g_ps2RecompiledFunctionTable[446387] = MapDrawMarker_0x2b3d80; // 0x2b3ed4 - g_ps2RecompiledFunctionTable[446388] = MapDrawMarker_0x2b3d80; // 0x2b3ed8 - g_ps2RecompiledFunctionTable[446389] = MapDrawMarker_0x2b3d80; // 0x2b3edc - g_ps2RecompiledFunctionTable[446390] = MapDrawMarker_0x2b3d80; // 0x2b3ee0 - g_ps2RecompiledFunctionTable[446391] = MapDrawMarker_0x2b3d80; // 0x2b3ee4 - g_ps2RecompiledFunctionTable[446392] = MapDrawMarker_0x2b3d80; // 0x2b3ee8 - g_ps2RecompiledFunctionTable[446393] = MapDrawMarker_0x2b3d80; // 0x2b3eec - g_ps2RecompiledFunctionTable[446394] = MapDrawMarker_0x2b3d80; // 0x2b3ef0 - g_ps2RecompiledFunctionTable[446395] = MapDrawMarker_0x2b3d80; // 0x2b3ef4 - g_ps2RecompiledFunctionTable[446396] = MapDrawMarker_0x2b3d80; // 0x2b3ef8 - g_ps2RecompiledFunctionTable[446397] = MapDrawMarker_0x2b3d80; // 0x2b3efc - g_ps2RecompiledFunctionTable[446398] = MapDrawMarker_0x2b3d80; // 0x2b3f00 - g_ps2RecompiledFunctionTable[446399] = MapDrawMarker_0x2b3d80; // 0x2b3f04 - g_ps2RecompiledFunctionTable[446400] = MapDrawMarker_0x2b3d80; // 0x2b3f08 - g_ps2RecompiledFunctionTable[446401] = MapDrawMarker_0x2b3d80; // 0x2b3f0c - g_ps2RecompiledFunctionTable[446402] = MapDrawMarker_0x2b3d80; // 0x2b3f10 - g_ps2RecompiledFunctionTable[446403] = MapDrawMarker_0x2b3d80; // 0x2b3f14 - g_ps2RecompiledFunctionTable[446404] = MapDrawMarker_0x2b3d80; // 0x2b3f18 - g_ps2RecompiledFunctionTable[446405] = MapDrawMarker_0x2b3d80; // 0x2b3f1c - g_ps2RecompiledFunctionTable[446406] = MapDrawMarker_0x2b3d80; // 0x2b3f20 - g_ps2RecompiledFunctionTable[446407] = MapDrawMarker_0x2b3d80; // 0x2b3f24 - g_ps2RecompiledFunctionTable[446408] = MapDrawMarker_0x2b3d80; // 0x2b3f28 - g_ps2RecompiledFunctionTable[446409] = MapDrawMarker_0x2b3d80; // 0x2b3f2c - g_ps2RecompiledFunctionTable[446410] = MapDrawMarker_0x2b3d80; // 0x2b3f30 - g_ps2RecompiledFunctionTable[446411] = MapDrawMarker_0x2b3d80; // 0x2b3f34 - g_ps2RecompiledFunctionTable[446412] = MapDrawMarker_0x2b3d80; // 0x2b3f38 - g_ps2RecompiledFunctionTable[446413] = MapDrawMarker_0x2b3d80; // 0x2b3f3c - g_ps2RecompiledFunctionTable[446414] = MapDrawMarker_0x2b3d80; // 0x2b3f40 - g_ps2RecompiledFunctionTable[446415] = MapDrawMarker_0x2b3d80; // 0x2b3f44 - g_ps2RecompiledFunctionTable[446416] = MapDrawMarker_0x2b3d80; // 0x2b3f48 - g_ps2RecompiledFunctionTable[446417] = MapDrawMarker_0x2b3d80; // 0x2b3f4c - g_ps2RecompiledFunctionTable[446418] = MapDrawMarker_0x2b3d80; // 0x2b3f50 - g_ps2RecompiledFunctionTable[446419] = MapDrawMarker_0x2b3d80; // 0x2b3f54 - g_ps2RecompiledFunctionTable[446420] = MapDrawMarker_0x2b3d80; // 0x2b3f58 - g_ps2RecompiledFunctionTable[446421] = MapDrawMarker_0x2b3d80; // 0x2b3f5c - g_ps2RecompiledFunctionTable[446422] = MapDrawMarker_0x2b3d80; // 0x2b3f60 - g_ps2RecompiledFunctionTable[446423] = MapDrawMarker_0x2b3d80; // 0x2b3f64 - g_ps2RecompiledFunctionTable[446424] = MapDrawMarker_0x2b3d80; // 0x2b3f68 - g_ps2RecompiledFunctionTable[446425] = MapDrawMarker_0x2b3d80; // 0x2b3f6c - g_ps2RecompiledFunctionTable[446426] = MapDrawBackground_0x2b3f70; // 0x2b3f70 - g_ps2RecompiledFunctionTable[446441] = MapDrawBackground_0x2b3f70; // 0x2b3fac - g_ps2RecompiledFunctionTable[446446] = MapDrawBackground_0x2b3f70; // 0x2b3fc0 - g_ps2RecompiledFunctionTable[446449] = MapDrawBackground_0x2b3f70; // 0x2b3fcc - g_ps2RecompiledFunctionTable[446453] = MapDrawBackground_0x2b3f70; // 0x2b3fdc - g_ps2RecompiledFunctionTable[446459] = MapDrawBackground_0x2b3f70; // 0x2b3ff4 - g_ps2RecompiledFunctionTable[446464] = MapDrawBackground_0x2b3f70; // 0x2b4008 - g_ps2RecompiledFunctionTable[446471] = MapDrawBackground_0x2b3f70; // 0x2b4024 - g_ps2RecompiledFunctionTable[446490] = MapDrawBackground_0x2b3f70; // 0x2b4070 - g_ps2RecompiledFunctionTable[446493] = MapDrawBackground_0x2b3f70; // 0x2b407c - g_ps2RecompiledFunctionTable[446498] = MapDrawBackground_0x2b3f70; // 0x2b4090 - g_ps2RecompiledFunctionTable[446501] = MapDrawBackground_0x2b3f70; // 0x2b409c - g_ps2RecompiledFunctionTable[446503] = MapDrawBackground_0x2b3f70; // 0x2b40a4 - g_ps2RecompiledFunctionTable[446510] = MapDrawBackground_0x2b3f70; // 0x2b40c0 - g_ps2RecompiledFunctionTable[446534] = MapDrawSprite_0x2b4120; // 0x2b4120 - g_ps2RecompiledFunctionTable[446576] = MapDrawSprite_0x2b4120; // 0x2b41c8 - g_ps2RecompiledFunctionTable[446584] = MapDrawSprite_0x2b4120; // 0x2b41e8 - g_ps2RecompiledFunctionTable[446586] = MapDrawSprite_0x2b4120; // 0x2b41f0 - g_ps2RecompiledFunctionTable[446592] = MapDrawSprite_0x2b4120; // 0x2b4208 - g_ps2RecompiledFunctionTable[446600] = MapDrawSprite_0x2b4120; // 0x2b4228 - g_ps2RecompiledFunctionTable[446602] = MapDrawSprite_0x2b4120; // 0x2b4230 - g_ps2RecompiledFunctionTable[446608] = MapDrawSprite_0x2b4120; // 0x2b4248 - g_ps2RecompiledFunctionTable[446616] = MapDrawSprite_0x2b4120; // 0x2b4268 - g_ps2RecompiledFunctionTable[446618] = MapDrawSprite_0x2b4120; // 0x2b4270 - g_ps2RecompiledFunctionTable[446624] = MapDrawSprite_0x2b4120; // 0x2b4288 - g_ps2RecompiledFunctionTable[446632] = MapDrawSprite_0x2b4120; // 0x2b42a8 - g_ps2RecompiledFunctionTable[446634] = MapDrawSprite_0x2b4120; // 0x2b42b0 - g_ps2RecompiledFunctionTable[446637] = MapDrawSprite_0x2b4120; // 0x2b42bc - g_ps2RecompiledFunctionTable[446642] = MapDrawSprite_0x2b4120; // 0x2b42d0 - g_ps2RecompiledFunctionTable[446650] = MapGetFloorNo_0x2b42f0; // 0x2b42f0 - g_ps2RecompiledFunctionTable[446663] = MapGetFloorNo_0x2b42f0; // 0x2b4324 - g_ps2RecompiledFunctionTable[446694] = MapPurgeTree_0x2b43a0; // 0x2b43a0 - g_ps2RecompiledFunctionTable[446704] = MapPurgeTree_0x2b43a0; // 0x2b43c8 - g_ps2RecompiledFunctionTable[446706] = MapPurgeTree_0x2b43a0; // 0x2b43d0 - g_ps2RecompiledFunctionTable[446709] = MapPurgeTree_0x2b43a0; // 0x2b43dc - g_ps2RecompiledFunctionTable[446714] = MapPurgeTree_0x2b43a0; // 0x2b43f0 - g_ps2RecompiledFunctionTable[446719] = MapPurgeTree_0x2b43a0; // 0x2b4404 - g_ps2RecompiledFunctionTable[446724] = MapPurgeTree_0x2b43a0; // 0x2b4418 - g_ps2RecompiledFunctionTable[446726] = MapPurgeTree_0x2b43a0; // 0x2b4420 - g_ps2RecompiledFunctionTable[446729] = MapPurgeTree_0x2b43a0; // 0x2b442c - g_ps2RecompiledFunctionTable[446734] = MapPurgeTree_0x2b43a0; // 0x2b4440 - g_ps2RecompiledFunctionTable[446738] = MapPurgeTree_0x2b43a0; // 0x2b4450 - g_ps2RecompiledFunctionTable[446743] = MapPurgeTree_0x2b43a0; // 0x2b4464 - g_ps2RecompiledFunctionTable[446747] = MapPurgeTree_0x2b43a0; // 0x2b4474 - g_ps2RecompiledFunctionTable[446752] = MapPurgeTree_0x2b43a0; // 0x2b4488 - g_ps2RecompiledFunctionTable[446764] = MapPurgeTree_0x2b43a0; // 0x2b44b8 - g_ps2RecompiledFunctionTable[446772] = MapPurgeTree_0x2b43a0; // 0x2b44d8 - g_ps2RecompiledFunctionTable[446778] = MapFuncInit_0x2b44f0; // 0x2b44f0 - g_ps2RecompiledFunctionTable[446787] = MapFuncInit_0x2b44f0; // 0x2b4514 - g_ps2RecompiledFunctionTable[446801] = MapFuncInit_0x2b44f0; // 0x2b454c - g_ps2RecompiledFunctionTable[446806] = MapFuncInit_0x2b44f0; // 0x2b4560 - g_ps2RecompiledFunctionTable[446818] = MapFuncAlloc_0x2b4590; // 0x2b4590 - g_ps2RecompiledFunctionTable[446831] = MapFuncAlloc_0x2b4590; // 0x2b45c4 - g_ps2RecompiledFunctionTable[446836] = MapFuncAlloc_0x2b4590; // 0x2b45d8 - g_ps2RecompiledFunctionTable[446858] = MapFuncFree_0x2b4630; // 0x2b4630 - g_ps2RecompiledFunctionTable[446863] = MapFuncFree_0x2b4630; // 0x2b4644 - g_ps2RecompiledFunctionTable[446868] = MapFuncFree_0x2b4630; // 0x2b4658 - g_ps2RecompiledFunctionTable[446874] = MapFuncDel_0x2b4670; // 0x2b4670 - g_ps2RecompiledFunctionTable[446882] = MapFuncIns_0x2b4690; // 0x2b4690 - g_ps2RecompiledFunctionTable[446890] = MapFuncExec_0x2b46b0; // 0x2b46b0 - g_ps2RecompiledFunctionTable[446891] = MapFuncExec_0x2b46b0; // 0x2b46b4 - g_ps2RecompiledFunctionTable[446892] = MapFuncExec_0x2b46b0; // 0x2b46b8 - g_ps2RecompiledFunctionTable[446893] = MapFuncExec_0x2b46b0; // 0x2b46bc - g_ps2RecompiledFunctionTable[446894] = MapFuncExec_0x2b46b0; // 0x2b46c0 - g_ps2RecompiledFunctionTable[446895] = MapFuncExec_0x2b46b0; // 0x2b46c4 - g_ps2RecompiledFunctionTable[446896] = MapFuncExec_0x2b46b0; // 0x2b46c8 - g_ps2RecompiledFunctionTable[446897] = MapFuncExec_0x2b46b0; // 0x2b46cc - g_ps2RecompiledFunctionTable[446898] = MapFuncExec_0x2b46b0; // 0x2b46d0 - g_ps2RecompiledFunctionTable[446899] = MapFuncExec_0x2b46b0; // 0x2b46d4 - g_ps2RecompiledFunctionTable[446900] = MapFuncExec_0x2b46b0; // 0x2b46d8 - g_ps2RecompiledFunctionTable[446901] = MapFuncExec_0x2b46b0; // 0x2b46dc - g_ps2RecompiledFunctionTable[446902] = MapFuncExec_0x2b46b0; // 0x2b46e0 - g_ps2RecompiledFunctionTable[446903] = MapFuncExec_0x2b46b0; // 0x2b46e4 - g_ps2RecompiledFunctionTable[446904] = MapFuncExec_0x2b46b0; // 0x2b46e8 - g_ps2RecompiledFunctionTable[446905] = MapFuncExec_0x2b46b0; // 0x2b46ec - g_ps2RecompiledFunctionTable[446906] = MapFuncExec_0x2b46b0; // 0x2b46f0 - g_ps2RecompiledFunctionTable[446907] = MapFuncExec_0x2b46b0; // 0x2b46f4 - g_ps2RecompiledFunctionTable[446908] = MapFuncExec_0x2b46b0; // 0x2b46f8 - g_ps2RecompiledFunctionTable[446909] = MapFuncExec_0x2b46b0; // 0x2b46fc - g_ps2RecompiledFunctionTable[446910] = MapFuncExec_0x2b46b0; // 0x2b4700 - g_ps2RecompiledFunctionTable[446911] = MapFuncExec_0x2b46b0; // 0x2b4704 - g_ps2RecompiledFunctionTable[446912] = MapFuncExec_0x2b46b0; // 0x2b4708 - g_ps2RecompiledFunctionTable[446913] = MapFuncExec_0x2b46b0; // 0x2b470c - g_ps2RecompiledFunctionTable[446914] = MapFuncExec_0x2b46b0; // 0x2b4710 - g_ps2RecompiledFunctionTable[446918] = FsubMapDraw_0x2b4720; // 0x2b4720 - g_ps2RecompiledFunctionTable[446931] = FsubMapDraw_0x2b4720; // 0x2b4754 - g_ps2RecompiledFunctionTable[446941] = FsubMapDraw_0x2b4720; // 0x2b477c - g_ps2RecompiledFunctionTable[446953] = FsubMapDraw_0x2b4720; // 0x2b47ac - g_ps2RecompiledFunctionTable[446959] = FsubMapDraw_0x2b4720; // 0x2b47c4 - g_ps2RecompiledFunctionTable[446966] = FsubBackDraw_0x2b47e0; // 0x2b47e0 - g_ps2RecompiledFunctionTable[446974] = FsubBackDraw_0x2b47e0; // 0x2b4800 - g_ps2RecompiledFunctionTable[446978] = MapEntrySprite_0x2b4810; // 0x2b4810 - g_ps2RecompiledFunctionTable[446992] = MapEntrySprite_0x2b4810; // 0x2b4848 - g_ps2RecompiledFunctionTable[447018] = FsprSpriteDraw_0x2b48b0; // 0x2b48b0 - g_ps2RecompiledFunctionTable[447030] = FsprSpriteDraw_0x2b48b0; // 0x2b48e0 - g_ps2RecompiledFunctionTable[447039] = FsprSpriteDraw_0x2b48b0; // 0x2b4904 - g_ps2RecompiledFunctionTable[447046] = FsprSilhouetteDraw_0x2b4920; // 0x2b4920 - g_ps2RecompiledFunctionTable[447080] = FsprSilhouetteDraw_0x2b4920; // 0x2b49a8 - g_ps2RecompiledFunctionTable[447084] = FsprSilhouetteDraw_0x2b4920; // 0x2b49b8 - g_ps2RecompiledFunctionTable[447090] = FsprArrowDraw_0x2b49d0; // 0x2b49d0 - g_ps2RecompiledFunctionTable[447124] = FsprArrowDraw_0x2b49d0; // 0x2b4a58 - g_ps2RecompiledFunctionTable[447135] = FsprArrowDraw_0x2b49d0; // 0x2b4a84 - g_ps2RecompiledFunctionTable[447146] = FsprArrowDraw_0x2b49d0; // 0x2b4ab0 - g_ps2RecompiledFunctionTable[447156] = FsprArrowDraw_0x2b49d0; // 0x2b4ad8 - g_ps2RecompiledFunctionTable[447166] = FsprArrowDraw_0x2b49d0; // 0x2b4b00 - g_ps2RecompiledFunctionTable[447169] = FsprArrowDraw_0x2b49d0; // 0x2b4b0c - g_ps2RecompiledFunctionTable[447172] = FsprArrowDraw_0x2b49d0; // 0x2b4b18 - g_ps2RecompiledFunctionTable[447234] = FsprArrowDraw_0x2b49d0; // 0x2b4c10 - g_ps2RecompiledFunctionTable[447247] = FsprArrowDraw_0x2b49d0; // 0x2b4c44 - g_ps2RecompiledFunctionTable[447251] = FsprArrowDraw_0x2b49d0; // 0x2b4c54 - g_ps2RecompiledFunctionTable[447269] = FsprArrowDraw_0x2b49d0; // 0x2b4c9c - g_ps2RecompiledFunctionTable[447273] = FsprArrowDraw_0x2b49d0; // 0x2b4cac - g_ps2RecompiledFunctionTable[447298] = FsprArrowDraw2_0x2b4d10; // 0x2b4d10 - g_ps2RecompiledFunctionTable[447336] = FsprArrowDraw2_0x2b4d10; // 0x2b4da8 - g_ps2RecompiledFunctionTable[447348] = FsprArrowDraw2_0x2b4d10; // 0x2b4dd8 - g_ps2RecompiledFunctionTable[447360] = FsprArrowDraw2_0x2b4d10; // 0x2b4e08 - g_ps2RecompiledFunctionTable[447371] = FsprArrowDraw2_0x2b4d10; // 0x2b4e34 - g_ps2RecompiledFunctionTable[447382] = FsprArrowDraw2_0x2b4d10; // 0x2b4e60 - g_ps2RecompiledFunctionTable[447385] = FsprArrowDraw2_0x2b4d10; // 0x2b4e6c - g_ps2RecompiledFunctionTable[447397] = FsprArrowDraw2_0x2b4d10; // 0x2b4e9c - g_ps2RecompiledFunctionTable[447426] = MapEntryTask_0x2b4f10; // 0x2b4f10 - g_ps2RecompiledFunctionTable[447438] = MapEntryTask_0x2b4f10; // 0x2b4f40 - g_ps2RecompiledFunctionTable[447458] = FsubTaskMain_0x2b4f90; // 0x2b4f90 - g_ps2RecompiledFunctionTable[447459] = FsubTaskMain_0x2b4f90; // 0x2b4f94 - g_ps2RecompiledFunctionTable[447460] = FsubTaskMain_0x2b4f90; // 0x2b4f98 - g_ps2RecompiledFunctionTable[447461] = FsubTaskMain_0x2b4f90; // 0x2b4f9c - g_ps2RecompiledFunctionTable[447462] = FsubTaskMain_0x2b4f90; // 0x2b4fa0 - g_ps2RecompiledFunctionTable[447463] = FsubTaskMain_0x2b4f90; // 0x2b4fa4 - g_ps2RecompiledFunctionTable[447464] = FsubTaskMain_0x2b4f90; // 0x2b4fa8 - g_ps2RecompiledFunctionTable[447465] = FsubTaskMain_0x2b4f90; // 0x2b4fac - g_ps2RecompiledFunctionTable[447466] = FsubTaskMain_0x2b4f90; // 0x2b4fb0 - g_ps2RecompiledFunctionTable[447467] = FsubTaskMain_0x2b4f90; // 0x2b4fb4 - g_ps2RecompiledFunctionTable[447468] = FsubTaskMain_0x2b4f90; // 0x2b4fb8 - g_ps2RecompiledFunctionTable[447469] = FsubTaskMain_0x2b4f90; // 0x2b4fbc - g_ps2RecompiledFunctionTable[447470] = FsubTaskMain_0x2b4f90; // 0x2b4fc0 - g_ps2RecompiledFunctionTable[447471] = FsubTaskMain_0x2b4f90; // 0x2b4fc4 - g_ps2RecompiledFunctionTable[447472] = FsubTaskMain_0x2b4f90; // 0x2b4fc8 - g_ps2RecompiledFunctionTable[447473] = FsubTaskMain_0x2b4f90; // 0x2b4fcc - g_ps2RecompiledFunctionTable[447474] = FsubTaskMain_0x2b4f90; // 0x2b4fd0 - g_ps2RecompiledFunctionTable[447475] = FsubTaskMain_0x2b4f90; // 0x2b4fd4 - g_ps2RecompiledFunctionTable[447476] = FsubTaskMain_0x2b4f90; // 0x2b4fd8 - g_ps2RecompiledFunctionTable[447478] = FtskMapWait_0x2b4fe0; // 0x2b4fe0 - g_ps2RecompiledFunctionTable[447490] = FtskMapExit_0x2b5010; // 0x2b5010 - g_ps2RecompiledFunctionTable[447502] = FtskMapRead_0x2b5040; // 0x2b5040 - g_ps2RecompiledFunctionTable[447521] = FtskMapRead_0x2b5040; // 0x2b508c - g_ps2RecompiledFunctionTable[447530] = FtskMapNormal_0x2b50b0; // 0x2b50b0 - g_ps2RecompiledFunctionTable[447546] = FtskMapNormal_0x2b50b0; // 0x2b50f0 - g_ps2RecompiledFunctionTable[447562] = FtskMapNormal_0x2b50b0; // 0x2b5130 - g_ps2RecompiledFunctionTable[447570] = FtskMapNormal_0x2b50b0; // 0x2b5150 - g_ps2RecompiledFunctionTable[447577] = FtskMapNormal_0x2b50b0; // 0x2b516c - g_ps2RecompiledFunctionTable[447584] = FtskMapNormal_0x2b50b0; // 0x2b5188 - g_ps2RecompiledFunctionTable[447591] = FtskMapNormal_0x2b50b0; // 0x2b51a4 - g_ps2RecompiledFunctionTable[447603] = FtskMapNormal_0x2b50b0; // 0x2b51d4 - g_ps2RecompiledFunctionTable[447622] = FtskMapZoom_0x2b5220; // 0x2b5220 - g_ps2RecompiledFunctionTable[447637] = FtskMapZoom_0x2b5220; // 0x2b525c - g_ps2RecompiledFunctionTable[447681] = FtskMapZoom_0x2b5220; // 0x2b530c - g_ps2RecompiledFunctionTable[447685] = FtskMapZoom_0x2b5220; // 0x2b531c - g_ps2RecompiledFunctionTable[447688] = FtskMapZoom_0x2b5220; // 0x2b5328 - g_ps2RecompiledFunctionTable[447691] = FtskMapZoom_0x2b5220; // 0x2b5334 - g_ps2RecompiledFunctionTable[447694] = FtskMapZoom_0x2b5220; // 0x2b5340 - g_ps2RecompiledFunctionTable[447697] = FtskMapZoom_0x2b5220; // 0x2b534c - g_ps2RecompiledFunctionTable[447700] = FtskMapZoom_0x2b5220; // 0x2b5358 - g_ps2RecompiledFunctionTable[447704] = FtskMapZoom_0x2b5220; // 0x2b5368 - g_ps2RecompiledFunctionTable[447721] = FtskMapZoom_0x2b5220; // 0x2b53ac - g_ps2RecompiledFunctionTable[447781] = FtskMapZoom_0x2b5220; // 0x2b549c - g_ps2RecompiledFunctionTable[447830] = FsubGaugeDrawZ_0x2b5560; // 0x2b5560 - g_ps2RecompiledFunctionTable[447874] = FsubGaugeDrawZ_0x2b5560; // 0x2b5610 - g_ps2RecompiledFunctionTable[447886] = FsubGaugeDrawZ_0x2b5560; // 0x2b5640 - g_ps2RecompiledFunctionTable[447892] = FsubGaugeDrawZ_0x2b5560; // 0x2b5658 - g_ps2RecompiledFunctionTable[447904] = FsubGaugeDrawZ_0x2b5560; // 0x2b5688 - g_ps2RecompiledFunctionTable[447906] = FsubGaugeDrawZ_0x2b5560; // 0x2b5690 - g_ps2RecompiledFunctionTable[447919] = FsubGaugeDrawZ_0x2b5560; // 0x2b56c4 - g_ps2RecompiledFunctionTable[447927] = FsubGaugeDrawZ_0x2b5560; // 0x2b56e4 - g_ps2RecompiledFunctionTable[447938] = FsubGaugeDrawZ_0x2b5560; // 0x2b5710 - g_ps2RecompiledFunctionTable[447953] = FsubGaugeDrawZ_0x2b5560; // 0x2b574c - g_ps2RecompiledFunctionTable[447961] = FsubGaugeDrawZ_0x2b5560; // 0x2b576c - g_ps2RecompiledFunctionTable[447967] = FsubGaugeDrawZ_0x2b5560; // 0x2b5784 - g_ps2RecompiledFunctionTable[447969] = FsubGaugeDrawZ_0x2b5560; // 0x2b578c - g_ps2RecompiledFunctionTable[447972] = FsubGaugeDrawZ_0x2b5560; // 0x2b5798 - g_ps2RecompiledFunctionTable[447987] = FsubGaugeDrawZ_0x2b5560; // 0x2b57d4 - g_ps2RecompiledFunctionTable[448015] = FsubGaugeDrawZ_0x2b5560; // 0x2b5844 - g_ps2RecompiledFunctionTable[448032] = FsubGaugeDrawZ_0x2b5560; // 0x2b5888 - g_ps2RecompiledFunctionTable[448058] = FsubGaugeDrawX_0x2b58f0; // 0x2b58f0 - g_ps2RecompiledFunctionTable[448104] = FsubGaugeDrawX_0x2b58f0; // 0x2b59a8 - g_ps2RecompiledFunctionTable[448115] = FsubGaugeDrawX_0x2b58f0; // 0x2b59d4 - g_ps2RecompiledFunctionTable[448122] = FsubGaugeDrawX_0x2b58f0; // 0x2b59f0 - g_ps2RecompiledFunctionTable[448134] = FsubGaugeDrawX_0x2b58f0; // 0x2b5a20 - g_ps2RecompiledFunctionTable[448140] = FsubGaugeDrawX_0x2b58f0; // 0x2b5a38 - g_ps2RecompiledFunctionTable[448153] = FsubGaugeDrawX_0x2b58f0; // 0x2b5a6c - g_ps2RecompiledFunctionTable[448161] = FsubGaugeDrawX_0x2b58f0; // 0x2b5a8c - g_ps2RecompiledFunctionTable[448172] = FsubGaugeDrawX_0x2b58f0; // 0x2b5ab8 - g_ps2RecompiledFunctionTable[448187] = FsubGaugeDrawX_0x2b58f0; // 0x2b5af4 - g_ps2RecompiledFunctionTable[448195] = FsubGaugeDrawX_0x2b58f0; // 0x2b5b14 - g_ps2RecompiledFunctionTable[448201] = FsubGaugeDrawX_0x2b58f0; // 0x2b5b2c - g_ps2RecompiledFunctionTable[448203] = FsubGaugeDrawX_0x2b58f0; // 0x2b5b34 - g_ps2RecompiledFunctionTable[448206] = FsubGaugeDrawX_0x2b58f0; // 0x2b5b40 - g_ps2RecompiledFunctionTable[448221] = FsubGaugeDrawX_0x2b58f0; // 0x2b5b7c - g_ps2RecompiledFunctionTable[448249] = FsubGaugeDrawX_0x2b58f0; // 0x2b5bec - g_ps2RecompiledFunctionTable[448266] = FsubGaugeDrawX_0x2b58f0; // 0x2b5c30 - g_ps2RecompiledFunctionTable[448294] = FsubGaugeDraw_0x2b5ca0; // 0x2b5ca0 - g_ps2RecompiledFunctionTable[448302] = FsubGaugeDraw_0x2b5ca0; // 0x2b5cc0 - g_ps2RecompiledFunctionTable[448304] = FsubGaugeDraw_0x2b5ca0; // 0x2b5cc8 - g_ps2RecompiledFunctionTable[448337] = FsubGaugeDraw_0x2b5ca0; // 0x2b5d4c - g_ps2RecompiledFunctionTable[448354] = FsubGaugeDraw_0x2b5ca0; // 0x2b5d90 - g_ps2RecompiledFunctionTable[448380] = FsubGaugeDraw_0x2b5ca0; // 0x2b5df8 - g_ps2RecompiledFunctionTable[448388] = FsubGaugeDraw_0x2b5ca0; // 0x2b5e18 - g_ps2RecompiledFunctionTable[448398] = MapTagInit_0x2b5e40; // 0x2b5e40 - g_ps2RecompiledFunctionTable[448406] = MapTagInit_0x2b5e40; // 0x2b5e60 - g_ps2RecompiledFunctionTable[448414] = MapTagEntry_0x2b5e80; // 0x2b5e80 - g_ps2RecompiledFunctionTable[448429] = MapTagEntry_0x2b5e80; // 0x2b5ebc - g_ps2RecompiledFunctionTable[448442] = MapTagConnect_0x2b5ef0; // 0x2b5ef0 - g_ps2RecompiledFunctionTable[448458] = MapTagConnect_0x2b5ef0; // 0x2b5f30 - g_ps2RecompiledFunctionTable[448476] = MapTagConnect_0x2b5ef0; // 0x2b5f78 - g_ps2RecompiledFunctionTable[448487] = MapTagConnect_0x2b5ef0; // 0x2b5fa4 - g_ps2RecompiledFunctionTable[448492] = MapTagConnect_0x2b5ef0; // 0x2b5fb8 - g_ps2RecompiledFunctionTable[448530] = MapTagCenter_0x2b6050; // 0x2b6050 - g_ps2RecompiledFunctionTable[448547] = MapTagCenter_0x2b6050; // 0x2b6094 - g_ps2RecompiledFunctionTable[448561] = MapTagCenter_0x2b6050; // 0x2b60cc - g_ps2RecompiledFunctionTable[448582] = MapDrawLine2_0x2b6120; // 0x2b6120 - g_ps2RecompiledFunctionTable[448606] = MapDrawLine_0x2b6180; // 0x2b6180 - g_ps2RecompiledFunctionTable[448618] = MapDrawLine_0x2b6180; // 0x2b61b0 - g_ps2RecompiledFunctionTable[448625] = MapDrawLine_0x2b6180; // 0x2b61cc - g_ps2RecompiledFunctionTable[448632] = MapDrawLine_0x2b6180; // 0x2b61e8 - g_ps2RecompiledFunctionTable[448639] = MapDrawLine_0x2b6180; // 0x2b6204 - g_ps2RecompiledFunctionTable[448655] = MapDrawLine_0x2b6180; // 0x2b6244 - g_ps2RecompiledFunctionTable[448662] = MapDrawFill_0x2b6260; // 0x2b6260 - g_ps2RecompiledFunctionTable[448690] = MapDrawPolyFill_0x2b62d0; // 0x2b62d0 - g_ps2RecompiledFunctionTable[448706] = MapDrawMessage_0x2b6310; // 0x2b6310 - g_ps2RecompiledFunctionTable[448710] = FsubZoomCursor_0x2b6320; // 0x2b6320 - g_ps2RecompiledFunctionTable[448769] = FsubZoomCursor_0x2b6320; // 0x2b640c - g_ps2RecompiledFunctionTable[448792] = FsubZoomCursor_0x2b6320; // 0x2b6468 - g_ps2RecompiledFunctionTable[448803] = FsubZoomCursor_0x2b6320; // 0x2b6494 - g_ps2RecompiledFunctionTable[448808] = FsubZoomCursor_0x2b6320; // 0x2b64a8 - g_ps2RecompiledFunctionTable[448815] = FsubZoomCursor_0x2b6320; // 0x2b64c4 - g_ps2RecompiledFunctionTable[448820] = FsubZoomCursor_0x2b6320; // 0x2b64d8 - g_ps2RecompiledFunctionTable[448828] = FsubZoomCursor_0x2b6320; // 0x2b64f8 - g_ps2RecompiledFunctionTable[448840] = FsubZoomCursor_0x2b6320; // 0x2b6528 - g_ps2RecompiledFunctionTable[448852] = FsubZoomCursor_0x2b6320; // 0x2b6558 - g_ps2RecompiledFunctionTable[448864] = FsubZoomCursor_0x2b6320; // 0x2b6588 - g_ps2RecompiledFunctionTable[448876] = FsubZoomCursor_0x2b6320; // 0x2b65b8 - g_ps2RecompiledFunctionTable[448888] = FsubZoomCursor_0x2b6320; // 0x2b65e8 - g_ps2RecompiledFunctionTable[448900] = FsubZoomCursor_0x2b6320; // 0x2b6618 - g_ps2RecompiledFunctionTable[448912] = FsubZoomCursor_0x2b6320; // 0x2b6648 - g_ps2RecompiledFunctionTable[448922] = FsubZoomInfomation_0x2b6670; // 0x2b6670 - g_ps2RecompiledFunctionTable[448960] = FsubZoomInfomation_0x2b6670; // 0x2b6708 - g_ps2RecompiledFunctionTable[448980] = FsubZoomInfomation_0x2b6670; // 0x2b6758 - g_ps2RecompiledFunctionTable[448984] = FsubZoomInfomation_0x2b6670; // 0x2b6768 - g_ps2RecompiledFunctionTable[448993] = FsubZoomInfomation_0x2b6670; // 0x2b678c - g_ps2RecompiledFunctionTable[449006] = FsubZoomInfomation_0x2b6670; // 0x2b67c0 - g_ps2RecompiledFunctionTable[449010] = FsubZoomInfomation_0x2b6670; // 0x2b67d0 - g_ps2RecompiledFunctionTable[449019] = FsubZoomInfomation_0x2b6670; // 0x2b67f4 - g_ps2RecompiledFunctionTable[449032] = FsubZoomInfomation_0x2b6670; // 0x2b6828 - g_ps2RecompiledFunctionTable[449036] = FsubZoomInfomation_0x2b6670; // 0x2b6838 - g_ps2RecompiledFunctionTable[449045] = FsubZoomInfomation_0x2b6670; // 0x2b685c - g_ps2RecompiledFunctionTable[449054] = FsubZoomInfomation_0x2b6670; // 0x2b6880 - g_ps2RecompiledFunctionTable[449066] = FsubZoomInfomation_0x2b6670; // 0x2b68b0 - g_ps2RecompiledFunctionTable[449074] = MapCnvArgb2Color_0x2b68d0; // 0x2b68d0 - g_ps2RecompiledFunctionTable[449085] = MapCnvArgb2Color_0x2b68d0; // 0x2b68fc - g_ps2RecompiledFunctionTable[449091] = MapCnvArgb2Color_0x2b68d0; // 0x2b6914 - g_ps2RecompiledFunctionTable[449097] = MapCnvArgb2Color_0x2b68d0; // 0x2b692c - g_ps2RecompiledFunctionTable[449103] = MapCnvArgb2Color_0x2b68d0; // 0x2b6944 - g_ps2RecompiledFunctionTable[449114] = FsubZoomScreen_0x2b6970; // 0x2b6970 - g_ps2RecompiledFunctionTable[449196] = FsubZoomScreen_0x2b6970; // 0x2b6ab8 - g_ps2RecompiledFunctionTable[449204] = FsubZoomScreen_0x2b6970; // 0x2b6ad8 - g_ps2RecompiledFunctionTable[449205] = FsubZoomScreen_0x2b6970; // 0x2b6adc - g_ps2RecompiledFunctionTable[449207] = FsubZoomScreen_0x2b6970; // 0x2b6ae4 - g_ps2RecompiledFunctionTable[449217] = FsubZoomScreen_0x2b6970; // 0x2b6b0c - g_ps2RecompiledFunctionTable[449229] = FsubZoomScreen_0x2b6970; // 0x2b6b3c - g_ps2RecompiledFunctionTable[449239] = FsubZoomScreen_0x2b6970; // 0x2b6b64 - g_ps2RecompiledFunctionTable[449256] = FsubZoomScreen_0x2b6970; // 0x2b6ba8 - g_ps2RecompiledFunctionTable[449284] = FsubZoomScreen_0x2b6970; // 0x2b6c18 - g_ps2RecompiledFunctionTable[449297] = FsubZoomScreen_0x2b6970; // 0x2b6c4c - g_ps2RecompiledFunctionTable[449328] = FsubZoomScreen_0x2b6970; // 0x2b6cc8 - g_ps2RecompiledFunctionTable[449355] = FsubZoomScreen_0x2b6970; // 0x2b6d34 - g_ps2RecompiledFunctionTable[449364] = FsubZoomScreen_0x2b6970; // 0x2b6d58 - g_ps2RecompiledFunctionTable[449392] = FsubZoomScreen_0x2b6970; // 0x2b6dc8 - g_ps2RecompiledFunctionTable[449404] = FsubZoomScreen_0x2b6970; // 0x2b6df8 - g_ps2RecompiledFunctionTable[449425] = FsubZoomScreen_0x2b6970; // 0x2b6e4c - g_ps2RecompiledFunctionTable[449441] = FsubZoomScreen_0x2b6970; // 0x2b6e8c - g_ps2RecompiledFunctionTable[449462] = FsubZoomScreen_0x2b6970; // 0x2b6ee0 - g_ps2RecompiledFunctionTable[449478] = FsubZoomScreen_0x2b6970; // 0x2b6f20 - g_ps2RecompiledFunctionTable[449486] = FsubCompass_0x2b6f40; // 0x2b6f40 - g_ps2RecompiledFunctionTable[449506] = FsubCompass_0x2b6f40; // 0x2b6f90 - g_ps2RecompiledFunctionTable[449537] = FsubCompass_0x2b6f40; // 0x2b700c - g_ps2RecompiledFunctionTable[449539] = FsubCompass_0x2b6f40; // 0x2b7014 - g_ps2RecompiledFunctionTable[449542] = FsubCompass_0x2b6f40; // 0x2b7020 - g_ps2RecompiledFunctionTable[449544] = FsubCompass_0x2b6f40; // 0x2b7028 - g_ps2RecompiledFunctionTable[449549] = FsubCompass_0x2b6f40; // 0x2b703c - g_ps2RecompiledFunctionTable[449554] = FsubCompass_0x2b6f40; // 0x2b7050 - g_ps2RecompiledFunctionTable[449559] = FsubCompass_0x2b6f40; // 0x2b7064 - g_ps2RecompiledFunctionTable[449561] = FsubCompass_0x2b6f40; // 0x2b706c - g_ps2RecompiledFunctionTable[449566] = FsubModeMessage_0x2b7080; // 0x2b7080 - g_ps2RecompiledFunctionTable[449592] = FsubModeMessage_0x2b7080; // 0x2b70e8 - g_ps2RecompiledFunctionTable[449596] = FsubModeMessage_0x2b7080; // 0x2b70f8 - g_ps2RecompiledFunctionTable[449602] = MapCncInit_0x2b7110; // 0x2b7110 - g_ps2RecompiledFunctionTable[449622] = MapCncInit_0x2b7110; // 0x2b7160 - g_ps2RecompiledFunctionTable[449629] = MapCncInit_0x2b7110; // 0x2b717c - g_ps2RecompiledFunctionTable[449632] = MapCncInit_0x2b7110; // 0x2b7188 - g_ps2RecompiledFunctionTable[449635] = MapCncInit_0x2b7110; // 0x2b7194 - g_ps2RecompiledFunctionTable[449654] = MapCncGet_0x2b71e0; // 0x2b71e0 - g_ps2RecompiledFunctionTable[449666] = MapCnc_0x2b7210; // 0x2b7210 - g_ps2RecompiledFunctionTable[449675] = MapCnc_0x2b7210; // 0x2b7234 - g_ps2RecompiledFunctionTable[449679] = MapCnc_0x2b7210; // 0x2b7244 - g_ps2RecompiledFunctionTable[449730] = MapCncConnect_0x2b7310; // 0x2b7310 - g_ps2RecompiledFunctionTable[449735] = MapCncConnect_0x2b7310; // 0x2b7324 - g_ps2RecompiledFunctionTable[449736] = MapCncConnect_0x2b7310; // 0x2b7328 - g_ps2RecompiledFunctionTable[449746] = MapCncConnect_0x2b7310; // 0x2b7350 - g_ps2RecompiledFunctionTable[449751] = MapCncConnect_0x2b7310; // 0x2b7364 - g_ps2RecompiledFunctionTable[449758] = MapCheckNextMap_0x2b7380; // 0x2b7380 - g_ps2RecompiledFunctionTable[449766] = MapCheckNextMap_0x2b7380; // 0x2b73a0 - g_ps2RecompiledFunctionTable[449769] = MapCheckNextMap_0x2b7380; // 0x2b73ac - g_ps2RecompiledFunctionTable[449788] = MapCheckNextMap_0x2b7380; // 0x2b73f8 - g_ps2RecompiledFunctionTable[449806] = MapCheckNextMap_0x2b7380; // 0x2b7440 - g_ps2RecompiledFunctionTable[449824] = MapCheckNextMap_0x2b7380; // 0x2b7488 - g_ps2RecompiledFunctionTable[449846] = GetGameMode_0x2b74e0; // 0x2b74e0 - g_ps2RecompiledFunctionTable[449858] = bhSetMessage_0x2b7510; // 0x2b7510 - g_ps2RecompiledFunctionTable[449946] = bhControlMessage_0x2b7670; // 0x2b7670 - g_ps2RecompiledFunctionTable[449992] = bhControlMessage_0x2b7670; // 0x2b7728 - g_ps2RecompiledFunctionTable[450143] = bhControlMessage_0x2b7670; // 0x2b7984 - g_ps2RecompiledFunctionTable[450271] = bhControlMessage_0x2b7670; // 0x2b7b84 - g_ps2RecompiledFunctionTable[450273] = bhControlMessage_0x2b7670; // 0x2b7b8c - g_ps2RecompiledFunctionTable[450403] = bhControlMessage_0x2b7670; // 0x2b7d94 - g_ps2RecompiledFunctionTable[450426] = bhControlMessage_0x2b7670; // 0x2b7df0 - g_ps2RecompiledFunctionTable[450484] = bhControlMessage_0x2b7670; // 0x2b7ed8 - g_ps2RecompiledFunctionTable[450611] = bhControlMessage_0x2b7670; // 0x2b80d4 - g_ps2RecompiledFunctionTable[450658] = bhDispFont_0x2b8190; // 0x2b8190 - g_ps2RecompiledFunctionTable[450670] = bhDispFont_0x2b8190; // 0x2b81c0 - g_ps2RecompiledFunctionTable[450673] = bhDispFont_0x2b8190; // 0x2b81cc - g_ps2RecompiledFunctionTable[450676] = bhDispFont_0x2b8190; // 0x2b81d8 - g_ps2RecompiledFunctionTable[450682] = bhDispFont_0x2b8190; // 0x2b81f0 - g_ps2RecompiledFunctionTable[450691] = bhDispFont_0x2b8190; // 0x2b8214 - g_ps2RecompiledFunctionTable[450818] = bhDispFont_0x2b8190; // 0x2b8410 - g_ps2RecompiledFunctionTable[450826] = bhDispFontEx_0x2b8430; // 0x2b8430 - g_ps2RecompiledFunctionTable[450838] = bhDispFontEx_0x2b8430; // 0x2b8460 - g_ps2RecompiledFunctionTable[450841] = bhDispFontEx_0x2b8430; // 0x2b846c - g_ps2RecompiledFunctionTable[450844] = bhDispFontEx_0x2b8430; // 0x2b8478 - g_ps2RecompiledFunctionTable[450850] = bhDispFontEx_0x2b8430; // 0x2b8490 - g_ps2RecompiledFunctionTable[450859] = bhDispFontEx_0x2b8430; // 0x2b84b4 - g_ps2RecompiledFunctionTable[450943] = bhDispFontEx_0x2b8430; // 0x2b8604 - g_ps2RecompiledFunctionTable[450950] = bhDispItemName_0x2b8620; // 0x2b8620 - g_ps2RecompiledFunctionTable[450976] = bhDispItemName_0x2b8620; // 0x2b8688 - g_ps2RecompiledFunctionTable[450988] = bhDispItemName_0x2b8620; // 0x2b86b8 - g_ps2RecompiledFunctionTable[450990] = bhDispItemName_0x2b8620; // 0x2b86c0 - g_ps2RecompiledFunctionTable[451026] = bhDispMessage_0x2b8750; // 0x2b8750 - g_ps2RecompiledFunctionTable[451075] = bhDispMessage_0x2b8750; // 0x2b8814 - g_ps2RecompiledFunctionTable[451076] = bhDispMessage_0x2b8750; // 0x2b8818 - g_ps2RecompiledFunctionTable[451162] = bhDispMessage_0x2b8750; // 0x2b8970 - g_ps2RecompiledFunctionTable[451164] = bhDispMessage_0x2b8750; // 0x2b8978 - g_ps2RecompiledFunctionTable[451190] = bhDispMessageEx_0x2b89e0; // 0x2b89e0 - g_ps2RecompiledFunctionTable[451239] = bhDispMessageEx_0x2b89e0; // 0x2b8aa4 - g_ps2RecompiledFunctionTable[451240] = bhDispMessageEx_0x2b89e0; // 0x2b8aa8 - g_ps2RecompiledFunctionTable[451331] = bhDispMessageEx_0x2b89e0; // 0x2b8c14 - g_ps2RecompiledFunctionTable[451333] = bhDispMessageEx_0x2b89e0; // 0x2b8c1c - g_ps2RecompiledFunctionTable[451358] = bhDispTime_0x2b8c80; // 0x2b8c80 - g_ps2RecompiledFunctionTable[451502] = bhDispTime_0x2b8c80; // 0x2b8ec0 - g_ps2RecompiledFunctionTable[451522] = bhDispTime_0x2b8c80; // 0x2b8f10 - g_ps2RecompiledFunctionTable[451535] = bhDispTime_0x2b8c80; // 0x2b8f44 - g_ps2RecompiledFunctionTable[451537] = bhDispTime_0x2b8c80; // 0x2b8f4c - g_ps2RecompiledFunctionTable[451576] = bhDispTime_0x2b8c80; // 0x2b8fe8 - g_ps2RecompiledFunctionTable[451596] = bhDispTime_0x2b8c80; // 0x2b9038 - g_ps2RecompiledFunctionTable[451613] = bhDispTime_0x2b8c80; // 0x2b907c - g_ps2RecompiledFunctionTable[451615] = bhDispTime_0x2b8c80; // 0x2b9084 - g_ps2RecompiledFunctionTable[451640] = bhDispTime_0x2b8c80; // 0x2b90e8 - g_ps2RecompiledFunctionTable[451660] = bhDispTime_0x2b8c80; // 0x2b9138 - g_ps2RecompiledFunctionTable[451674] = bhDispTime_0x2b8c80; // 0x2b9170 - g_ps2RecompiledFunctionTable[451676] = bhDispTime_0x2b8c80; // 0x2b9178 - g_ps2RecompiledFunctionTable[451701] = bhDispTime_0x2b8c80; // 0x2b91dc - g_ps2RecompiledFunctionTable[451721] = bhDispTime_0x2b8c80; // 0x2b922c - g_ps2RecompiledFunctionTable[451734] = bhDispTimeEx_0x2b9260; // 0x2b9260 - g_ps2RecompiledFunctionTable[451878] = bhDispTimeEx_0x2b9260; // 0x2b94a0 - g_ps2RecompiledFunctionTable[451898] = bhDispTimeEx_0x2b9260; // 0x2b94f0 - g_ps2RecompiledFunctionTable[451911] = bhDispTimeEx_0x2b9260; // 0x2b9524 - g_ps2RecompiledFunctionTable[451913] = bhDispTimeEx_0x2b9260; // 0x2b952c - g_ps2RecompiledFunctionTable[451952] = bhDispTimeEx_0x2b9260; // 0x2b95c8 - g_ps2RecompiledFunctionTable[451972] = bhDispTimeEx_0x2b9260; // 0x2b9618 - g_ps2RecompiledFunctionTable[451989] = bhDispTimeEx_0x2b9260; // 0x2b965c - g_ps2RecompiledFunctionTable[451991] = bhDispTimeEx_0x2b9260; // 0x2b9664 - g_ps2RecompiledFunctionTable[452016] = bhDispTimeEx_0x2b9260; // 0x2b96c8 - g_ps2RecompiledFunctionTable[452036] = bhDispTimeEx_0x2b9260; // 0x2b9718 - g_ps2RecompiledFunctionTable[452050] = bhDispTimeEx_0x2b9260; // 0x2b9750 - g_ps2RecompiledFunctionTable[452052] = bhDispTimeEx_0x2b9260; // 0x2b9758 - g_ps2RecompiledFunctionTable[452077] = bhDispTimeEx_0x2b9260; // 0x2b97bc - g_ps2RecompiledFunctionTable[452097] = bhDispTimeEx_0x2b9260; // 0x2b980c - g_ps2RecompiledFunctionTable[452110] = bhGetFontSize_0x2b9840; // 0x2b9840 - g_ps2RecompiledFunctionTable[452138] = bhMesLen_0x2b98b0; // 0x2b98b0 - g_ps2RecompiledFunctionTable[452144] = bhMesLen_0x2b98b0; // 0x2b98c8 - g_ps2RecompiledFunctionTable[452145] = bhMesLen_0x2b98b0; // 0x2b98cc - g_ps2RecompiledFunctionTable[452229] = bhMesLen_0x2b98b0; // 0x2b9a1c - g_ps2RecompiledFunctionTable[452242] = bhFontScaleSet_0x2b9a50; // 0x2b9a50 - g_ps2RecompiledFunctionTable[452250] = bhControlGameOver_0x2b9a70; // 0x2b9a70 - g_ps2RecompiledFunctionTable[452251] = bhControlGameOver_0x2b9a70; // 0x2b9a74 - g_ps2RecompiledFunctionTable[452252] = bhControlGameOver_0x2b9a70; // 0x2b9a78 - g_ps2RecompiledFunctionTable[452253] = bhControlGameOver_0x2b9a70; // 0x2b9a7c - g_ps2RecompiledFunctionTable[452254] = bhControlGameOver_0x2b9a70; // 0x2b9a80 - g_ps2RecompiledFunctionTable[452255] = bhControlGameOver_0x2b9a70; // 0x2b9a84 - g_ps2RecompiledFunctionTable[452256] = bhControlGameOver_0x2b9a70; // 0x2b9a88 - g_ps2RecompiledFunctionTable[452257] = bhControlGameOver_0x2b9a70; // 0x2b9a8c - g_ps2RecompiledFunctionTable[452258] = bhControlGameOver_0x2b9a70; // 0x2b9a90 - g_ps2RecompiledFunctionTable[452259] = bhControlGameOver_0x2b9a70; // 0x2b9a94 - g_ps2RecompiledFunctionTable[452260] = bhControlGameOver_0x2b9a70; // 0x2b9a98 - g_ps2RecompiledFunctionTable[452261] = bhControlGameOver_0x2b9a70; // 0x2b9a9c - g_ps2RecompiledFunctionTable[452262] = bhSelectContinue_0x2b9aa0; // 0x2b9aa0 - g_ps2RecompiledFunctionTable[452267] = bhSelectContinue_0x2b9aa0; // 0x2b9ab4 - g_ps2RecompiledFunctionTable[452294] = bhInitGameOver_0x2b9b20; // 0x2b9b20 - g_ps2RecompiledFunctionTable[452339] = bhInitGameOver_0x2b9b20; // 0x2b9bd4 - g_ps2RecompiledFunctionTable[452344] = bhInitGameOver_0x2b9b20; // 0x2b9be8 - g_ps2RecompiledFunctionTable[452349] = bhInitGameOver_0x2b9b20; // 0x2b9bfc - g_ps2RecompiledFunctionTable[452374] = bhInitGameOver_0x2b9b20; // 0x2b9c60 - g_ps2RecompiledFunctionTable[452403] = bhInitGameOver_0x2b9b20; // 0x2b9cd4 - g_ps2RecompiledFunctionTable[452412] = bhInitGameOver_0x2b9b20; // 0x2b9cf8 - g_ps2RecompiledFunctionTable[452422] = bhInitGameOver_0x2b9b20; // 0x2b9d20 - g_ps2RecompiledFunctionTable[452445] = bhInitGameOver_0x2b9b20; // 0x2b9d7c - g_ps2RecompiledFunctionTable[452472] = bhInitGameOver_0x2b9b20; // 0x2b9de8 - g_ps2RecompiledFunctionTable[452490] = bhInitGameOver_0x2b9b20; // 0x2b9e30 - g_ps2RecompiledFunctionTable[452502] = bhInitGameOver_0x2b9b20; // 0x2b9e60 - g_ps2RecompiledFunctionTable[452505] = bhInitGameOver_0x2b9b20; // 0x2b9e6c - g_ps2RecompiledFunctionTable[452507] = bhInitGameOver_0x2b9b20; // 0x2b9e74 - g_ps2RecompiledFunctionTable[452515] = bhInitGameOver_0x2b9b20; // 0x2b9e94 - g_ps2RecompiledFunctionTable[452518] = bhInitGameOver_0x2b9b20; // 0x2b9ea0 - g_ps2RecompiledFunctionTable[452528] = bhInitGameOver_0x2b9b20; // 0x2b9ec8 - g_ps2RecompiledFunctionTable[452540] = bhInitGameOver_0x2b9b20; // 0x2b9ef8 - g_ps2RecompiledFunctionTable[452543] = bhInitGameOver_0x2b9b20; // 0x2b9f04 - g_ps2RecompiledFunctionTable[452545] = bhInitGameOver_0x2b9b20; // 0x2b9f0c - g_ps2RecompiledFunctionTable[452554] = bhInitGameOver_0x2b9b20; // 0x2b9f30 - g_ps2RecompiledFunctionTable[452557] = bhInitGameOver_0x2b9b20; // 0x2b9f3c - g_ps2RecompiledFunctionTable[452568] = bhInitGameOver_0x2b9b20; // 0x2b9f68 - g_ps2RecompiledFunctionTable[452580] = bhInitGameOver_0x2b9b20; // 0x2b9f98 - g_ps2RecompiledFunctionTable[452583] = bhInitGameOver_0x2b9b20; // 0x2b9fa4 - g_ps2RecompiledFunctionTable[452585] = bhInitGameOver_0x2b9b20; // 0x2b9fac - g_ps2RecompiledFunctionTable[452593] = bhInitGameOver_0x2b9b20; // 0x2b9fcc - g_ps2RecompiledFunctionTable[452596] = bhInitGameOver_0x2b9b20; // 0x2b9fd8 - g_ps2RecompiledFunctionTable[452604] = bhInitGameOver_0x2b9b20; // 0x2b9ff8 - g_ps2RecompiledFunctionTable[452616] = bhInitGameOver_0x2b9b20; // 0x2ba028 - g_ps2RecompiledFunctionTable[452619] = bhInitGameOver_0x2b9b20; // 0x2ba034 - g_ps2RecompiledFunctionTable[452621] = bhInitGameOver_0x2b9b20; // 0x2ba03c - g_ps2RecompiledFunctionTable[452630] = bhInitGameOver_0x2b9b20; // 0x2ba060 - g_ps2RecompiledFunctionTable[452633] = bhInitGameOver_0x2b9b20; // 0x2ba06c - g_ps2RecompiledFunctionTable[452666] = bhMainGameOver_0x2ba0f0; // 0x2ba0f0 - g_ps2RecompiledFunctionTable[452720] = bhMainGameOver_0x2ba0f0; // 0x2ba1c8 - g_ps2RecompiledFunctionTable[452727] = bhMainGameOver_0x2ba0f0; // 0x2ba1e4 - g_ps2RecompiledFunctionTable[452780] = bhMainGameOver_0x2ba0f0; // 0x2ba2b8 - g_ps2RecompiledFunctionTable[452784] = bhMainGameOver_0x2ba0f0; // 0x2ba2c8 - g_ps2RecompiledFunctionTable[452788] = bhMainGameOver_0x2ba0f0; // 0x2ba2d8 - g_ps2RecompiledFunctionTable[452818] = bhMainGameOver_0x2ba0f0; // 0x2ba350 - g_ps2RecompiledFunctionTable[452984] = bhMainGameOver_0x2ba0f0; // 0x2ba5e8 - g_ps2RecompiledFunctionTable[452988] = bhMainGameOver_0x2ba0f0; // 0x2ba5f8 - g_ps2RecompiledFunctionTable[452992] = bhMainGameOver_0x2ba0f0; // 0x2ba608 - g_ps2RecompiledFunctionTable[453030] = bhMainGameOver_0x2ba0f0; // 0x2ba6a0 - g_ps2RecompiledFunctionTable[453048] = bhMainGameOver_0x2ba0f0; // 0x2ba6e8 - g_ps2RecompiledFunctionTable[453061] = bhMainGameOver_0x2ba0f0; // 0x2ba71c - g_ps2RecompiledFunctionTable[453064] = bhMainGameOver_0x2ba0f0; // 0x2ba728 - g_ps2RecompiledFunctionTable[453074] = bhMainGameOver_0x2ba0f0; // 0x2ba750 - g_ps2RecompiledFunctionTable[453086] = bhMainGameOver_0x2ba0f0; // 0x2ba780 - g_ps2RecompiledFunctionTable[453099] = bhMainGameOver_0x2ba0f0; // 0x2ba7b4 - g_ps2RecompiledFunctionTable[453102] = bhMainGameOver_0x2ba0f0; // 0x2ba7c0 - g_ps2RecompiledFunctionTable[453113] = bhMainGameOver_0x2ba0f0; // 0x2ba7ec - g_ps2RecompiledFunctionTable[453126] = bhMainGameOver_0x2ba0f0; // 0x2ba820 - g_ps2RecompiledFunctionTable[453139] = bhMainGameOver_0x2ba0f0; // 0x2ba854 - g_ps2RecompiledFunctionTable[453142] = bhMainGameOver_0x2ba0f0; // 0x2ba860 - g_ps2RecompiledFunctionTable[453152] = bhMainGameOver_0x2ba0f0; // 0x2ba888 - g_ps2RecompiledFunctionTable[453162] = bhMainGameOver_0x2ba0f0; // 0x2ba8b0 - g_ps2RecompiledFunctionTable[453175] = bhMainGameOver_0x2ba0f0; // 0x2ba8e4 - g_ps2RecompiledFunctionTable[453178] = bhMainGameOver_0x2ba0f0; // 0x2ba8f0 - g_ps2RecompiledFunctionTable[453189] = bhMainGameOver_0x2ba0f0; // 0x2ba91c - g_ps2RecompiledFunctionTable[453213] = bhMainGameOver_0x2ba0f0; // 0x2ba97c - g_ps2RecompiledFunctionTable[453216] = bhMainGameOver_0x2ba0f0; // 0x2ba988 - g_ps2RecompiledFunctionTable[453268] = bhMainGameOver_0x2ba0f0; // 0x2baa58 - g_ps2RecompiledFunctionTable[453320] = bhMainGameOver_0x2ba0f0; // 0x2bab28 - g_ps2RecompiledFunctionTable[453324] = bhMainGameOver_0x2ba0f0; // 0x2bab38 - g_ps2RecompiledFunctionTable[453352] = bhMainGameOver_0x2ba0f0; // 0x2baba8 - g_ps2RecompiledFunctionTable[453366] = bhMainGameOver_0x2ba0f0; // 0x2babe0 - g_ps2RecompiledFunctionTable[453370] = bhMainGameOver_0x2ba0f0; // 0x2babf0 - g_ps2RecompiledFunctionTable[453394] = bhMainGameOver_0x2ba0f0; // 0x2bac50 - g_ps2RecompiledFunctionTable[453410] = bhMainGameOver_0x2ba0f0; // 0x2bac90 - g_ps2RecompiledFunctionTable[453426] = bhMainGameOver_0x2ba0f0; // 0x2bacd0 - g_ps2RecompiledFunctionTable[453441] = bhMainGameOver_0x2ba0f0; // 0x2bad0c - g_ps2RecompiledFunctionTable[453445] = bhMainGameOver_0x2ba0f0; // 0x2bad1c - g_ps2RecompiledFunctionTable[453453] = bhMainGameOver_0x2ba0f0; // 0x2bad3c - g_ps2RecompiledFunctionTable[453466] = bhMainGameOver_0x2ba0f0; // 0x2bad70 - g_ps2RecompiledFunctionTable[453470] = bhMainGameOver_0x2ba0f0; // 0x2bad80 - g_ps2RecompiledFunctionTable[453475] = bhMainGameOver_0x2ba0f0; // 0x2bad94 - g_ps2RecompiledFunctionTable[453485] = bhMainGameOver_0x2ba0f0; // 0x2badbc - g_ps2RecompiledFunctionTable[453496] = bhMainGameOver_0x2ba0f0; // 0x2bade8 - g_ps2RecompiledFunctionTable[453511] = bhMainGameOver_0x2ba0f0; // 0x2bae24 - g_ps2RecompiledFunctionTable[453530] = bhMainGameOver_0x2ba0f0; // 0x2bae70 - g_ps2RecompiledFunctionTable[453537] = bhMainGameOver_0x2ba0f0; // 0x2bae8c - g_ps2RecompiledFunctionTable[453567] = bhMainGameOver_0x2ba0f0; // 0x2baf04 - g_ps2RecompiledFunctionTable[453571] = bhMainGameOver_0x2ba0f0; // 0x2baf14 - g_ps2RecompiledFunctionTable[453591] = bhMainGameOver_0x2ba0f0; // 0x2baf64 - g_ps2RecompiledFunctionTable[453616] = bhMainGameOver_0x2ba0f0; // 0x2bafc8 - g_ps2RecompiledFunctionTable[453620] = bhMainGameOver_0x2ba0f0; // 0x2bafd8 - g_ps2RecompiledFunctionTable[453622] = bhMainGameOver_0x2ba0f0; // 0x2bafe0 - g_ps2RecompiledFunctionTable[453638] = bhExitGameOver_0x2bb020; // 0x2bb020 - g_ps2RecompiledFunctionTable[453648] = bhExitGameOver_0x2bb020; // 0x2bb048 - g_ps2RecompiledFunctionTable[453654] = bhExitGameOver_0x2bb020; // 0x2bb060 - g_ps2RecompiledFunctionTable[453658] = bhDrawGameOver_0x2bb070; // 0x2bb070 - g_ps2RecompiledFunctionTable[453670] = bhDrawGameOver_0x2bb070; // 0x2bb0a0 - g_ps2RecompiledFunctionTable[453673] = bhDrawGameOver_0x2bb070; // 0x2bb0ac - g_ps2RecompiledFunctionTable[453676] = bhDrawGameOver_0x2bb070; // 0x2bb0b8 - g_ps2RecompiledFunctionTable[453682] = bhDrawGameOver_0x2bb070; // 0x2bb0d0 - g_ps2RecompiledFunctionTable[453684] = bhDrawGameOver_0x2bb070; // 0x2bb0d8 - g_ps2RecompiledFunctionTable[453694] = bhDrawGameOver_0x2bb070; // 0x2bb100 - g_ps2RecompiledFunctionTable[453702] = bhDrawGameOver_0x2bb070; // 0x2bb120 - g_ps2RecompiledFunctionTable[453751] = bhDrawGameOver_0x2bb070; // 0x2bb1e4 - g_ps2RecompiledFunctionTable[453762] = ControlRanking_0x2bb210; // 0x2bb210 - g_ps2RecompiledFunctionTable[453763] = ControlRanking_0x2bb210; // 0x2bb214 - g_ps2RecompiledFunctionTable[453764] = ControlRanking_0x2bb210; // 0x2bb218 - g_ps2RecompiledFunctionTable[453765] = ControlRanking_0x2bb210; // 0x2bb21c - g_ps2RecompiledFunctionTable[453766] = ControlRanking_0x2bb210; // 0x2bb220 - g_ps2RecompiledFunctionTable[453767] = ControlRanking_0x2bb210; // 0x2bb224 - g_ps2RecompiledFunctionTable[453768] = ControlRanking_0x2bb210; // 0x2bb228 - g_ps2RecompiledFunctionTable[453769] = ControlRanking_0x2bb210; // 0x2bb22c - g_ps2RecompiledFunctionTable[453770] = ControlRanking_0x2bb210; // 0x2bb230 - g_ps2RecompiledFunctionTable[453771] = ControlRanking_0x2bb210; // 0x2bb234 - g_ps2RecompiledFunctionTable[453774] = RankingInit_0x2bb240; // 0x2bb240 - g_ps2RecompiledFunctionTable[453785] = RankingInit_0x2bb240; // 0x2bb26c - g_ps2RecompiledFunctionTable[453799] = RankingInit_0x2bb240; // 0x2bb2a4 - g_ps2RecompiledFunctionTable[453817] = RankingInit_0x2bb240; // 0x2bb2ec - g_ps2RecompiledFunctionTable[453829] = RankingInit_0x2bb240; // 0x2bb31c - g_ps2RecompiledFunctionTable[453833] = RankingInit_0x2bb240; // 0x2bb32c - g_ps2RecompiledFunctionTable[453837] = RankingInit_0x2bb240; // 0x2bb33c - g_ps2RecompiledFunctionTable[453841] = RankingInit_0x2bb240; // 0x2bb34c - g_ps2RecompiledFunctionTable[453845] = RankingInit_0x2bb240; // 0x2bb35c - g_ps2RecompiledFunctionTable[453849] = RankingInit_0x2bb240; // 0x2bb36c - g_ps2RecompiledFunctionTable[453853] = RankingInit_0x2bb240; // 0x2bb37c - g_ps2RecompiledFunctionTable[453859] = RankingInit_0x2bb240; // 0x2bb394 - g_ps2RecompiledFunctionTable[453909] = RankingInit_0x2bb240; // 0x2bb45c - g_ps2RecompiledFunctionTable[453929] = RankingInit_0x2bb240; // 0x2bb4ac - g_ps2RecompiledFunctionTable[453955] = RankingInit_0x2bb240; // 0x2bb514 - g_ps2RecompiledFunctionTable[453961] = RankingInit_0x2bb240; // 0x2bb52c - g_ps2RecompiledFunctionTable[453967] = RankingInit_0x2bb240; // 0x2bb544 - g_ps2RecompiledFunctionTable[454138] = RankingVmsWait_0x2bb7f0; // 0x2bb7f0 - g_ps2RecompiledFunctionTable[454150] = RankingSave_0x2bb820; // 0x2bb820 - g_ps2RecompiledFunctionTable[454154] = RankingErrorMessage_0x2bb830; // 0x2bb830 - g_ps2RecompiledFunctionTable[454176] = RankingErrorMessage_0x2bb830; // 0x2bb888 - g_ps2RecompiledFunctionTable[454187] = RankingErrorMessage_0x2bb830; // 0x2bb8b4 - g_ps2RecompiledFunctionTable[454205] = RankingErrorMessage_0x2bb830; // 0x2bb8fc - g_ps2RecompiledFunctionTable[454221] = RankingErrorMessage_0x2bb830; // 0x2bb93c - g_ps2RecompiledFunctionTable[454226] = RankingMain_0x2bb950; // 0x2bb950 - g_ps2RecompiledFunctionTable[454241] = RankingMain_0x2bb950; // 0x2bb98c - g_ps2RecompiledFunctionTable[454248] = RankingMain_0x2bb950; // 0x2bb9a8 - g_ps2RecompiledFunctionTable[454250] = RankingMain_0x2bb950; // 0x2bb9b0 - g_ps2RecompiledFunctionTable[454252] = RankingMain_0x2bb950; // 0x2bb9b8 - g_ps2RecompiledFunctionTable[454306] = RankingMain_0x2bb950; // 0x2bba90 - g_ps2RecompiledFunctionTable[454344] = RankingMain_0x2bb950; // 0x2bbb28 - g_ps2RecompiledFunctionTable[454414] = RankingExit_0x2bbc40; // 0x2bbc40 - g_ps2RecompiledFunctionTable[454449] = RankingExit_0x2bbc40; // 0x2bbccc - g_ps2RecompiledFunctionTable[454454] = RankingExit_0x2bbc40; // 0x2bbce0 - g_ps2RecompiledFunctionTable[454462] = RankingExit_0x2bbc40; // 0x2bbd00 - g_ps2RecompiledFunctionTable[454467] = RankingExit_0x2bbc40; // 0x2bbd14 - g_ps2RecompiledFunctionTable[454475] = RankingExit_0x2bbc40; // 0x2bbd34 - g_ps2RecompiledFunctionTable[454479] = RankingExit_0x2bbc40; // 0x2bbd44 - g_ps2RecompiledFunctionTable[454490] = RankingTextureInit_0x2bbd70; // 0x2bbd70 - g_ps2RecompiledFunctionTable[454539] = RankingTextureInit_0x2bbd70; // 0x2bbe34 - g_ps2RecompiledFunctionTable[454560] = RankingTextureInit_0x2bbd70; // 0x2bbe88 - g_ps2RecompiledFunctionTable[454581] = RankingTextureInit_0x2bbd70; // 0x2bbedc - g_ps2RecompiledFunctionTable[454591] = RankingTextureInit_0x2bbd70; // 0x2bbf04 - g_ps2RecompiledFunctionTable[454614] = RankingTextureInit_0x2bbd70; // 0x2bbf60 - g_ps2RecompiledFunctionTable[454621] = RankingTextureInit_0x2bbd70; // 0x2bbf7c - g_ps2RecompiledFunctionTable[454641] = RankingTextureInit_0x2bbd70; // 0x2bbfcc - g_ps2RecompiledFunctionTable[454646] = RankingTextureInit_0x2bbd70; // 0x2bbfe0 - g_ps2RecompiledFunctionTable[454654] = RankingTextureInit_0x2bbd70; // 0x2bc000 - g_ps2RecompiledFunctionTable[454659] = RankingTextureInit_0x2bbd70; // 0x2bc014 - g_ps2RecompiledFunctionTable[454685] = RankingTextureInit_0x2bbd70; // 0x2bc07c - g_ps2RecompiledFunctionTable[454692] = RankingTextureInit_0x2bbd70; // 0x2bc098 - g_ps2RecompiledFunctionTable[454712] = RankingTextureInit_0x2bbd70; // 0x2bc0e8 - g_ps2RecompiledFunctionTable[454734] = RankingTextureInit_0x2bbd70; // 0x2bc140 - g_ps2RecompiledFunctionTable[454736] = RankingTextureInit_0x2bbd70; // 0x2bc148 - g_ps2RecompiledFunctionTable[454750] = RankingTextureInit_0x2bbd70; // 0x2bc180 - g_ps2RecompiledFunctionTable[454762] = WallPaperDisp_0x2bc1b0; // 0x2bc1b0 - g_ps2RecompiledFunctionTable[454768] = WallPaperDisp_0x2bc1b0; // 0x2bc1c8 - g_ps2RecompiledFunctionTable[454770] = WallPaperDisp_0x2bc1b0; // 0x2bc1d0 - g_ps2RecompiledFunctionTable[454787] = WallPaperDisp_0x2bc1b0; // 0x2bc214 - g_ps2RecompiledFunctionTable[454792] = WallPaperDisp_0x2bc1b0; // 0x2bc228 - g_ps2RecompiledFunctionTable[454811] = WallPaperDisp_0x2bc1b0; // 0x2bc274 - g_ps2RecompiledFunctionTable[454816] = WallPaperDisp_0x2bc1b0; // 0x2bc288 - g_ps2RecompiledFunctionTable[454818] = WallPaperDisp_0x2bc1b0; // 0x2bc290 - g_ps2RecompiledFunctionTable[454822] = DispRank_0x2bc2a0; // 0x2bc2a0 - g_ps2RecompiledFunctionTable[454866] = DispRankingData00_0x2bc350; // 0x2bc350 - g_ps2RecompiledFunctionTable[454886] = DispRankingData00_0x2bc350; // 0x2bc3a0 - g_ps2RecompiledFunctionTable[454897] = DispRankingData00_0x2bc350; // 0x2bc3cc - g_ps2RecompiledFunctionTable[454908] = DispRankingData00_0x2bc350; // 0x2bc3f8 - g_ps2RecompiledFunctionTable[454919] = DispRankingData00_0x2bc350; // 0x2bc424 - g_ps2RecompiledFunctionTable[454930] = DispRankingData00_0x2bc350; // 0x2bc450 - g_ps2RecompiledFunctionTable[454940] = DispRankingData00_0x2bc350; // 0x2bc478 - g_ps2RecompiledFunctionTable[454951] = DispRankingData00_0x2bc350; // 0x2bc4a4 - g_ps2RecompiledFunctionTable[454961] = DispRankingData00_0x2bc350; // 0x2bc4cc - g_ps2RecompiledFunctionTable[454971] = DispRankingData00_0x2bc350; // 0x2bc4f4 - g_ps2RecompiledFunctionTable[454978] = DispRankingData01_0x2bc510; // 0x2bc510 - g_ps2RecompiledFunctionTable[455002] = DispRankingData01_0x2bc510; // 0x2bc570 - g_ps2RecompiledFunctionTable[455013] = DispRankingData01_0x2bc510; // 0x2bc59c - g_ps2RecompiledFunctionTable[455024] = DispRankingData01_0x2bc510; // 0x2bc5c8 - g_ps2RecompiledFunctionTable[455035] = DispRankingData01_0x2bc510; // 0x2bc5f4 - g_ps2RecompiledFunctionTable[455052] = DispRankingData01_0x2bc510; // 0x2bc638 - g_ps2RecompiledFunctionTable[455064] = DispRankingData01_0x2bc510; // 0x2bc668 - g_ps2RecompiledFunctionTable[455075] = DispRankingData01_0x2bc510; // 0x2bc694 - g_ps2RecompiledFunctionTable[455101] = DispRankingData01_0x2bc510; // 0x2bc6fc - g_ps2RecompiledFunctionTable[455124] = DispRankingData01_0x2bc510; // 0x2bc758 - g_ps2RecompiledFunctionTable[455138] = DispRankingData01_0x2bc510; // 0x2bc790 - g_ps2RecompiledFunctionTable[455144] = DispRankingData01_0x2bc510; // 0x2bc7a8 - g_ps2RecompiledFunctionTable[455156] = DispRankingData01_0x2bc510; // 0x2bc7d8 - g_ps2RecompiledFunctionTable[455159] = DispRankingData01_0x2bc510; // 0x2bc7e4 - g_ps2RecompiledFunctionTable[455166] = DispRankingData01_0x2bc510; // 0x2bc800 - g_ps2RecompiledFunctionTable[455174] = DispNumber_0x2bc820; // 0x2bc820 - g_ps2RecompiledFunctionTable[455197] = DispNumber_0x2bc820; // 0x2bc87c - g_ps2RecompiledFunctionTable[455215] = DispNumber_0x2bc820; // 0x2bc8c4 - g_ps2RecompiledFunctionTable[455222] = DispTime_0x2bc8e0; // 0x2bc8e0 - g_ps2RecompiledFunctionTable[455230] = AllRanking_0x2bc900; // 0x2bc900 - g_ps2RecompiledFunctionTable[455316] = AllRanking_0x2bc900; // 0x2bca58 - g_ps2RecompiledFunctionTable[455337] = AllRanking_0x2bc900; // 0x2bcaac - g_ps2RecompiledFunctionTable[455354] = GameClearScore_0x2bcaf0; // 0x2bcaf0 - g_ps2RecompiledFunctionTable[455360] = GameClearScore_0x2bcaf0; // 0x2bcb08 - g_ps2RecompiledFunctionTable[455506] = RodorigoEventScore_0x2bcd50; // 0x2bcd50 - g_ps2RecompiledFunctionTable[455513] = RodorigoEventScore_0x2bcd50; // 0x2bcd6c - g_ps2RecompiledFunctionTable[455522] = SteveEventScore_0x2bcd90; // 0x2bcd90 - g_ps2RecompiledFunctionTable[455529] = SteveEventScore_0x2bcd90; // 0x2bcdac - g_ps2RecompiledFunctionTable[455538] = SteveEventScore_0x2bcd90; // 0x2bcdd0 - g_ps2RecompiledFunctionTable[455546] = MapScore_0x2bcdf0; // 0x2bcdf0 - g_ps2RecompiledFunctionTable[455554] = MapScore_0x2bcdf0; // 0x2bce10 - g_ps2RecompiledFunctionTable[455561] = MapScore_0x2bcdf0; // 0x2bce2c - g_ps2RecompiledFunctionTable[455568] = MapScore_0x2bcdf0; // 0x2bce48 - g_ps2RecompiledFunctionTable[455575] = MapScore_0x2bcdf0; // 0x2bce64 - g_ps2RecompiledFunctionTable[455582] = MapScore_0x2bcdf0; // 0x2bce80 - g_ps2RecompiledFunctionTable[455598] = HealItemUseScore_0x2bcec0; // 0x2bcec0 - g_ps2RecompiledFunctionTable[455606] = SaveCountScore_0x2bcee0; // 0x2bcee0 - g_ps2RecompiledFunctionTable[455622] = RetryCountScore_0x2bcf20; // 0x2bcf20 - g_ps2RecompiledFunctionTable[455638] = GetMessage_0x2bcf60; // 0x2bcf60 - g_ps2RecompiledFunctionTable[455654] = RankingBgmSet_0x2bcfa0; // 0x2bcfa0 - g_ps2RecompiledFunctionTable[455675] = RankingBgmSet_0x2bcfa0; // 0x2bcff4 - g_ps2RecompiledFunctionTable[455680] = RankingBgmSet_0x2bcfa0; // 0x2bd008 - g_ps2RecompiledFunctionTable[455698] = bhControlSpEvtComputer_0x2bd050; // 0x2bd050 - g_ps2RecompiledFunctionTable[455699] = bhControlSpEvtComputer_0x2bd050; // 0x2bd054 - g_ps2RecompiledFunctionTable[455700] = bhControlSpEvtComputer_0x2bd050; // 0x2bd058 - g_ps2RecompiledFunctionTable[455701] = bhControlSpEvtComputer_0x2bd050; // 0x2bd05c - g_ps2RecompiledFunctionTable[455702] = bhControlSpEvtComputer_0x2bd050; // 0x2bd060 - g_ps2RecompiledFunctionTable[455703] = bhControlSpEvtComputer_0x2bd050; // 0x2bd064 - g_ps2RecompiledFunctionTable[455704] = bhControlSpEvtComputer_0x2bd050; // 0x2bd068 - g_ps2RecompiledFunctionTable[455705] = bhControlSpEvtComputer_0x2bd050; // 0x2bd06c - g_ps2RecompiledFunctionTable[455706] = bhControlSpEvtComputer_0x2bd050; // 0x2bd070 - g_ps2RecompiledFunctionTable[455707] = bhControlSpEvtComputer_0x2bd050; // 0x2bd074 - g_ps2RecompiledFunctionTable[455708] = bhControlSpEvtComputer_0x2bd050; // 0x2bd078 - g_ps2RecompiledFunctionTable[455709] = bhControlSpEvtComputer_0x2bd050; // 0x2bd07c - g_ps2RecompiledFunctionTable[455710] = bhKeepSpEvtComputer_0x2bd080; // 0x2bd080 - g_ps2RecompiledFunctionTable[455726] = bhKeepSpEvtComputer_0x2bd080; // 0x2bd0c0 - g_ps2RecompiledFunctionTable[455734] = bhInitSpEvtComputer_0x2bd0e0; // 0x2bd0e0 - g_ps2RecompiledFunctionTable[455757] = bhInitSpEvtComputer_0x2bd0e0; // 0x2bd13c - g_ps2RecompiledFunctionTable[455780] = bhInitSpEvtComputer_0x2bd0e0; // 0x2bd198 - g_ps2RecompiledFunctionTable[455786] = bhInitSpEvtComputer_0x2bd0e0; // 0x2bd1b0 - g_ps2RecompiledFunctionTable[455795] = bhInitSpEvtComputer_0x2bd0e0; // 0x2bd1d4 - g_ps2RecompiledFunctionTable[455805] = bhInitSpEvtComputer_0x2bd0e0; // 0x2bd1fc - g_ps2RecompiledFunctionTable[455807] = bhInitSpEvtComputer_0x2bd0e0; // 0x2bd204 - g_ps2RecompiledFunctionTable[455810] = bhInitSpEvtComputer_0x2bd0e0; // 0x2bd210 - g_ps2RecompiledFunctionTable[455813] = bhInitSpEvtComputer_0x2bd0e0; // 0x2bd21c - g_ps2RecompiledFunctionTable[455815] = bhInitSpEvtComputer_0x2bd0e0; // 0x2bd224 - g_ps2RecompiledFunctionTable[455817] = bhInitSpEvtComputer_0x2bd0e0; // 0x2bd22c - g_ps2RecompiledFunctionTable[455844] = bhInitSpEvtComputer_0x2bd0e0; // 0x2bd298 - g_ps2RecompiledFunctionTable[455857] = bhInitSpEvtComputer_0x2bd0e0; // 0x2bd2cc - g_ps2RecompiledFunctionTable[455880] = bhInitSpEvtComputer_0x2bd0e0; // 0x2bd328 - g_ps2RecompiledFunctionTable[455898] = bhMainSpEvtComputer_0x2bd370; // 0x2bd370 - g_ps2RecompiledFunctionTable[455971] = bhMainSpEvtComputer_0x2bd370; // 0x2bd494 - g_ps2RecompiledFunctionTable[455978] = bhMainSpEvtComputer_0x2bd370; // 0x2bd4b0 - g_ps2RecompiledFunctionTable[455986] = bhMainSpEvtComputer_0x2bd370; // 0x2bd4d0 - g_ps2RecompiledFunctionTable[455992] = bhMainSpEvtComputer_0x2bd370; // 0x2bd4e8 - g_ps2RecompiledFunctionTable[456024] = bhMainSpEvtComputer_0x2bd370; // 0x2bd568 - g_ps2RecompiledFunctionTable[456028] = bhMainSpEvtComputer_0x2bd370; // 0x2bd578 - g_ps2RecompiledFunctionTable[456049] = bhMainSpEvtComputer_0x2bd370; // 0x2bd5cc - g_ps2RecompiledFunctionTable[456057] = bhMainSpEvtComputer_0x2bd370; // 0x2bd5ec - g_ps2RecompiledFunctionTable[456063] = bhMainSpEvtComputer_0x2bd370; // 0x2bd604 - g_ps2RecompiledFunctionTable[456086] = bhMainSpEvtComputer_0x2bd370; // 0x2bd660 - g_ps2RecompiledFunctionTable[456090] = bhMainSpEvtComputer_0x2bd370; // 0x2bd670 - g_ps2RecompiledFunctionTable[456111] = bhMainSpEvtComputer_0x2bd370; // 0x2bd6c4 - g_ps2RecompiledFunctionTable[456119] = bhMainSpEvtComputer_0x2bd370; // 0x2bd6e4 - g_ps2RecompiledFunctionTable[456125] = bhMainSpEvtComputer_0x2bd370; // 0x2bd6fc - g_ps2RecompiledFunctionTable[456157] = bhMainSpEvtComputer_0x2bd370; // 0x2bd77c - g_ps2RecompiledFunctionTable[456161] = bhMainSpEvtComputer_0x2bd370; // 0x2bd78c - g_ps2RecompiledFunctionTable[456177] = bhMainSpEvtComputer_0x2bd370; // 0x2bd7cc - g_ps2RecompiledFunctionTable[456191] = bhMainSpEvtComputer_0x2bd370; // 0x2bd804 - g_ps2RecompiledFunctionTable[456222] = bhMainSpEvtComputer_0x2bd370; // 0x2bd880 - g_ps2RecompiledFunctionTable[456229] = bhMainSpEvtComputer_0x2bd370; // 0x2bd89c - g_ps2RecompiledFunctionTable[456235] = bhMainSpEvtComputer_0x2bd370; // 0x2bd8b4 - g_ps2RecompiledFunctionTable[456237] = bhMainSpEvtComputer_0x2bd370; // 0x2bd8bc - g_ps2RecompiledFunctionTable[456241] = bhMainSpEvtComputer_0x2bd370; // 0x2bd8cc - g_ps2RecompiledFunctionTable[456262] = bhMainSpEvtComputer_0x2bd370; // 0x2bd920 - g_ps2RecompiledFunctionTable[456269] = bhMainSpEvtComputer_0x2bd370; // 0x2bd93c - g_ps2RecompiledFunctionTable[456275] = bhMainSpEvtComputer_0x2bd370; // 0x2bd954 - g_ps2RecompiledFunctionTable[456277] = bhMainSpEvtComputer_0x2bd370; // 0x2bd95c - g_ps2RecompiledFunctionTable[456281] = bhMainSpEvtComputer_0x2bd370; // 0x2bd96c - g_ps2RecompiledFunctionTable[456318] = bhMainSpEvtComputer_0x2bd370; // 0x2bda00 - g_ps2RecompiledFunctionTable[456326] = bhMainSpEvtComputer_0x2bd370; // 0x2bda20 - g_ps2RecompiledFunctionTable[456345] = bhMainSpEvtComputer_0x2bd370; // 0x2bda6c - g_ps2RecompiledFunctionTable[456352] = bhMainSpEvtComputer_0x2bd370; // 0x2bda88 - g_ps2RecompiledFunctionTable[456358] = bhMainSpEvtComputer_0x2bd370; // 0x2bdaa0 - g_ps2RecompiledFunctionTable[456360] = bhMainSpEvtComputer_0x2bd370; // 0x2bdaa8 - g_ps2RecompiledFunctionTable[456364] = bhMainSpEvtComputer_0x2bd370; // 0x2bdab8 - g_ps2RecompiledFunctionTable[456395] = bhMainSpEvtComputer_0x2bd370; // 0x2bdb34 - g_ps2RecompiledFunctionTable[456406] = bhMainSpEvtComputer_0x2bd370; // 0x2bdb60 - g_ps2RecompiledFunctionTable[456425] = bhMainSpEvtComputer_0x2bd370; // 0x2bdbac - g_ps2RecompiledFunctionTable[456432] = bhMainSpEvtComputer_0x2bd370; // 0x2bdbc8 - g_ps2RecompiledFunctionTable[456438] = bhMainSpEvtComputer_0x2bd370; // 0x2bdbe0 - g_ps2RecompiledFunctionTable[456440] = bhMainSpEvtComputer_0x2bd370; // 0x2bdbe8 - g_ps2RecompiledFunctionTable[456444] = bhMainSpEvtComputer_0x2bd370; // 0x2bdbf8 - g_ps2RecompiledFunctionTable[456464] = bhMainSpEvtComputer_0x2bd370; // 0x2bdc48 - g_ps2RecompiledFunctionTable[456477] = bhMainSpEvtComputer_0x2bd370; // 0x2bdc7c - g_ps2RecompiledFunctionTable[456485] = bhMainSpEvtComputer_0x2bd370; // 0x2bdc9c - g_ps2RecompiledFunctionTable[456492] = bhMainSpEvtComputer_0x2bd370; // 0x2bdcb8 - g_ps2RecompiledFunctionTable[456498] = bhMainSpEvtComputer_0x2bd370; // 0x2bdcd0 - g_ps2RecompiledFunctionTable[456500] = bhMainSpEvtComputer_0x2bd370; // 0x2bdcd8 - g_ps2RecompiledFunctionTable[456504] = bhMainSpEvtComputer_0x2bd370; // 0x2bdce8 - g_ps2RecompiledFunctionTable[456514] = bhMainSpEvtComputer_0x2bd370; // 0x2bdd10 - g_ps2RecompiledFunctionTable[456537] = bhMainSpEvtComputer_0x2bd370; // 0x2bdd6c - g_ps2RecompiledFunctionTable[456547] = bhMainSpEvtComputer_0x2bd370; // 0x2bdd94 - g_ps2RecompiledFunctionTable[456552] = bhMainSpEvtComputer_0x2bd370; // 0x2bdda8 - g_ps2RecompiledFunctionTable[456554] = bhMainSpEvtComputer_0x2bd370; // 0x2bddb0 - g_ps2RecompiledFunctionTable[456556] = bhMainSpEvtComputer_0x2bd370; // 0x2bddb8 - g_ps2RecompiledFunctionTable[456562] = bhExitSpEvtComputer_0x2bddd0; // 0x2bddd0 - g_ps2RecompiledFunctionTable[456578] = bhExitSpEvtComputer_0x2bddd0; // 0x2bde10 - g_ps2RecompiledFunctionTable[456581] = bhExitSpEvtComputer_0x2bddd0; // 0x2bde1c - g_ps2RecompiledFunctionTable[456584] = bhExitSpEvtComputer_0x2bddd0; // 0x2bde28 - g_ps2RecompiledFunctionTable[456591] = bhExitSpEvtComputer_0x2bddd0; // 0x2bde44 - g_ps2RecompiledFunctionTable[456597] = bhExitSpEvtComputer_0x2bddd0; // 0x2bde5c - g_ps2RecompiledFunctionTable[456610] = bhExitSpEvtComputer_0x2bddd0; // 0x2bde90 - g_ps2RecompiledFunctionTable[456659] = bhExitSpEvtComputer_0x2bddd0; // 0x2bdf54 - g_ps2RecompiledFunctionTable[456666] = bhEntrySpEvtComputer_0x2bdf70; // 0x2bdf70 - g_ps2RecompiledFunctionTable[456755] = bhEntrySpEvtComputer_0x2bdf70; // 0x2be0d4 - g_ps2RecompiledFunctionTable[456932] = bhEntrySpEvtComputer_0x2bdf70; // 0x2be398 - g_ps2RecompiledFunctionTable[456934] = bhEntrySpEvtComputer_0x2bdf70; // 0x2be3a0 - g_ps2RecompiledFunctionTable[456938] = bhEntrySpEvtComputer_0x2bdf70; // 0x2be3b0 - g_ps2RecompiledFunctionTable[457017] = bhEntrySpEvtComputer_0x2bdf70; // 0x2be4ec - g_ps2RecompiledFunctionTable[457021] = bhEntrySpEvtComputer_0x2bdf70; // 0x2be4fc - g_ps2RecompiledFunctionTable[457031] = bhEntrySpEvtComputer_0x2bdf70; // 0x2be524 - g_ps2RecompiledFunctionTable[457046] = bhEntrySpEvtComputer_0x2bdf70; // 0x2be560 - g_ps2RecompiledFunctionTable[457238] = bhEntrySpEvtComputer_0x2bdf70; // 0x2be860 - g_ps2RecompiledFunctionTable[457240] = bhEntrySpEvtComputer_0x2bdf70; // 0x2be868 - g_ps2RecompiledFunctionTable[457244] = bhEntrySpEvtComputer_0x2bdf70; // 0x2be878 - g_ps2RecompiledFunctionTable[457319] = bhEntrySpEvtComputer_0x2bdf70; // 0x2be9a4 - g_ps2RecompiledFunctionTable[457378] = bhDrawSpEvtComputer_0x2bea90; // 0x2bea90 - g_ps2RecompiledFunctionTable[457397] = bhDrawSpEvtComputer_0x2bea90; // 0x2beadc - g_ps2RecompiledFunctionTable[457411] = bhDrawSpEvtComputer_0x2bea90; // 0x2beb14 - g_ps2RecompiledFunctionTable[457413] = bhDrawSpEvtComputer_0x2bea90; // 0x2beb1c - g_ps2RecompiledFunctionTable[457416] = bhDrawSpEvtComputer_0x2bea90; // 0x2beb28 - g_ps2RecompiledFunctionTable[457421] = bhDrawSpEvtComputer_0x2bea90; // 0x2beb3c - g_ps2RecompiledFunctionTable[457423] = bhDrawSpEvtComputer_0x2bea90; // 0x2beb44 - g_ps2RecompiledFunctionTable[457425] = bhDrawSpEvtComputer_0x2bea90; // 0x2beb4c - g_ps2RecompiledFunctionTable[457428] = bhDrawSpEvtComputer_0x2bea90; // 0x2beb58 - g_ps2RecompiledFunctionTable[457432] = bhDrawSpEvtComputer_0x2bea90; // 0x2beb68 - g_ps2RecompiledFunctionTable[457435] = bhDrawSpEvtComputer_0x2bea90; // 0x2beb74 - g_ps2RecompiledFunctionTable[457440] = bhDrawSpEvtComputer_0x2bea90; // 0x2beb88 - g_ps2RecompiledFunctionTable[457452] = bhDrawSpEvtComputer_0x2bea90; // 0x2bebb8 - g_ps2RecompiledFunctionTable[457457] = bhDrawSpEvtComputer_0x2bea90; // 0x2bebcc - g_ps2RecompiledFunctionTable[457460] = bhDrawSpEvtComputer_0x2bea90; // 0x2bebd8 - g_ps2RecompiledFunctionTable[457465] = bhDrawSpEvtComputer_0x2bea90; // 0x2bebec - g_ps2RecompiledFunctionTable[457478] = bhDrawSpEvtComputer_0x2bea90; // 0x2bec20 - g_ps2RecompiledFunctionTable[457483] = bhDrawSpEvtComputer_0x2bea90; // 0x2bec34 - g_ps2RecompiledFunctionTable[457486] = bhDrawSpEvtComputer_0x2bea90; // 0x2bec40 - g_ps2RecompiledFunctionTable[457491] = bhDrawSpEvtComputer_0x2bea90; // 0x2bec54 - g_ps2RecompiledFunctionTable[457495] = bhDrawSpEvtComputer_0x2bea90; // 0x2bec64 - g_ps2RecompiledFunctionTable[457515] = bhDrawSpEvtComputer_0x2bea90; // 0x2becb4 - g_ps2RecompiledFunctionTable[457517] = bhDrawSpEvtComputer_0x2bea90; // 0x2becbc - g_ps2RecompiledFunctionTable[457527] = bhDrawSpEvtComputer_0x2bea90; // 0x2bece4 - g_ps2RecompiledFunctionTable[457530] = bhDrawSpEvtComputer_0x2bea90; // 0x2becf0 - g_ps2RecompiledFunctionTable[457532] = bhDrawSpEvtComputer_0x2bea90; // 0x2becf8 - g_ps2RecompiledFunctionTable[457534] = bhDrawSpEvtComputer_0x2bea90; // 0x2bed00 - g_ps2RecompiledFunctionTable[457540] = bhDrawSpEvtComputer_0x2bea90; // 0x2bed18 - g_ps2RecompiledFunctionTable[457545] = bhDrawSpEvtComputer_0x2bea90; // 0x2bed2c - g_ps2RecompiledFunctionTable[457559] = bhDrawSpEvtComputer_0x2bea90; // 0x2bed64 - g_ps2RecompiledFunctionTable[457564] = bhDrawSpEvtComputer_0x2bea90; // 0x2bed78 - g_ps2RecompiledFunctionTable[457567] = bhDrawSpEvtComputer_0x2bea90; // 0x2bed84 - g_ps2RecompiledFunctionTable[457572] = bhDrawSpEvtComputer_0x2bea90; // 0x2bed98 - g_ps2RecompiledFunctionTable[457574] = bhDrawSpEvtComputer_0x2bea90; // 0x2beda0 - g_ps2RecompiledFunctionTable[457577] = bhDrawSpEvtComputer_0x2bea90; // 0x2bedac - g_ps2RecompiledFunctionTable[457580] = bhDrawSpEvtComputer_0x2bea90; // 0x2bedb8 - g_ps2RecompiledFunctionTable[457594] = bhDrawSpEvtComputer_0x2bea90; // 0x2bedf0 - g_ps2RecompiledFunctionTable[457604] = bhDrawSpEvtComputer_0x2bea90; // 0x2bee18 - g_ps2RecompiledFunctionTable[457606] = bhDrawSpEvtComputer_0x2bea90; // 0x2bee20 - g_ps2RecompiledFunctionTable[457609] = bhDrawSpEvtComputer_0x2bea90; // 0x2bee2c - g_ps2RecompiledFunctionTable[457615] = bhDrawSpEvtComputer_0x2bea90; // 0x2bee44 - g_ps2RecompiledFunctionTable[457675] = bhDrawSpEvtComputer_0x2bea90; // 0x2bef34 - g_ps2RecompiledFunctionTable[457679] = bhDrawSpEvtComputer_0x2bea90; // 0x2bef44 - g_ps2RecompiledFunctionTable[457683] = bhDrawSpEvtComputer_0x2bea90; // 0x2bef54 - g_ps2RecompiledFunctionTable[457709] = bhDrawSpEvtComputer_0x2bea90; // 0x2befbc - g_ps2RecompiledFunctionTable[457722] = bhDrawSpEvtComTime_0x2beff0; // 0x2beff0 - g_ps2RecompiledFunctionTable[457742] = bhDrawSpEvtComTime_0x2beff0; // 0x2bf040 - g_ps2RecompiledFunctionTable[457758] = bhDrawSpEvtComTime_0x2beff0; // 0x2bf080 - g_ps2RecompiledFunctionTable[457768] = bhDrawSpEvtComTime_0x2beff0; // 0x2bf0a8 - g_ps2RecompiledFunctionTable[457780] = bhDrawSpEvtComTime_0x2beff0; // 0x2bf0d8 - g_ps2RecompiledFunctionTable[457789] = bhDrawSpEvtComTime_0x2beff0; // 0x2bf0fc - g_ps2RecompiledFunctionTable[457795] = bhDrawSpEvtComTime_0x2beff0; // 0x2bf114 - g_ps2RecompiledFunctionTable[457809] = bhDrawSpEvtComTime_0x2beff0; // 0x2bf14c - g_ps2RecompiledFunctionTable[457819] = bhDrawSpEvtComTime_0x2beff0; // 0x2bf174 - g_ps2RecompiledFunctionTable[457826] = bhDrawSpEvtComVal_0x2bf190; // 0x2bf190 - g_ps2RecompiledFunctionTable[457875] = bhDrawSpEvtComVal_0x2bf190; // 0x2bf254 - g_ps2RecompiledFunctionTable[457879] = bhDrawSpEvtComVal_0x2bf190; // 0x2bf264 - g_ps2RecompiledFunctionTable[457884] = bhDrawSpEvtComVal_0x2bf190; // 0x2bf278 - g_ps2RecompiledFunctionTable[457886] = bhDrawSpEvtComVal_0x2bf190; // 0x2bf280 - g_ps2RecompiledFunctionTable[457890] = bhDrawSpEvtComBar_0x2bf290; // 0x2bf290 - g_ps2RecompiledFunctionTable[457911] = bhDrawSpEvtComBar_0x2bf290; // 0x2bf2e4 - g_ps2RecompiledFunctionTable[457965] = bhDrawSpEvtComBar_0x2bf290; // 0x2bf3bc - g_ps2RecompiledFunctionTable[457970] = bhDrawSpEvtComBar_0x2bf290; // 0x2bf3d0 - g_ps2RecompiledFunctionTable[458012] = bhDrawSpEvtComBar_0x2bf290; // 0x2bf478 - g_ps2RecompiledFunctionTable[458017] = bhDrawSpEvtComBar_0x2bf290; // 0x2bf48c - g_ps2RecompiledFunctionTable[458019] = bhDrawSpEvtComBar_0x2bf290; // 0x2bf494 - g_ps2RecompiledFunctionTable[458034] = bhDrawSpEvtComCharacter_0x2bf4d0; // 0x2bf4d0 - g_ps2RecompiledFunctionTable[458055] = bhDrawSpEvtComCharacter_0x2bf4d0; // 0x2bf524 - g_ps2RecompiledFunctionTable[458071] = bhDrawSpEvtComCharacter_0x2bf4d0; // 0x2bf564 - g_ps2RecompiledFunctionTable[458107] = bhDrawSpEvtComCharacter_0x2bf4d0; // 0x2bf5f4 - g_ps2RecompiledFunctionTable[458120] = bhDrawSpEvtComCharacter_0x2bf4d0; // 0x2bf628 - g_ps2RecompiledFunctionTable[458126] = bhDrawSpEvtComCharacter_0x2bf4d0; // 0x2bf640 - g_ps2RecompiledFunctionTable[458133] = bhDrawSpEvtComCharacter_0x2bf4d0; // 0x2bf65c - g_ps2RecompiledFunctionTable[458141] = bhDrawSpEvtComCharacter_0x2bf4d0; // 0x2bf67c - g_ps2RecompiledFunctionTable[458146] = bhDrawSpEvtComCharacter_0x2bf4d0; // 0x2bf690 - g_ps2RecompiledFunctionTable[458151] = bhDrawSpEvtComCharacter_0x2bf4d0; // 0x2bf6a4 - g_ps2RecompiledFunctionTable[458158] = bhDrawSpEvtComCharacter_0x2bf4d0; // 0x2bf6c0 - g_ps2RecompiledFunctionTable[458164] = bhDrawSpEvtComCharacter_0x2bf4d0; // 0x2bf6d8 - g_ps2RecompiledFunctionTable[458167] = bhDrawSpEvtComCharacter_0x2bf4d0; // 0x2bf6e4 - g_ps2RecompiledFunctionTable[458188] = bhDrawSpEvtComCharacter_0x2bf4d0; // 0x2bf738 - g_ps2RecompiledFunctionTable[458191] = bhDrawSpEvtComCharacter_0x2bf4d0; // 0x2bf744 - g_ps2RecompiledFunctionTable[458201] = bhDrawSpEvtComCharacter_0x2bf4d0; // 0x2bf76c - g_ps2RecompiledFunctionTable[458205] = bhDrawSpEvtComCharacter_0x2bf4d0; // 0x2bf77c - g_ps2RecompiledFunctionTable[458218] = bhSetSpEvtComFade_0x2bf7b0; // 0x2bf7b0 - g_ps2RecompiledFunctionTable[458242] = bhCalcSpEvtComFade_0x2bf810; // 0x2bf810 - g_ps2RecompiledFunctionTable[458280] = bhCalcSpEvtComFade_0x2bf810; // 0x2bf8a8 - g_ps2RecompiledFunctionTable[458294] = bhDrawSpEvtComFade_0x2bf8e0; // 0x2bf8e0 - g_ps2RecompiledFunctionTable[458338] = bhDrawSpEvtComFade_0x2bf8e0; // 0x2bf990 - g_ps2RecompiledFunctionTable[458342] = bhEntrySpEvtBoxLine_0x2bf9a0; // 0x2bf9a0 - g_ps2RecompiledFunctionTable[458349] = bhEntrySpEvtBoxLine_0x2bf9a0; // 0x2bf9bc - g_ps2RecompiledFunctionTable[458386] = bhDrawSpEvtBoxLine_0x2bfa50; // 0x2bfa50 - g_ps2RecompiledFunctionTable[458409] = bhDrawSpEvtBoxLine_0x2bfa50; // 0x2bfaac - g_ps2RecompiledFunctionTable[458459] = bhDrawSpEvtBoxLine_0x2bfa50; // 0x2bfb74 - g_ps2RecompiledFunctionTable[458482] = bhClearComEvtText_0x2bfbd0; // 0x2bfbd0 - g_ps2RecompiledFunctionTable[458494] = bhInitComEvtScript_0x2bfc00; // 0x2bfc00 - g_ps2RecompiledFunctionTable[458524] = bhInitComEvtScript_0x2bfc00; // 0x2bfc78 - g_ps2RecompiledFunctionTable[458610] = bhControlComEvtScript_0x2bfdd0; // 0x2bfdd0 - g_ps2RecompiledFunctionTable[458673] = bhControlComEvtScript_0x2bfdd0; // 0x2bfecc - g_ps2RecompiledFunctionTable[458782] = bhControlComEvtScript_0x2bfdd0; // 0x2c0080 - g_ps2RecompiledFunctionTable[458848] = bhControlComEvtScript_0x2bfdd0; // 0x2c0188 - g_ps2RecompiledFunctionTable[458871] = bhControlComEvtScript_0x2bfdd0; // 0x2c01e4 - g_ps2RecompiledFunctionTable[458883] = bhControlComEvtScript_0x2bfdd0; // 0x2c0214 - g_ps2RecompiledFunctionTable[458906] = bhControlComEvtScript_0x2bfdd0; // 0x2c0270 - g_ps2RecompiledFunctionTable[458946] = bhControlComEvtScript_0x2bfdd0; // 0x2c0310 - g_ps2RecompiledFunctionTable[459067] = bhControlComEvtScript_0x2bfdd0; // 0x2c04f4 - g_ps2RecompiledFunctionTable[459127] = bhControlComEvtScript_0x2bfdd0; // 0x2c05e4 - g_ps2RecompiledFunctionTable[459154] = bhControlComEvtKeyboard_0x2c0650; // 0x2c0650 - g_ps2RecompiledFunctionTable[459207] = bhControlComEvtKeyboard_0x2c0650; // 0x2c0724 - g_ps2RecompiledFunctionTable[459232] = bhControlComEvtKeyboard_0x2c0650; // 0x2c0788 - g_ps2RecompiledFunctionTable[459254] = bhControlComEvtKeyboard_0x2c0650; // 0x2c07e0 - g_ps2RecompiledFunctionTable[459279] = bhControlComEvtKeyboard_0x2c0650; // 0x2c0844 - g_ps2RecompiledFunctionTable[459312] = bhControlComEvtKeyboard_0x2c0650; // 0x2c08c8 - g_ps2RecompiledFunctionTable[459337] = bhControlComEvtKeyboard_0x2c0650; // 0x2c092c - g_ps2RecompiledFunctionTable[459359] = bhControlComEvtKeyboard_0x2c0650; // 0x2c0984 - g_ps2RecompiledFunctionTable[459384] = bhControlComEvtKeyboard_0x2c0650; // 0x2c09e8 - g_ps2RecompiledFunctionTable[459455] = bhControlComEvtKeyboard_0x2c0650; // 0x2c0b04 - g_ps2RecompiledFunctionTable[459484] = bhControlComEvtKeyboard_0x2c0650; // 0x2c0b78 - g_ps2RecompiledFunctionTable[459497] = bhControlComEvtKeyboard_0x2c0650; // 0x2c0bac - g_ps2RecompiledFunctionTable[459567] = bhControlComEvtKeyboard_0x2c0650; // 0x2c0cc4 - g_ps2RecompiledFunctionTable[459598] = CallPlayerDeadVoice_0x2c0d40; // 0x2c0d40 - g_ps2RecompiledFunctionTable[459606] = CallSystemVoice_0x2c0d60; // 0x2c0d60 - g_ps2RecompiledFunctionTable[459614] = GetSamurai_0x2c0d80; // 0x2c0d80 - g_ps2RecompiledFunctionTable[459650] = InitAdvSystem_0x2c0e10; // 0x2c0e10 - g_ps2RecompiledFunctionTable[459664] = InitAdvSystem_0x2c0e10; // 0x2c0e48 - g_ps2RecompiledFunctionTable[459672] = InitAdvSystem_0x2c0e10; // 0x2c0e68 - g_ps2RecompiledFunctionTable[459678] = ResetAdvSystem_0x2c0e80; // 0x2c0e80 - g_ps2RecompiledFunctionTable[459688] = ResetAdvSystem_0x2c0e80; // 0x2c0ea8 - g_ps2RecompiledFunctionTable[459694] = ResetAdvSystem_0x2c0e80; // 0x2c0ec0 - g_ps2RecompiledFunctionTable[459696] = ResetAdvSystem_0x2c0e80; // 0x2c0ec8 - g_ps2RecompiledFunctionTable[459698] = ResetAdvSystem_0x2c0e80; // 0x2c0ed0 - g_ps2RecompiledFunctionTable[459706] = ResetAdvSystem_0x2c0e80; // 0x2c0ef0 - g_ps2RecompiledFunctionTable[459714] = ResetAdvSystem_0x2c0e80; // 0x2c0f10 - g_ps2RecompiledFunctionTable[459745] = ResetAdvSystem_0x2c0e80; // 0x2c0f8c - g_ps2RecompiledFunctionTable[459750] = MountAdvAfs_0x2c0fa0; // 0x2c0fa0 - g_ps2RecompiledFunctionTable[459758] = AdvGetResourcePtr_0x2c0fc0; // 0x2c0fc0 - g_ps2RecompiledFunctionTable[459766] = AdvSetSoundMode_0x2c0fe0; // 0x2c0fe0 - g_ps2RecompiledFunctionTable[459776] = AdvSetSoundMode_0x2c0fe0; // 0x2c1008 - g_ps2RecompiledFunctionTable[459782] = AdvCheckSoftReset_0x2c1020; // 0x2c1020 - g_ps2RecompiledFunctionTable[459800] = AdvCheckSoftReset_0x2c1020; // 0x2c1068 - g_ps2RecompiledFunctionTable[459811] = AdvCheckSoftReset_0x2c1020; // 0x2c1094 - g_ps2RecompiledFunctionTable[459818] = AdvPushRoomTexture_0x2c10b0; // 0x2c10b0 - g_ps2RecompiledFunctionTable[459844] = AdvPushRoomTexture_0x2c10b0; // 0x2c1118 - g_ps2RecompiledFunctionTable[459853] = AdvPushRoomTexture_0x2c10b0; // 0x2c113c - g_ps2RecompiledFunctionTable[459857] = AdvPushRoomTexture_0x2c10b0; // 0x2c114c - g_ps2RecompiledFunctionTable[459866] = AdvPopRoomTexture_0x2c1170; // 0x2c1170 - g_ps2RecompiledFunctionTable[459881] = AdvPopRoomTexture_0x2c1170; // 0x2c11ac - g_ps2RecompiledFunctionTable[459894] = AdvPushPaletteData_0x2c11e0; // 0x2c11e0 - g_ps2RecompiledFunctionTable[459902] = AdvPushPaletteData_0x2c11e0; // 0x2c1200 - g_ps2RecompiledFunctionTable[459904] = AdvPushPaletteData_0x2c11e0; // 0x2c1208 - g_ps2RecompiledFunctionTable[459910] = AdvPopPaletteData_0x2c1220; // 0x2c1220 - g_ps2RecompiledFunctionTable[459916] = AdvPopPaletteData_0x2c1220; // 0x2c1238 - g_ps2RecompiledFunctionTable[459922] = AdvPopPaletteData_0x2c1220; // 0x2c1250 - g_ps2RecompiledFunctionTable[459935] = AdvPopPaletteData_0x2c1220; // 0x2c1284 - g_ps2RecompiledFunctionTable[459946] = RequestAdvInsideFileEx_0x2c12b0; // 0x2c12b0 - g_ps2RecompiledFunctionTable[459958] = RequestAdvInsideFileEx_0x2c12b0; // 0x2c12e0 - g_ps2RecompiledFunctionTable[459961] = RequestAdvInsideFileEx_0x2c12b0; // 0x2c12ec - g_ps2RecompiledFunctionTable[459968] = RequestAdvInsideFileEx_0x2c12b0; // 0x2c1308 - g_ps2RecompiledFunctionTable[459974] = RequestAdvInsideFile_0x2c1320; // 0x2c1320 - g_ps2RecompiledFunctionTable[459978] = FreeAdvMemoryEx_0x2c1330; // 0x2c1330 - g_ps2RecompiledFunctionTable[459990] = FreeAdvMemoryEx_0x2c1330; // 0x2c1360 - g_ps2RecompiledFunctionTable[459998] = AllFreeAdvMemory_0x2c1380; // 0x2c1380 - g_ps2RecompiledFunctionTable[460002] = AllFreeAdvMemory_0x2c1380; // 0x2c1390 - g_ps2RecompiledFunctionTable[460004] = AllFreeAdvMemory_0x2c1380; // 0x2c1398 - g_ps2RecompiledFunctionTable[460014] = CheckReadEndAdvInsideFile_0x2c13c0; // 0x2c13c0 - g_ps2RecompiledFunctionTable[460018] = CheckReadEndAdvInsideFile_0x2c13c0; // 0x2c13d0 - g_ps2RecompiledFunctionTable[460024] = CheckReadEndAdvInsideFile_0x2c13c0; // 0x2c13e8 - g_ps2RecompiledFunctionTable[460030] = CheckReadEndAdvInsideFile2Ex_0x2c1400; // 0x2c1400 - g_ps2RecompiledFunctionTable[460040] = CheckReadEndAdvInsideFile2Ex_0x2c1400; // 0x2c1428 - g_ps2RecompiledFunctionTable[460070] = CheckReadEndAdvInsideFile2_0x2c14a0; // 0x2c14a0 - g_ps2RecompiledFunctionTable[460074] = RequestAdvFade_0x2c14b0; // 0x2c14b0 - g_ps2RecompiledFunctionTable[460098] = CheckAdvFade_0x2c1510; // 0x2c1510 - g_ps2RecompiledFunctionTable[460102] = AdvDrawFadePolygon_0x2c1520; // 0x2c1520 - g_ps2RecompiledFunctionTable[460117] = AdvDrawFadePolygon_0x2c1520; // 0x2c155c - g_ps2RecompiledFunctionTable[460147] = AdvDrawFadePolygon_0x2c1520; // 0x2c15d4 - g_ps2RecompiledFunctionTable[460154] = ExecuteAdvFadeEx_0x2c15f0; // 0x2c15f0 - g_ps2RecompiledFunctionTable[460181] = ExecuteAdvFadeEx_0x2c15f0; // 0x2c165c - g_ps2RecompiledFunctionTable[460198] = ExecuteAdvFadeEx_0x2c15f0; // 0x2c16a0 - g_ps2RecompiledFunctionTable[460202] = ExecuteAdvFade_0x2c16b0; // 0x2c16b0 - g_ps2RecompiledFunctionTable[460206] = StopAdvScreenSaver_0x2c16c0; // 0x2c16c0 - g_ps2RecompiledFunctionTable[460218] = ExecuteAdvScreenSaver_0x2c16f0; // 0x2c16f0 - g_ps2RecompiledFunctionTable[460270] = CheckAdvScreenSaverStopKey_0x2c17c0; // 0x2c17c0 - g_ps2RecompiledFunctionTable[460296] = CheckAdvScreenSaverStopKey_0x2c17c0; // 0x2c1828 - g_ps2RecompiledFunctionTable[460302] = AdvGetOkButton_0x2c1840; // 0x2c1840 - g_ps2RecompiledFunctionTable[460318] = AdvGetCancelButton_0x2c1880; // 0x2c1880 - g_ps2RecompiledFunctionTable[460334] = SetPvrInfo_0x2c18c0; // 0x2c18c0 - g_ps2RecompiledFunctionTable[460349] = SetPvrInfo_0x2c18c0; // 0x2c18fc - g_ps2RecompiledFunctionTable[460355] = SetPvrInfo_0x2c18c0; // 0x2c1914 - g_ps2RecompiledFunctionTable[460360] = SetPvrInfo_0x2c18c0; // 0x2c1928 - g_ps2RecompiledFunctionTable[460370] = TransPvpData_0x2c1950; // 0x2c1950 - g_ps2RecompiledFunctionTable[460380] = TransPvpData_0x2c1950; // 0x2c1978 - g_ps2RecompiledFunctionTable[460389] = TransPvpData_0x2c1950; // 0x2c199c - g_ps2RecompiledFunctionTable[460398] = AdvTransShadowPalette_0x2c19c0; // 0x2c19c0 - g_ps2RecompiledFunctionTable[460404] = AdvTransShadowPalette_0x2c19c0; // 0x2c19d8 - g_ps2RecompiledFunctionTable[460411] = AdvTransShadowPalette_0x2c19c0; // 0x2c19f4 - g_ps2RecompiledFunctionTable[460422] = AdvTransShadowPalette_0x2c19c0; // 0x2c1a20 - g_ps2RecompiledFunctionTable[460424] = AdvTransShadowPalette_0x2c19c0; // 0x2c1a28 - g_ps2RecompiledFunctionTable[460430] = AdvEasyDrawWindow_0x2c1a40; // 0x2c1a40 - g_ps2RecompiledFunctionTable[460488] = AdvEasyDrawWindow_0x2c1a40; // 0x2c1b28 - g_ps2RecompiledFunctionTable[460502] = AdvEasyDrawWindow_0x2c1a40; // 0x2c1b60 - g_ps2RecompiledFunctionTable[460522] = AdvEasyDrawWindow_0x2c1a40; // 0x2c1bb0 - g_ps2RecompiledFunctionTable[460540] = AdvEasyDrawWindow_0x2c1a40; // 0x2c1bf8 - g_ps2RecompiledFunctionTable[460580] = AdvEasyDrawWindow_0x2c1a40; // 0x2c1c98 - g_ps2RecompiledFunctionTable[460594] = AdvEasyDrawTexture_0x2c1cd0; // 0x2c1cd0 - g_ps2RecompiledFunctionTable[460613] = AdvEasyDrawTexture_0x2c1cd0; // 0x2c1d1c - g_ps2RecompiledFunctionTable[460616] = AdvEasyDrawTexture_0x2c1cd0; // 0x2c1d28 - g_ps2RecompiledFunctionTable[460619] = AdvEasyDrawTexture_0x2c1cd0; // 0x2c1d34 - g_ps2RecompiledFunctionTable[460621] = AdvEasyDrawTexture_0x2c1cd0; // 0x2c1d3c - g_ps2RecompiledFunctionTable[460630] = AdvEasyDrawTextureS_0x2c1d60; // 0x2c1d60 - g_ps2RecompiledFunctionTable[460644] = AdvEasyDrawTextureS_0x2c1d60; // 0x2c1d98 - g_ps2RecompiledFunctionTable[460648] = AdvEasyDrawTextureS_0x2c1d60; // 0x2c1da8 - g_ps2RecompiledFunctionTable[460671] = AdvEasyDrawTextureS_0x2c1d60; // 0x2c1e04 - g_ps2RecompiledFunctionTable[460682] = SetQuadPos_0x2c1e30; // 0x2c1e30 - g_ps2RecompiledFunctionTable[460694] = SetQuadUv2Ex_0x2c1e60; // 0x2c1e60 - g_ps2RecompiledFunctionTable[460750] = SetQuadUv2_0x2c1f40; // 0x2c1f40 - g_ps2RecompiledFunctionTable[460754] = AdvDwawOnePictureEx_0x2c1f50; // 0x2c1f50 - g_ps2RecompiledFunctionTable[460765] = AdvDwawOnePictureEx_0x2c1f50; // 0x2c1f7c - g_ps2RecompiledFunctionTable[460773] = AdvDwawOnePictureEx_0x2c1f50; // 0x2c1f9c - g_ps2RecompiledFunctionTable[460782] = AdvDwawOnePictureEx_0x2c1f50; // 0x2c1fc0 - g_ps2RecompiledFunctionTable[460790] = AdvDwawOnePictureEx_0x2c1f50; // 0x2c1fe0 - g_ps2RecompiledFunctionTable[460792] = AdvDwawOnePictureEx_0x2c1f50; // 0x2c1fe8 - g_ps2RecompiledFunctionTable[460798] = AdvDwawOnePicture_0x2c2000; // 0x2c2000 - g_ps2RecompiledFunctionTable[460802] = AdvEasySetupTextureBasic_0x2c2010; // 0x2c2010 - g_ps2RecompiledFunctionTable[460826] = AdvEasySetupTextureBasic_0x2c2010; // 0x2c2070 - g_ps2RecompiledFunctionTable[460862] = AdvEasySetupTextureBasic_0x2c2010; // 0x2c2100 - g_ps2RecompiledFunctionTable[460870] = AdvEasySetupTextureEx_0x2c2120; // 0x2c2120 - g_ps2RecompiledFunctionTable[460881] = AdvEasySetupTextureEx_0x2c2120; // 0x2c214c - g_ps2RecompiledFunctionTable[460890] = AdvEasySetupTexture_0x2c2170; // 0x2c2170 - g_ps2RecompiledFunctionTable[460894] = AdvEasySetTextureList_0x2c2180; // 0x2c2180 - g_ps2RecompiledFunctionTable[460901] = AdvEasySetTextureList_0x2c2180; // 0x2c219c - g_ps2RecompiledFunctionTable[460903] = AdvEasySetTextureList_0x2c2180; // 0x2c21a4 - g_ps2RecompiledFunctionTable[460906] = AdvEasyTransTextureBasic_0x2c21b0; // 0x2c21b0 - g_ps2RecompiledFunctionTable[460924] = AdvEasyTransTextureBasic_0x2c21b0; // 0x2c21f8 - g_ps2RecompiledFunctionTable[460926] = AdvEasyTransTextureBasic_0x2c21b0; // 0x2c2200 - g_ps2RecompiledFunctionTable[460930] = AdvEasyTransTextureBasic_0x2c21b0; // 0x2c2210 - g_ps2RecompiledFunctionTable[460942] = AdvEasyTransTextureEx_0x2c2240; // 0x2c2240 - g_ps2RecompiledFunctionTable[460950] = AdvEasyTransTexture_0x2c2260; // 0x2c2260 - g_ps2RecompiledFunctionTable[460954] = AdvEasyReleaseTextureEx_0x2c2270; // 0x2c2270 - g_ps2RecompiledFunctionTable[460969] = AdvEasyReleaseTextureEx_0x2c2270; // 0x2c22ac - g_ps2RecompiledFunctionTable[460973] = AdvEasyReleaseTextureEx_0x2c2270; // 0x2c22bc - g_ps2RecompiledFunctionTable[460978] = AdvEasyReleaseTexture_0x2c22d0; // 0x2c22d0 - g_ps2RecompiledFunctionTable[460982] = AdvEasyReleaseAllTexture_0x2c22e0; // 0x2c22e0 - g_ps2RecompiledFunctionTable[460987] = AdvEasyReleaseAllTexture_0x2c22e0; // 0x2c22f4 - g_ps2RecompiledFunctionTable[460996] = AdvEasyReleaseAllTexture_0x2c22e0; // 0x2c2318 - g_ps2RecompiledFunctionTable[461006] = AdvGetCurrentPort_0x2c2340; // 0x2c2340 - g_ps2RecompiledFunctionTable[461010] = CheckConnectVmDrive_0x2c2350; // 0x2c2350 - g_ps2RecompiledFunctionTable[461016] = CheckConnectVmDrive_0x2c2350; // 0x2c2368 - g_ps2RecompiledFunctionTable[461019] = CheckConnectVmDrive_0x2c2350; // 0x2c2374 - g_ps2RecompiledFunctionTable[461042] = FindFirstVmDrive_0x2c23d0; // 0x2c23d0 - g_ps2RecompiledFunctionTable[461047] = FindFirstVmDrive_0x2c23d0; // 0x2c23e4 - g_ps2RecompiledFunctionTable[461049] = FindFirstVmDrive_0x2c23d0; // 0x2c23ec - g_ps2RecompiledFunctionTable[461062] = AdvEasyDispMessage_0x2c2420; // 0x2c2420 - g_ps2RecompiledFunctionTable[461084] = AdvEasyDispMessage_0x2c2420; // 0x2c2478 - g_ps2RecompiledFunctionTable[461089] = AdvEasyDispMessage_0x2c2420; // 0x2c248c - g_ps2RecompiledFunctionTable[461092] = AdvEasyDispMessage_0x2c2420; // 0x2c2498 - g_ps2RecompiledFunctionTable[461103] = AdvEasyDispMessage_0x2c2420; // 0x2c24c4 - g_ps2RecompiledFunctionTable[461170] = AdvEasyDispMessage_0x2c2420; // 0x2c25d0 - g_ps2RecompiledFunctionTable[461178] = AdvEasyDispMessage_0x2c2420; // 0x2c25f0 - g_ps2RecompiledFunctionTable[461202] = AutoSaveLoadEasyDispMessage_0x2c2650; // 0x2c2650 - g_ps2RecompiledFunctionTable[461221] = AutoSaveLoadEasyDispMessage_0x2c2650; // 0x2c269c - g_ps2RecompiledFunctionTable[461226] = AutoSaveLoadEasyDispMessage_0x2c2650; // 0x2c26b0 - g_ps2RecompiledFunctionTable[461229] = AutoSaveLoadEasyDispMessage_0x2c2650; // 0x2c26bc - g_ps2RecompiledFunctionTable[461241] = AutoSaveLoadEasyDispMessage_0x2c2650; // 0x2c26ec - g_ps2RecompiledFunctionTable[461314] = AutoSaveLoadEasyDispMessage_0x2c2650; // 0x2c2810 - g_ps2RecompiledFunctionTable[461325] = AutoSaveLoadEasyDispMessage_0x2c2650; // 0x2c283c - g_ps2RecompiledFunctionTable[461354] = DispVmWarningMessage_0x2c28b0; // 0x2c28b0 - g_ps2RecompiledFunctionTable[461388] = DispVmWarningMessage_0x2c28b0; // 0x2c2938 - g_ps2RecompiledFunctionTable[461397] = DispVmWarningMessage_0x2c28b0; // 0x2c295c - g_ps2RecompiledFunctionTable[461402] = DefaultSetOption_0x2c2970; // 0x2c2970 - g_ps2RecompiledFunctionTable[461410] = DefaultSetOption_0x2c2970; // 0x2c2990 - g_ps2RecompiledFunctionTable[461418] = DefaultSetOption_0x2c2970; // 0x2c29b0 - g_ps2RecompiledFunctionTable[461427] = DefaultSetOption_0x2c2970; // 0x2c29d4 - g_ps2RecompiledFunctionTable[461430] = Adv_FirstWarningMessage_0x2c29e0; // 0x2c29e0 - g_ps2RecompiledFunctionTable[461445] = Adv_FirstWarningMessage_0x2c29e0; // 0x2c2a1c - g_ps2RecompiledFunctionTable[461447] = Adv_FirstWarningMessage_0x2c29e0; // 0x2c2a24 - g_ps2RecompiledFunctionTable[461449] = Adv_FirstWarningMessage_0x2c29e0; // 0x2c2a2c - g_ps2RecompiledFunctionTable[461451] = Adv_FirstWarningMessage_0x2c29e0; // 0x2c2a34 - g_ps2RecompiledFunctionTable[461453] = Adv_FirstWarningMessage_0x2c29e0; // 0x2c2a3c - g_ps2RecompiledFunctionTable[461466] = Adv_FirstWarningMessage_0x2c29e0; // 0x2c2a70 - g_ps2RecompiledFunctionTable[461474] = Adv_FirstWarningMessage_0x2c29e0; // 0x2c2a90 - g_ps2RecompiledFunctionTable[461477] = Adv_FirstWarningMessage_0x2c29e0; // 0x2c2a9c - g_ps2RecompiledFunctionTable[461484] = Adv_FirstWarningMessage_0x2c29e0; // 0x2c2ab8 - g_ps2RecompiledFunctionTable[461489] = Adv_FirstWarningMessage_0x2c29e0; // 0x2c2acc - g_ps2RecompiledFunctionTable[461493] = Adv_FirstWarningMessage_0x2c29e0; // 0x2c2adc - g_ps2RecompiledFunctionTable[461495] = Adv_FirstWarningMessage_0x2c29e0; // 0x2c2ae4 - g_ps2RecompiledFunctionTable[461500] = Adv_FirstWarningMessage_0x2c29e0; // 0x2c2af8 - g_ps2RecompiledFunctionTable[461505] = Adv_FirstWarningMessage_0x2c29e0; // 0x2c2b0c - g_ps2RecompiledFunctionTable[461510] = Adv_FirstWarningMessage_0x2c29e0; // 0x2c2b20 - g_ps2RecompiledFunctionTable[461514] = Adv_FirstWarningMessage_0x2c29e0; // 0x2c2b30 - g_ps2RecompiledFunctionTable[461518] = Adv_FirstWarningMessage_0x2c29e0; // 0x2c2b40 - g_ps2RecompiledFunctionTable[461521] = Adv_FirstWarningMessage_0x2c29e0; // 0x2c2b4c - g_ps2RecompiledFunctionTable[461525] = Adv_FirstWarningMessage_0x2c29e0; // 0x2c2b5c - g_ps2RecompiledFunctionTable[461528] = Adv_FirstWarningMessage_0x2c29e0; // 0x2c2b68 - g_ps2RecompiledFunctionTable[461531] = Adv_FirstWarningMessage_0x2c29e0; // 0x2c2b74 - g_ps2RecompiledFunctionTable[461536] = Adv_FirstWarningMessage_0x2c29e0; // 0x2c2b88 - g_ps2RecompiledFunctionTable[461558] = Adv_FirstWarningMessage_0x2c29e0; // 0x2c2be0 - g_ps2RecompiledFunctionTable[461569] = Adv_FirstWarningMessage_0x2c29e0; // 0x2c2c0c - g_ps2RecompiledFunctionTable[461583] = Adv_FirstWarningMessage_0x2c29e0; // 0x2c2c44 - g_ps2RecompiledFunctionTable[461607] = Adv_FirstWarningMessage_0x2c29e0; // 0x2c2ca4 - g_ps2RecompiledFunctionTable[461611] = Adv_FirstWarningMessage_0x2c29e0; // 0x2c2cb4 - g_ps2RecompiledFunctionTable[461621] = Adv_FirstWarningMessage_0x2c29e0; // 0x2c2cdc - g_ps2RecompiledFunctionTable[461623] = Adv_FirstWarningMessage_0x2c29e0; // 0x2c2ce4 - g_ps2RecompiledFunctionTable[461633] = Adv_FirstWarningMessage_0x2c29e0; // 0x2c2d0c - g_ps2RecompiledFunctionTable[461636] = Adv_FirstWarningMessage_0x2c29e0; // 0x2c2d18 - g_ps2RecompiledFunctionTable[461639] = Adv_FirstWarningMessage_0x2c29e0; // 0x2c2d24 - g_ps2RecompiledFunctionTable[461645] = Adv_FirstWarningMessage_0x2c29e0; // 0x2c2d3c - g_ps2RecompiledFunctionTable[461654] = Adv_FirstWarningMessage_0x2c29e0; // 0x2c2d60 - g_ps2RecompiledFunctionTable[461659] = Adv_FirstWarningMessage_0x2c29e0; // 0x2c2d74 - g_ps2RecompiledFunctionTable[461673] = Adv_FirstWarningMessage_0x2c29e0; // 0x2c2dac - g_ps2RecompiledFunctionTable[461676] = Adv_FirstWarningMessage_0x2c29e0; // 0x2c2db8 - g_ps2RecompiledFunctionTable[461680] = Adv_FirstWarningMessage_0x2c29e0; // 0x2c2dc8 - g_ps2RecompiledFunctionTable[461685] = Adv_FirstWarningMessage_0x2c29e0; // 0x2c2ddc - g_ps2RecompiledFunctionTable[461689] = Adv_FirstWarningMessage_0x2c29e0; // 0x2c2dec - g_ps2RecompiledFunctionTable[461706] = Adv_FirstWarningMessage_0x2c29e0; // 0x2c2e30 - g_ps2RecompiledFunctionTable[461709] = Adv_FirstWarningMessage_0x2c29e0; // 0x2c2e3c - g_ps2RecompiledFunctionTable[461715] = Adv_FirstWarningMessage_0x2c29e0; // 0x2c2e54 - g_ps2RecompiledFunctionTable[461720] = Adv_FirstWarningMessage_0x2c29e0; // 0x2c2e68 - g_ps2RecompiledFunctionTable[461726] = Adv_FirstWarningMessage_0x2c29e0; // 0x2c2e80 - g_ps2RecompiledFunctionTable[461728] = Adv_FirstWarningMessage_0x2c29e0; // 0x2c2e88 - g_ps2RecompiledFunctionTable[461738] = Adv_CapcomLogo_0x2c2eb0; // 0x2c2eb0 - g_ps2RecompiledFunctionTable[461746] = Adv_CapcomLogo_0x2c2eb0; // 0x2c2ed0 - g_ps2RecompiledFunctionTable[461748] = Adv_CapcomLogo_0x2c2eb0; // 0x2c2ed8 - g_ps2RecompiledFunctionTable[461750] = Adv_CapcomLogo_0x2c2eb0; // 0x2c2ee0 - g_ps2RecompiledFunctionTable[461763] = Adv_CapcomLogo_0x2c2eb0; // 0x2c2f14 - g_ps2RecompiledFunctionTable[461768] = Adv_CapcomLogo_0x2c2eb0; // 0x2c2f28 - g_ps2RecompiledFunctionTable[461773] = Adv_CapcomLogo_0x2c2eb0; // 0x2c2f3c - g_ps2RecompiledFunctionTable[461777] = Adv_CapcomLogo_0x2c2eb0; // 0x2c2f4c - g_ps2RecompiledFunctionTable[461779] = Adv_CapcomLogo_0x2c2eb0; // 0x2c2f54 - g_ps2RecompiledFunctionTable[461781] = Adv_CapcomLogo_0x2c2eb0; // 0x2c2f5c - g_ps2RecompiledFunctionTable[461784] = Adv_CapcomLogo_0x2c2eb0; // 0x2c2f68 - g_ps2RecompiledFunctionTable[461789] = Adv_CapcomLogo_0x2c2eb0; // 0x2c2f7c - g_ps2RecompiledFunctionTable[461798] = Adv_CapcomLogo_0x2c2eb0; // 0x2c2fa0 - g_ps2RecompiledFunctionTable[461812] = Adv_CapcomLogo_0x2c2eb0; // 0x2c2fd8 - g_ps2RecompiledFunctionTable[461815] = Adv_CapcomLogo_0x2c2eb0; // 0x2c2fe4 - g_ps2RecompiledFunctionTable[461821] = Adv_CapcomLogo_0x2c2eb0; // 0x2c2ffc - g_ps2RecompiledFunctionTable[461825] = Adv_CapcomLogo_0x2c2eb0; // 0x2c300c - g_ps2RecompiledFunctionTable[461846] = Adv_CapcomLogo_0x2c2eb0; // 0x2c3060 - g_ps2RecompiledFunctionTable[461852] = Adv_CapcomLogo_0x2c2eb0; // 0x2c3078 - g_ps2RecompiledFunctionTable[461857] = Adv_CapcomLogo_0x2c2eb0; // 0x2c308c - g_ps2RecompiledFunctionTable[461878] = Adv_CapcomLogo_0x2c2eb0; // 0x2c30e0 - g_ps2RecompiledFunctionTable[461899] = Adv_CapcomLogo_0x2c2eb0; // 0x2c3134 - g_ps2RecompiledFunctionTable[461910] = ResetFlushPlate_0x2c3160; // 0x2c3160 - g_ps2RecompiledFunctionTable[461918] = FlushPlate_0x2c3180; // 0x2c3180 - g_ps2RecompiledFunctionTable[461955] = FlushPlate_0x2c3180; // 0x2c3214 - g_ps2RecompiledFunctionTable[461959] = FlushPlate_0x2c3180; // 0x2c3224 - g_ps2RecompiledFunctionTable[461966] = FlushPlate_0x2c3180; // 0x2c3240 - g_ps2RecompiledFunctionTable[461978] = DisplayTitleBg_0x2c3270; // 0x2c3270 - g_ps2RecompiledFunctionTable[461986] = DisplayTitleBg_0x2c3270; // 0x2c3290 - g_ps2RecompiledFunctionTable[461996] = DisplayTitleBg_0x2c3270; // 0x2c32b8 - g_ps2RecompiledFunctionTable[462006] = DisplayTitleBg_0x2c3270; // 0x2c32e0 - g_ps2RecompiledFunctionTable[462015] = DisplayTitleBg_0x2c3270; // 0x2c3304 - g_ps2RecompiledFunctionTable[462025] = DisplayTitleBg_0x2c3270; // 0x2c332c - g_ps2RecompiledFunctionTable[462036] = DisplayTitleBg_0x2c3270; // 0x2c3358 - g_ps2RecompiledFunctionTable[462045] = DisplayTitleBg_0x2c3270; // 0x2c337c - g_ps2RecompiledFunctionTable[462050] = DisplayPressStartPlate_0x2c3390; // 0x2c3390 - g_ps2RecompiledFunctionTable[462059] = DisplayPressStartPlate_0x2c3390; // 0x2c33b4 - g_ps2RecompiledFunctionTable[462069] = DisplayPressStartPlate_0x2c3390; // 0x2c33dc - g_ps2RecompiledFunctionTable[462078] = DisplayPressStartPlate_0x2c3390; // 0x2c3400 - g_ps2RecompiledFunctionTable[462080] = DisplayPressStartPlate_0x2c3390; // 0x2c3408 - g_ps2RecompiledFunctionTable[462089] = DisplayPressStartPlate_0x2c3390; // 0x2c342c - g_ps2RecompiledFunctionTable[462096] = DisplayPressStartPlate_0x2c3390; // 0x2c3448 - g_ps2RecompiledFunctionTable[462102] = DisplayGameModePlate_0x2c3460; // 0x2c3460 - g_ps2RecompiledFunctionTable[462156] = DisplayGameModePlate_0x2c3460; // 0x2c3538 - g_ps2RecompiledFunctionTable[462167] = DisplayGameModePlate_0x2c3460; // 0x2c3564 - g_ps2RecompiledFunctionTable[462178] = DisplayGameModePlate_0x2c3460; // 0x2c3590 - g_ps2RecompiledFunctionTable[462189] = DisplayGameModePlate_0x2c3460; // 0x2c35bc - g_ps2RecompiledFunctionTable[462200] = DisplayGameModePlate_0x2c3460; // 0x2c35e8 - g_ps2RecompiledFunctionTable[462211] = DisplayGameModePlate_0x2c3460; // 0x2c3614 - g_ps2RecompiledFunctionTable[462222] = DisplayGameModePlate_0x2c3460; // 0x2c3640 - g_ps2RecompiledFunctionTable[462233] = DisplayGameModePlate_0x2c3460; // 0x2c366c - g_ps2RecompiledFunctionTable[462237] = DisplayGameModePlate_0x2c3460; // 0x2c367c - g_ps2RecompiledFunctionTable[462239] = DisplayGameModePlate_0x2c3460; // 0x2c3684 - g_ps2RecompiledFunctionTable[462246] = DisplayGameModePlate_0x2c3460; // 0x2c36a0 - g_ps2RecompiledFunctionTable[462252] = DisplayGameModePlate_0x2c3460; // 0x2c36b8 - g_ps2RecompiledFunctionTable[462265] = DisplayGameModePlate_0x2c3460; // 0x2c36ec - g_ps2RecompiledFunctionTable[462275] = DisplayGameModePlate_0x2c3460; // 0x2c3714 - g_ps2RecompiledFunctionTable[462289] = DisplayGameModePlate_0x2c3460; // 0x2c374c - g_ps2RecompiledFunctionTable[462296] = DisplayGameModePlate_0x2c3460; // 0x2c3768 - g_ps2RecompiledFunctionTable[462298] = DisplayGameModePlate_0x2c3460; // 0x2c3770 - g_ps2RecompiledFunctionTable[462310] = DisplayNewGamePlate_0x2c37a0; // 0x2c37a0 - g_ps2RecompiledFunctionTable[462346] = DisplayNewGamePlate_0x2c37a0; // 0x2c3830 - g_ps2RecompiledFunctionTable[462356] = DisplayNewGamePlate_0x2c37a0; // 0x2c3858 - g_ps2RecompiledFunctionTable[462366] = DisplayNewGamePlate_0x2c37a0; // 0x2c3880 - g_ps2RecompiledFunctionTable[462376] = DisplayNewGamePlate_0x2c37a0; // 0x2c38a8 - g_ps2RecompiledFunctionTable[462386] = DisplayNewGamePlate_0x2c37a0; // 0x2c38d0 - g_ps2RecompiledFunctionTable[462396] = DisplayNewGamePlate_0x2c37a0; // 0x2c38f8 - g_ps2RecompiledFunctionTable[462407] = DisplayNewGamePlate_0x2c37a0; // 0x2c3924 - g_ps2RecompiledFunctionTable[462418] = DisplayNewGamePlate_0x2c37a0; // 0x2c3950 - g_ps2RecompiledFunctionTable[462420] = DisplayNewGamePlate_0x2c37a0; // 0x2c3958 - g_ps2RecompiledFunctionTable[462422] = DisplayNewGamePlate_0x2c37a0; // 0x2c3960 - g_ps2RecompiledFunctionTable[462429] = DisplayNewGamePlate_0x2c37a0; // 0x2c397c - g_ps2RecompiledFunctionTable[462438] = DisplayNewGamePlate_0x2c37a0; // 0x2c39a0 - g_ps2RecompiledFunctionTable[462450] = DisplayNewGamePlate_0x2c37a0; // 0x2c39d0 - g_ps2RecompiledFunctionTable[462459] = DisplayNewGamePlate_0x2c37a0; // 0x2c39f4 - g_ps2RecompiledFunctionTable[462473] = DisplayNewGamePlate_0x2c37a0; // 0x2c3a2c - g_ps2RecompiledFunctionTable[462480] = DisplayNewGamePlate_0x2c37a0; // 0x2c3a48 - g_ps2RecompiledFunctionTable[462486] = DisplayNewGamePlate_0x2c37a0; // 0x2c3a60 - g_ps2RecompiledFunctionTable[462495] = DisplayNewGamePlate_0x2c37a0; // 0x2c3a84 - g_ps2RecompiledFunctionTable[462497] = DisplayNewGamePlate_0x2c37a0; // 0x2c3a8c - g_ps2RecompiledFunctionTable[462499] = DisplayNewGamePlate_0x2c37a0; // 0x2c3a94 - g_ps2RecompiledFunctionTable[462510] = DisplayExtraGamePlate_0x2c3ac0; // 0x2c3ac0 - g_ps2RecompiledFunctionTable[462544] = DisplayExtraGamePlate_0x2c3ac0; // 0x2c3b48 - g_ps2RecompiledFunctionTable[462554] = DisplayExtraGamePlate_0x2c3ac0; // 0x2c3b70 - g_ps2RecompiledFunctionTable[462564] = DisplayExtraGamePlate_0x2c3ac0; // 0x2c3b98 - g_ps2RecompiledFunctionTable[462574] = DisplayExtraGamePlate_0x2c3ac0; // 0x2c3bc0 - g_ps2RecompiledFunctionTable[462584] = DisplayExtraGamePlate_0x2c3ac0; // 0x2c3be8 - g_ps2RecompiledFunctionTable[462594] = DisplayExtraGamePlate_0x2c3ac0; // 0x2c3c10 - g_ps2RecompiledFunctionTable[462596] = DisplayExtraGamePlate_0x2c3ac0; // 0x2c3c18 - g_ps2RecompiledFunctionTable[462598] = DisplayExtraGamePlate_0x2c3ac0; // 0x2c3c20 - g_ps2RecompiledFunctionTable[462605] = DisplayExtraGamePlate_0x2c3ac0; // 0x2c3c3c - g_ps2RecompiledFunctionTable[462614] = DisplayExtraGamePlate_0x2c3ac0; // 0x2c3c60 - g_ps2RecompiledFunctionTable[462626] = DisplayExtraGamePlate_0x2c3ac0; // 0x2c3c90 - g_ps2RecompiledFunctionTable[462635] = DisplayExtraGamePlate_0x2c3ac0; // 0x2c3cb4 - g_ps2RecompiledFunctionTable[462649] = DisplayExtraGamePlate_0x2c3ac0; // 0x2c3cec - g_ps2RecompiledFunctionTable[462656] = DisplayExtraGamePlate_0x2c3ac0; // 0x2c3d08 - g_ps2RecompiledFunctionTable[462662] = DisplayExtraGamePlate_0x2c3ac0; // 0x2c3d20 - g_ps2RecompiledFunctionTable[462671] = DisplayExtraGamePlate_0x2c3ac0; // 0x2c3d44 - g_ps2RecompiledFunctionTable[462673] = DisplayExtraGamePlate_0x2c3ac0; // 0x2c3d4c - g_ps2RecompiledFunctionTable[462675] = DisplayExtraGamePlate_0x2c3ac0; // 0x2c3d54 - g_ps2RecompiledFunctionTable[462686] = FadeInPlate_0x2c3d80; // 0x2c3d80 - g_ps2RecompiledFunctionTable[462694] = FadeInPlate_0x2c3d80; // 0x2c3da0 - g_ps2RecompiledFunctionTable[462714] = FadeOutPlate_0x2c3df0; // 0x2c3df0 - g_ps2RecompiledFunctionTable[462720] = FadeOutPlate_0x2c3df0; // 0x2c3e08 - g_ps2RecompiledFunctionTable[462738] = TitleCall_0x2c3e50; // 0x2c3e50 - g_ps2RecompiledFunctionTable[462747] = TitleCall_0x2c3e50; // 0x2c3e74 - g_ps2RecompiledFunctionTable[462750] = TitleCall_0x2c3e50; // 0x2c3e80 - g_ps2RecompiledFunctionTable[462754] = TitleCall_0x2c3e50; // 0x2c3e90 - g_ps2RecompiledFunctionTable[462756] = TitleCall_0x2c3e50; // 0x2c3e98 - g_ps2RecompiledFunctionTable[462759] = TitleCall_0x2c3e50; // 0x2c3ea4 - g_ps2RecompiledFunctionTable[462774] = CheckButton_0x2c3ee0; // 0x2c3ee0 - g_ps2RecompiledFunctionTable[462829] = CheckButton_0x2c3ee0; // 0x2c3fbc - g_ps2RecompiledFunctionTable[462860] = CheckButton_0x2c3ee0; // 0x2c4038 - g_ps2RecompiledFunctionTable[462901] = CheckButton_0x2c3ee0; // 0x2c40dc - g_ps2RecompiledFunctionTable[462910] = CheckButton_0x2c3ee0; // 0x2c4100 - g_ps2RecompiledFunctionTable[462953] = CheckButton_0x2c3ee0; // 0x2c41ac - g_ps2RecompiledFunctionTable[462968] = CheckButton_0x2c3ee0; // 0x2c41e8 - g_ps2RecompiledFunctionTable[462999] = CheckButton_0x2c3ee0; // 0x2c4264 - g_ps2RecompiledFunctionTable[463004] = CheckButton_0x2c3ee0; // 0x2c4278 - g_ps2RecompiledFunctionTable[463013] = CheckButton_0x2c3ee0; // 0x2c429c - g_ps2RecompiledFunctionTable[463023] = CheckButton_0x2c3ee0; // 0x2c42c4 - g_ps2RecompiledFunctionTable[463035] = CheckButton_0x2c3ee0; // 0x2c42f4 - g_ps2RecompiledFunctionTable[463037] = CheckButton_0x2c3ee0; // 0x2c42fc - g_ps2RecompiledFunctionTable[463040] = CheckButton_0x2c3ee0; // 0x2c4308 - g_ps2RecompiledFunctionTable[463051] = CheckButton_0x2c3ee0; // 0x2c4334 - g_ps2RecompiledFunctionTable[463062] = CheckButton_0x2c3ee0; // 0x2c4360 - g_ps2RecompiledFunctionTable[463073] = CheckButton_0x2c3ee0; // 0x2c438c - g_ps2RecompiledFunctionTable[463083] = CheckButton_0x2c3ee0; // 0x2c43b4 - g_ps2RecompiledFunctionTable[463096] = CheckButton_0x2c3ee0; // 0x2c43e8 - g_ps2RecompiledFunctionTable[463106] = CheckStartButton_0x2c4410; // 0x2c4410 - g_ps2RecompiledFunctionTable[463125] = CheckStartButton_0x2c4410; // 0x2c445c - g_ps2RecompiledFunctionTable[463127] = CheckStartButton_0x2c4410; // 0x2c4464 - g_ps2RecompiledFunctionTable[463134] = Adv_BioCvTitle_0x2c4480; // 0x2c4480 - g_ps2RecompiledFunctionTable[463145] = Adv_BioCvTitle_0x2c4480; // 0x2c44ac - g_ps2RecompiledFunctionTable[463147] = Adv_BioCvTitle_0x2c4480; // 0x2c44b4 - g_ps2RecompiledFunctionTable[463149] = Adv_BioCvTitle_0x2c4480; // 0x2c44bc - g_ps2RecompiledFunctionTable[463151] = Adv_BioCvTitle_0x2c4480; // 0x2c44c4 - g_ps2RecompiledFunctionTable[463156] = Adv_BioCvTitle_0x2c4480; // 0x2c44d8 - g_ps2RecompiledFunctionTable[463176] = Adv_BioCvTitle_0x2c4480; // 0x2c4528 - g_ps2RecompiledFunctionTable[463178] = Adv_BioCvTitle_0x2c4480; // 0x2c4530 - g_ps2RecompiledFunctionTable[463180] = Adv_BioCvTitle_0x2c4480; // 0x2c4538 - g_ps2RecompiledFunctionTable[463184] = Adv_BioCvTitle_0x2c4480; // 0x2c4548 - g_ps2RecompiledFunctionTable[463186] = Adv_BioCvTitle_0x2c4480; // 0x2c4550 - g_ps2RecompiledFunctionTable[463297] = Adv_BioCvTitle_0x2c4480; // 0x2c470c - g_ps2RecompiledFunctionTable[463309] = Adv_BioCvTitle_0x2c4480; // 0x2c473c - g_ps2RecompiledFunctionTable[463314] = Adv_BioCvTitle_0x2c4480; // 0x2c4750 - g_ps2RecompiledFunctionTable[463320] = Adv_BioCvTitle_0x2c4480; // 0x2c4768 - g_ps2RecompiledFunctionTable[463323] = Adv_BioCvTitle_0x2c4480; // 0x2c4774 - g_ps2RecompiledFunctionTable[463327] = Adv_BioCvTitle_0x2c4480; // 0x2c4784 - g_ps2RecompiledFunctionTable[463330] = Adv_BioCvTitle_0x2c4480; // 0x2c4790 - g_ps2RecompiledFunctionTable[463334] = Adv_BioCvTitle_0x2c4480; // 0x2c47a0 - g_ps2RecompiledFunctionTable[463338] = Adv_BioCvTitle_0x2c4480; // 0x2c47b0 - g_ps2RecompiledFunctionTable[463340] = Adv_BioCvTitle_0x2c4480; // 0x2c47b8 - g_ps2RecompiledFunctionTable[463342] = Adv_BioCvTitle_0x2c4480; // 0x2c47c0 - g_ps2RecompiledFunctionTable[463345] = Adv_BioCvTitle_0x2c4480; // 0x2c47cc - g_ps2RecompiledFunctionTable[463350] = Adv_BioCvTitle_0x2c4480; // 0x2c47e0 - g_ps2RecompiledFunctionTable[463376] = Adv_BioCvTitle_0x2c4480; // 0x2c4848 - g_ps2RecompiledFunctionTable[463401] = Adv_BioCvTitle_0x2c4480; // 0x2c48ac - g_ps2RecompiledFunctionTable[463450] = Adv_BioCvTitle_0x2c4480; // 0x2c4970 - g_ps2RecompiledFunctionTable[463453] = Adv_BioCvTitle_0x2c4480; // 0x2c497c - g_ps2RecompiledFunctionTable[463461] = Adv_BioCvTitle_0x2c4480; // 0x2c499c - g_ps2RecompiledFunctionTable[463473] = Adv_BioCvTitle_0x2c4480; // 0x2c49cc - g_ps2RecompiledFunctionTable[463477] = Adv_BioCvTitle_0x2c4480; // 0x2c49dc - g_ps2RecompiledFunctionTable[463479] = Adv_BioCvTitle_0x2c4480; // 0x2c49e4 - g_ps2RecompiledFunctionTable[463507] = Adv_BioCvTitle_0x2c4480; // 0x2c4a54 - g_ps2RecompiledFunctionTable[463514] = Adv_BioCvTitle_0x2c4480; // 0x2c4a70 - g_ps2RecompiledFunctionTable[463519] = Adv_BioCvTitle_0x2c4480; // 0x2c4a84 - g_ps2RecompiledFunctionTable[463527] = Adv_BioCvTitle_0x2c4480; // 0x2c4aa4 - g_ps2RecompiledFunctionTable[463537] = Adv_BioCvTitle_0x2c4480; // 0x2c4acc - g_ps2RecompiledFunctionTable[463543] = Adv_BioCvTitle_0x2c4480; // 0x2c4ae4 - g_ps2RecompiledFunctionTable[463554] = Adv_BioCvTitle_0x2c4480; // 0x2c4b10 - g_ps2RecompiledFunctionTable[463564] = Adv_BioCvTitle_0x2c4480; // 0x2c4b38 - g_ps2RecompiledFunctionTable[463570] = Adv_BioCvTitle_0x2c4480; // 0x2c4b50 - g_ps2RecompiledFunctionTable[463578] = Adv_BioCvTitle_0x2c4480; // 0x2c4b70 - g_ps2RecompiledFunctionTable[463581] = Adv_BioCvTitle_0x2c4480; // 0x2c4b7c - g_ps2RecompiledFunctionTable[463592] = Adv_BioCvTitle_0x2c4480; // 0x2c4ba8 - g_ps2RecompiledFunctionTable[463600] = Adv_BioCvTitle_0x2c4480; // 0x2c4bc8 - g_ps2RecompiledFunctionTable[463609] = Adv_BioCvTitle_0x2c4480; // 0x2c4bec - g_ps2RecompiledFunctionTable[463616] = Adv_BioCvTitle_0x2c4480; // 0x2c4c08 - g_ps2RecompiledFunctionTable[463618] = Adv_BioCvTitle_0x2c4480; // 0x2c4c10 - g_ps2RecompiledFunctionTable[463622] = Adv_BioCvTitle_0x2c4480; // 0x2c4c20 - g_ps2RecompiledFunctionTable[463626] = Adv_BioCvTitle_0x2c4480; // 0x2c4c30 - g_ps2RecompiledFunctionTable[463632] = Adv_BioCvTitle_0x2c4480; // 0x2c4c48 - g_ps2RecompiledFunctionTable[463636] = Adv_BioCvTitle_0x2c4480; // 0x2c4c58 - g_ps2RecompiledFunctionTable[463642] = Adv_BioCvTitle_0x2c4480; // 0x2c4c70 - g_ps2RecompiledFunctionTable[463644] = Adv_BioCvTitle_0x2c4480; // 0x2c4c78 - g_ps2RecompiledFunctionTable[463648] = Adv_BioCvTitle_0x2c4480; // 0x2c4c88 - g_ps2RecompiledFunctionTable[463652] = Adv_BioCvTitle_0x2c4480; // 0x2c4c98 - g_ps2RecompiledFunctionTable[463658] = Adv_BioCvTitle_0x2c4480; // 0x2c4cb0 - g_ps2RecompiledFunctionTable[463662] = Adv_BioCvTitle_0x2c4480; // 0x2c4cc0 - g_ps2RecompiledFunctionTable[463668] = Adv_BioCvTitle_0x2c4480; // 0x2c4cd8 - g_ps2RecompiledFunctionTable[463670] = Adv_BioCvTitle_0x2c4480; // 0x2c4ce0 - g_ps2RecompiledFunctionTable[463674] = Adv_BioCvTitle_0x2c4480; // 0x2c4cf0 - g_ps2RecompiledFunctionTable[463681] = Adv_BioCvTitle_0x2c4480; // 0x2c4d0c - g_ps2RecompiledFunctionTable[463693] = Adv_BioCvTitle_0x2c4480; // 0x2c4d3c - g_ps2RecompiledFunctionTable[463724] = Adv_BioCvTitle_0x2c4480; // 0x2c4db8 - g_ps2RecompiledFunctionTable[463741] = Adv_BioCvTitle_0x2c4480; // 0x2c4dfc - g_ps2RecompiledFunctionTable[463743] = Adv_BioCvTitle_0x2c4480; // 0x2c4e04 - g_ps2RecompiledFunctionTable[463756] = Adv_BioCvTitle_0x2c4480; // 0x2c4e38 - g_ps2RecompiledFunctionTable[463786] = ResetOptionMenuParam_0x2c4eb0; // 0x2c4eb0 - g_ps2RecompiledFunctionTable[463800] = ResetOptionMenuParam_0x2c4eb0; // 0x2c4ee8 - g_ps2RecompiledFunctionTable[463804] = ResetOptionMenuParam_0x2c4eb0; // 0x2c4ef8 - g_ps2RecompiledFunctionTable[463848] = ResetOptionMenuParam_0x2c4eb0; // 0x2c4fa8 - g_ps2RecompiledFunctionTable[463851] = ResetOptionMenuParam_0x2c4eb0; // 0x2c4fb4 - g_ps2RecompiledFunctionTable[463866] = ResetOptionMenuParam_0x2c4eb0; // 0x2c4ff0 - g_ps2RecompiledFunctionTable[463869] = ResetOptionMenuParam_0x2c4eb0; // 0x2c4ffc - g_ps2RecompiledFunctionTable[463876] = ResetOptionMenuParam_0x2c4eb0; // 0x2c5018 - g_ps2RecompiledFunctionTable[463880] = ResetOptionMenuParam_0x2c4eb0; // 0x2c5028 - g_ps2RecompiledFunctionTable[463887] = ResetOptionMenuParam_0x2c4eb0; // 0x2c5044 - g_ps2RecompiledFunctionTable[463893] = ResetOptionMenuParam_0x2c4eb0; // 0x2c505c - g_ps2RecompiledFunctionTable[463922] = ResetOptionMenuParam_0x2c4eb0; // 0x2c50d0 - g_ps2RecompiledFunctionTable[463934] = DisplayOptionScrollPlate_0x2c5100; // 0x2c5100 - g_ps2RecompiledFunctionTable[463946] = DisplayOptionScrollPlate_0x2c5100; // 0x2c5130 - g_ps2RecompiledFunctionTable[463947] = DisplayOptionScrollPlate_0x2c5100; // 0x2c5134 - g_ps2RecompiledFunctionTable[463960] = DisplayOptionScrollPlate_0x2c5100; // 0x2c5168 - g_ps2RecompiledFunctionTable[463972] = DisplayOptionScrollPlate_0x2c5100; // 0x2c5198 - g_ps2RecompiledFunctionTable[463987] = DisplayOptionScrollPlate_0x2c5100; // 0x2c51d4 - g_ps2RecompiledFunctionTable[463993] = DisplayOptionScrollPlate_0x2c5100; // 0x2c51ec - g_ps2RecompiledFunctionTable[464002] = DisplayOptionBg_0x2c5210; // 0x2c5210 - g_ps2RecompiledFunctionTable[464042] = DisplayOptionBg_0x2c5210; // 0x2c52b0 - g_ps2RecompiledFunctionTable[464046] = DisplayOptionBg_0x2c5210; // 0x2c52c0 - g_ps2RecompiledFunctionTable[464049] = DisplayOptionBg_0x2c5210; // 0x2c52cc - g_ps2RecompiledFunctionTable[464062] = DisplayOptionBg_0x2c5210; // 0x2c5300 - g_ps2RecompiledFunctionTable[464102] = DisplayOptionBg_0x2c5210; // 0x2c53a0 - g_ps2RecompiledFunctionTable[464111] = DisplayOptionBg_0x2c5210; // 0x2c53c4 - g_ps2RecompiledFunctionTable[464121] = DisplayOptionBg_0x2c5210; // 0x2c53ec - g_ps2RecompiledFunctionTable[464130] = DisplayOptionBg_0x2c5210; // 0x2c5410 - g_ps2RecompiledFunctionTable[464140] = DisplayOptionBg_0x2c5210; // 0x2c5438 - g_ps2RecompiledFunctionTable[464149] = DisplayOptionBg_0x2c5210; // 0x2c545c - g_ps2RecompiledFunctionTable[464158] = DisplayOptionBg_0x2c5210; // 0x2c5480 - g_ps2RecompiledFunctionTable[464160] = DisplayOptionBg_0x2c5210; // 0x2c5488 - g_ps2RecompiledFunctionTable[464174] = DisplayOptionPlateLevel0_0x2c54c0; // 0x2c54c0 - g_ps2RecompiledFunctionTable[464195] = DisplayOptionPlateLevel0_0x2c54c0; // 0x2c5514 - g_ps2RecompiledFunctionTable[464203] = DisplayOptionPlateLevel0_0x2c54c0; // 0x2c5534 - g_ps2RecompiledFunctionTable[464227] = DisplayOptionPlateLevel0_0x2c54c0; // 0x2c5594 - g_ps2RecompiledFunctionTable[464237] = DisplayOptionPlateLevel0_0x2c54c0; // 0x2c55bc - g_ps2RecompiledFunctionTable[464241] = DisplayOptionPlateLevel0_0x2c54c0; // 0x2c55cc - g_ps2RecompiledFunctionTable[464262] = DisplayOptionPlateLevel0_0x2c54c0; // 0x2c5620 - g_ps2RecompiledFunctionTable[464276] = DisplayOptionPlateLevel0_0x2c54c0; // 0x2c5658 - g_ps2RecompiledFunctionTable[464289] = DisplayOptionPlateLevel0_0x2c54c0; // 0x2c568c - g_ps2RecompiledFunctionTable[464292] = DisplayOptionPlateLevel0_0x2c54c0; // 0x2c5698 - g_ps2RecompiledFunctionTable[464322] = DisplayOptionPlateLevel0_0x2c54c0; // 0x2c5710 - g_ps2RecompiledFunctionTable[464346] = DisplayOptionPlateLevel0_0x2c54c0; // 0x2c5770 - g_ps2RecompiledFunctionTable[464380] = DisplayOptionPlateLevel0_0x2c54c0; // 0x2c57f8 - g_ps2RecompiledFunctionTable[464384] = DisplayOptionPlateLevel0_0x2c54c0; // 0x2c5808 - g_ps2RecompiledFunctionTable[464387] = DisplayOptionPlateLevel0_0x2c54c0; // 0x2c5814 - g_ps2RecompiledFunctionTable[464394] = DisplayOptionPlateLevel0_0x2c54c0; // 0x2c5830 - g_ps2RecompiledFunctionTable[464435] = DisplayOptionPlateLevel0_0x2c54c0; // 0x2c58d4 - g_ps2RecompiledFunctionTable[464441] = DisplayOptionPlateLevel0_0x2c54c0; // 0x2c58ec - g_ps2RecompiledFunctionTable[464447] = DisplayOptionPlateLevel0_0x2c54c0; // 0x2c5904 - g_ps2RecompiledFunctionTable[464450] = DisplayOptionPlateLevel0_0x2c54c0; // 0x2c5910 - g_ps2RecompiledFunctionTable[464476] = DisplayOptionPlateLevel0_0x2c54c0; // 0x2c5978 - g_ps2RecompiledFunctionTable[464485] = DisplayOptionPlateLevel0_0x2c54c0; // 0x2c599c - g_ps2RecompiledFunctionTable[464494] = DisplayOptionPlateLevel0_0x2c54c0; // 0x2c59c0 - g_ps2RecompiledFunctionTable[464503] = DisplayOptionPlateLevel0_0x2c54c0; // 0x2c59e4 - g_ps2RecompiledFunctionTable[464512] = DisplayOptionPlateLevel0_0x2c54c0; // 0x2c5a08 - g_ps2RecompiledFunctionTable[464522] = DisplayOptionPlateLevel0_0x2c54c0; // 0x2c5a30 - g_ps2RecompiledFunctionTable[464531] = DisplayOptionPlateLevel0_0x2c54c0; // 0x2c5a54 - g_ps2RecompiledFunctionTable[464541] = DisplayOptionPlateLevel0_0x2c54c0; // 0x2c5a7c - g_ps2RecompiledFunctionTable[464549] = DisplayOptionPlateLevel0_0x2c54c0; // 0x2c5a9c - g_ps2RecompiledFunctionTable[464559] = DisplayOptionPlateLevel0_0x2c54c0; // 0x2c5ac4 - g_ps2RecompiledFunctionTable[464568] = DisplayOptionPlateLevel0_0x2c54c0; // 0x2c5ae8 - g_ps2RecompiledFunctionTable[464578] = DisplayOptionPlateLevel0_0x2c54c0; // 0x2c5b10 - g_ps2RecompiledFunctionTable[464587] = DisplayOptionPlateLevel0_0x2c54c0; // 0x2c5b34 - g_ps2RecompiledFunctionTable[464597] = DisplayOptionPlateLevel0_0x2c54c0; // 0x2c5b5c - g_ps2RecompiledFunctionTable[464607] = DisplayOptionPlateLevel0_0x2c54c0; // 0x2c5b84 - g_ps2RecompiledFunctionTable[464617] = DisplayOptionPlateLevel0_0x2c54c0; // 0x2c5bac - g_ps2RecompiledFunctionTable[464627] = DisplayOptionPlateLevel0_0x2c54c0; // 0x2c5bd4 - g_ps2RecompiledFunctionTable[464637] = DisplayOptionPlateLevel0_0x2c54c0; // 0x2c5bfc - g_ps2RecompiledFunctionTable[464647] = DisplayOptionPlateLevel0_0x2c54c0; // 0x2c5c24 - g_ps2RecompiledFunctionTable[464657] = DisplayOptionPlateLevel0_0x2c54c0; // 0x2c5c4c - g_ps2RecompiledFunctionTable[464666] = DisplayOptionPlateLevel0_0x2c54c0; // 0x2c5c70 - g_ps2RecompiledFunctionTable[464682] = DisplayOptionPlateLevel0_0x2c54c0; // 0x2c5cb0 - g_ps2RecompiledFunctionTable[464692] = DisplayOptionPlateLevel0_0x2c54c0; // 0x2c5cd8 - g_ps2RecompiledFunctionTable[464702] = DisplayOptionPlateLevel0_0x2c54c0; // 0x2c5d00 - g_ps2RecompiledFunctionTable[464712] = DisplayOptionPlateLevel0_0x2c54c0; // 0x2c5d28 - g_ps2RecompiledFunctionTable[464722] = DisplayOptionPlateLevel0_0x2c54c0; // 0x2c5d50 - g_ps2RecompiledFunctionTable[464731] = DisplayOptionPlateLevel0_0x2c54c0; // 0x2c5d74 - g_ps2RecompiledFunctionTable[464741] = DisplayOptionPlateLevel0_0x2c54c0; // 0x2c5d9c - g_ps2RecompiledFunctionTable[464744] = DisplayOptionPlateLevel0_0x2c54c0; // 0x2c5da8 - g_ps2RecompiledFunctionTable[464749] = DisplayOptionPlateLevel0_0x2c54c0; // 0x2c5dbc - g_ps2RecompiledFunctionTable[464770] = DisplayOptionPlateLevel0_0x2c54c0; // 0x2c5e10 - g_ps2RecompiledFunctionTable[464791] = DisplayOptionPlateLevel0_0x2c54c0; // 0x2c5e64 - g_ps2RecompiledFunctionTable[464803] = DisplayOptionPlateLevel0_0x2c54c0; // 0x2c5e94 - g_ps2RecompiledFunctionTable[464813] = DisplayOptionPlateLevel0_0x2c54c0; // 0x2c5ebc - g_ps2RecompiledFunctionTable[464825] = DisplayOptionPlateLevel0_0x2c54c0; // 0x2c5eec - g_ps2RecompiledFunctionTable[464838] = DisplayOptionPlateLevel0_0x2c54c0; // 0x2c5f20 - g_ps2RecompiledFunctionTable[464850] = DisplayOptionPlateLevel0_0x2c54c0; // 0x2c5f50 - g_ps2RecompiledFunctionTable[464863] = DisplayOptionPlateLevel0_0x2c54c0; // 0x2c5f84 - g_ps2RecompiledFunctionTable[464873] = DisplayOptionPlateLevel0_0x2c54c0; // 0x2c5fac - g_ps2RecompiledFunctionTable[464884] = DisplayOptionPlateLevel0_0x2c54c0; // 0x2c5fd8 - g_ps2RecompiledFunctionTable[464894] = DisplayOptionPlateLevel0_0x2c54c0; // 0x2c6000 - g_ps2RecompiledFunctionTable[464912] = DisplayOptionPlateLevel0_0x2c54c0; // 0x2c6048 - g_ps2RecompiledFunctionTable[464924] = DisplayOptionPlateLevel0_0x2c54c0; // 0x2c6078 - g_ps2RecompiledFunctionTable[464934] = DisplayOptionPlateLevel0_0x2c54c0; // 0x2c60a0 - g_ps2RecompiledFunctionTable[464946] = DisplayOptionPlateLevel0_0x2c54c0; // 0x2c60d0 - g_ps2RecompiledFunctionTable[464960] = DisplayOptionPlateLevel0_0x2c54c0; // 0x2c6108 - g_ps2RecompiledFunctionTable[464972] = DisplayOptionPlateLevel0_0x2c54c0; // 0x2c6138 - g_ps2RecompiledFunctionTable[464981] = DisplayOptionPlateLevel0_0x2c54c0; // 0x2c615c - g_ps2RecompiledFunctionTable[464983] = DisplayOptionPlateLevel0_0x2c54c0; // 0x2c6164 - g_ps2RecompiledFunctionTable[464994] = DisplayOptionPlateLevel1_0x2c6190; // 0x2c6190 - g_ps2RecompiledFunctionTable[465086] = DisplayOptionPlateLevel1_0x2c6190; // 0x2c6300 - g_ps2RecompiledFunctionTable[465127] = DisplayOptionPlateLevel1_0x2c6190; // 0x2c63a4 - g_ps2RecompiledFunctionTable[465169] = DisplayOptionPlateLevel1_0x2c6190; // 0x2c644c - g_ps2RecompiledFunctionTable[465180] = DisplayOptionPlateLevel1_0x2c6190; // 0x2c6478 - g_ps2RecompiledFunctionTable[465190] = DisplayOptionPlateLevel1_0x2c6190; // 0x2c64a0 - g_ps2RecompiledFunctionTable[465198] = DisplayOptionPlateLevel1_0x2c6190; // 0x2c64c0 - g_ps2RecompiledFunctionTable[465208] = DisplayOptionPlateLevel1_0x2c6190; // 0x2c64e8 - g_ps2RecompiledFunctionTable[465217] = DisplayOptionPlateLevel1_0x2c6190; // 0x2c650c - g_ps2RecompiledFunctionTable[465225] = DisplayOptionPlateLevel1_0x2c6190; // 0x2c652c - g_ps2RecompiledFunctionTable[465235] = DisplayOptionPlateLevel1_0x2c6190; // 0x2c6554 - g_ps2RecompiledFunctionTable[465245] = DisplayOptionPlateLevel1_0x2c6190; // 0x2c657c - g_ps2RecompiledFunctionTable[465253] = DisplayOptionPlateLevel1_0x2c6190; // 0x2c659c - g_ps2RecompiledFunctionTable[465262] = DisplayOptionPlateLevel1_0x2c6190; // 0x2c65c0 - g_ps2RecompiledFunctionTable[465284] = DisplayOptionPlateLevel1_0x2c6190; // 0x2c6618 - g_ps2RecompiledFunctionTable[465292] = DisplayOptionPlateLevel1_0x2c6190; // 0x2c6638 - g_ps2RecompiledFunctionTable[465301] = DisplayOptionPlateLevel1_0x2c6190; // 0x2c665c - g_ps2RecompiledFunctionTable[465311] = DisplayOptionPlateLevel1_0x2c6190; // 0x2c6684 - g_ps2RecompiledFunctionTable[465313] = DisplayOptionPlateLevel1_0x2c6190; // 0x2c668c - g_ps2RecompiledFunctionTable[465325] = DisplayOptionPlateLevel1_0x2c6190; // 0x2c66bc - g_ps2RecompiledFunctionTable[465334] = DisplayOptionPlateLevel1_0x2c6190; // 0x2c66e0 - g_ps2RecompiledFunctionTable[465344] = DisplayOptionPlateLevel1_0x2c6190; // 0x2c6708 - g_ps2RecompiledFunctionTable[465346] = DisplayOptionPlateLevel1_0x2c6190; // 0x2c6710 - g_ps2RecompiledFunctionTable[465358] = DisplayOptionPlateLevel1_0x2c6190; // 0x2c6740 - g_ps2RecompiledFunctionTable[465365] = DisplayOptionPlateLevel1_0x2c6190; // 0x2c675c - g_ps2RecompiledFunctionTable[465376] = DisplayOptionPlateLevel1_0x2c6190; // 0x2c6788 - g_ps2RecompiledFunctionTable[465401] = DisplayOptionPlateLevel1_0x2c6190; // 0x2c67ec - g_ps2RecompiledFunctionTable[465409] = DisplayOptionPlateLevel1_0x2c6190; // 0x2c680c - g_ps2RecompiledFunctionTable[465424] = DisplayOptionPlateLevel1_0x2c6190; // 0x2c6848 - g_ps2RecompiledFunctionTable[465444] = DisplayOptionPlateLevel1_0x2c6190; // 0x2c6898 - g_ps2RecompiledFunctionTable[465452] = DisplayOptionPlateLevel1_0x2c6190; // 0x2c68b8 - g_ps2RecompiledFunctionTable[465474] = DisplayOptionPlateLevel1_0x2c6190; // 0x2c6910 - g_ps2RecompiledFunctionTable[465485] = DisplayOptionPlateLevel1_0x2c6190; // 0x2c693c - g_ps2RecompiledFunctionTable[465500] = DisplayOptionPlateLevel1_0x2c6190; // 0x2c6978 - g_ps2RecompiledFunctionTable[465512] = DisplayOptionPlateLevel1_0x2c6190; // 0x2c69a8 - g_ps2RecompiledFunctionTable[465520] = DisplayOptionPlateLevel1_0x2c6190; // 0x2c69c8 - g_ps2RecompiledFunctionTable[465543] = DisplayOptionPlateLevel1_0x2c6190; // 0x2c6a24 - g_ps2RecompiledFunctionTable[465571] = DisplayOptionPlateLevel1_0x2c6190; // 0x2c6a94 - g_ps2RecompiledFunctionTable[465606] = DisplayOptionPlateLevel1_0x2c6190; // 0x2c6b20 - g_ps2RecompiledFunctionTable[465632] = DisplayOptionPlateLevel1_0x2c6190; // 0x2c6b88 - g_ps2RecompiledFunctionTable[465652] = DisplayOptionPlateLevel1_0x2c6190; // 0x2c6bd8 - g_ps2RecompiledFunctionTable[465670] = DisplayOptionPlateLevel1_0x2c6190; // 0x2c6c20 - g_ps2RecompiledFunctionTable[465687] = DisplayOptionPlateLevel1_0x2c6190; // 0x2c6c64 - g_ps2RecompiledFunctionTable[465709] = DisplayOptionPlateLevel1_0x2c6190; // 0x2c6cbc - g_ps2RecompiledFunctionTable[465718] = DisplayOptionPlateLevel1_0x2c6190; // 0x2c6ce0 - g_ps2RecompiledFunctionTable[465732] = DisplayOptionPlateLevel1_0x2c6190; // 0x2c6d18 - g_ps2RecompiledFunctionTable[465746] = DisplayOptionPlateLevel2_0x2c6d50; // 0x2c6d50 - g_ps2RecompiledFunctionTable[465777] = DisplayOptionPlateLevel2_0x2c6d50; // 0x2c6dcc - g_ps2RecompiledFunctionTable[465787] = DisplayOptionPlateLevel2_0x2c6d50; // 0x2c6df4 - g_ps2RecompiledFunctionTable[465790] = DisplayOptionPlateLevel2_0x2c6d50; // 0x2c6e00 - g_ps2RecompiledFunctionTable[465804] = DisplayOptionPlateLevel2_0x2c6d50; // 0x2c6e38 - g_ps2RecompiledFunctionTable[465807] = DisplayOptionPlateLevel2_0x2c6d50; // 0x2c6e44 - g_ps2RecompiledFunctionTable[465822] = DisplayOptionPlateLevel2_0x2c6d50; // 0x2c6e80 - g_ps2RecompiledFunctionTable[465825] = DisplayOptionPlateLevel2_0x2c6d50; // 0x2c6e8c - g_ps2RecompiledFunctionTable[465840] = DisplayOptionPlateLevel2_0x2c6d50; // 0x2c6ec8 - g_ps2RecompiledFunctionTable[465843] = DisplayOptionPlateLevel2_0x2c6d50; // 0x2c6ed4 - g_ps2RecompiledFunctionTable[465858] = DisplayOptionPlateLevel2_0x2c6d50; // 0x2c6f10 - g_ps2RecompiledFunctionTable[465861] = DisplayOptionPlateLevel2_0x2c6d50; // 0x2c6f1c - g_ps2RecompiledFunctionTable[465873] = DisplayOptionPlateLevel2_0x2c6d50; // 0x2c6f4c - g_ps2RecompiledFunctionTable[465883] = DisplayOptionPlateLevel2_0x2c6d50; // 0x2c6f74 - g_ps2RecompiledFunctionTable[465891] = DisplayOptionPlateLevel2_0x2c6d50; // 0x2c6f94 - g_ps2RecompiledFunctionTable[465900] = DisplayOptionPlateLevel2_0x2c6d50; // 0x2c6fb8 - g_ps2RecompiledFunctionTable[465911] = DisplayOptionPlateLevel2_0x2c6d50; // 0x2c6fe4 - g_ps2RecompiledFunctionTable[465920] = DisplayOptionPlateLevel2_0x2c6d50; // 0x2c7008 - g_ps2RecompiledFunctionTable[465930] = DisplayOptionPlateLevel2_0x2c6d50; // 0x2c7030 - g_ps2RecompiledFunctionTable[465940] = DisplayOptionPlateLevel2_0x2c6d50; // 0x2c7058 - g_ps2RecompiledFunctionTable[465948] = DisplayOptionPlateLevel2_0x2c6d50; // 0x2c7078 - g_ps2RecompiledFunctionTable[465957] = DisplayOptionPlateLevel2_0x2c6d50; // 0x2c709c - g_ps2RecompiledFunctionTable[465967] = DisplayOptionPlateLevel2_0x2c6d50; // 0x2c70c4 - g_ps2RecompiledFunctionTable[465975] = DisplayOptionPlateLevel2_0x2c6d50; // 0x2c70e4 - g_ps2RecompiledFunctionTable[465984] = DisplayOptionPlateLevel2_0x2c6d50; // 0x2c7108 - g_ps2RecompiledFunctionTable[465994] = DisplayOptionPlateLevel2_0x2c6d50; // 0x2c7130 - g_ps2RecompiledFunctionTable[466002] = DisplayOptionPlateLevel2_0x2c6d50; // 0x2c7150 - g_ps2RecompiledFunctionTable[466011] = DisplayOptionPlateLevel2_0x2c6d50; // 0x2c7174 - g_ps2RecompiledFunctionTable[466021] = DisplayOptionPlateLevel2_0x2c6d50; // 0x2c719c - g_ps2RecompiledFunctionTable[466029] = DisplayOptionPlateLevel2_0x2c6d50; // 0x2c71bc - g_ps2RecompiledFunctionTable[466038] = DisplayOptionPlateLevel2_0x2c6d50; // 0x2c71e0 - g_ps2RecompiledFunctionTable[466048] = DisplayOptionPlateLevel2_0x2c6d50; // 0x2c7208 - g_ps2RecompiledFunctionTable[466056] = DisplayOptionPlateLevel2_0x2c6d50; // 0x2c7228 - g_ps2RecompiledFunctionTable[466065] = DisplayOptionPlateLevel2_0x2c6d50; // 0x2c724c - g_ps2RecompiledFunctionTable[466075] = DisplayOptionPlateLevel2_0x2c6d50; // 0x2c7274 - g_ps2RecompiledFunctionTable[466084] = DisplayOptionPlateLevel2_0x2c6d50; // 0x2c7298 - g_ps2RecompiledFunctionTable[466094] = DisplayOptionPlateLevel2_0x2c6d50; // 0x2c72c0 - g_ps2RecompiledFunctionTable[466105] = DisplayOptionPlateLevel2_0x2c6d50; // 0x2c72ec - g_ps2RecompiledFunctionTable[466114] = DisplayOptionPlateLevel2_0x2c6d50; // 0x2c7310 - g_ps2RecompiledFunctionTable[466127] = DisplayOptionPlateLevel2_0x2c6d50; // 0x2c7344 - g_ps2RecompiledFunctionTable[466138] = DisplayOptionPlateLevel2_0x2c6d50; // 0x2c7370 - g_ps2RecompiledFunctionTable[466147] = DisplayOptionPlateLevel2_0x2c6d50; // 0x2c7394 - g_ps2RecompiledFunctionTable[466150] = DisplayOptionPlateLevel2_0x2c6d50; // 0x2c73a0 - g_ps2RecompiledFunctionTable[466152] = DisplayOptionPlateLevel2_0x2c6d50; // 0x2c73a8 - g_ps2RecompiledFunctionTable[466157] = DisplayOptionPlateLevel2_0x2c6d50; // 0x2c73bc - g_ps2RecompiledFunctionTable[466167] = DisplayOptionPlateLevel2_0x2c6d50; // 0x2c73e4 - g_ps2RecompiledFunctionTable[466184] = DisplayOptionPlateLevel2_0x2c6d50; // 0x2c7428 - g_ps2RecompiledFunctionTable[466193] = DisplayOptionPlateLevel2_0x2c6d50; // 0x2c744c - g_ps2RecompiledFunctionTable[466203] = DisplayOptionPlateLevel2_0x2c6d50; // 0x2c7474 - g_ps2RecompiledFunctionTable[466221] = DisplayOptionPlateLevel2_0x2c6d50; // 0x2c74bc - g_ps2RecompiledFunctionTable[466230] = DisplayOptionPlateLevel2_0x2c6d50; // 0x2c74e0 - g_ps2RecompiledFunctionTable[466240] = DisplayOptionPlateLevel2_0x2c6d50; // 0x2c7508 - g_ps2RecompiledFunctionTable[466250] = DisplayOptionPlateLevel2_0x2c6d50; // 0x2c7530 - g_ps2RecompiledFunctionTable[466259] = DisplayOptionPlateLevel2_0x2c6d50; // 0x2c7554 - g_ps2RecompiledFunctionTable[466269] = DisplayOptionPlateLevel2_0x2c6d50; // 0x2c757c - g_ps2RecompiledFunctionTable[466280] = DisplayOptionPlateLevel2_0x2c6d50; // 0x2c75a8 - g_ps2RecompiledFunctionTable[466289] = DisplayOptionPlateLevel2_0x2c6d50; // 0x2c75cc - g_ps2RecompiledFunctionTable[466302] = DisplayOptionPlateLevel2_0x2c6d50; // 0x2c7600 - g_ps2RecompiledFunctionTable[466313] = DisplayOptionPlateLevel2_0x2c6d50; // 0x2c762c - g_ps2RecompiledFunctionTable[466322] = DisplayOptionPlateLevel2_0x2c6d50; // 0x2c7650 - g_ps2RecompiledFunctionTable[466325] = DisplayOptionPlateLevel2_0x2c6d50; // 0x2c765c - g_ps2RecompiledFunctionTable[466327] = DisplayOptionPlateLevel2_0x2c6d50; // 0x2c7664 - g_ps2RecompiledFunctionTable[466332] = DisplayOptionPlateLevel2_0x2c6d50; // 0x2c7678 - g_ps2RecompiledFunctionTable[466342] = DisplayOptionPlateLevel2_0x2c6d50; // 0x2c76a0 - g_ps2RecompiledFunctionTable[466359] = DisplayOptionPlateLevel2_0x2c6d50; // 0x2c76e4 - g_ps2RecompiledFunctionTable[466368] = DisplayOptionPlateLevel2_0x2c6d50; // 0x2c7708 - g_ps2RecompiledFunctionTable[466378] = DisplayOptionPlateLevel2_0x2c6d50; // 0x2c7730 - g_ps2RecompiledFunctionTable[466395] = DisplayOptionPlateLevel2_0x2c6d50; // 0x2c7774 - g_ps2RecompiledFunctionTable[466404] = DisplayOptionPlateLevel2_0x2c6d50; // 0x2c7798 - g_ps2RecompiledFunctionTable[466427] = DisplayOptionPlateLevel2_0x2c6d50; // 0x2c77f4 - g_ps2RecompiledFunctionTable[466446] = DisplayOptionPlateLevel2_0x2c6d50; // 0x2c7840 - g_ps2RecompiledFunctionTable[466448] = DisplayOptionPlateLevel2_0x2c6d50; // 0x2c7848 - g_ps2RecompiledFunctionTable[466458] = DisplayOptionPlateLevel3_0x2c7870; // 0x2c7870 - g_ps2RecompiledFunctionTable[466497] = DisplayOptionPlateLevel3_0x2c7870; // 0x2c790c - g_ps2RecompiledFunctionTable[466509] = DisplayOptionPlateLevel3_0x2c7870; // 0x2c793c - g_ps2RecompiledFunctionTable[466519] = DisplayOptionPlateLevel3_0x2c7870; // 0x2c7964 - g_ps2RecompiledFunctionTable[466527] = DisplayOptionPlateLevel3_0x2c7870; // 0x2c7984 - g_ps2RecompiledFunctionTable[466536] = DisplayOptionPlateLevel3_0x2c7870; // 0x2c79a8 - g_ps2RecompiledFunctionTable[466547] = DisplayOptionPlateLevel3_0x2c7870; // 0x2c79d4 - g_ps2RecompiledFunctionTable[466549] = DisplayOptionPlateLevel3_0x2c7870; // 0x2c79dc - g_ps2RecompiledFunctionTable[466561] = DisplayOptionPlateLevel3_0x2c7870; // 0x2c7a0c - g_ps2RecompiledFunctionTable[466571] = DisplayOptionPlateLevel3_0x2c7870; // 0x2c7a34 - g_ps2RecompiledFunctionTable[466581] = DisplayOptionPlateLevel3_0x2c7870; // 0x2c7a5c - g_ps2RecompiledFunctionTable[466590] = DisplayOptionPlateLevel3_0x2c7870; // 0x2c7a80 - g_ps2RecompiledFunctionTable[466615] = DisplayOptionPlateLevel3_0x2c7870; // 0x2c7ae4 - g_ps2RecompiledFunctionTable[466663] = DisplayOptionPlateLevel3_0x2c7870; // 0x2c7ba4 - g_ps2RecompiledFunctionTable[466711] = DisplayOptionPlateLevel3_0x2c7870; // 0x2c7c64 - g_ps2RecompiledFunctionTable[466731] = DisplayOptionPlateLevel3_0x2c7870; // 0x2c7cb4 - g_ps2RecompiledFunctionTable[466733] = DisplayOptionPlateLevel3_0x2c7870; // 0x2c7cbc - g_ps2RecompiledFunctionTable[466746] = DisplayOptionPlate_0x2c7cf0; // 0x2c7cf0 - g_ps2RecompiledFunctionTable[466763] = DisplayOptionPlate_0x2c7cf0; // 0x2c7d34 - g_ps2RecompiledFunctionTable[466768] = DisplayOptionPlate_0x2c7cf0; // 0x2c7d48 - g_ps2RecompiledFunctionTable[466773] = DisplayOptionPlate_0x2c7cf0; // 0x2c7d5c - g_ps2RecompiledFunctionTable[466777] = DisplayOptionPlate_0x2c7cf0; // 0x2c7d6c - g_ps2RecompiledFunctionTable[466786] = Adv_GameOptionScreen_0x2c7d90; // 0x2c7d90 - g_ps2RecompiledFunctionTable[466794] = Adv_GameOptionScreen_0x2c7d90; // 0x2c7db0 - g_ps2RecompiledFunctionTable[466797] = Adv_GameOptionScreen_0x2c7d90; // 0x2c7dbc - g_ps2RecompiledFunctionTable[466802] = Adv_GameOptionScreen_0x2c7d90; // 0x2c7dd0 - g_ps2RecompiledFunctionTable[466805] = Adv_GameOptionScreen_0x2c7d90; // 0x2c7ddc - g_ps2RecompiledFunctionTable[466818] = Adv_GameOptionScreen_0x2c7d90; // 0x2c7e10 - g_ps2RecompiledFunctionTable[466820] = Adv_GameOptionScreen_0x2c7d90; // 0x2c7e18 - g_ps2RecompiledFunctionTable[466831] = Adv_GameOptionScreen_0x2c7d90; // 0x2c7e44 - g_ps2RecompiledFunctionTable[466834] = Adv_GameOptionScreen_0x2c7d90; // 0x2c7e50 - g_ps2RecompiledFunctionTable[466841] = Adv_GameOptionScreen_0x2c7d90; // 0x2c7e6c - g_ps2RecompiledFunctionTable[466847] = Adv_GameOptionScreen_0x2c7d90; // 0x2c7e84 - g_ps2RecompiledFunctionTable[466851] = Adv_GameOptionScreen_0x2c7d90; // 0x2c7e94 - g_ps2RecompiledFunctionTable[466853] = Adv_GameOptionScreen_0x2c7d90; // 0x2c7e9c - g_ps2RecompiledFunctionTable[466859] = Adv_GameOptionScreen_0x2c7d90; // 0x2c7eb4 - g_ps2RecompiledFunctionTable[466867] = Adv_GameOptionScreen_0x2c7d90; // 0x2c7ed4 - g_ps2RecompiledFunctionTable[466871] = Adv_GameOptionScreen_0x2c7d90; // 0x2c7ee4 - g_ps2RecompiledFunctionTable[466876] = Adv_GameOptionScreen_0x2c7d90; // 0x2c7ef8 - g_ps2RecompiledFunctionTable[466882] = Adv_GameOptionScreen_0x2c7d90; // 0x2c7f10 - g_ps2RecompiledFunctionTable[466886] = Adv_GameOptionScreen_0x2c7d90; // 0x2c7f20 - g_ps2RecompiledFunctionTable[466889] = Adv_GameOptionScreen_0x2c7d90; // 0x2c7f2c - g_ps2RecompiledFunctionTable[466893] = Adv_GameOptionScreen_0x2c7d90; // 0x2c7f3c - g_ps2RecompiledFunctionTable[466896] = Adv_GameOptionScreen_0x2c7d90; // 0x2c7f48 - g_ps2RecompiledFunctionTable[466900] = Adv_GameOptionScreen_0x2c7d90; // 0x2c7f58 - g_ps2RecompiledFunctionTable[466903] = Adv_GameOptionScreen_0x2c7d90; // 0x2c7f64 - g_ps2RecompiledFunctionTable[466906] = Adv_GameOptionScreen_0x2c7d90; // 0x2c7f70 - g_ps2RecompiledFunctionTable[466910] = Adv_GameOptionScreen_0x2c7d90; // 0x2c7f80 - g_ps2RecompiledFunctionTable[466915] = Adv_GameOptionScreen_0x2c7d90; // 0x2c7f94 - g_ps2RecompiledFunctionTable[466919] = Adv_GameOptionScreen_0x2c7d90; // 0x2c7fa4 - g_ps2RecompiledFunctionTable[466925] = Adv_GameOptionScreen_0x2c7d90; // 0x2c7fbc - g_ps2RecompiledFunctionTable[466932] = Adv_GameOptionScreen_0x2c7d90; // 0x2c7fd8 - g_ps2RecompiledFunctionTable[466935] = Adv_GameOptionScreen_0x2c7d90; // 0x2c7fe4 - g_ps2RecompiledFunctionTable[466937] = Adv_GameOptionScreen_0x2c7d90; // 0x2c7fec - g_ps2RecompiledFunctionTable[466944] = Adv_GameOptionScreen_0x2c7d90; // 0x2c8008 - g_ps2RecompiledFunctionTable[466948] = Adv_GameOptionScreen_0x2c7d90; // 0x2c8018 - g_ps2RecompiledFunctionTable[466952] = Adv_GameOptionScreen_0x2c7d90; // 0x2c8028 - g_ps2RecompiledFunctionTable[466960] = Adv_GameOptionScreen_0x2c7d90; // 0x2c8048 - g_ps2RecompiledFunctionTable[466994] = Adv_GameOptionScreen_0x2c7d90; // 0x2c80d0 - g_ps2RecompiledFunctionTable[467001] = Adv_GameOptionScreen_0x2c7d90; // 0x2c80ec - g_ps2RecompiledFunctionTable[467031] = Adv_GameOptionScreen_0x2c7d90; // 0x2c8164 - g_ps2RecompiledFunctionTable[467036] = Adv_GameOptionScreen_0x2c7d90; // 0x2c8178 - g_ps2RecompiledFunctionTable[467039] = Adv_GameOptionScreen_0x2c7d90; // 0x2c8184 - g_ps2RecompiledFunctionTable[467043] = Adv_GameOptionScreen_0x2c7d90; // 0x2c8194 - g_ps2RecompiledFunctionTable[467057] = Adv_GameOptionScreen_0x2c7d90; // 0x2c81cc - g_ps2RecompiledFunctionTable[467060] = Adv_GameOptionScreen_0x2c7d90; // 0x2c81d8 - g_ps2RecompiledFunctionTable[467064] = Adv_GameOptionScreen_0x2c7d90; // 0x2c81e8 - g_ps2RecompiledFunctionTable[467081] = Adv_GameOptionScreen_0x2c7d90; // 0x2c822c - g_ps2RecompiledFunctionTable[467091] = Adv_GameOptionScreen_0x2c7d90; // 0x2c8254 - g_ps2RecompiledFunctionTable[467102] = Adv_GameOptionScreen_0x2c7d90; // 0x2c8280 - g_ps2RecompiledFunctionTable[467131] = Adv_GameOptionScreen_0x2c7d90; // 0x2c82f4 - g_ps2RecompiledFunctionTable[467135] = Adv_GameOptionScreen_0x2c7d90; // 0x2c8304 - g_ps2RecompiledFunctionTable[467142] = Adv_GameOptionScreen_0x2c7d90; // 0x2c8320 - g_ps2RecompiledFunctionTable[467147] = Adv_GameOptionScreen_0x2c7d90; // 0x2c8334 - g_ps2RecompiledFunctionTable[467152] = Adv_GameOptionScreen_0x2c7d90; // 0x2c8348 - g_ps2RecompiledFunctionTable[467157] = Adv_GameOptionScreen_0x2c7d90; // 0x2c835c - g_ps2RecompiledFunctionTable[467171] = Adv_GameOptionScreen_0x2c7d90; // 0x2c8394 - g_ps2RecompiledFunctionTable[467175] = Adv_GameOptionScreen_0x2c7d90; // 0x2c83a4 - g_ps2RecompiledFunctionTable[467177] = Adv_GameOptionScreen_0x2c7d90; // 0x2c83ac - g_ps2RecompiledFunctionTable[467179] = Adv_GameOptionScreen_0x2c7d90; // 0x2c83b4 - g_ps2RecompiledFunctionTable[467190] = Adv_ChangeDiscScreen_0x2c83e0; // 0x2c83e0 - g_ps2RecompiledFunctionTable[467196] = Adv_ChangeDiscScreen_0x2c83e0; // 0x2c83f8 - g_ps2RecompiledFunctionTable[467228] = Adv_ChangeDiscScreen_0x2c83e0; // 0x2c8478 - g_ps2RecompiledFunctionTable[467250] = Adv_SoundMuseum_0x2c84d0; // 0x2c84d0 - g_ps2RecompiledFunctionTable[467254] = InitVibrationUnit_0x2c84e0; // 0x2c84e0 - g_ps2RecompiledFunctionTable[467264] = InitVibrationUnit_0x2c84e0; // 0x2c8508 - g_ps2RecompiledFunctionTable[467266] = InitVibrationUnit_0x2c84e0; // 0x2c8510 - g_ps2RecompiledFunctionTable[467273] = InitVibrationUnit_0x2c84e0; // 0x2c852c - g_ps2RecompiledFunctionTable[467286] = ExitVibrationUnit_0x2c8560; // 0x2c8560 - g_ps2RecompiledFunctionTable[467293] = ExitVibrationUnit_0x2c8560; // 0x2c857c - g_ps2RecompiledFunctionTable[467295] = ExitVibrationUnit_0x2c8560; // 0x2c8584 - g_ps2RecompiledFunctionTable[467300] = ExitVibrationUnit_0x2c8560; // 0x2c8598 - g_ps2RecompiledFunctionTable[467310] = SetUseVibrationUnit_0x2c85c0; // 0x2c85c0 - g_ps2RecompiledFunctionTable[467314] = GetUseVibrationUnit_0x2c85d0; // 0x2c85d0 - g_ps2RecompiledFunctionTable[467318] = CheckVibrationUnit_0x2c85e0; // 0x2c85e0 - g_ps2RecompiledFunctionTable[467322] = StartVibration_0x2c85f0; // 0x2c85f0 - g_ps2RecompiledFunctionTable[467345] = StartVibration_0x2c85f0; // 0x2c864c - g_ps2RecompiledFunctionTable[467354] = StartVibration_0x2c85f0; // 0x2c8670 - g_ps2RecompiledFunctionTable[467362] = StopVibration_0x2c8690; // 0x2c8690 - g_ps2RecompiledFunctionTable[467383] = StopVibration_0x2c8690; // 0x2c86e4 - g_ps2RecompiledFunctionTable[467391] = StopVibration_0x2c8690; // 0x2c8704 - g_ps2RecompiledFunctionTable[467398] = bhMlbBinRealize_0x2c8720; // 0x2c8720 - g_ps2RecompiledFunctionTable[467428] = bhMlbBinRealize_0x2c8720; // 0x2c8798 - g_ps2RecompiledFunctionTable[467454] = bhMlbBinRealize_0x2c8720; // 0x2c8800 - g_ps2RecompiledFunctionTable[467459] = bhMlbBinRealize_0x2c8720; // 0x2c8814 - g_ps2RecompiledFunctionTable[467479] = bhMlbBinRealize_0x2c8720; // 0x2c8864 - g_ps2RecompiledFunctionTable[467498] = bhBscBinRealize_0x2c88b0; // 0x2c88b0 - g_ps2RecompiledFunctionTable[467533] = bhBscBinRealize_0x2c88b0; // 0x2c893c - g_ps2RecompiledFunctionTable[467582] = bhCnkBinRealize_0x2c8a00; // 0x2c8a00 - g_ps2RecompiledFunctionTable[467606] = bhMnbBinRealize_0x2c8a60; // 0x2c8a60 - g_ps2RecompiledFunctionTable[467631] = bhMnbBinRealize_0x2c8a60; // 0x2c8ac4 - g_ps2RecompiledFunctionTable[467654] = ControlTypewriter_0x2c8b20; // 0x2c8b20 - g_ps2RecompiledFunctionTable[467655] = ControlTypewriter_0x2c8b20; // 0x2c8b24 - g_ps2RecompiledFunctionTable[467656] = ControlTypewriter_0x2c8b20; // 0x2c8b28 - g_ps2RecompiledFunctionTable[467657] = ControlTypewriter_0x2c8b20; // 0x2c8b2c - g_ps2RecompiledFunctionTable[467658] = ControlTypewriter_0x2c8b20; // 0x2c8b30 - g_ps2RecompiledFunctionTable[467659] = ControlTypewriter_0x2c8b20; // 0x2c8b34 - g_ps2RecompiledFunctionTable[467660] = ControlTypewriter_0x2c8b20; // 0x2c8b38 - g_ps2RecompiledFunctionTable[467661] = ControlTypewriter_0x2c8b20; // 0x2c8b3c - g_ps2RecompiledFunctionTable[467662] = ControlTypewriter_0x2c8b20; // 0x2c8b40 - g_ps2RecompiledFunctionTable[467663] = ControlTypewriter_0x2c8b20; // 0x2c8b44 - g_ps2RecompiledFunctionTable[467666] = TypewriterKeepMemory_0x2c8b50; // 0x2c8b50 - g_ps2RecompiledFunctionTable[467671] = TypewriterKeepMemory_0x2c8b50; // 0x2c8b64 - g_ps2RecompiledFunctionTable[467678] = CountDisplay_0x2c8b80; // 0x2c8b80 - g_ps2RecompiledFunctionTable[467692] = CountDisplay_0x2c8b80; // 0x2c8bb8 - g_ps2RecompiledFunctionTable[467694] = CountDisplay_0x2c8b80; // 0x2c8bc0 - g_ps2RecompiledFunctionTable[467757] = CountDisplay_0x2c8b80; // 0x2c8cbc - g_ps2RecompiledFunctionTable[467766] = RoomNameSwitch_0x2c8ce0; // 0x2c8ce0 - g_ps2RecompiledFunctionTable[467858] = TypeWriterTextureInit_0x2c8e50; // 0x2c8e50 - g_ps2RecompiledFunctionTable[467895] = TypeWriterTextureInit_0x2c8e50; // 0x2c8ee4 - g_ps2RecompiledFunctionTable[467916] = TypeWriterTextureInit_0x2c8e50; // 0x2c8f38 - g_ps2RecompiledFunctionTable[467937] = TypeWriterTextureInit_0x2c8e50; // 0x2c8f8c - g_ps2RecompiledFunctionTable[467950] = TypeWriterTextureInit_0x2c8e50; // 0x2c8fc0 - g_ps2RecompiledFunctionTable[467973] = TypeWriterTextureInit_0x2c8e50; // 0x2c901c - g_ps2RecompiledFunctionTable[467980] = TypeWriterTextureInit_0x2c8e50; // 0x2c9038 - g_ps2RecompiledFunctionTable[468000] = TypeWriterTextureInit_0x2c8e50; // 0x2c9088 - g_ps2RecompiledFunctionTable[468005] = TypeWriterTextureInit_0x2c8e50; // 0x2c909c - g_ps2RecompiledFunctionTable[468013] = TypeWriterTextureInit_0x2c8e50; // 0x2c90bc - g_ps2RecompiledFunctionTable[468022] = TypeWriterTextureInit_0x2c8e50; // 0x2c90e0 - g_ps2RecompiledFunctionTable[468046] = TypeWriterTextureInit_0x2c8e50; // 0x2c9140 - g_ps2RecompiledFunctionTable[468059] = TypeWriterTextureInit_0x2c8e50; // 0x2c9174 - g_ps2RecompiledFunctionTable[468066] = TypeWriterTextureInit_0x2c8e50; // 0x2c9190 - g_ps2RecompiledFunctionTable[468086] = TypeWriterTextureInit_0x2c8e50; // 0x2c91e0 - g_ps2RecompiledFunctionTable[468112] = TypeWriterTextureInit_0x2c8e50; // 0x2c9248 - g_ps2RecompiledFunctionTable[468114] = TypeWriterTextureInit_0x2c8e50; // 0x2c9250 - g_ps2RecompiledFunctionTable[468133] = TypeWriterTextureInit_0x2c8e50; // 0x2c929c - g_ps2RecompiledFunctionTable[468136] = TypeWriterTextureInit_0x2c8e50; // 0x2c92a8 - g_ps2RecompiledFunctionTable[468142] = TypeWriterTextureInit_0x2c8e50; // 0x2c92c0 - g_ps2RecompiledFunctionTable[468147] = TypeWriterTextureInit_0x2c8e50; // 0x2c92d4 - g_ps2RecompiledFunctionTable[468158] = TypeWriterTextureInit_0x2c8e50; // 0x2c9300 - g_ps2RecompiledFunctionTable[468176] = TypeWriterTextureInit_0x2c8e50; // 0x2c9348 - g_ps2RecompiledFunctionTable[468182] = TypewriterInit_0x2c9360; // 0x2c9360 - g_ps2RecompiledFunctionTable[468190] = TypewriterInit_0x2c9360; // 0x2c9380 - g_ps2RecompiledFunctionTable[468212] = TypewriterInit_0x2c9360; // 0x2c93d8 - g_ps2RecompiledFunctionTable[468282] = TypewriterInit_0x2c9360; // 0x2c94f0 - g_ps2RecompiledFunctionTable[468290] = TypewriterMain_0x2c9510; // 0x2c9510 - g_ps2RecompiledFunctionTable[468301] = TypewriterMain_0x2c9510; // 0x2c953c - g_ps2RecompiledFunctionTable[468325] = TypewriterMain_0x2c9510; // 0x2c959c - g_ps2RecompiledFunctionTable[468346] = TypewriterExit_0x2c95f0; // 0x2c95f0 - g_ps2RecompiledFunctionTable[468357] = TypewriterExit_0x2c95f0; // 0x2c961c - g_ps2RecompiledFunctionTable[468440] = TypewriterExit_0x2c95f0; // 0x2c9768 - g_ps2RecompiledFunctionTable[468443] = TypewriterExit_0x2c95f0; // 0x2c9774 - g_ps2RecompiledFunctionTable[468451] = TypewriterExit_0x2c95f0; // 0x2c9794 - g_ps2RecompiledFunctionTable[468479] = TypewriterExit_0x2c95f0; // 0x2c9804 - g_ps2RecompiledFunctionTable[468482] = TypewriterExit_0x2c95f0; // 0x2c9810 - g_ps2RecompiledFunctionTable[468488] = TypewriterExit_0x2c95f0; // 0x2c9828 - g_ps2RecompiledFunctionTable[468550] = TypewriterExit_0x2c95f0; // 0x2c9920 - g_ps2RecompiledFunctionTable[468569] = TypewriterExit_0x2c95f0; // 0x2c996c - g_ps2RecompiledFunctionTable[468573] = TypewriterExit_0x2c95f0; // 0x2c997c - g_ps2RecompiledFunctionTable[468578] = TypewriterExit_0x2c95f0; // 0x2c9990 - g_ps2RecompiledFunctionTable[468630] = BupInit_0x2c9a60; // 0x2c9a60 - g_ps2RecompiledFunctionTable[468637] = BupInit_0x2c9a60; // 0x2c9a7c - g_ps2RecompiledFunctionTable[468643] = BupInit_0x2c9a60; // 0x2c9a94 - g_ps2RecompiledFunctionTable[468646] = BupExit_0x2c9aa0; // 0x2c9aa0 - g_ps2RecompiledFunctionTable[468648] = BupExit_0x2c9aa0; // 0x2c9aa8 - g_ps2RecompiledFunctionTable[468650] = BupExit_0x2c9aa0; // 0x2c9ab0 - g_ps2RecompiledFunctionTable[468662] = ClearInfo_0x2c9ae0; // 0x2c9ae0 - g_ps2RecompiledFunctionTable[468678] = BupComplete_0x2c9b20; // 0x2c9b20 - g_ps2RecompiledFunctionTable[468716] = BupComplete_0x2c9b20; // 0x2c9bb8 - g_ps2RecompiledFunctionTable[468730] = BupComplete_0x2c9b20; // 0x2c9bf0 - g_ps2RecompiledFunctionTable[468733] = BupComplete_0x2c9b20; // 0x2c9bfc - g_ps2RecompiledFunctionTable[468742] = BupComplete_0x2c9b20; // 0x2c9c20 - g_ps2RecompiledFunctionTable[468750] = BupProgress_0x2c9c40; // 0x2c9c40 - g_ps2RecompiledFunctionTable[468762] = BupInitCallback_0x2c9c70; // 0x2c9c70 - g_ps2RecompiledFunctionTable[468767] = BupInitCallback_0x2c9c70; // 0x2c9c84 - g_ps2RecompiledFunctionTable[468770] = BupInitCallback_0x2c9c70; // 0x2c9c90 - g_ps2RecompiledFunctionTable[468774] = bhReadPlayerData_0x2c9ca0; // 0x2c9ca0 - g_ps2RecompiledFunctionTable[468797] = bhReadPlayerData_0x2c9ca0; // 0x2c9cfc - g_ps2RecompiledFunctionTable[468811] = bhReadPlayerData_0x2c9ca0; // 0x2c9d34 - g_ps2RecompiledFunctionTable[468830] = bhReadPlayerData_0x2c9ca0; // 0x2c9d80 - g_ps2RecompiledFunctionTable[468840] = bhReadPlayerData_0x2c9ca0; // 0x2c9da8 - g_ps2RecompiledFunctionTable[468879] = bhReadPlayerData_0x2c9ca0; // 0x2c9e44 - g_ps2RecompiledFunctionTable[468903] = bhReadPlayerData_0x2c9ca0; // 0x2c9ea4 - g_ps2RecompiledFunctionTable[468909] = bhReadPlayerData_0x2c9ca0; // 0x2c9ebc - g_ps2RecompiledFunctionTable[468931] = bhReadPlayerData_0x2c9ca0; // 0x2c9f14 - g_ps2RecompiledFunctionTable[468936] = bhReadPlayerData_0x2c9ca0; // 0x2c9f28 - g_ps2RecompiledFunctionTable[468962] = bhReadPlayerData_0x2c9ca0; // 0x2c9f90 - g_ps2RecompiledFunctionTable[468992] = bhReadPlayerData_0x2c9ca0; // 0x2ca008 - g_ps2RecompiledFunctionTable[468998] = bhReadPlayerData_0x2c9ca0; // 0x2ca020 - g_ps2RecompiledFunctionTable[469038] = bhReadWeaponData_0x2ca0c0; // 0x2ca0c0 - g_ps2RecompiledFunctionTable[469068] = bhReadWeaponData_0x2ca0c0; // 0x2ca138 - g_ps2RecompiledFunctionTable[469071] = bhReadWeaponData_0x2ca0c0; // 0x2ca144 - g_ps2RecompiledFunctionTable[469082] = bhReadWeaponData_0x2ca0c0; // 0x2ca170 - g_ps2RecompiledFunctionTable[469086] = bhReadWeaponData_0x2ca0c0; // 0x2ca180 - g_ps2RecompiledFunctionTable[469091] = bhReadWeaponData_0x2ca0c0; // 0x2ca194 - g_ps2RecompiledFunctionTable[469119] = bhReadWeaponData_0x2ca0c0; // 0x2ca204 - g_ps2RecompiledFunctionTable[469133] = bhReadWeaponData_0x2ca0c0; // 0x2ca23c - g_ps2RecompiledFunctionTable[469152] = bhReadWeaponData_0x2ca0c0; // 0x2ca288 - g_ps2RecompiledFunctionTable[469155] = bhReadWeaponData_0x2ca0c0; // 0x2ca294 - g_ps2RecompiledFunctionTable[469166] = bhReadWeaponData_0x2ca0c0; // 0x2ca2c0 - g_ps2RecompiledFunctionTable[469170] = bhReadWeaponData_0x2ca0c0; // 0x2ca2d0 - g_ps2RecompiledFunctionTable[469175] = bhReadWeaponData_0x2ca0c0; // 0x2ca2e4 - g_ps2RecompiledFunctionTable[469203] = bhReadWeaponData_0x2ca0c0; // 0x2ca354 - g_ps2RecompiledFunctionTable[469217] = bhReadWeaponData_0x2ca0c0; // 0x2ca38c - g_ps2RecompiledFunctionTable[469231] = bhReadWeaponData_0x2ca0c0; // 0x2ca3c4 - g_ps2RecompiledFunctionTable[469241] = bhReadWeaponData_0x2ca0c0; // 0x2ca3ec - g_ps2RecompiledFunctionTable[469247] = bhReadWeaponData_0x2ca0c0; // 0x2ca404 - g_ps2RecompiledFunctionTable[469266] = bhKeepObjWork_0x2ca450; // 0x2ca450 - g_ps2RecompiledFunctionTable[469283] = bhKeepObjWork_0x2ca450; // 0x2ca494 - g_ps2RecompiledFunctionTable[469294] = bhInitVSync_0x2ca4c0; // 0x2ca4c0 - g_ps2RecompiledFunctionTable[469299] = bhInitVSync_0x2ca4c0; // 0x2ca4d4 - g_ps2RecompiledFunctionTable[469302] = bhInitVSync_0x2ca4c0; // 0x2ca4e0 - g_ps2RecompiledFunctionTable[469306] = bhClearVSync_0x2ca4f0; // 0x2ca4f0 - g_ps2RecompiledFunctionTable[469310] = bhClearVSync_0x2ca4f0; // 0x2ca500 - g_ps2RecompiledFunctionTable[469312] = bhClearVSync_0x2ca4f0; // 0x2ca508 - g_ps2RecompiledFunctionTable[469318] = bhControlVSync_0x2ca520; // 0x2ca520 - g_ps2RecompiledFunctionTable[469322] = bhControlVSync_0x2ca520; // 0x2ca530 - g_ps2RecompiledFunctionTable[469340] = bhControlVSync_0x2ca520; // 0x2ca578 - g_ps2RecompiledFunctionTable[469405] = bhControlVSync_0x2ca520; // 0x2ca67c - g_ps2RecompiledFunctionTable[469457] = bhControlVSync_0x2ca520; // 0x2ca74c - g_ps2RecompiledFunctionTable[469473] = bhControlVSync_0x2ca520; // 0x2ca78c - g_ps2RecompiledFunctionTable[469489] = bhControlVSync_0x2ca520; // 0x2ca7cc - g_ps2RecompiledFunctionTable[469506] = bhControlEOR_0x2ca810; // 0x2ca810 - g_ps2RecompiledFunctionTable[469533] = bhControlEOR_0x2ca810; // 0x2ca87c - g_ps2RecompiledFunctionTable[469535] = bhControlEOR_0x2ca810; // 0x2ca884 - g_ps2RecompiledFunctionTable[469597] = bhControlEOR_0x2ca810; // 0x2ca97c - g_ps2RecompiledFunctionTable[469601] = bhControlEOR_0x2ca810; // 0x2ca98c - g_ps2RecompiledFunctionTable[469610] = bhControlEOR_0x2ca810; // 0x2ca9b0 - g_ps2RecompiledFunctionTable[469640] = bhControlEOR_0x2ca810; // 0x2caa28 - g_ps2RecompiledFunctionTable[469647] = bhControlEOR_0x2ca810; // 0x2caa44 - g_ps2RecompiledFunctionTable[469655] = bhControlEOR_0x2ca810; // 0x2caa64 - g_ps2RecompiledFunctionTable[469659] = bhControlEOR_0x2ca810; // 0x2caa74 - g_ps2RecompiledFunctionTable[469661] = bhControlEOR_0x2ca810; // 0x2caa7c - g_ps2RecompiledFunctionTable[469704] = bhControlEOR_0x2ca810; // 0x2cab28 - g_ps2RecompiledFunctionTable[469711] = bhControlEOR_0x2ca810; // 0x2cab44 - g_ps2RecompiledFunctionTable[469719] = bhControlEOR_0x2ca810; // 0x2cab64 - g_ps2RecompiledFunctionTable[469723] = bhControlEOR_0x2ca810; // 0x2cab74 - g_ps2RecompiledFunctionTable[469725] = bhControlEOR_0x2ca810; // 0x2cab7c - g_ps2RecompiledFunctionTable[469733] = bhControlEOR_0x2ca810; // 0x2cab9c - g_ps2RecompiledFunctionTable[469789] = bhControlEOR_0x2ca810; // 0x2cac7c - g_ps2RecompiledFunctionTable[469796] = bhControlEOR_0x2ca810; // 0x2cac98 - g_ps2RecompiledFunctionTable[469804] = bhControlEOR_0x2ca810; // 0x2cacb8 - g_ps2RecompiledFunctionTable[469808] = bhControlEOR_0x2ca810; // 0x2cacc8 - g_ps2RecompiledFunctionTable[469810] = bhControlEOR_0x2ca810; // 0x2cacd0 - g_ps2RecompiledFunctionTable[469818] = bhControlEOR_0x2ca810; // 0x2cacf0 - g_ps2RecompiledFunctionTable[469830] = bhCheckPadPort_0x2cad20; // 0x2cad20 - g_ps2RecompiledFunctionTable[469834] = bhCheckPadPort_0x2cad20; // 0x2cad30 - g_ps2RecompiledFunctionTable[469890] = bhCheckSoftReset_0x2cae10; // 0x2cae10 - g_ps2RecompiledFunctionTable[469916] = bhCheckSoftReset_0x2cae10; // 0x2cae78 - g_ps2RecompiledFunctionTable[469922] = Init_Expand_0x2cae90; // 0x2cae90 - g_ps2RecompiledFunctionTable[469926] = Expand_0x2caea0; // 0x2caea0 - g_ps2RecompiledFunctionTable[469939] = Expand_0x2caea0; // 0x2caed4 - g_ps2RecompiledFunctionTable[469943] = Expand_0x2caea0; // 0x2caee4 - g_ps2RecompiledFunctionTable[469999] = Expand_0x2caea0; // 0x2cafc4 - g_ps2RecompiledFunctionTable[470001] = Expand_0x2caea0; // 0x2cafcc - g_ps2RecompiledFunctionTable[470034] = ADXT_Pause_0x2cb050; // 0x2cb050 - g_ps2RecompiledFunctionTable[470038] = _builtin_set_imask_0x2cb060; // 0x2cb060 - g_ps2RecompiledFunctionTable[470042] = Ps2Init_0x2cb070; // 0x2cb070 - g_ps2RecompiledFunctionTable[470050] = Ps2Init_0x2cb070; // 0x2cb090 - g_ps2RecompiledFunctionTable[470052] = Ps2Init_0x2cb070; // 0x2cb098 - g_ps2RecompiledFunctionTable[470054] = Ps2Init_0x2cb070; // 0x2cb0a0 - g_ps2RecompiledFunctionTable[470059] = Ps2Init_0x2cb070; // 0x2cb0b4 - g_ps2RecompiledFunctionTable[470061] = Ps2Init_0x2cb070; // 0x2cb0bc - g_ps2RecompiledFunctionTable[470070] = Ps2Init_0x2cb070; // 0x2cb0e0 - g_ps2RecompiledFunctionTable[470194] = Ps2Init_0x2cb070; // 0x2cb2d0 - g_ps2RecompiledFunctionTable[470199] = Ps2Init_0x2cb070; // 0x2cb2e4 - g_ps2RecompiledFunctionTable[470201] = Ps2Init_0x2cb070; // 0x2cb2ec - g_ps2RecompiledFunctionTable[470203] = Ps2Init_0x2cb070; // 0x2cb2f4 - g_ps2RecompiledFunctionTable[470210] = Ps2Init_0x2cb070; // 0x2cb310 - g_ps2RecompiledFunctionTable[470213] = Ps2Init_0x2cb070; // 0x2cb31c - g_ps2RecompiledFunctionTable[470218] = Ps2Init_0x2cb070; // 0x2cb330 - g_ps2RecompiledFunctionTable[470220] = Ps2Init_0x2cb070; // 0x2cb338 - g_ps2RecompiledFunctionTable[470228] = Ps2Init_0x2cb070; // 0x2cb358 - g_ps2RecompiledFunctionTable[470230] = Ps2Init_0x2cb070; // 0x2cb360 - g_ps2RecompiledFunctionTable[470237] = Ps2Init_0x2cb070; // 0x2cb37c - g_ps2RecompiledFunctionTable[470239] = Ps2Init_0x2cb070; // 0x2cb384 - g_ps2RecompiledFunctionTable[470241] = Ps2Init_0x2cb070; // 0x2cb38c - g_ps2RecompiledFunctionTable[470246] = Ps2Init_0x2cb070; // 0x2cb3a0 - g_ps2RecompiledFunctionTable[470248] = Ps2Init_0x2cb070; // 0x2cb3a8 - g_ps2RecompiledFunctionTable[470251] = Ps2Init_0x2cb070; // 0x2cb3b4 - g_ps2RecompiledFunctionTable[470254] = Ps2Init_0x2cb070; // 0x2cb3c0 - g_ps2RecompiledFunctionTable[470257] = Ps2Init_0x2cb070; // 0x2cb3cc - g_ps2RecompiledFunctionTable[470260] = Ps2Init_0x2cb070; // 0x2cb3d8 - g_ps2RecompiledFunctionTable[470263] = Ps2Init_0x2cb070; // 0x2cb3e4 - g_ps2RecompiledFunctionTable[470266] = Ps2Init_0x2cb070; // 0x2cb3f0 - g_ps2RecompiledFunctionTable[470269] = Ps2Init_0x2cb070; // 0x2cb3fc - g_ps2RecompiledFunctionTable[470272] = Ps2Init_0x2cb070; // 0x2cb408 - g_ps2RecompiledFunctionTable[470275] = Ps2Init_0x2cb070; // 0x2cb414 - g_ps2RecompiledFunctionTable[470277] = Ps2Init_0x2cb070; // 0x2cb41c - g_ps2RecompiledFunctionTable[470279] = Ps2Init_0x2cb070; // 0x2cb424 - g_ps2RecompiledFunctionTable[470281] = Ps2Init_0x2cb070; // 0x2cb42c - g_ps2RecompiledFunctionTable[470283] = Ps2Init_0x2cb070; // 0x2cb434 - g_ps2RecompiledFunctionTable[470285] = Ps2Init_0x2cb070; // 0x2cb43c - g_ps2RecompiledFunctionTable[470287] = Ps2Init_0x2cb070; // 0x2cb444 - g_ps2RecompiledFunctionTable[470289] = Ps2Init_0x2cb070; // 0x2cb44c - g_ps2RecompiledFunctionTable[470291] = Ps2Init_0x2cb070; // 0x2cb454 - g_ps2RecompiledFunctionTable[470308] = Ps2Init_0x2cb070; // 0x2cb498 - g_ps2RecompiledFunctionTable[470310] = Ps2Init_0x2cb070; // 0x2cb4a0 - g_ps2RecompiledFunctionTable[470326] = Ps2Init_0x2cb070; // 0x2cb4e0 - g_ps2RecompiledFunctionTable[470328] = Ps2Init_0x2cb070; // 0x2cb4e8 - g_ps2RecompiledFunctionTable[470330] = Ps2Init_0x2cb070; // 0x2cb4f0 - g_ps2RecompiledFunctionTable[470333] = Ps2Init_0x2cb070; // 0x2cb4fc - g_ps2RecompiledFunctionTable[470336] = Ps2Init_0x2cb070; // 0x2cb508 - g_ps2RecompiledFunctionTable[470339] = Ps2Init_0x2cb070; // 0x2cb514 - g_ps2RecompiledFunctionTable[470341] = Ps2Init_0x2cb070; // 0x2cb51c - g_ps2RecompiledFunctionTable[470343] = Ps2Init_0x2cb070; // 0x2cb524 - g_ps2RecompiledFunctionTable[470345] = Ps2Init_0x2cb070; // 0x2cb52c - g_ps2RecompiledFunctionTable[470347] = Ps2Init_0x2cb070; // 0x2cb534 - g_ps2RecompiledFunctionTable[470350] = Ps2LoadModule_0x2cb540; // 0x2cb540 - g_ps2RecompiledFunctionTable[470357] = Ps2LoadModule_0x2cb540; // 0x2cb55c - g_ps2RecompiledFunctionTable[470363] = Ps2LoadModule_0x2cb540; // 0x2cb574 - g_ps2RecompiledFunctionTable[470365] = Ps2LoadModule_0x2cb540; // 0x2cb57c - g_ps2RecompiledFunctionTable[470370] = Snd_init_0x2cb590; // 0x2cb590 - g_ps2RecompiledFunctionTable[470374] = Cd_init_0x2cb5a0; // 0x2cb5a0 - g_ps2RecompiledFunctionTable[470378] = Card_init_0x2cb5b0; // 0x2cb5b0 - g_ps2RecompiledFunctionTable[470382] = PS2_jikken_0x2cb5c0; // 0x2cb5c0 - g_ps2RecompiledFunctionTable[470386] = PS2_jikken_0x2cb5c0; // 0x2cb5d0 - g_ps2RecompiledFunctionTable[470388] = PS2_jikken_0x2cb5c0; // 0x2cb5d8 - g_ps2RecompiledFunctionTable[470394] = PS2_swap_0x2cb5f0; // 0x2cb5f0 - g_ps2RecompiledFunctionTable[470399] = PS2_swap_0x2cb5f0; // 0x2cb604 - g_ps2RecompiledFunctionTable[470506] = PS2_swap_0x2cb5f0; // 0x2cb7b0 - g_ps2RecompiledFunctionTable[470508] = PS2_swap_0x2cb5f0; // 0x2cb7b8 - g_ps2RecompiledFunctionTable[470510] = PS2_swap_0x2cb5f0; // 0x2cb7c0 - g_ps2RecompiledFunctionTable[470514] = Ps2AddPrim_0x2cb7d0; // 0x2cb7d0 - g_ps2RecompiledFunctionTable[470577] = Ps2AddPrim_0x2cb7d0; // 0x2cb8cc - g_ps2RecompiledFunctionTable[470582] = Ps2AddPrim_0x2cb7d0; // 0x2cb8e0 - g_ps2RecompiledFunctionTable[470652] = Ps2AddPrim_0x2cb7d0; // 0x2cb9f8 - g_ps2RecompiledFunctionTable[470765] = Ps2AddPrim_0x2cb7d0; // 0x2cbbbc - g_ps2RecompiledFunctionTable[470798] = Ps2AddPrim_0x2cb7d0; // 0x2cbc40 - g_ps2RecompiledFunctionTable[470802] = Ps2AddPrim_0x2cb7d0; // 0x2cbc50 - g_ps2RecompiledFunctionTable[470804] = Ps2AddPrim_0x2cb7d0; // 0x2cbc58 - g_ps2RecompiledFunctionTable[470818] = Ps2AddPrim2D_0x2cbc90; // 0x2cbc90 - g_ps2RecompiledFunctionTable[470822] = Ps2AddPrim3D_0x2cbca0; // 0x2cbca0 - g_ps2RecompiledFunctionTable[470886] = Ps2AddPrim3D_0x2cbca0; // 0x2cbda0 - g_ps2RecompiledFunctionTable[470891] = Ps2AddPrim3D_0x2cbca0; // 0x2cbdb4 - g_ps2RecompiledFunctionTable[470957] = Ps2AddPrim3D_0x2cbca0; // 0x2cbebc - g_ps2RecompiledFunctionTable[471006] = Ps2AddPrim3D_0x2cbca0; // 0x2cbf80 - g_ps2RecompiledFunctionTable[471010] = Ps2AddPrim3D_0x2cbca0; // 0x2cbf90 - g_ps2RecompiledFunctionTable[471012] = Ps2AddPrim3D_0x2cbca0; // 0x2cbf98 - g_ps2RecompiledFunctionTable[471018] = Ps2AddPrim3DEx_0x2cbfb0; // 0x2cbfb0 - g_ps2RecompiledFunctionTable[471082] = Ps2AddPrim3DEx_0x2cbfb0; // 0x2cc0b0 - g_ps2RecompiledFunctionTable[471087] = Ps2AddPrim3DEx_0x2cbfb0; // 0x2cc0c4 - g_ps2RecompiledFunctionTable[471153] = Ps2AddPrim3DEx_0x2cbfb0; // 0x2cc1cc - g_ps2RecompiledFunctionTable[471203] = Ps2AddPrim3DEx_0x2cbfb0; // 0x2cc294 - g_ps2RecompiledFunctionTable[471207] = Ps2AddPrim3DEx_0x2cbfb0; // 0x2cc2a4 - g_ps2RecompiledFunctionTable[471209] = Ps2AddPrim3DEx_0x2cbfb0; // 0x2cc2ac - g_ps2RecompiledFunctionTable[471218] = Ps2AddPrim3DEx1P_0x2cc2d0; // 0x2cc2d0 - g_ps2RecompiledFunctionTable[471282] = Ps2AddPrim3DEx1P_0x2cc2d0; // 0x2cc3d0 - g_ps2RecompiledFunctionTable[471295] = Ps2AddPrim3DEx1P_0x2cc2d0; // 0x2cc404 - g_ps2RecompiledFunctionTable[471300] = Ps2AddPrim3DEx1P_0x2cc2d0; // 0x2cc418 - g_ps2RecompiledFunctionTable[471365] = Ps2AddPrim3DEx1P_0x2cc2d0; // 0x2cc51c - g_ps2RecompiledFunctionTable[471416] = Ps2AddPrim3DEx1P_0x2cc2d0; // 0x2cc5e8 - g_ps2RecompiledFunctionTable[471420] = Ps2AddPrim3DEx1P_0x2cc2d0; // 0x2cc5f8 - g_ps2RecompiledFunctionTable[471422] = Ps2AddPrim3DEx1P_0x2cc2d0; // 0x2cc600 - g_ps2RecompiledFunctionTable[471430] = Ps2AddPrim3DMod_0x2cc620; // 0x2cc620 - g_ps2RecompiledFunctionTable[471456] = Ps2AddPrim3DMod_0x2cc620; // 0x2cc688 - g_ps2RecompiledFunctionTable[471521] = Ps2AddPrim3DMod_0x2cc620; // 0x2cc78c - g_ps2RecompiledFunctionTable[471559] = Ps2AddPrim3DMod_0x2cc620; // 0x2cc824 - g_ps2RecompiledFunctionTable[471561] = Ps2AddPrim3DMod_0x2cc620; // 0x2cc82c - g_ps2RecompiledFunctionTable[471570] = Ps2ClearOT_0x2cc850; // 0x2cc850 - g_ps2RecompiledFunctionTable[471583] = Ps2ClearOT_0x2cc850; // 0x2cc884 - g_ps2RecompiledFunctionTable[471594] = Ps2AddOT_0x2cc8b0; // 0x2cc8b0 - g_ps2RecompiledFunctionTable[471851] = Ps2AddOT_0x2cc8b0; // 0x2cccb4 - g_ps2RecompiledFunctionTable[471874] = Ps2DrawOTag_0x2ccd10; // 0x2ccd10 - g_ps2RecompiledFunctionTable[471878] = Ps2DrawOTag_0x2ccd10; // 0x2ccd20 - g_ps2RecompiledFunctionTable[471879] = Ps2DrawOTag_0x2ccd10; // 0x2ccd24 - g_ps2RecompiledFunctionTable[471881] = Ps2DrawOTag_0x2ccd10; // 0x2ccd2c - g_ps2RecompiledFunctionTable[471889] = Ps2DrawOTag_0x2ccd10; // 0x2ccd4c - g_ps2RecompiledFunctionTable[471898] = Ps2DrawOTagSub_0x2ccd70; // 0x2ccd70 - g_ps2RecompiledFunctionTable[471922] = Ps2DrawOTagSub_0x2ccd70; // 0x2ccdd0 - g_ps2RecompiledFunctionTable[471943] = Ps2DrawOTagSub_0x2ccd70; // 0x2cce24 - g_ps2RecompiledFunctionTable[471950] = Ps2DrawOTagSub_0x2ccd70; // 0x2cce40 - g_ps2RecompiledFunctionTable[471979] = Ps2DrawOTagSub_0x2ccd70; // 0x2cceb4 - g_ps2RecompiledFunctionTable[471981] = Ps2DrawOTagSub_0x2ccd70; // 0x2ccebc - g_ps2RecompiledFunctionTable[471992] = Ps2DrawOTagSub_0x2ccd70; // 0x2ccee8 - g_ps2RecompiledFunctionTable[472053] = Ps2DrawOTagSub_0x2ccd70; // 0x2ccfdc - g_ps2RecompiledFunctionTable[472221] = Ps2DrawOTagSub_0x2ccd70; // 0x2cd27c - g_ps2RecompiledFunctionTable[472233] = Ps2DrawOTagSub_0x2ccd70; // 0x2cd2ac - g_ps2RecompiledFunctionTable[472235] = Ps2DrawOTagSub_0x2ccd70; // 0x2cd2b4 - g_ps2RecompiledFunctionTable[472239] = Ps2DrawOTagSub_0x2ccd70; // 0x2cd2c4 - g_ps2RecompiledFunctionTable[472241] = Ps2DrawOTagSub_0x2ccd70; // 0x2cd2cc - g_ps2RecompiledFunctionTable[472247] = Ps2DrawOTagSub_0x2ccd70; // 0x2cd2e4 - g_ps2RecompiledFunctionTable[472252] = Ps2DrawOTagSub_0x2ccd70; // 0x2cd2f8 - g_ps2RecompiledFunctionTable[472270] = Ps2BitCount_0x2cd340; // 0x2cd340 - g_ps2RecompiledFunctionTable[472278] = Ps2InitTexCache_0x2cd360; // 0x2cd360 - g_ps2RecompiledFunctionTable[472283] = Ps2InitTexCache_0x2cd360; // 0x2cd374 - g_ps2RecompiledFunctionTable[472294] = Ps2GlobalIndexTexLoad_0x2cd3a0; // 0x2cd3a0 - g_ps2RecompiledFunctionTable[472300] = Ps2GlobalIndexTexLoad_0x2cd3a0; // 0x2cd3b8 - g_ps2RecompiledFunctionTable[472309] = Ps2GlobalIndexTexLoad_0x2cd3a0; // 0x2cd3dc - g_ps2RecompiledFunctionTable[472315] = Ps2GlobalIndexTexLoad_0x2cd3a0; // 0x2cd3f4 - g_ps2RecompiledFunctionTable[472322] = Ps2TexLoad_0x2cd410; // 0x2cd410 - g_ps2RecompiledFunctionTable[472339] = Ps2TexLoad_0x2cd410; // 0x2cd454 - g_ps2RecompiledFunctionTable[472351] = Ps2TexLoad_0x2cd410; // 0x2cd484 - g_ps2RecompiledFunctionTable[472399] = Ps2TexLoad_0x2cd410; // 0x2cd544 - g_ps2RecompiledFunctionTable[472402] = Ps2TexLoad_0x2cd410; // 0x2cd550 - g_ps2RecompiledFunctionTable[472430] = Ps2TexLoad_0x2cd410; // 0x2cd5c0 - g_ps2RecompiledFunctionTable[472433] = Ps2TexLoad_0x2cd410; // 0x2cd5cc - g_ps2RecompiledFunctionTable[472632] = Ps2TexLoad_0x2cd410; // 0x2cd8e8 - g_ps2RecompiledFunctionTable[472642] = Ps2SetFogColor_0x2cd910; // 0x2cd910 - g_ps2RecompiledFunctionTable[472646] = Ps2SetFogColor_0x2cd910; // 0x2cd920 - g_ps2RecompiledFunctionTable[472680] = Ps2SetFogColor_0x2cd910; // 0x2cd9a8 - g_ps2RecompiledFunctionTable[472682] = Ps2SetFogColor_0x2cd910; // 0x2cd9b0 - g_ps2RecompiledFunctionTable[472686] = Ps2SetFogColorSys_0x2cd9c0; // 0x2cd9c0 - g_ps2RecompiledFunctionTable[472695] = Ps2SetFogColorSys_0x2cd9c0; // 0x2cd9e4 - g_ps2RecompiledFunctionTable[472729] = Ps2SetFogColorSys_0x2cd9c0; // 0x2cda6c - g_ps2RecompiledFunctionTable[472731] = Ps2SetFogColorSys_0x2cd9c0; // 0x2cda74 - g_ps2RecompiledFunctionTable[472738] = Ps2AlphaIs000_0x2cda90; // 0x2cda90 - g_ps2RecompiledFunctionTable[472741] = Ps2AlphaIs000_0x2cda90; // 0x2cda9c - g_ps2RecompiledFunctionTable[472762] = Ps2AlphaIsHalf_0x2cdaf0; // 0x2cdaf0 - g_ps2RecompiledFunctionTable[472765] = Ps2AlphaIsHalf_0x2cdaf0; // 0x2cdafc - g_ps2RecompiledFunctionTable[472778] = Ps2Alpha4to8_0x2cdb30; // 0x2cdb30 - g_ps2RecompiledFunctionTable[472781] = Ps2Alpha4to8_0x2cdb30; // 0x2cdb3c - g_ps2RecompiledFunctionTable[472794] = Ps2CheckTextureAlpha_0x2cdb70; // 0x2cdb70 - g_ps2RecompiledFunctionTable[472812] = Ps2CheckTextureAlpha_0x2cdb70; // 0x2cdbb8 - g_ps2RecompiledFunctionTable[472832] = Ps2CheckTextureAlpha_0x2cdb70; // 0x2cdc08 - g_ps2RecompiledFunctionTable[472838] = Ps2CheckTextureAlpha_0x2cdb70; // 0x2cdc20 - g_ps2RecompiledFunctionTable[472844] = Ps2CheckTextureAlpha_0x2cdb70; // 0x2cdc38 - g_ps2RecompiledFunctionTable[472847] = Ps2CheckTextureAlpha_0x2cdb70; // 0x2cdc44 - g_ps2RecompiledFunctionTable[472850] = Ps2CheckTextureAlpha_0x2cdb70; // 0x2cdc50 - g_ps2RecompiledFunctionTable[472856] = Ps2CheckTextureAlpha_0x2cdb70; // 0x2cdc68 - g_ps2RecompiledFunctionTable[472859] = Ps2CheckTextureAlpha_0x2cdb70; // 0x2cdc74 - g_ps2RecompiledFunctionTable[472864] = Ps2CheckTextureAlpha_0x2cdb70; // 0x2cdc88 - g_ps2RecompiledFunctionTable[472884] = Ps2CheckTextureAlpha_0x2cdb70; // 0x2cdcd8 - g_ps2RecompiledFunctionTable[472887] = Ps2CheckTextureAlpha_0x2cdb70; // 0x2cdce4 - g_ps2RecompiledFunctionTable[472893] = Ps2CheckTextureAlpha_0x2cdb70; // 0x2cdcfc - g_ps2RecompiledFunctionTable[472896] = Ps2CheckTextureAlpha_0x2cdb70; // 0x2cdd08 - g_ps2RecompiledFunctionTable[472902] = Ps2CheckTextureAlpha_0x2cdb70; // 0x2cdd20 - g_ps2RecompiledFunctionTable[472905] = Ps2CheckTextureAlpha_0x2cdb70; // 0x2cdd2c - g_ps2RecompiledFunctionTable[472908] = Ps2CheckTextureAlpha_0x2cdb70; // 0x2cdd38 - g_ps2RecompiledFunctionTable[472911] = Ps2CheckTextureAlpha_0x2cdb70; // 0x2cdd44 - g_ps2RecompiledFunctionTable[472917] = Ps2CheckTextureAlpha_0x2cdb70; // 0x2cdd5c - g_ps2RecompiledFunctionTable[472920] = Ps2CheckTextureAlpha_0x2cdb70; // 0x2cdd68 - g_ps2RecompiledFunctionTable[472923] = Ps2CheckTextureAlpha_0x2cdb70; // 0x2cdd74 - g_ps2RecompiledFunctionTable[472928] = Ps2CheckTextureAlpha_0x2cdb70; // 0x2cdd88 - g_ps2RecompiledFunctionTable[472948] = Ps2CheckTextureAlpha_0x2cdb70; // 0x2cddd8 - g_ps2RecompiledFunctionTable[472958] = Ps2InitPS2_GS_SAVE_0x2cde00; // 0x2cde00 - g_ps2RecompiledFunctionTable[473026] = Ps2ScreenClear_0x2cdf10; // 0x2cdf10 - g_ps2RecompiledFunctionTable[473030] = Ps2ScreenClear_0x2cdf10; // 0x2cdf20 - g_ps2RecompiledFunctionTable[473088] = Ps2ScreenClear_0x2cdf10; // 0x2ce008 - g_ps2RecompiledFunctionTable[473090] = Ps2ScreenClear_0x2cdf10; // 0x2ce010 - g_ps2RecompiledFunctionTable[473092] = Ps2ScreenClear_0x2cdf10; // 0x2ce018 - g_ps2RecompiledFunctionTable[473098] = Ps2DispScreenClear_0x2ce030; // 0x2ce030 - g_ps2RecompiledFunctionTable[473102] = Ps2DispScreenClear_0x2ce030; // 0x2ce040 - g_ps2RecompiledFunctionTable[473161] = Ps2DispScreenClear_0x2ce030; // 0x2ce12c - g_ps2RecompiledFunctionTable[473163] = Ps2DispScreenClear_0x2ce030; // 0x2ce134 - g_ps2RecompiledFunctionTable[473165] = Ps2DispScreenClear_0x2ce030; // 0x2ce13c - g_ps2RecompiledFunctionTable[473170] = Ps2ZbuffOff_0x2ce150; // 0x2ce150 - g_ps2RecompiledFunctionTable[473174] = Ps2ZbuffOff_0x2ce150; // 0x2ce160 - g_ps2RecompiledFunctionTable[473198] = Ps2ZbuffOff_0x2ce150; // 0x2ce1c0 - g_ps2RecompiledFunctionTable[473200] = Ps2ZbuffOff_0x2ce150; // 0x2ce1c8 - g_ps2RecompiledFunctionTable[473206] = Ps2ZbuffOff2_0x2ce1e0; // 0x2ce1e0 - g_ps2RecompiledFunctionTable[473210] = Ps2ZbuffOff2_0x2ce1e0; // 0x2ce1f0 - g_ps2RecompiledFunctionTable[473244] = Ps2ZbuffOff2_0x2ce1e0; // 0x2ce278 - g_ps2RecompiledFunctionTable[473246] = Ps2ZbuffOff2_0x2ce1e0; // 0x2ce280 - g_ps2RecompiledFunctionTable[473250] = Ps2ZbuffOn_0x2ce290; // 0x2ce290 - g_ps2RecompiledFunctionTable[473254] = Ps2ZbuffOn_0x2ce290; // 0x2ce2a0 - g_ps2RecompiledFunctionTable[473285] = Ps2ZbuffOn_0x2ce290; // 0x2ce31c - g_ps2RecompiledFunctionTable[473287] = Ps2ZbuffOn_0x2ce290; // 0x2ce324 - g_ps2RecompiledFunctionTable[473290] = Ps2ShadowStart_0x2ce330; // 0x2ce330 - g_ps2RecompiledFunctionTable[473296] = Ps2ShadowStart_0x2ce330; // 0x2ce348 - g_ps2RecompiledFunctionTable[473373] = Ps2ShadowStart_0x2ce330; // 0x2ce47c - g_ps2RecompiledFunctionTable[473378] = Ps2ShadowDraw_0x2ce490; // 0x2ce490 - g_ps2RecompiledFunctionTable[473534] = Ps2ShadowDraw_0x2ce490; // 0x2ce700 - g_ps2RecompiledFunctionTable[473538] = Ps2ShadowDraw_0x2ce490; // 0x2ce710 - g_ps2RecompiledFunctionTable[473571] = Ps2ShadowDraw_0x2ce490; // 0x2ce794 - g_ps2RecompiledFunctionTable[473618] = Ps2ShadowDraw_0x2ce490; // 0x2ce850 - g_ps2RecompiledFunctionTable[473694] = Ps2ShadowDraw_0x2ce490; // 0x2ce980 - g_ps2RecompiledFunctionTable[473702] = Ps2ShadowMain0_0x2ce9a0; // 0x2ce9a0 - g_ps2RecompiledFunctionTable[473718] = Ps2ShadowMain1_0x2ce9e0; // 0x2ce9e0 - g_ps2RecompiledFunctionTable[473722] = Ps2ShadowEnd_0x2ce9f0; // 0x2ce9f0 - g_ps2RecompiledFunctionTable[473726] = Ps2ShadowEnd_0x2ce9f0; // 0x2cea00 - g_ps2RecompiledFunctionTable[473767] = Ps2ShadowEnd_0x2ce9f0; // 0x2ceaa4 - g_ps2RecompiledFunctionTable[473770] = Ps2Vu0ProgSend_0x2ceab0; // 0x2ceab0 - g_ps2RecompiledFunctionTable[473780] = Ps2Vu0ProgSend_0x2ceab0; // 0x2cead8 - g_ps2RecompiledFunctionTable[473785] = Ps2Vu0ProgSend_0x2ceab0; // 0x2ceaec - g_ps2RecompiledFunctionTable[473790] = Ps2Vu1ProgSend_0x2ceb00; // 0x2ceb00 - g_ps2RecompiledFunctionTable[473800] = Ps2Vu1ProgSend_0x2ceb00; // 0x2ceb28 - g_ps2RecompiledFunctionTable[473805] = Ps2Vu1ProgSend_0x2ceb00; // 0x2ceb3c - g_ps2RecompiledFunctionTable[473810] = Ps2AddPrim3DExI_0x2ceb50; // 0x2ceb50 - g_ps2RecompiledFunctionTable[473874] = Ps2AddPrim3DExI_0x2ceb50; // 0x2cec50 - g_ps2RecompiledFunctionTable[473879] = Ps2AddPrim3DExI_0x2ceb50; // 0x2cec64 - g_ps2RecompiledFunctionTable[473945] = Ps2AddPrim3DExI_0x2ceb50; // 0x2ced6c - g_ps2RecompiledFunctionTable[474056] = Ps2AddPrim3DExI_0x2ceb50; // 0x2cef28 - g_ps2RecompiledFunctionTable[474071] = Ps2AddPrim3DExI_0x2ceb50; // 0x2cef64 - g_ps2RecompiledFunctionTable[474106] = Ps2AddPrim3DExI_0x2ceb50; // 0x2ceff0 - g_ps2RecompiledFunctionTable[474109] = Ps2AddPrim3DExI_0x2ceb50; // 0x2ceffc - g_ps2RecompiledFunctionTable[474112] = Ps2AddPrim3DExI_0x2ceb50; // 0x2cf008 - g_ps2RecompiledFunctionTable[474144] = Ps2AddPrim3DExI_0x2ceb50; // 0x2cf088 - g_ps2RecompiledFunctionTable[474159] = Ps2AddPrim3DExI_0x2ceb50; // 0x2cf0c4 - g_ps2RecompiledFunctionTable[474180] = Ps2AddPrim3DExI_0x2ceb50; // 0x2cf118 - g_ps2RecompiledFunctionTable[474198] = Ps2AddPrim3DExI_0x2ceb50; // 0x2cf160 - g_ps2RecompiledFunctionTable[474202] = Ps2AddPrim3DExI_0x2ceb50; // 0x2cf170 - g_ps2RecompiledFunctionTable[474204] = Ps2AddPrim3DExI_0x2ceb50; // 0x2cf178 - g_ps2RecompiledFunctionTable[474210] = PS2_Render_Tex_Sub_0x2cf190; // 0x2cf190 - g_ps2RecompiledFunctionTable[474216] = PS2_Render_Tex_Sub_0x2cf190; // 0x2cf1a8 - g_ps2RecompiledFunctionTable[474320] = PS2_Render_Tex_Sub_0x2cf190; // 0x2cf348 - g_ps2RecompiledFunctionTable[474322] = PS2_Render_Tex_Sub_0x2cf190; // 0x2cf350 - g_ps2RecompiledFunctionTable[474326] = njInit3D_0x2cf360; // 0x2cf360 - g_ps2RecompiledFunctionTable[474334] = njDrawModel_0x2cf380; // 0x2cf380 - g_ps2RecompiledFunctionTable[474338] = njControl3D_0x2cf390; // 0x2cf390 - g_ps2RecompiledFunctionTable[474358] = njSetConstantAttr_0x2cf3e0; // 0x2cf3e0 - g_ps2RecompiledFunctionTable[474374] = njSetConstantMaterial_0x2cf420; // 0x2cf420 - g_ps2RecompiledFunctionTable[474402] = njSetCnkBlendMode_0x2cf490; // 0x2cf490 - g_ps2RecompiledFunctionTable[474422] = njCnkModDrawModel_0x2cf4e0; // 0x2cf4e0 - g_ps2RecompiledFunctionTable[474426] = njCnkSetEasyLight_0x2cf4f0; // 0x2cf4f0 - g_ps2RecompiledFunctionTable[474438] = njCnkSetEasyLightIntensity_0x2cf520; // 0x2cf520 - g_ps2RecompiledFunctionTable[474450] = njCnkSetEasyLightColor_0x2cf550; // 0x2cf550 - g_ps2RecompiledFunctionTable[474458] = njCnkSetEasyMultiLight_0x2cf570; // 0x2cf570 - g_ps2RecompiledFunctionTable[474466] = njCnkSetEasyMultiLightSwitch_0x2cf590; // 0x2cf590 - g_ps2RecompiledFunctionTable[474474] = njCnkSetEasyMultiLightSwitch_0x2cf590; // 0x2cf5b0 - g_ps2RecompiledFunctionTable[474494] = njCnkSetEasyMultiAmbient_0x2cf600; // 0x2cf600 - g_ps2RecompiledFunctionTable[474518] = njCnkSetEasyMultiLightColor_0x2cf660; // 0x2cf660 - g_ps2RecompiledFunctionTable[474534] = njCnkSetEasyMultiLightVector_0x2cf6a0; // 0x2cf6a0 - g_ps2RecompiledFunctionTable[474546] = njCnkSetEasyMultiLightPoint_0x2cf6d0; // 0x2cf6d0 - g_ps2RecompiledFunctionTable[474566] = njCnkSetEasyMultiLightRange_0x2cf720; // 0x2cf720 - g_ps2RecompiledFunctionTable[474586] = njCnkSetEasyMultiLightMatrices_0x2cf770; // 0x2cf770 - g_ps2RecompiledFunctionTable[474594] = njCnkSetEasyMultiLightMatrices_0x2cf770; // 0x2cf790 - g_ps2RecompiledFunctionTable[474602] = njCnkSetEasyMultiLightMatrices_0x2cf770; // 0x2cf7b0 - g_ps2RecompiledFunctionTable[474604] = njCnkSetEasyMultiLightMatrices_0x2cf770; // 0x2cf7b8 - g_ps2RecompiledFunctionTable[474608] = njCnkSetEasyMultiLightMatrices_0x2cf770; // 0x2cf7c8 - g_ps2RecompiledFunctionTable[474610] = njCnkSetEasyMultiLightMatrices_0x2cf770; // 0x2cf7d0 - g_ps2RecompiledFunctionTable[474616] = njCnkSetEasyMultiLightMatrices_0x2cf770; // 0x2cf7e8 - g_ps2RecompiledFunctionTable[474630] = njCnkSetSimpleLight_0x2cf820; // 0x2cf820 - g_ps2RecompiledFunctionTable[474642] = njCnkSetSimpleLightIntensity_0x2cf850; // 0x2cf850 - g_ps2RecompiledFunctionTable[474654] = njCnkSetSimpleLightColor_0x2cf880; // 0x2cf880 - g_ps2RecompiledFunctionTable[474662] = njCnkSetSimpleMultiLight_0x2cf8a0; // 0x2cf8a0 - g_ps2RecompiledFunctionTable[474670] = njCnkSetSimpleMultiLightSwitch_0x2cf8c0; // 0x2cf8c0 - g_ps2RecompiledFunctionTable[474678] = njCnkSetSimpleMultiLightSwitch_0x2cf8c0; // 0x2cf8e0 - g_ps2RecompiledFunctionTable[474698] = njCnkSetSimpleMultiAmbient_0x2cf930; // 0x2cf930 - g_ps2RecompiledFunctionTable[474722] = njCnkSetSimpleMultiLightColor_0x2cf990; // 0x2cf990 - g_ps2RecompiledFunctionTable[474738] = njCnkSetSimpleMultiLightVector_0x2cf9d0; // 0x2cf9d0 - g_ps2RecompiledFunctionTable[474750] = njCnkSetSimpleMultiLightPoint_0x2cfa00; // 0x2cfa00 - g_ps2RecompiledFunctionTable[474770] = njCnkSetSimpleMultiLightRange_0x2cfa50; // 0x2cfa50 - g_ps2RecompiledFunctionTable[474790] = njCnkSetSimpleMultiLightMatrices_0x2cfaa0; // 0x2cfaa0 - g_ps2RecompiledFunctionTable[474798] = njCnkSetSimpleMultiLightMatrices_0x2cfaa0; // 0x2cfac0 - g_ps2RecompiledFunctionTable[474806] = njCnkSetSimpleMultiLightMatrices_0x2cfaa0; // 0x2cfae0 - g_ps2RecompiledFunctionTable[474808] = njCnkSetSimpleMultiLightMatrices_0x2cfaa0; // 0x2cfae8 - g_ps2RecompiledFunctionTable[474812] = njCnkSetSimpleMultiLightMatrices_0x2cfaa0; // 0x2cfaf8 - g_ps2RecompiledFunctionTable[474814] = njCnkSetSimpleMultiLightMatrices_0x2cfaa0; // 0x2cfb00 - g_ps2RecompiledFunctionTable[474820] = njCnkSetSimpleMultiLightMatrices_0x2cfaa0; // 0x2cfb18 - g_ps2RecompiledFunctionTable[474834] = njCnkEasyDrawModel_0x2cfb50; // 0x2cfb50 - g_ps2RecompiledFunctionTable[474840] = njCnkEasyDrawModel_0x2cfb50; // 0x2cfb68 - g_ps2RecompiledFunctionTable[474842] = njCnkEasyDrawModel_0x2cfb50; // 0x2cfb70 - g_ps2RecompiledFunctionTable[474846] = njCnkEasyDrawObject_0x2cfb80; // 0x2cfb80 - g_ps2RecompiledFunctionTable[474853] = njCnkEasyDrawObject_0x2cfb80; // 0x2cfb9c - g_ps2RecompiledFunctionTable[474855] = njCnkEasyDrawObject_0x2cfb80; // 0x2cfba4 - g_ps2RecompiledFunctionTable[474857] = njCnkEasyDrawObject_0x2cfb80; // 0x2cfbac - g_ps2RecompiledFunctionTable[474862] = njCnkEasyDrawObject_0x2cfb80; // 0x2cfbc0 - g_ps2RecompiledFunctionTable[474868] = njCnkEasyDrawObject_0x2cfb80; // 0x2cfbd8 - g_ps2RecompiledFunctionTable[474873] = njCnkEasyDrawObject_0x2cfb80; // 0x2cfbec - g_ps2RecompiledFunctionTable[474881] = njCnkEasyDrawObject_0x2cfb80; // 0x2cfc0c - g_ps2RecompiledFunctionTable[474892] = njCnkEasyDrawObject_0x2cfb80; // 0x2cfc38 - g_ps2RecompiledFunctionTable[474894] = njCnkEasyDrawObject_0x2cfb80; // 0x2cfc40 - g_ps2RecompiledFunctionTable[474906] = njCnkEasyMultiDrawModel_0x2cfc70; // 0x2cfc70 - g_ps2RecompiledFunctionTable[474912] = njCnkEasyMultiDrawModel_0x2cfc70; // 0x2cfc88 - g_ps2RecompiledFunctionTable[474914] = njCnkEasyMultiDrawModel_0x2cfc70; // 0x2cfc90 - g_ps2RecompiledFunctionTable[474918] = njCnkEasyMultiDrawObject_0x2cfca0; // 0x2cfca0 - g_ps2RecompiledFunctionTable[474925] = njCnkEasyMultiDrawObject_0x2cfca0; // 0x2cfcbc - g_ps2RecompiledFunctionTable[474927] = njCnkEasyMultiDrawObject_0x2cfca0; // 0x2cfcc4 - g_ps2RecompiledFunctionTable[474929] = njCnkEasyMultiDrawObject_0x2cfca0; // 0x2cfccc - g_ps2RecompiledFunctionTable[474934] = njCnkEasyMultiDrawObject_0x2cfca0; // 0x2cfce0 - g_ps2RecompiledFunctionTable[474940] = njCnkEasyMultiDrawObject_0x2cfca0; // 0x2cfcf8 - g_ps2RecompiledFunctionTable[474945] = njCnkEasyMultiDrawObject_0x2cfca0; // 0x2cfd0c - g_ps2RecompiledFunctionTable[474953] = njCnkEasyMultiDrawObject_0x2cfca0; // 0x2cfd2c - g_ps2RecompiledFunctionTable[474964] = njCnkEasyMultiDrawObject_0x2cfca0; // 0x2cfd58 - g_ps2RecompiledFunctionTable[474966] = njCnkEasyMultiDrawObject_0x2cfca0; // 0x2cfd60 - g_ps2RecompiledFunctionTable[474978] = njCnkSimpleDrawModel_0x2cfd90; // 0x2cfd90 - g_ps2RecompiledFunctionTable[474984] = njCnkSimpleDrawModel_0x2cfd90; // 0x2cfda8 - g_ps2RecompiledFunctionTable[474986] = njCnkSimpleDrawModel_0x2cfd90; // 0x2cfdb0 - g_ps2RecompiledFunctionTable[474990] = njCnkSimpleMultiDrawModel_0x2cfdc0; // 0x2cfdc0 - g_ps2RecompiledFunctionTable[474996] = njCnkSimpleMultiDrawModel_0x2cfdc0; // 0x2cfdd8 - g_ps2RecompiledFunctionTable[474998] = njCnkSimpleMultiDrawModel_0x2cfdc0; // 0x2cfde0 - g_ps2RecompiledFunctionTable[475002] = njCnkSetCurrentDrawMode_0x2cfdf0; // 0x2cfdf0 - g_ps2RecompiledFunctionTable[475018] = njCnkDrawModelLocal_0x2cfe30; // 0x2cfe30 - g_ps2RecompiledFunctionTable[475019] = njCnkDrawModelLocal_0x2cfe30; // 0x2cfe34 - g_ps2RecompiledFunctionTable[475020] = njCnkDrawModelLocal_0x2cfe30; // 0x2cfe38 - g_ps2RecompiledFunctionTable[475021] = njCnkDrawModelLocal_0x2cfe30; // 0x2cfe3c - g_ps2RecompiledFunctionTable[475022] = njCnkDrawModelLocal_0x2cfe30; // 0x2cfe40 - g_ps2RecompiledFunctionTable[475023] = njCnkDrawModelLocal_0x2cfe30; // 0x2cfe44 - g_ps2RecompiledFunctionTable[475024] = njCnkDrawModelLocal_0x2cfe30; // 0x2cfe48 - g_ps2RecompiledFunctionTable[475025] = njCnkDrawModelLocal_0x2cfe30; // 0x2cfe4c - g_ps2RecompiledFunctionTable[475026] = njCnkDrawModelLocal_0x2cfe30; // 0x2cfe50 - g_ps2RecompiledFunctionTable[475027] = njCnkDrawModelLocal_0x2cfe30; // 0x2cfe54 - g_ps2RecompiledFunctionTable[475028] = njCnkDrawModelLocal_0x2cfe30; // 0x2cfe58 - g_ps2RecompiledFunctionTable[475029] = njCnkDrawModelLocal_0x2cfe30; // 0x2cfe5c - g_ps2RecompiledFunctionTable[475030] = njCnkDrawModelLocal_0x2cfe30; // 0x2cfe60 - g_ps2RecompiledFunctionTable[475031] = njCnkDrawModelLocal_0x2cfe30; // 0x2cfe64 - g_ps2RecompiledFunctionTable[475032] = njCnkDrawModelLocal_0x2cfe30; // 0x2cfe68 - g_ps2RecompiledFunctionTable[475033] = njCnkDrawModelLocal_0x2cfe30; // 0x2cfe6c - g_ps2RecompiledFunctionTable[475034] = njCnkDrawModelLocal_0x2cfe30; // 0x2cfe70 - g_ps2RecompiledFunctionTable[475035] = njCnkDrawModelLocal_0x2cfe30; // 0x2cfe74 - g_ps2RecompiledFunctionTable[475036] = njCnkDrawModelLocal_0x2cfe30; // 0x2cfe78 - g_ps2RecompiledFunctionTable[475037] = njCnkDrawModelLocal_0x2cfe30; // 0x2cfe7c - g_ps2RecompiledFunctionTable[475038] = njCnkDrawModelLocal_0x2cfe30; // 0x2cfe80 - g_ps2RecompiledFunctionTable[475039] = njCnkDrawModelLocal_0x2cfe30; // 0x2cfe84 - g_ps2RecompiledFunctionTable[475040] = njCnkDrawModelLocal_0x2cfe30; // 0x2cfe88 - g_ps2RecompiledFunctionTable[475041] = njCnkDrawModelLocal_0x2cfe30; // 0x2cfe8c - g_ps2RecompiledFunctionTable[475042] = njCnkDrawModelLocal_0x2cfe30; // 0x2cfe90 - g_ps2RecompiledFunctionTable[475043] = njCnkDrawModelLocal_0x2cfe30; // 0x2cfe94 - g_ps2RecompiledFunctionTable[475044] = njCnkDrawModelLocal_0x2cfe30; // 0x2cfe98 - g_ps2RecompiledFunctionTable[475045] = njCnkDrawModelLocal_0x2cfe30; // 0x2cfe9c - g_ps2RecompiledFunctionTable[475046] = njCnkDrawModelLocal_0x2cfe30; // 0x2cfea0 - g_ps2RecompiledFunctionTable[475047] = njCnkDrawModelLocal_0x2cfe30; // 0x2cfea4 - g_ps2RecompiledFunctionTable[475048] = njCnkDrawModelLocal_0x2cfe30; // 0x2cfea8 - g_ps2RecompiledFunctionTable[475049] = njCnkDrawModelLocal_0x2cfe30; // 0x2cfeac - g_ps2RecompiledFunctionTable[475050] = njCnkDrawModelLocal_0x2cfe30; // 0x2cfeb0 - g_ps2RecompiledFunctionTable[475051] = njCnkDrawModelLocal_0x2cfe30; // 0x2cfeb4 - g_ps2RecompiledFunctionTable[475052] = njCnkDrawModelLocal_0x2cfe30; // 0x2cfeb8 - g_ps2RecompiledFunctionTable[475053] = njCnkDrawModelLocal_0x2cfe30; // 0x2cfebc - g_ps2RecompiledFunctionTable[475054] = njCnkDrawModelLocal_0x2cfe30; // 0x2cfec0 - g_ps2RecompiledFunctionTable[475055] = njCnkDrawModelLocal_0x2cfe30; // 0x2cfec4 - g_ps2RecompiledFunctionTable[475056] = njCnkDrawModelLocal_0x2cfe30; // 0x2cfec8 - g_ps2RecompiledFunctionTable[475057] = njCnkDrawModelLocal_0x2cfe30; // 0x2cfecc - g_ps2RecompiledFunctionTable[475058] = njCnkDrawModelLocal_0x2cfe30; // 0x2cfed0 - g_ps2RecompiledFunctionTable[475059] = njCnkDrawModelLocal_0x2cfe30; // 0x2cfed4 - g_ps2RecompiledFunctionTable[475060] = njCnkDrawModelLocal_0x2cfe30; // 0x2cfed8 - g_ps2RecompiledFunctionTable[475061] = njCnkDrawModelLocal_0x2cfe30; // 0x2cfedc - g_ps2RecompiledFunctionTable[475062] = njCnkDrawModelLocal_0x2cfe30; // 0x2cfee0 - g_ps2RecompiledFunctionTable[475063] = njCnkDrawModelLocal_0x2cfe30; // 0x2cfee4 - g_ps2RecompiledFunctionTable[475064] = njCnkDrawModelLocal_0x2cfe30; // 0x2cfee8 - g_ps2RecompiledFunctionTable[475065] = njCnkDrawModelLocal_0x2cfe30; // 0x2cfeec - g_ps2RecompiledFunctionTable[475066] = njCnkDrawModelLocal_0x2cfe30; // 0x2cfef0 - g_ps2RecompiledFunctionTable[475067] = njCnkDrawModelLocal_0x2cfe30; // 0x2cfef4 - g_ps2RecompiledFunctionTable[475068] = njCnkDrawModelLocal_0x2cfe30; // 0x2cfef8 - g_ps2RecompiledFunctionTable[475069] = njCnkDrawModelLocal_0x2cfe30; // 0x2cfefc - g_ps2RecompiledFunctionTable[475070] = njCnkDrawModelLocal_0x2cfe30; // 0x2cff00 - g_ps2RecompiledFunctionTable[475071] = njCnkDrawModelLocal_0x2cfe30; // 0x2cff04 - g_ps2RecompiledFunctionTable[475072] = njCnkDrawModelLocal_0x2cfe30; // 0x2cff08 - g_ps2RecompiledFunctionTable[475073] = njCnkDrawModelLocal_0x2cfe30; // 0x2cff0c - g_ps2RecompiledFunctionTable[475074] = njCnkDrawModelLocal_0x2cfe30; // 0x2cff10 - g_ps2RecompiledFunctionTable[475075] = njCnkDrawModelLocal_0x2cfe30; // 0x2cff14 - g_ps2RecompiledFunctionTable[475076] = njCnkDrawModelLocal_0x2cfe30; // 0x2cff18 - g_ps2RecompiledFunctionTable[475077] = njCnkDrawModelLocal_0x2cfe30; // 0x2cff1c - g_ps2RecompiledFunctionTable[475078] = njCnkDrawModelLocal_0x2cfe30; // 0x2cff20 - g_ps2RecompiledFunctionTable[475079] = njCnkDrawModelLocal_0x2cfe30; // 0x2cff24 - g_ps2RecompiledFunctionTable[475080] = njCnkDrawModelLocal_0x2cfe30; // 0x2cff28 - g_ps2RecompiledFunctionTable[475081] = njCnkDrawModelLocal_0x2cfe30; // 0x2cff2c - g_ps2RecompiledFunctionTable[475082] = njCnkDrawModelLocal_0x2cfe30; // 0x2cff30 - g_ps2RecompiledFunctionTable[475083] = njCnkDrawModelLocal_0x2cfe30; // 0x2cff34 - g_ps2RecompiledFunctionTable[475084] = njCnkDrawModelLocal_0x2cfe30; // 0x2cff38 - g_ps2RecompiledFunctionTable[475085] = njCnkDrawModelLocal_0x2cfe30; // 0x2cff3c - g_ps2RecompiledFunctionTable[475086] = njCnkDrawModelLocal_0x2cfe30; // 0x2cff40 - g_ps2RecompiledFunctionTable[475087] = njCnkDrawModelLocal_0x2cfe30; // 0x2cff44 - g_ps2RecompiledFunctionTable[475088] = njCnkDrawModelLocal_0x2cfe30; // 0x2cff48 - g_ps2RecompiledFunctionTable[475089] = njCnkDrawModelLocal_0x2cfe30; // 0x2cff4c - g_ps2RecompiledFunctionTable[475090] = njCnkDrawModelLocal_0x2cfe30; // 0x2cff50 - g_ps2RecompiledFunctionTable[475091] = njCnkDrawModelLocal_0x2cfe30; // 0x2cff54 - g_ps2RecompiledFunctionTable[475092] = njCnkDrawModelLocal_0x2cfe30; // 0x2cff58 - g_ps2RecompiledFunctionTable[475093] = njCnkDrawModelLocal_0x2cfe30; // 0x2cff5c - g_ps2RecompiledFunctionTable[475094] = njCnkDrawModelLocal_0x2cfe30; // 0x2cff60 - g_ps2RecompiledFunctionTable[475095] = njCnkDrawModelLocal_0x2cfe30; // 0x2cff64 - g_ps2RecompiledFunctionTable[475096] = njCnkDrawModelLocal_0x2cfe30; // 0x2cff68 - g_ps2RecompiledFunctionTable[475097] = njCnkDrawModelLocal_0x2cfe30; // 0x2cff6c - g_ps2RecompiledFunctionTable[475098] = njCnkDrawModelLocal_0x2cfe30; // 0x2cff70 - g_ps2RecompiledFunctionTable[475099] = njCnkDrawModelLocal_0x2cfe30; // 0x2cff74 - g_ps2RecompiledFunctionTable[475100] = njCnkDrawModelLocal_0x2cfe30; // 0x2cff78 - g_ps2RecompiledFunctionTable[475101] = njCnkDrawModelLocal_0x2cfe30; // 0x2cff7c - g_ps2RecompiledFunctionTable[475102] = njCnkDrawModelLocal_0x2cfe30; // 0x2cff80 - g_ps2RecompiledFunctionTable[475103] = njCnkDrawModelLocal_0x2cfe30; // 0x2cff84 - g_ps2RecompiledFunctionTable[475104] = njCnkDrawModelLocal_0x2cfe30; // 0x2cff88 - g_ps2RecompiledFunctionTable[475105] = njCnkDrawModelLocal_0x2cfe30; // 0x2cff8c - g_ps2RecompiledFunctionTable[475106] = njCnkDrawModelLocal_0x2cfe30; // 0x2cff90 - g_ps2RecompiledFunctionTable[475107] = njCnkDrawModelLocal_0x2cfe30; // 0x2cff94 - g_ps2RecompiledFunctionTable[475108] = njCnkDrawModelLocal_0x2cfe30; // 0x2cff98 - g_ps2RecompiledFunctionTable[475109] = njCnkDrawModelLocal_0x2cfe30; // 0x2cff9c - g_ps2RecompiledFunctionTable[475110] = njCnkDrawModelLocal_0x2cfe30; // 0x2cffa0 - g_ps2RecompiledFunctionTable[475111] = njCnkDrawModelLocal_0x2cfe30; // 0x2cffa4 - g_ps2RecompiledFunctionTable[475112] = njCnkDrawModelLocal_0x2cfe30; // 0x2cffa8 - g_ps2RecompiledFunctionTable[475113] = njCnkDrawModelLocal_0x2cfe30; // 0x2cffac - g_ps2RecompiledFunctionTable[475114] = njCnkDrawModelLocal_0x2cfe30; // 0x2cffb0 - g_ps2RecompiledFunctionTable[475115] = njCnkDrawModelLocal_0x2cfe30; // 0x2cffb4 - g_ps2RecompiledFunctionTable[475116] = njCnkDrawModelLocal_0x2cfe30; // 0x2cffb8 - g_ps2RecompiledFunctionTable[475117] = njCnkDrawModelLocal_0x2cfe30; // 0x2cffbc - g_ps2RecompiledFunctionTable[475118] = njCnkDrawModelLocal_0x2cfe30; // 0x2cffc0 - g_ps2RecompiledFunctionTable[475119] = njCnkDrawModelLocal_0x2cfe30; // 0x2cffc4 - g_ps2RecompiledFunctionTable[475120] = njCnkDrawModelLocal_0x2cfe30; // 0x2cffc8 - g_ps2RecompiledFunctionTable[475121] = njCnkDrawModelLocal_0x2cfe30; // 0x2cffcc - g_ps2RecompiledFunctionTable[475122] = njCnkDrawModelLocal_0x2cfe30; // 0x2cffd0 - g_ps2RecompiledFunctionTable[475123] = njCnkDrawModelLocal_0x2cfe30; // 0x2cffd4 - g_ps2RecompiledFunctionTable[475124] = njCnkDrawModelLocal_0x2cfe30; // 0x2cffd8 - g_ps2RecompiledFunctionTable[475125] = njCnkDrawModelLocal_0x2cfe30; // 0x2cffdc - g_ps2RecompiledFunctionTable[475126] = njCnkDrawModelLocal_0x2cfe30; // 0x2cffe0 - g_ps2RecompiledFunctionTable[475127] = njCnkDrawModelLocal_0x2cfe30; // 0x2cffe4 - g_ps2RecompiledFunctionTable[475128] = njCnkDrawModelLocal_0x2cfe30; // 0x2cffe8 - g_ps2RecompiledFunctionTable[475129] = njCnkDrawModelLocal_0x2cfe30; // 0x2cffec - g_ps2RecompiledFunctionTable[475130] = njCnkDrawModelLocal_0x2cfe30; // 0x2cfff0 - g_ps2RecompiledFunctionTable[475131] = njCnkDrawModelLocal_0x2cfe30; // 0x2cfff4 - g_ps2RecompiledFunctionTable[475132] = njCnkDrawModelLocal_0x2cfe30; // 0x2cfff8 - g_ps2RecompiledFunctionTable[475133] = njCnkDrawModelLocal_0x2cfe30; // 0x2cfffc - g_ps2RecompiledFunctionTable[475134] = njCnkDrawModelLocal_0x2cfe30; // 0x2d0000 - g_ps2RecompiledFunctionTable[475135] = njCnkDrawModelLocal_0x2cfe30; // 0x2d0004 - g_ps2RecompiledFunctionTable[475136] = njCnkDrawModelLocal_0x2cfe30; // 0x2d0008 - g_ps2RecompiledFunctionTable[475137] = njCnkDrawModelLocal_0x2cfe30; // 0x2d000c - g_ps2RecompiledFunctionTable[475138] = njCnkDrawModelLocal_0x2cfe30; // 0x2d0010 - g_ps2RecompiledFunctionTable[475139] = njCnkDrawModelLocal_0x2cfe30; // 0x2d0014 - g_ps2RecompiledFunctionTable[475140] = njCnkDrawModelLocal_0x2cfe30; // 0x2d0018 - g_ps2RecompiledFunctionTable[475141] = njCnkDrawModelLocal_0x2cfe30; // 0x2d001c - g_ps2RecompiledFunctionTable[475142] = njCnkDrawModelLocal_0x2cfe30; // 0x2d0020 - g_ps2RecompiledFunctionTable[475143] = njCnkDrawModelLocal_0x2cfe30; // 0x2d0024 - g_ps2RecompiledFunctionTable[475144] = njCnkDrawModelLocal_0x2cfe30; // 0x2d0028 - g_ps2RecompiledFunctionTable[475145] = njCnkDrawModelLocal_0x2cfe30; // 0x2d002c - g_ps2RecompiledFunctionTable[475146] = njCnkDrawModelLocal_0x2cfe30; // 0x2d0030 - g_ps2RecompiledFunctionTable[475147] = njCnkDrawModelLocal_0x2cfe30; // 0x2d0034 - g_ps2RecompiledFunctionTable[475148] = njCnkDrawModelLocal_0x2cfe30; // 0x2d0038 - g_ps2RecompiledFunctionTable[475149] = njCnkDrawModelLocal_0x2cfe30; // 0x2d003c - g_ps2RecompiledFunctionTable[475150] = njCnkDrawModelLocal_0x2cfe30; // 0x2d0040 - g_ps2RecompiledFunctionTable[475151] = njCnkDrawModelLocal_0x2cfe30; // 0x2d0044 - g_ps2RecompiledFunctionTable[475152] = njCnkDrawModelLocal_0x2cfe30; // 0x2d0048 - g_ps2RecompiledFunctionTable[475153] = njCnkDrawModelLocal_0x2cfe30; // 0x2d004c - g_ps2RecompiledFunctionTable[475154] = njCnkDrawModelLocal_0x2cfe30; // 0x2d0050 - g_ps2RecompiledFunctionTable[475155] = njCnkDrawModelLocal_0x2cfe30; // 0x2d0054 - g_ps2RecompiledFunctionTable[475156] = njCnkDrawModelLocal_0x2cfe30; // 0x2d0058 - g_ps2RecompiledFunctionTable[475157] = njCnkDrawModelLocal_0x2cfe30; // 0x2d005c - g_ps2RecompiledFunctionTable[475158] = njCnkDrawModelLocal_0x2cfe30; // 0x2d0060 - g_ps2RecompiledFunctionTable[475159] = njCnkDrawModelLocal_0x2cfe30; // 0x2d0064 - g_ps2RecompiledFunctionTable[475160] = njCnkDrawModelLocal_0x2cfe30; // 0x2d0068 - g_ps2RecompiledFunctionTable[475161] = njCnkDrawModelLocal_0x2cfe30; // 0x2d006c - g_ps2RecompiledFunctionTable[475162] = njCnkDrawModelLocal_0x2cfe30; // 0x2d0070 - g_ps2RecompiledFunctionTable[475163] = njCnkDrawModelLocal_0x2cfe30; // 0x2d0074 - g_ps2RecompiledFunctionTable[475164] = njCnkDrawModelLocal_0x2cfe30; // 0x2d0078 - g_ps2RecompiledFunctionTable[475165] = njCnkDrawModelLocal_0x2cfe30; // 0x2d007c - g_ps2RecompiledFunctionTable[475166] = njCnkDrawModelLocal_0x2cfe30; // 0x2d0080 - g_ps2RecompiledFunctionTable[475167] = njCnkDrawModelLocal_0x2cfe30; // 0x2d0084 - g_ps2RecompiledFunctionTable[475168] = njCnkDrawModelLocal_0x2cfe30; // 0x2d0088 - g_ps2RecompiledFunctionTable[475169] = njCnkDrawModelLocal_0x2cfe30; // 0x2d008c - g_ps2RecompiledFunctionTable[475170] = njCnkDrawModelLocal_0x2cfe30; // 0x2d0090 - g_ps2RecompiledFunctionTable[475171] = njCnkDrawModelLocal_0x2cfe30; // 0x2d0094 - g_ps2RecompiledFunctionTable[475172] = njCnkDrawModelLocal_0x2cfe30; // 0x2d0098 - g_ps2RecompiledFunctionTable[475174] = njCnkDrawModelLocalMod_0x2d00a0; // 0x2d00a0 - g_ps2RecompiledFunctionTable[475194] = njCnkDrawModelLocalMod_0x2d00a0; // 0x2d00f0 - g_ps2RecompiledFunctionTable[475197] = njCnkDrawModelLocalMod_0x2d00a0; // 0x2d00fc - g_ps2RecompiledFunctionTable[475201] = njCnkDrawModelLocalMod_0x2d00a0; // 0x2d010c - g_ps2RecompiledFunctionTable[475226] = njCnkDrawModelLocalMod_0x2d00a0; // 0x2d0170 - g_ps2RecompiledFunctionTable[475273] = njCnkDrawModelLocalMod_0x2d00a0; // 0x2d022c - g_ps2RecompiledFunctionTable[475278] = njCnkDrawModelLocalMod_0x2d00a0; // 0x2d0240 - g_ps2RecompiledFunctionTable[475280] = njCnkDrawModelLocalMod_0x2d00a0; // 0x2d0248 - g_ps2RecompiledFunctionTable[475285] = njCnkDrawModelLocalMod_0x2d00a0; // 0x2d025c - g_ps2RecompiledFunctionTable[475294] = njCnkCn_0x2d0280; // 0x2d0280 - g_ps2RecompiledFunctionTable[475298] = njCnkCbBa_0x2d0290; // 0x2d0290 - g_ps2RecompiledFunctionTable[475321] = njCnkCbBa_0x2d0290; // 0x2d02ec - g_ps2RecompiledFunctionTable[475326] = njCnkCbDa_0x2d0300; // 0x2d0300 - g_ps2RecompiledFunctionTable[475330] = njCnkCbExp_0x2d0310; // 0x2d0310 - g_ps2RecompiledFunctionTable[475350] = njCnkCtTid_0x2d0360; // 0x2d0360 - g_ps2RecompiledFunctionTable[475361] = njCnkCtTid_0x2d0360; // 0x2d038c - g_ps2RecompiledFunctionTable[475364] = njCnkCtTid_0x2d0360; // 0x2d0398 - g_ps2RecompiledFunctionTable[475371] = njCnkCtTid_0x2d0360; // 0x2d03b4 - g_ps2RecompiledFunctionTable[475378] = njCnkCmD_0x2d03d0; // 0x2d03d0 - g_ps2RecompiledFunctionTable[475401] = njCnkCmD_0x2d03d0; // 0x2d042c - g_ps2RecompiledFunctionTable[475478] = njCnkCmA_0x2d0560; // 0x2d0560 - g_ps2RecompiledFunctionTable[475501] = njCnkCmA_0x2d0560; // 0x2d05bc - g_ps2RecompiledFunctionTable[475594] = njCnkCmDa_0x2d0730; // 0x2d0730 - g_ps2RecompiledFunctionTable[475617] = njCnkCmDa_0x2d0730; // 0x2d078c - g_ps2RecompiledFunctionTable[475782] = njCnkCmS_0x2d0a20; // 0x2d0a20 - g_ps2RecompiledFunctionTable[475805] = njCnkCmS_0x2d0a20; // 0x2d0a7c - g_ps2RecompiledFunctionTable[475882] = njCnkCmDs_0x2d0bb0; // 0x2d0bb0 - g_ps2RecompiledFunctionTable[475905] = njCnkCmDs_0x2d0bb0; // 0x2d0c0c - g_ps2RecompiledFunctionTable[476054] = njCnkCmAs_0x2d0e60; // 0x2d0e60 - g_ps2RecompiledFunctionTable[476077] = njCnkCmAs_0x2d0e60; // 0x2d0ebc - g_ps2RecompiledFunctionTable[476242] = njCnkCmDas_0x2d1150; // 0x2d1150 - g_ps2RecompiledFunctionTable[476265] = njCnkCmDas_0x2d1150; // 0x2d11ac - g_ps2RecompiledFunctionTable[476502] = njCnkCoP4_0x2d1560; // 0x2d1560 - g_ps2RecompiledFunctionTable[476510] = njCnkCoSt_0x2d1580; // 0x2d1580 - g_ps2RecompiledFunctionTable[476518] = njCnkCvVn_0x2d15a0; // 0x2d15a0 - g_ps2RecompiledFunctionTable[476572] = njCnkCvVn_0x2d15a0; // 0x2d1678 - g_ps2RecompiledFunctionTable[476609] = njCnkCvVn_0x2d15a0; // 0x2d170c - g_ps2RecompiledFunctionTable[476664] = njCnkCvVn_0x2d15a0; // 0x2d17e8 - g_ps2RecompiledFunctionTable[476703] = njCnkCvVn_0x2d15a0; // 0x2d1884 - g_ps2RecompiledFunctionTable[476766] = njCnkCvVnPs2_0x2d1980; // 0x2d1980 - g_ps2RecompiledFunctionTable[476912] = njCnkCvVnPs2_0x2d1980; // 0x2d1bc8 - g_ps2RecompiledFunctionTable[476928] = njCnkCvVnPs2_0x2d1980; // 0x2d1c08 - g_ps2RecompiledFunctionTable[476934] = njCnkCvVnPs2_0x2d1980; // 0x2d1c20 - g_ps2RecompiledFunctionTable[476954] = njCnkCvVnPs2_0x2d1980; // 0x2d1c70 - g_ps2RecompiledFunctionTable[476966] = njCnkCvVMod_0x2d1ca0; // 0x2d1ca0 - g_ps2RecompiledFunctionTable[477011] = njCnkCvVMod_0x2d1ca0; // 0x2d1d54 - g_ps2RecompiledFunctionTable[477048] = njCnkCvVMod_0x2d1ca0; // 0x2d1de8 - g_ps2RecompiledFunctionTable[477090] = njCnkCoP3_0x2d1e90; // 0x2d1e90 - g_ps2RecompiledFunctionTable[477105] = njCnkCoP3_0x2d1e90; // 0x2d1ecc - g_ps2RecompiledFunctionTable[477350] = njCnkCoP3_0x2d1e90; // 0x2d22a0 - g_ps2RecompiledFunctionTable[477366] = njCnkCs_0x2d22e0; // 0x2d22e0 - g_ps2RecompiledFunctionTable[477367] = njCnkCs_0x2d22e0; // 0x2d22e4 - g_ps2RecompiledFunctionTable[477368] = njCnkCs_0x2d22e0; // 0x2d22e8 - g_ps2RecompiledFunctionTable[477369] = njCnkCs_0x2d22e0; // 0x2d22ec - g_ps2RecompiledFunctionTable[477370] = njCnkCs_0x2d22e0; // 0x2d22f0 - g_ps2RecompiledFunctionTable[477371] = njCnkCs_0x2d22e0; // 0x2d22f4 - g_ps2RecompiledFunctionTable[477372] = njCnkCs_0x2d22e0; // 0x2d22f8 - g_ps2RecompiledFunctionTable[477373] = njCnkCs_0x2d22e0; // 0x2d22fc - g_ps2RecompiledFunctionTable[477374] = njCnkCs_0x2d22e0; // 0x2d2300 - g_ps2RecompiledFunctionTable[477375] = njCnkCs_0x2d22e0; // 0x2d2304 - g_ps2RecompiledFunctionTable[477376] = njCnkCs_0x2d22e0; // 0x2d2308 - g_ps2RecompiledFunctionTable[477377] = njCnkCs_0x2d22e0; // 0x2d230c - g_ps2RecompiledFunctionTable[477378] = njCnkCs_0x2d22e0; // 0x2d2310 - g_ps2RecompiledFunctionTable[477379] = njCnkCs_0x2d22e0; // 0x2d2314 - g_ps2RecompiledFunctionTable[477380] = njCnkCs_0x2d22e0; // 0x2d2318 - g_ps2RecompiledFunctionTable[477381] = njCnkCs_0x2d22e0; // 0x2d231c - g_ps2RecompiledFunctionTable[477382] = njCnkCs_0x2d22e0; // 0x2d2320 - g_ps2RecompiledFunctionTable[477383] = njCnkCs_0x2d22e0; // 0x2d2324 - g_ps2RecompiledFunctionTable[477384] = njCnkCs_0x2d22e0; // 0x2d2328 - g_ps2RecompiledFunctionTable[477385] = njCnkCs_0x2d22e0; // 0x2d232c - g_ps2RecompiledFunctionTable[477386] = njCnkCs_0x2d22e0; // 0x2d2330 - g_ps2RecompiledFunctionTable[477387] = njCnkCs_0x2d22e0; // 0x2d2334 - g_ps2RecompiledFunctionTable[477388] = njCnkCs_0x2d22e0; // 0x2d2338 - g_ps2RecompiledFunctionTable[477389] = njCnkCs_0x2d22e0; // 0x2d233c - g_ps2RecompiledFunctionTable[477390] = njCnkCs_0x2d22e0; // 0x2d2340 - g_ps2RecompiledFunctionTable[477391] = njCnkCs_0x2d22e0; // 0x2d2344 - g_ps2RecompiledFunctionTable[477392] = njCnkCs_0x2d22e0; // 0x2d2348 - g_ps2RecompiledFunctionTable[477393] = njCnkCs_0x2d22e0; // 0x2d234c - g_ps2RecompiledFunctionTable[477394] = njCnkCs_0x2d22e0; // 0x2d2350 - g_ps2RecompiledFunctionTable[477395] = njCnkCs_0x2d22e0; // 0x2d2354 - g_ps2RecompiledFunctionTable[477396] = njCnkCs_0x2d22e0; // 0x2d2358 - g_ps2RecompiledFunctionTable[477397] = njCnkCs_0x2d22e0; // 0x2d235c - g_ps2RecompiledFunctionTable[477398] = njCnkCs_0x2d22e0; // 0x2d2360 - g_ps2RecompiledFunctionTable[477399] = njCnkCs_0x2d22e0; // 0x2d2364 - g_ps2RecompiledFunctionTable[477400] = njCnkCs_0x2d22e0; // 0x2d2368 - g_ps2RecompiledFunctionTable[477401] = njCnkCs_0x2d22e0; // 0x2d236c - g_ps2RecompiledFunctionTable[477402] = njCnkCs_0x2d22e0; // 0x2d2370 - g_ps2RecompiledFunctionTable[477403] = njCnkCs_0x2d22e0; // 0x2d2374 - g_ps2RecompiledFunctionTable[477404] = njCnkCs_0x2d22e0; // 0x2d2378 - g_ps2RecompiledFunctionTable[477405] = njCnkCs_0x2d22e0; // 0x2d237c - g_ps2RecompiledFunctionTable[477406] = njCnkCs_0x2d22e0; // 0x2d2380 - g_ps2RecompiledFunctionTable[477407] = njCnkCs_0x2d22e0; // 0x2d2384 - g_ps2RecompiledFunctionTable[477408] = njCnkCs_0x2d22e0; // 0x2d2388 - g_ps2RecompiledFunctionTable[477409] = njCnkCs_0x2d22e0; // 0x2d238c - g_ps2RecompiledFunctionTable[477410] = njCnkCs_0x2d22e0; // 0x2d2390 - g_ps2RecompiledFunctionTable[477411] = njCnkCs_0x2d22e0; // 0x2d2394 - g_ps2RecompiledFunctionTable[477412] = njCnkCs_0x2d22e0; // 0x2d2398 - g_ps2RecompiledFunctionTable[477413] = njCnkCs_0x2d22e0; // 0x2d239c - g_ps2RecompiledFunctionTable[477414] = njCnkCs_0x2d22e0; // 0x2d23a0 - g_ps2RecompiledFunctionTable[477415] = njCnkCs_0x2d22e0; // 0x2d23a4 - g_ps2RecompiledFunctionTable[477416] = njCnkCs_0x2d22e0; // 0x2d23a8 - g_ps2RecompiledFunctionTable[477417] = njCnkCs_0x2d22e0; // 0x2d23ac - g_ps2RecompiledFunctionTable[477418] = njCnkCs_0x2d22e0; // 0x2d23b0 - g_ps2RecompiledFunctionTable[477419] = njCnkCs_0x2d22e0; // 0x2d23b4 - g_ps2RecompiledFunctionTable[477420] = njCnkCs_0x2d22e0; // 0x2d23b8 - g_ps2RecompiledFunctionTable[477421] = njCnkCs_0x2d22e0; // 0x2d23bc - g_ps2RecompiledFunctionTable[477422] = njCnkCs_0x2d22e0; // 0x2d23c0 - g_ps2RecompiledFunctionTable[477423] = njCnkCs_0x2d22e0; // 0x2d23c4 - g_ps2RecompiledFunctionTable[477424] = njCnkCs_0x2d22e0; // 0x2d23c8 - g_ps2RecompiledFunctionTable[477425] = njCnkCs_0x2d22e0; // 0x2d23cc - g_ps2RecompiledFunctionTable[477426] = njCnkCs_0x2d22e0; // 0x2d23d0 - g_ps2RecompiledFunctionTable[477427] = njCnkCs_0x2d22e0; // 0x2d23d4 - g_ps2RecompiledFunctionTable[477428] = njCnkCs_0x2d22e0; // 0x2d23d8 - g_ps2RecompiledFunctionTable[477429] = njCnkCs_0x2d22e0; // 0x2d23dc - g_ps2RecompiledFunctionTable[477430] = njCnkCs_0x2d22e0; // 0x2d23e0 - g_ps2RecompiledFunctionTable[477431] = njCnkCs_0x2d22e0; // 0x2d23e4 - g_ps2RecompiledFunctionTable[477432] = njCnkCs_0x2d22e0; // 0x2d23e8 - g_ps2RecompiledFunctionTable[477433] = njCnkCs_0x2d22e0; // 0x2d23ec - g_ps2RecompiledFunctionTable[477434] = njCnkCs_0x2d22e0; // 0x2d23f0 - g_ps2RecompiledFunctionTable[477435] = njCnkCs_0x2d22e0; // 0x2d23f4 - g_ps2RecompiledFunctionTable[477436] = njCnkCs_0x2d22e0; // 0x2d23f8 - g_ps2RecompiledFunctionTable[477437] = njCnkCs_0x2d22e0; // 0x2d23fc - g_ps2RecompiledFunctionTable[477438] = njCnkCs_0x2d22e0; // 0x2d2400 - g_ps2RecompiledFunctionTable[477439] = njCnkCs_0x2d22e0; // 0x2d2404 - g_ps2RecompiledFunctionTable[477440] = njCnkCs_0x2d22e0; // 0x2d2408 - g_ps2RecompiledFunctionTable[477441] = njCnkCs_0x2d22e0; // 0x2d240c - g_ps2RecompiledFunctionTable[477442] = njCnkCs_0x2d22e0; // 0x2d2410 - g_ps2RecompiledFunctionTable[477443] = njCnkCs_0x2d22e0; // 0x2d2414 - g_ps2RecompiledFunctionTable[477444] = njCnkCs_0x2d22e0; // 0x2d2418 - g_ps2RecompiledFunctionTable[477445] = njCnkCs_0x2d22e0; // 0x2d241c - g_ps2RecompiledFunctionTable[477446] = njCnkCs_0x2d22e0; // 0x2d2420 - g_ps2RecompiledFunctionTable[477447] = njCnkCs_0x2d22e0; // 0x2d2424 - g_ps2RecompiledFunctionTable[477448] = njCnkCs_0x2d22e0; // 0x2d2428 - g_ps2RecompiledFunctionTable[477449] = njCnkCs_0x2d22e0; // 0x2d242c - g_ps2RecompiledFunctionTable[477450] = njCnkCs_0x2d22e0; // 0x2d2430 - g_ps2RecompiledFunctionTable[477451] = njCnkCs_0x2d22e0; // 0x2d2434 - g_ps2RecompiledFunctionTable[477452] = njCnkCs_0x2d22e0; // 0x2d2438 - g_ps2RecompiledFunctionTable[477453] = njCnkCs_0x2d22e0; // 0x2d243c - g_ps2RecompiledFunctionTable[477454] = njCnkCs_0x2d22e0; // 0x2d2440 - g_ps2RecompiledFunctionTable[477455] = njCnkCs_0x2d22e0; // 0x2d2444 - g_ps2RecompiledFunctionTable[477456] = njCnkCs_0x2d22e0; // 0x2d2448 - g_ps2RecompiledFunctionTable[477457] = njCnkCs_0x2d22e0; // 0x2d244c - g_ps2RecompiledFunctionTable[477458] = njCnkCs_0x2d22e0; // 0x2d2450 - g_ps2RecompiledFunctionTable[477459] = njCnkCs_0x2d22e0; // 0x2d2454 - g_ps2RecompiledFunctionTable[477460] = njCnkCs_0x2d22e0; // 0x2d2458 - g_ps2RecompiledFunctionTable[477461] = njCnkCs_0x2d22e0; // 0x2d245c - g_ps2RecompiledFunctionTable[477462] = njCnkCs_0x2d22e0; // 0x2d2460 - g_ps2RecompiledFunctionTable[477463] = njCnkCs_0x2d22e0; // 0x2d2464 - g_ps2RecompiledFunctionTable[477464] = njCnkCs_0x2d22e0; // 0x2d2468 - g_ps2RecompiledFunctionTable[477465] = njCnkCs_0x2d22e0; // 0x2d246c - g_ps2RecompiledFunctionTable[477466] = njCnkCs_0x2d22e0; // 0x2d2470 - g_ps2RecompiledFunctionTable[477467] = njCnkCs_0x2d22e0; // 0x2d2474 - g_ps2RecompiledFunctionTable[477468] = njCnkCs_0x2d22e0; // 0x2d2478 - g_ps2RecompiledFunctionTable[477469] = njCnkCs_0x2d22e0; // 0x2d247c - g_ps2RecompiledFunctionTable[477470] = njCnkCs_0x2d22e0; // 0x2d2480 - g_ps2RecompiledFunctionTable[477471] = njCnkCs_0x2d22e0; // 0x2d2484 - g_ps2RecompiledFunctionTable[477472] = njCnkCs_0x2d22e0; // 0x2d2488 - g_ps2RecompiledFunctionTable[477473] = njCnkCs_0x2d22e0; // 0x2d248c - g_ps2RecompiledFunctionTable[477474] = njCnkCs_0x2d22e0; // 0x2d2490 - g_ps2RecompiledFunctionTable[477475] = njCnkCs_0x2d22e0; // 0x2d2494 - g_ps2RecompiledFunctionTable[477476] = njCnkCs_0x2d22e0; // 0x2d2498 - g_ps2RecompiledFunctionTable[477477] = njCnkCs_0x2d22e0; // 0x2d249c - g_ps2RecompiledFunctionTable[477478] = njCnkCs_0x2d22e0; // 0x2d24a0 - g_ps2RecompiledFunctionTable[477479] = njCnkCs_0x2d22e0; // 0x2d24a4 - g_ps2RecompiledFunctionTable[477480] = njCnkCs_0x2d22e0; // 0x2d24a8 - g_ps2RecompiledFunctionTable[477481] = njCnkCs_0x2d22e0; // 0x2d24ac - g_ps2RecompiledFunctionTable[477482] = njCnkCs_0x2d22e0; // 0x2d24b0 - g_ps2RecompiledFunctionTable[477483] = njCnkCs_0x2d22e0; // 0x2d24b4 - g_ps2RecompiledFunctionTable[477484] = njCnkCs_0x2d22e0; // 0x2d24b8 - g_ps2RecompiledFunctionTable[477485] = njCnkCs_0x2d22e0; // 0x2d24bc - g_ps2RecompiledFunctionTable[477486] = njCnkCs_0x2d22e0; // 0x2d24c0 - g_ps2RecompiledFunctionTable[477487] = njCnkCs_0x2d22e0; // 0x2d24c4 - g_ps2RecompiledFunctionTable[477488] = njCnkCs_0x2d22e0; // 0x2d24c8 - g_ps2RecompiledFunctionTable[477489] = njCnkCs_0x2d22e0; // 0x2d24cc - g_ps2RecompiledFunctionTable[477490] = njCnkCs_0x2d22e0; // 0x2d24d0 - g_ps2RecompiledFunctionTable[477491] = njCnkCs_0x2d22e0; // 0x2d24d4 - g_ps2RecompiledFunctionTable[477492] = njCnkCs_0x2d22e0; // 0x2d24d8 - g_ps2RecompiledFunctionTable[477493] = njCnkCs_0x2d22e0; // 0x2d24dc - g_ps2RecompiledFunctionTable[477494] = njCnkCs_0x2d22e0; // 0x2d24e0 - g_ps2RecompiledFunctionTable[477495] = njCnkCs_0x2d22e0; // 0x2d24e4 - g_ps2RecompiledFunctionTable[477496] = njCnkCs_0x2d22e0; // 0x2d24e8 - g_ps2RecompiledFunctionTable[477497] = njCnkCs_0x2d22e0; // 0x2d24ec - g_ps2RecompiledFunctionTable[477498] = njCnkCs_0x2d22e0; // 0x2d24f0 - g_ps2RecompiledFunctionTable[477499] = njCnkCs_0x2d22e0; // 0x2d24f4 - g_ps2RecompiledFunctionTable[477500] = njCnkCs_0x2d22e0; // 0x2d24f8 - g_ps2RecompiledFunctionTable[477501] = njCnkCs_0x2d22e0; // 0x2d24fc - g_ps2RecompiledFunctionTable[477502] = njCnkCs_0x2d22e0; // 0x2d2500 - g_ps2RecompiledFunctionTable[477503] = njCnkCs_0x2d22e0; // 0x2d2504 - g_ps2RecompiledFunctionTable[477504] = njCnkCs_0x2d22e0; // 0x2d2508 - g_ps2RecompiledFunctionTable[477505] = njCnkCs_0x2d22e0; // 0x2d250c - g_ps2RecompiledFunctionTable[477506] = njCnkCs_0x2d22e0; // 0x2d2510 - g_ps2RecompiledFunctionTable[477507] = njCnkCs_0x2d22e0; // 0x2d2514 - g_ps2RecompiledFunctionTable[477508] = njCnkCs_0x2d22e0; // 0x2d2518 - g_ps2RecompiledFunctionTable[477509] = njCnkCs_0x2d22e0; // 0x2d251c - g_ps2RecompiledFunctionTable[477510] = njCnkCs_0x2d22e0; // 0x2d2520 - g_ps2RecompiledFunctionTable[477511] = njCnkCs_0x2d22e0; // 0x2d2524 - g_ps2RecompiledFunctionTable[477512] = njCnkCs_0x2d22e0; // 0x2d2528 - g_ps2RecompiledFunctionTable[477513] = njCnkCs_0x2d22e0; // 0x2d252c - g_ps2RecompiledFunctionTable[477514] = njCnkCs_0x2d22e0; // 0x2d2530 - g_ps2RecompiledFunctionTable[477515] = njCnkCs_0x2d22e0; // 0x2d2534 - g_ps2RecompiledFunctionTable[477516] = njCnkCs_0x2d22e0; // 0x2d2538 - g_ps2RecompiledFunctionTable[477517] = njCnkCs_0x2d22e0; // 0x2d253c - g_ps2RecompiledFunctionTable[477518] = njCnkCs_0x2d22e0; // 0x2d2540 - g_ps2RecompiledFunctionTable[477519] = njCnkCs_0x2d22e0; // 0x2d2544 - g_ps2RecompiledFunctionTable[477520] = njCnkCs_0x2d22e0; // 0x2d2548 - g_ps2RecompiledFunctionTable[477521] = njCnkCs_0x2d22e0; // 0x2d254c - g_ps2RecompiledFunctionTable[477522] = njCnkCs_0x2d22e0; // 0x2d2550 - g_ps2RecompiledFunctionTable[477523] = njCnkCs_0x2d22e0; // 0x2d2554 - g_ps2RecompiledFunctionTable[477524] = njCnkCs_0x2d22e0; // 0x2d2558 - g_ps2RecompiledFunctionTable[477525] = njCnkCs_0x2d22e0; // 0x2d255c - g_ps2RecompiledFunctionTable[477526] = ps2__CVV_0x2d2560; // 0x2d2560 - g_ps2RecompiledFunctionTable[477542] = njCnkCsUvh_0x2d25a0; // 0x2d25a0 - g_ps2RecompiledFunctionTable[477543] = njCnkCsUvh_0x2d25a0; // 0x2d25a4 - g_ps2RecompiledFunctionTable[477544] = njCnkCsUvh_0x2d25a0; // 0x2d25a8 - g_ps2RecompiledFunctionTable[477545] = njCnkCsUvh_0x2d25a0; // 0x2d25ac - g_ps2RecompiledFunctionTable[477546] = njCnkCsUvh_0x2d25a0; // 0x2d25b0 - g_ps2RecompiledFunctionTable[477547] = njCnkCsUvh_0x2d25a0; // 0x2d25b4 - g_ps2RecompiledFunctionTable[477548] = njCnkCsUvh_0x2d25a0; // 0x2d25b8 - g_ps2RecompiledFunctionTable[477549] = njCnkCsUvh_0x2d25a0; // 0x2d25bc - g_ps2RecompiledFunctionTable[477550] = njCnkCsUvh_0x2d25a0; // 0x2d25c0 - g_ps2RecompiledFunctionTable[477551] = njCnkCsUvh_0x2d25a0; // 0x2d25c4 - g_ps2RecompiledFunctionTable[477552] = njCnkCsUvh_0x2d25a0; // 0x2d25c8 - g_ps2RecompiledFunctionTable[477553] = njCnkCsUvh_0x2d25a0; // 0x2d25cc - g_ps2RecompiledFunctionTable[477554] = njCnkCsUvh_0x2d25a0; // 0x2d25d0 - g_ps2RecompiledFunctionTable[477555] = njCnkCsUvh_0x2d25a0; // 0x2d25d4 - g_ps2RecompiledFunctionTable[477556] = njCnkCsUvh_0x2d25a0; // 0x2d25d8 - g_ps2RecompiledFunctionTable[477557] = njCnkCsUvh_0x2d25a0; // 0x2d25dc - g_ps2RecompiledFunctionTable[477558] = njCnkCsUvh_0x2d25a0; // 0x2d25e0 - g_ps2RecompiledFunctionTable[477559] = njCnkCsUvh_0x2d25a0; // 0x2d25e4 - g_ps2RecompiledFunctionTable[477560] = njCnkCsUvh_0x2d25a0; // 0x2d25e8 - g_ps2RecompiledFunctionTable[477561] = njCnkCsUvh_0x2d25a0; // 0x2d25ec - g_ps2RecompiledFunctionTable[477562] = njCnkCsUvh_0x2d25a0; // 0x2d25f0 - g_ps2RecompiledFunctionTable[477563] = njCnkCsUvh_0x2d25a0; // 0x2d25f4 - g_ps2RecompiledFunctionTable[477564] = njCnkCsUvh_0x2d25a0; // 0x2d25f8 - g_ps2RecompiledFunctionTable[477565] = njCnkCsUvh_0x2d25a0; // 0x2d25fc - g_ps2RecompiledFunctionTable[477566] = njCnkCsUvh_0x2d25a0; // 0x2d2600 - g_ps2RecompiledFunctionTable[477567] = njCnkCsUvh_0x2d25a0; // 0x2d2604 - g_ps2RecompiledFunctionTable[477568] = njCnkCsUvh_0x2d25a0; // 0x2d2608 - g_ps2RecompiledFunctionTable[477569] = njCnkCsUvh_0x2d25a0; // 0x2d260c - g_ps2RecompiledFunctionTable[477570] = njCnkCsUvh_0x2d25a0; // 0x2d2610 - g_ps2RecompiledFunctionTable[477571] = njCnkCsUvh_0x2d25a0; // 0x2d2614 - g_ps2RecompiledFunctionTable[477572] = njCnkCsUvh_0x2d25a0; // 0x2d2618 - g_ps2RecompiledFunctionTable[477573] = njCnkCsUvh_0x2d25a0; // 0x2d261c - g_ps2RecompiledFunctionTable[477574] = njCnkCsUvh_0x2d25a0; // 0x2d2620 - g_ps2RecompiledFunctionTable[477575] = njCnkCsUvh_0x2d25a0; // 0x2d2624 - g_ps2RecompiledFunctionTable[477576] = njCnkCsUvh_0x2d25a0; // 0x2d2628 - g_ps2RecompiledFunctionTable[477577] = njCnkCsUvh_0x2d25a0; // 0x2d262c - g_ps2RecompiledFunctionTable[477578] = njCnkCsUvh_0x2d25a0; // 0x2d2630 - g_ps2RecompiledFunctionTable[477579] = njCnkCsUvh_0x2d25a0; // 0x2d2634 - g_ps2RecompiledFunctionTable[477580] = njCnkCsUvh_0x2d25a0; // 0x2d2638 - g_ps2RecompiledFunctionTable[477581] = njCnkCsUvh_0x2d25a0; // 0x2d263c - g_ps2RecompiledFunctionTable[477582] = njCnkCsUvh_0x2d25a0; // 0x2d2640 - g_ps2RecompiledFunctionTable[477583] = njCnkCsUvh_0x2d25a0; // 0x2d2644 - g_ps2RecompiledFunctionTable[477584] = njCnkCsUvh_0x2d25a0; // 0x2d2648 - g_ps2RecompiledFunctionTable[477585] = njCnkCsUvh_0x2d25a0; // 0x2d264c - g_ps2RecompiledFunctionTable[477586] = njCnkCsUvh_0x2d25a0; // 0x2d2650 - g_ps2RecompiledFunctionTable[477587] = njCnkCsUvh_0x2d25a0; // 0x2d2654 - g_ps2RecompiledFunctionTable[477588] = njCnkCsUvh_0x2d25a0; // 0x2d2658 - g_ps2RecompiledFunctionTable[477589] = njCnkCsUvh_0x2d25a0; // 0x2d265c - g_ps2RecompiledFunctionTable[477590] = njCnkCsUvh_0x2d25a0; // 0x2d2660 - g_ps2RecompiledFunctionTable[477591] = njCnkCsUvh_0x2d25a0; // 0x2d2664 - g_ps2RecompiledFunctionTable[477592] = njCnkCsUvh_0x2d25a0; // 0x2d2668 - g_ps2RecompiledFunctionTable[477593] = njCnkCsUvh_0x2d25a0; // 0x2d266c - g_ps2RecompiledFunctionTable[477594] = njCnkCsUvh_0x2d25a0; // 0x2d2670 - g_ps2RecompiledFunctionTable[477595] = njCnkCsUvh_0x2d25a0; // 0x2d2674 - g_ps2RecompiledFunctionTable[477596] = njCnkCsUvh_0x2d25a0; // 0x2d2678 - g_ps2RecompiledFunctionTable[477597] = njCnkCsUvh_0x2d25a0; // 0x2d267c - g_ps2RecompiledFunctionTable[477598] = njCnkCsUvh_0x2d25a0; // 0x2d2680 - g_ps2RecompiledFunctionTable[477599] = njCnkCsUvh_0x2d25a0; // 0x2d2684 - g_ps2RecompiledFunctionTable[477600] = njCnkCsUvh_0x2d25a0; // 0x2d2688 - g_ps2RecompiledFunctionTable[477601] = njCnkCsUvh_0x2d25a0; // 0x2d268c - g_ps2RecompiledFunctionTable[477602] = njCnkCsUvh_0x2d25a0; // 0x2d2690 - g_ps2RecompiledFunctionTable[477603] = njCnkCsUvh_0x2d25a0; // 0x2d2694 - g_ps2RecompiledFunctionTable[477604] = njCnkCsUvh_0x2d25a0; // 0x2d2698 - g_ps2RecompiledFunctionTable[477605] = njCnkCsUvh_0x2d25a0; // 0x2d269c - g_ps2RecompiledFunctionTable[477606] = njCnkCsUvh_0x2d25a0; // 0x2d26a0 - g_ps2RecompiledFunctionTable[477607] = njCnkCsUvh_0x2d25a0; // 0x2d26a4 - g_ps2RecompiledFunctionTable[477608] = njCnkCsUvh_0x2d25a0; // 0x2d26a8 - g_ps2RecompiledFunctionTable[477609] = njCnkCsUvh_0x2d25a0; // 0x2d26ac - g_ps2RecompiledFunctionTable[477610] = njCnkCsUvh_0x2d25a0; // 0x2d26b0 - g_ps2RecompiledFunctionTable[477611] = njCnkCsUvh_0x2d25a0; // 0x2d26b4 - g_ps2RecompiledFunctionTable[477612] = njCnkCsUvh_0x2d25a0; // 0x2d26b8 - g_ps2RecompiledFunctionTable[477613] = njCnkCsUvh_0x2d25a0; // 0x2d26bc - g_ps2RecompiledFunctionTable[477614] = njCnkCsUvh_0x2d25a0; // 0x2d26c0 - g_ps2RecompiledFunctionTable[477615] = njCnkCsUvh_0x2d25a0; // 0x2d26c4 - g_ps2RecompiledFunctionTable[477616] = njCnkCsUvh_0x2d25a0; // 0x2d26c8 - g_ps2RecompiledFunctionTable[477617] = njCnkCsUvh_0x2d25a0; // 0x2d26cc - g_ps2RecompiledFunctionTable[477618] = njCnkCsUvh_0x2d25a0; // 0x2d26d0 - g_ps2RecompiledFunctionTable[477619] = njCnkCsUvh_0x2d25a0; // 0x2d26d4 - g_ps2RecompiledFunctionTable[477620] = njCnkCsUvh_0x2d25a0; // 0x2d26d8 - g_ps2RecompiledFunctionTable[477621] = njCnkCsUvh_0x2d25a0; // 0x2d26dc - g_ps2RecompiledFunctionTable[477622] = njCnkCsUvh_0x2d25a0; // 0x2d26e0 - g_ps2RecompiledFunctionTable[477623] = njCnkCsUvh_0x2d25a0; // 0x2d26e4 - g_ps2RecompiledFunctionTable[477624] = njCnkCsUvh_0x2d25a0; // 0x2d26e8 - g_ps2RecompiledFunctionTable[477625] = njCnkCsUvh_0x2d25a0; // 0x2d26ec - g_ps2RecompiledFunctionTable[477626] = njCnkCsUvh_0x2d25a0; // 0x2d26f0 - g_ps2RecompiledFunctionTable[477627] = njCnkCsUvh_0x2d25a0; // 0x2d26f4 - g_ps2RecompiledFunctionTable[477628] = njCnkCsUvh_0x2d25a0; // 0x2d26f8 - g_ps2RecompiledFunctionTable[477629] = njCnkCsUvh_0x2d25a0; // 0x2d26fc - g_ps2RecompiledFunctionTable[477630] = njCnkCsUvh_0x2d25a0; // 0x2d2700 - g_ps2RecompiledFunctionTable[477631] = njCnkCsUvh_0x2d25a0; // 0x2d2704 - g_ps2RecompiledFunctionTable[477632] = njCnkCsUvh_0x2d25a0; // 0x2d2708 - g_ps2RecompiledFunctionTable[477633] = njCnkCsUvh_0x2d25a0; // 0x2d270c - g_ps2RecompiledFunctionTable[477634] = njCnkCsUvh_0x2d25a0; // 0x2d2710 - g_ps2RecompiledFunctionTable[477635] = njCnkCsUvh_0x2d25a0; // 0x2d2714 - g_ps2RecompiledFunctionTable[477636] = njCnkCsUvh_0x2d25a0; // 0x2d2718 - g_ps2RecompiledFunctionTable[477637] = njCnkCsUvh_0x2d25a0; // 0x2d271c - g_ps2RecompiledFunctionTable[477638] = njCnkCsUvh_0x2d25a0; // 0x2d2720 - g_ps2RecompiledFunctionTable[477639] = njCnkCsUvh_0x2d25a0; // 0x2d2724 - g_ps2RecompiledFunctionTable[477640] = njCnkCsUvh_0x2d25a0; // 0x2d2728 - g_ps2RecompiledFunctionTable[477641] = njCnkCsUvh_0x2d25a0; // 0x2d272c - g_ps2RecompiledFunctionTable[477642] = njCnkCsUvh_0x2d25a0; // 0x2d2730 - g_ps2RecompiledFunctionTable[477643] = njCnkCsUvh_0x2d25a0; // 0x2d2734 - g_ps2RecompiledFunctionTable[477644] = njCnkCsUvh_0x2d25a0; // 0x2d2738 - g_ps2RecompiledFunctionTable[477645] = njCnkCsUvh_0x2d25a0; // 0x2d273c - g_ps2RecompiledFunctionTable[477646] = njCnkCsUvh_0x2d25a0; // 0x2d2740 - g_ps2RecompiledFunctionTable[477647] = njCnkCsUvh_0x2d25a0; // 0x2d2744 - g_ps2RecompiledFunctionTable[477648] = njCnkCsUvh_0x2d25a0; // 0x2d2748 - g_ps2RecompiledFunctionTable[477649] = njCnkCsUvh_0x2d25a0; // 0x2d274c - g_ps2RecompiledFunctionTable[477650] = njCnkCsUvh_0x2d25a0; // 0x2d2750 - g_ps2RecompiledFunctionTable[477651] = njCnkCsUvh_0x2d25a0; // 0x2d2754 - g_ps2RecompiledFunctionTable[477652] = njCnkCsUvh_0x2d25a0; // 0x2d2758 - g_ps2RecompiledFunctionTable[477653] = njCnkCsUvh_0x2d25a0; // 0x2d275c - g_ps2RecompiledFunctionTable[477654] = njCnkCsUvh_0x2d25a0; // 0x2d2760 - g_ps2RecompiledFunctionTable[477655] = njCnkCsUvh_0x2d25a0; // 0x2d2764 - g_ps2RecompiledFunctionTable[477656] = njCnkCsUvh_0x2d25a0; // 0x2d2768 - g_ps2RecompiledFunctionTable[477657] = njCnkCsUvh_0x2d25a0; // 0x2d276c - g_ps2RecompiledFunctionTable[477658] = njCnkCsUvh_0x2d25a0; // 0x2d2770 - g_ps2RecompiledFunctionTable[477659] = njCnkCsUvh_0x2d25a0; // 0x2d2774 - g_ps2RecompiledFunctionTable[477660] = njCnkCsUvh_0x2d25a0; // 0x2d2778 - g_ps2RecompiledFunctionTable[477661] = njCnkCsUvh_0x2d25a0; // 0x2d277c - g_ps2RecompiledFunctionTable[477662] = njCnkCsUvh_0x2d25a0; // 0x2d2780 - g_ps2RecompiledFunctionTable[477663] = njCnkCsUvh_0x2d25a0; // 0x2d2784 - g_ps2RecompiledFunctionTable[477664] = njCnkCsUvh_0x2d25a0; // 0x2d2788 - g_ps2RecompiledFunctionTable[477665] = njCnkCsUvh_0x2d25a0; // 0x2d278c - g_ps2RecompiledFunctionTable[477666] = njCnkCsUvh_0x2d25a0; // 0x2d2790 - g_ps2RecompiledFunctionTable[477667] = njCnkCsUvh_0x2d25a0; // 0x2d2794 - g_ps2RecompiledFunctionTable[477668] = njCnkCsUvh_0x2d25a0; // 0x2d2798 - g_ps2RecompiledFunctionTable[477669] = njCnkCsUvh_0x2d25a0; // 0x2d279c - g_ps2RecompiledFunctionTable[477670] = njCnkCsUvh_0x2d25a0; // 0x2d27a0 - g_ps2RecompiledFunctionTable[477671] = njCnkCsUvh_0x2d25a0; // 0x2d27a4 - g_ps2RecompiledFunctionTable[477672] = njCnkCsUvh_0x2d25a0; // 0x2d27a8 - g_ps2RecompiledFunctionTable[477673] = njCnkCsUvh_0x2d25a0; // 0x2d27ac - g_ps2RecompiledFunctionTable[477674] = njCnkCsUvh_0x2d25a0; // 0x2d27b0 - g_ps2RecompiledFunctionTable[477675] = njCnkCsUvh_0x2d25a0; // 0x2d27b4 - g_ps2RecompiledFunctionTable[477676] = njCnkCsUvh_0x2d25a0; // 0x2d27b8 - g_ps2RecompiledFunctionTable[477677] = njCnkCsUvh_0x2d25a0; // 0x2d27bc - g_ps2RecompiledFunctionTable[477678] = njCnkCsUvh_0x2d25a0; // 0x2d27c0 - g_ps2RecompiledFunctionTable[477679] = njCnkCsUvh_0x2d25a0; // 0x2d27c4 - g_ps2RecompiledFunctionTable[477680] = njCnkCsUvh_0x2d25a0; // 0x2d27c8 - g_ps2RecompiledFunctionTable[477681] = njCnkCsUvh_0x2d25a0; // 0x2d27cc - g_ps2RecompiledFunctionTable[477682] = njCnkCsUvh_0x2d25a0; // 0x2d27d0 - g_ps2RecompiledFunctionTable[477683] = njCnkCsUvh_0x2d25a0; // 0x2d27d4 - g_ps2RecompiledFunctionTable[477684] = njCnkCsUvh_0x2d25a0; // 0x2d27d8 - g_ps2RecompiledFunctionTable[477685] = njCnkCsUvh_0x2d25a0; // 0x2d27dc - g_ps2RecompiledFunctionTable[477686] = njCnkCsUvh_0x2d25a0; // 0x2d27e0 - g_ps2RecompiledFunctionTable[477687] = njCnkCsUvh_0x2d25a0; // 0x2d27e4 - g_ps2RecompiledFunctionTable[477688] = njCnkCsUvh_0x2d25a0; // 0x2d27e8 - g_ps2RecompiledFunctionTable[477689] = njCnkCsUvh_0x2d25a0; // 0x2d27ec - g_ps2RecompiledFunctionTable[477690] = njCnkCsUvh_0x2d25a0; // 0x2d27f0 - g_ps2RecompiledFunctionTable[477691] = njCnkCsUvh_0x2d25a0; // 0x2d27f4 - g_ps2RecompiledFunctionTable[477692] = njCnkCsUvh_0x2d25a0; // 0x2d27f8 - g_ps2RecompiledFunctionTable[477693] = njCnkCsUvh_0x2d25a0; // 0x2d27fc - g_ps2RecompiledFunctionTable[477694] = njCnkCsUvh_0x2d25a0; // 0x2d2800 - g_ps2RecompiledFunctionTable[477695] = njCnkCsUvh_0x2d25a0; // 0x2d2804 - g_ps2RecompiledFunctionTable[477696] = njCnkCsUvh_0x2d25a0; // 0x2d2808 - g_ps2RecompiledFunctionTable[477697] = njCnkCsUvh_0x2d25a0; // 0x2d280c - g_ps2RecompiledFunctionTable[477698] = njCnkCsUvh_0x2d25a0; // 0x2d2810 - g_ps2RecompiledFunctionTable[477699] = njCnkCsUvh_0x2d25a0; // 0x2d2814 - g_ps2RecompiledFunctionTable[477700] = njCnkCsUvh_0x2d25a0; // 0x2d2818 - g_ps2RecompiledFunctionTable[477701] = njCnkCsUvh_0x2d25a0; // 0x2d281c - g_ps2RecompiledFunctionTable[477702] = njCnkCsUvh_0x2d25a0; // 0x2d2820 - g_ps2RecompiledFunctionTable[477703] = njCnkCsUvh_0x2d25a0; // 0x2d2824 - g_ps2RecompiledFunctionTable[477704] = njCnkCsUvh_0x2d25a0; // 0x2d2828 - g_ps2RecompiledFunctionTable[477705] = njCnkCsUvh_0x2d25a0; // 0x2d282c - g_ps2RecompiledFunctionTable[477706] = njCnkCsUvh_0x2d25a0; // 0x2d2830 - g_ps2RecompiledFunctionTable[477707] = njCnkCsUvh_0x2d25a0; // 0x2d2834 - g_ps2RecompiledFunctionTable[477708] = njCnkCsUvh_0x2d25a0; // 0x2d2838 - g_ps2RecompiledFunctionTable[477709] = njCnkCsUvh_0x2d25a0; // 0x2d283c - g_ps2RecompiledFunctionTable[477710] = njCnkCsUvh_0x2d25a0; // 0x2d2840 - g_ps2RecompiledFunctionTable[477711] = njCnkCsUvh_0x2d25a0; // 0x2d2844 - g_ps2RecompiledFunctionTable[477712] = njCnkCsUvh_0x2d25a0; // 0x2d2848 - g_ps2RecompiledFunctionTable[477713] = njCnkCsUvh_0x2d25a0; // 0x2d284c - g_ps2RecompiledFunctionTable[477714] = njCnkCsUvh_0x2d25a0; // 0x2d2850 - g_ps2RecompiledFunctionTable[477715] = njCnkCsUvh_0x2d25a0; // 0x2d2854 - g_ps2RecompiledFunctionTable[477716] = njCnkCsUvh_0x2d25a0; // 0x2d2858 - g_ps2RecompiledFunctionTable[477717] = njCnkCsUvh_0x2d25a0; // 0x2d285c - g_ps2RecompiledFunctionTable[477718] = njCnkCsUvh_0x2d25a0; // 0x2d2860 - g_ps2RecompiledFunctionTable[477719] = njCnkCsUvh_0x2d25a0; // 0x2d2864 - g_ps2RecompiledFunctionTable[477720] = njCnkCsUvh_0x2d25a0; // 0x2d2868 - g_ps2RecompiledFunctionTable[477721] = njCnkCsUvh_0x2d25a0; // 0x2d286c - g_ps2RecompiledFunctionTable[477722] = njCnkCsUvh_0x2d25a0; // 0x2d2870 - g_ps2RecompiledFunctionTable[477723] = njCnkCsUvh_0x2d25a0; // 0x2d2874 - g_ps2RecompiledFunctionTable[477724] = njCnkCsUvh_0x2d25a0; // 0x2d2878 - g_ps2RecompiledFunctionTable[477725] = njCnkCsUvh_0x2d25a0; // 0x2d287c - g_ps2RecompiledFunctionTable[477726] = njCnkCsUvh_0x2d25a0; // 0x2d2880 - g_ps2RecompiledFunctionTable[477727] = njCnkCsUvh_0x2d25a0; // 0x2d2884 - g_ps2RecompiledFunctionTable[477728] = njCnkCsUvh_0x2d25a0; // 0x2d2888 - g_ps2RecompiledFunctionTable[477729] = njCnkCsUvh_0x2d25a0; // 0x2d288c - g_ps2RecompiledFunctionTable[477730] = njCnkCsUvh_0x2d25a0; // 0x2d2890 - g_ps2RecompiledFunctionTable[477731] = njCnkCsUvh_0x2d25a0; // 0x2d2894 - g_ps2RecompiledFunctionTable[477732] = njCnkCsUvh_0x2d25a0; // 0x2d2898 - g_ps2RecompiledFunctionTable[477733] = njCnkCsUvh_0x2d25a0; // 0x2d289c - g_ps2RecompiledFunctionTable[477734] = njCnkCsUvh_0x2d25a0; // 0x2d28a0 - g_ps2RecompiledFunctionTable[477735] = njCnkCsUvh_0x2d25a0; // 0x2d28a4 - g_ps2RecompiledFunctionTable[477736] = njCnkCsUvh_0x2d25a0; // 0x2d28a8 - g_ps2RecompiledFunctionTable[477737] = njCnkCsUvh_0x2d25a0; // 0x2d28ac - g_ps2RecompiledFunctionTable[477738] = njCnkCsUvh_0x2d25a0; // 0x2d28b0 - g_ps2RecompiledFunctionTable[477739] = njCnkCsUvh_0x2d25a0; // 0x2d28b4 - g_ps2RecompiledFunctionTable[477740] = njCnkCsUvh_0x2d25a0; // 0x2d28b8 - g_ps2RecompiledFunctionTable[477741] = njCnkCsUvh_0x2d25a0; // 0x2d28bc - g_ps2RecompiledFunctionTable[477742] = njCnkCsUvh_0x2d25a0; // 0x2d28c0 - g_ps2RecompiledFunctionTable[477743] = njCnkCsUvh_0x2d25a0; // 0x2d28c4 - g_ps2RecompiledFunctionTable[477744] = njCnkCsUvh_0x2d25a0; // 0x2d28c8 - g_ps2RecompiledFunctionTable[477745] = njCnkCsUvh_0x2d25a0; // 0x2d28cc - g_ps2RecompiledFunctionTable[477746] = njCnkCsUvh_0x2d25a0; // 0x2d28d0 - g_ps2RecompiledFunctionTable[477747] = njCnkCsUvh_0x2d25a0; // 0x2d28d4 - g_ps2RecompiledFunctionTable[477748] = njCnkCsUvh_0x2d25a0; // 0x2d28d8 - g_ps2RecompiledFunctionTable[477749] = njCnkCsUvh_0x2d25a0; // 0x2d28dc - g_ps2RecompiledFunctionTable[477750] = njCnkCsUvh_0x2d25a0; // 0x2d28e0 - g_ps2RecompiledFunctionTable[477751] = njCnkCsUvh_0x2d25a0; // 0x2d28e4 - g_ps2RecompiledFunctionTable[477752] = njCnkCsUvh_0x2d25a0; // 0x2d28e8 - g_ps2RecompiledFunctionTable[477753] = njCnkCsUvh_0x2d25a0; // 0x2d28ec - g_ps2RecompiledFunctionTable[477754] = njCnkCsUvh_0x2d25a0; // 0x2d28f0 - g_ps2RecompiledFunctionTable[477755] = njCnkCsUvh_0x2d25a0; // 0x2d28f4 - g_ps2RecompiledFunctionTable[477756] = njCnkCsUvh_0x2d25a0; // 0x2d28f8 - g_ps2RecompiledFunctionTable[477757] = njCnkCsUvh_0x2d25a0; // 0x2d28fc - g_ps2RecompiledFunctionTable[477758] = njCnkCsUvh_0x2d25a0; // 0x2d2900 - g_ps2RecompiledFunctionTable[477759] = njCnkCsUvh_0x2d25a0; // 0x2d2904 - g_ps2RecompiledFunctionTable[477760] = njCnkCsUvh_0x2d25a0; // 0x2d2908 - g_ps2RecompiledFunctionTable[477761] = njCnkCsUvh_0x2d25a0; // 0x2d290c - g_ps2RecompiledFunctionTable[477762] = njCnkCsUvh_0x2d25a0; // 0x2d2910 - g_ps2RecompiledFunctionTable[477763] = njCnkCsUvh_0x2d25a0; // 0x2d2914 - g_ps2RecompiledFunctionTable[477764] = njCnkCsUvh_0x2d25a0; // 0x2d2918 - g_ps2RecompiledFunctionTable[477765] = njCnkCsUvh_0x2d25a0; // 0x2d291c - g_ps2RecompiledFunctionTable[477766] = njCnkCsUvh_0x2d25a0; // 0x2d2920 - g_ps2RecompiledFunctionTable[477767] = njCnkCsUvh_0x2d25a0; // 0x2d2924 - g_ps2RecompiledFunctionTable[477768] = njCnkCsUvh_0x2d25a0; // 0x2d2928 - g_ps2RecompiledFunctionTable[477769] = njCnkCsUvh_0x2d25a0; // 0x2d292c - g_ps2RecompiledFunctionTable[477770] = njCnkCsUvh_0x2d25a0; // 0x2d2930 - g_ps2RecompiledFunctionTable[477771] = njCnkCsUvh_0x2d25a0; // 0x2d2934 - g_ps2RecompiledFunctionTable[477772] = njCnkCsUvh_0x2d25a0; // 0x2d2938 - g_ps2RecompiledFunctionTable[477773] = njCnkCsUvh_0x2d25a0; // 0x2d293c - g_ps2RecompiledFunctionTable[477774] = njCnkCsUvh_0x2d25a0; // 0x2d2940 - g_ps2RecompiledFunctionTable[477775] = njCnkCsUvh_0x2d25a0; // 0x2d2944 - g_ps2RecompiledFunctionTable[477776] = njCnkCsUvh_0x2d25a0; // 0x2d2948 - g_ps2RecompiledFunctionTable[477777] = njCnkCsUvh_0x2d25a0; // 0x2d294c - g_ps2RecompiledFunctionTable[477778] = njCnkCsUvh_0x2d25a0; // 0x2d2950 - g_ps2RecompiledFunctionTable[477779] = njCnkCsUvh_0x2d25a0; // 0x2d2954 - g_ps2RecompiledFunctionTable[477780] = njCnkCsUvh_0x2d25a0; // 0x2d2958 - g_ps2RecompiledFunctionTable[477781] = njCnkCsUvh_0x2d25a0; // 0x2d295c - g_ps2RecompiledFunctionTable[477782] = njCnkCsUvh_0x2d25a0; // 0x2d2960 - g_ps2RecompiledFunctionTable[477783] = njCnkCsUvh_0x2d25a0; // 0x2d2964 - g_ps2RecompiledFunctionTable[477784] = njCnkCsUvh_0x2d25a0; // 0x2d2968 - g_ps2RecompiledFunctionTable[477785] = njCnkCsUvh_0x2d25a0; // 0x2d296c - g_ps2RecompiledFunctionTable[477786] = njCnkCsUvh_0x2d25a0; // 0x2d2970 - g_ps2RecompiledFunctionTable[477787] = njCnkCsUvh_0x2d25a0; // 0x2d2974 - g_ps2RecompiledFunctionTable[477788] = njCnkCsUvh_0x2d25a0; // 0x2d2978 - g_ps2RecompiledFunctionTable[477789] = njCnkCsUvh_0x2d25a0; // 0x2d297c - g_ps2RecompiledFunctionTable[477790] = njCnkCsUvh_0x2d25a0; // 0x2d2980 - g_ps2RecompiledFunctionTable[477791] = njCnkCsUvh_0x2d25a0; // 0x2d2984 - g_ps2RecompiledFunctionTable[477792] = njCnkCsUvh_0x2d25a0; // 0x2d2988 - g_ps2RecompiledFunctionTable[477793] = njCnkCsUvh_0x2d25a0; // 0x2d298c - g_ps2RecompiledFunctionTable[477794] = njCnkCsUvh_0x2d25a0; // 0x2d2990 - g_ps2RecompiledFunctionTable[477795] = njCnkCsUvh_0x2d25a0; // 0x2d2994 - g_ps2RecompiledFunctionTable[477796] = njCnkCsUvh_0x2d25a0; // 0x2d2998 - g_ps2RecompiledFunctionTable[477797] = njCnkCsUvh_0x2d25a0; // 0x2d299c - g_ps2RecompiledFunctionTable[477798] = njCnkCsUvh_0x2d25a0; // 0x2d29a0 - g_ps2RecompiledFunctionTable[477799] = njCnkCsUvh_0x2d25a0; // 0x2d29a4 - g_ps2RecompiledFunctionTable[477800] = njCnkCsUvh_0x2d25a0; // 0x2d29a8 - g_ps2RecompiledFunctionTable[477801] = njCnkCsUvh_0x2d25a0; // 0x2d29ac - g_ps2RecompiledFunctionTable[477802] = njCnkCsUvh_0x2d25a0; // 0x2d29b0 - g_ps2RecompiledFunctionTable[477803] = njCnkCsUvh_0x2d25a0; // 0x2d29b4 - g_ps2RecompiledFunctionTable[477804] = njCnkCsUvh_0x2d25a0; // 0x2d29b8 - g_ps2RecompiledFunctionTable[477805] = njCnkCsUvh_0x2d25a0; // 0x2d29bc - g_ps2RecompiledFunctionTable[477806] = njCnkCsUvh_0x2d25a0; // 0x2d29c0 - g_ps2RecompiledFunctionTable[477807] = njCnkCsUvh_0x2d25a0; // 0x2d29c4 - g_ps2RecompiledFunctionTable[477808] = njCnkCsUvh_0x2d25a0; // 0x2d29c8 - g_ps2RecompiledFunctionTable[477809] = njCnkCsUvh_0x2d25a0; // 0x2d29cc - g_ps2RecompiledFunctionTable[477810] = njCnkCsUvh_0x2d25a0; // 0x2d29d0 - g_ps2RecompiledFunctionTable[477811] = njCnkCsUvh_0x2d25a0; // 0x2d29d4 - g_ps2RecompiledFunctionTable[477812] = njCnkCsUvh_0x2d25a0; // 0x2d29d8 - g_ps2RecompiledFunctionTable[477813] = njCnkCsUvh_0x2d25a0; // 0x2d29dc - g_ps2RecompiledFunctionTable[477814] = njCnkCsUvh_0x2d25a0; // 0x2d29e0 - g_ps2RecompiledFunctionTable[477815] = njCnkCsUvh_0x2d25a0; // 0x2d29e4 - g_ps2RecompiledFunctionTable[477816] = njCnkCsUvh_0x2d25a0; // 0x2d29e8 - g_ps2RecompiledFunctionTable[477817] = njCnkCsUvh_0x2d25a0; // 0x2d29ec - g_ps2RecompiledFunctionTable[477818] = njCnkCsUvh_0x2d25a0; // 0x2d29f0 - g_ps2RecompiledFunctionTable[477819] = njCnkCsUvh_0x2d25a0; // 0x2d29f4 - g_ps2RecompiledFunctionTable[477820] = njCnkCsUvh_0x2d25a0; // 0x2d29f8 - g_ps2RecompiledFunctionTable[477821] = njCnkCsUvh_0x2d25a0; // 0x2d29fc - g_ps2RecompiledFunctionTable[477822] = njCnkCsUvh_0x2d25a0; // 0x2d2a00 - g_ps2RecompiledFunctionTable[477823] = njCnkCsUvh_0x2d25a0; // 0x2d2a04 - g_ps2RecompiledFunctionTable[477824] = njCnkCsUvh_0x2d25a0; // 0x2d2a08 - g_ps2RecompiledFunctionTable[477825] = njCnkCsUvh_0x2d25a0; // 0x2d2a0c - g_ps2RecompiledFunctionTable[477826] = njCnkCsUvh_0x2d25a0; // 0x2d2a10 - g_ps2RecompiledFunctionTable[477827] = njCnkCsUvh_0x2d25a0; // 0x2d2a14 - g_ps2RecompiledFunctionTable[477828] = njCnkCsUvh_0x2d25a0; // 0x2d2a18 - g_ps2RecompiledFunctionTable[477829] = njCnkCsUvh_0x2d25a0; // 0x2d2a1c - g_ps2RecompiledFunctionTable[477830] = njCnkCsUvh_0x2d25a0; // 0x2d2a20 - g_ps2RecompiledFunctionTable[477831] = njCnkCsUvh_0x2d25a0; // 0x2d2a24 - g_ps2RecompiledFunctionTable[477832] = njCnkCsUvh_0x2d25a0; // 0x2d2a28 - g_ps2RecompiledFunctionTable[477833] = njCnkCsUvh_0x2d25a0; // 0x2d2a2c - g_ps2RecompiledFunctionTable[477834] = njCnkCsUvh_0x2d25a0; // 0x2d2a30 - g_ps2RecompiledFunctionTable[477835] = njCnkCsUvh_0x2d25a0; // 0x2d2a34 - g_ps2RecompiledFunctionTable[477836] = njCnkCsUvh_0x2d25a0; // 0x2d2a38 - g_ps2RecompiledFunctionTable[477837] = njCnkCsUvh_0x2d25a0; // 0x2d2a3c - g_ps2RecompiledFunctionTable[477838] = njCnkCsUvh_0x2d25a0; // 0x2d2a40 - g_ps2RecompiledFunctionTable[477839] = njCnkCsUvh_0x2d25a0; // 0x2d2a44 - g_ps2RecompiledFunctionTable[477840] = njCnkCsUvh_0x2d25a0; // 0x2d2a48 - g_ps2RecompiledFunctionTable[477841] = njCnkCsUvh_0x2d25a0; // 0x2d2a4c - g_ps2RecompiledFunctionTable[477842] = njCnkCsUvh_0x2d25a0; // 0x2d2a50 - g_ps2RecompiledFunctionTable[477843] = njCnkCsUvh_0x2d25a0; // 0x2d2a54 - g_ps2RecompiledFunctionTable[477844] = njCnkCsUvh_0x2d25a0; // 0x2d2a58 - g_ps2RecompiledFunctionTable[477845] = njCnkCsUvh_0x2d25a0; // 0x2d2a5c - g_ps2RecompiledFunctionTable[477846] = njCnkCsUvh_0x2d25a0; // 0x2d2a60 - g_ps2RecompiledFunctionTable[477847] = njCnkCsUvh_0x2d25a0; // 0x2d2a64 - g_ps2RecompiledFunctionTable[477848] = njCnkCsUvh_0x2d25a0; // 0x2d2a68 - g_ps2RecompiledFunctionTable[477849] = njCnkCsUvh_0x2d25a0; // 0x2d2a6c - g_ps2RecompiledFunctionTable[477850] = njCnkCsUvh_0x2d25a0; // 0x2d2a70 - g_ps2RecompiledFunctionTable[477851] = njCnkCsUvh_0x2d25a0; // 0x2d2a74 - g_ps2RecompiledFunctionTable[477852] = njCnkCsUvh_0x2d25a0; // 0x2d2a78 - g_ps2RecompiledFunctionTable[477853] = njCnkCsUvh_0x2d25a0; // 0x2d2a7c - g_ps2RecompiledFunctionTable[477854] = njCnkCsUvh_0x2d25a0; // 0x2d2a80 - g_ps2RecompiledFunctionTable[477855] = njCnkCsUvh_0x2d25a0; // 0x2d2a84 - g_ps2RecompiledFunctionTable[477856] = njCnkCsUvh_0x2d25a0; // 0x2d2a88 - g_ps2RecompiledFunctionTable[477857] = njCnkCsUvh_0x2d25a0; // 0x2d2a8c - g_ps2RecompiledFunctionTable[477858] = njCnkCsUvh_0x2d25a0; // 0x2d2a90 - g_ps2RecompiledFunctionTable[477859] = njCnkCsUvh_0x2d25a0; // 0x2d2a94 - g_ps2RecompiledFunctionTable[477860] = njCnkCsUvh_0x2d25a0; // 0x2d2a98 - g_ps2RecompiledFunctionTable[477861] = njCnkCsUvh_0x2d25a0; // 0x2d2a9c - g_ps2RecompiledFunctionTable[477862] = njCnkCsUvh_0x2d25a0; // 0x2d2aa0 - g_ps2RecompiledFunctionTable[477863] = njCnkCsUvh_0x2d25a0; // 0x2d2aa4 - g_ps2RecompiledFunctionTable[477864] = njCnkCsUvh_0x2d25a0; // 0x2d2aa8 - g_ps2RecompiledFunctionTable[477865] = njCnkCsUvh_0x2d25a0; // 0x2d2aac - g_ps2RecompiledFunctionTable[477866] = njCnkCsUvh_0x2d25a0; // 0x2d2ab0 - g_ps2RecompiledFunctionTable[477867] = njCnkCsUvh_0x2d25a0; // 0x2d2ab4 - g_ps2RecompiledFunctionTable[477868] = njCnkCsUvh_0x2d25a0; // 0x2d2ab8 - g_ps2RecompiledFunctionTable[477869] = njCnkCsUvh_0x2d25a0; // 0x2d2abc - g_ps2RecompiledFunctionTable[477870] = njCnkCsUvh_0x2d25a0; // 0x2d2ac0 - g_ps2RecompiledFunctionTable[477871] = njCnkCsUvh_0x2d25a0; // 0x2d2ac4 - g_ps2RecompiledFunctionTable[477872] = njCnkCsUvh_0x2d25a0; // 0x2d2ac8 - g_ps2RecompiledFunctionTable[477873] = njCnkCsUvh_0x2d25a0; // 0x2d2acc - g_ps2RecompiledFunctionTable[477874] = njCnkCsUvh_0x2d25a0; // 0x2d2ad0 - g_ps2RecompiledFunctionTable[477875] = njCnkCsUvh_0x2d25a0; // 0x2d2ad4 - g_ps2RecompiledFunctionTable[477876] = njCnkCsUvh_0x2d25a0; // 0x2d2ad8 - g_ps2RecompiledFunctionTable[477877] = njCnkCsUvh_0x2d25a0; // 0x2d2adc - g_ps2RecompiledFunctionTable[477878] = njCnkCsUvh_0x2d25a0; // 0x2d2ae0 - g_ps2RecompiledFunctionTable[477879] = njCnkCsUvh_0x2d25a0; // 0x2d2ae4 - g_ps2RecompiledFunctionTable[477880] = njCnkCsUvh_0x2d25a0; // 0x2d2ae8 - g_ps2RecompiledFunctionTable[477881] = njCnkCsUvh_0x2d25a0; // 0x2d2aec - g_ps2RecompiledFunctionTable[477882] = njCnkCsUvh_0x2d25a0; // 0x2d2af0 - g_ps2RecompiledFunctionTable[477883] = njCnkCsUvh_0x2d25a0; // 0x2d2af4 - g_ps2RecompiledFunctionTable[477884] = njCnkCsUvh_0x2d25a0; // 0x2d2af8 - g_ps2RecompiledFunctionTable[477885] = njCnkCsUvh_0x2d25a0; // 0x2d2afc - g_ps2RecompiledFunctionTable[477886] = njCnkCsUvh_0x2d25a0; // 0x2d2b00 - g_ps2RecompiledFunctionTable[477887] = njCnkCsUvh_0x2d25a0; // 0x2d2b04 - g_ps2RecompiledFunctionTable[477888] = njCnkCsUvh_0x2d25a0; // 0x2d2b08 - g_ps2RecompiledFunctionTable[477889] = njCnkCsUvh_0x2d25a0; // 0x2d2b0c - g_ps2RecompiledFunctionTable[477890] = njCnkCsUvh_0x2d25a0; // 0x2d2b10 - g_ps2RecompiledFunctionTable[477891] = njCnkCsUvh_0x2d25a0; // 0x2d2b14 - g_ps2RecompiledFunctionTable[477892] = njCnkCsUvh_0x2d25a0; // 0x2d2b18 - g_ps2RecompiledFunctionTable[477893] = njCnkCsUvh_0x2d25a0; // 0x2d2b1c - g_ps2RecompiledFunctionTable[477894] = njCnkCsUvh_0x2d25a0; // 0x2d2b20 - g_ps2RecompiledFunctionTable[477895] = njCnkCsUvh_0x2d25a0; // 0x2d2b24 - g_ps2RecompiledFunctionTable[477896] = njCnkCsUvh_0x2d25a0; // 0x2d2b28 - g_ps2RecompiledFunctionTable[477897] = njCnkCsUvh_0x2d25a0; // 0x2d2b2c - g_ps2RecompiledFunctionTable[477898] = njCnkCsUvh_0x2d25a0; // 0x2d2b30 - g_ps2RecompiledFunctionTable[477899] = njCnkCsUvh_0x2d25a0; // 0x2d2b34 - g_ps2RecompiledFunctionTable[477900] = njCnkCsUvh_0x2d25a0; // 0x2d2b38 - g_ps2RecompiledFunctionTable[477901] = njCnkCsUvh_0x2d25a0; // 0x2d2b3c - g_ps2RecompiledFunctionTable[477902] = njCnkCsUvh_0x2d25a0; // 0x2d2b40 - g_ps2RecompiledFunctionTable[477903] = njCnkCsUvh_0x2d25a0; // 0x2d2b44 - g_ps2RecompiledFunctionTable[477904] = njCnkCsUvh_0x2d25a0; // 0x2d2b48 - g_ps2RecompiledFunctionTable[477905] = njCnkCsUvh_0x2d25a0; // 0x2d2b4c - g_ps2RecompiledFunctionTable[477906] = njCnkCsUvh_0x2d25a0; // 0x2d2b50 - g_ps2RecompiledFunctionTable[477907] = njCnkCsUvh_0x2d25a0; // 0x2d2b54 - g_ps2RecompiledFunctionTable[477908] = njCnkCsUvh_0x2d25a0; // 0x2d2b58 - g_ps2RecompiledFunctionTable[477909] = njCnkCsUvh_0x2d25a0; // 0x2d2b5c - g_ps2RecompiledFunctionTable[477910] = njCnkCsUvh_0x2d25a0; // 0x2d2b60 - g_ps2RecompiledFunctionTable[477911] = njCnkCsUvh_0x2d25a0; // 0x2d2b64 - g_ps2RecompiledFunctionTable[477912] = njCnkCsUvh_0x2d25a0; // 0x2d2b68 - g_ps2RecompiledFunctionTable[477913] = njCnkCsUvh_0x2d25a0; // 0x2d2b6c - g_ps2RecompiledFunctionTable[477914] = njCnkCsUvh_0x2d25a0; // 0x2d2b70 - g_ps2RecompiledFunctionTable[477915] = njCnkCsUvh_0x2d25a0; // 0x2d2b74 - g_ps2RecompiledFunctionTable[477916] = njCnkCsUvh_0x2d25a0; // 0x2d2b78 - g_ps2RecompiledFunctionTable[477917] = njCnkCsUvh_0x2d25a0; // 0x2d2b7c - g_ps2RecompiledFunctionTable[477918] = njCnkCsUvh_0x2d25a0; // 0x2d2b80 - g_ps2RecompiledFunctionTable[477919] = njCnkCsUvh_0x2d25a0; // 0x2d2b84 - g_ps2RecompiledFunctionTable[477920] = njCnkCsUvh_0x2d25a0; // 0x2d2b88 - g_ps2RecompiledFunctionTable[477921] = njCnkCsUvh_0x2d25a0; // 0x2d2b8c - g_ps2RecompiledFunctionTable[477922] = njCnkCsUvh_0x2d25a0; // 0x2d2b90 - g_ps2RecompiledFunctionTable[477923] = njCnkCsUvh_0x2d25a0; // 0x2d2b94 - g_ps2RecompiledFunctionTable[477924] = njCnkCsUvh_0x2d25a0; // 0x2d2b98 - g_ps2RecompiledFunctionTable[477925] = njCnkCsUvh_0x2d25a0; // 0x2d2b9c - g_ps2RecompiledFunctionTable[477926] = njCnkCsUvh_0x2d25a0; // 0x2d2ba0 - g_ps2RecompiledFunctionTable[477927] = njCnkCsUvh_0x2d25a0; // 0x2d2ba4 - g_ps2RecompiledFunctionTable[477928] = njCnkCsUvh_0x2d25a0; // 0x2d2ba8 - g_ps2RecompiledFunctionTable[477929] = njCnkCsUvh_0x2d25a0; // 0x2d2bac - g_ps2RecompiledFunctionTable[477930] = njCnkCsUvh_0x2d25a0; // 0x2d2bb0 - g_ps2RecompiledFunctionTable[477931] = njCnkCsUvh_0x2d25a0; // 0x2d2bb4 - g_ps2RecompiledFunctionTable[477932] = njCnkCsUvh_0x2d25a0; // 0x2d2bb8 - g_ps2RecompiledFunctionTable[477933] = njCnkCsUvh_0x2d25a0; // 0x2d2bbc - g_ps2RecompiledFunctionTable[477934] = njCnkCsUvh_0x2d25a0; // 0x2d2bc0 - g_ps2RecompiledFunctionTable[477935] = njCnkCsUvh_0x2d25a0; // 0x2d2bc4 - g_ps2RecompiledFunctionTable[477936] = njCnkCsUvh_0x2d25a0; // 0x2d2bc8 - g_ps2RecompiledFunctionTable[477937] = njCnkCsUvh_0x2d25a0; // 0x2d2bcc - g_ps2RecompiledFunctionTable[477938] = njCnkCsUvh_0x2d25a0; // 0x2d2bd0 - g_ps2RecompiledFunctionTable[477939] = njCnkCsUvh_0x2d25a0; // 0x2d2bd4 - g_ps2RecompiledFunctionTable[477940] = njCnkCsUvh_0x2d25a0; // 0x2d2bd8 - g_ps2RecompiledFunctionTable[477941] = njCnkCsUvh_0x2d25a0; // 0x2d2bdc - g_ps2RecompiledFunctionTable[477942] = njCnkCsUvh_0x2d25a0; // 0x2d2be0 - g_ps2RecompiledFunctionTable[477943] = njCnkCsUvh_0x2d25a0; // 0x2d2be4 - g_ps2RecompiledFunctionTable[477944] = njCnkCsUvh_0x2d25a0; // 0x2d2be8 - g_ps2RecompiledFunctionTable[477945] = njCnkCsUvh_0x2d25a0; // 0x2d2bec - g_ps2RecompiledFunctionTable[477946] = njCnkCsUvh_0x2d25a0; // 0x2d2bf0 - g_ps2RecompiledFunctionTable[477947] = njCnkCsUvh_0x2d25a0; // 0x2d2bf4 - g_ps2RecompiledFunctionTable[477948] = njCnkCsUvh_0x2d25a0; // 0x2d2bf8 - g_ps2RecompiledFunctionTable[477949] = njCnkCsUvh_0x2d25a0; // 0x2d2bfc - g_ps2RecompiledFunctionTable[477950] = njCnkCsUvh_0x2d25a0; // 0x2d2c00 - g_ps2RecompiledFunctionTable[477951] = njCnkCsUvh_0x2d25a0; // 0x2d2c04 - g_ps2RecompiledFunctionTable[477952] = njCnkCsUvh_0x2d25a0; // 0x2d2c08 - g_ps2RecompiledFunctionTable[477953] = njCnkCsUvh_0x2d25a0; // 0x2d2c0c - g_ps2RecompiledFunctionTable[477954] = njCnkCsUvh_0x2d25a0; // 0x2d2c10 - g_ps2RecompiledFunctionTable[477955] = njCnkCsUvh_0x2d25a0; // 0x2d2c14 - g_ps2RecompiledFunctionTable[477956] = njCnkCsUvh_0x2d25a0; // 0x2d2c18 - g_ps2RecompiledFunctionTable[477957] = njCnkCsUvh_0x2d25a0; // 0x2d2c1c - g_ps2RecompiledFunctionTable[477958] = njCnkCsUvh_0x2d25a0; // 0x2d2c20 - g_ps2RecompiledFunctionTable[477959] = njCnkCsUvh_0x2d25a0; // 0x2d2c24 - g_ps2RecompiledFunctionTable[477960] = njCnkCsUvh_0x2d25a0; // 0x2d2c28 - g_ps2RecompiledFunctionTable[477961] = njCnkCsUvh_0x2d25a0; // 0x2d2c2c - g_ps2RecompiledFunctionTable[477962] = njCnkCsUvh_0x2d25a0; // 0x2d2c30 - g_ps2RecompiledFunctionTable[477963] = njCnkCsUvh_0x2d25a0; // 0x2d2c34 - g_ps2RecompiledFunctionTable[477964] = njCnkCsUvh_0x2d25a0; // 0x2d2c38 - g_ps2RecompiledFunctionTable[477965] = njCnkCsUvh_0x2d25a0; // 0x2d2c3c - g_ps2RecompiledFunctionTable[477966] = njCnkCsUvh_0x2d25a0; // 0x2d2c40 - g_ps2RecompiledFunctionTable[477967] = njCnkCsUvh_0x2d25a0; // 0x2d2c44 - g_ps2RecompiledFunctionTable[477968] = njCnkCsUvh_0x2d25a0; // 0x2d2c48 - g_ps2RecompiledFunctionTable[477969] = njCnkCsUvh_0x2d25a0; // 0x2d2c4c - g_ps2RecompiledFunctionTable[477970] = njCnkCsUvh_0x2d25a0; // 0x2d2c50 - g_ps2RecompiledFunctionTable[477971] = njCnkCsUvh_0x2d25a0; // 0x2d2c54 - g_ps2RecompiledFunctionTable[477972] = njCnkCsUvh_0x2d25a0; // 0x2d2c58 - g_ps2RecompiledFunctionTable[477973] = njCnkCsUvh_0x2d25a0; // 0x2d2c5c - g_ps2RecompiledFunctionTable[477974] = njCnkCsUvh_0x2d25a0; // 0x2d2c60 - g_ps2RecompiledFunctionTable[477975] = njCnkCsUvh_0x2d25a0; // 0x2d2c64 - g_ps2RecompiledFunctionTable[477976] = njCnkCsUvh_0x2d25a0; // 0x2d2c68 - g_ps2RecompiledFunctionTable[477977] = njCnkCsUvh_0x2d25a0; // 0x2d2c6c - g_ps2RecompiledFunctionTable[477978] = njCnkCsUvh_0x2d25a0; // 0x2d2c70 - g_ps2RecompiledFunctionTable[477979] = njCnkCsUvh_0x2d25a0; // 0x2d2c74 - g_ps2RecompiledFunctionTable[477980] = njCnkCsUvh_0x2d25a0; // 0x2d2c78 - g_ps2RecompiledFunctionTable[477981] = njCnkCsUvh_0x2d25a0; // 0x2d2c7c - g_ps2RecompiledFunctionTable[477982] = njCnkCsUvh_0x2d25a0; // 0x2d2c80 - g_ps2RecompiledFunctionTable[477983] = njCnkCsUvh_0x2d25a0; // 0x2d2c84 - g_ps2RecompiledFunctionTable[477984] = njCnkCsUvh_0x2d25a0; // 0x2d2c88 - g_ps2RecompiledFunctionTable[477985] = njCnkCsUvh_0x2d25a0; // 0x2d2c8c - g_ps2RecompiledFunctionTable[477986] = njCnkCsUvh_0x2d25a0; // 0x2d2c90 - g_ps2RecompiledFunctionTable[477987] = njCnkCsUvh_0x2d25a0; // 0x2d2c94 - g_ps2RecompiledFunctionTable[477988] = njCnkCsUvh_0x2d25a0; // 0x2d2c98 - g_ps2RecompiledFunctionTable[477989] = njCnkCsUvh_0x2d25a0; // 0x2d2c9c - g_ps2RecompiledFunctionTable[477990] = njCnkCsUvh_0x2d25a0; // 0x2d2ca0 - g_ps2RecompiledFunctionTable[477991] = njCnkCsUvh_0x2d25a0; // 0x2d2ca4 - g_ps2RecompiledFunctionTable[477992] = njCnkCsUvh_0x2d25a0; // 0x2d2ca8 - g_ps2RecompiledFunctionTable[477993] = njCnkCsUvh_0x2d25a0; // 0x2d2cac - g_ps2RecompiledFunctionTable[477994] = njCnkCsUvh_0x2d25a0; // 0x2d2cb0 - g_ps2RecompiledFunctionTable[477995] = njCnkCsUvh_0x2d25a0; // 0x2d2cb4 - g_ps2RecompiledFunctionTable[477996] = njCnkCsUvh_0x2d25a0; // 0x2d2cb8 - g_ps2RecompiledFunctionTable[477997] = njCnkCsUvh_0x2d25a0; // 0x2d2cbc - g_ps2RecompiledFunctionTable[477998] = njCnkCsUvh_0x2d25a0; // 0x2d2cc0 - g_ps2RecompiledFunctionTable[477999] = njCnkCsUvh_0x2d25a0; // 0x2d2cc4 - g_ps2RecompiledFunctionTable[478000] = njCnkCsUvh_0x2d25a0; // 0x2d2cc8 - g_ps2RecompiledFunctionTable[478001] = njCnkCsUvh_0x2d25a0; // 0x2d2ccc - g_ps2RecompiledFunctionTable[478002] = njCnkCsUvh_0x2d25a0; // 0x2d2cd0 - g_ps2RecompiledFunctionTable[478003] = njCnkCsUvh_0x2d25a0; // 0x2d2cd4 - g_ps2RecompiledFunctionTable[478004] = njCnkCsUvh_0x2d25a0; // 0x2d2cd8 - g_ps2RecompiledFunctionTable[478005] = njCnkCsUvh_0x2d25a0; // 0x2d2cdc - g_ps2RecompiledFunctionTable[478006] = njCnkCsUvh_0x2d25a0; // 0x2d2ce0 - g_ps2RecompiledFunctionTable[478007] = njCnkCsUvh_0x2d25a0; // 0x2d2ce4 - g_ps2RecompiledFunctionTable[478008] = njCnkCsUvh_0x2d25a0; // 0x2d2ce8 - g_ps2RecompiledFunctionTable[478009] = njCnkCsUvh_0x2d25a0; // 0x2d2cec - g_ps2RecompiledFunctionTable[478010] = njCnkCsUvh_0x2d25a0; // 0x2d2cf0 - g_ps2RecompiledFunctionTable[478011] = njCnkCsUvh_0x2d25a0; // 0x2d2cf4 - g_ps2RecompiledFunctionTable[478012] = njCnkCsUvh_0x2d25a0; // 0x2d2cf8 - g_ps2RecompiledFunctionTable[478013] = njCnkCsUvh_0x2d25a0; // 0x2d2cfc - g_ps2RecompiledFunctionTable[478014] = njCnkCsUvh_0x2d25a0; // 0x2d2d00 - g_ps2RecompiledFunctionTable[478015] = njCnkCsUvh_0x2d25a0; // 0x2d2d04 - g_ps2RecompiledFunctionTable[478016] = njCnkCsUvh_0x2d25a0; // 0x2d2d08 - g_ps2RecompiledFunctionTable[478017] = njCnkCsUvh_0x2d25a0; // 0x2d2d0c - g_ps2RecompiledFunctionTable[478018] = njCnkCsUvh_0x2d25a0; // 0x2d2d10 - g_ps2RecompiledFunctionTable[478019] = njCnkCsUvh_0x2d25a0; // 0x2d2d14 - g_ps2RecompiledFunctionTable[478020] = njCnkCsUvh_0x2d25a0; // 0x2d2d18 - g_ps2RecompiledFunctionTable[478021] = njCnkCsUvh_0x2d25a0; // 0x2d2d1c - g_ps2RecompiledFunctionTable[478022] = njCnkCsUvh_0x2d25a0; // 0x2d2d20 - g_ps2RecompiledFunctionTable[478023] = njCnkCsUvh_0x2d25a0; // 0x2d2d24 - g_ps2RecompiledFunctionTable[478024] = njCnkCsUvh_0x2d25a0; // 0x2d2d28 - g_ps2RecompiledFunctionTable[478025] = njCnkCsUvh_0x2d25a0; // 0x2d2d2c - g_ps2RecompiledFunctionTable[478026] = njCnkCsUvh_0x2d25a0; // 0x2d2d30 - g_ps2RecompiledFunctionTable[478027] = njCnkCsUvh_0x2d25a0; // 0x2d2d34 - g_ps2RecompiledFunctionTable[478028] = njCnkCsUvh_0x2d25a0; // 0x2d2d38 - g_ps2RecompiledFunctionTable[478029] = njCnkCsUvh_0x2d25a0; // 0x2d2d3c - g_ps2RecompiledFunctionTable[478030] = njCnkCsUvh_0x2d25a0; // 0x2d2d40 - g_ps2RecompiledFunctionTable[478031] = njCnkCsUvh_0x2d25a0; // 0x2d2d44 - g_ps2RecompiledFunctionTable[478032] = njCnkCsUvh_0x2d25a0; // 0x2d2d48 - g_ps2RecompiledFunctionTable[478033] = njCnkCsUvh_0x2d25a0; // 0x2d2d4c - g_ps2RecompiledFunctionTable[478034] = njCnkCsUvh_0x2d25a0; // 0x2d2d50 - g_ps2RecompiledFunctionTable[478035] = njCnkCsUvh_0x2d25a0; // 0x2d2d54 - g_ps2RecompiledFunctionTable[478036] = njCnkCsUvh_0x2d25a0; // 0x2d2d58 - g_ps2RecompiledFunctionTable[478037] = njCnkCsUvh_0x2d25a0; // 0x2d2d5c - g_ps2RecompiledFunctionTable[478038] = njCnkCsUvh_0x2d25a0; // 0x2d2d60 - g_ps2RecompiledFunctionTable[478039] = njCnkCsUvh_0x2d25a0; // 0x2d2d64 - g_ps2RecompiledFunctionTable[478040] = njCnkCsUvh_0x2d25a0; // 0x2d2d68 - g_ps2RecompiledFunctionTable[478041] = njCnkCsUvh_0x2d25a0; // 0x2d2d6c - g_ps2RecompiledFunctionTable[478042] = njCnkCsUvh_0x2d25a0; // 0x2d2d70 - g_ps2RecompiledFunctionTable[478043] = njCnkCsUvh_0x2d25a0; // 0x2d2d74 - g_ps2RecompiledFunctionTable[478044] = njCnkCsUvh_0x2d25a0; // 0x2d2d78 - g_ps2RecompiledFunctionTable[478045] = njCnkCsUvh_0x2d25a0; // 0x2d2d7c - g_ps2RecompiledFunctionTable[478046] = njCnkCsUvh_0x2d25a0; // 0x2d2d80 - g_ps2RecompiledFunctionTable[478047] = njCnkCsUvh_0x2d25a0; // 0x2d2d84 - g_ps2RecompiledFunctionTable[478048] = njCnkCsUvh_0x2d25a0; // 0x2d2d88 - g_ps2RecompiledFunctionTable[478049] = njCnkCsUvh_0x2d25a0; // 0x2d2d8c - g_ps2RecompiledFunctionTable[478050] = njCnkCsUvh_0x2d25a0; // 0x2d2d90 - g_ps2RecompiledFunctionTable[478051] = njCnkCsUvh_0x2d25a0; // 0x2d2d94 - g_ps2RecompiledFunctionTable[478052] = njCnkCsUvh_0x2d25a0; // 0x2d2d98 - g_ps2RecompiledFunctionTable[478053] = njCnkCsUvh_0x2d25a0; // 0x2d2d9c - g_ps2RecompiledFunctionTable[478054] = njCnkCsUvh_0x2d25a0; // 0x2d2da0 - g_ps2RecompiledFunctionTable[478055] = njCnkCsUvh_0x2d25a0; // 0x2d2da4 - g_ps2RecompiledFunctionTable[478056] = njCnkCsUvh_0x2d25a0; // 0x2d2da8 - g_ps2RecompiledFunctionTable[478057] = njCnkCsUvh_0x2d25a0; // 0x2d2dac - g_ps2RecompiledFunctionTable[478058] = njCnkCsUvh_0x2d25a0; // 0x2d2db0 - g_ps2RecompiledFunctionTable[478059] = njCnkCsUvh_0x2d25a0; // 0x2d2db4 - g_ps2RecompiledFunctionTable[478060] = njCnkCsUvh_0x2d25a0; // 0x2d2db8 - g_ps2RecompiledFunctionTable[478061] = njCnkCsUvh_0x2d25a0; // 0x2d2dbc - g_ps2RecompiledFunctionTable[478062] = njCnkCsUvh_0x2d25a0; // 0x2d2dc0 - g_ps2RecompiledFunctionTable[478063] = njCnkCsUvh_0x2d25a0; // 0x2d2dc4 - g_ps2RecompiledFunctionTable[478064] = njCnkCsUvh_0x2d25a0; // 0x2d2dc8 - g_ps2RecompiledFunctionTable[478065] = njCnkCsUvh_0x2d25a0; // 0x2d2dcc - g_ps2RecompiledFunctionTable[478066] = njCnkCsUvh_0x2d25a0; // 0x2d2dd0 - g_ps2RecompiledFunctionTable[478067] = njCnkCsUvh_0x2d25a0; // 0x2d2dd4 - g_ps2RecompiledFunctionTable[478068] = njCnkCsUvh_0x2d25a0; // 0x2d2dd8 - g_ps2RecompiledFunctionTable[478069] = njCnkCsUvh_0x2d25a0; // 0x2d2ddc - g_ps2RecompiledFunctionTable[478070] = njCnkCsUvh_0x2d25a0; // 0x2d2de0 - g_ps2RecompiledFunctionTable[478071] = njCnkCsUvh_0x2d25a0; // 0x2d2de4 - g_ps2RecompiledFunctionTable[478072] = njCnkCsUvh_0x2d25a0; // 0x2d2de8 - g_ps2RecompiledFunctionTable[478073] = njCnkCsUvh_0x2d25a0; // 0x2d2dec - g_ps2RecompiledFunctionTable[478074] = njCnkCsUvh_0x2d25a0; // 0x2d2df0 - g_ps2RecompiledFunctionTable[478075] = njCnkCsUvh_0x2d25a0; // 0x2d2df4 - g_ps2RecompiledFunctionTable[478076] = njCnkCsUvh_0x2d25a0; // 0x2d2df8 - g_ps2RecompiledFunctionTable[478077] = njCnkCsUvh_0x2d25a0; // 0x2d2dfc - g_ps2RecompiledFunctionTable[478078] = njCnkCsUvh_0x2d25a0; // 0x2d2e00 - g_ps2RecompiledFunctionTable[478079] = njCnkCsUvh_0x2d25a0; // 0x2d2e04 - g_ps2RecompiledFunctionTable[478080] = njCnkCsUvh_0x2d25a0; // 0x2d2e08 - g_ps2RecompiledFunctionTable[478081] = njCnkCsUvh_0x2d25a0; // 0x2d2e0c - g_ps2RecompiledFunctionTable[478082] = njCnkCsUvh_0x2d25a0; // 0x2d2e10 - g_ps2RecompiledFunctionTable[478083] = njCnkCsUvh_0x2d25a0; // 0x2d2e14 - g_ps2RecompiledFunctionTable[478084] = njCnkCsUvh_0x2d25a0; // 0x2d2e18 - g_ps2RecompiledFunctionTable[478085] = njCnkCsUvh_0x2d25a0; // 0x2d2e1c - g_ps2RecompiledFunctionTable[478086] = njCnkCsUvh_0x2d25a0; // 0x2d2e20 - g_ps2RecompiledFunctionTable[478087] = njCnkCsUvh_0x2d25a0; // 0x2d2e24 - g_ps2RecompiledFunctionTable[478088] = njCnkCsUvh_0x2d25a0; // 0x2d2e28 - g_ps2RecompiledFunctionTable[478089] = njCnkCsUvh_0x2d25a0; // 0x2d2e2c - g_ps2RecompiledFunctionTable[478090] = njCnkCsUvh_0x2d25a0; // 0x2d2e30 - g_ps2RecompiledFunctionTable[478091] = njCnkCsUvh_0x2d25a0; // 0x2d2e34 - g_ps2RecompiledFunctionTable[478092] = njCnkCsUvh_0x2d25a0; // 0x2d2e38 - g_ps2RecompiledFunctionTable[478093] = njCnkCsUvh_0x2d25a0; // 0x2d2e3c - g_ps2RecompiledFunctionTable[478094] = njCnkCsUvh_0x2d25a0; // 0x2d2e40 - g_ps2RecompiledFunctionTable[478095] = njCnkCsUvh_0x2d25a0; // 0x2d2e44 - g_ps2RecompiledFunctionTable[478096] = njCnkCsUvh_0x2d25a0; // 0x2d2e48 - g_ps2RecompiledFunctionTable[478097] = njCnkCsUvh_0x2d25a0; // 0x2d2e4c - g_ps2RecompiledFunctionTable[478098] = njCnkCsUvh_0x2d25a0; // 0x2d2e50 - g_ps2RecompiledFunctionTable[478099] = njCnkCsUvh_0x2d25a0; // 0x2d2e54 - g_ps2RecompiledFunctionTable[478100] = njCnkCsUvh_0x2d25a0; // 0x2d2e58 - g_ps2RecompiledFunctionTable[478101] = njCnkCsUvh_0x2d25a0; // 0x2d2e5c - g_ps2RecompiledFunctionTable[478102] = njCnkCsUvh_0x2d25a0; // 0x2d2e60 - g_ps2RecompiledFunctionTable[478103] = njCnkCsUvh_0x2d25a0; // 0x2d2e64 - g_ps2RecompiledFunctionTable[478104] = njCnkCsUvh_0x2d25a0; // 0x2d2e68 - g_ps2RecompiledFunctionTable[478105] = njCnkCsUvh_0x2d25a0; // 0x2d2e6c - g_ps2RecompiledFunctionTable[478106] = njCnkCsUvh_0x2d25a0; // 0x2d2e70 - g_ps2RecompiledFunctionTable[478107] = njCnkCsUvh_0x2d25a0; // 0x2d2e74 - g_ps2RecompiledFunctionTable[478108] = njCnkCsUvh_0x2d25a0; // 0x2d2e78 - g_ps2RecompiledFunctionTable[478109] = njCnkCsUvh_0x2d25a0; // 0x2d2e7c - g_ps2RecompiledFunctionTable[478110] = njCnkCsUvh_0x2d25a0; // 0x2d2e80 - g_ps2RecompiledFunctionTable[478111] = njCnkCsUvh_0x2d25a0; // 0x2d2e84 - g_ps2RecompiledFunctionTable[478112] = njCnkCsUvh_0x2d25a0; // 0x2d2e88 - g_ps2RecompiledFunctionTable[478114] = njCnkCsUvn_0x2d2e90; // 0x2d2e90 - g_ps2RecompiledFunctionTable[478115] = njCnkCsUvn_0x2d2e90; // 0x2d2e94 - g_ps2RecompiledFunctionTable[478116] = njCnkCsUvn_0x2d2e90; // 0x2d2e98 - g_ps2RecompiledFunctionTable[478117] = njCnkCsUvn_0x2d2e90; // 0x2d2e9c - g_ps2RecompiledFunctionTable[478118] = njCnkCsUvn_0x2d2e90; // 0x2d2ea0 - g_ps2RecompiledFunctionTable[478119] = njCnkCsUvn_0x2d2e90; // 0x2d2ea4 - g_ps2RecompiledFunctionTable[478120] = njCnkCsUvn_0x2d2e90; // 0x2d2ea8 - g_ps2RecompiledFunctionTable[478121] = njCnkCsUvn_0x2d2e90; // 0x2d2eac - g_ps2RecompiledFunctionTable[478122] = njCnkCsUvn_0x2d2e90; // 0x2d2eb0 - g_ps2RecompiledFunctionTable[478123] = njCnkCsUvn_0x2d2e90; // 0x2d2eb4 - g_ps2RecompiledFunctionTable[478124] = njCnkCsUvn_0x2d2e90; // 0x2d2eb8 - g_ps2RecompiledFunctionTable[478125] = njCnkCsUvn_0x2d2e90; // 0x2d2ebc - g_ps2RecompiledFunctionTable[478126] = njCnkCsUvn_0x2d2e90; // 0x2d2ec0 - g_ps2RecompiledFunctionTable[478127] = njCnkCsUvn_0x2d2e90; // 0x2d2ec4 - g_ps2RecompiledFunctionTable[478128] = njCnkCsUvn_0x2d2e90; // 0x2d2ec8 - g_ps2RecompiledFunctionTable[478129] = njCnkCsUvn_0x2d2e90; // 0x2d2ecc - g_ps2RecompiledFunctionTable[478130] = njCnkCsUvn_0x2d2e90; // 0x2d2ed0 - g_ps2RecompiledFunctionTable[478131] = njCnkCsUvn_0x2d2e90; // 0x2d2ed4 - g_ps2RecompiledFunctionTable[478132] = njCnkCsUvn_0x2d2e90; // 0x2d2ed8 - g_ps2RecompiledFunctionTable[478133] = njCnkCsUvn_0x2d2e90; // 0x2d2edc - g_ps2RecompiledFunctionTable[478134] = njCnkCsUvn_0x2d2e90; // 0x2d2ee0 - g_ps2RecompiledFunctionTable[478135] = njCnkCsUvn_0x2d2e90; // 0x2d2ee4 - g_ps2RecompiledFunctionTable[478136] = njCnkCsUvn_0x2d2e90; // 0x2d2ee8 - g_ps2RecompiledFunctionTable[478137] = njCnkCsUvn_0x2d2e90; // 0x2d2eec - g_ps2RecompiledFunctionTable[478138] = njCnkCsUvn_0x2d2e90; // 0x2d2ef0 - g_ps2RecompiledFunctionTable[478139] = njCnkCsUvn_0x2d2e90; // 0x2d2ef4 - g_ps2RecompiledFunctionTable[478140] = njCnkCsUvn_0x2d2e90; // 0x2d2ef8 - g_ps2RecompiledFunctionTable[478141] = njCnkCsUvn_0x2d2e90; // 0x2d2efc - g_ps2RecompiledFunctionTable[478142] = njCnkCsUvn_0x2d2e90; // 0x2d2f00 - g_ps2RecompiledFunctionTable[478143] = njCnkCsUvn_0x2d2e90; // 0x2d2f04 - g_ps2RecompiledFunctionTable[478144] = njCnkCsUvn_0x2d2e90; // 0x2d2f08 - g_ps2RecompiledFunctionTable[478145] = njCnkCsUvn_0x2d2e90; // 0x2d2f0c - g_ps2RecompiledFunctionTable[478146] = njCnkCsUvn_0x2d2e90; // 0x2d2f10 - g_ps2RecompiledFunctionTable[478147] = njCnkCsUvn_0x2d2e90; // 0x2d2f14 - g_ps2RecompiledFunctionTable[478148] = njCnkCsUvn_0x2d2e90; // 0x2d2f18 - g_ps2RecompiledFunctionTable[478149] = njCnkCsUvn_0x2d2e90; // 0x2d2f1c - g_ps2RecompiledFunctionTable[478150] = njCnkCsUvn_0x2d2e90; // 0x2d2f20 - g_ps2RecompiledFunctionTable[478151] = njCnkCsUvn_0x2d2e90; // 0x2d2f24 - g_ps2RecompiledFunctionTable[478152] = njCnkCsUvn_0x2d2e90; // 0x2d2f28 - g_ps2RecompiledFunctionTable[478153] = njCnkCsUvn_0x2d2e90; // 0x2d2f2c - g_ps2RecompiledFunctionTable[478154] = njCnkCsUvn_0x2d2e90; // 0x2d2f30 - g_ps2RecompiledFunctionTable[478155] = njCnkCsUvn_0x2d2e90; // 0x2d2f34 - g_ps2RecompiledFunctionTable[478156] = njCnkCsUvn_0x2d2e90; // 0x2d2f38 - g_ps2RecompiledFunctionTable[478157] = njCnkCsUvn_0x2d2e90; // 0x2d2f3c - g_ps2RecompiledFunctionTable[478158] = njCnkCsUvn_0x2d2e90; // 0x2d2f40 - g_ps2RecompiledFunctionTable[478159] = njCnkCsUvn_0x2d2e90; // 0x2d2f44 - g_ps2RecompiledFunctionTable[478160] = njCnkCsUvn_0x2d2e90; // 0x2d2f48 - g_ps2RecompiledFunctionTable[478161] = njCnkCsUvn_0x2d2e90; // 0x2d2f4c - g_ps2RecompiledFunctionTable[478162] = njCnkCsUvn_0x2d2e90; // 0x2d2f50 - g_ps2RecompiledFunctionTable[478163] = njCnkCsUvn_0x2d2e90; // 0x2d2f54 - g_ps2RecompiledFunctionTable[478164] = njCnkCsUvn_0x2d2e90; // 0x2d2f58 - g_ps2RecompiledFunctionTable[478165] = njCnkCsUvn_0x2d2e90; // 0x2d2f5c - g_ps2RecompiledFunctionTable[478166] = njCnkCsUvn_0x2d2e90; // 0x2d2f60 - g_ps2RecompiledFunctionTable[478167] = njCnkCsUvn_0x2d2e90; // 0x2d2f64 - g_ps2RecompiledFunctionTable[478168] = njCnkCsUvn_0x2d2e90; // 0x2d2f68 - g_ps2RecompiledFunctionTable[478169] = njCnkCsUvn_0x2d2e90; // 0x2d2f6c - g_ps2RecompiledFunctionTable[478170] = njCnkCsUvn_0x2d2e90; // 0x2d2f70 - g_ps2RecompiledFunctionTable[478171] = njCnkCsUvn_0x2d2e90; // 0x2d2f74 - g_ps2RecompiledFunctionTable[478172] = njCnkCsUvn_0x2d2e90; // 0x2d2f78 - g_ps2RecompiledFunctionTable[478173] = njCnkCsUvn_0x2d2e90; // 0x2d2f7c - g_ps2RecompiledFunctionTable[478174] = njCnkCsUvn_0x2d2e90; // 0x2d2f80 - g_ps2RecompiledFunctionTable[478175] = njCnkCsUvn_0x2d2e90; // 0x2d2f84 - g_ps2RecompiledFunctionTable[478176] = njCnkCsUvn_0x2d2e90; // 0x2d2f88 - g_ps2RecompiledFunctionTable[478177] = njCnkCsUvn_0x2d2e90; // 0x2d2f8c - g_ps2RecompiledFunctionTable[478178] = njCnkCsUvn_0x2d2e90; // 0x2d2f90 - g_ps2RecompiledFunctionTable[478179] = njCnkCsUvn_0x2d2e90; // 0x2d2f94 - g_ps2RecompiledFunctionTable[478180] = njCnkCsUvn_0x2d2e90; // 0x2d2f98 - g_ps2RecompiledFunctionTable[478181] = njCnkCsUvn_0x2d2e90; // 0x2d2f9c - g_ps2RecompiledFunctionTable[478182] = njCnkCsUvn_0x2d2e90; // 0x2d2fa0 - g_ps2RecompiledFunctionTable[478183] = njCnkCsUvn_0x2d2e90; // 0x2d2fa4 - g_ps2RecompiledFunctionTable[478184] = njCnkCsUvn_0x2d2e90; // 0x2d2fa8 - g_ps2RecompiledFunctionTable[478185] = njCnkCsUvn_0x2d2e90; // 0x2d2fac - g_ps2RecompiledFunctionTable[478186] = njCnkCsUvn_0x2d2e90; // 0x2d2fb0 - g_ps2RecompiledFunctionTable[478187] = njCnkCsUvn_0x2d2e90; // 0x2d2fb4 - g_ps2RecompiledFunctionTable[478188] = njCnkCsUvn_0x2d2e90; // 0x2d2fb8 - g_ps2RecompiledFunctionTable[478189] = njCnkCsUvn_0x2d2e90; // 0x2d2fbc - g_ps2RecompiledFunctionTable[478190] = njCnkCsUvn_0x2d2e90; // 0x2d2fc0 - g_ps2RecompiledFunctionTable[478191] = njCnkCsUvn_0x2d2e90; // 0x2d2fc4 - g_ps2RecompiledFunctionTable[478192] = njCnkCsUvn_0x2d2e90; // 0x2d2fc8 - g_ps2RecompiledFunctionTable[478193] = njCnkCsUvn_0x2d2e90; // 0x2d2fcc - g_ps2RecompiledFunctionTable[478194] = njCnkCsUvn_0x2d2e90; // 0x2d2fd0 - g_ps2RecompiledFunctionTable[478195] = njCnkCsUvn_0x2d2e90; // 0x2d2fd4 - g_ps2RecompiledFunctionTable[478196] = njCnkCsUvn_0x2d2e90; // 0x2d2fd8 - g_ps2RecompiledFunctionTable[478197] = njCnkCsUvn_0x2d2e90; // 0x2d2fdc - g_ps2RecompiledFunctionTable[478198] = njCnkCsUvn_0x2d2e90; // 0x2d2fe0 - g_ps2RecompiledFunctionTable[478199] = njCnkCsUvn_0x2d2e90; // 0x2d2fe4 - g_ps2RecompiledFunctionTable[478200] = njCnkCsUvn_0x2d2e90; // 0x2d2fe8 - g_ps2RecompiledFunctionTable[478201] = njCnkCsUvn_0x2d2e90; // 0x2d2fec - g_ps2RecompiledFunctionTable[478202] = njCnkCsUvn_0x2d2e90; // 0x2d2ff0 - g_ps2RecompiledFunctionTable[478203] = njCnkCsUvn_0x2d2e90; // 0x2d2ff4 - g_ps2RecompiledFunctionTable[478204] = njCnkCsUvn_0x2d2e90; // 0x2d2ff8 - g_ps2RecompiledFunctionTable[478205] = njCnkCsUvn_0x2d2e90; // 0x2d2ffc - g_ps2RecompiledFunctionTable[478206] = njCnkCsUvn_0x2d2e90; // 0x2d3000 - g_ps2RecompiledFunctionTable[478207] = njCnkCsUvn_0x2d2e90; // 0x2d3004 - g_ps2RecompiledFunctionTable[478208] = njCnkCsUvn_0x2d2e90; // 0x2d3008 - g_ps2RecompiledFunctionTable[478209] = njCnkCsUvn_0x2d2e90; // 0x2d300c - g_ps2RecompiledFunctionTable[478210] = njCnkCsUvn_0x2d2e90; // 0x2d3010 - g_ps2RecompiledFunctionTable[478211] = njCnkCsUvn_0x2d2e90; // 0x2d3014 - g_ps2RecompiledFunctionTable[478212] = njCnkCsUvn_0x2d2e90; // 0x2d3018 - g_ps2RecompiledFunctionTable[478213] = njCnkCsUvn_0x2d2e90; // 0x2d301c - g_ps2RecompiledFunctionTable[478214] = njCnkCsUvn_0x2d2e90; // 0x2d3020 - g_ps2RecompiledFunctionTable[478215] = njCnkCsUvn_0x2d2e90; // 0x2d3024 - g_ps2RecompiledFunctionTable[478216] = njCnkCsUvn_0x2d2e90; // 0x2d3028 - g_ps2RecompiledFunctionTable[478217] = njCnkCsUvn_0x2d2e90; // 0x2d302c - g_ps2RecompiledFunctionTable[478218] = njCnkCsUvn_0x2d2e90; // 0x2d3030 - g_ps2RecompiledFunctionTable[478219] = njCnkCsUvn_0x2d2e90; // 0x2d3034 - g_ps2RecompiledFunctionTable[478220] = njCnkCsUvn_0x2d2e90; // 0x2d3038 - g_ps2RecompiledFunctionTable[478221] = njCnkCsUvn_0x2d2e90; // 0x2d303c - g_ps2RecompiledFunctionTable[478222] = njCnkCsUvn_0x2d2e90; // 0x2d3040 - g_ps2RecompiledFunctionTable[478223] = njCnkCsUvn_0x2d2e90; // 0x2d3044 - g_ps2RecompiledFunctionTable[478224] = njCnkCsUvn_0x2d2e90; // 0x2d3048 - g_ps2RecompiledFunctionTable[478225] = njCnkCsUvn_0x2d2e90; // 0x2d304c - g_ps2RecompiledFunctionTable[478226] = njCnkCsUvn_0x2d2e90; // 0x2d3050 - g_ps2RecompiledFunctionTable[478227] = njCnkCsUvn_0x2d2e90; // 0x2d3054 - g_ps2RecompiledFunctionTable[478228] = njCnkCsUvn_0x2d2e90; // 0x2d3058 - g_ps2RecompiledFunctionTable[478229] = njCnkCsUvn_0x2d2e90; // 0x2d305c - g_ps2RecompiledFunctionTable[478230] = njCnkCsUvn_0x2d2e90; // 0x2d3060 - g_ps2RecompiledFunctionTable[478231] = njCnkCsUvn_0x2d2e90; // 0x2d3064 - g_ps2RecompiledFunctionTable[478232] = njCnkCsUvn_0x2d2e90; // 0x2d3068 - g_ps2RecompiledFunctionTable[478233] = njCnkCsUvn_0x2d2e90; // 0x2d306c - g_ps2RecompiledFunctionTable[478234] = njCnkCsUvn_0x2d2e90; // 0x2d3070 - g_ps2RecompiledFunctionTable[478235] = njCnkCsUvn_0x2d2e90; // 0x2d3074 - g_ps2RecompiledFunctionTable[478236] = njCnkCsUvn_0x2d2e90; // 0x2d3078 - g_ps2RecompiledFunctionTable[478237] = njCnkCsUvn_0x2d2e90; // 0x2d307c - g_ps2RecompiledFunctionTable[478238] = njCnkCsUvn_0x2d2e90; // 0x2d3080 - g_ps2RecompiledFunctionTable[478239] = njCnkCsUvn_0x2d2e90; // 0x2d3084 - g_ps2RecompiledFunctionTable[478240] = njCnkCsUvn_0x2d2e90; // 0x2d3088 - g_ps2RecompiledFunctionTable[478241] = njCnkCsUvn_0x2d2e90; // 0x2d308c - g_ps2RecompiledFunctionTable[478242] = njCnkCsUvn_0x2d2e90; // 0x2d3090 - g_ps2RecompiledFunctionTable[478243] = njCnkCsUvn_0x2d2e90; // 0x2d3094 - g_ps2RecompiledFunctionTable[478244] = njCnkCsUvn_0x2d2e90; // 0x2d3098 - g_ps2RecompiledFunctionTable[478245] = njCnkCsUvn_0x2d2e90; // 0x2d309c - g_ps2RecompiledFunctionTable[478246] = njCnkCsUvn_0x2d2e90; // 0x2d30a0 - g_ps2RecompiledFunctionTable[478247] = njCnkCsUvn_0x2d2e90; // 0x2d30a4 - g_ps2RecompiledFunctionTable[478248] = njCnkCsUvn_0x2d2e90; // 0x2d30a8 - g_ps2RecompiledFunctionTable[478249] = njCnkCsUvn_0x2d2e90; // 0x2d30ac - g_ps2RecompiledFunctionTable[478250] = njCnkCsUvn_0x2d2e90; // 0x2d30b0 - g_ps2RecompiledFunctionTable[478251] = njCnkCsUvn_0x2d2e90; // 0x2d30b4 - g_ps2RecompiledFunctionTable[478252] = njCnkCsUvn_0x2d2e90; // 0x2d30b8 - g_ps2RecompiledFunctionTable[478253] = njCnkCsUvn_0x2d2e90; // 0x2d30bc - g_ps2RecompiledFunctionTable[478254] = njCnkCsUvn_0x2d2e90; // 0x2d30c0 - g_ps2RecompiledFunctionTable[478255] = njCnkCsUvn_0x2d2e90; // 0x2d30c4 - g_ps2RecompiledFunctionTable[478256] = njCnkCsUvn_0x2d2e90; // 0x2d30c8 - g_ps2RecompiledFunctionTable[478257] = njCnkCsUvn_0x2d2e90; // 0x2d30cc - g_ps2RecompiledFunctionTable[478258] = njCnkCsUvn_0x2d2e90; // 0x2d30d0 - g_ps2RecompiledFunctionTable[478259] = njCnkCsUvn_0x2d2e90; // 0x2d30d4 - g_ps2RecompiledFunctionTable[478260] = njCnkCsUvn_0x2d2e90; // 0x2d30d8 - g_ps2RecompiledFunctionTable[478261] = njCnkCsUvn_0x2d2e90; // 0x2d30dc - g_ps2RecompiledFunctionTable[478262] = njCnkCsUvn_0x2d2e90; // 0x2d30e0 - g_ps2RecompiledFunctionTable[478263] = njCnkCsUvn_0x2d2e90; // 0x2d30e4 - g_ps2RecompiledFunctionTable[478264] = njCnkCsUvn_0x2d2e90; // 0x2d30e8 - g_ps2RecompiledFunctionTable[478265] = njCnkCsUvn_0x2d2e90; // 0x2d30ec - g_ps2RecompiledFunctionTable[478266] = njCnkCsUvn_0x2d2e90; // 0x2d30f0 - g_ps2RecompiledFunctionTable[478267] = njCnkCsUvn_0x2d2e90; // 0x2d30f4 - g_ps2RecompiledFunctionTable[478268] = njCnkCsUvn_0x2d2e90; // 0x2d30f8 - g_ps2RecompiledFunctionTable[478269] = njCnkCsUvn_0x2d2e90; // 0x2d30fc - g_ps2RecompiledFunctionTable[478270] = njCnkCsUvn_0x2d2e90; // 0x2d3100 - g_ps2RecompiledFunctionTable[478271] = njCnkCsUvn_0x2d2e90; // 0x2d3104 - g_ps2RecompiledFunctionTable[478272] = njCnkCsUvn_0x2d2e90; // 0x2d3108 - g_ps2RecompiledFunctionTable[478273] = njCnkCsUvn_0x2d2e90; // 0x2d310c - g_ps2RecompiledFunctionTable[478274] = njCnkCsUvn_0x2d2e90; // 0x2d3110 - g_ps2RecompiledFunctionTable[478275] = njCnkCsUvn_0x2d2e90; // 0x2d3114 - g_ps2RecompiledFunctionTable[478276] = njCnkCsUvn_0x2d2e90; // 0x2d3118 - g_ps2RecompiledFunctionTable[478277] = njCnkCsUvn_0x2d2e90; // 0x2d311c - g_ps2RecompiledFunctionTable[478278] = njCnkCsUvn_0x2d2e90; // 0x2d3120 - g_ps2RecompiledFunctionTable[478279] = njCnkCsUvn_0x2d2e90; // 0x2d3124 - g_ps2RecompiledFunctionTable[478280] = njCnkCsUvn_0x2d2e90; // 0x2d3128 - g_ps2RecompiledFunctionTable[478281] = njCnkCsUvn_0x2d2e90; // 0x2d312c - g_ps2RecompiledFunctionTable[478282] = njCnkCsUvn_0x2d2e90; // 0x2d3130 - g_ps2RecompiledFunctionTable[478283] = njCnkCsUvn_0x2d2e90; // 0x2d3134 - g_ps2RecompiledFunctionTable[478284] = njCnkCsUvn_0x2d2e90; // 0x2d3138 - g_ps2RecompiledFunctionTable[478285] = njCnkCsUvn_0x2d2e90; // 0x2d313c - g_ps2RecompiledFunctionTable[478286] = njCnkCsUvn_0x2d2e90; // 0x2d3140 - g_ps2RecompiledFunctionTable[478287] = njCnkCsUvn_0x2d2e90; // 0x2d3144 - g_ps2RecompiledFunctionTable[478288] = njCnkCsUvn_0x2d2e90; // 0x2d3148 - g_ps2RecompiledFunctionTable[478289] = njCnkCsUvn_0x2d2e90; // 0x2d314c - g_ps2RecompiledFunctionTable[478290] = njCnkCsUvn_0x2d2e90; // 0x2d3150 - g_ps2RecompiledFunctionTable[478291] = njCnkCsUvn_0x2d2e90; // 0x2d3154 - g_ps2RecompiledFunctionTable[478292] = njCnkCsUvn_0x2d2e90; // 0x2d3158 - g_ps2RecompiledFunctionTable[478293] = njCnkCsUvn_0x2d2e90; // 0x2d315c - g_ps2RecompiledFunctionTable[478294] = njCnkCsUvn_0x2d2e90; // 0x2d3160 - g_ps2RecompiledFunctionTable[478295] = njCnkCsUvn_0x2d2e90; // 0x2d3164 - g_ps2RecompiledFunctionTable[478296] = njCnkCsUvn_0x2d2e90; // 0x2d3168 - g_ps2RecompiledFunctionTable[478297] = njCnkCsUvn_0x2d2e90; // 0x2d316c - g_ps2RecompiledFunctionTable[478298] = njCnkCsUvn_0x2d2e90; // 0x2d3170 - g_ps2RecompiledFunctionTable[478299] = njCnkCsUvn_0x2d2e90; // 0x2d3174 - g_ps2RecompiledFunctionTable[478300] = njCnkCsUvn_0x2d2e90; // 0x2d3178 - g_ps2RecompiledFunctionTable[478301] = njCnkCsUvn_0x2d2e90; // 0x2d317c - g_ps2RecompiledFunctionTable[478302] = njCnkCsUvn_0x2d2e90; // 0x2d3180 - g_ps2RecompiledFunctionTable[478303] = njCnkCsUvn_0x2d2e90; // 0x2d3184 - g_ps2RecompiledFunctionTable[478304] = njCnkCsUvn_0x2d2e90; // 0x2d3188 - g_ps2RecompiledFunctionTable[478305] = njCnkCsUvn_0x2d2e90; // 0x2d318c - g_ps2RecompiledFunctionTable[478306] = njCnkCsUvn_0x2d2e90; // 0x2d3190 - g_ps2RecompiledFunctionTable[478307] = njCnkCsUvn_0x2d2e90; // 0x2d3194 - g_ps2RecompiledFunctionTable[478308] = njCnkCsUvn_0x2d2e90; // 0x2d3198 - g_ps2RecompiledFunctionTable[478309] = njCnkCsUvn_0x2d2e90; // 0x2d319c - g_ps2RecompiledFunctionTable[478310] = njCnkCsUvn_0x2d2e90; // 0x2d31a0 - g_ps2RecompiledFunctionTable[478311] = njCnkCsUvn_0x2d2e90; // 0x2d31a4 - g_ps2RecompiledFunctionTable[478312] = njCnkCsUvn_0x2d2e90; // 0x2d31a8 - g_ps2RecompiledFunctionTable[478313] = njCnkCsUvn_0x2d2e90; // 0x2d31ac - g_ps2RecompiledFunctionTable[478314] = njCnkCsUvn_0x2d2e90; // 0x2d31b0 - g_ps2RecompiledFunctionTable[478315] = njCnkCsUvn_0x2d2e90; // 0x2d31b4 - g_ps2RecompiledFunctionTable[478316] = njCnkCsUvn_0x2d2e90; // 0x2d31b8 - g_ps2RecompiledFunctionTable[478317] = njCnkCsUvn_0x2d2e90; // 0x2d31bc - g_ps2RecompiledFunctionTable[478318] = njCnkCsUvn_0x2d2e90; // 0x2d31c0 - g_ps2RecompiledFunctionTable[478319] = njCnkCsUvn_0x2d2e90; // 0x2d31c4 - g_ps2RecompiledFunctionTable[478320] = njCnkCsUvn_0x2d2e90; // 0x2d31c8 - g_ps2RecompiledFunctionTable[478321] = njCnkCsUvn_0x2d2e90; // 0x2d31cc - g_ps2RecompiledFunctionTable[478322] = njCnkCsUvn_0x2d2e90; // 0x2d31d0 - g_ps2RecompiledFunctionTable[478323] = njCnkCsUvn_0x2d2e90; // 0x2d31d4 - g_ps2RecompiledFunctionTable[478324] = njCnkCsUvn_0x2d2e90; // 0x2d31d8 - g_ps2RecompiledFunctionTable[478325] = njCnkCsUvn_0x2d2e90; // 0x2d31dc - g_ps2RecompiledFunctionTable[478326] = njCnkCsUvn_0x2d2e90; // 0x2d31e0 - g_ps2RecompiledFunctionTable[478327] = njCnkCsUvn_0x2d2e90; // 0x2d31e4 - g_ps2RecompiledFunctionTable[478328] = njCnkCsUvn_0x2d2e90; // 0x2d31e8 - g_ps2RecompiledFunctionTable[478329] = njCnkCsUvn_0x2d2e90; // 0x2d31ec - g_ps2RecompiledFunctionTable[478330] = njCnkCsUvn_0x2d2e90; // 0x2d31f0 - g_ps2RecompiledFunctionTable[478331] = njCnkCsUvn_0x2d2e90; // 0x2d31f4 - g_ps2RecompiledFunctionTable[478332] = njCnkCsUvn_0x2d2e90; // 0x2d31f8 - g_ps2RecompiledFunctionTable[478333] = njCnkCsUvn_0x2d2e90; // 0x2d31fc - g_ps2RecompiledFunctionTable[478334] = njCnkCsUvn_0x2d2e90; // 0x2d3200 - g_ps2RecompiledFunctionTable[478335] = njCnkCsUvn_0x2d2e90; // 0x2d3204 - g_ps2RecompiledFunctionTable[478336] = njCnkCsUvn_0x2d2e90; // 0x2d3208 - g_ps2RecompiledFunctionTable[478337] = njCnkCsUvn_0x2d2e90; // 0x2d320c - g_ps2RecompiledFunctionTable[478338] = njCnkCsUvn_0x2d2e90; // 0x2d3210 - g_ps2RecompiledFunctionTable[478339] = njCnkCsUvn_0x2d2e90; // 0x2d3214 - g_ps2RecompiledFunctionTable[478340] = njCnkCsUvn_0x2d2e90; // 0x2d3218 - g_ps2RecompiledFunctionTable[478341] = njCnkCsUvn_0x2d2e90; // 0x2d321c - g_ps2RecompiledFunctionTable[478342] = njCnkCsUvn_0x2d2e90; // 0x2d3220 - g_ps2RecompiledFunctionTable[478343] = njCnkCsUvn_0x2d2e90; // 0x2d3224 - g_ps2RecompiledFunctionTable[478344] = njCnkCsUvn_0x2d2e90; // 0x2d3228 - g_ps2RecompiledFunctionTable[478345] = njCnkCsUvn_0x2d2e90; // 0x2d322c - g_ps2RecompiledFunctionTable[478346] = njCnkCsUvn_0x2d2e90; // 0x2d3230 - g_ps2RecompiledFunctionTable[478347] = njCnkCsUvn_0x2d2e90; // 0x2d3234 - g_ps2RecompiledFunctionTable[478348] = njCnkCsUvn_0x2d2e90; // 0x2d3238 - g_ps2RecompiledFunctionTable[478349] = njCnkCsUvn_0x2d2e90; // 0x2d323c - g_ps2RecompiledFunctionTable[478350] = njCnkCsUvn_0x2d2e90; // 0x2d3240 - g_ps2RecompiledFunctionTable[478351] = njCnkCsUvn_0x2d2e90; // 0x2d3244 - g_ps2RecompiledFunctionTable[478352] = njCnkCsUvn_0x2d2e90; // 0x2d3248 - g_ps2RecompiledFunctionTable[478353] = njCnkCsUvn_0x2d2e90; // 0x2d324c - g_ps2RecompiledFunctionTable[478354] = njCnkCsUvn_0x2d2e90; // 0x2d3250 - g_ps2RecompiledFunctionTable[478355] = njCnkCsUvn_0x2d2e90; // 0x2d3254 - g_ps2RecompiledFunctionTable[478356] = njCnkCsUvn_0x2d2e90; // 0x2d3258 - g_ps2RecompiledFunctionTable[478357] = njCnkCsUvn_0x2d2e90; // 0x2d325c - g_ps2RecompiledFunctionTable[478358] = njCnkCsUvn_0x2d2e90; // 0x2d3260 - g_ps2RecompiledFunctionTable[478359] = njCnkCsUvn_0x2d2e90; // 0x2d3264 - g_ps2RecompiledFunctionTable[478360] = njCnkCsUvn_0x2d2e90; // 0x2d3268 - g_ps2RecompiledFunctionTable[478361] = njCnkCsUvn_0x2d2e90; // 0x2d326c - g_ps2RecompiledFunctionTable[478362] = njCnkCsUvn_0x2d2e90; // 0x2d3270 - g_ps2RecompiledFunctionTable[478363] = njCnkCsUvn_0x2d2e90; // 0x2d3274 - g_ps2RecompiledFunctionTable[478364] = njCnkCsUvn_0x2d2e90; // 0x2d3278 - g_ps2RecompiledFunctionTable[478365] = njCnkCsUvn_0x2d2e90; // 0x2d327c - g_ps2RecompiledFunctionTable[478366] = njCnkCsUvn_0x2d2e90; // 0x2d3280 - g_ps2RecompiledFunctionTable[478367] = njCnkCsUvn_0x2d2e90; // 0x2d3284 - g_ps2RecompiledFunctionTable[478368] = njCnkCsUvn_0x2d2e90; // 0x2d3288 - g_ps2RecompiledFunctionTable[478369] = njCnkCsUvn_0x2d2e90; // 0x2d328c - g_ps2RecompiledFunctionTable[478370] = njCnkCsUvn_0x2d2e90; // 0x2d3290 - g_ps2RecompiledFunctionTable[478371] = njCnkCsUvn_0x2d2e90; // 0x2d3294 - g_ps2RecompiledFunctionTable[478372] = njCnkCsUvn_0x2d2e90; // 0x2d3298 - g_ps2RecompiledFunctionTable[478373] = njCnkCsUvn_0x2d2e90; // 0x2d329c - g_ps2RecompiledFunctionTable[478374] = njCnkCsUvn_0x2d2e90; // 0x2d32a0 - g_ps2RecompiledFunctionTable[478375] = njCnkCsUvn_0x2d2e90; // 0x2d32a4 - g_ps2RecompiledFunctionTable[478376] = njCnkCsUvn_0x2d2e90; // 0x2d32a8 - g_ps2RecompiledFunctionTable[478377] = njCnkCsUvn_0x2d2e90; // 0x2d32ac - g_ps2RecompiledFunctionTable[478378] = njCnkCsUvn_0x2d2e90; // 0x2d32b0 - g_ps2RecompiledFunctionTable[478379] = njCnkCsUvn_0x2d2e90; // 0x2d32b4 - g_ps2RecompiledFunctionTable[478380] = njCnkCsUvn_0x2d2e90; // 0x2d32b8 - g_ps2RecompiledFunctionTable[478381] = njCnkCsUvn_0x2d2e90; // 0x2d32bc - g_ps2RecompiledFunctionTable[478382] = njCnkCsUvn_0x2d2e90; // 0x2d32c0 - g_ps2RecompiledFunctionTable[478383] = njCnkCsUvn_0x2d2e90; // 0x2d32c4 - g_ps2RecompiledFunctionTable[478384] = njCnkCsUvn_0x2d2e90; // 0x2d32c8 - g_ps2RecompiledFunctionTable[478385] = njCnkCsUvn_0x2d2e90; // 0x2d32cc - g_ps2RecompiledFunctionTable[478386] = njCnkCsUvn_0x2d2e90; // 0x2d32d0 - g_ps2RecompiledFunctionTable[478387] = njCnkCsUvn_0x2d2e90; // 0x2d32d4 - g_ps2RecompiledFunctionTable[478388] = njCnkCsUvn_0x2d2e90; // 0x2d32d8 - g_ps2RecompiledFunctionTable[478389] = njCnkCsUvn_0x2d2e90; // 0x2d32dc - g_ps2RecompiledFunctionTable[478390] = njCnkCsUvn_0x2d2e90; // 0x2d32e0 - g_ps2RecompiledFunctionTable[478391] = njCnkCsUvn_0x2d2e90; // 0x2d32e4 - g_ps2RecompiledFunctionTable[478392] = njCnkCsUvn_0x2d2e90; // 0x2d32e8 - g_ps2RecompiledFunctionTable[478393] = njCnkCsUvn_0x2d2e90; // 0x2d32ec - g_ps2RecompiledFunctionTable[478394] = njCnkCsUvn_0x2d2e90; // 0x2d32f0 - g_ps2RecompiledFunctionTable[478395] = njCnkCsUvn_0x2d2e90; // 0x2d32f4 - g_ps2RecompiledFunctionTable[478396] = njCnkCsUvn_0x2d2e90; // 0x2d32f8 - g_ps2RecompiledFunctionTable[478397] = njCnkCsUvn_0x2d2e90; // 0x2d32fc - g_ps2RecompiledFunctionTable[478398] = njCnkCsUvn_0x2d2e90; // 0x2d3300 - g_ps2RecompiledFunctionTable[478399] = njCnkCsUvn_0x2d2e90; // 0x2d3304 - g_ps2RecompiledFunctionTable[478400] = njCnkCsUvn_0x2d2e90; // 0x2d3308 - g_ps2RecompiledFunctionTable[478401] = njCnkCsUvn_0x2d2e90; // 0x2d330c - g_ps2RecompiledFunctionTable[478402] = njCnkCsUvn_0x2d2e90; // 0x2d3310 - g_ps2RecompiledFunctionTable[478403] = njCnkCsUvn_0x2d2e90; // 0x2d3314 - g_ps2RecompiledFunctionTable[478404] = njCnkCsUvn_0x2d2e90; // 0x2d3318 - g_ps2RecompiledFunctionTable[478405] = njCnkCsUvn_0x2d2e90; // 0x2d331c - g_ps2RecompiledFunctionTable[478406] = njCnkCsUvn_0x2d2e90; // 0x2d3320 - g_ps2RecompiledFunctionTable[478407] = njCnkCsUvn_0x2d2e90; // 0x2d3324 - g_ps2RecompiledFunctionTable[478408] = njCnkCsUvn_0x2d2e90; // 0x2d3328 - g_ps2RecompiledFunctionTable[478409] = njCnkCsUvn_0x2d2e90; // 0x2d332c - g_ps2RecompiledFunctionTable[478410] = njCnkCsUvn_0x2d2e90; // 0x2d3330 - g_ps2RecompiledFunctionTable[478411] = njCnkCsUvn_0x2d2e90; // 0x2d3334 - g_ps2RecompiledFunctionTable[478412] = njCnkCsUvn_0x2d2e90; // 0x2d3338 - g_ps2RecompiledFunctionTable[478413] = njCnkCsUvn_0x2d2e90; // 0x2d333c - g_ps2RecompiledFunctionTable[478414] = njCnkCsUvn_0x2d2e90; // 0x2d3340 - g_ps2RecompiledFunctionTable[478415] = njCnkCsUvn_0x2d2e90; // 0x2d3344 - g_ps2RecompiledFunctionTable[478416] = njCnkCsUvn_0x2d2e90; // 0x2d3348 - g_ps2RecompiledFunctionTable[478417] = njCnkCsUvn_0x2d2e90; // 0x2d334c - g_ps2RecompiledFunctionTable[478418] = njCnkCsUvn_0x2d2e90; // 0x2d3350 - g_ps2RecompiledFunctionTable[478419] = njCnkCsUvn_0x2d2e90; // 0x2d3354 - g_ps2RecompiledFunctionTable[478420] = njCnkCsUvn_0x2d2e90; // 0x2d3358 - g_ps2RecompiledFunctionTable[478421] = njCnkCsUvn_0x2d2e90; // 0x2d335c - g_ps2RecompiledFunctionTable[478422] = njCnkCsUvn_0x2d2e90; // 0x2d3360 - g_ps2RecompiledFunctionTable[478423] = njCnkCsUvn_0x2d2e90; // 0x2d3364 - g_ps2RecompiledFunctionTable[478424] = njCnkCsUvn_0x2d2e90; // 0x2d3368 - g_ps2RecompiledFunctionTable[478425] = njCnkCsUvn_0x2d2e90; // 0x2d336c - g_ps2RecompiledFunctionTable[478426] = njCnkCsUvn_0x2d2e90; // 0x2d3370 - g_ps2RecompiledFunctionTable[478427] = njCnkCsUvn_0x2d2e90; // 0x2d3374 - g_ps2RecompiledFunctionTable[478428] = njCnkCsUvn_0x2d2e90; // 0x2d3378 - g_ps2RecompiledFunctionTable[478429] = njCnkCsUvn_0x2d2e90; // 0x2d337c - g_ps2RecompiledFunctionTable[478430] = njCnkCsUvn_0x2d2e90; // 0x2d3380 - g_ps2RecompiledFunctionTable[478431] = njCnkCsUvn_0x2d2e90; // 0x2d3384 - g_ps2RecompiledFunctionTable[478432] = njCnkCsUvn_0x2d2e90; // 0x2d3388 - g_ps2RecompiledFunctionTable[478433] = njCnkCsUvn_0x2d2e90; // 0x2d338c - g_ps2RecompiledFunctionTable[478434] = njCnkCsUvn_0x2d2e90; // 0x2d3390 - g_ps2RecompiledFunctionTable[478435] = njCnkCsUvn_0x2d2e90; // 0x2d3394 - g_ps2RecompiledFunctionTable[478436] = njCnkCsUvn_0x2d2e90; // 0x2d3398 - g_ps2RecompiledFunctionTable[478437] = njCnkCsUvn_0x2d2e90; // 0x2d339c - g_ps2RecompiledFunctionTable[478438] = njCnkCsUvn_0x2d2e90; // 0x2d33a0 - g_ps2RecompiledFunctionTable[478439] = njCnkCsUvn_0x2d2e90; // 0x2d33a4 - g_ps2RecompiledFunctionTable[478440] = njCnkCsUvn_0x2d2e90; // 0x2d33a8 - g_ps2RecompiledFunctionTable[478441] = njCnkCsUvn_0x2d2e90; // 0x2d33ac - g_ps2RecompiledFunctionTable[478442] = njCnkCsUvn_0x2d2e90; // 0x2d33b0 - g_ps2RecompiledFunctionTable[478443] = njCnkCsUvn_0x2d2e90; // 0x2d33b4 - g_ps2RecompiledFunctionTable[478444] = njCnkCsUvn_0x2d2e90; // 0x2d33b8 - g_ps2RecompiledFunctionTable[478445] = njCnkCsUvn_0x2d2e90; // 0x2d33bc - g_ps2RecompiledFunctionTable[478446] = njCnkCsUvn_0x2d2e90; // 0x2d33c0 - g_ps2RecompiledFunctionTable[478447] = njCnkCsUvn_0x2d2e90; // 0x2d33c4 - g_ps2RecompiledFunctionTable[478448] = njCnkCsUvn_0x2d2e90; // 0x2d33c8 - g_ps2RecompiledFunctionTable[478449] = njCnkCsUvn_0x2d2e90; // 0x2d33cc - g_ps2RecompiledFunctionTable[478450] = njCnkCsUvn_0x2d2e90; // 0x2d33d0 - g_ps2RecompiledFunctionTable[478451] = njCnkCsUvn_0x2d2e90; // 0x2d33d4 - g_ps2RecompiledFunctionTable[478452] = njCnkCsUvn_0x2d2e90; // 0x2d33d8 - g_ps2RecompiledFunctionTable[478453] = njCnkCsUvn_0x2d2e90; // 0x2d33dc - g_ps2RecompiledFunctionTable[478454] = njCnkCsUvn_0x2d2e90; // 0x2d33e0 - g_ps2RecompiledFunctionTable[478455] = njCnkCsUvn_0x2d2e90; // 0x2d33e4 - g_ps2RecompiledFunctionTable[478456] = njCnkCsUvn_0x2d2e90; // 0x2d33e8 - g_ps2RecompiledFunctionTable[478457] = njCnkCsUvn_0x2d2e90; // 0x2d33ec - g_ps2RecompiledFunctionTable[478458] = njCnkCsUvn_0x2d2e90; // 0x2d33f0 - g_ps2RecompiledFunctionTable[478459] = njCnkCsUvn_0x2d2e90; // 0x2d33f4 - g_ps2RecompiledFunctionTable[478460] = njCnkCsUvn_0x2d2e90; // 0x2d33f8 - g_ps2RecompiledFunctionTable[478461] = njCnkCsUvn_0x2d2e90; // 0x2d33fc - g_ps2RecompiledFunctionTable[478462] = njCnkCsUvn_0x2d2e90; // 0x2d3400 - g_ps2RecompiledFunctionTable[478463] = njCnkCsUvn_0x2d2e90; // 0x2d3404 - g_ps2RecompiledFunctionTable[478464] = njCnkCsUvn_0x2d2e90; // 0x2d3408 - g_ps2RecompiledFunctionTable[478465] = njCnkCsUvn_0x2d2e90; // 0x2d340c - g_ps2RecompiledFunctionTable[478466] = njCnkCsUvn_0x2d2e90; // 0x2d3410 - g_ps2RecompiledFunctionTable[478467] = njCnkCsUvn_0x2d2e90; // 0x2d3414 - g_ps2RecompiledFunctionTable[478468] = njCnkCsUvn_0x2d2e90; // 0x2d3418 - g_ps2RecompiledFunctionTable[478469] = njCnkCsUvn_0x2d2e90; // 0x2d341c - g_ps2RecompiledFunctionTable[478470] = njCnkCsUvn_0x2d2e90; // 0x2d3420 - g_ps2RecompiledFunctionTable[478471] = njCnkCsUvn_0x2d2e90; // 0x2d3424 - g_ps2RecompiledFunctionTable[478472] = njCnkCsUvn_0x2d2e90; // 0x2d3428 - g_ps2RecompiledFunctionTable[478473] = njCnkCsUvn_0x2d2e90; // 0x2d342c - g_ps2RecompiledFunctionTable[478474] = njCnkCsUvn_0x2d2e90; // 0x2d3430 - g_ps2RecompiledFunctionTable[478475] = njCnkCsUvn_0x2d2e90; // 0x2d3434 - g_ps2RecompiledFunctionTable[478476] = njCnkCsUvn_0x2d2e90; // 0x2d3438 - g_ps2RecompiledFunctionTable[478477] = njCnkCsUvn_0x2d2e90; // 0x2d343c - g_ps2RecompiledFunctionTable[478478] = njCnkCsUvn_0x2d2e90; // 0x2d3440 - g_ps2RecompiledFunctionTable[478479] = njCnkCsUvn_0x2d2e90; // 0x2d3444 - g_ps2RecompiledFunctionTable[478480] = njCnkCsUvn_0x2d2e90; // 0x2d3448 - g_ps2RecompiledFunctionTable[478481] = njCnkCsUvn_0x2d2e90; // 0x2d344c - g_ps2RecompiledFunctionTable[478482] = njCnkCsUvn_0x2d2e90; // 0x2d3450 - g_ps2RecompiledFunctionTable[478483] = njCnkCsUvn_0x2d2e90; // 0x2d3454 - g_ps2RecompiledFunctionTable[478484] = njCnkCsUvn_0x2d2e90; // 0x2d3458 - g_ps2RecompiledFunctionTable[478485] = njCnkCsUvn_0x2d2e90; // 0x2d345c - g_ps2RecompiledFunctionTable[478486] = njCnkCsUvn_0x2d2e90; // 0x2d3460 - g_ps2RecompiledFunctionTable[478487] = njCnkCsUvn_0x2d2e90; // 0x2d3464 - g_ps2RecompiledFunctionTable[478488] = njCnkCsUvn_0x2d2e90; // 0x2d3468 - g_ps2RecompiledFunctionTable[478489] = njCnkCsUvn_0x2d2e90; // 0x2d346c - g_ps2RecompiledFunctionTable[478490] = njCnkCsUvn_0x2d2e90; // 0x2d3470 - g_ps2RecompiledFunctionTable[478491] = njCnkCsUvn_0x2d2e90; // 0x2d3474 - g_ps2RecompiledFunctionTable[478492] = njCnkCsUvn_0x2d2e90; // 0x2d3478 - g_ps2RecompiledFunctionTable[478493] = njCnkCsUvn_0x2d2e90; // 0x2d347c - g_ps2RecompiledFunctionTable[478494] = njCnkCsUvn_0x2d2e90; // 0x2d3480 - g_ps2RecompiledFunctionTable[478495] = njCnkCsUvn_0x2d2e90; // 0x2d3484 - g_ps2RecompiledFunctionTable[478496] = njCnkCsUvn_0x2d2e90; // 0x2d3488 - g_ps2RecompiledFunctionTable[478497] = njCnkCsUvn_0x2d2e90; // 0x2d348c - g_ps2RecompiledFunctionTable[478498] = njCnkCsUvn_0x2d2e90; // 0x2d3490 - g_ps2RecompiledFunctionTable[478499] = njCnkCsUvn_0x2d2e90; // 0x2d3494 - g_ps2RecompiledFunctionTable[478500] = njCnkCsUvn_0x2d2e90; // 0x2d3498 - g_ps2RecompiledFunctionTable[478501] = njCnkCsUvn_0x2d2e90; // 0x2d349c - g_ps2RecompiledFunctionTable[478502] = njCnkCsUvn_0x2d2e90; // 0x2d34a0 - g_ps2RecompiledFunctionTable[478503] = njCnkCsUvn_0x2d2e90; // 0x2d34a4 - g_ps2RecompiledFunctionTable[478504] = njCnkCsUvn_0x2d2e90; // 0x2d34a8 - g_ps2RecompiledFunctionTable[478505] = njCnkCsUvn_0x2d2e90; // 0x2d34ac - g_ps2RecompiledFunctionTable[478506] = njCnkCsUvn_0x2d2e90; // 0x2d34b0 - g_ps2RecompiledFunctionTable[478507] = njCnkCsUvn_0x2d2e90; // 0x2d34b4 - g_ps2RecompiledFunctionTable[478508] = njCnkCsUvn_0x2d2e90; // 0x2d34b8 - g_ps2RecompiledFunctionTable[478509] = njCnkCsUvn_0x2d2e90; // 0x2d34bc - g_ps2RecompiledFunctionTable[478510] = njCnkCsUvn_0x2d2e90; // 0x2d34c0 - g_ps2RecompiledFunctionTable[478511] = njCnkCsUvn_0x2d2e90; // 0x2d34c4 - g_ps2RecompiledFunctionTable[478512] = njCnkCsUvn_0x2d2e90; // 0x2d34c8 - g_ps2RecompiledFunctionTable[478513] = njCnkCsUvn_0x2d2e90; // 0x2d34cc - g_ps2RecompiledFunctionTable[478514] = njCnkCsUvn_0x2d2e90; // 0x2d34d0 - g_ps2RecompiledFunctionTable[478515] = njCnkCsUvn_0x2d2e90; // 0x2d34d4 - g_ps2RecompiledFunctionTable[478516] = njCnkCsUvn_0x2d2e90; // 0x2d34d8 - g_ps2RecompiledFunctionTable[478517] = njCnkCsUvn_0x2d2e90; // 0x2d34dc - g_ps2RecompiledFunctionTable[478518] = njCnkCsUvn_0x2d2e90; // 0x2d34e0 - g_ps2RecompiledFunctionTable[478519] = njCnkCsUvn_0x2d2e90; // 0x2d34e4 - g_ps2RecompiledFunctionTable[478520] = njCnkCsUvn_0x2d2e90; // 0x2d34e8 - g_ps2RecompiledFunctionTable[478521] = njCnkCsUvn_0x2d2e90; // 0x2d34ec - g_ps2RecompiledFunctionTable[478522] = njCnkCsUvn_0x2d2e90; // 0x2d34f0 - g_ps2RecompiledFunctionTable[478523] = njCnkCsUvn_0x2d2e90; // 0x2d34f4 - g_ps2RecompiledFunctionTable[478524] = njCnkCsUvn_0x2d2e90; // 0x2d34f8 - g_ps2RecompiledFunctionTable[478525] = njCnkCsUvn_0x2d2e90; // 0x2d34fc - g_ps2RecompiledFunctionTable[478526] = njCnkCsUvn_0x2d2e90; // 0x2d3500 - g_ps2RecompiledFunctionTable[478527] = njCnkCsUvn_0x2d2e90; // 0x2d3504 - g_ps2RecompiledFunctionTable[478528] = njCnkCsUvn_0x2d2e90; // 0x2d3508 - g_ps2RecompiledFunctionTable[478529] = njCnkCsUvn_0x2d2e90; // 0x2d350c - g_ps2RecompiledFunctionTable[478530] = njCnkCsUvn_0x2d2e90; // 0x2d3510 - g_ps2RecompiledFunctionTable[478531] = njCnkCsUvn_0x2d2e90; // 0x2d3514 - g_ps2RecompiledFunctionTable[478532] = njCnkCsUvn_0x2d2e90; // 0x2d3518 - g_ps2RecompiledFunctionTable[478533] = njCnkCsUvn_0x2d2e90; // 0x2d351c - g_ps2RecompiledFunctionTable[478534] = njCnkCsUvn_0x2d2e90; // 0x2d3520 - g_ps2RecompiledFunctionTable[478535] = njCnkCsUvn_0x2d2e90; // 0x2d3524 - g_ps2RecompiledFunctionTable[478536] = njCnkCsUvn_0x2d2e90; // 0x2d3528 - g_ps2RecompiledFunctionTable[478537] = njCnkCsUvn_0x2d2e90; // 0x2d352c - g_ps2RecompiledFunctionTable[478538] = njCnkCsUvn_0x2d2e90; // 0x2d3530 - g_ps2RecompiledFunctionTable[478539] = njCnkCsUvn_0x2d2e90; // 0x2d3534 - g_ps2RecompiledFunctionTable[478540] = njCnkCsUvn_0x2d2e90; // 0x2d3538 - g_ps2RecompiledFunctionTable[478541] = njCnkCsUvn_0x2d2e90; // 0x2d353c - g_ps2RecompiledFunctionTable[478542] = njCnkCsUvn_0x2d2e90; // 0x2d3540 - g_ps2RecompiledFunctionTable[478543] = njCnkCsUvn_0x2d2e90; // 0x2d3544 - g_ps2RecompiledFunctionTable[478544] = njCnkCsUvn_0x2d2e90; // 0x2d3548 - g_ps2RecompiledFunctionTable[478545] = njCnkCsUvn_0x2d2e90; // 0x2d354c - g_ps2RecompiledFunctionTable[478546] = njCnkCsUvn_0x2d2e90; // 0x2d3550 - g_ps2RecompiledFunctionTable[478547] = njCnkCsUvn_0x2d2e90; // 0x2d3554 - g_ps2RecompiledFunctionTable[478548] = njCnkCsUvn_0x2d2e90; // 0x2d3558 - g_ps2RecompiledFunctionTable[478549] = njCnkCsUvn_0x2d2e90; // 0x2d355c - g_ps2RecompiledFunctionTable[478550] = njCnkCsUvn_0x2d2e90; // 0x2d3560 - g_ps2RecompiledFunctionTable[478551] = njCnkCsUvn_0x2d2e90; // 0x2d3564 - g_ps2RecompiledFunctionTable[478552] = njCnkCsUvn_0x2d2e90; // 0x2d3568 - g_ps2RecompiledFunctionTable[478553] = njCnkCsUvn_0x2d2e90; // 0x2d356c - g_ps2RecompiledFunctionTable[478554] = njCnkCsUvn_0x2d2e90; // 0x2d3570 - g_ps2RecompiledFunctionTable[478555] = njCnkCsUvn_0x2d2e90; // 0x2d3574 - g_ps2RecompiledFunctionTable[478556] = njCnkCsUvn_0x2d2e90; // 0x2d3578 - g_ps2RecompiledFunctionTable[478557] = njCnkCsUvn_0x2d2e90; // 0x2d357c - g_ps2RecompiledFunctionTable[478558] = njCnkCsUvn_0x2d2e90; // 0x2d3580 - g_ps2RecompiledFunctionTable[478559] = njCnkCsUvn_0x2d2e90; // 0x2d3584 - g_ps2RecompiledFunctionTable[478560] = njCnkCsUvn_0x2d2e90; // 0x2d3588 - g_ps2RecompiledFunctionTable[478561] = njCnkCsUvn_0x2d2e90; // 0x2d358c - g_ps2RecompiledFunctionTable[478562] = njCnkCsUvn_0x2d2e90; // 0x2d3590 - g_ps2RecompiledFunctionTable[478563] = njCnkCsUvn_0x2d2e90; // 0x2d3594 - g_ps2RecompiledFunctionTable[478564] = njCnkCsUvn_0x2d2e90; // 0x2d3598 - g_ps2RecompiledFunctionTable[478565] = njCnkCsUvn_0x2d2e90; // 0x2d359c - g_ps2RecompiledFunctionTable[478566] = njCnkCsUvn_0x2d2e90; // 0x2d35a0 - g_ps2RecompiledFunctionTable[478567] = njCnkCsUvn_0x2d2e90; // 0x2d35a4 - g_ps2RecompiledFunctionTable[478568] = njCnkCsUvn_0x2d2e90; // 0x2d35a8 - g_ps2RecompiledFunctionTable[478569] = njCnkCsUvn_0x2d2e90; // 0x2d35ac - g_ps2RecompiledFunctionTable[478570] = njCnkCsUvn_0x2d2e90; // 0x2d35b0 - g_ps2RecompiledFunctionTable[478571] = njCnkCsUvn_0x2d2e90; // 0x2d35b4 - g_ps2RecompiledFunctionTable[478572] = njCnkCsUvn_0x2d2e90; // 0x2d35b8 - g_ps2RecompiledFunctionTable[478573] = njCnkCsUvn_0x2d2e90; // 0x2d35bc - g_ps2RecompiledFunctionTable[478574] = njCnkCsUvn_0x2d2e90; // 0x2d35c0 - g_ps2RecompiledFunctionTable[478575] = njCnkCsUvn_0x2d2e90; // 0x2d35c4 - g_ps2RecompiledFunctionTable[478576] = njCnkCsUvn_0x2d2e90; // 0x2d35c8 - g_ps2RecompiledFunctionTable[478577] = njCnkCsUvn_0x2d2e90; // 0x2d35cc - g_ps2RecompiledFunctionTable[478578] = njCnkCsUvn_0x2d2e90; // 0x2d35d0 - g_ps2RecompiledFunctionTable[478579] = njCnkCsUvn_0x2d2e90; // 0x2d35d4 - g_ps2RecompiledFunctionTable[478580] = njCnkCsUvn_0x2d2e90; // 0x2d35d8 - g_ps2RecompiledFunctionTable[478581] = njCnkCsUvn_0x2d2e90; // 0x2d35dc - g_ps2RecompiledFunctionTable[478582] = njCnkCsUvn_0x2d2e90; // 0x2d35e0 - g_ps2RecompiledFunctionTable[478583] = njCnkCsUvn_0x2d2e90; // 0x2d35e4 - g_ps2RecompiledFunctionTable[478584] = njCnkCsUvn_0x2d2e90; // 0x2d35e8 - g_ps2RecompiledFunctionTable[478585] = njCnkCsUvn_0x2d2e90; // 0x2d35ec - g_ps2RecompiledFunctionTable[478586] = njCnkCsUvn_0x2d2e90; // 0x2d35f0 - g_ps2RecompiledFunctionTable[478587] = njCnkCsUvn_0x2d2e90; // 0x2d35f4 - g_ps2RecompiledFunctionTable[478588] = njCnkCsUvn_0x2d2e90; // 0x2d35f8 - g_ps2RecompiledFunctionTable[478589] = njCnkCsUvn_0x2d2e90; // 0x2d35fc - g_ps2RecompiledFunctionTable[478590] = njCnkCsUvn_0x2d2e90; // 0x2d3600 - g_ps2RecompiledFunctionTable[478591] = njCnkCsUvn_0x2d2e90; // 0x2d3604 - g_ps2RecompiledFunctionTable[478592] = njCnkCsUvn_0x2d2e90; // 0x2d3608 - g_ps2RecompiledFunctionTable[478593] = njCnkCsUvn_0x2d2e90; // 0x2d360c - g_ps2RecompiledFunctionTable[478594] = njCnkCsUvn_0x2d2e90; // 0x2d3610 - g_ps2RecompiledFunctionTable[478595] = njCnkCsUvn_0x2d2e90; // 0x2d3614 - g_ps2RecompiledFunctionTable[478596] = njCnkCsUvn_0x2d2e90; // 0x2d3618 - g_ps2RecompiledFunctionTable[478597] = njCnkCsUvn_0x2d2e90; // 0x2d361c - g_ps2RecompiledFunctionTable[478598] = njCnkCsUvn_0x2d2e90; // 0x2d3620 - g_ps2RecompiledFunctionTable[478599] = njCnkCsUvn_0x2d2e90; // 0x2d3624 - g_ps2RecompiledFunctionTable[478600] = njCnkCsUvn_0x2d2e90; // 0x2d3628 - g_ps2RecompiledFunctionTable[478601] = njCnkCsUvn_0x2d2e90; // 0x2d362c - g_ps2RecompiledFunctionTable[478602] = njCnkCsUvn_0x2d2e90; // 0x2d3630 - g_ps2RecompiledFunctionTable[478603] = njCnkCsUvn_0x2d2e90; // 0x2d3634 - g_ps2RecompiledFunctionTable[478604] = njCnkCsUvn_0x2d2e90; // 0x2d3638 - g_ps2RecompiledFunctionTable[478605] = njCnkCsUvn_0x2d2e90; // 0x2d363c - g_ps2RecompiledFunctionTable[478606] = njCnkCsUvn_0x2d2e90; // 0x2d3640 - g_ps2RecompiledFunctionTable[478607] = njCnkCsUvn_0x2d2e90; // 0x2d3644 - g_ps2RecompiledFunctionTable[478608] = njCnkCsUvn_0x2d2e90; // 0x2d3648 - g_ps2RecompiledFunctionTable[478609] = njCnkCsUvn_0x2d2e90; // 0x2d364c - g_ps2RecompiledFunctionTable[478610] = njCnkCsUvn_0x2d2e90; // 0x2d3650 - g_ps2RecompiledFunctionTable[478611] = njCnkCsUvn_0x2d2e90; // 0x2d3654 - g_ps2RecompiledFunctionTable[478612] = njCnkCsUvn_0x2d2e90; // 0x2d3658 - g_ps2RecompiledFunctionTable[478613] = njCnkCsUvn_0x2d2e90; // 0x2d365c - g_ps2RecompiledFunctionTable[478614] = njCnkCsUvn_0x2d2e90; // 0x2d3660 - g_ps2RecompiledFunctionTable[478615] = njCnkCsUvn_0x2d2e90; // 0x2d3664 - g_ps2RecompiledFunctionTable[478616] = njCnkCsUvn_0x2d2e90; // 0x2d3668 - g_ps2RecompiledFunctionTable[478617] = njCnkCsUvn_0x2d2e90; // 0x2d366c - g_ps2RecompiledFunctionTable[478618] = njCnkCsUvn_0x2d2e90; // 0x2d3670 - g_ps2RecompiledFunctionTable[478619] = njCnkCsUvn_0x2d2e90; // 0x2d3674 - g_ps2RecompiledFunctionTable[478620] = njCnkCsUvn_0x2d2e90; // 0x2d3678 - g_ps2RecompiledFunctionTable[478621] = njCnkCsUvn_0x2d2e90; // 0x2d367c - g_ps2RecompiledFunctionTable[478622] = njCnkCsUvn_0x2d2e90; // 0x2d3680 - g_ps2RecompiledFunctionTable[478623] = njCnkCsUvn_0x2d2e90; // 0x2d3684 - g_ps2RecompiledFunctionTable[478624] = njCnkCsUvn_0x2d2e90; // 0x2d3688 - g_ps2RecompiledFunctionTable[478625] = njCnkCsUvn_0x2d2e90; // 0x2d368c - g_ps2RecompiledFunctionTable[478626] = njCnkCsUvn_0x2d2e90; // 0x2d3690 - g_ps2RecompiledFunctionTable[478627] = njCnkCsUvn_0x2d2e90; // 0x2d3694 - g_ps2RecompiledFunctionTable[478628] = njCnkCsUvn_0x2d2e90; // 0x2d3698 - g_ps2RecompiledFunctionTable[478629] = njCnkCsUvn_0x2d2e90; // 0x2d369c - g_ps2RecompiledFunctionTable[478630] = njCnkCsUvn_0x2d2e90; // 0x2d36a0 - g_ps2RecompiledFunctionTable[478631] = njCnkCsUvn_0x2d2e90; // 0x2d36a4 - g_ps2RecompiledFunctionTable[478632] = njCnkCsUvn_0x2d2e90; // 0x2d36a8 - g_ps2RecompiledFunctionTable[478633] = njCnkCsUvn_0x2d2e90; // 0x2d36ac - g_ps2RecompiledFunctionTable[478634] = njCnkCsUvn_0x2d2e90; // 0x2d36b0 - g_ps2RecompiledFunctionTable[478635] = njCnkCsUvn_0x2d2e90; // 0x2d36b4 - g_ps2RecompiledFunctionTable[478636] = njCnkCsUvn_0x2d2e90; // 0x2d36b8 - g_ps2RecompiledFunctionTable[478637] = njCnkCsUvn_0x2d2e90; // 0x2d36bc - g_ps2RecompiledFunctionTable[478638] = njCnkCsUvn_0x2d2e90; // 0x2d36c0 - g_ps2RecompiledFunctionTable[478639] = njCnkCsUvn_0x2d2e90; // 0x2d36c4 - g_ps2RecompiledFunctionTable[478640] = njCnkCsUvn_0x2d2e90; // 0x2d36c8 - g_ps2RecompiledFunctionTable[478641] = njCnkCsUvn_0x2d2e90; // 0x2d36cc - g_ps2RecompiledFunctionTable[478642] = njCnkCsUvn_0x2d2e90; // 0x2d36d0 - g_ps2RecompiledFunctionTable[478643] = njCnkCsUvn_0x2d2e90; // 0x2d36d4 - g_ps2RecompiledFunctionTable[478644] = njCnkCsUvn_0x2d2e90; // 0x2d36d8 - g_ps2RecompiledFunctionTable[478645] = njCnkCsUvn_0x2d2e90; // 0x2d36dc - g_ps2RecompiledFunctionTable[478646] = njCnkCsUvn_0x2d2e90; // 0x2d36e0 - g_ps2RecompiledFunctionTable[478647] = njCnkCsUvn_0x2d2e90; // 0x2d36e4 - g_ps2RecompiledFunctionTable[478648] = njCnkCsUvn_0x2d2e90; // 0x2d36e8 - g_ps2RecompiledFunctionTable[478649] = njCnkCsUvn_0x2d2e90; // 0x2d36ec - g_ps2RecompiledFunctionTable[478650] = njCnkCsUvn_0x2d2e90; // 0x2d36f0 - g_ps2RecompiledFunctionTable[478651] = njCnkCsUvn_0x2d2e90; // 0x2d36f4 - g_ps2RecompiledFunctionTable[478652] = njCnkCsUvn_0x2d2e90; // 0x2d36f8 - g_ps2RecompiledFunctionTable[478653] = njCnkCsUvn_0x2d2e90; // 0x2d36fc - g_ps2RecompiledFunctionTable[478654] = njCnkCsUvn_0x2d2e90; // 0x2d3700 - g_ps2RecompiledFunctionTable[478655] = njCnkCsUvn_0x2d2e90; // 0x2d3704 - g_ps2RecompiledFunctionTable[478656] = njCnkCsUvn_0x2d2e90; // 0x2d3708 - g_ps2RecompiledFunctionTable[478657] = njCnkCsUvn_0x2d2e90; // 0x2d370c - g_ps2RecompiledFunctionTable[478658] = njCnkCsUvn_0x2d2e90; // 0x2d3710 - g_ps2RecompiledFunctionTable[478659] = njCnkCsUvn_0x2d2e90; // 0x2d3714 - g_ps2RecompiledFunctionTable[478660] = njCnkCsUvn_0x2d2e90; // 0x2d3718 - g_ps2RecompiledFunctionTable[478661] = njCnkCsUvn_0x2d2e90; // 0x2d371c - g_ps2RecompiledFunctionTable[478662] = njCnkCsUvn_0x2d2e90; // 0x2d3720 - g_ps2RecompiledFunctionTable[478663] = njCnkCsUvn_0x2d2e90; // 0x2d3724 - g_ps2RecompiledFunctionTable[478664] = njCnkCsUvn_0x2d2e90; // 0x2d3728 - g_ps2RecompiledFunctionTable[478665] = njCnkCsUvn_0x2d2e90; // 0x2d372c - g_ps2RecompiledFunctionTable[478666] = njCnkCsUvn_0x2d2e90; // 0x2d3730 - g_ps2RecompiledFunctionTable[478667] = njCnkCsUvn_0x2d2e90; // 0x2d3734 - g_ps2RecompiledFunctionTable[478668] = njCnkCsUvn_0x2d2e90; // 0x2d3738 - g_ps2RecompiledFunctionTable[478669] = njCnkCsUvn_0x2d2e90; // 0x2d373c - g_ps2RecompiledFunctionTable[478670] = njCnkCsUvn_0x2d2e90; // 0x2d3740 - g_ps2RecompiledFunctionTable[478671] = njCnkCsUvn_0x2d2e90; // 0x2d3744 - g_ps2RecompiledFunctionTable[478672] = njCnkCsUvn_0x2d2e90; // 0x2d3748 - g_ps2RecompiledFunctionTable[478673] = njCnkCsUvn_0x2d2e90; // 0x2d374c - g_ps2RecompiledFunctionTable[478674] = njCnkCsUvn_0x2d2e90; // 0x2d3750 - g_ps2RecompiledFunctionTable[478675] = njCnkCsUvn_0x2d2e90; // 0x2d3754 - g_ps2RecompiledFunctionTable[478676] = njCnkCsUvn_0x2d2e90; // 0x2d3758 - g_ps2RecompiledFunctionTable[478677] = njCnkCsUvn_0x2d2e90; // 0x2d375c - g_ps2RecompiledFunctionTable[478678] = njCnkCsUvn_0x2d2e90; // 0x2d3760 - g_ps2RecompiledFunctionTable[478679] = njCnkCsUvn_0x2d2e90; // 0x2d3764 - g_ps2RecompiledFunctionTable[478680] = njCnkCsUvn_0x2d2e90; // 0x2d3768 - g_ps2RecompiledFunctionTable[478681] = njCnkCsUvn_0x2d2e90; // 0x2d376c - g_ps2RecompiledFunctionTable[478682] = njCnkCsUvn_0x2d2e90; // 0x2d3770 - g_ps2RecompiledFunctionTable[478683] = njCnkCsUvn_0x2d2e90; // 0x2d3774 - g_ps2RecompiledFunctionTable[478684] = njCnkCsUvn_0x2d2e90; // 0x2d3778 - g_ps2RecompiledFunctionTable[478686] = njCnkDefaultLong_0x2d3780; // 0x2d3780 - g_ps2RecompiledFunctionTable[478694] = njCnkDefaultShort_0x2d37a0; // 0x2d37a0 - g_ps2RecompiledFunctionTable[478702] = njCnkEasyMultiDrawObjectI_0x2d37c0; // 0x2d37c0 - g_ps2RecompiledFunctionTable[478709] = njCnkEasyMultiDrawObjectI_0x2d37c0; // 0x2d37dc - g_ps2RecompiledFunctionTable[478715] = njCnkEasyMultiDrawObjectI_0x2d37c0; // 0x2d37f4 - g_ps2RecompiledFunctionTable[478717] = njCnkEasyMultiDrawObjectI_0x2d37c0; // 0x2d37fc - g_ps2RecompiledFunctionTable[478722] = njCnkEasyMultiDrawObjectI_0x2d37c0; // 0x2d3810 - g_ps2RecompiledFunctionTable[478728] = njCnkEasyMultiDrawObjectI_0x2d37c0; // 0x2d3828 - g_ps2RecompiledFunctionTable[478733] = njCnkEasyMultiDrawObjectI_0x2d37c0; // 0x2d383c - g_ps2RecompiledFunctionTable[478741] = njCnkEasyMultiDrawObjectI_0x2d37c0; // 0x2d385c - g_ps2RecompiledFunctionTable[478752] = njCnkEasyMultiDrawObjectI_0x2d37c0; // 0x2d3888 - g_ps2RecompiledFunctionTable[478754] = njCnkEasyMultiDrawObjectI_0x2d37c0; // 0x2d3890 - g_ps2RecompiledFunctionTable[478766] = vu1SetScreenProjection_0x2d38c0; // 0x2d38c0 - g_ps2RecompiledFunctionTable[478782] = vu1SetNearFarClip_0x2d3900; // 0x2d3900 - g_ps2RecompiledFunctionTable[478810] = vu1SetScreenOffset_0x2d3970; // 0x2d3970 - g_ps2RecompiledFunctionTable[478822] = vu1SetScreenAspect_0x2d39a0; // 0x2d39a0 - g_ps2RecompiledFunctionTable[478834] = vu1SetDiffuseMaterial_0x2d39d0; // 0x2d39d0 - g_ps2RecompiledFunctionTable[478862] = vu1SetSpeculaMaterial_0x2d3a40; // 0x2d3a40 - g_ps2RecompiledFunctionTable[478886] = vu1SetAmbient_0x2d3aa0; // 0x2d3aa0 - g_ps2RecompiledFunctionTable[478898] = vu1SetAlphaRatio_0x2d3ad0; // 0x2d3ad0 - g_ps2RecompiledFunctionTable[478910] = DrawScissorPolygonOpaque2_0x2d3b00; // 0x2d3b00 - g_ps2RecompiledFunctionTable[478921] = DrawScissorPolygonOpaque2_0x2d3b00; // 0x2d3b2c - g_ps2RecompiledFunctionTable[478956] = DrawScissorPolygonOpaque2_0x2d3b00; // 0x2d3bb8 - g_ps2RecompiledFunctionTable[478962] = InitNodeArraySet2_0x2d3bd0; // 0x2d3bd0 - g_ps2RecompiledFunctionTable[478966] = ps2__Clip_ViewVolume2_0x2d3be0; // 0x2d3be0 - g_ps2RecompiledFunctionTable[478974] = ps2__Get_ClipViewVolume2_0x2d3c00; // 0x2d3c00 - g_ps2RecompiledFunctionTable[478978] = ps2__Get_ClipVolumePlane_0x2d3c10; // 0x2d3c10 - g_ps2RecompiledFunctionTable[478982] = ps2__Check_ClipViewAll_0x2d3c20; // 0x2d3c20 - g_ps2RecompiledFunctionTable[478990] = ps2__Set_NodeArray_0x2d3c40; // 0x2d3c40 - g_ps2RecompiledFunctionTable[479006] = ps2__ClipInter_0x2d3c80; // 0x2d3c80 - g_ps2RecompiledFunctionTable[479031] = ps2__ClipInter_0x2d3c80; // 0x2d3ce4 - g_ps2RecompiledFunctionTable[479059] = ps2__ClipInter_0x2d3c80; // 0x2d3d54 - g_ps2RecompiledFunctionTable[479098] = ps2__ClipInter_0x2d3c80; // 0x2d3df0 - g_ps2RecompiledFunctionTable[479146] = ps2__Check_ScissorPlane_0x2d3eb0; // 0x2d3eb0 - g_ps2RecompiledFunctionTable[479157] = ps2__Check_ScissorPlane_0x2d3eb0; // 0x2d3edc - g_ps2RecompiledFunctionTable[479170] = ps2__Check_ScissorPlane_0x2d3eb0; // 0x2d3f10 - g_ps2RecompiledFunctionTable[479183] = ps2__Check_ScissorPlane_0x2d3eb0; // 0x2d3f44 - g_ps2RecompiledFunctionTable[479196] = ps2__Check_ScissorPlane_0x2d3eb0; // 0x2d3f78 - g_ps2RecompiledFunctionTable[479209] = ps2__Check_ScissorPlane_0x2d3eb0; // 0x2d3fac - g_ps2RecompiledFunctionTable[479222] = ps2__Check_ScissorPlane_0x2d3eb0; // 0x2d3fe0 - g_ps2RecompiledFunctionTable[479226] = InitNodeArraySet_0x2d3ff0; // 0x2d3ff0 - g_ps2RecompiledFunctionTable[479238] = InitScissorPlane_0x2d4020; // 0x2d4020 - g_ps2RecompiledFunctionTable[479262] = ps2__Init_ScissorSystem_0x2d4080; // 0x2d4080 - g_ps2RecompiledFunctionTable[479267] = ps2__Init_ScissorSystem_0x2d4080; // 0x2d4094 - g_ps2RecompiledFunctionTable[479270] = ps2__Init_ScissorSystem_0x2d4080; // 0x2d40a0 - g_ps2RecompiledFunctionTable[479274] = ps2__Clip_ViewVolume_0x2d40b0; // 0x2d40b0 - g_ps2RecompiledFunctionTable[479290] = PushTriangleNodeArray_0x2d40f0; // 0x2d40f0 - g_ps2RecompiledFunctionTable[479318] = ResetNodeArraySet_0x2d4160; // 0x2d4160 - g_ps2RecompiledFunctionTable[479330] = ScissorTriangle_0x2d4190; // 0x2d4190 - g_ps2RecompiledFunctionTable[479336] = ScissorTriangle_0x2d4190; // 0x2d41a8 - g_ps2RecompiledFunctionTable[479361] = ScissorTriangle_0x2d4190; // 0x2d420c - g_ps2RecompiledFunctionTable[479442] = ScissorTriangle_0x2d4190; // 0x2d4350 - g_ps2RecompiledFunctionTable[479536] = ScissorTriangle_0x2d4190; // 0x2d44c8 - g_ps2RecompiledFunctionTable[479634] = ps2__Check_DisplayAreaPoint_0x2d4650; // 0x2d4650 - g_ps2RecompiledFunctionTable[479678] = DrawScissorPolygonOpaque_0x2d4700; // 0x2d4700 - g_ps2RecompiledFunctionTable[479686] = DrawScissorPolygonOpaque_0x2d4700; // 0x2d4720 - g_ps2RecompiledFunctionTable[479726] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d47c0 - g_ps2RecompiledFunctionTable[479727] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d47c4 - g_ps2RecompiledFunctionTable[479728] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d47c8 - g_ps2RecompiledFunctionTable[479729] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d47cc - g_ps2RecompiledFunctionTable[479730] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d47d0 - g_ps2RecompiledFunctionTable[479731] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d47d4 - g_ps2RecompiledFunctionTable[479732] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d47d8 - g_ps2RecompiledFunctionTable[479733] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d47dc - g_ps2RecompiledFunctionTable[479734] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d47e0 - g_ps2RecompiledFunctionTable[479735] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d47e4 - g_ps2RecompiledFunctionTable[479736] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d47e8 - g_ps2RecompiledFunctionTable[479737] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d47ec - g_ps2RecompiledFunctionTable[479738] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d47f0 - g_ps2RecompiledFunctionTable[479739] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d47f4 - g_ps2RecompiledFunctionTable[479740] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d47f8 - g_ps2RecompiledFunctionTable[479741] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d47fc - g_ps2RecompiledFunctionTable[479742] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4800 - g_ps2RecompiledFunctionTable[479743] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4804 - g_ps2RecompiledFunctionTable[479744] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4808 - g_ps2RecompiledFunctionTable[479745] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d480c - g_ps2RecompiledFunctionTable[479746] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4810 - g_ps2RecompiledFunctionTable[479747] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4814 - g_ps2RecompiledFunctionTable[479748] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4818 - g_ps2RecompiledFunctionTable[479749] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d481c - g_ps2RecompiledFunctionTable[479750] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4820 - g_ps2RecompiledFunctionTable[479751] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4824 - g_ps2RecompiledFunctionTable[479752] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4828 - g_ps2RecompiledFunctionTable[479753] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d482c - g_ps2RecompiledFunctionTable[479754] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4830 - g_ps2RecompiledFunctionTable[479755] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4834 - g_ps2RecompiledFunctionTable[479756] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4838 - g_ps2RecompiledFunctionTable[479757] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d483c - g_ps2RecompiledFunctionTable[479758] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4840 - g_ps2RecompiledFunctionTable[479759] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4844 - g_ps2RecompiledFunctionTable[479760] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4848 - g_ps2RecompiledFunctionTable[479761] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d484c - g_ps2RecompiledFunctionTable[479762] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4850 - g_ps2RecompiledFunctionTable[479763] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4854 - g_ps2RecompiledFunctionTable[479764] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4858 - g_ps2RecompiledFunctionTable[479765] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d485c - g_ps2RecompiledFunctionTable[479766] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4860 - g_ps2RecompiledFunctionTable[479767] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4864 - g_ps2RecompiledFunctionTable[479768] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4868 - g_ps2RecompiledFunctionTable[479769] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d486c - g_ps2RecompiledFunctionTable[479770] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4870 - g_ps2RecompiledFunctionTable[479771] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4874 - g_ps2RecompiledFunctionTable[479772] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4878 - g_ps2RecompiledFunctionTable[479773] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d487c - g_ps2RecompiledFunctionTable[479774] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4880 - g_ps2RecompiledFunctionTable[479775] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4884 - g_ps2RecompiledFunctionTable[479776] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4888 - g_ps2RecompiledFunctionTable[479777] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d488c - g_ps2RecompiledFunctionTable[479778] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4890 - g_ps2RecompiledFunctionTable[479779] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4894 - g_ps2RecompiledFunctionTable[479780] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4898 - g_ps2RecompiledFunctionTable[479781] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d489c - g_ps2RecompiledFunctionTable[479782] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d48a0 - g_ps2RecompiledFunctionTable[479783] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d48a4 - g_ps2RecompiledFunctionTable[479784] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d48a8 - g_ps2RecompiledFunctionTable[479785] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d48ac - g_ps2RecompiledFunctionTable[479786] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d48b0 - g_ps2RecompiledFunctionTable[479787] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d48b4 - g_ps2RecompiledFunctionTable[479788] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d48b8 - g_ps2RecompiledFunctionTable[479789] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d48bc - g_ps2RecompiledFunctionTable[479790] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d48c0 - g_ps2RecompiledFunctionTable[479791] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d48c4 - g_ps2RecompiledFunctionTable[479792] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d48c8 - g_ps2RecompiledFunctionTable[479793] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d48cc - g_ps2RecompiledFunctionTable[479794] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d48d0 - g_ps2RecompiledFunctionTable[479795] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d48d4 - g_ps2RecompiledFunctionTable[479796] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d48d8 - g_ps2RecompiledFunctionTable[479797] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d48dc - g_ps2RecompiledFunctionTable[479798] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d48e0 - g_ps2RecompiledFunctionTable[479799] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d48e4 - g_ps2RecompiledFunctionTable[479800] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d48e8 - g_ps2RecompiledFunctionTable[479801] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d48ec - g_ps2RecompiledFunctionTable[479802] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d48f0 - g_ps2RecompiledFunctionTable[479803] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d48f4 - g_ps2RecompiledFunctionTable[479804] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d48f8 - g_ps2RecompiledFunctionTable[479805] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d48fc - g_ps2RecompiledFunctionTable[479806] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4900 - g_ps2RecompiledFunctionTable[479807] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4904 - g_ps2RecompiledFunctionTable[479808] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4908 - g_ps2RecompiledFunctionTable[479809] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d490c - g_ps2RecompiledFunctionTable[479810] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4910 - g_ps2RecompiledFunctionTable[479811] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4914 - g_ps2RecompiledFunctionTable[479812] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4918 - g_ps2RecompiledFunctionTable[479813] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d491c - g_ps2RecompiledFunctionTable[479814] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4920 - g_ps2RecompiledFunctionTable[479815] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4924 - g_ps2RecompiledFunctionTable[479816] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4928 - g_ps2RecompiledFunctionTable[479817] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d492c - g_ps2RecompiledFunctionTable[479818] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4930 - g_ps2RecompiledFunctionTable[479819] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4934 - g_ps2RecompiledFunctionTable[479820] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4938 - g_ps2RecompiledFunctionTable[479821] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d493c - g_ps2RecompiledFunctionTable[479822] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4940 - g_ps2RecompiledFunctionTable[479823] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4944 - g_ps2RecompiledFunctionTable[479824] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4948 - g_ps2RecompiledFunctionTable[479825] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d494c - g_ps2RecompiledFunctionTable[479826] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4950 - g_ps2RecompiledFunctionTable[479827] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4954 - g_ps2RecompiledFunctionTable[479828] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4958 - g_ps2RecompiledFunctionTable[479829] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d495c - g_ps2RecompiledFunctionTable[479830] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4960 - g_ps2RecompiledFunctionTable[479831] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4964 - g_ps2RecompiledFunctionTable[479832] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4968 - g_ps2RecompiledFunctionTable[479833] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d496c - g_ps2RecompiledFunctionTable[479834] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4970 - g_ps2RecompiledFunctionTable[479835] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4974 - g_ps2RecompiledFunctionTable[479836] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4978 - g_ps2RecompiledFunctionTable[479837] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d497c - g_ps2RecompiledFunctionTable[479838] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4980 - g_ps2RecompiledFunctionTable[479839] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4984 - g_ps2RecompiledFunctionTable[479840] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4988 - g_ps2RecompiledFunctionTable[479841] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d498c - g_ps2RecompiledFunctionTable[479842] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4990 - g_ps2RecompiledFunctionTable[479843] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4994 - g_ps2RecompiledFunctionTable[479844] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4998 - g_ps2RecompiledFunctionTable[479845] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d499c - g_ps2RecompiledFunctionTable[479846] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d49a0 - g_ps2RecompiledFunctionTable[479847] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d49a4 - g_ps2RecompiledFunctionTable[479848] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d49a8 - g_ps2RecompiledFunctionTable[479849] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d49ac - g_ps2RecompiledFunctionTable[479850] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d49b0 - g_ps2RecompiledFunctionTable[479851] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d49b4 - g_ps2RecompiledFunctionTable[479852] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d49b8 - g_ps2RecompiledFunctionTable[479853] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d49bc - g_ps2RecompiledFunctionTable[479854] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d49c0 - g_ps2RecompiledFunctionTable[479855] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d49c4 - g_ps2RecompiledFunctionTable[479856] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d49c8 - g_ps2RecompiledFunctionTable[479857] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d49cc - g_ps2RecompiledFunctionTable[479858] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d49d0 - g_ps2RecompiledFunctionTable[479859] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d49d4 - g_ps2RecompiledFunctionTable[479860] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d49d8 - g_ps2RecompiledFunctionTable[479861] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d49dc - g_ps2RecompiledFunctionTable[479862] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d49e0 - g_ps2RecompiledFunctionTable[479863] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d49e4 - g_ps2RecompiledFunctionTable[479864] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d49e8 - g_ps2RecompiledFunctionTable[479865] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d49ec - g_ps2RecompiledFunctionTable[479866] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d49f0 - g_ps2RecompiledFunctionTable[479867] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d49f4 - g_ps2RecompiledFunctionTable[479868] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d49f8 - g_ps2RecompiledFunctionTable[479869] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d49fc - g_ps2RecompiledFunctionTable[479870] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4a00 - g_ps2RecompiledFunctionTable[479871] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4a04 - g_ps2RecompiledFunctionTable[479872] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4a08 - g_ps2RecompiledFunctionTable[479873] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4a0c - g_ps2RecompiledFunctionTable[479874] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4a10 - g_ps2RecompiledFunctionTable[479875] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4a14 - g_ps2RecompiledFunctionTable[479876] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4a18 - g_ps2RecompiledFunctionTable[479877] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4a1c - g_ps2RecompiledFunctionTable[479878] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4a20 - g_ps2RecompiledFunctionTable[479879] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4a24 - g_ps2RecompiledFunctionTable[479880] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4a28 - g_ps2RecompiledFunctionTable[479881] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4a2c - g_ps2RecompiledFunctionTable[479882] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4a30 - g_ps2RecompiledFunctionTable[479883] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4a34 - g_ps2RecompiledFunctionTable[479884] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4a38 - g_ps2RecompiledFunctionTable[479885] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4a3c - g_ps2RecompiledFunctionTable[479886] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4a40 - g_ps2RecompiledFunctionTable[479887] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4a44 - g_ps2RecompiledFunctionTable[479888] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4a48 - g_ps2RecompiledFunctionTable[479889] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4a4c - g_ps2RecompiledFunctionTable[479890] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4a50 - g_ps2RecompiledFunctionTable[479891] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4a54 - g_ps2RecompiledFunctionTable[479892] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4a58 - g_ps2RecompiledFunctionTable[479893] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4a5c - g_ps2RecompiledFunctionTable[479894] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4a60 - g_ps2RecompiledFunctionTable[479895] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4a64 - g_ps2RecompiledFunctionTable[479896] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4a68 - g_ps2RecompiledFunctionTable[479897] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4a6c - g_ps2RecompiledFunctionTable[479898] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4a70 - g_ps2RecompiledFunctionTable[479899] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4a74 - g_ps2RecompiledFunctionTable[479900] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4a78 - g_ps2RecompiledFunctionTable[479901] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4a7c - g_ps2RecompiledFunctionTable[479902] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4a80 - g_ps2RecompiledFunctionTable[479903] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4a84 - g_ps2RecompiledFunctionTable[479904] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4a88 - g_ps2RecompiledFunctionTable[479905] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4a8c - g_ps2RecompiledFunctionTable[479906] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4a90 - g_ps2RecompiledFunctionTable[479907] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4a94 - g_ps2RecompiledFunctionTable[479908] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4a98 - g_ps2RecompiledFunctionTable[479909] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4a9c - g_ps2RecompiledFunctionTable[479910] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4aa0 - g_ps2RecompiledFunctionTable[479911] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4aa4 - g_ps2RecompiledFunctionTable[479912] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4aa8 - g_ps2RecompiledFunctionTable[479913] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4aac - g_ps2RecompiledFunctionTable[479914] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4ab0 - g_ps2RecompiledFunctionTable[479915] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4ab4 - g_ps2RecompiledFunctionTable[479916] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4ab8 - g_ps2RecompiledFunctionTable[479917] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4abc - g_ps2RecompiledFunctionTable[479918] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4ac0 - g_ps2RecompiledFunctionTable[479919] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4ac4 - g_ps2RecompiledFunctionTable[479920] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4ac8 - g_ps2RecompiledFunctionTable[479921] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4acc - g_ps2RecompiledFunctionTable[479922] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4ad0 - g_ps2RecompiledFunctionTable[479923] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4ad4 - g_ps2RecompiledFunctionTable[479924] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4ad8 - g_ps2RecompiledFunctionTable[479925] = vu1DrawTriangleStripOpaqueSingle_0x2d47c0; // 0x2d4adc - g_ps2RecompiledFunctionTable[479926] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4ae0 - g_ps2RecompiledFunctionTable[479927] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4ae4 - g_ps2RecompiledFunctionTable[479928] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4ae8 - g_ps2RecompiledFunctionTable[479929] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4aec - g_ps2RecompiledFunctionTable[479930] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4af0 - g_ps2RecompiledFunctionTable[479931] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4af4 - g_ps2RecompiledFunctionTable[479932] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4af8 - g_ps2RecompiledFunctionTable[479933] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4afc - g_ps2RecompiledFunctionTable[479934] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4b00 - g_ps2RecompiledFunctionTable[479935] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4b04 - g_ps2RecompiledFunctionTable[479936] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4b08 - g_ps2RecompiledFunctionTable[479937] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4b0c - g_ps2RecompiledFunctionTable[479938] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4b10 - g_ps2RecompiledFunctionTable[479939] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4b14 - g_ps2RecompiledFunctionTable[479940] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4b18 - g_ps2RecompiledFunctionTable[479941] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4b1c - g_ps2RecompiledFunctionTable[479942] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4b20 - g_ps2RecompiledFunctionTable[479943] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4b24 - g_ps2RecompiledFunctionTable[479944] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4b28 - g_ps2RecompiledFunctionTable[479945] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4b2c - g_ps2RecompiledFunctionTable[479946] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4b30 - g_ps2RecompiledFunctionTable[479947] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4b34 - g_ps2RecompiledFunctionTable[479948] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4b38 - g_ps2RecompiledFunctionTable[479949] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4b3c - g_ps2RecompiledFunctionTable[479950] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4b40 - g_ps2RecompiledFunctionTable[479951] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4b44 - g_ps2RecompiledFunctionTable[479952] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4b48 - g_ps2RecompiledFunctionTable[479953] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4b4c - g_ps2RecompiledFunctionTable[479954] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4b50 - g_ps2RecompiledFunctionTable[479955] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4b54 - g_ps2RecompiledFunctionTable[479956] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4b58 - g_ps2RecompiledFunctionTable[479957] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4b5c - g_ps2RecompiledFunctionTable[479958] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4b60 - g_ps2RecompiledFunctionTable[479959] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4b64 - g_ps2RecompiledFunctionTable[479960] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4b68 - g_ps2RecompiledFunctionTable[479961] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4b6c - g_ps2RecompiledFunctionTable[479962] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4b70 - g_ps2RecompiledFunctionTable[479963] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4b74 - g_ps2RecompiledFunctionTable[479964] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4b78 - g_ps2RecompiledFunctionTable[479965] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4b7c - g_ps2RecompiledFunctionTable[479966] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4b80 - g_ps2RecompiledFunctionTable[479967] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4b84 - g_ps2RecompiledFunctionTable[479968] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4b88 - g_ps2RecompiledFunctionTable[479969] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4b8c - g_ps2RecompiledFunctionTable[479970] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4b90 - g_ps2RecompiledFunctionTable[479971] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4b94 - g_ps2RecompiledFunctionTable[479972] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4b98 - g_ps2RecompiledFunctionTable[479973] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4b9c - g_ps2RecompiledFunctionTable[479974] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4ba0 - g_ps2RecompiledFunctionTable[479975] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4ba4 - g_ps2RecompiledFunctionTable[479976] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4ba8 - g_ps2RecompiledFunctionTable[479977] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4bac - g_ps2RecompiledFunctionTable[479978] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4bb0 - g_ps2RecompiledFunctionTable[479979] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4bb4 - g_ps2RecompiledFunctionTable[479980] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4bb8 - g_ps2RecompiledFunctionTable[479981] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4bbc - g_ps2RecompiledFunctionTable[479982] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4bc0 - g_ps2RecompiledFunctionTable[479983] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4bc4 - g_ps2RecompiledFunctionTable[479984] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4bc8 - g_ps2RecompiledFunctionTable[479985] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4bcc - g_ps2RecompiledFunctionTable[479986] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4bd0 - g_ps2RecompiledFunctionTable[479987] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4bd4 - g_ps2RecompiledFunctionTable[479988] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4bd8 - g_ps2RecompiledFunctionTable[479989] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4bdc - g_ps2RecompiledFunctionTable[479990] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4be0 - g_ps2RecompiledFunctionTable[479991] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4be4 - g_ps2RecompiledFunctionTable[479992] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4be8 - g_ps2RecompiledFunctionTable[479993] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4bec - g_ps2RecompiledFunctionTable[479994] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4bf0 - g_ps2RecompiledFunctionTable[479995] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4bf4 - g_ps2RecompiledFunctionTable[479996] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4bf8 - g_ps2RecompiledFunctionTable[479997] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4bfc - g_ps2RecompiledFunctionTable[479998] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4c00 - g_ps2RecompiledFunctionTable[479999] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4c04 - g_ps2RecompiledFunctionTable[480000] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4c08 - g_ps2RecompiledFunctionTable[480001] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4c0c - g_ps2RecompiledFunctionTable[480002] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4c10 - g_ps2RecompiledFunctionTable[480003] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4c14 - g_ps2RecompiledFunctionTable[480004] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4c18 - g_ps2RecompiledFunctionTable[480005] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4c1c - g_ps2RecompiledFunctionTable[480006] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4c20 - g_ps2RecompiledFunctionTable[480007] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4c24 - g_ps2RecompiledFunctionTable[480008] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4c28 - g_ps2RecompiledFunctionTable[480009] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4c2c - g_ps2RecompiledFunctionTable[480010] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4c30 - g_ps2RecompiledFunctionTable[480011] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4c34 - g_ps2RecompiledFunctionTable[480012] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4c38 - g_ps2RecompiledFunctionTable[480013] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4c3c - g_ps2RecompiledFunctionTable[480014] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4c40 - g_ps2RecompiledFunctionTable[480015] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4c44 - g_ps2RecompiledFunctionTable[480016] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4c48 - g_ps2RecompiledFunctionTable[480017] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4c4c - g_ps2RecompiledFunctionTable[480018] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4c50 - g_ps2RecompiledFunctionTable[480019] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4c54 - g_ps2RecompiledFunctionTable[480020] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4c58 - g_ps2RecompiledFunctionTable[480021] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4c5c - g_ps2RecompiledFunctionTable[480022] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4c60 - g_ps2RecompiledFunctionTable[480023] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4c64 - g_ps2RecompiledFunctionTable[480024] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4c68 - g_ps2RecompiledFunctionTable[480025] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4c6c - g_ps2RecompiledFunctionTable[480026] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4c70 - g_ps2RecompiledFunctionTable[480027] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4c74 - g_ps2RecompiledFunctionTable[480028] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4c78 - g_ps2RecompiledFunctionTable[480029] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4c7c - g_ps2RecompiledFunctionTable[480030] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4c80 - g_ps2RecompiledFunctionTable[480031] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4c84 - g_ps2RecompiledFunctionTable[480032] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4c88 - g_ps2RecompiledFunctionTable[480033] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4c8c - g_ps2RecompiledFunctionTable[480034] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4c90 - g_ps2RecompiledFunctionTable[480035] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4c94 - g_ps2RecompiledFunctionTable[480036] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4c98 - g_ps2RecompiledFunctionTable[480037] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4c9c - g_ps2RecompiledFunctionTable[480038] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4ca0 - g_ps2RecompiledFunctionTable[480039] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4ca4 - g_ps2RecompiledFunctionTable[480040] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4ca8 - g_ps2RecompiledFunctionTable[480041] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4cac - g_ps2RecompiledFunctionTable[480042] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4cb0 - g_ps2RecompiledFunctionTable[480043] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4cb4 - g_ps2RecompiledFunctionTable[480044] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4cb8 - g_ps2RecompiledFunctionTable[480045] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4cbc - g_ps2RecompiledFunctionTable[480046] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4cc0 - g_ps2RecompiledFunctionTable[480047] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4cc4 - g_ps2RecompiledFunctionTable[480048] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4cc8 - g_ps2RecompiledFunctionTable[480049] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4ccc - g_ps2RecompiledFunctionTable[480050] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4cd0 - g_ps2RecompiledFunctionTable[480051] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4cd4 - g_ps2RecompiledFunctionTable[480052] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4cd8 - g_ps2RecompiledFunctionTable[480053] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4cdc - g_ps2RecompiledFunctionTable[480054] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4ce0 - g_ps2RecompiledFunctionTable[480055] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4ce4 - g_ps2RecompiledFunctionTable[480056] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4ce8 - g_ps2RecompiledFunctionTable[480057] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4cec - g_ps2RecompiledFunctionTable[480058] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4cf0 - g_ps2RecompiledFunctionTable[480059] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4cf4 - g_ps2RecompiledFunctionTable[480060] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4cf8 - g_ps2RecompiledFunctionTable[480061] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4cfc - g_ps2RecompiledFunctionTable[480062] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4d00 - g_ps2RecompiledFunctionTable[480063] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4d04 - g_ps2RecompiledFunctionTable[480064] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4d08 - g_ps2RecompiledFunctionTable[480065] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4d0c - g_ps2RecompiledFunctionTable[480066] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4d10 - g_ps2RecompiledFunctionTable[480067] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4d14 - g_ps2RecompiledFunctionTable[480068] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4d18 - g_ps2RecompiledFunctionTable[480069] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4d1c - g_ps2RecompiledFunctionTable[480070] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4d20 - g_ps2RecompiledFunctionTable[480071] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4d24 - g_ps2RecompiledFunctionTable[480072] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4d28 - g_ps2RecompiledFunctionTable[480073] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4d2c - g_ps2RecompiledFunctionTable[480074] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4d30 - g_ps2RecompiledFunctionTable[480075] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4d34 - g_ps2RecompiledFunctionTable[480076] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4d38 - g_ps2RecompiledFunctionTable[480077] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4d3c - g_ps2RecompiledFunctionTable[480078] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4d40 - g_ps2RecompiledFunctionTable[480079] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4d44 - g_ps2RecompiledFunctionTable[480080] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4d48 - g_ps2RecompiledFunctionTable[480081] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4d4c - g_ps2RecompiledFunctionTable[480082] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4d50 - g_ps2RecompiledFunctionTable[480083] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4d54 - g_ps2RecompiledFunctionTable[480084] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4d58 - g_ps2RecompiledFunctionTable[480085] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4d5c - g_ps2RecompiledFunctionTable[480086] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4d60 - g_ps2RecompiledFunctionTable[480087] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4d64 - g_ps2RecompiledFunctionTable[480088] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4d68 - g_ps2RecompiledFunctionTable[480089] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4d6c - g_ps2RecompiledFunctionTable[480090] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4d70 - g_ps2RecompiledFunctionTable[480091] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4d74 - g_ps2RecompiledFunctionTable[480092] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4d78 - g_ps2RecompiledFunctionTable[480093] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4d7c - g_ps2RecompiledFunctionTable[480094] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4d80 - g_ps2RecompiledFunctionTable[480095] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4d84 - g_ps2RecompiledFunctionTable[480096] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4d88 - g_ps2RecompiledFunctionTable[480097] = vu1DrawTriangleStripOpaqueDouble_0x2d4ae0; // 0x2d4d8c - g_ps2RecompiledFunctionTable[480098] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4d90 - g_ps2RecompiledFunctionTable[480099] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4d94 - g_ps2RecompiledFunctionTable[480100] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4d98 - g_ps2RecompiledFunctionTable[480101] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4d9c - g_ps2RecompiledFunctionTable[480102] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4da0 - g_ps2RecompiledFunctionTable[480103] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4da4 - g_ps2RecompiledFunctionTable[480104] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4da8 - g_ps2RecompiledFunctionTable[480105] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4dac - g_ps2RecompiledFunctionTable[480106] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4db0 - g_ps2RecompiledFunctionTable[480107] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4db4 - g_ps2RecompiledFunctionTable[480108] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4db8 - g_ps2RecompiledFunctionTable[480109] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4dbc - g_ps2RecompiledFunctionTable[480110] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4dc0 - g_ps2RecompiledFunctionTable[480111] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4dc4 - g_ps2RecompiledFunctionTable[480112] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4dc8 - g_ps2RecompiledFunctionTable[480113] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4dcc - g_ps2RecompiledFunctionTable[480114] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4dd0 - g_ps2RecompiledFunctionTable[480115] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4dd4 - g_ps2RecompiledFunctionTable[480116] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4dd8 - g_ps2RecompiledFunctionTable[480117] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4ddc - g_ps2RecompiledFunctionTable[480118] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4de0 - g_ps2RecompiledFunctionTable[480119] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4de4 - g_ps2RecompiledFunctionTable[480120] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4de8 - g_ps2RecompiledFunctionTable[480121] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4dec - g_ps2RecompiledFunctionTable[480122] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4df0 - g_ps2RecompiledFunctionTable[480123] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4df4 - g_ps2RecompiledFunctionTable[480124] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4df8 - g_ps2RecompiledFunctionTable[480125] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4dfc - g_ps2RecompiledFunctionTable[480126] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4e00 - g_ps2RecompiledFunctionTable[480127] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4e04 - g_ps2RecompiledFunctionTable[480128] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4e08 - g_ps2RecompiledFunctionTable[480129] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4e0c - g_ps2RecompiledFunctionTable[480130] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4e10 - g_ps2RecompiledFunctionTable[480131] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4e14 - g_ps2RecompiledFunctionTable[480132] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4e18 - g_ps2RecompiledFunctionTable[480133] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4e1c - g_ps2RecompiledFunctionTable[480134] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4e20 - g_ps2RecompiledFunctionTable[480135] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4e24 - g_ps2RecompiledFunctionTable[480136] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4e28 - g_ps2RecompiledFunctionTable[480137] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4e2c - g_ps2RecompiledFunctionTable[480138] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4e30 - g_ps2RecompiledFunctionTable[480139] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4e34 - g_ps2RecompiledFunctionTable[480140] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4e38 - g_ps2RecompiledFunctionTable[480141] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4e3c - g_ps2RecompiledFunctionTable[480142] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4e40 - g_ps2RecompiledFunctionTable[480143] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4e44 - g_ps2RecompiledFunctionTable[480144] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4e48 - g_ps2RecompiledFunctionTable[480145] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4e4c - g_ps2RecompiledFunctionTable[480146] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4e50 - g_ps2RecompiledFunctionTable[480147] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4e54 - g_ps2RecompiledFunctionTable[480148] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4e58 - g_ps2RecompiledFunctionTable[480149] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4e5c - g_ps2RecompiledFunctionTable[480150] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4e60 - g_ps2RecompiledFunctionTable[480151] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4e64 - g_ps2RecompiledFunctionTable[480152] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4e68 - g_ps2RecompiledFunctionTable[480153] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4e6c - g_ps2RecompiledFunctionTable[480154] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4e70 - g_ps2RecompiledFunctionTable[480155] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4e74 - g_ps2RecompiledFunctionTable[480156] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4e78 - g_ps2RecompiledFunctionTable[480157] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4e7c - g_ps2RecompiledFunctionTable[480158] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4e80 - g_ps2RecompiledFunctionTable[480159] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4e84 - g_ps2RecompiledFunctionTable[480160] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4e88 - g_ps2RecompiledFunctionTable[480161] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4e8c - g_ps2RecompiledFunctionTable[480162] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4e90 - g_ps2RecompiledFunctionTable[480163] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4e94 - g_ps2RecompiledFunctionTable[480164] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4e98 - g_ps2RecompiledFunctionTable[480165] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4e9c - g_ps2RecompiledFunctionTable[480166] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4ea0 - g_ps2RecompiledFunctionTable[480167] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4ea4 - g_ps2RecompiledFunctionTable[480168] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4ea8 - g_ps2RecompiledFunctionTable[480169] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4eac - g_ps2RecompiledFunctionTable[480170] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4eb0 - g_ps2RecompiledFunctionTable[480171] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4eb4 - g_ps2RecompiledFunctionTable[480172] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4eb8 - g_ps2RecompiledFunctionTable[480173] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4ebc - g_ps2RecompiledFunctionTable[480174] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4ec0 - g_ps2RecompiledFunctionTable[480175] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4ec4 - g_ps2RecompiledFunctionTable[480176] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4ec8 - g_ps2RecompiledFunctionTable[480177] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4ecc - g_ps2RecompiledFunctionTable[480178] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4ed0 - g_ps2RecompiledFunctionTable[480179] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4ed4 - g_ps2RecompiledFunctionTable[480180] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4ed8 - g_ps2RecompiledFunctionTable[480181] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4edc - g_ps2RecompiledFunctionTable[480182] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4ee0 - g_ps2RecompiledFunctionTable[480183] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4ee4 - g_ps2RecompiledFunctionTable[480184] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4ee8 - g_ps2RecompiledFunctionTable[480185] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4eec - g_ps2RecompiledFunctionTable[480186] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4ef0 - g_ps2RecompiledFunctionTable[480187] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4ef4 - g_ps2RecompiledFunctionTable[480188] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4ef8 - g_ps2RecompiledFunctionTable[480189] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4efc - g_ps2RecompiledFunctionTable[480190] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4f00 - g_ps2RecompiledFunctionTable[480191] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4f04 - g_ps2RecompiledFunctionTable[480192] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4f08 - g_ps2RecompiledFunctionTable[480193] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4f0c - g_ps2RecompiledFunctionTable[480194] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4f10 - g_ps2RecompiledFunctionTable[480195] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4f14 - g_ps2RecompiledFunctionTable[480196] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4f18 - g_ps2RecompiledFunctionTable[480197] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4f1c - g_ps2RecompiledFunctionTable[480198] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4f20 - g_ps2RecompiledFunctionTable[480199] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4f24 - g_ps2RecompiledFunctionTable[480200] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4f28 - g_ps2RecompiledFunctionTable[480201] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4f2c - g_ps2RecompiledFunctionTable[480202] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4f30 - g_ps2RecompiledFunctionTable[480203] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4f34 - g_ps2RecompiledFunctionTable[480204] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4f38 - g_ps2RecompiledFunctionTable[480205] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4f3c - g_ps2RecompiledFunctionTable[480206] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4f40 - g_ps2RecompiledFunctionTable[480207] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4f44 - g_ps2RecompiledFunctionTable[480208] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4f48 - g_ps2RecompiledFunctionTable[480209] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4f4c - g_ps2RecompiledFunctionTable[480210] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4f50 - g_ps2RecompiledFunctionTable[480211] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4f54 - g_ps2RecompiledFunctionTable[480212] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4f58 - g_ps2RecompiledFunctionTable[480213] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4f5c - g_ps2RecompiledFunctionTable[480214] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4f60 - g_ps2RecompiledFunctionTable[480215] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4f64 - g_ps2RecompiledFunctionTable[480216] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4f68 - g_ps2RecompiledFunctionTable[480217] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4f6c - g_ps2RecompiledFunctionTable[480218] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4f70 - g_ps2RecompiledFunctionTable[480219] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4f74 - g_ps2RecompiledFunctionTable[480220] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4f78 - g_ps2RecompiledFunctionTable[480221] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4f7c - g_ps2RecompiledFunctionTable[480222] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4f80 - g_ps2RecompiledFunctionTable[480223] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4f84 - g_ps2RecompiledFunctionTable[480224] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4f88 - g_ps2RecompiledFunctionTable[480225] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4f8c - g_ps2RecompiledFunctionTable[480226] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4f90 - g_ps2RecompiledFunctionTable[480227] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4f94 - g_ps2RecompiledFunctionTable[480228] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4f98 - g_ps2RecompiledFunctionTable[480229] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4f9c - g_ps2RecompiledFunctionTable[480230] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4fa0 - g_ps2RecompiledFunctionTable[480231] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4fa4 - g_ps2RecompiledFunctionTable[480232] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4fa8 - g_ps2RecompiledFunctionTable[480233] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4fac - g_ps2RecompiledFunctionTable[480234] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4fb0 - g_ps2RecompiledFunctionTable[480235] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4fb4 - g_ps2RecompiledFunctionTable[480236] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4fb8 - g_ps2RecompiledFunctionTable[480237] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4fbc - g_ps2RecompiledFunctionTable[480238] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4fc0 - g_ps2RecompiledFunctionTable[480239] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4fc4 - g_ps2RecompiledFunctionTable[480240] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4fc8 - g_ps2RecompiledFunctionTable[480241] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4fcc - g_ps2RecompiledFunctionTable[480242] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4fd0 - g_ps2RecompiledFunctionTable[480243] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4fd4 - g_ps2RecompiledFunctionTable[480244] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4fd8 - g_ps2RecompiledFunctionTable[480245] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4fdc - g_ps2RecompiledFunctionTable[480246] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4fe0 - g_ps2RecompiledFunctionTable[480247] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4fe4 - g_ps2RecompiledFunctionTable[480248] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4fe8 - g_ps2RecompiledFunctionTable[480249] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4fec - g_ps2RecompiledFunctionTable[480250] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4ff0 - g_ps2RecompiledFunctionTable[480251] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4ff4 - g_ps2RecompiledFunctionTable[480252] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4ff8 - g_ps2RecompiledFunctionTable[480253] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d4ffc - g_ps2RecompiledFunctionTable[480254] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d5000 - g_ps2RecompiledFunctionTable[480255] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d5004 - g_ps2RecompiledFunctionTable[480256] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d5008 - g_ps2RecompiledFunctionTable[480257] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d500c - g_ps2RecompiledFunctionTable[480258] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d5010 - g_ps2RecompiledFunctionTable[480259] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d5014 - g_ps2RecompiledFunctionTable[480260] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d5018 - g_ps2RecompiledFunctionTable[480261] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d501c - g_ps2RecompiledFunctionTable[480262] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d5020 - g_ps2RecompiledFunctionTable[480263] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d5024 - g_ps2RecompiledFunctionTable[480264] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d5028 - g_ps2RecompiledFunctionTable[480265] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d502c - g_ps2RecompiledFunctionTable[480266] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d5030 - g_ps2RecompiledFunctionTable[480267] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d5034 - g_ps2RecompiledFunctionTable[480268] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d5038 - g_ps2RecompiledFunctionTable[480269] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d503c - g_ps2RecompiledFunctionTable[480270] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d5040 - g_ps2RecompiledFunctionTable[480271] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d5044 - g_ps2RecompiledFunctionTable[480272] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d5048 - g_ps2RecompiledFunctionTable[480273] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d504c - g_ps2RecompiledFunctionTable[480274] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d5050 - g_ps2RecompiledFunctionTable[480275] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d5054 - g_ps2RecompiledFunctionTable[480276] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d5058 - g_ps2RecompiledFunctionTable[480277] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d505c - g_ps2RecompiledFunctionTable[480278] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d5060 - g_ps2RecompiledFunctionTable[480279] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d5064 - g_ps2RecompiledFunctionTable[480280] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d5068 - g_ps2RecompiledFunctionTable[480281] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d506c - g_ps2RecompiledFunctionTable[480282] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d5070 - g_ps2RecompiledFunctionTable[480283] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d5074 - g_ps2RecompiledFunctionTable[480284] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d5078 - g_ps2RecompiledFunctionTable[480285] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d507c - g_ps2RecompiledFunctionTable[480286] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d5080 - g_ps2RecompiledFunctionTable[480287] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d5084 - g_ps2RecompiledFunctionTable[480288] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d5088 - g_ps2RecompiledFunctionTable[480289] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d508c - g_ps2RecompiledFunctionTable[480290] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d5090 - g_ps2RecompiledFunctionTable[480291] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d5094 - g_ps2RecompiledFunctionTable[480292] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d5098 - g_ps2RecompiledFunctionTable[480293] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d509c - g_ps2RecompiledFunctionTable[480294] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d50a0 - g_ps2RecompiledFunctionTable[480295] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d50a4 - g_ps2RecompiledFunctionTable[480296] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d50a8 - g_ps2RecompiledFunctionTable[480297] = vu1DrawTriangleStripTransSingle_0x2d4d90; // 0x2d50ac - g_ps2RecompiledFunctionTable[480298] = ps2__Clip_Screen_0x2d50b0; // 0x2d50b0 - g_ps2RecompiledFunctionTable[480314] = vu1DrawTriangleStripTransDouble_0x2d50f0; // 0x2d50f0 - g_ps2RecompiledFunctionTable[480364] = vu1DrawTriangleStripTransDouble_0x2d50f0; // 0x2d51b8 - g_ps2RecompiledFunctionTable[480396] = vu1DrawTriangleStripTransDouble_0x2d50f0; // 0x2d5238 - g_ps2RecompiledFunctionTable[480404] = vu1DrawTriangleStripTransDouble_0x2d50f0; // 0x2d5258 - g_ps2RecompiledFunctionTable[480431] = vu1DrawTriangleStripTransDouble_0x2d50f0; // 0x2d52c4 - g_ps2RecompiledFunctionTable[480444] = vu1DrawTriangleStripTransDouble_0x2d50f0; // 0x2d52f8 - g_ps2RecompiledFunctionTable[480449] = vu1DrawTriangleStripTransDouble_0x2d50f0; // 0x2d530c - g_ps2RecompiledFunctionTable[480451] = vu1DrawTriangleStripTransDouble_0x2d50f0; // 0x2d5314 - g_ps2RecompiledFunctionTable[480456] = vu1DrawTriangleStripTransDouble_0x2d50f0; // 0x2d5328 - g_ps2RecompiledFunctionTable[480499] = vu1DrawTriangleStripTransDouble_0x2d50f0; // 0x2d53d4 - g_ps2RecompiledFunctionTable[480531] = vu1DrawTriangleStripTransDouble_0x2d50f0; // 0x2d5454 - g_ps2RecompiledFunctionTable[480535] = vu1DrawTriangleStripTransDouble_0x2d50f0; // 0x2d5464 - g_ps2RecompiledFunctionTable[480565] = vu1DrawTriangleStripTransDouble_0x2d50f0; // 0x2d54dc - g_ps2RecompiledFunctionTable[480567] = vu1DrawTriangleStripTransDouble_0x2d50f0; // 0x2d54e4 - g_ps2RecompiledFunctionTable[480589] = vu1DrawTriangleStripTransDouble_0x2d50f0; // 0x2d553c - g_ps2RecompiledFunctionTable[480602] = vu1GetVertexColor_0x2d5570; // 0x2d5570 - g_ps2RecompiledFunctionTable[480618] = vu1GetVertexColorCM_0x2d55b0; // 0x2d55b0 - g_ps2RecompiledFunctionTable[480630] = vu1GetVertexColorIgnore_0x2d55e0; // 0x2d55e0 - g_ps2RecompiledFunctionTable[480642] = vu1GetVertexColorDif_0x2d5610; // 0x2d5610 - g_ps2RecompiledFunctionTable[480658] = vu1GetVertexColorDifAmb_0x2d5650; // 0x2d5650 - g_ps2RecompiledFunctionTable[480670] = vu1GetVertexColorDifSpe1_0x2d5680; // 0x2d5680 - g_ps2RecompiledFunctionTable[480690] = vu1GetVertexColorDifSpe2_0x2d56d0; // 0x2d56d0 - g_ps2RecompiledFunctionTable[480718] = vu1GetVertexColorDifSpe3_0x2d5740; // 0x2d5740 - g_ps2RecompiledFunctionTable[480730] = vu1GetVertexColorDifSpe3_0x2d5740; // 0x2d5770 - g_ps2RecompiledFunctionTable[480750] = vu1GetVertexColorDifSpe1Amb_0x2d57c0; // 0x2d57c0 - g_ps2RecompiledFunctionTable[480778] = vu1GetVertexColorDifSpe2Amb_0x2d5830; // 0x2d5830 - g_ps2RecompiledFunctionTable[480806] = vu1GetVertexColorDifSpe3Amb_0x2d58a0; // 0x2d58a0 - g_ps2RecompiledFunctionTable[480822] = vu1GetVertexColorDifSpe3Amb_0x2d58a0; // 0x2d58e0 - g_ps2RecompiledFunctionTable[480842] = vu1RotTransStripBuf_0x2d5930; // 0x2d5930 - g_ps2RecompiledFunctionTable[480848] = vu1RotTransStripBuf_0x2d5930; // 0x2d5948 - g_ps2RecompiledFunctionTable[480869] = vu1RotTransStripBuf_0x2d5930; // 0x2d599c - g_ps2RecompiledFunctionTable[480874] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d59b0 - g_ps2RecompiledFunctionTable[480875] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d59b4 - g_ps2RecompiledFunctionTable[480876] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d59b8 - g_ps2RecompiledFunctionTable[480877] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d59bc - g_ps2RecompiledFunctionTable[480878] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d59c0 - g_ps2RecompiledFunctionTable[480879] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d59c4 - g_ps2RecompiledFunctionTable[480880] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d59c8 - g_ps2RecompiledFunctionTable[480881] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d59cc - g_ps2RecompiledFunctionTable[480882] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d59d0 - g_ps2RecompiledFunctionTable[480883] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d59d4 - g_ps2RecompiledFunctionTable[480884] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d59d8 - g_ps2RecompiledFunctionTable[480885] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d59dc - g_ps2RecompiledFunctionTable[480886] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d59e0 - g_ps2RecompiledFunctionTable[480887] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d59e4 - g_ps2RecompiledFunctionTable[480888] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d59e8 - g_ps2RecompiledFunctionTable[480889] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d59ec - g_ps2RecompiledFunctionTable[480890] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d59f0 - g_ps2RecompiledFunctionTable[480891] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d59f4 - g_ps2RecompiledFunctionTable[480892] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d59f8 - g_ps2RecompiledFunctionTable[480893] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d59fc - g_ps2RecompiledFunctionTable[480894] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5a00 - g_ps2RecompiledFunctionTable[480895] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5a04 - g_ps2RecompiledFunctionTable[480896] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5a08 - g_ps2RecompiledFunctionTable[480897] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5a0c - g_ps2RecompiledFunctionTable[480898] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5a10 - g_ps2RecompiledFunctionTable[480899] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5a14 - g_ps2RecompiledFunctionTable[480900] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5a18 - g_ps2RecompiledFunctionTable[480901] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5a1c - g_ps2RecompiledFunctionTable[480902] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5a20 - g_ps2RecompiledFunctionTable[480903] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5a24 - g_ps2RecompiledFunctionTable[480904] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5a28 - g_ps2RecompiledFunctionTable[480905] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5a2c - g_ps2RecompiledFunctionTable[480906] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5a30 - g_ps2RecompiledFunctionTable[480907] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5a34 - g_ps2RecompiledFunctionTable[480908] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5a38 - g_ps2RecompiledFunctionTable[480909] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5a3c - g_ps2RecompiledFunctionTable[480910] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5a40 - g_ps2RecompiledFunctionTable[480911] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5a44 - g_ps2RecompiledFunctionTable[480912] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5a48 - g_ps2RecompiledFunctionTable[480913] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5a4c - g_ps2RecompiledFunctionTable[480914] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5a50 - g_ps2RecompiledFunctionTable[480915] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5a54 - g_ps2RecompiledFunctionTable[480916] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5a58 - g_ps2RecompiledFunctionTable[480917] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5a5c - g_ps2RecompiledFunctionTable[480918] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5a60 - g_ps2RecompiledFunctionTable[480919] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5a64 - g_ps2RecompiledFunctionTable[480920] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5a68 - g_ps2RecompiledFunctionTable[480921] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5a6c - g_ps2RecompiledFunctionTable[480922] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5a70 - g_ps2RecompiledFunctionTable[480923] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5a74 - g_ps2RecompiledFunctionTable[480924] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5a78 - g_ps2RecompiledFunctionTable[480925] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5a7c - g_ps2RecompiledFunctionTable[480926] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5a80 - g_ps2RecompiledFunctionTable[480927] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5a84 - g_ps2RecompiledFunctionTable[480928] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5a88 - g_ps2RecompiledFunctionTable[480929] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5a8c - g_ps2RecompiledFunctionTable[480930] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5a90 - g_ps2RecompiledFunctionTable[480931] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5a94 - g_ps2RecompiledFunctionTable[480932] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5a98 - g_ps2RecompiledFunctionTable[480933] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5a9c - g_ps2RecompiledFunctionTable[480934] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5aa0 - g_ps2RecompiledFunctionTable[480935] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5aa4 - g_ps2RecompiledFunctionTable[480936] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5aa8 - g_ps2RecompiledFunctionTable[480937] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5aac - g_ps2RecompiledFunctionTable[480938] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5ab0 - g_ps2RecompiledFunctionTable[480939] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5ab4 - g_ps2RecompiledFunctionTable[480940] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5ab8 - g_ps2RecompiledFunctionTable[480941] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5abc - g_ps2RecompiledFunctionTable[480942] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5ac0 - g_ps2RecompiledFunctionTable[480943] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5ac4 - g_ps2RecompiledFunctionTable[480944] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5ac8 - g_ps2RecompiledFunctionTable[480945] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5acc - g_ps2RecompiledFunctionTable[480946] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5ad0 - g_ps2RecompiledFunctionTable[480947] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5ad4 - g_ps2RecompiledFunctionTable[480948] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5ad8 - g_ps2RecompiledFunctionTable[480949] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5adc - g_ps2RecompiledFunctionTable[480950] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5ae0 - g_ps2RecompiledFunctionTable[480951] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5ae4 - g_ps2RecompiledFunctionTable[480952] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5ae8 - g_ps2RecompiledFunctionTable[480953] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5aec - g_ps2RecompiledFunctionTable[480954] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5af0 - g_ps2RecompiledFunctionTable[480955] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5af4 - g_ps2RecompiledFunctionTable[480956] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5af8 - g_ps2RecompiledFunctionTable[480957] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5afc - g_ps2RecompiledFunctionTable[480958] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5b00 - g_ps2RecompiledFunctionTable[480959] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5b04 - g_ps2RecompiledFunctionTable[480960] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5b08 - g_ps2RecompiledFunctionTable[480961] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5b0c - g_ps2RecompiledFunctionTable[480962] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5b10 - g_ps2RecompiledFunctionTable[480963] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5b14 - g_ps2RecompiledFunctionTable[480964] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5b18 - g_ps2RecompiledFunctionTable[480965] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5b1c - g_ps2RecompiledFunctionTable[480966] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5b20 - g_ps2RecompiledFunctionTable[480967] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5b24 - g_ps2RecompiledFunctionTable[480968] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5b28 - g_ps2RecompiledFunctionTable[480969] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5b2c - g_ps2RecompiledFunctionTable[480970] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5b30 - g_ps2RecompiledFunctionTable[480971] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5b34 - g_ps2RecompiledFunctionTable[480972] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5b38 - g_ps2RecompiledFunctionTable[480973] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5b3c - g_ps2RecompiledFunctionTable[480974] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5b40 - g_ps2RecompiledFunctionTable[480975] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5b44 - g_ps2RecompiledFunctionTable[480976] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5b48 - g_ps2RecompiledFunctionTable[480977] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5b4c - g_ps2RecompiledFunctionTable[480978] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5b50 - g_ps2RecompiledFunctionTable[480979] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5b54 - g_ps2RecompiledFunctionTable[480980] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5b58 - g_ps2RecompiledFunctionTable[480981] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5b5c - g_ps2RecompiledFunctionTable[480982] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5b60 - g_ps2RecompiledFunctionTable[480983] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5b64 - g_ps2RecompiledFunctionTable[480984] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5b68 - g_ps2RecompiledFunctionTable[480985] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5b6c - g_ps2RecompiledFunctionTable[480986] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5b70 - g_ps2RecompiledFunctionTable[480987] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5b74 - g_ps2RecompiledFunctionTable[480988] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5b78 - g_ps2RecompiledFunctionTable[480989] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5b7c - g_ps2RecompiledFunctionTable[480990] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5b80 - g_ps2RecompiledFunctionTable[480991] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5b84 - g_ps2RecompiledFunctionTable[480992] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5b88 - g_ps2RecompiledFunctionTable[480993] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5b8c - g_ps2RecompiledFunctionTable[480994] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5b90 - g_ps2RecompiledFunctionTable[480995] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5b94 - g_ps2RecompiledFunctionTable[480996] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5b98 - g_ps2RecompiledFunctionTable[480997] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5b9c - g_ps2RecompiledFunctionTable[480998] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5ba0 - g_ps2RecompiledFunctionTable[480999] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5ba4 - g_ps2RecompiledFunctionTable[481000] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5ba8 - g_ps2RecompiledFunctionTable[481001] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5bac - g_ps2RecompiledFunctionTable[481002] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5bb0 - g_ps2RecompiledFunctionTable[481003] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5bb4 - g_ps2RecompiledFunctionTable[481004] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5bb8 - g_ps2RecompiledFunctionTable[481005] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5bbc - g_ps2RecompiledFunctionTable[481006] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5bc0 - g_ps2RecompiledFunctionTable[481007] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5bc4 - g_ps2RecompiledFunctionTable[481008] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5bc8 - g_ps2RecompiledFunctionTable[481009] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5bcc - g_ps2RecompiledFunctionTable[481010] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5bd0 - g_ps2RecompiledFunctionTable[481011] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5bd4 - g_ps2RecompiledFunctionTable[481012] = vu1DrawTriangleStripTransDoubleI_0x2d59b0; // 0x2d5bd8 - g_ps2RecompiledFunctionTable[481014] = DrawScissorPolygonTrans1P_0x2d5be0; // 0x2d5be0 - g_ps2RecompiledFunctionTable[481022] = DrawScissorPolygonTrans1P_0x2d5be0; // 0x2d5c00 - g_ps2RecompiledFunctionTable[481062] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5ca0 - g_ps2RecompiledFunctionTable[481063] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5ca4 - g_ps2RecompiledFunctionTable[481064] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5ca8 - g_ps2RecompiledFunctionTable[481065] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5cac - g_ps2RecompiledFunctionTable[481066] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5cb0 - g_ps2RecompiledFunctionTable[481067] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5cb4 - g_ps2RecompiledFunctionTable[481068] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5cb8 - g_ps2RecompiledFunctionTable[481069] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5cbc - g_ps2RecompiledFunctionTable[481070] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5cc0 - g_ps2RecompiledFunctionTable[481071] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5cc4 - g_ps2RecompiledFunctionTable[481072] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5cc8 - g_ps2RecompiledFunctionTable[481073] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5ccc - g_ps2RecompiledFunctionTable[481074] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5cd0 - g_ps2RecompiledFunctionTable[481075] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5cd4 - g_ps2RecompiledFunctionTable[481076] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5cd8 - g_ps2RecompiledFunctionTable[481077] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5cdc - g_ps2RecompiledFunctionTable[481078] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5ce0 - g_ps2RecompiledFunctionTable[481079] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5ce4 - g_ps2RecompiledFunctionTable[481080] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5ce8 - g_ps2RecompiledFunctionTable[481081] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5cec - g_ps2RecompiledFunctionTable[481082] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5cf0 - g_ps2RecompiledFunctionTable[481083] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5cf4 - g_ps2RecompiledFunctionTable[481084] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5cf8 - g_ps2RecompiledFunctionTable[481085] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5cfc - g_ps2RecompiledFunctionTable[481086] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5d00 - g_ps2RecompiledFunctionTable[481087] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5d04 - g_ps2RecompiledFunctionTable[481088] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5d08 - g_ps2RecompiledFunctionTable[481089] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5d0c - g_ps2RecompiledFunctionTable[481090] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5d10 - g_ps2RecompiledFunctionTable[481091] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5d14 - g_ps2RecompiledFunctionTable[481092] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5d18 - g_ps2RecompiledFunctionTable[481093] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5d1c - g_ps2RecompiledFunctionTable[481094] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5d20 - g_ps2RecompiledFunctionTable[481095] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5d24 - g_ps2RecompiledFunctionTable[481096] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5d28 - g_ps2RecompiledFunctionTable[481097] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5d2c - g_ps2RecompiledFunctionTable[481098] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5d30 - g_ps2RecompiledFunctionTable[481099] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5d34 - g_ps2RecompiledFunctionTable[481100] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5d38 - g_ps2RecompiledFunctionTable[481101] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5d3c - g_ps2RecompiledFunctionTable[481102] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5d40 - g_ps2RecompiledFunctionTable[481103] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5d44 - g_ps2RecompiledFunctionTable[481104] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5d48 - g_ps2RecompiledFunctionTable[481105] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5d4c - g_ps2RecompiledFunctionTable[481106] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5d50 - g_ps2RecompiledFunctionTable[481107] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5d54 - g_ps2RecompiledFunctionTable[481108] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5d58 - g_ps2RecompiledFunctionTable[481109] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5d5c - g_ps2RecompiledFunctionTable[481110] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5d60 - g_ps2RecompiledFunctionTable[481111] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5d64 - g_ps2RecompiledFunctionTable[481112] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5d68 - g_ps2RecompiledFunctionTable[481113] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5d6c - g_ps2RecompiledFunctionTable[481114] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5d70 - g_ps2RecompiledFunctionTable[481115] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5d74 - g_ps2RecompiledFunctionTable[481116] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5d78 - g_ps2RecompiledFunctionTable[481117] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5d7c - g_ps2RecompiledFunctionTable[481118] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5d80 - g_ps2RecompiledFunctionTable[481119] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5d84 - g_ps2RecompiledFunctionTable[481120] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5d88 - g_ps2RecompiledFunctionTable[481121] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5d8c - g_ps2RecompiledFunctionTable[481122] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5d90 - g_ps2RecompiledFunctionTable[481123] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5d94 - g_ps2RecompiledFunctionTable[481124] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5d98 - g_ps2RecompiledFunctionTable[481125] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5d9c - g_ps2RecompiledFunctionTable[481126] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5da0 - g_ps2RecompiledFunctionTable[481127] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5da4 - g_ps2RecompiledFunctionTable[481128] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5da8 - g_ps2RecompiledFunctionTable[481129] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5dac - g_ps2RecompiledFunctionTable[481130] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5db0 - g_ps2RecompiledFunctionTable[481131] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5db4 - g_ps2RecompiledFunctionTable[481132] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5db8 - g_ps2RecompiledFunctionTable[481133] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5dbc - g_ps2RecompiledFunctionTable[481134] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5dc0 - g_ps2RecompiledFunctionTable[481135] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5dc4 - g_ps2RecompiledFunctionTable[481136] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5dc8 - g_ps2RecompiledFunctionTable[481137] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5dcc - g_ps2RecompiledFunctionTable[481138] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5dd0 - g_ps2RecompiledFunctionTable[481139] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5dd4 - g_ps2RecompiledFunctionTable[481140] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5dd8 - g_ps2RecompiledFunctionTable[481141] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5ddc - g_ps2RecompiledFunctionTable[481142] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5de0 - g_ps2RecompiledFunctionTable[481143] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5de4 - g_ps2RecompiledFunctionTable[481144] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5de8 - g_ps2RecompiledFunctionTable[481145] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5dec - g_ps2RecompiledFunctionTable[481146] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5df0 - g_ps2RecompiledFunctionTable[481147] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5df4 - g_ps2RecompiledFunctionTable[481148] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5df8 - g_ps2RecompiledFunctionTable[481149] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5dfc - g_ps2RecompiledFunctionTable[481150] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5e00 - g_ps2RecompiledFunctionTable[481151] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5e04 - g_ps2RecompiledFunctionTable[481152] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5e08 - g_ps2RecompiledFunctionTable[481153] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5e0c - g_ps2RecompiledFunctionTable[481154] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5e10 - g_ps2RecompiledFunctionTable[481155] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5e14 - g_ps2RecompiledFunctionTable[481156] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5e18 - g_ps2RecompiledFunctionTable[481157] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5e1c - g_ps2RecompiledFunctionTable[481158] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5e20 - g_ps2RecompiledFunctionTable[481159] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5e24 - g_ps2RecompiledFunctionTable[481160] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5e28 - g_ps2RecompiledFunctionTable[481161] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5e2c - g_ps2RecompiledFunctionTable[481162] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5e30 - g_ps2RecompiledFunctionTable[481163] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5e34 - g_ps2RecompiledFunctionTable[481164] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5e38 - g_ps2RecompiledFunctionTable[481165] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5e3c - g_ps2RecompiledFunctionTable[481166] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5e40 - g_ps2RecompiledFunctionTable[481167] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5e44 - g_ps2RecompiledFunctionTable[481168] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5e48 - g_ps2RecompiledFunctionTable[481169] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5e4c - g_ps2RecompiledFunctionTable[481170] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5e50 - g_ps2RecompiledFunctionTable[481171] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5e54 - g_ps2RecompiledFunctionTable[481172] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5e58 - g_ps2RecompiledFunctionTable[481173] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5e5c - g_ps2RecompiledFunctionTable[481174] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5e60 - g_ps2RecompiledFunctionTable[481175] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5e64 - g_ps2RecompiledFunctionTable[481176] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5e68 - g_ps2RecompiledFunctionTable[481177] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5e6c - g_ps2RecompiledFunctionTable[481178] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5e70 - g_ps2RecompiledFunctionTable[481179] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5e74 - g_ps2RecompiledFunctionTable[481180] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5e78 - g_ps2RecompiledFunctionTable[481181] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5e7c - g_ps2RecompiledFunctionTable[481182] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5e80 - g_ps2RecompiledFunctionTable[481183] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5e84 - g_ps2RecompiledFunctionTable[481184] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5e88 - g_ps2RecompiledFunctionTable[481185] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5e8c - g_ps2RecompiledFunctionTable[481186] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5e90 - g_ps2RecompiledFunctionTable[481187] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5e94 - g_ps2RecompiledFunctionTable[481188] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5e98 - g_ps2RecompiledFunctionTable[481189] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5e9c - g_ps2RecompiledFunctionTable[481190] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5ea0 - g_ps2RecompiledFunctionTable[481191] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5ea4 - g_ps2RecompiledFunctionTable[481192] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5ea8 - g_ps2RecompiledFunctionTable[481193] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5eac - g_ps2RecompiledFunctionTable[481194] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5eb0 - g_ps2RecompiledFunctionTable[481195] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5eb4 - g_ps2RecompiledFunctionTable[481196] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5eb8 - g_ps2RecompiledFunctionTable[481197] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5ebc - g_ps2RecompiledFunctionTable[481198] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5ec0 - g_ps2RecompiledFunctionTable[481199] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5ec4 - g_ps2RecompiledFunctionTable[481200] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5ec8 - g_ps2RecompiledFunctionTable[481201] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5ecc - g_ps2RecompiledFunctionTable[481202] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5ed0 - g_ps2RecompiledFunctionTable[481203] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5ed4 - g_ps2RecompiledFunctionTable[481204] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5ed8 - g_ps2RecompiledFunctionTable[481205] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5edc - g_ps2RecompiledFunctionTable[481206] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5ee0 - g_ps2RecompiledFunctionTable[481207] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5ee4 - g_ps2RecompiledFunctionTable[481208] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5ee8 - g_ps2RecompiledFunctionTable[481209] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5eec - g_ps2RecompiledFunctionTable[481210] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5ef0 - g_ps2RecompiledFunctionTable[481211] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5ef4 - g_ps2RecompiledFunctionTable[481212] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5ef8 - g_ps2RecompiledFunctionTable[481213] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5efc - g_ps2RecompiledFunctionTable[481214] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5f00 - g_ps2RecompiledFunctionTable[481215] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5f04 - g_ps2RecompiledFunctionTable[481216] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5f08 - g_ps2RecompiledFunctionTable[481217] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5f0c - g_ps2RecompiledFunctionTable[481218] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5f10 - g_ps2RecompiledFunctionTable[481219] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5f14 - g_ps2RecompiledFunctionTable[481220] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5f18 - g_ps2RecompiledFunctionTable[481221] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5f1c - g_ps2RecompiledFunctionTable[481222] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5f20 - g_ps2RecompiledFunctionTable[481223] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5f24 - g_ps2RecompiledFunctionTable[481224] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5f28 - g_ps2RecompiledFunctionTable[481225] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5f2c - g_ps2RecompiledFunctionTable[481226] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5f30 - g_ps2RecompiledFunctionTable[481227] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5f34 - g_ps2RecompiledFunctionTable[481228] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5f38 - g_ps2RecompiledFunctionTable[481229] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5f3c - g_ps2RecompiledFunctionTable[481230] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5f40 - g_ps2RecompiledFunctionTable[481231] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5f44 - g_ps2RecompiledFunctionTable[481232] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5f48 - g_ps2RecompiledFunctionTable[481233] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5f4c - g_ps2RecompiledFunctionTable[481234] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5f50 - g_ps2RecompiledFunctionTable[481235] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5f54 - g_ps2RecompiledFunctionTable[481236] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5f58 - g_ps2RecompiledFunctionTable[481237] = vu1DrawTriangleStripTransDouble1P_0x2d5ca0; // 0x2d5f5c - g_ps2RecompiledFunctionTable[481238] = njFogEnable_0x2d5f60; // 0x2d5f60 - g_ps2RecompiledFunctionTable[481242] = njFogDisable_0x2d5f70; // 0x2d5f70 - g_ps2RecompiledFunctionTable[481246] = njSetFogColor_0x2d5f80; // 0x2d5f80 - g_ps2RecompiledFunctionTable[481342] = njSetFogTable_0x2d6100; // 0x2d6100 - g_ps2RecompiledFunctionTable[481346] = njGenerateFogTable3_0x2d6110; // 0x2d6110 - g_ps2RecompiledFunctionTable[481366] = njGenerateFogTable3_0x2d6110; // 0x2d6160 - g_ps2RecompiledFunctionTable[481373] = njGenerateFogTable3_0x2d6110; // 0x2d617c - g_ps2RecompiledFunctionTable[481422] = njGenerateFogTable3_0x2d6110; // 0x2d6240 - g_ps2RecompiledFunctionTable[481470] = njGenerateFogTable3_0x2d6110; // 0x2d6300 - g_ps2RecompiledFunctionTable[481494] = njGenerateFogTable3_0x2d6110; // 0x2d6360 - g_ps2RecompiledFunctionTable[481507] = njGenerateFogTable3_0x2d6110; // 0x2d6394 - g_ps2RecompiledFunctionTable[481522] = njCalcFogPowerEx_0x2d63d0; // 0x2d63d0 - g_ps2RecompiledFunctionTable[481606] = njCalcFogPower_0x2d6520; // 0x2d6520 - g_ps2RecompiledFunctionTable[481706] = njInitMatrix_0x2d66b0; // 0x2d66b0 - g_ps2RecompiledFunctionTable[481758] = njCalcPoints_0x2d6780; // 0x2d6780 - g_ps2RecompiledFunctionTable[481775] = njCalcPoints_0x2d6780; // 0x2d67c4 - g_ps2RecompiledFunctionTable[481798] = njGetTranslation_0x2d6820; // 0x2d6820 - g_ps2RecompiledFunctionTable[481814] = njUnitTransPortion_0x2d6860; // 0x2d6860 - g_ps2RecompiledFunctionTable[481822] = njUnitRotPortion_0x2d6880; // 0x2d6880 - g_ps2RecompiledFunctionTable[481838] = njClearMatrix_0x2d68c0; // 0x2d68c0 - g_ps2RecompiledFunctionTable[481850] = njPushMatrix_0x2d68f0; // 0x2d68f0 - g_ps2RecompiledFunctionTable[481886] = njPopMatrix_0x2d6980; // 0x2d6980 - g_ps2RecompiledFunctionTable[481906] = njUnitMatrix_0x2d69d0; // 0x2d69d0 - g_ps2RecompiledFunctionTable[481922] = njSetMatrix_0x2d6a10; // 0x2d6a10 - g_ps2RecompiledFunctionTable[481942] = njSetMatrixCN_0x2d6a60; // 0x2d6a60 - g_ps2RecompiledFunctionTable[481950] = njGetMatrix_0x2d6a80; // 0x2d6a80 - g_ps2RecompiledFunctionTable[481966] = njMultiMatrix_0x2d6ac0; // 0x2d6ac0 - g_ps2RecompiledFunctionTable[481998] = njTranslate_0x2d6b40; // 0x2d6b40 - g_ps2RecompiledFunctionTable[482022] = njTranslateV_0x2d6ba0; // 0x2d6ba0 - g_ps2RecompiledFunctionTable[482046] = njRotateX_0x2d6c00; // 0x2d6c00 - g_ps2RecompiledFunctionTable[482055] = njRotateX_0x2d6c00; // 0x2d6c24 - g_ps2RecompiledFunctionTable[482082] = njRotateY_0x2d6c90; // 0x2d6c90 - g_ps2RecompiledFunctionTable[482091] = njRotateY_0x2d6c90; // 0x2d6cb4 - g_ps2RecompiledFunctionTable[482118] = njRotateZ_0x2d6d20; // 0x2d6d20 - g_ps2RecompiledFunctionTable[482127] = njRotateZ_0x2d6d20; // 0x2d6d44 - g_ps2RecompiledFunctionTable[482154] = njRotateXYZ_0x2d6db0; // 0x2d6db0 - g_ps2RecompiledFunctionTable[482169] = njRotateXYZ_0x2d6db0; // 0x2d6dec - g_ps2RecompiledFunctionTable[482172] = njRotateXYZ_0x2d6db0; // 0x2d6df8 - g_ps2RecompiledFunctionTable[482175] = njRotateXYZ_0x2d6db0; // 0x2d6e04 - g_ps2RecompiledFunctionTable[482182] = njRotXYZ_0x2d6e20; // 0x2d6e20 - g_ps2RecompiledFunctionTable[482195] = njRotXYZ_0x2d6e20; // 0x2d6e54 - g_ps2RecompiledFunctionTable[482210] = njRotXYZ_0x2d6e20; // 0x2d6e90 - g_ps2RecompiledFunctionTable[482222] = njRotXYZ_0x2d6e20; // 0x2d6ec0 - g_ps2RecompiledFunctionTable[482238] = njRotate_0x2d6f00; // 0x2d6f00 - g_ps2RecompiledFunctionTable[482254] = njRotate_0x2d6f00; // 0x2d6f40 - g_ps2RecompiledFunctionTable[482326] = njScale_0x2d7060; // 0x2d7060 - g_ps2RecompiledFunctionTable[482350] = njScaleV_0x2d70c0; // 0x2d70c0 - g_ps2RecompiledFunctionTable[482374] = njInvertMatrix_0x2d7120; // 0x2d7120 - g_ps2RecompiledFunctionTable[482410] = njTransposeMatrix_0x2d71b0; // 0x2d71b0 - g_ps2RecompiledFunctionTable[482434] = njAtan2b_0x2d7210; // 0x2d7210 - g_ps2RecompiledFunctionTable[482440] = njAtan2b_0x2d7210; // 0x2d7228 - g_ps2RecompiledFunctionTable[482443] = njAtan2b_0x2d7210; // 0x2d7234 - g_ps2RecompiledFunctionTable[482446] = njAtan2b_0x2d7210; // 0x2d7240 - g_ps2RecompiledFunctionTable[482448] = njAtan2b_0x2d7210; // 0x2d7248 - g_ps2RecompiledFunctionTable[482454] = njMirror_0x2d7260; // 0x2d7260 - g_ps2RecompiledFunctionTable[482535] = njMirror_0x2d7260; // 0x2d73a4 - g_ps2RecompiledFunctionTable[482564] = njMirror_0x2d7260; // 0x2d7418 - g_ps2RecompiledFunctionTable[482580] = njMirror_0x2d7260; // 0x2d7458 - g_ps2RecompiledFunctionTable[482583] = njMirror_0x2d7260; // 0x2d7464 - g_ps2RecompiledFunctionTable[482586] = njMirror_0x2d7260; // 0x2d7470 - g_ps2RecompiledFunctionTable[482593] = njMirror_0x2d7260; // 0x2d748c - g_ps2RecompiledFunctionTable[482597] = njMirror_0x2d7260; // 0x2d749c - g_ps2RecompiledFunctionTable[482601] = njMirror_0x2d7260; // 0x2d74ac - g_ps2RecompiledFunctionTable[482604] = njMirror_0x2d7260; // 0x2d74b8 - g_ps2RecompiledFunctionTable[482610] = njCalcPoint_0x2d74d0; // 0x2d74d0 - g_ps2RecompiledFunctionTable[482638] = njCalcPoint4_0x2d7540; // 0x2d7540 - g_ps2RecompiledFunctionTable[482658] = njCalcPointCN_0x2d7590; // 0x2d7590 - g_ps2RecompiledFunctionTable[482674] = njAddVector_0x2d75d0; // 0x2d75d0 - g_ps2RecompiledFunctionTable[482690] = njSubVector_0x2d7610; // 0x2d7610 - g_ps2RecompiledFunctionTable[482706] = njCalcVector_0x2d7650; // 0x2d7650 - g_ps2RecompiledFunctionTable[482730] = njUnitVector_0x2d76b0; // 0x2d76b0 - g_ps2RecompiledFunctionTable[482754] = njScalor_0x2d7710; // 0x2d7710 - g_ps2RecompiledFunctionTable[482770] = njScalor2_0x2d7750; // 0x2d7750 - g_ps2RecompiledFunctionTable[482782] = njProjectScreen_0x2d7780; // 0x2d7780 - g_ps2RecompiledFunctionTable[482796] = njProjectScreen_0x2d7780; // 0x2d77b8 - g_ps2RecompiledFunctionTable[482799] = njProjectScreen_0x2d7780; // 0x2d77c4 - g_ps2RecompiledFunctionTable[482826] = njOuterProduct_0x2d7830; // 0x2d7830 - g_ps2RecompiledFunctionTable[482854] = njInnerProduct_0x2d78a0; // 0x2d78a0 - g_ps2RecompiledFunctionTable[482874] = njTranslateEx_0x2d78f0; // 0x2d78f0 - g_ps2RecompiledFunctionTable[482894] = njRotateEx_0x2d7940; // 0x2d7940 - g_ps2RecompiledFunctionTable[482902] = njRotateEx_0x2d7940; // 0x2d7960 - g_ps2RecompiledFunctionTable[482905] = njRotateEx_0x2d7940; // 0x2d796c - g_ps2RecompiledFunctionTable[482908] = njRotateEx_0x2d7940; // 0x2d7978 - g_ps2RecompiledFunctionTable[482913] = njRotateEx_0x2d7940; // 0x2d798c - g_ps2RecompiledFunctionTable[482916] = njRotateEx_0x2d7940; // 0x2d7998 - g_ps2RecompiledFunctionTable[482919] = njRotateEx_0x2d7940; // 0x2d79a4 - g_ps2RecompiledFunctionTable[482926] = njScaleEx_0x2d79c0; // 0x2d79c0 - g_ps2RecompiledFunctionTable[482946] = njPushMatrixEx_0x2d7a10; // 0x2d7a10 - g_ps2RecompiledFunctionTable[482950] = njPopMatrixEx_0x2d7a20; // 0x2d7a20 - g_ps2RecompiledFunctionTable[482954] = njRotTransPers_0x2d7a30; // 0x2d7a30 - g_ps2RecompiledFunctionTable[482964] = njRotTransPers_0x2d7a30; // 0x2d7a58 - g_ps2RecompiledFunctionTable[482967] = njRotTransPers_0x2d7a30; // 0x2d7a64 - g_ps2RecompiledFunctionTable[482992] = njRotTransPers_0x2d7a30; // 0x2d7ac8 - g_ps2RecompiledFunctionTable[482998] = njRotTrans_0x2d7ae0; // 0x2d7ae0 - g_ps2RecompiledFunctionTable[483008] = njRotTrans_0x2d7ae0; // 0x2d7b08 - g_ps2RecompiledFunctionTable[483011] = njRotTrans_0x2d7ae0; // 0x2d7b14 - g_ps2RecompiledFunctionTable[483018] = njPers_0x2d7b30; // 0x2d7b30 - g_ps2RecompiledFunctionTable[483050] = njCopyMatrix_0x2d7bb0; // 0x2d7bb0 - g_ps2RecompiledFunctionTable[483062] = njMulMatrixCN_0x2d7be0; // 0x2d7be0 - g_ps2RecompiledFunctionTable[483090] = ps2__Make_SinTable_0x2d7c50; // 0x2d7c50 - g_ps2RecompiledFunctionTable[483097] = ps2__Make_SinTable_0x2d7c50; // 0x2d7c6c - g_ps2RecompiledFunctionTable[483104] = ps2__Make_SinTable_0x2d7c50; // 0x2d7c88 - g_ps2RecompiledFunctionTable[483114] = njSin_0x2d7cb0; // 0x2d7cb0 - g_ps2RecompiledFunctionTable[483150] = njCos_0x2d7d40; // 0x2d7d40 - g_ps2RecompiledFunctionTable[483186] = njSinCos_0x2d7dd0; // 0x2d7dd0 - g_ps2RecompiledFunctionTable[483246] = njFraction_0x2d7ec0; // 0x2d7ec0 - g_ps2RecompiledFunctionTable[483251] = njFraction_0x2d7ec0; // 0x2d7ed4 - g_ps2RecompiledFunctionTable[483258] = njSqrt_0x2d7ef0; // 0x2d7ef0 - g_ps2RecompiledFunctionTable[483270] = njInvertSqrt_0x2d7f20; // 0x2d7f20 - g_ps2RecompiledFunctionTable[483282] = njLinear_0x2d7f50; // 0x2d7f50 - g_ps2RecompiledFunctionTable[483306] = njOverhauserSpline_0x2d7fb0; // 0x2d7fb0 - g_ps2RecompiledFunctionTable[483366] = njBezierSpline_0x2d80a0; // 0x2d80a0 - g_ps2RecompiledFunctionTable[483389] = njBezierSpline_0x2d80a0; // 0x2d80fc - g_ps2RecompiledFunctionTable[483408] = njBezierSpline_0x2d80a0; // 0x2d8148 - g_ps2RecompiledFunctionTable[483411] = njBezierSpline_0x2d80a0; // 0x2d8154 - g_ps2RecompiledFunctionTable[483414] = njBezierSpline_0x2d80a0; // 0x2d8160 - g_ps2RecompiledFunctionTable[483446] = njBezierSpline_0x2d80a0; // 0x2d81e0 - g_ps2RecompiledFunctionTable[483460] = njBezierSpline_0x2d80a0; // 0x2d8218 - g_ps2RecompiledFunctionTable[483494] = njFactorial_0x2d82a0; // 0x2d82a0 - g_ps2RecompiledFunctionTable[483496] = njFactorial_0x2d82a0; // 0x2d82a8 - g_ps2RecompiledFunctionTable[483506] = njGetPeripheral_0x2d82d0; // 0x2d82d0 - g_ps2RecompiledFunctionTable[483510] = njPtclPolygonStart_0x2d82e0; // 0x2d82e0 - g_ps2RecompiledFunctionTable[483514] = njPtclPolygonEnd_0x2d82f0; // 0x2d82f0 - g_ps2RecompiledFunctionTable[483518] = njPtclDrawPolygon_0x2d8300; // 0x2d8300 - g_ps2RecompiledFunctionTable[483550] = njPtclDrawPolygon_0x2d8300; // 0x2d8380 - g_ps2RecompiledFunctionTable[483561] = njPtclDrawPolygon_0x2d8300; // 0x2d83ac - g_ps2RecompiledFunctionTable[483608] = njPtclDrawPolygon_0x2d8300; // 0x2d8468 - g_ps2RecompiledFunctionTable[483615] = njPtclDrawPolygon_0x2d8300; // 0x2d8484 - g_ps2RecompiledFunctionTable[483630] = njPtclSpriteStart_0x2d84c0; // 0x2d84c0 - g_ps2RecompiledFunctionTable[483638] = njPtclSpriteEnd_0x2d84e0; // 0x2d84e0 - g_ps2RecompiledFunctionTable[483642] = njPtclDrawSprite_0x2d84f0; // 0x2d84f0 - g_ps2RecompiledFunctionTable[483679] = njPtclDrawSprite_0x2d84f0; // 0x2d8584 - g_ps2RecompiledFunctionTable[483690] = njPtclDrawSprite_0x2d84f0; // 0x2d85b0 - g_ps2RecompiledFunctionTable[483754] = njPtclDrawSprite_0x2d84f0; // 0x2d86b0 - g_ps2RecompiledFunctionTable[483761] = njPtclDrawSprite_0x2d84f0; // 0x2d86cc - g_ps2RecompiledFunctionTable[483774] = mwPlyCalcWorkSofdec_0x2d8700; // 0x2d8700 - g_ps2RecompiledFunctionTable[483778] = ps2mwPlyCreateSofdec_0x2d8710; // 0x2d8710 - g_ps2RecompiledFunctionTable[483785] = ps2mwPlyCreateSofdec_0x2d8710; // 0x2d872c - g_ps2RecompiledFunctionTable[483787] = ps2mwPlyCreateSofdec_0x2d8710; // 0x2d8734 - g_ps2RecompiledFunctionTable[483790] = ps2mwPlyCreateSofdec_0x2d8710; // 0x2d8740 - g_ps2RecompiledFunctionTable[483804] = ps2mwPlyCreateSofdec_0x2d8710; // 0x2d8778 - g_ps2RecompiledFunctionTable[483814] = ps2mwPlyCreateSofdec_0x2d8710; // 0x2d87a0 - g_ps2RecompiledFunctionTable[483827] = ps2mwPlyCreateSofdec_0x2d8710; // 0x2d87d4 - g_ps2RecompiledFunctionTable[483829] = ps2mwPlyCreateSofdec_0x2d8710; // 0x2d87dc - g_ps2RecompiledFunctionTable[483833] = ps2mwPlyCreateSofdec_0x2d8710; // 0x2d87ec - g_ps2RecompiledFunctionTable[483836] = ps2mwPlyCreateSofdec_0x2d8710; // 0x2d87f8 - g_ps2RecompiledFunctionTable[483839] = ps2mwPlyCreateSofdec_0x2d8710; // 0x2d8804 - g_ps2RecompiledFunctionTable[483850] = ps2mwPlyCreateSofdec_0x2d8710; // 0x2d8830 - g_ps2RecompiledFunctionTable[483854] = ps2mwPlyCreateSofdec_0x2d8710; // 0x2d8840 - g_ps2RecompiledFunctionTable[483858] = ps2mwPlyCreateSofdec_0x2d8710; // 0x2d8850 - g_ps2RecompiledFunctionTable[483872] = ps2mwPlyCreateSofdec_0x2d8710; // 0x2d8888 - g_ps2RecompiledFunctionTable[483878] = ps2mwPlyCreateSofdec_0x2d8710; // 0x2d88a0 - g_ps2RecompiledFunctionTable[483889] = ps2mwPlyCreateSofdec_0x2d8710; // 0x2d88cc - g_ps2RecompiledFunctionTable[483892] = ps2mwPlyCreateSofdec_0x2d8710; // 0x2d88d8 - g_ps2RecompiledFunctionTable[483902] = mwPlyExecServer_0x2d8900; // 0x2d8900 - g_ps2RecompiledFunctionTable[483906] = mwPlyExecServer_0x2d8900; // 0x2d8910 - g_ps2RecompiledFunctionTable[483908] = mwPlyExecServer_0x2d8900; // 0x2d8918 - g_ps2RecompiledFunctionTable[483921] = mwPlyExecServer_0x2d8900; // 0x2d894c - g_ps2RecompiledFunctionTable[483926] = mwPlyExecServer_0x2d8900; // 0x2d8960 - g_ps2RecompiledFunctionTable[483928] = mwPlyExecServer_0x2d8900; // 0x2d8968 - g_ps2RecompiledFunctionTable[483938] = mwPlyFinishSofdec_0x2d8990; // 0x2d8990 - g_ps2RecompiledFunctionTable[483942] = mwPlyGetBright_0x2d89a0; // 0x2d89a0 - g_ps2RecompiledFunctionTable[483946] = mwPlyInitSofdec_0x2d89b0; // 0x2d89b0 - g_ps2RecompiledFunctionTable[483950] = mwPlyPreInitSofdec_0x2d89c0; // 0x2d89c0 - g_ps2RecompiledFunctionTable[483954] = mwPlySetDispMode_0x2d89d0; // 0x2d89d0 - g_ps2RecompiledFunctionTable[483958] = mwPlySetDispPos_0x2d89e0; // 0x2d89e0 - g_ps2RecompiledFunctionTable[483963] = mwPlySetDispPos_0x2d89e0; // 0x2d89f4 - g_ps2RecompiledFunctionTable[483967] = mwPlySetDispPos_0x2d89e0; // 0x2d8a04 - g_ps2RecompiledFunctionTable[483974] = mwPlySetFastHalfpel_0x2d8a20; // 0x2d8a20 - g_ps2RecompiledFunctionTable[483978] = mwPlyStartFrame_0x2d8a30; // 0x2d8a30 - g_ps2RecompiledFunctionTable[483982] = mwPlySetDispSize_0x2d8a40; // 0x2d8a40 - g_ps2RecompiledFunctionTable[483987] = mwPlySetDispSize_0x2d8a40; // 0x2d8a54 - g_ps2RecompiledFunctionTable[483991] = mwPlySetDispSize_0x2d8a40; // 0x2d8a64 - g_ps2RecompiledFunctionTable[483998] = ps2mwPlyVsyncHndl_0x2d8a80; // 0x2d8a80 - g_ps2RecompiledFunctionTable[484002] = ps2mwPlyExecSvrHndl_0x2d8a90; // 0x2d8a90 - g_ps2RecompiledFunctionTable[484006] = ps2mwPlyDestroy_0x2d8aa0; // 0x2d8aa0 - g_ps2RecompiledFunctionTable[484010] = ps2mwPlyStartFname_0x2d8ab0; // 0x2d8ab0 - g_ps2RecompiledFunctionTable[484015] = ps2mwPlyStartFname_0x2d8ab0; // 0x2d8ac4 - g_ps2RecompiledFunctionTable[484019] = ps2mwPlyStartFname_0x2d8ab0; // 0x2d8ad4 - g_ps2RecompiledFunctionTable[484021] = ps2mwPlyStartFname_0x2d8ab0; // 0x2d8adc - g_ps2RecompiledFunctionTable[484032] = ps2mwPlyStartFname_0x2d8ab0; // 0x2d8b08 - g_ps2RecompiledFunctionTable[484046] = ps2mwPlyStop_0x2d8b40; // 0x2d8b40 - g_ps2RecompiledFunctionTable[484050] = ps2mwPlyGetStat_0x2d8b50; // 0x2d8b50 - g_ps2RecompiledFunctionTable[484054] = ps2mwPlyGetTime_0x2d8b60; // 0x2d8b60 - g_ps2RecompiledFunctionTable[484066] = ps2mwPlyPause_0x2d8b90; // 0x2d8b90 - g_ps2RecompiledFunctionTable[484082] = ps2mwPlySetOutVol_0x2d8bd0; // 0x2d8bd0 - g_ps2RecompiledFunctionTable[484086] = ps2mwPlySetOutVol_0x2d8bd0; // 0x2d8be0 - g_ps2RecompiledFunctionTable[484094] = ps2mwPlySetOutVol_0x2d8bd0; // 0x2d8c00 - g_ps2RecompiledFunctionTable[484096] = ps2mwPlySetOutVol_0x2d8bd0; // 0x2d8c08 - g_ps2RecompiledFunctionTable[484098] = ps2mwPlySetOutVol_0x2d8bd0; // 0x2d8c10 - g_ps2RecompiledFunctionTable[484102] = ps2mwPlyGetOutVol_0x2d8c20; // 0x2d8c20 - g_ps2RecompiledFunctionTable[484106] = ps2mwErrorStop_0x2d8c30; // 0x2d8c30 - g_ps2RecompiledFunctionTable[484110] = Setps2FuncTbl_0x2d8c40; // 0x2d8c40 - g_ps2RecompiledFunctionTable[484114] = buExit_0x2d8c50; // 0x2d8c50 - g_ps2RecompiledFunctionTable[484118] = buGetDiskInfo_0x2d8c60; // 0x2d8c60 - g_ps2RecompiledFunctionTable[484122] = buInit_0x2d8c70; // 0x2d8c70 - g_ps2RecompiledFunctionTable[484123] = buInit_0x2d8c70; // 0x2d8c74 - g_ps2RecompiledFunctionTable[484124] = buInit_0x2d8c70; // 0x2d8c78 - g_ps2RecompiledFunctionTable[484125] = buInit_0x2d8c70; // 0x2d8c7c - g_ps2RecompiledFunctionTable[484126] = buInit_0x2d8c70; // 0x2d8c80 - g_ps2RecompiledFunctionTable[484127] = buInit_0x2d8c70; // 0x2d8c84 - g_ps2RecompiledFunctionTable[484128] = buInit_0x2d8c70; // 0x2d8c88 - g_ps2RecompiledFunctionTable[484129] = buInit_0x2d8c70; // 0x2d8c8c - g_ps2RecompiledFunctionTable[484130] = buInit_0x2d8c70; // 0x2d8c90 - g_ps2RecompiledFunctionTable[484131] = buInit_0x2d8c70; // 0x2d8c94 - g_ps2RecompiledFunctionTable[484132] = buInit_0x2d8c70; // 0x2d8c98 - g_ps2RecompiledFunctionTable[484133] = buInit_0x2d8c70; // 0x2d8c9c - g_ps2RecompiledFunctionTable[484134] = buInit_0x2d8c70; // 0x2d8ca0 - g_ps2RecompiledFunctionTable[484135] = buInit_0x2d8c70; // 0x2d8ca4 - g_ps2RecompiledFunctionTable[484136] = buInit_0x2d8c70; // 0x2d8ca8 - g_ps2RecompiledFunctionTable[484137] = buInit_0x2d8c70; // 0x2d8cac - g_ps2RecompiledFunctionTable[484138] = buInit_0x2d8c70; // 0x2d8cb0 - g_ps2RecompiledFunctionTable[484139] = buInit_0x2d8c70; // 0x2d8cb4 - g_ps2RecompiledFunctionTable[484140] = buInit_0x2d8c70; // 0x2d8cb8 - g_ps2RecompiledFunctionTable[484141] = buInit_0x2d8c70; // 0x2d8cbc - g_ps2RecompiledFunctionTable[484142] = buInit_0x2d8c70; // 0x2d8cc0 - g_ps2RecompiledFunctionTable[484143] = buInit_0x2d8c70; // 0x2d8cc4 - g_ps2RecompiledFunctionTable[484144] = buInit_0x2d8c70; // 0x2d8cc8 - g_ps2RecompiledFunctionTable[484145] = buInit_0x2d8c70; // 0x2d8ccc - g_ps2RecompiledFunctionTable[484146] = buInit_0x2d8c70; // 0x2d8cd0 - g_ps2RecompiledFunctionTable[484147] = buInit_0x2d8c70; // 0x2d8cd4 - g_ps2RecompiledFunctionTable[484148] = buInit_0x2d8c70; // 0x2d8cd8 - g_ps2RecompiledFunctionTable[484149] = buInit_0x2d8c70; // 0x2d8cdc - g_ps2RecompiledFunctionTable[484150] = buInit_0x2d8c70; // 0x2d8ce0 - g_ps2RecompiledFunctionTable[484151] = buInit_0x2d8c70; // 0x2d8ce4 - g_ps2RecompiledFunctionTable[484152] = buInit_0x2d8c70; // 0x2d8ce8 - g_ps2RecompiledFunctionTable[484153] = buInit_0x2d8c70; // 0x2d8cec - g_ps2RecompiledFunctionTable[484154] = buInit_0x2d8c70; // 0x2d8cf0 - g_ps2RecompiledFunctionTable[484155] = buInit_0x2d8c70; // 0x2d8cf4 - g_ps2RecompiledFunctionTable[484156] = buInit_0x2d8c70; // 0x2d8cf8 - g_ps2RecompiledFunctionTable[484157] = buInit_0x2d8c70; // 0x2d8cfc - g_ps2RecompiledFunctionTable[484158] = buInit_0x2d8c70; // 0x2d8d00 - g_ps2RecompiledFunctionTable[484159] = buInit_0x2d8c70; // 0x2d8d04 - g_ps2RecompiledFunctionTable[484160] = buInit_0x2d8c70; // 0x2d8d08 - g_ps2RecompiledFunctionTable[484161] = buInit_0x2d8c70; // 0x2d8d0c - g_ps2RecompiledFunctionTable[484162] = buInit_0x2d8c70; // 0x2d8d10 - g_ps2RecompiledFunctionTable[484163] = buInit_0x2d8c70; // 0x2d8d14 - g_ps2RecompiledFunctionTable[484164] = buInit_0x2d8c70; // 0x2d8d18 - g_ps2RecompiledFunctionTable[484165] = buInit_0x2d8c70; // 0x2d8d1c - g_ps2RecompiledFunctionTable[484166] = buInit_0x2d8c70; // 0x2d8d20 - g_ps2RecompiledFunctionTable[484167] = buInit_0x2d8c70; // 0x2d8d24 - g_ps2RecompiledFunctionTable[484168] = buInit_0x2d8c70; // 0x2d8d28 - g_ps2RecompiledFunctionTable[484169] = buInit_0x2d8c70; // 0x2d8d2c - g_ps2RecompiledFunctionTable[484170] = buSetCompleteCallback_0x2d8d30; // 0x2d8d30 - g_ps2RecompiledFunctionTable[484174] = buSetProgressCallback_0x2d8d40; // 0x2d8d40 - g_ps2RecompiledFunctionTable[484178] = gdFsClose_0x2d8d50; // 0x2d8d50 - g_ps2RecompiledFunctionTable[484186] = gdFsCreateDirhn_0x2d8d70; // 0x2d8d70 - g_ps2RecompiledFunctionTable[484190] = gdFsFinish_0x2d8d80; // 0x2d8d80 - g_ps2RecompiledFunctionTable[484194] = gdFsGetDirInfo_0x2d8d90; // 0x2d8d90 - g_ps2RecompiledFunctionTable[484204] = gdFsGetDirInfo_0x2d8d90; // 0x2d8db8 - g_ps2RecompiledFunctionTable[484209] = gdFsGetDirInfo_0x2d8d90; // 0x2d8dcc - g_ps2RecompiledFunctionTable[484224] = gdFsGetDirInfo_0x2d8d90; // 0x2d8e08 - g_ps2RecompiledFunctionTable[484233] = gdFsGetDirInfo_0x2d8d90; // 0x2d8e2c - g_ps2RecompiledFunctionTable[484239] = gdFsGetDirInfo_0x2d8d90; // 0x2d8e44 - g_ps2RecompiledFunctionTable[484282] = gdFsGetDrvStat_0x2d8ef0; // 0x2d8ef0 - g_ps2RecompiledFunctionTable[484286] = gdFsGetFileSize_0x2d8f00; // 0x2d8f00 - g_ps2RecompiledFunctionTable[484298] = gdFsInit_0x2d8f30; // 0x2d8f30 - g_ps2RecompiledFunctionTable[484372] = gdFsInit_0x2d8f30; // 0x2d9058 - g_ps2RecompiledFunctionTable[484384] = gdFsInit_0x2d8f30; // 0x2d9088 - g_ps2RecompiledFunctionTable[484506] = gdFsInit_0x2d8f30; // 0x2d9270 - g_ps2RecompiledFunctionTable[484537] = gdFsInit_0x2d8f30; // 0x2d92ec - g_ps2RecompiledFunctionTable[484540] = gdFsInit_0x2d8f30; // 0x2d92f8 - g_ps2RecompiledFunctionTable[484542] = gdFsInit_0x2d8f30; // 0x2d9300 - g_ps2RecompiledFunctionTable[484582] = gdFsInit_0x2d8f30; // 0x2d93a0 - g_ps2RecompiledFunctionTable[484602] = gdFsInit_0x2d8f30; // 0x2d93f0 - g_ps2RecompiledFunctionTable[484604] = gdFsInit_0x2d8f30; // 0x2d93f8 - g_ps2RecompiledFunctionTable[484606] = gdFsInit_0x2d8f30; // 0x2d9400 - g_ps2RecompiledFunctionTable[484619] = gdFsInit_0x2d8f30; // 0x2d9434 - g_ps2RecompiledFunctionTable[484623] = gdFsInit_0x2d8f30; // 0x2d9444 - g_ps2RecompiledFunctionTable[484666] = gdFsInit_0x2d8f30; // 0x2d94f0 - g_ps2RecompiledFunctionTable[484668] = gdFsInit_0x2d8f30; // 0x2d94f8 - g_ps2RecompiledFunctionTable[484670] = gdFsInit_0x2d8f30; // 0x2d9500 - g_ps2RecompiledFunctionTable[484680] = gdFsInit_0x2d8f30; // 0x2d9528 - g_ps2RecompiledFunctionTable[484685] = gdFsInit_0x2d8f30; // 0x2d953c - g_ps2RecompiledFunctionTable[484689] = gdFsInit_0x2d8f30; // 0x2d954c - g_ps2RecompiledFunctionTable[484691] = gdFsInit_0x2d8f30; // 0x2d9554 - g_ps2RecompiledFunctionTable[484700] = gdFsInit_0x2d8f30; // 0x2d9578 - g_ps2RecompiledFunctionTable[484743] = gdFsInit_0x2d8f30; // 0x2d9624 - g_ps2RecompiledFunctionTable[484785] = gdFsInit_0x2d8f30; // 0x2d96cc - g_ps2RecompiledFunctionTable[484806] = gdFsOpen_0x2d9720; // 0x2d9720 - g_ps2RecompiledFunctionTable[484814] = gdFsOpen_0x2d9720; // 0x2d9740 - g_ps2RecompiledFunctionTable[484819] = gdFsOpen_0x2d9720; // 0x2d9754 - g_ps2RecompiledFunctionTable[484834] = gdFsOpen_0x2d9720; // 0x2d9790 - g_ps2RecompiledFunctionTable[484843] = gdFsOpen_0x2d9720; // 0x2d97b4 - g_ps2RecompiledFunctionTable[484849] = gdFsOpen_0x2d9720; // 0x2d97cc - g_ps2RecompiledFunctionTable[484859] = gdFsOpen_0x2d9720; // 0x2d97f4 - g_ps2RecompiledFunctionTable[484926] = gdFsReqDrvStat_0x2d9900; // 0x2d9900 - g_ps2RecompiledFunctionTable[484930] = gdFsSetDir_0x2d9910; // 0x2d9910 - g_ps2RecompiledFunctionTable[484934] = gdFsEntryErrFuncAll_0x2d9920; // 0x2d9920 - g_ps2RecompiledFunctionTable[484938] = gdFsLoadDir_0x2d9930; // 0x2d9930 - g_ps2RecompiledFunctionTable[484942] = gdFsRead_0x2d9940; // 0x2d9940 - g_ps2RecompiledFunctionTable[484955] = gdFsRead_0x2d9940; // 0x2d9974 - g_ps2RecompiledFunctionTable[484957] = gdFsRead_0x2d9940; // 0x2d997c - g_ps2RecompiledFunctionTable[484966] = gdFsRead_0x2d9940; // 0x2d99a0 - g_ps2RecompiledFunctionTable[484971] = gdFsRead_0x2d9940; // 0x2d99b4 - g_ps2RecompiledFunctionTable[484975] = gdFsRead_0x2d9940; // 0x2d99c4 - g_ps2RecompiledFunctionTable[484977] = gdFsRead_0x2d9940; // 0x2d99cc - g_ps2RecompiledFunctionTable[484986] = syFree_0x2d99f0; // 0x2d99f0 - g_ps2RecompiledFunctionTable[484992] = syFree_0x2d99f0; // 0x2d9a08 - g_ps2RecompiledFunctionTable[485018] = syMalloc_0x2d9a70; // 0x2d9a70 - g_ps2RecompiledFunctionTable[485025] = syMalloc_0x2d9a70; // 0x2d9a8c - g_ps2RecompiledFunctionTable[485086] = syMallocFinish_0x2d9b80; // 0x2d9b80 - g_ps2RecompiledFunctionTable[485090] = syMallocInit_0x2d9b90; // 0x2d9b90 - g_ps2RecompiledFunctionTable[485110] = syMallocStat_0x2d9be0; // 0x2d9be0 - g_ps2RecompiledFunctionTable[485116] = syMallocStat_0x2d9be0; // 0x2d9bf8 - g_ps2RecompiledFunctionTable[485138] = pdInitPeripheral_0x2d9c50; // 0x2d9c50 - g_ps2RecompiledFunctionTable[485162] = pdExitPeripheral_0x2d9cb0; // 0x2d9cb0 - g_ps2RecompiledFunctionTable[485167] = pdExitPeripheral_0x2d9cb0; // 0x2d9cc4 - g_ps2RecompiledFunctionTable[485172] = pdExitPeripheral_0x2d9cb0; // 0x2d9cd8 - g_ps2RecompiledFunctionTable[485178] = pdGetPeripheral_0x2d9cf0; // 0x2d9cf0 - g_ps2RecompiledFunctionTable[485201] = pdGetPeripheral_0x2d9cf0; // 0x2d9d4c - g_ps2RecompiledFunctionTable[485262] = pdGetPeripheral_0x2d9cf0; // 0x2d9e40 - g_ps2RecompiledFunctionTable[485274] = pdGetPeripheralInfo_0x2d9e70; // 0x2d9e70 - g_ps2RecompiledFunctionTable[485282] = pdGetPeripheralInfo_0x2d9e70; // 0x2d9e90 - g_ps2RecompiledFunctionTable[485315] = pdGetPeripheralInfo_0x2d9e70; // 0x2d9f14 - g_ps2RecompiledFunctionTable[485324] = pdGetPeripheralInfo_0x2d9e70; // 0x2d9f38 - g_ps2RecompiledFunctionTable[485338] = pdSetMode_0x2d9f70; // 0x2d9f70 - g_ps2RecompiledFunctionTable[485342] = Ps2_pad_read_0x2d9f80; // 0x2d9f80 - g_ps2RecompiledFunctionTable[485351] = Ps2_pad_read_0x2d9f80; // 0x2d9fa4 - g_ps2RecompiledFunctionTable[485373] = Ps2_pad_read_0x2d9f80; // 0x2d9ffc - g_ps2RecompiledFunctionTable[485384] = Ps2_pad_read_0x2d9f80; // 0x2da028 - g_ps2RecompiledFunctionTable[485403] = Ps2_pad_read_0x2d9f80; // 0x2da074 - g_ps2RecompiledFunctionTable[485423] = Ps2_pad_read_0x2d9f80; // 0x2da0c4 - g_ps2RecompiledFunctionTable[485440] = Ps2_pad_read_0x2d9f80; // 0x2da108 - g_ps2RecompiledFunctionTable[485450] = Ps2_pad_read_0x2d9f80; // 0x2da130 - g_ps2RecompiledFunctionTable[485475] = Ps2_pad_read_0x2d9f80; // 0x2da194 - g_ps2RecompiledFunctionTable[485484] = Ps2_pad_read_0x2d9f80; // 0x2da1b8 - g_ps2RecompiledFunctionTable[485509] = Ps2_pad_read_0x2d9f80; // 0x2da21c - g_ps2RecompiledFunctionTable[485524] = Ps2_pad_read_0x2d9f80; // 0x2da258 - g_ps2RecompiledFunctionTable[485529] = Ps2_pad_read_0x2d9f80; // 0x2da26c - g_ps2RecompiledFunctionTable[485543] = Ps2_pad_read_0x2d9f80; // 0x2da2a4 - g_ps2RecompiledFunctionTable[485566] = Ps2_pad_read_0x2d9f80; // 0x2da300 - g_ps2RecompiledFunctionTable[485623] = Ps2_pad_read_0x2d9f80; // 0x2da3e4 - g_ps2RecompiledFunctionTable[485625] = Ps2_pad_read_0x2d9f80; // 0x2da3ec - g_ps2RecompiledFunctionTable[485630] = Ps2_Read_Key_0x2da400; // 0x2da400 - g_ps2RecompiledFunctionTable[485641] = Ps2_Read_Key_0x2da400; // 0x2da42c - g_ps2RecompiledFunctionTable[485672] = Ps2_Read_Key_0x2da400; // 0x2da4a8 - g_ps2RecompiledFunctionTable[485825] = Ps2_Read_Key_0x2da400; // 0x2da70c - g_ps2RecompiledFunctionTable[485850] = Ps2_MakeRepeatKey_0x2da770; // 0x2da770 - g_ps2RecompiledFunctionTable[485862] = Pad_set_0x2da7a0; // 0x2da7a0 - g_ps2RecompiledFunctionTable[485954] = Pad_set_0x2da7a0; // 0x2da910 - g_ps2RecompiledFunctionTable[486034] = Pad_init_0x2daa50; // 0x2daa50 - g_ps2RecompiledFunctionTable[486036] = Pad_init_0x2daa50; // 0x2daa58 - g_ps2RecompiledFunctionTable[486038] = Pad_init_0x2daa50; // 0x2daa60 - g_ps2RecompiledFunctionTable[486048] = Pad_init_0x2daa50; // 0x2daa88 - g_ps2RecompiledFunctionTable[486053] = Pad_init_0x2daa50; // 0x2daa9c - g_ps2RecompiledFunctionTable[486058] = pdVibMxIsReady_0x2daab0; // 0x2daab0 - g_ps2RecompiledFunctionTable[486063] = pdVibMxIsReady_0x2daab0; // 0x2daac4 - g_ps2RecompiledFunctionTable[486080] = pdVibMxIsReady_0x2daab0; // 0x2dab08 - g_ps2RecompiledFunctionTable[486093] = pdVibMxIsReady_0x2daab0; // 0x2dab3c - g_ps2RecompiledFunctionTable[486106] = pdVibMxSetStopTime_0x2dab70; // 0x2dab70 - g_ps2RecompiledFunctionTable[486110] = pdVibMxStart_0x2dab80; // 0x2dab80 - g_ps2RecompiledFunctionTable[486115] = pdVibMxStart_0x2dab80; // 0x2dab94 - g_ps2RecompiledFunctionTable[486158] = pdVibMxStop_0x2dac40; // 0x2dac40 - g_ps2RecompiledFunctionTable[486162] = pdVibMxStop_0x2dac40; // 0x2dac50 - g_ps2RecompiledFunctionTable[486166] = Ps2_pad_actuater_0x2dac60; // 0x2dac60 - g_ps2RecompiledFunctionTable[486177] = Ps2_pad_actuater_0x2dac60; // 0x2dac8c - g_ps2RecompiledFunctionTable[486192] = Ps2_pad_actuater_0x2dac60; // 0x2dacc8 - g_ps2RecompiledFunctionTable[486199] = Ps2_pad_actuater_0x2dac60; // 0x2dace4 - g_ps2RecompiledFunctionTable[486211] = Ps2_pad_actuater_0x2dac60; // 0x2dad14 - g_ps2RecompiledFunctionTable[486218] = Ps2_pad_act_start_0x2dad30; // 0x2dad30 - g_ps2RecompiledFunctionTable[486258] = Ps2_pad_act_stop_0x2dadd0; // 0x2dadd0 - g_ps2RecompiledFunctionTable[486262] = Ps2_pad_act_all_stop_0x2dade0; // 0x2dade0 - g_ps2RecompiledFunctionTable[486265] = Ps2_pad_act_all_stop_0x2dade0; // 0x2dadec - g_ps2RecompiledFunctionTable[486274] = sdBankDownload_0x2dae10; // 0x2dae10 - g_ps2RecompiledFunctionTable[486315] = sdBankDownload_0x2dae10; // 0x2daeb4 - g_ps2RecompiledFunctionTable[486327] = sdBankDownload_0x2dae10; // 0x2daee4 - g_ps2RecompiledFunctionTable[486337] = sdBankDownload_0x2dae10; // 0x2daf0c - g_ps2RecompiledFunctionTable[486363] = sdBankDownload_0x2dae10; // 0x2daf74 - g_ps2RecompiledFunctionTable[486375] = sdBankDownload_0x2dae10; // 0x2dafa4 - g_ps2RecompiledFunctionTable[486385] = sdBankDownload_0x2dae10; // 0x2dafcc - g_ps2RecompiledFunctionTable[486435] = sdBankDownload_0x2dae10; // 0x2db094 - g_ps2RecompiledFunctionTable[486457] = sdBankDownload_0x2dae10; // 0x2db0ec - g_ps2RecompiledFunctionTable[486467] = sdBankDownload_0x2dae10; // 0x2db114 - g_ps2RecompiledFunctionTable[486502] = sdBankDownload_0x2dae10; // 0x2db1a0 - g_ps2RecompiledFunctionTable[486518] = sdDrvInit_0x2db1e0; // 0x2db1e0 - g_ps2RecompiledFunctionTable[486522] = sdDrvInit_0x2db1e0; // 0x2db1f0 - g_ps2RecompiledFunctionTable[486524] = sdDrvInit_0x2db1e0; // 0x2db1f8 - g_ps2RecompiledFunctionTable[486527] = sdDrvInit_0x2db1e0; // 0x2db204 - g_ps2RecompiledFunctionTable[486529] = sdDrvInit_0x2db1e0; // 0x2db20c - g_ps2RecompiledFunctionTable[486538] = sdDrvInit_0x2db1e0; // 0x2db230 - g_ps2RecompiledFunctionTable[486544] = sdDrvInit_0x2db1e0; // 0x2db248 - g_ps2RecompiledFunctionTable[486546] = sdDrvInit_0x2db1e0; // 0x2db250 - g_ps2RecompiledFunctionTable[486555] = sdDrvInit_0x2db1e0; // 0x2db274 - g_ps2RecompiledFunctionTable[486561] = sdDrvInit_0x2db1e0; // 0x2db28c - g_ps2RecompiledFunctionTable[486568] = sdDrvInit_0x2db1e0; // 0x2db2a8 - g_ps2RecompiledFunctionTable[486573] = sdDrvInit_0x2db1e0; // 0x2db2bc - g_ps2RecompiledFunctionTable[486579] = sdDrvInit_0x2db1e0; // 0x2db2d4 - g_ps2RecompiledFunctionTable[486588] = sdDrvInit_0x2db1e0; // 0x2db2f8 - g_ps2RecompiledFunctionTable[486597] = sdDrvInit_0x2db1e0; // 0x2db31c - g_ps2RecompiledFunctionTable[486603] = sdDrvInit_0x2db1e0; // 0x2db334 - g_ps2RecompiledFunctionTable[486609] = sdDrvInit_0x2db1e0; // 0x2db34c - g_ps2RecompiledFunctionTable[486623] = sdDrvInit_0x2db1e0; // 0x2db384 - g_ps2RecompiledFunctionTable[486630] = sdDrvInit_0x2db1e0; // 0x2db3a0 - g_ps2RecompiledFunctionTable[486638] = sdGddaSetPan_0x2db3c0; // 0x2db3c0 - g_ps2RecompiledFunctionTable[486647] = sdGddaSetPan_0x2db3c0; // 0x2db3e4 - g_ps2RecompiledFunctionTable[486654] = sdLibInit_0x2db400; // 0x2db400 - g_ps2RecompiledFunctionTable[486660] = sdLibInit_0x2db400; // 0x2db418 - g_ps2RecompiledFunctionTable[486662] = sdLibInit_0x2db400; // 0x2db420 - g_ps2RecompiledFunctionTable[486678] = sdLibInit_0x2db400; // 0x2db460 - g_ps2RecompiledFunctionTable[486690] = sdMemBlkCreate_0x2db490; // 0x2db490 - g_ps2RecompiledFunctionTable[486697] = sdMemBlkCreate_0x2db490; // 0x2db4ac - g_ps2RecompiledFunctionTable[486726] = sdMemBlkDestroy_0x2db520; // 0x2db520 - g_ps2RecompiledFunctionTable[486736] = sdMemBlkDestroy_0x2db520; // 0x2db548 - g_ps2RecompiledFunctionTable[486750] = sdMemBlkSetPrm_0x2db580; // 0x2db580 - g_ps2RecompiledFunctionTable[486774] = sdMidiClosePort_0x2db5e0; // 0x2db5e0 - g_ps2RecompiledFunctionTable[486797] = sdMidiClosePort_0x2db5e0; // 0x2db63c - g_ps2RecompiledFunctionTable[486822] = sdMidiGetStat_0x2db6a0; // 0x2db6a0 - g_ps2RecompiledFunctionTable[486854] = sdMidiOpenPort_0x2db720; // 0x2db720 - g_ps2RecompiledFunctionTable[486865] = sdMidiOpenPort_0x2db720; // 0x2db74c - g_ps2RecompiledFunctionTable[486910] = sdMidiPlay_0x2db800; // 0x2db800 - g_ps2RecompiledFunctionTable[486937] = sdMidiPlay_0x2db800; // 0x2db86c - g_ps2RecompiledFunctionTable[486970] = sdMidiSetFxLev_0x2db8f0; // 0x2db8f0 - g_ps2RecompiledFunctionTable[486978] = sdMidiSetPan_0x2db910; // 0x2db910 - g_ps2RecompiledFunctionTable[487006] = sdMidiSetPan_0x2db910; // 0x2db980 - g_ps2RecompiledFunctionTable[487018] = sdMidiSetPitch_0x2db9b0; // 0x2db9b0 - g_ps2RecompiledFunctionTable[487084] = sdMidiSetPitch_0x2db9b0; // 0x2dbab8 - g_ps2RecompiledFunctionTable[487098] = sdMidiSetSpeed_0x2dbaf0; // 0x2dbaf0 - g_ps2RecompiledFunctionTable[487107] = sdMidiSetSpeed_0x2dbaf0; // 0x2dbb14 - g_ps2RecompiledFunctionTable[487114] = sdMidiSetVol_0x2dbb30; // 0x2dbb30 - g_ps2RecompiledFunctionTable[487151] = sdMidiSetVol_0x2dbb30; // 0x2dbbc4 - g_ps2RecompiledFunctionTable[487178] = sdMidiStop_0x2dbc30; // 0x2dbc30 - g_ps2RecompiledFunctionTable[487192] = sdMidiStop_0x2dbc30; // 0x2dbc68 - g_ps2RecompiledFunctionTable[487206] = sdShotClosePort_0x2dbca0; // 0x2dbca0 - g_ps2RecompiledFunctionTable[487239] = sdShotClosePort_0x2dbca0; // 0x2dbd24 - g_ps2RecompiledFunctionTable[487282] = sdShotGetStat_0x2dbdd0; // 0x2dbdd0 - g_ps2RecompiledFunctionTable[487318] = sdShotOpenPort_0x2dbe60; // 0x2dbe60 - g_ps2RecompiledFunctionTable[487329] = sdShotOpenPort_0x2dbe60; // 0x2dbe8c - g_ps2RecompiledFunctionTable[487370] = sdShotPlay_0x2dbf30; // 0x2dbf30 - g_ps2RecompiledFunctionTable[487430] = sdShotPlay_0x2dbf30; // 0x2dc020 - g_ps2RecompiledFunctionTable[487456] = sdShotPlay_0x2dbf30; // 0x2dc088 - g_ps2RecompiledFunctionTable[487518] = sdShotSetFxLev_0x2dc180; // 0x2dc180 - g_ps2RecompiledFunctionTable[487526] = sdShotSetPan_0x2dc1a0; // 0x2dc1a0 - g_ps2RecompiledFunctionTable[487554] = sdShotSetPan_0x2dc1a0; // 0x2dc210 - g_ps2RecompiledFunctionTable[487566] = Panpot_Control_0x2dc240; // 0x2dc240 - g_ps2RecompiledFunctionTable[487675] = Panpot_Control_0x2dc240; // 0x2dc3f4 - g_ps2RecompiledFunctionTable[487686] = sdShotSetPitch_0x2dc420; // 0x2dc420 - g_ps2RecompiledFunctionTable[487722] = sdShotSetPitch_0x2dc420; // 0x2dc4b0 - g_ps2RecompiledFunctionTable[487734] = Pitch_Control_0x2dc4e0; // 0x2dc4e0 - g_ps2RecompiledFunctionTable[487827] = Pitch_Control_0x2dc4e0; // 0x2dc654 - g_ps2RecompiledFunctionTable[487838] = sdShotSetVol_0x2dc680; // 0x2dc680 - g_ps2RecompiledFunctionTable[487863] = sdShotSetVol_0x2dc680; // 0x2dc6e4 - g_ps2RecompiledFunctionTable[487878] = Volume_Control_0x2dc720; // 0x2dc720 - g_ps2RecompiledFunctionTable[487985] = Volume_Control_0x2dc720; // 0x2dc8cc - g_ps2RecompiledFunctionTable[487991] = Volume_Control_0x2dc720; // 0x2dc8e4 - g_ps2RecompiledFunctionTable[488002] = sdShotStop_0x2dc910; // 0x2dc910 - g_ps2RecompiledFunctionTable[488017] = sdShotStop_0x2dc910; // 0x2dc94c - g_ps2RecompiledFunctionTable[488030] = sdSndClearFxPrg_0x2dc980; // 0x2dc980 - g_ps2RecompiledFunctionTable[488038] = sdSndSetFxPrg_0x2dc9a0; // 0x2dc9a0 - g_ps2RecompiledFunctionTable[488046] = sdSndSetMasterVol_0x2dc9c0; // 0x2dc9c0 - g_ps2RecompiledFunctionTable[488072] = sdSndSetMasterVol_0x2dc9c0; // 0x2dca28 - g_ps2RecompiledFunctionTable[488084] = sdSndSetMasterVol_0x2dc9c0; // 0x2dca58 - g_ps2RecompiledFunctionTable[488098] = sdSndSetPanMode_0x2dca90; // 0x2dca90 - g_ps2RecompiledFunctionTable[488110] = sdSndSetPanMode_0x2dca90; // 0x2dcac0 - g_ps2RecompiledFunctionTable[488113] = sdSndSetPanMode_0x2dca90; // 0x2dcacc - g_ps2RecompiledFunctionTable[488115] = sdSndSetPanMode_0x2dca90; // 0x2dcad4 - g_ps2RecompiledFunctionTable[488122] = sdSndSetPanMode_0x2dca90; // 0x2dcaf0 - g_ps2RecompiledFunctionTable[488125] = sdSndSetPanMode_0x2dca90; // 0x2dcafc - g_ps2RecompiledFunctionTable[488127] = sdSndSetPanMode_0x2dca90; // 0x2dcb04 - g_ps2RecompiledFunctionTable[488150] = sdSndStopAll_0x2dcb60; // 0x2dcb60 - g_ps2RecompiledFunctionTable[488158] = sdSndStopAll_0x2dcb60; // 0x2dcb80 - g_ps2RecompiledFunctionTable[488170] = sndr_trans_func_0x2dcbb0; // 0x2dcbb0 - g_ps2RecompiledFunctionTable[488171] = sndr_trans_func_0x2dcbb0; // 0x2dcbb4 - g_ps2RecompiledFunctionTable[488172] = sndr_trans_func_0x2dcbb0; // 0x2dcbb8 - g_ps2RecompiledFunctionTable[488173] = sndr_trans_func_0x2dcbb0; // 0x2dcbbc - g_ps2RecompiledFunctionTable[488174] = sndr_trans_func_0x2dcbb0; // 0x2dcbc0 - g_ps2RecompiledFunctionTable[488175] = sndr_trans_func_0x2dcbb0; // 0x2dcbc4 - g_ps2RecompiledFunctionTable[488176] = sndr_trans_func_0x2dcbb0; // 0x2dcbc8 - g_ps2RecompiledFunctionTable[488177] = sndr_trans_func_0x2dcbb0; // 0x2dcbcc - g_ps2RecompiledFunctionTable[488178] = sndr_trans_func_0x2dcbb0; // 0x2dcbd0 - g_ps2RecompiledFunctionTable[488179] = sndr_trans_func_0x2dcbb0; // 0x2dcbd4 - g_ps2RecompiledFunctionTable[488180] = sndr_trans_func_0x2dcbb0; // 0x2dcbd8 - g_ps2RecompiledFunctionTable[488181] = sndr_trans_func_0x2dcbb0; // 0x2dcbdc - g_ps2RecompiledFunctionTable[488182] = sndr_trans_func_0x2dcbb0; // 0x2dcbe0 - g_ps2RecompiledFunctionTable[488183] = sndr_trans_func_0x2dcbb0; // 0x2dcbe4 - g_ps2RecompiledFunctionTable[488184] = sndr_trans_func_0x2dcbb0; // 0x2dcbe8 - g_ps2RecompiledFunctionTable[488185] = sndr_trans_func_0x2dcbb0; // 0x2dcbec - g_ps2RecompiledFunctionTable[488186] = sndr_trans_func_0x2dcbb0; // 0x2dcbf0 - g_ps2RecompiledFunctionTable[488187] = sndr_trans_func_0x2dcbb0; // 0x2dcbf4 - g_ps2RecompiledFunctionTable[488188] = sndr_trans_func_0x2dcbb0; // 0x2dcbf8 - g_ps2RecompiledFunctionTable[488189] = sndr_trans_func_0x2dcbb0; // 0x2dcbfc - g_ps2RecompiledFunctionTable[488190] = sndr_trans_func_0x2dcbb0; // 0x2dcc00 - g_ps2RecompiledFunctionTable[488191] = sndr_trans_func_0x2dcbb0; // 0x2dcc04 - g_ps2RecompiledFunctionTable[488192] = sndr_trans_func_0x2dcbb0; // 0x2dcc08 - g_ps2RecompiledFunctionTable[488193] = sndr_trans_func_0x2dcbb0; // 0x2dcc0c - g_ps2RecompiledFunctionTable[488194] = sndr_trans_func_0x2dcbb0; // 0x2dcc10 - g_ps2RecompiledFunctionTable[488195] = sndr_trans_func_0x2dcbb0; // 0x2dcc14 - g_ps2RecompiledFunctionTable[488196] = sndr_trans_func_0x2dcbb0; // 0x2dcc18 - g_ps2RecompiledFunctionTable[488197] = sndr_trans_func_0x2dcbb0; // 0x2dcc1c - g_ps2RecompiledFunctionTable[488198] = sndr_trans_func_0x2dcbb0; // 0x2dcc20 - g_ps2RecompiledFunctionTable[488199] = sndr_trans_func_0x2dcbb0; // 0x2dcc24 - g_ps2RecompiledFunctionTable[488200] = sndr_trans_func_0x2dcbb0; // 0x2dcc28 - g_ps2RecompiledFunctionTable[488201] = sndr_trans_func_0x2dcbb0; // 0x2dcc2c - g_ps2RecompiledFunctionTable[488202] = sndr_trans_func_0x2dcbb0; // 0x2dcc30 - g_ps2RecompiledFunctionTable[488203] = sndr_trans_func_0x2dcbb0; // 0x2dcc34 - g_ps2RecompiledFunctionTable[488204] = sndr_trans_func_0x2dcbb0; // 0x2dcc38 - g_ps2RecompiledFunctionTable[488205] = sndr_trans_func_0x2dcbb0; // 0x2dcc3c - g_ps2RecompiledFunctionTable[488206] = sndr_trans_func_0x2dcbb0; // 0x2dcc40 - g_ps2RecompiledFunctionTable[488207] = sndr_trans_func_0x2dcbb0; // 0x2dcc44 - g_ps2RecompiledFunctionTable[488208] = sndr_trans_func_0x2dcbb0; // 0x2dcc48 - g_ps2RecompiledFunctionTable[488209] = sndr_trans_func_0x2dcbb0; // 0x2dcc4c - g_ps2RecompiledFunctionTable[488210] = sndr_trans_func_0x2dcbb0; // 0x2dcc50 - g_ps2RecompiledFunctionTable[488211] = sndr_trans_func_0x2dcbb0; // 0x2dcc54 - g_ps2RecompiledFunctionTable[488212] = sndr_trans_func_0x2dcbb0; // 0x2dcc58 - g_ps2RecompiledFunctionTable[488213] = sndr_trans_func_0x2dcbb0; // 0x2dcc5c - g_ps2RecompiledFunctionTable[488214] = sndr_trans_func_0x2dcbb0; // 0x2dcc60 - g_ps2RecompiledFunctionTable[488215] = sndr_trans_func_0x2dcbb0; // 0x2dcc64 - g_ps2RecompiledFunctionTable[488216] = sndr_trans_func_0x2dcbb0; // 0x2dcc68 - g_ps2RecompiledFunctionTable[488217] = sndr_trans_func_0x2dcbb0; // 0x2dcc6c - g_ps2RecompiledFunctionTable[488218] = sndr_trans_func_0x2dcbb0; // 0x2dcc70 - g_ps2RecompiledFunctionTable[488219] = sndr_trans_func_0x2dcbb0; // 0x2dcc74 - g_ps2RecompiledFunctionTable[488220] = sndr_trans_func_0x2dcbb0; // 0x2dcc78 - g_ps2RecompiledFunctionTable[488221] = sndr_trans_func_0x2dcbb0; // 0x2dcc7c - g_ps2RecompiledFunctionTable[488222] = sndr_trans_func_0x2dcbb0; // 0x2dcc80 - g_ps2RecompiledFunctionTable[488223] = sndr_trans_func_0x2dcbb0; // 0x2dcc84 - g_ps2RecompiledFunctionTable[488224] = sndr_trans_func_0x2dcbb0; // 0x2dcc88 - g_ps2RecompiledFunctionTable[488225] = sndr_trans_func_0x2dcbb0; // 0x2dcc8c - g_ps2RecompiledFunctionTable[488226] = sndr_trans_func_0x2dcbb0; // 0x2dcc90 - g_ps2RecompiledFunctionTable[488227] = sndr_trans_func_0x2dcbb0; // 0x2dcc94 - g_ps2RecompiledFunctionTable[488228] = sndr_trans_func_0x2dcbb0; // 0x2dcc98 - g_ps2RecompiledFunctionTable[488229] = sndr_trans_func_0x2dcbb0; // 0x2dcc9c - g_ps2RecompiledFunctionTable[488230] = sndr_trans_func_0x2dcbb0; // 0x2dcca0 - g_ps2RecompiledFunctionTable[488231] = sndr_trans_func_0x2dcbb0; // 0x2dcca4 - g_ps2RecompiledFunctionTable[488232] = sndr_trans_func_0x2dcbb0; // 0x2dcca8 - g_ps2RecompiledFunctionTable[488233] = sndr_trans_func_0x2dcbb0; // 0x2dccac - g_ps2RecompiledFunctionTable[488234] = sndr_trans_func_0x2dcbb0; // 0x2dccb0 - g_ps2RecompiledFunctionTable[488235] = sndr_trans_func_0x2dcbb0; // 0x2dccb4 - g_ps2RecompiledFunctionTable[488236] = sndr_trans_func_0x2dcbb0; // 0x2dccb8 - g_ps2RecompiledFunctionTable[488237] = sndr_trans_func_0x2dcbb0; // 0x2dccbc - g_ps2RecompiledFunctionTable[488238] = sndr_trans_func_0x2dcbb0; // 0x2dccc0 - g_ps2RecompiledFunctionTable[488239] = sndr_trans_func_0x2dcbb0; // 0x2dccc4 - g_ps2RecompiledFunctionTable[488240] = sndr_trans_func_0x2dcbb0; // 0x2dccc8 - g_ps2RecompiledFunctionTable[488241] = sndr_trans_func_0x2dcbb0; // 0x2dcccc - g_ps2RecompiledFunctionTable[488242] = sndr_trans_func_0x2dcbb0; // 0x2dccd0 - g_ps2RecompiledFunctionTable[488243] = sndr_trans_func_0x2dcbb0; // 0x2dccd4 - g_ps2RecompiledFunctionTable[488244] = sndr_trans_func_0x2dcbb0; // 0x2dccd8 - g_ps2RecompiledFunctionTable[488245] = sndr_trans_func_0x2dcbb0; // 0x2dccdc - g_ps2RecompiledFunctionTable[488246] = sndr_trans_func_0x2dcbb0; // 0x2dcce0 - g_ps2RecompiledFunctionTable[488247] = sndr_trans_func_0x2dcbb0; // 0x2dcce4 - g_ps2RecompiledFunctionTable[488248] = sndr_trans_func_0x2dcbb0; // 0x2dcce8 - g_ps2RecompiledFunctionTable[488249] = sndr_trans_func_0x2dcbb0; // 0x2dccec - g_ps2RecompiledFunctionTable[488250] = sndr_trans_func_0x2dcbb0; // 0x2dccf0 - g_ps2RecompiledFunctionTable[488251] = sndr_trans_func_0x2dcbb0; // 0x2dccf4 - g_ps2RecompiledFunctionTable[488252] = sndr_trans_func_0x2dcbb0; // 0x2dccf8 - g_ps2RecompiledFunctionTable[488253] = sndr_trans_func_0x2dcbb0; // 0x2dccfc - g_ps2RecompiledFunctionTable[488254] = sndr_trans_func_0x2dcbb0; // 0x2dcd00 - g_ps2RecompiledFunctionTable[488255] = sndr_trans_func_0x2dcbb0; // 0x2dcd04 - g_ps2RecompiledFunctionTable[488256] = sndr_trans_func_0x2dcbb0; // 0x2dcd08 - g_ps2RecompiledFunctionTable[488257] = sndr_trans_func_0x2dcbb0; // 0x2dcd0c - g_ps2RecompiledFunctionTable[488258] = sndr_trans_func_0x2dcbb0; // 0x2dcd10 - g_ps2RecompiledFunctionTable[488259] = sndr_trans_func_0x2dcbb0; // 0x2dcd14 - g_ps2RecompiledFunctionTable[488260] = sndr_trans_func_0x2dcbb0; // 0x2dcd18 - g_ps2RecompiledFunctionTable[488261] = sndr_trans_func_0x2dcbb0; // 0x2dcd1c - g_ps2RecompiledFunctionTable[488262] = sndr_trans_func_0x2dcbb0; // 0x2dcd20 - g_ps2RecompiledFunctionTable[488263] = sndr_trans_func_0x2dcbb0; // 0x2dcd24 - g_ps2RecompiledFunctionTable[488264] = sndr_trans_func_0x2dcbb0; // 0x2dcd28 - g_ps2RecompiledFunctionTable[488265] = sndr_trans_func_0x2dcbb0; // 0x2dcd2c - g_ps2RecompiledFunctionTable[488266] = sndr_trans_func_0x2dcbb0; // 0x2dcd30 - g_ps2RecompiledFunctionTable[488267] = sndr_trans_func_0x2dcbb0; // 0x2dcd34 - g_ps2RecompiledFunctionTable[488268] = sndr_trans_func_0x2dcbb0; // 0x2dcd38 - g_ps2RecompiledFunctionTable[488269] = sndr_trans_func_0x2dcbb0; // 0x2dcd3c - g_ps2RecompiledFunctionTable[488270] = sndr_trans_func_0x2dcbb0; // 0x2dcd40 - g_ps2RecompiledFunctionTable[488271] = sndr_trans_func_0x2dcbb0; // 0x2dcd44 - g_ps2RecompiledFunctionTable[488272] = sndr_trans_func_0x2dcbb0; // 0x2dcd48 - g_ps2RecompiledFunctionTable[488273] = sndr_trans_func_0x2dcbb0; // 0x2dcd4c - g_ps2RecompiledFunctionTable[488274] = sndr_trans_func_0x2dcbb0; // 0x2dcd50 - g_ps2RecompiledFunctionTable[488275] = sndr_trans_func_0x2dcbb0; // 0x2dcd54 - g_ps2RecompiledFunctionTable[488276] = sndr_trans_func_0x2dcbb0; // 0x2dcd58 - g_ps2RecompiledFunctionTable[488277] = sndr_trans_func_0x2dcbb0; // 0x2dcd5c - g_ps2RecompiledFunctionTable[488278] = sndr_trans_func_0x2dcbb0; // 0x2dcd60 - g_ps2RecompiledFunctionTable[488279] = sndr_trans_func_0x2dcbb0; // 0x2dcd64 - g_ps2RecompiledFunctionTable[488280] = sndr_trans_func_0x2dcbb0; // 0x2dcd68 - g_ps2RecompiledFunctionTable[488281] = sndr_trans_func_0x2dcbb0; // 0x2dcd6c - g_ps2RecompiledFunctionTable[488282] = sndr_trans_func_0x2dcbb0; // 0x2dcd70 - g_ps2RecompiledFunctionTable[488283] = sndr_trans_func_0x2dcbb0; // 0x2dcd74 - g_ps2RecompiledFunctionTable[488284] = sndr_trans_func_0x2dcbb0; // 0x2dcd78 - g_ps2RecompiledFunctionTable[488285] = sndr_trans_func_0x2dcbb0; // 0x2dcd7c - g_ps2RecompiledFunctionTable[488286] = sndr_trans_func_0x2dcbb0; // 0x2dcd80 - g_ps2RecompiledFunctionTable[488287] = sndr_trans_func_0x2dcbb0; // 0x2dcd84 - g_ps2RecompiledFunctionTable[488288] = sndr_trans_func_0x2dcbb0; // 0x2dcd88 - g_ps2RecompiledFunctionTable[488289] = sndr_trans_func_0x2dcbb0; // 0x2dcd8c - g_ps2RecompiledFunctionTable[488290] = sndr_trans_func_0x2dcbb0; // 0x2dcd90 - g_ps2RecompiledFunctionTable[488291] = sndr_trans_func_0x2dcbb0; // 0x2dcd94 - g_ps2RecompiledFunctionTable[488292] = sndr_trans_func_0x2dcbb0; // 0x2dcd98 - g_ps2RecompiledFunctionTable[488293] = sndr_trans_func_0x2dcbb0; // 0x2dcd9c - g_ps2RecompiledFunctionTable[488294] = sndr_trans_func_0x2dcbb0; // 0x2dcda0 - g_ps2RecompiledFunctionTable[488295] = sndr_trans_func_0x2dcbb0; // 0x2dcda4 - g_ps2RecompiledFunctionTable[488296] = sndr_trans_func_0x2dcbb0; // 0x2dcda8 - g_ps2RecompiledFunctionTable[488297] = sndr_trans_func_0x2dcbb0; // 0x2dcdac - g_ps2RecompiledFunctionTable[488298] = sndr_trans_func_0x2dcbb0; // 0x2dcdb0 - g_ps2RecompiledFunctionTable[488299] = sndr_trans_func_0x2dcbb0; // 0x2dcdb4 - g_ps2RecompiledFunctionTable[488300] = sndr_trans_func_0x2dcbb0; // 0x2dcdb8 - g_ps2RecompiledFunctionTable[488301] = sndr_trans_func_0x2dcbb0; // 0x2dcdbc - g_ps2RecompiledFunctionTable[488302] = sndr_trans_func_0x2dcbb0; // 0x2dcdc0 - g_ps2RecompiledFunctionTable[488303] = sndr_trans_func_0x2dcbb0; // 0x2dcdc4 - g_ps2RecompiledFunctionTable[488304] = sndr_trans_func_0x2dcbb0; // 0x2dcdc8 - g_ps2RecompiledFunctionTable[488305] = sndr_trans_func_0x2dcbb0; // 0x2dcdcc - g_ps2RecompiledFunctionTable[488306] = sndr_trans_func_0x2dcbb0; // 0x2dcdd0 - g_ps2RecompiledFunctionTable[488307] = sndr_trans_func_0x2dcbb0; // 0x2dcdd4 - g_ps2RecompiledFunctionTable[488308] = sndr_trans_func_0x2dcbb0; // 0x2dcdd8 - g_ps2RecompiledFunctionTable[488309] = sndr_trans_func_0x2dcbb0; // 0x2dcddc - g_ps2RecompiledFunctionTable[488310] = sndr_trans_func_0x2dcbb0; // 0x2dcde0 - g_ps2RecompiledFunctionTable[488311] = sndr_trans_func_0x2dcbb0; // 0x2dcde4 - g_ps2RecompiledFunctionTable[488312] = sndr_trans_func_0x2dcbb0; // 0x2dcde8 - g_ps2RecompiledFunctionTable[488313] = sndr_trans_func_0x2dcbb0; // 0x2dcdec - g_ps2RecompiledFunctionTable[488314] = sndr_trans_func_0x2dcbb0; // 0x2dcdf0 - g_ps2RecompiledFunctionTable[488315] = sndr_trans_func_0x2dcbb0; // 0x2dcdf4 - g_ps2RecompiledFunctionTable[488316] = sndr_trans_func_0x2dcbb0; // 0x2dcdf8 - g_ps2RecompiledFunctionTable[488317] = sndr_trans_func_0x2dcbb0; // 0x2dcdfc - g_ps2RecompiledFunctionTable[488318] = sndr_trans_func_0x2dcbb0; // 0x2dce00 - g_ps2RecompiledFunctionTable[488319] = sndr_trans_func_0x2dcbb0; // 0x2dce04 - g_ps2RecompiledFunctionTable[488320] = sndr_trans_func_0x2dcbb0; // 0x2dce08 - g_ps2RecompiledFunctionTable[488321] = sndr_trans_func_0x2dcbb0; // 0x2dce0c - g_ps2RecompiledFunctionTable[488322] = sndr_trans_func_0x2dcbb0; // 0x2dce10 - g_ps2RecompiledFunctionTable[488323] = sndr_trans_func_0x2dcbb0; // 0x2dce14 - g_ps2RecompiledFunctionTable[488324] = sndr_trans_func_0x2dcbb0; // 0x2dce18 - g_ps2RecompiledFunctionTable[488325] = sndr_trans_func_0x2dcbb0; // 0x2dce1c - g_ps2RecompiledFunctionTable[488326] = sndr_trans_func_0x2dcbb0; // 0x2dce20 - g_ps2RecompiledFunctionTable[488327] = sndr_trans_func_0x2dcbb0; // 0x2dce24 - g_ps2RecompiledFunctionTable[488328] = sndr_trans_func_0x2dcbb0; // 0x2dce28 - g_ps2RecompiledFunctionTable[488329] = sndr_trans_func_0x2dcbb0; // 0x2dce2c - g_ps2RecompiledFunctionTable[488330] = sndr_trans_func_0x2dcbb0; // 0x2dce30 - g_ps2RecompiledFunctionTable[488331] = sndr_trans_func_0x2dcbb0; // 0x2dce34 - g_ps2RecompiledFunctionTable[488332] = sndr_trans_func_0x2dcbb0; // 0x2dce38 - g_ps2RecompiledFunctionTable[488333] = sndr_trans_func_0x2dcbb0; // 0x2dce3c - g_ps2RecompiledFunctionTable[488334] = sndr_trans_func_0x2dcbb0; // 0x2dce40 - g_ps2RecompiledFunctionTable[488335] = sndr_trans_func_0x2dcbb0; // 0x2dce44 - g_ps2RecompiledFunctionTable[488336] = sndr_trans_func_0x2dcbb0; // 0x2dce48 - g_ps2RecompiledFunctionTable[488337] = sndr_trans_func_0x2dcbb0; // 0x2dce4c - g_ps2RecompiledFunctionTable[488338] = sndr_trans_func_0x2dcbb0; // 0x2dce50 - g_ps2RecompiledFunctionTable[488339] = sndr_trans_func_0x2dcbb0; // 0x2dce54 - g_ps2RecompiledFunctionTable[488340] = sndr_trans_func_0x2dcbb0; // 0x2dce58 - g_ps2RecompiledFunctionTable[488341] = sndr_trans_func_0x2dcbb0; // 0x2dce5c - g_ps2RecompiledFunctionTable[488342] = sndr_trans_func_0x2dcbb0; // 0x2dce60 - g_ps2RecompiledFunctionTable[488343] = sndr_trans_func_0x2dcbb0; // 0x2dce64 - g_ps2RecompiledFunctionTable[488344] = sndr_trans_func_0x2dcbb0; // 0x2dce68 - g_ps2RecompiledFunctionTable[488345] = sndr_trans_func_0x2dcbb0; // 0x2dce6c - g_ps2RecompiledFunctionTable[488346] = sndr_trans_func_0x2dcbb0; // 0x2dce70 - g_ps2RecompiledFunctionTable[488347] = sndr_trans_func_0x2dcbb0; // 0x2dce74 - g_ps2RecompiledFunctionTable[488348] = sndr_trans_func_0x2dcbb0; // 0x2dce78 - g_ps2RecompiledFunctionTable[488349] = sndr_trans_func_0x2dcbb0; // 0x2dce7c - g_ps2RecompiledFunctionTable[488350] = sndr_trans_func_0x2dcbb0; // 0x2dce80 - g_ps2RecompiledFunctionTable[488351] = sndr_trans_func_0x2dcbb0; // 0x2dce84 - g_ps2RecompiledFunctionTable[488352] = sndr_trans_func_0x2dcbb0; // 0x2dce88 - g_ps2RecompiledFunctionTable[488353] = sndr_trans_func_0x2dcbb0; // 0x2dce8c - g_ps2RecompiledFunctionTable[488354] = sndr_trans_func_0x2dcbb0; // 0x2dce90 - g_ps2RecompiledFunctionTable[488355] = sndr_trans_func_0x2dcbb0; // 0x2dce94 - g_ps2RecompiledFunctionTable[488356] = sndr_trans_func_0x2dcbb0; // 0x2dce98 - g_ps2RecompiledFunctionTable[488357] = sndr_trans_func_0x2dcbb0; // 0x2dce9c - g_ps2RecompiledFunctionTable[488358] = sndr_trans_func_0x2dcbb0; // 0x2dcea0 - g_ps2RecompiledFunctionTable[488359] = sndr_trans_func_0x2dcbb0; // 0x2dcea4 - g_ps2RecompiledFunctionTable[488360] = sndr_trans_func_0x2dcbb0; // 0x2dcea8 - g_ps2RecompiledFunctionTable[488361] = sndr_trans_func_0x2dcbb0; // 0x2dceac - g_ps2RecompiledFunctionTable[488362] = sndr_trans_func_0x2dcbb0; // 0x2dceb0 - g_ps2RecompiledFunctionTable[488363] = sndr_trans_func_0x2dcbb0; // 0x2dceb4 - g_ps2RecompiledFunctionTable[488364] = sndr_trans_func_0x2dcbb0; // 0x2dceb8 - g_ps2RecompiledFunctionTable[488365] = sndr_trans_func_0x2dcbb0; // 0x2dcebc - g_ps2RecompiledFunctionTable[488366] = sndr_trans_func_0x2dcbb0; // 0x2dcec0 - g_ps2RecompiledFunctionTable[488367] = sndr_trans_func_0x2dcbb0; // 0x2dcec4 - g_ps2RecompiledFunctionTable[488368] = sndr_trans_func_0x2dcbb0; // 0x2dcec8 - g_ps2RecompiledFunctionTable[488369] = sndr_trans_func_0x2dcbb0; // 0x2dcecc - g_ps2RecompiledFunctionTable[488370] = sndr_trans_func_0x2dcbb0; // 0x2dced0 - g_ps2RecompiledFunctionTable[488371] = sndr_trans_func_0x2dcbb0; // 0x2dced4 - g_ps2RecompiledFunctionTable[488372] = sndr_trans_func_0x2dcbb0; // 0x2dced8 - g_ps2RecompiledFunctionTable[488373] = sndr_trans_func_0x2dcbb0; // 0x2dcedc - g_ps2RecompiledFunctionTable[488374] = sndr_trans_func_0x2dcbb0; // 0x2dcee0 - g_ps2RecompiledFunctionTable[488375] = sndr_trans_func_0x2dcbb0; // 0x2dcee4 - g_ps2RecompiledFunctionTable[488376] = sndr_trans_func_0x2dcbb0; // 0x2dcee8 - g_ps2RecompiledFunctionTable[488377] = sndr_trans_func_0x2dcbb0; // 0x2dceec - g_ps2RecompiledFunctionTable[488378] = sndr_trans_func_0x2dcbb0; // 0x2dcef0 - g_ps2RecompiledFunctionTable[488379] = sndr_trans_func_0x2dcbb0; // 0x2dcef4 - g_ps2RecompiledFunctionTable[488380] = sndr_trans_func_0x2dcbb0; // 0x2dcef8 - g_ps2RecompiledFunctionTable[488381] = sndr_trans_func_0x2dcbb0; // 0x2dcefc - g_ps2RecompiledFunctionTable[488382] = sndr_trans_func_0x2dcbb0; // 0x2dcf00 - g_ps2RecompiledFunctionTable[488383] = sndr_trans_func_0x2dcbb0; // 0x2dcf04 - g_ps2RecompiledFunctionTable[488384] = sndr_trans_func_0x2dcbb0; // 0x2dcf08 - g_ps2RecompiledFunctionTable[488385] = sndr_trans_func_0x2dcbb0; // 0x2dcf0c - g_ps2RecompiledFunctionTable[488386] = sndr_trans_func_0x2dcbb0; // 0x2dcf10 - g_ps2RecompiledFunctionTable[488387] = sndr_trans_func_0x2dcbb0; // 0x2dcf14 - g_ps2RecompiledFunctionTable[488388] = sndr_trans_func_0x2dcbb0; // 0x2dcf18 - g_ps2RecompiledFunctionTable[488389] = sndr_trans_func_0x2dcbb0; // 0x2dcf1c - g_ps2RecompiledFunctionTable[488390] = sndr_trans_func_0x2dcbb0; // 0x2dcf20 - g_ps2RecompiledFunctionTable[488391] = sndr_trans_func_0x2dcbb0; // 0x2dcf24 - g_ps2RecompiledFunctionTable[488392] = sndr_trans_func_0x2dcbb0; // 0x2dcf28 - g_ps2RecompiledFunctionTable[488393] = sndr_trans_func_0x2dcbb0; // 0x2dcf2c - g_ps2RecompiledFunctionTable[488394] = sndr_trans_func_0x2dcbb0; // 0x2dcf30 - g_ps2RecompiledFunctionTable[488395] = sndr_trans_func_0x2dcbb0; // 0x2dcf34 - g_ps2RecompiledFunctionTable[488396] = sndr_trans_func_0x2dcbb0; // 0x2dcf38 - g_ps2RecompiledFunctionTable[488397] = sndr_trans_func_0x2dcbb0; // 0x2dcf3c - g_ps2RecompiledFunctionTable[488398] = sndr_trans_func_0x2dcbb0; // 0x2dcf40 - g_ps2RecompiledFunctionTable[488399] = sndr_trans_func_0x2dcbb0; // 0x2dcf44 - g_ps2RecompiledFunctionTable[488400] = sndr_trans_func_0x2dcbb0; // 0x2dcf48 - g_ps2RecompiledFunctionTable[488401] = sndr_trans_func_0x2dcbb0; // 0x2dcf4c - g_ps2RecompiledFunctionTable[488402] = sndr_trans_func_0x2dcbb0; // 0x2dcf50 - g_ps2RecompiledFunctionTable[488403] = sndr_trans_func_0x2dcbb0; // 0x2dcf54 - g_ps2RecompiledFunctionTable[488404] = sndr_trans_func_0x2dcbb0; // 0x2dcf58 - g_ps2RecompiledFunctionTable[488405] = sndr_trans_func_0x2dcbb0; // 0x2dcf5c - g_ps2RecompiledFunctionTable[488406] = sndr_trans_func_0x2dcbb0; // 0x2dcf60 - g_ps2RecompiledFunctionTable[488407] = sndr_trans_func_0x2dcbb0; // 0x2dcf64 - g_ps2RecompiledFunctionTable[488408] = sndr_trans_func_0x2dcbb0; // 0x2dcf68 - g_ps2RecompiledFunctionTable[488409] = sndr_trans_func_0x2dcbb0; // 0x2dcf6c - g_ps2RecompiledFunctionTable[488410] = sndr_trans_func_0x2dcbb0; // 0x2dcf70 - g_ps2RecompiledFunctionTable[488411] = sndr_trans_func_0x2dcbb0; // 0x2dcf74 - g_ps2RecompiledFunctionTable[488412] = sndr_trans_func_0x2dcbb0; // 0x2dcf78 - g_ps2RecompiledFunctionTable[488413] = sndr_trans_func_0x2dcbb0; // 0x2dcf7c - g_ps2RecompiledFunctionTable[488414] = sndr_trans_func_0x2dcbb0; // 0x2dcf80 - g_ps2RecompiledFunctionTable[488415] = sndr_trans_func_0x2dcbb0; // 0x2dcf84 - g_ps2RecompiledFunctionTable[488416] = sndr_trans_func_0x2dcbb0; // 0x2dcf88 - g_ps2RecompiledFunctionTable[488417] = sndr_trans_func_0x2dcbb0; // 0x2dcf8c - g_ps2RecompiledFunctionTable[488418] = sndr_trans_func_0x2dcbb0; // 0x2dcf90 - g_ps2RecompiledFunctionTable[488419] = sndr_trans_func_0x2dcbb0; // 0x2dcf94 - g_ps2RecompiledFunctionTable[488420] = sndr_trans_func_0x2dcbb0; // 0x2dcf98 - g_ps2RecompiledFunctionTable[488421] = sndr_trans_func_0x2dcbb0; // 0x2dcf9c - g_ps2RecompiledFunctionTable[488422] = sndr_trans_func_0x2dcbb0; // 0x2dcfa0 - g_ps2RecompiledFunctionTable[488423] = sndr_trans_func_0x2dcbb0; // 0x2dcfa4 - g_ps2RecompiledFunctionTable[488424] = sndr_trans_func_0x2dcbb0; // 0x2dcfa8 - g_ps2RecompiledFunctionTable[488425] = sndr_trans_func_0x2dcbb0; // 0x2dcfac - g_ps2RecompiledFunctionTable[488426] = sndr_trans_func_0x2dcbb0; // 0x2dcfb0 - g_ps2RecompiledFunctionTable[488427] = sndr_trans_func_0x2dcbb0; // 0x2dcfb4 - g_ps2RecompiledFunctionTable[488428] = sndr_trans_func_0x2dcbb0; // 0x2dcfb8 - g_ps2RecompiledFunctionTable[488429] = sndr_trans_func_0x2dcbb0; // 0x2dcfbc - g_ps2RecompiledFunctionTable[488430] = sndr_trans_func_0x2dcbb0; // 0x2dcfc0 - g_ps2RecompiledFunctionTable[488431] = sndr_trans_func_0x2dcbb0; // 0x2dcfc4 - g_ps2RecompiledFunctionTable[488432] = sndr_trans_func_0x2dcbb0; // 0x2dcfc8 - g_ps2RecompiledFunctionTable[488433] = sndr_trans_func_0x2dcbb0; // 0x2dcfcc - g_ps2RecompiledFunctionTable[488434] = sndr_trans_func_0x2dcbb0; // 0x2dcfd0 - g_ps2RecompiledFunctionTable[488435] = sndr_trans_func_0x2dcbb0; // 0x2dcfd4 - g_ps2RecompiledFunctionTable[488436] = sndr_trans_func_0x2dcbb0; // 0x2dcfd8 - g_ps2RecompiledFunctionTable[488437] = sndr_trans_func_0x2dcbb0; // 0x2dcfdc - g_ps2RecompiledFunctionTable[488438] = sndr_trans_func_0x2dcbb0; // 0x2dcfe0 - g_ps2RecompiledFunctionTable[488439] = sndr_trans_func_0x2dcbb0; // 0x2dcfe4 - g_ps2RecompiledFunctionTable[488440] = sndr_trans_func_0x2dcbb0; // 0x2dcfe8 - g_ps2RecompiledFunctionTable[488441] = sndr_trans_func_0x2dcbb0; // 0x2dcfec - g_ps2RecompiledFunctionTable[488442] = sndr_trans_func_0x2dcbb0; // 0x2dcff0 - g_ps2RecompiledFunctionTable[488443] = sndr_trans_func_0x2dcbb0; // 0x2dcff4 - g_ps2RecompiledFunctionTable[488444] = sndr_trans_func_0x2dcbb0; // 0x2dcff8 - g_ps2RecompiledFunctionTable[488445] = sndr_trans_func_0x2dcbb0; // 0x2dcffc - g_ps2RecompiledFunctionTable[488446] = sndr_trans_func_0x2dcbb0; // 0x2dd000 - g_ps2RecompiledFunctionTable[488447] = sndr_trans_func_0x2dcbb0; // 0x2dd004 - g_ps2RecompiledFunctionTable[488448] = sndr_trans_func_0x2dcbb0; // 0x2dd008 - g_ps2RecompiledFunctionTable[488449] = sndr_trans_func_0x2dcbb0; // 0x2dd00c - g_ps2RecompiledFunctionTable[488450] = sndr_trans_func_0x2dcbb0; // 0x2dd010 - g_ps2RecompiledFunctionTable[488451] = sndr_trans_func_0x2dcbb0; // 0x2dd014 - g_ps2RecompiledFunctionTable[488452] = sndr_trans_func_0x2dcbb0; // 0x2dd018 - g_ps2RecompiledFunctionTable[488453] = sndr_trans_func_0x2dcbb0; // 0x2dd01c - g_ps2RecompiledFunctionTable[488454] = sndr_trans_func_0x2dcbb0; // 0x2dd020 - g_ps2RecompiledFunctionTable[488455] = sndr_trans_func_0x2dcbb0; // 0x2dd024 - g_ps2RecompiledFunctionTable[488456] = sndr_trans_func_0x2dcbb0; // 0x2dd028 - g_ps2RecompiledFunctionTable[488457] = sndr_trans_func_0x2dcbb0; // 0x2dd02c - g_ps2RecompiledFunctionTable[488458] = sndr_trans_func_0x2dcbb0; // 0x2dd030 - g_ps2RecompiledFunctionTable[488459] = sndr_trans_func_0x2dcbb0; // 0x2dd034 - g_ps2RecompiledFunctionTable[488460] = sndr_trans_func_0x2dcbb0; // 0x2dd038 - g_ps2RecompiledFunctionTable[488461] = sndr_trans_func_0x2dcbb0; // 0x2dd03c - g_ps2RecompiledFunctionTable[488462] = sndr_trans_func_0x2dcbb0; // 0x2dd040 - g_ps2RecompiledFunctionTable[488463] = sndr_trans_func_0x2dcbb0; // 0x2dd044 - g_ps2RecompiledFunctionTable[488464] = sndr_trans_func_0x2dcbb0; // 0x2dd048 - g_ps2RecompiledFunctionTable[488465] = sndr_trans_func_0x2dcbb0; // 0x2dd04c - g_ps2RecompiledFunctionTable[488466] = sndr_trans_func_0x2dcbb0; // 0x2dd050 - g_ps2RecompiledFunctionTable[488467] = sndr_trans_func_0x2dcbb0; // 0x2dd054 - g_ps2RecompiledFunctionTable[488468] = sndr_trans_func_0x2dcbb0; // 0x2dd058 - g_ps2RecompiledFunctionTable[488469] = sndr_trans_func_0x2dcbb0; // 0x2dd05c - g_ps2RecompiledFunctionTable[488470] = sndr_trans_func_0x2dcbb0; // 0x2dd060 - g_ps2RecompiledFunctionTable[488471] = sndr_trans_func_0x2dcbb0; // 0x2dd064 - g_ps2RecompiledFunctionTable[488472] = sndr_trans_func_0x2dcbb0; // 0x2dd068 - g_ps2RecompiledFunctionTable[488473] = sndr_trans_func_0x2dcbb0; // 0x2dd06c - g_ps2RecompiledFunctionTable[488474] = sndr_trans_func_0x2dcbb0; // 0x2dd070 - g_ps2RecompiledFunctionTable[488475] = sndr_trans_func_0x2dcbb0; // 0x2dd074 - g_ps2RecompiledFunctionTable[488476] = sndr_trans_func_0x2dcbb0; // 0x2dd078 - g_ps2RecompiledFunctionTable[488477] = sndr_trans_func_0x2dcbb0; // 0x2dd07c - g_ps2RecompiledFunctionTable[488478] = sndr_trans_func_0x2dcbb0; // 0x2dd080 - g_ps2RecompiledFunctionTable[488479] = sndr_trans_func_0x2dcbb0; // 0x2dd084 - g_ps2RecompiledFunctionTable[488480] = sndr_trans_func_0x2dcbb0; // 0x2dd088 - g_ps2RecompiledFunctionTable[488481] = sndr_trans_func_0x2dcbb0; // 0x2dd08c - g_ps2RecompiledFunctionTable[488482] = sndr_trans_func_0x2dcbb0; // 0x2dd090 - g_ps2RecompiledFunctionTable[488483] = sndr_trans_func_0x2dcbb0; // 0x2dd094 - g_ps2RecompiledFunctionTable[488484] = sndr_trans_func_0x2dcbb0; // 0x2dd098 - g_ps2RecompiledFunctionTable[488485] = sndr_trans_func_0x2dcbb0; // 0x2dd09c - g_ps2RecompiledFunctionTable[488486] = sndr_trans_func_0x2dcbb0; // 0x2dd0a0 - g_ps2RecompiledFunctionTable[488487] = sndr_trans_func_0x2dcbb0; // 0x2dd0a4 - g_ps2RecompiledFunctionTable[488488] = sndr_trans_func_0x2dcbb0; // 0x2dd0a8 - g_ps2RecompiledFunctionTable[488489] = sndr_trans_func_0x2dcbb0; // 0x2dd0ac - g_ps2RecompiledFunctionTable[488490] = sndr_trans_func_0x2dcbb0; // 0x2dd0b0 - g_ps2RecompiledFunctionTable[488491] = sndr_trans_func_0x2dcbb0; // 0x2dd0b4 - g_ps2RecompiledFunctionTable[488492] = sndr_trans_func_0x2dcbb0; // 0x2dd0b8 - g_ps2RecompiledFunctionTable[488493] = sndr_trans_func_0x2dcbb0; // 0x2dd0bc - g_ps2RecompiledFunctionTable[488494] = sndr_trans_func_0x2dcbb0; // 0x2dd0c0 - g_ps2RecompiledFunctionTable[488495] = sndr_trans_func_0x2dcbb0; // 0x2dd0c4 - g_ps2RecompiledFunctionTable[488496] = sndr_trans_func_0x2dcbb0; // 0x2dd0c8 - g_ps2RecompiledFunctionTable[488497] = sndr_trans_func_0x2dcbb0; // 0x2dd0cc - g_ps2RecompiledFunctionTable[488498] = sndr_trans_func_0x2dcbb0; // 0x2dd0d0 - g_ps2RecompiledFunctionTable[488499] = sndr_trans_func_0x2dcbb0; // 0x2dd0d4 - g_ps2RecompiledFunctionTable[488500] = sndr_trans_func_0x2dcbb0; // 0x2dd0d8 - g_ps2RecompiledFunctionTable[488501] = sndr_trans_func_0x2dcbb0; // 0x2dd0dc - g_ps2RecompiledFunctionTable[488502] = sndr_trans_func_0x2dcbb0; // 0x2dd0e0 - g_ps2RecompiledFunctionTable[488503] = sndr_trans_func_0x2dcbb0; // 0x2dd0e4 - g_ps2RecompiledFunctionTable[488504] = sndr_trans_func_0x2dcbb0; // 0x2dd0e8 - g_ps2RecompiledFunctionTable[488505] = sndr_trans_func_0x2dcbb0; // 0x2dd0ec - g_ps2RecompiledFunctionTable[488506] = sndr_trans_func_0x2dcbb0; // 0x2dd0f0 - g_ps2RecompiledFunctionTable[488507] = sndr_trans_func_0x2dcbb0; // 0x2dd0f4 - g_ps2RecompiledFunctionTable[488508] = sndr_trans_func_0x2dcbb0; // 0x2dd0f8 - g_ps2RecompiledFunctionTable[488509] = sndr_trans_func_0x2dcbb0; // 0x2dd0fc - g_ps2RecompiledFunctionTable[488510] = sndr_trans_func_0x2dcbb0; // 0x2dd100 - g_ps2RecompiledFunctionTable[488511] = sndr_trans_func_0x2dcbb0; // 0x2dd104 - g_ps2RecompiledFunctionTable[488512] = sndr_trans_func_0x2dcbb0; // 0x2dd108 - g_ps2RecompiledFunctionTable[488513] = sndr_trans_func_0x2dcbb0; // 0x2dd10c - g_ps2RecompiledFunctionTable[488514] = sndr_trans_func_0x2dcbb0; // 0x2dd110 - g_ps2RecompiledFunctionTable[488515] = sndr_trans_func_0x2dcbb0; // 0x2dd114 - g_ps2RecompiledFunctionTable[488516] = sndr_trans_func_0x2dcbb0; // 0x2dd118 - g_ps2RecompiledFunctionTable[488517] = sndr_trans_func_0x2dcbb0; // 0x2dd11c - g_ps2RecompiledFunctionTable[488518] = sndr_trans_func_0x2dcbb0; // 0x2dd120 - g_ps2RecompiledFunctionTable[488519] = sndr_trans_func_0x2dcbb0; // 0x2dd124 - g_ps2RecompiledFunctionTable[488520] = sndr_trans_func_0x2dcbb0; // 0x2dd128 - g_ps2RecompiledFunctionTable[488521] = sndr_trans_func_0x2dcbb0; // 0x2dd12c - g_ps2RecompiledFunctionTable[488522] = sndr_trans_func_0x2dcbb0; // 0x2dd130 - g_ps2RecompiledFunctionTable[488523] = sndr_trans_func_0x2dcbb0; // 0x2dd134 - g_ps2RecompiledFunctionTable[488524] = sndr_trans_func_0x2dcbb0; // 0x2dd138 - g_ps2RecompiledFunctionTable[488525] = sndr_trans_func_0x2dcbb0; // 0x2dd13c - g_ps2RecompiledFunctionTable[488526] = sndr_trans_func_0x2dcbb0; // 0x2dd140 - g_ps2RecompiledFunctionTable[488527] = sndr_trans_func_0x2dcbb0; // 0x2dd144 - g_ps2RecompiledFunctionTable[488528] = sndr_trans_func_0x2dcbb0; // 0x2dd148 - g_ps2RecompiledFunctionTable[488529] = sndr_trans_func_0x2dcbb0; // 0x2dd14c - g_ps2RecompiledFunctionTable[488530] = sndr_trans_func_0x2dcbb0; // 0x2dd150 - g_ps2RecompiledFunctionTable[488531] = sndr_trans_func_0x2dcbb0; // 0x2dd154 - g_ps2RecompiledFunctionTable[488532] = sndr_trans_func_0x2dcbb0; // 0x2dd158 - g_ps2RecompiledFunctionTable[488533] = sndr_trans_func_0x2dcbb0; // 0x2dd15c - g_ps2RecompiledFunctionTable[488534] = sndr_trans_func_0x2dcbb0; // 0x2dd160 - g_ps2RecompiledFunctionTable[488535] = sndr_trans_func_0x2dcbb0; // 0x2dd164 - g_ps2RecompiledFunctionTable[488536] = sndr_trans_func_0x2dcbb0; // 0x2dd168 - g_ps2RecompiledFunctionTable[488537] = sndr_trans_func_0x2dcbb0; // 0x2dd16c - g_ps2RecompiledFunctionTable[488538] = sndr_trans_func_0x2dcbb0; // 0x2dd170 - g_ps2RecompiledFunctionTable[488539] = sndr_trans_func_0x2dcbb0; // 0x2dd174 - g_ps2RecompiledFunctionTable[488540] = sndr_trans_func_0x2dcbb0; // 0x2dd178 - g_ps2RecompiledFunctionTable[488541] = sndr_trans_func_0x2dcbb0; // 0x2dd17c - g_ps2RecompiledFunctionTable[488542] = sndr_trans_func_0x2dcbb0; // 0x2dd180 - g_ps2RecompiledFunctionTable[488543] = sndr_trans_func_0x2dcbb0; // 0x2dd184 - g_ps2RecompiledFunctionTable[488544] = sndr_trans_func_0x2dcbb0; // 0x2dd188 - g_ps2RecompiledFunctionTable[488545] = sndr_trans_func_0x2dcbb0; // 0x2dd18c - g_ps2RecompiledFunctionTable[488546] = sndr_trans_func_0x2dcbb0; // 0x2dd190 - g_ps2RecompiledFunctionTable[488547] = sndr_trans_func_0x2dcbb0; // 0x2dd194 - g_ps2RecompiledFunctionTable[488548] = sndr_trans_func_0x2dcbb0; // 0x2dd198 - g_ps2RecompiledFunctionTable[488549] = sndr_trans_func_0x2dcbb0; // 0x2dd19c - g_ps2RecompiledFunctionTable[488550] = sndr_trans_func_0x2dcbb0; // 0x2dd1a0 - g_ps2RecompiledFunctionTable[488551] = sndr_trans_func_0x2dcbb0; // 0x2dd1a4 - g_ps2RecompiledFunctionTable[488552] = sndr_trans_func_0x2dcbb0; // 0x2dd1a8 - g_ps2RecompiledFunctionTable[488553] = sndr_trans_func_0x2dcbb0; // 0x2dd1ac - g_ps2RecompiledFunctionTable[488554] = sndr_trans_func_0x2dcbb0; // 0x2dd1b0 - g_ps2RecompiledFunctionTable[488555] = sndr_trans_func_0x2dcbb0; // 0x2dd1b4 - g_ps2RecompiledFunctionTable[488556] = sndr_trans_func_0x2dcbb0; // 0x2dd1b8 - g_ps2RecompiledFunctionTable[488557] = sndr_trans_func_0x2dcbb0; // 0x2dd1bc - g_ps2RecompiledFunctionTable[488558] = sndr_trans_func_0x2dcbb0; // 0x2dd1c0 - g_ps2RecompiledFunctionTable[488559] = sndr_trans_func_0x2dcbb0; // 0x2dd1c4 - g_ps2RecompiledFunctionTable[488560] = sndr_trans_func_0x2dcbb0; // 0x2dd1c8 - g_ps2RecompiledFunctionTable[488561] = sndr_trans_func_0x2dcbb0; // 0x2dd1cc - g_ps2RecompiledFunctionTable[488562] = sndr_trans_func_0x2dcbb0; // 0x2dd1d0 - g_ps2RecompiledFunctionTable[488563] = sndr_trans_func_0x2dcbb0; // 0x2dd1d4 - g_ps2RecompiledFunctionTable[488564] = sndr_trans_func_0x2dcbb0; // 0x2dd1d8 - g_ps2RecompiledFunctionTable[488565] = sndr_trans_func_0x2dcbb0; // 0x2dd1dc - g_ps2RecompiledFunctionTable[488566] = sndr_trans_func_0x2dcbb0; // 0x2dd1e0 - g_ps2RecompiledFunctionTable[488567] = sndr_trans_func_0x2dcbb0; // 0x2dd1e4 - g_ps2RecompiledFunctionTable[488568] = sndr_trans_func_0x2dcbb0; // 0x2dd1e8 - g_ps2RecompiledFunctionTable[488569] = sndr_trans_func_0x2dcbb0; // 0x2dd1ec - g_ps2RecompiledFunctionTable[488570] = sndr_trans_func_0x2dcbb0; // 0x2dd1f0 - g_ps2RecompiledFunctionTable[488571] = sndr_trans_func_0x2dcbb0; // 0x2dd1f4 - g_ps2RecompiledFunctionTable[488572] = sndr_trans_func_0x2dcbb0; // 0x2dd1f8 - g_ps2RecompiledFunctionTable[488573] = sndr_trans_func_0x2dcbb0; // 0x2dd1fc - g_ps2RecompiledFunctionTable[488574] = sndr_trans_func_0x2dcbb0; // 0x2dd200 - g_ps2RecompiledFunctionTable[488575] = sndr_trans_func_0x2dcbb0; // 0x2dd204 - g_ps2RecompiledFunctionTable[488576] = sndr_trans_func_0x2dcbb0; // 0x2dd208 - g_ps2RecompiledFunctionTable[488577] = sndr_trans_func_0x2dcbb0; // 0x2dd20c - g_ps2RecompiledFunctionTable[488578] = sndr_trans_func_0x2dcbb0; // 0x2dd210 - g_ps2RecompiledFunctionTable[488579] = sndr_trans_func_0x2dcbb0; // 0x2dd214 - g_ps2RecompiledFunctionTable[488580] = sndr_trans_func_0x2dcbb0; // 0x2dd218 - g_ps2RecompiledFunctionTable[488581] = sndr_trans_func_0x2dcbb0; // 0x2dd21c - g_ps2RecompiledFunctionTable[488582] = sndr_trans_func_0x2dcbb0; // 0x2dd220 - g_ps2RecompiledFunctionTable[488583] = sndr_trans_func_0x2dcbb0; // 0x2dd224 - g_ps2RecompiledFunctionTable[488584] = sndr_trans_func_0x2dcbb0; // 0x2dd228 - g_ps2RecompiledFunctionTable[488585] = sndr_trans_func_0x2dcbb0; // 0x2dd22c - g_ps2RecompiledFunctionTable[488586] = sndr_trans_func_0x2dcbb0; // 0x2dd230 - g_ps2RecompiledFunctionTable[488587] = sndr_trans_func_0x2dcbb0; // 0x2dd234 - g_ps2RecompiledFunctionTable[488588] = sndr_trans_func_0x2dcbb0; // 0x2dd238 - g_ps2RecompiledFunctionTable[488589] = sndr_trans_func_0x2dcbb0; // 0x2dd23c - g_ps2RecompiledFunctionTable[488590] = sndr_trans_func_0x2dcbb0; // 0x2dd240 - g_ps2RecompiledFunctionTable[488591] = sndr_trans_func_0x2dcbb0; // 0x2dd244 - g_ps2RecompiledFunctionTable[488592] = sndr_trans_func_0x2dcbb0; // 0x2dd248 - g_ps2RecompiledFunctionTable[488593] = sndr_trans_func_0x2dcbb0; // 0x2dd24c - g_ps2RecompiledFunctionTable[488594] = sndr_trans_func_0x2dcbb0; // 0x2dd250 - g_ps2RecompiledFunctionTable[488595] = sndr_trans_func_0x2dcbb0; // 0x2dd254 - g_ps2RecompiledFunctionTable[488596] = sndr_trans_func_0x2dcbb0; // 0x2dd258 - g_ps2RecompiledFunctionTable[488597] = sndr_trans_func_0x2dcbb0; // 0x2dd25c - g_ps2RecompiledFunctionTable[488598] = sndr_trans_func_0x2dcbb0; // 0x2dd260 - g_ps2RecompiledFunctionTable[488599] = sndr_trans_func_0x2dcbb0; // 0x2dd264 - g_ps2RecompiledFunctionTable[488600] = sndr_trans_func_0x2dcbb0; // 0x2dd268 - g_ps2RecompiledFunctionTable[488601] = sndr_trans_func_0x2dcbb0; // 0x2dd26c - g_ps2RecompiledFunctionTable[488602] = sndr_trans_func_0x2dcbb0; // 0x2dd270 - g_ps2RecompiledFunctionTable[488603] = sndr_trans_func_0x2dcbb0; // 0x2dd274 - g_ps2RecompiledFunctionTable[488604] = sndr_trans_func_0x2dcbb0; // 0x2dd278 - g_ps2RecompiledFunctionTable[488605] = sndr_trans_func_0x2dcbb0; // 0x2dd27c - g_ps2RecompiledFunctionTable[488606] = sndr_trans_func_0x2dcbb0; // 0x2dd280 - g_ps2RecompiledFunctionTable[488607] = sndr_trans_func_0x2dcbb0; // 0x2dd284 - g_ps2RecompiledFunctionTable[488608] = sndr_trans_func_0x2dcbb0; // 0x2dd288 - g_ps2RecompiledFunctionTable[488609] = sndr_trans_func_0x2dcbb0; // 0x2dd28c - g_ps2RecompiledFunctionTable[488610] = sndr_trans_func_0x2dcbb0; // 0x2dd290 - g_ps2RecompiledFunctionTable[488611] = sndr_trans_func_0x2dcbb0; // 0x2dd294 - g_ps2RecompiledFunctionTable[488612] = sndr_trans_func_0x2dcbb0; // 0x2dd298 - g_ps2RecompiledFunctionTable[488613] = sndr_trans_func_0x2dcbb0; // 0x2dd29c - g_ps2RecompiledFunctionTable[488614] = sndr_trans_func_0x2dcbb0; // 0x2dd2a0 - g_ps2RecompiledFunctionTable[488615] = sndr_trans_func_0x2dcbb0; // 0x2dd2a4 - g_ps2RecompiledFunctionTable[488616] = sndr_trans_func_0x2dcbb0; // 0x2dd2a8 - g_ps2RecompiledFunctionTable[488617] = sndr_trans_func_0x2dcbb0; // 0x2dd2ac - g_ps2RecompiledFunctionTable[488618] = sndr_trans_func_0x2dcbb0; // 0x2dd2b0 - g_ps2RecompiledFunctionTable[488619] = sndr_trans_func_0x2dcbb0; // 0x2dd2b4 - g_ps2RecompiledFunctionTable[488620] = sndr_trans_func_0x2dcbb0; // 0x2dd2b8 - g_ps2RecompiledFunctionTable[488621] = sndr_trans_func_0x2dcbb0; // 0x2dd2bc - g_ps2RecompiledFunctionTable[488622] = sndr_trans_func_0x2dcbb0; // 0x2dd2c0 - g_ps2RecompiledFunctionTable[488623] = sndr_trans_func_0x2dcbb0; // 0x2dd2c4 - g_ps2RecompiledFunctionTable[488624] = sndr_trans_func_0x2dcbb0; // 0x2dd2c8 - g_ps2RecompiledFunctionTable[488625] = sndr_trans_func_0x2dcbb0; // 0x2dd2cc - g_ps2RecompiledFunctionTable[488626] = sndr_trans_func_0x2dcbb0; // 0x2dd2d0 - g_ps2RecompiledFunctionTable[488627] = sndr_trans_func_0x2dcbb0; // 0x2dd2d4 - g_ps2RecompiledFunctionTable[488628] = sndr_trans_func_0x2dcbb0; // 0x2dd2d8 - g_ps2RecompiledFunctionTable[488629] = sndr_trans_func_0x2dcbb0; // 0x2dd2dc - g_ps2RecompiledFunctionTable[488630] = sndr_trans_func_0x2dcbb0; // 0x2dd2e0 - g_ps2RecompiledFunctionTable[488631] = sndr_trans_func_0x2dcbb0; // 0x2dd2e4 - g_ps2RecompiledFunctionTable[488632] = sndr_trans_func_0x2dcbb0; // 0x2dd2e8 - g_ps2RecompiledFunctionTable[488633] = sndr_trans_func_0x2dcbb0; // 0x2dd2ec - g_ps2RecompiledFunctionTable[488634] = sndr_trans_func_0x2dcbb0; // 0x2dd2f0 - g_ps2RecompiledFunctionTable[488635] = sndr_trans_func_0x2dcbb0; // 0x2dd2f4 - g_ps2RecompiledFunctionTable[488636] = sndr_trans_func_0x2dcbb0; // 0x2dd2f8 - g_ps2RecompiledFunctionTable[488637] = sndr_trans_func_0x2dcbb0; // 0x2dd2fc - g_ps2RecompiledFunctionTable[488638] = sndr_trans_func_0x2dcbb0; // 0x2dd300 - g_ps2RecompiledFunctionTable[488639] = sndr_trans_func_0x2dcbb0; // 0x2dd304 - g_ps2RecompiledFunctionTable[488640] = sndr_trans_func_0x2dcbb0; // 0x2dd308 - g_ps2RecompiledFunctionTable[488641] = sndr_trans_func_0x2dcbb0; // 0x2dd30c - g_ps2RecompiledFunctionTable[488642] = sndr_trans_func_0x2dcbb0; // 0x2dd310 - g_ps2RecompiledFunctionTable[488643] = sndr_trans_func_0x2dcbb0; // 0x2dd314 - g_ps2RecompiledFunctionTable[488644] = sndr_trans_func_0x2dcbb0; // 0x2dd318 - g_ps2RecompiledFunctionTable[488645] = sndr_trans_func_0x2dcbb0; // 0x2dd31c - g_ps2RecompiledFunctionTable[488646] = sndr_trans_func_0x2dcbb0; // 0x2dd320 - g_ps2RecompiledFunctionTable[488647] = sndr_trans_func_0x2dcbb0; // 0x2dd324 - g_ps2RecompiledFunctionTable[488648] = sndr_trans_func_0x2dcbb0; // 0x2dd328 - g_ps2RecompiledFunctionTable[488649] = sndr_trans_func_0x2dcbb0; // 0x2dd32c - g_ps2RecompiledFunctionTable[488650] = sndr_trans_func_0x2dcbb0; // 0x2dd330 - g_ps2RecompiledFunctionTable[488651] = sndr_trans_func_0x2dcbb0; // 0x2dd334 - g_ps2RecompiledFunctionTable[488652] = sndr_trans_func_0x2dcbb0; // 0x2dd338 - g_ps2RecompiledFunctionTable[488653] = sndr_trans_func_0x2dcbb0; // 0x2dd33c - g_ps2RecompiledFunctionTable[488654] = sndr_trans_func_0x2dcbb0; // 0x2dd340 - g_ps2RecompiledFunctionTable[488655] = sndr_trans_func_0x2dcbb0; // 0x2dd344 - g_ps2RecompiledFunctionTable[488656] = sndr_trans_func_0x2dcbb0; // 0x2dd348 - g_ps2RecompiledFunctionTable[488657] = sndr_trans_func_0x2dcbb0; // 0x2dd34c - g_ps2RecompiledFunctionTable[488658] = sndr_trans_func_0x2dcbb0; // 0x2dd350 - g_ps2RecompiledFunctionTable[488659] = sndr_trans_func_0x2dcbb0; // 0x2dd354 - g_ps2RecompiledFunctionTable[488660] = sndr_trans_func_0x2dcbb0; // 0x2dd358 - g_ps2RecompiledFunctionTable[488661] = sndr_trans_func_0x2dcbb0; // 0x2dd35c - g_ps2RecompiledFunctionTable[488662] = sndr_trans_func_0x2dcbb0; // 0x2dd360 - g_ps2RecompiledFunctionTable[488663] = sndr_trans_func_0x2dcbb0; // 0x2dd364 - g_ps2RecompiledFunctionTable[488664] = sndr_trans_func_0x2dcbb0; // 0x2dd368 - g_ps2RecompiledFunctionTable[488665] = sndr_trans_func_0x2dcbb0; // 0x2dd36c - g_ps2RecompiledFunctionTable[488666] = sndr_trans_func_0x2dcbb0; // 0x2dd370 - g_ps2RecompiledFunctionTable[488667] = sndr_trans_func_0x2dcbb0; // 0x2dd374 - g_ps2RecompiledFunctionTable[488668] = sndr_trans_func_0x2dcbb0; // 0x2dd378 - g_ps2RecompiledFunctionTable[488669] = sndr_trans_func_0x2dcbb0; // 0x2dd37c - g_ps2RecompiledFunctionTable[488670] = sndr_trans_func_0x2dcbb0; // 0x2dd380 - g_ps2RecompiledFunctionTable[488671] = sndr_trans_func_0x2dcbb0; // 0x2dd384 - g_ps2RecompiledFunctionTable[488672] = sndr_trans_func_0x2dcbb0; // 0x2dd388 - g_ps2RecompiledFunctionTable[488673] = sndr_trans_func_0x2dcbb0; // 0x2dd38c - g_ps2RecompiledFunctionTable[488674] = sndr_trans_func_0x2dcbb0; // 0x2dd390 - g_ps2RecompiledFunctionTable[488675] = sndr_trans_func_0x2dcbb0; // 0x2dd394 - g_ps2RecompiledFunctionTable[488676] = sndr_trans_func_0x2dcbb0; // 0x2dd398 - g_ps2RecompiledFunctionTable[488677] = sndr_trans_func_0x2dcbb0; // 0x2dd39c - g_ps2RecompiledFunctionTable[488678] = sndr_trans_func_0x2dcbb0; // 0x2dd3a0 - g_ps2RecompiledFunctionTable[488679] = sndr_trans_func_0x2dcbb0; // 0x2dd3a4 - g_ps2RecompiledFunctionTable[488680] = sndr_trans_func_0x2dcbb0; // 0x2dd3a8 - g_ps2RecompiledFunctionTable[488681] = sndr_trans_func_0x2dcbb0; // 0x2dd3ac - g_ps2RecompiledFunctionTable[488682] = sndr_trans_func_0x2dcbb0; // 0x2dd3b0 - g_ps2RecompiledFunctionTable[488683] = sndr_trans_func_0x2dcbb0; // 0x2dd3b4 - g_ps2RecompiledFunctionTable[488684] = sndr_trans_func_0x2dcbb0; // 0x2dd3b8 - g_ps2RecompiledFunctionTable[488685] = sndr_trans_func_0x2dcbb0; // 0x2dd3bc - g_ps2RecompiledFunctionTable[488686] = sndr_trans_func_0x2dcbb0; // 0x2dd3c0 - g_ps2RecompiledFunctionTable[488687] = sndr_trans_func_0x2dcbb0; // 0x2dd3c4 - g_ps2RecompiledFunctionTable[488688] = sndr_trans_func_0x2dcbb0; // 0x2dd3c8 - g_ps2RecompiledFunctionTable[488689] = sndr_trans_func_0x2dcbb0; // 0x2dd3cc - g_ps2RecompiledFunctionTable[488690] = sndr_trans_func_0x2dcbb0; // 0x2dd3d0 - g_ps2RecompiledFunctionTable[488691] = sndr_trans_func_0x2dcbb0; // 0x2dd3d4 - g_ps2RecompiledFunctionTable[488692] = sndr_trans_func_0x2dcbb0; // 0x2dd3d8 - g_ps2RecompiledFunctionTable[488693] = sndr_trans_func_0x2dcbb0; // 0x2dd3dc - g_ps2RecompiledFunctionTable[488694] = sndr_trans_func_0x2dcbb0; // 0x2dd3e0 - g_ps2RecompiledFunctionTable[488695] = sndr_trans_func_0x2dcbb0; // 0x2dd3e4 - g_ps2RecompiledFunctionTable[488696] = sndr_trans_func_0x2dcbb0; // 0x2dd3e8 - g_ps2RecompiledFunctionTable[488697] = sndr_trans_func_0x2dcbb0; // 0x2dd3ec - g_ps2RecompiledFunctionTable[488698] = sndr_trans_func_0x2dcbb0; // 0x2dd3f0 - g_ps2RecompiledFunctionTable[488699] = sndr_trans_func_0x2dcbb0; // 0x2dd3f4 - g_ps2RecompiledFunctionTable[488700] = sndr_trans_func_0x2dcbb0; // 0x2dd3f8 - g_ps2RecompiledFunctionTable[488701] = sndr_trans_func_0x2dcbb0; // 0x2dd3fc - g_ps2RecompiledFunctionTable[488702] = sndr_trans_func_0x2dcbb0; // 0x2dd400 - g_ps2RecompiledFunctionTable[488703] = sndr_trans_func_0x2dcbb0; // 0x2dd404 - g_ps2RecompiledFunctionTable[488704] = sndr_trans_func_0x2dcbb0; // 0x2dd408 - g_ps2RecompiledFunctionTable[488705] = sndr_trans_func_0x2dcbb0; // 0x2dd40c - g_ps2RecompiledFunctionTable[488706] = sndr_trans_func_0x2dcbb0; // 0x2dd410 - g_ps2RecompiledFunctionTable[488707] = sndr_trans_func_0x2dcbb0; // 0x2dd414 - g_ps2RecompiledFunctionTable[488708] = sndr_trans_func_0x2dcbb0; // 0x2dd418 - g_ps2RecompiledFunctionTable[488709] = sndr_trans_func_0x2dcbb0; // 0x2dd41c - g_ps2RecompiledFunctionTable[488710] = sndr_trans_func_0x2dcbb0; // 0x2dd420 - g_ps2RecompiledFunctionTable[488711] = sndr_trans_func_0x2dcbb0; // 0x2dd424 - g_ps2RecompiledFunctionTable[488712] = sndr_trans_func_0x2dcbb0; // 0x2dd428 - g_ps2RecompiledFunctionTable[488713] = sndr_trans_func_0x2dcbb0; // 0x2dd42c - g_ps2RecompiledFunctionTable[488714] = sndr_trans_func_0x2dcbb0; // 0x2dd430 - g_ps2RecompiledFunctionTable[488715] = sndr_trans_func_0x2dcbb0; // 0x2dd434 - g_ps2RecompiledFunctionTable[488716] = sndr_trans_func_0x2dcbb0; // 0x2dd438 - g_ps2RecompiledFunctionTable[488717] = sndr_trans_func_0x2dcbb0; // 0x2dd43c - g_ps2RecompiledFunctionTable[488718] = sndr_trans_func_0x2dcbb0; // 0x2dd440 - g_ps2RecompiledFunctionTable[488719] = sndr_trans_func_0x2dcbb0; // 0x2dd444 - g_ps2RecompiledFunctionTable[488720] = sndr_trans_func_0x2dcbb0; // 0x2dd448 - g_ps2RecompiledFunctionTable[488721] = sndr_trans_func_0x2dcbb0; // 0x2dd44c - g_ps2RecompiledFunctionTable[488722] = sndr_trans_func_0x2dcbb0; // 0x2dd450 - g_ps2RecompiledFunctionTable[488723] = sndr_trans_func_0x2dcbb0; // 0x2dd454 - g_ps2RecompiledFunctionTable[488724] = sndr_trans_func_0x2dcbb0; // 0x2dd458 - g_ps2RecompiledFunctionTable[488725] = sndr_trans_func_0x2dcbb0; // 0x2dd45c - g_ps2RecompiledFunctionTable[488726] = sndr_trans_func_0x2dcbb0; // 0x2dd460 - g_ps2RecompiledFunctionTable[488727] = sndr_trans_func_0x2dcbb0; // 0x2dd464 - g_ps2RecompiledFunctionTable[488728] = sndr_trans_func_0x2dcbb0; // 0x2dd468 - g_ps2RecompiledFunctionTable[488729] = sndr_trans_func_0x2dcbb0; // 0x2dd46c - g_ps2RecompiledFunctionTable[488730] = sndr_trans_func_0x2dcbb0; // 0x2dd470 - g_ps2RecompiledFunctionTable[488731] = sndr_trans_func_0x2dcbb0; // 0x2dd474 - g_ps2RecompiledFunctionTable[488732] = sndr_trans_func_0x2dcbb0; // 0x2dd478 - g_ps2RecompiledFunctionTable[488733] = sndr_trans_func_0x2dcbb0; // 0x2dd47c - g_ps2RecompiledFunctionTable[488734] = sndr_trans_func_0x2dcbb0; // 0x2dd480 - g_ps2RecompiledFunctionTable[488735] = sndr_trans_func_0x2dcbb0; // 0x2dd484 - g_ps2RecompiledFunctionTable[488736] = sndr_trans_func_0x2dcbb0; // 0x2dd488 - g_ps2RecompiledFunctionTable[488737] = sndr_trans_func_0x2dcbb0; // 0x2dd48c - g_ps2RecompiledFunctionTable[488738] = sndr_trans_func_0x2dcbb0; // 0x2dd490 - g_ps2RecompiledFunctionTable[488739] = sndr_trans_func_0x2dcbb0; // 0x2dd494 - g_ps2RecompiledFunctionTable[488740] = sndr_trans_func_0x2dcbb0; // 0x2dd498 - g_ps2RecompiledFunctionTable[488741] = sndr_trans_func_0x2dcbb0; // 0x2dd49c - g_ps2RecompiledFunctionTable[488742] = sndr_trans_func_0x2dcbb0; // 0x2dd4a0 - g_ps2RecompiledFunctionTable[488743] = sndr_trans_func_0x2dcbb0; // 0x2dd4a4 - g_ps2RecompiledFunctionTable[488744] = sndr_trans_func_0x2dcbb0; // 0x2dd4a8 - g_ps2RecompiledFunctionTable[488745] = sndr_trans_func_0x2dcbb0; // 0x2dd4ac - g_ps2RecompiledFunctionTable[488746] = sndr_trans_func_0x2dcbb0; // 0x2dd4b0 - g_ps2RecompiledFunctionTable[488747] = sndr_trans_func_0x2dcbb0; // 0x2dd4b4 - g_ps2RecompiledFunctionTable[488748] = sndr_trans_func_0x2dcbb0; // 0x2dd4b8 - g_ps2RecompiledFunctionTable[488749] = sndr_trans_func_0x2dcbb0; // 0x2dd4bc - g_ps2RecompiledFunctionTable[488750] = sndr_trans_func_0x2dcbb0; // 0x2dd4c0 - g_ps2RecompiledFunctionTable[488751] = sndr_trans_func_0x2dcbb0; // 0x2dd4c4 - g_ps2RecompiledFunctionTable[488752] = sndr_trans_func_0x2dcbb0; // 0x2dd4c8 - g_ps2RecompiledFunctionTable[488753] = sndr_trans_func_0x2dcbb0; // 0x2dd4cc - g_ps2RecompiledFunctionTable[488754] = sndr_trans_func_0x2dcbb0; // 0x2dd4d0 - g_ps2RecompiledFunctionTable[488755] = sndr_trans_func_0x2dcbb0; // 0x2dd4d4 - g_ps2RecompiledFunctionTable[488756] = sndr_trans_func_0x2dcbb0; // 0x2dd4d8 - g_ps2RecompiledFunctionTable[488757] = sndr_trans_func_0x2dcbb0; // 0x2dd4dc - g_ps2RecompiledFunctionTable[488758] = sndr_trans_func_0x2dcbb0; // 0x2dd4e0 - g_ps2RecompiledFunctionTable[488759] = sndr_trans_func_0x2dcbb0; // 0x2dd4e4 - g_ps2RecompiledFunctionTable[488760] = sndr_trans_func_0x2dcbb0; // 0x2dd4e8 - g_ps2RecompiledFunctionTable[488761] = sndr_trans_func_0x2dcbb0; // 0x2dd4ec - g_ps2RecompiledFunctionTable[488762] = sndr_trans_func_0x2dcbb0; // 0x2dd4f0 - g_ps2RecompiledFunctionTable[488763] = sndr_trans_func_0x2dcbb0; // 0x2dd4f4 - g_ps2RecompiledFunctionTable[488764] = sndr_trans_func_0x2dcbb0; // 0x2dd4f8 - g_ps2RecompiledFunctionTable[488765] = sndr_trans_func_0x2dcbb0; // 0x2dd4fc - g_ps2RecompiledFunctionTable[488766] = sndr_trans_func_0x2dcbb0; // 0x2dd500 - g_ps2RecompiledFunctionTable[488767] = sndr_trans_func_0x2dcbb0; // 0x2dd504 - g_ps2RecompiledFunctionTable[488768] = sndr_trans_func_0x2dcbb0; // 0x2dd508 - g_ps2RecompiledFunctionTable[488769] = sndr_trans_func_0x2dcbb0; // 0x2dd50c - g_ps2RecompiledFunctionTable[488770] = sndr_trans_func_0x2dcbb0; // 0x2dd510 - g_ps2RecompiledFunctionTable[488771] = sndr_trans_func_0x2dcbb0; // 0x2dd514 - g_ps2RecompiledFunctionTable[488772] = sndr_trans_func_0x2dcbb0; // 0x2dd518 - g_ps2RecompiledFunctionTable[488773] = sndr_trans_func_0x2dcbb0; // 0x2dd51c - g_ps2RecompiledFunctionTable[488774] = sndr_trans_func_0x2dcbb0; // 0x2dd520 - g_ps2RecompiledFunctionTable[488775] = sndr_trans_func_0x2dcbb0; // 0x2dd524 - g_ps2RecompiledFunctionTable[488776] = sndr_trans_func_0x2dcbb0; // 0x2dd528 - g_ps2RecompiledFunctionTable[488777] = sndr_trans_func_0x2dcbb0; // 0x2dd52c - g_ps2RecompiledFunctionTable[488778] = sndr_trans_func_0x2dcbb0; // 0x2dd530 - g_ps2RecompiledFunctionTable[488779] = sndr_trans_func_0x2dcbb0; // 0x2dd534 - g_ps2RecompiledFunctionTable[488780] = sndr_trans_func_0x2dcbb0; // 0x2dd538 - g_ps2RecompiledFunctionTable[488781] = sndr_trans_func_0x2dcbb0; // 0x2dd53c - g_ps2RecompiledFunctionTable[488782] = sndr_trans_func_0x2dcbb0; // 0x2dd540 - g_ps2RecompiledFunctionTable[488783] = sndr_trans_func_0x2dcbb0; // 0x2dd544 - g_ps2RecompiledFunctionTable[488784] = sndr_trans_func_0x2dcbb0; // 0x2dd548 - g_ps2RecompiledFunctionTable[488785] = sndr_trans_func_0x2dcbb0; // 0x2dd54c - g_ps2RecompiledFunctionTable[488786] = sndr_trans_func_0x2dcbb0; // 0x2dd550 - g_ps2RecompiledFunctionTable[488787] = sndr_trans_func_0x2dcbb0; // 0x2dd554 - g_ps2RecompiledFunctionTable[488788] = sndr_trans_func_0x2dcbb0; // 0x2dd558 - g_ps2RecompiledFunctionTable[488789] = sndr_trans_func_0x2dcbb0; // 0x2dd55c - g_ps2RecompiledFunctionTable[488790] = sndr_trans_func_0x2dcbb0; // 0x2dd560 - g_ps2RecompiledFunctionTable[488791] = sndr_trans_func_0x2dcbb0; // 0x2dd564 - g_ps2RecompiledFunctionTable[488792] = sndr_trans_func_0x2dcbb0; // 0x2dd568 - g_ps2RecompiledFunctionTable[488793] = sndr_trans_func_0x2dcbb0; // 0x2dd56c - g_ps2RecompiledFunctionTable[488794] = sndr_trans_func_0x2dcbb0; // 0x2dd570 - g_ps2RecompiledFunctionTable[488795] = sndr_trans_func_0x2dcbb0; // 0x2dd574 - g_ps2RecompiledFunctionTable[488796] = sndr_trans_func_0x2dcbb0; // 0x2dd578 - g_ps2RecompiledFunctionTable[488797] = sndr_trans_func_0x2dcbb0; // 0x2dd57c - g_ps2RecompiledFunctionTable[488798] = sndr_trans_func_0x2dcbb0; // 0x2dd580 - g_ps2RecompiledFunctionTable[488799] = sndr_trans_func_0x2dcbb0; // 0x2dd584 - g_ps2RecompiledFunctionTable[488800] = sndr_trans_func_0x2dcbb0; // 0x2dd588 - g_ps2RecompiledFunctionTable[488801] = sndr_trans_func_0x2dcbb0; // 0x2dd58c - g_ps2RecompiledFunctionTable[488802] = sndr_trans_func_0x2dcbb0; // 0x2dd590 - g_ps2RecompiledFunctionTable[488803] = sndr_trans_func_0x2dcbb0; // 0x2dd594 - g_ps2RecompiledFunctionTable[488804] = sndr_trans_func_0x2dcbb0; // 0x2dd598 - g_ps2RecompiledFunctionTable[488805] = sndr_trans_func_0x2dcbb0; // 0x2dd59c - g_ps2RecompiledFunctionTable[488806] = sndr_trans_func_0x2dcbb0; // 0x2dd5a0 - g_ps2RecompiledFunctionTable[488807] = sndr_trans_func_0x2dcbb0; // 0x2dd5a4 - g_ps2RecompiledFunctionTable[488808] = sndr_trans_func_0x2dcbb0; // 0x2dd5a8 - g_ps2RecompiledFunctionTable[488809] = sndr_trans_func_0x2dcbb0; // 0x2dd5ac - g_ps2RecompiledFunctionTable[488810] = sndr_trans_func_0x2dcbb0; // 0x2dd5b0 - g_ps2RecompiledFunctionTable[488811] = sndr_trans_func_0x2dcbb0; // 0x2dd5b4 - g_ps2RecompiledFunctionTable[488812] = sndr_trans_func_0x2dcbb0; // 0x2dd5b8 - g_ps2RecompiledFunctionTable[488813] = sndr_trans_func_0x2dcbb0; // 0x2dd5bc - g_ps2RecompiledFunctionTable[488814] = sndr_trans_func_0x2dcbb0; // 0x2dd5c0 - g_ps2RecompiledFunctionTable[488815] = sndr_trans_func_0x2dcbb0; // 0x2dd5c4 - g_ps2RecompiledFunctionTable[488818] = sdSysServer_0x2dd5d0; // 0x2dd5d0 - g_ps2RecompiledFunctionTable[488834] = sdSysServer_0x2dd5d0; // 0x2dd610 - g_ps2RecompiledFunctionTable[488836] = sdSysServer_0x2dd5d0; // 0x2dd618 - g_ps2RecompiledFunctionTable[488866] = sdSysServer_0x2dd5d0; // 0x2dd690 - g_ps2RecompiledFunctionTable[488873] = sdSysServer_0x2dd5d0; // 0x2dd6ac - g_ps2RecompiledFunctionTable[488878] = sdSysServer_0x2dd5d0; // 0x2dd6c0 - g_ps2RecompiledFunctionTable[488893] = sdSysServer_0x2dd5d0; // 0x2dd6fc - g_ps2RecompiledFunctionTable[488923] = sdSysServer_0x2dd5d0; // 0x2dd774 - g_ps2RecompiledFunctionTable[488933] = sdSysServer_0x2dd5d0; // 0x2dd79c - g_ps2RecompiledFunctionTable[488943] = sdSysServer_0x2dd5d0; // 0x2dd7c4 - g_ps2RecompiledFunctionTable[488965] = sdSysServer_0x2dd5d0; // 0x2dd81c - g_ps2RecompiledFunctionTable[488990] = sdSysServer_0x2dd5d0; // 0x2dd880 - g_ps2RecompiledFunctionTable[488999] = sdSysServer_0x2dd5d0; // 0x2dd8a4 - g_ps2RecompiledFunctionTable[489023] = sdSysServer_0x2dd5d0; // 0x2dd904 - g_ps2RecompiledFunctionTable[489029] = sdSysServer_0x2dd5d0; // 0x2dd91c - g_ps2RecompiledFunctionTable[489035] = sdSysServer_0x2dd5d0; // 0x2dd934 - g_ps2RecompiledFunctionTable[489041] = sdSysServer_0x2dd5d0; // 0x2dd94c - g_ps2RecompiledFunctionTable[489065] = sdSysServer_0x2dd5d0; // 0x2dd9ac - g_ps2RecompiledFunctionTable[489067] = sdSysServer_0x2dd5d0; // 0x2dd9b4 - g_ps2RecompiledFunctionTable[489070] = sdSysServer_0x2dd5d0; // 0x2dd9c0 - g_ps2RecompiledFunctionTable[489090] = sdSysSetSlotMax_0x2dda10; // 0x2dda10 - g_ps2RecompiledFunctionTable[489128] = sdSysSetSlotMax_0x2dda10; // 0x2ddaa8 - g_ps2RecompiledFunctionTable[489146] = sdSysSetSlotMax_0x2dda10; // 0x2ddaf0 - g_ps2RecompiledFunctionTable[489172] = sdSysSetSlotMax_0x2dda10; // 0x2ddb58 - g_ps2RecompiledFunctionTable[489202] = sdMemBlkSetTransferMode_0x2ddbd0; // 0x2ddbd0 - g_ps2RecompiledFunctionTable[489210] = sdMultiUnitDownload_0x2ddbf0; // 0x2ddbf0 - g_ps2RecompiledFunctionTable[489246] = sdMultiUnitDownload_0x2ddbf0; // 0x2ddc80 - g_ps2RecompiledFunctionTable[489248] = sdMultiUnitDownload_0x2ddbf0; // 0x2ddc88 - g_ps2RecompiledFunctionTable[489250] = sdMultiUnitDownload_0x2ddbf0; // 0x2ddc90 - g_ps2RecompiledFunctionTable[489264] = sdMultiUnitDownload_0x2ddbf0; // 0x2ddcc8 - g_ps2RecompiledFunctionTable[489266] = sdMultiUnitDownload_0x2ddbf0; // 0x2ddcd0 - g_ps2RecompiledFunctionTable[489268] = sdMultiUnitDownload_0x2ddbf0; // 0x2ddcd8 - g_ps2RecompiledFunctionTable[489282] = sdSysFinish_0x2ddd10; // 0x2ddd10 - g_ps2RecompiledFunctionTable[489290] = CpSifDmaTransEEToIOP_0x2ddd30; // 0x2ddd30 - g_ps2RecompiledFunctionTable[489313] = CpSifDmaTransEEToIOP_0x2ddd30; // 0x2ddd8c - g_ps2RecompiledFunctionTable[489323] = CpSifDmaTransEEToIOP_0x2ddd30; // 0x2dddb4 - g_ps2RecompiledFunctionTable[489327] = CpSifDmaTransEEToIOP_0x2ddd30; // 0x2dddc4 - g_ps2RecompiledFunctionTable[489331] = CpSifDmaTransEEToIOP_0x2ddd30; // 0x2dddd4 - g_ps2RecompiledFunctionTable[489333] = CpSifDmaTransEEToIOP_0x2ddd30; // 0x2ddddc - g_ps2RecompiledFunctionTable[489343] = CpSifDmaTransEEToIOP_0x2ddd30; // 0x2dde04 - g_ps2RecompiledFunctionTable[489347] = CpSifDmaTransEEToIOP_0x2ddd30; // 0x2dde14 - g_ps2RecompiledFunctionTable[489351] = CpSifDmaTransEEToIOP_0x2ddd30; // 0x2dde24 - g_ps2RecompiledFunctionTable[489366] = CpEEWait_0x2dde60; // 0x2dde60 - g_ps2RecompiledFunctionTable[489368] = CpEEWait_0x2dde60; // 0x2dde68 - g_ps2RecompiledFunctionTable[489378] = syBtExit_0x2dde90; // 0x2dde90 - g_ps2RecompiledFunctionTable[489382] = syBtGetBootSystemID_0x2ddea0; // 0x2ddea0 - g_ps2RecompiledFunctionTable[489391] = syBtGetBootSystemID_0x2ddea0; // 0x2ddec4 - g_ps2RecompiledFunctionTable[489402] = syCblCheck_0x2ddef0; // 0x2ddef0 - g_ps2RecompiledFunctionTable[489406] = syCfgExit_0x2ddf00; // 0x2ddf00 - g_ps2RecompiledFunctionTable[489410] = syCfgGetSoundMode_0x2ddf10; // 0x2ddf10 - g_ps2RecompiledFunctionTable[489418] = syCfgInit_0x2ddf30; // 0x2ddf30 - g_ps2RecompiledFunctionTable[489422] = syCfgSetSoundMode_0x2ddf40; // 0x2ddf40 - g_ps2RecompiledFunctionTable[489426] = syHwFinish_0x2ddf50; // 0x2ddf50 - g_ps2RecompiledFunctionTable[489430] = syHwInit_0x2ddf60; // 0x2ddf60 - g_ps2RecompiledFunctionTable[489434] = syHwInit2_0x2ddf70; // 0x2ddf70 - g_ps2RecompiledFunctionTable[489438] = syRtcFinish_0x2ddf80; // 0x2ddf80 - g_ps2RecompiledFunctionTable[489442] = syRtcGetDate_0x2ddf90; // 0x2ddf90 - g_ps2RecompiledFunctionTable[489448] = syRtcGetDate_0x2ddf90; // 0x2ddfa8 - g_ps2RecompiledFunctionTable[489530] = syRtcInit_0x2de0f0; // 0x2de0f0 - g_ps2RecompiledFunctionTable[489534] = syTmrGetCount_0x2de100; // 0x2de100 - g_ps2RecompiledFunctionTable[489538] = njInitPrint_0x2de110; // 0x2de110 - g_ps2RecompiledFunctionTable[489542] = njExitPrint_0x2de120; // 0x2de120 - g_ps2RecompiledFunctionTable[489546] = njPrintSize_0x2de130; // 0x2de130 - g_ps2RecompiledFunctionTable[489550] = njPrintColor_0x2de140; // 0x2de140 - g_ps2RecompiledFunctionTable[489554] = njPrintC_0x2de150; // 0x2de150 - g_ps2RecompiledFunctionTable[489558] = njDrawPolygon_0x2de160; // 0x2de160 - g_ps2RecompiledFunctionTable[489574] = njDrawPolygon_0x2de160; // 0x2de1a0 - g_ps2RecompiledFunctionTable[489628] = njDrawPolygon_0x2de160; // 0x2de278 - g_ps2RecompiledFunctionTable[489635] = njDrawPolygon_0x2de160; // 0x2de294 - g_ps2RecompiledFunctionTable[489638] = njDrawTextureSub_0x2de2a0; // 0x2de2a0 - g_ps2RecompiledFunctionTable[489656] = njDrawTextureSub_0x2de2a0; // 0x2de2e8 - g_ps2RecompiledFunctionTable[489730] = njDrawTextureSub_0x2de2a0; // 0x2de410 - g_ps2RecompiledFunctionTable[489737] = njDrawTextureSub_0x2de2a0; // 0x2de42c - g_ps2RecompiledFunctionTable[489742] = njDrawTexture_0x2de440; // 0x2de440 - g_ps2RecompiledFunctionTable[489752] = njDrawTexture_0x2de440; // 0x2de468 - g_ps2RecompiledFunctionTable[489756] = njDrawTexture_0x2de440; // 0x2de478 - g_ps2RecompiledFunctionTable[489762] = njDrawTextureSubH_0x2de490; // 0x2de490 - g_ps2RecompiledFunctionTable[489779] = njDrawTextureSubH_0x2de490; // 0x2de4d4 - g_ps2RecompiledFunctionTable[489848] = njDrawTextureSubH_0x2de490; // 0x2de5e8 - g_ps2RecompiledFunctionTable[489855] = njDrawTextureSubH_0x2de490; // 0x2de604 - g_ps2RecompiledFunctionTable[489858] = njDrawTextureH_0x2de610; // 0x2de610 - g_ps2RecompiledFunctionTable[489875] = njDrawTextureH_0x2de610; // 0x2de654 - g_ps2RecompiledFunctionTable[489877] = njDrawTextureH_0x2de610; // 0x2de65c - g_ps2RecompiledFunctionTable[489882] = njDrawTextureH_0x2de610; // 0x2de670 - g_ps2RecompiledFunctionTable[489924] = njDrawTextureH_0x2de610; // 0x2de718 - g_ps2RecompiledFunctionTable[489926] = njDrawTextureH_0x2de610; // 0x2de720 - g_ps2RecompiledFunctionTable[489934] = njDrawPolygon3DEx_0x2de740; // 0x2de740 - g_ps2RecompiledFunctionTable[489942] = njDrawPolygon3DEx_0x2de740; // 0x2de760 - g_ps2RecompiledFunctionTable[489945] = njDrawPolygon3DEx_0x2de740; // 0x2de76c - g_ps2RecompiledFunctionTable[489950] = njDrawPolygon3DExStart_0x2de780; // 0x2de780 - g_ps2RecompiledFunctionTable[489954] = njDrawPolygonSub3D_0x2de790; // 0x2de790 - g_ps2RecompiledFunctionTable[489968] = njDrawPolygonSub3D_0x2de790; // 0x2de7c8 - g_ps2RecompiledFunctionTable[489982] = njDrawPolygonSub3D_0x2de790; // 0x2de800 - g_ps2RecompiledFunctionTable[490008] = njDrawPolygonSub3D_0x2de790; // 0x2de868 - g_ps2RecompiledFunctionTable[490015] = njDrawPolygonSub3D_0x2de790; // 0x2de884 - g_ps2RecompiledFunctionTable[490026] = njDrawPolygon3DExSetData_0x2de8b0; // 0x2de8b0 - g_ps2RecompiledFunctionTable[490034] = njDrawPolygon3DExEnd_0x2de8d0; // 0x2de8d0 - g_ps2RecompiledFunctionTable[490038] = njDrawTexture3DEx_0x2de8e0; // 0x2de8e0 - g_ps2RecompiledFunctionTable[490046] = njDrawTexture3DEx_0x2de8e0; // 0x2de900 - g_ps2RecompiledFunctionTable[490049] = njDrawTexture3DEx_0x2de8e0; // 0x2de90c - g_ps2RecompiledFunctionTable[490054] = njDrawTexture3DEx1P_0x2de920; // 0x2de920 - g_ps2RecompiledFunctionTable[490062] = njDrawTexture3DEx1P_0x2de920; // 0x2de940 - g_ps2RecompiledFunctionTable[490065] = njDrawTexture3DEx1P_0x2de920; // 0x2de94c - g_ps2RecompiledFunctionTable[490070] = njDrawTexture3DExStart_0x2de960; // 0x2de960 - g_ps2RecompiledFunctionTable[490074] = njDrawTextureSub3D_0x2de970; // 0x2de970 - g_ps2RecompiledFunctionTable[490090] = njDrawTextureSub3D_0x2de970; // 0x2de9b0 - g_ps2RecompiledFunctionTable[490113] = njDrawTextureSub3D_0x2de970; // 0x2dea0c - g_ps2RecompiledFunctionTable[490130] = njDrawTextureSub3D_0x2de970; // 0x2dea50 - g_ps2RecompiledFunctionTable[490156] = njDrawTextureSub3D_0x2de970; // 0x2deab8 - g_ps2RecompiledFunctionTable[490163] = njDrawTextureSub3D_0x2de970; // 0x2dead4 - g_ps2RecompiledFunctionTable[490174] = njDrawTextureSub3D1P_0x2deb00; // 0x2deb00 - g_ps2RecompiledFunctionTable[490189] = njDrawTextureSub3D1P_0x2deb00; // 0x2deb3c - g_ps2RecompiledFunctionTable[490278] = njDrawTextureSub3D1P_0x2deb00; // 0x2deca0 - g_ps2RecompiledFunctionTable[490301] = njDrawTextureSub3D1P_0x2deb00; // 0x2decfc - g_ps2RecompiledFunctionTable[490310] = njDrawTexture3DExSetData_0x2ded20; // 0x2ded20 - g_ps2RecompiledFunctionTable[490318] = njDrawTexture3DExSetData1P_0x2ded40; // 0x2ded40 - g_ps2RecompiledFunctionTable[490326] = njDrawTexture3DExEnd_0x2ded60; // 0x2ded60 - g_ps2RecompiledFunctionTable[490330] = njDrawTextureSub3DH_0x2ded70; // 0x2ded70 - g_ps2RecompiledFunctionTable[490344] = njDrawTextureSub3DH_0x2ded70; // 0x2deda8 - g_ps2RecompiledFunctionTable[490369] = njDrawTextureSub3DH_0x2ded70; // 0x2dee0c - g_ps2RecompiledFunctionTable[490400] = njDrawTextureSub3DH_0x2ded70; // 0x2dee88 - g_ps2RecompiledFunctionTable[490407] = njDrawTextureSub3DH_0x2ded70; // 0x2deea4 - g_ps2RecompiledFunctionTable[490418] = njDrawTexture3DHEx_0x2deed0; // 0x2deed0 - g_ps2RecompiledFunctionTable[490433] = njDrawTexture3DHEx_0x2deed0; // 0x2def0c - g_ps2RecompiledFunctionTable[490438] = njDrawTexture3DHEx_0x2deed0; // 0x2def20 - g_ps2RecompiledFunctionTable[490480] = njDrawTexture3DHEx_0x2deed0; // 0x2defc8 - g_ps2RecompiledFunctionTable[490482] = njDrawTexture3DHEx_0x2deed0; // 0x2defd0 - g_ps2RecompiledFunctionTable[490490] = njQuadTextureStart_0x2deff0; // 0x2deff0 - g_ps2RecompiledFunctionTable[490502] = njQuadTextureEnd_0x2df020; // 0x2df020 - g_ps2RecompiledFunctionTable[490514] = njSetQuadTexture_0x2df050; // 0x2df050 - g_ps2RecompiledFunctionTable[490518] = njDrawQuadTexture_0x2df060; // 0x2df060 - g_ps2RecompiledFunctionTable[490608] = njDrawQuadTexture_0x2df060; // 0x2df1c8 - g_ps2RecompiledFunctionTable[490615] = njDrawQuadTexture_0x2df060; // 0x2df1e4 - g_ps2RecompiledFunctionTable[490618] = CalcPs2ZbuffAB_0x2df1f0; // 0x2df1f0 - g_ps2RecompiledFunctionTable[490638] = sceVu0ITOF12Vector_0x2df240; // 0x2df240 - g_ps2RecompiledFunctionTable[490642] = njDrawLine2D_0x2df250; // 0x2df250 - g_ps2RecompiledFunctionTable[490676] = njDrawLine2D_0x2df250; // 0x2df2d8 - g_ps2RecompiledFunctionTable[490694] = njDrawLine2D_0x2df250; // 0x2df320 - g_ps2RecompiledFunctionTable[490757] = njDrawLine2D_0x2df250; // 0x2df41c - g_ps2RecompiledFunctionTable[490770] = njDrawPolygon2D_0x2df450; // 0x2df450 - g_ps2RecompiledFunctionTable[490798] = njDrawPolygon2D_0x2df450; // 0x2df4c0 - g_ps2RecompiledFunctionTable[490818] = njDrawPolygon2D_0x2df450; // 0x2df510 - g_ps2RecompiledFunctionTable[490912] = njDrawPolygon2D_0x2df450; // 0x2df688 - g_ps2RecompiledFunctionTable[490926] = njDrawPolygon2DM_0x2df6c0; // 0x2df6c0 - g_ps2RecompiledFunctionTable[490954] = njDrawPolygon2DM_0x2df6c0; // 0x2df730 - g_ps2RecompiledFunctionTable[491026] = njDrawPolygon2DM_0x2df6c0; // 0x2df850 - g_ps2RecompiledFunctionTable[491120] = njDrawPolygon2DM_0x2df6c0; // 0x2df9c8 - g_ps2RecompiledFunctionTable[491134] = Ps2SetPlane_0x2dfa00; // 0x2dfa00 - g_ps2RecompiledFunctionTable[491145] = Ps2SetPlane_0x2dfa00; // 0x2dfa2c - g_ps2RecompiledFunctionTable[491149] = Ps2SetPlane_0x2dfa00; // 0x2dfa3c - g_ps2RecompiledFunctionTable[491153] = Ps2SetPlane_0x2dfa00; // 0x2dfa4c - g_ps2RecompiledFunctionTable[491156] = Ps2SetPlane_0x2dfa00; // 0x2dfa58 - g_ps2RecompiledFunctionTable[491166] = Ps2CalcScreenCone_0x2dfa80; // 0x2dfa80 - g_ps2RecompiledFunctionTable[491184] = Ps2CalcScreenCone_0x2dfa80; // 0x2dfac8 - g_ps2RecompiledFunctionTable[491192] = Ps2CalcScreenCone_0x2dfa80; // 0x2dfae8 - g_ps2RecompiledFunctionTable[491200] = Ps2CalcScreenCone_0x2dfa80; // 0x2dfb08 - g_ps2RecompiledFunctionTable[491208] = Ps2CalcScreenCone_0x2dfa80; // 0x2dfb28 - g_ps2RecompiledFunctionTable[491214] = Calc_Intersection2_0x2dfb40; // 0x2dfb40 - g_ps2RecompiledFunctionTable[491227] = Calc_Intersection2_0x2dfb40; // 0x2dfb74 - g_ps2RecompiledFunctionTable[491231] = Calc_Intersection2_0x2dfb40; // 0x2dfb84 - g_ps2RecompiledFunctionTable[491234] = Calc_Intersection2_0x2dfb40; // 0x2dfb90 - g_ps2RecompiledFunctionTable[491249] = Calc_Intersection2_0x2dfb40; // 0x2dfbcc - g_ps2RecompiledFunctionTable[491262] = CalcIntersectionCone_0x2dfc00; // 0x2dfc00 - g_ps2RecompiledFunctionTable[491280] = CalcIntersectionCone_0x2dfc00; // 0x2dfc48 - g_ps2RecompiledFunctionTable[491283] = CalcIntersectionCone_0x2dfc00; // 0x2dfc54 - g_ps2RecompiledFunctionTable[491287] = CalcIntersectionCone_0x2dfc00; // 0x2dfc64 - g_ps2RecompiledFunctionTable[491306] = CalcIntersectionCone_0x2dfc00; // 0x2dfcb0 - g_ps2RecompiledFunctionTable[491310] = CalcIntersectionCone_0x2dfc00; // 0x2dfcc0 - g_ps2RecompiledFunctionTable[491322] = Head_or_Tail_0x2dfcf0; // 0x2dfcf0 - g_ps2RecompiledFunctionTable[491332] = Head_or_Tail_0x2dfcf0; // 0x2dfd18 - g_ps2RecompiledFunctionTable[491335] = Head_or_Tail_0x2dfcf0; // 0x2dfd24 - g_ps2RecompiledFunctionTable[491338] = Across_Plane_0x2dfd30; // 0x2dfd30 - g_ps2RecompiledFunctionTable[491353] = Across_Plane_0x2dfd30; // 0x2dfd6c - g_ps2RecompiledFunctionTable[491357] = Across_Plane_0x2dfd30; // 0x2dfd7c - g_ps2RecompiledFunctionTable[491360] = Across_Plane_0x2dfd30; // 0x2dfd88 - g_ps2RecompiledFunctionTable[491364] = Across_Plane_0x2dfd30; // 0x2dfd98 - g_ps2RecompiledFunctionTable[491374] = njDrawLine3D_0x2dfdc0; // 0x2dfdc0 - g_ps2RecompiledFunctionTable[491402] = njDrawLine3D_0x2dfdc0; // 0x2dfe30 - g_ps2RecompiledFunctionTable[491422] = njDrawLine3D_0x2dfdc0; // 0x2dfe80 - g_ps2RecompiledFunctionTable[491447] = njDrawLine3D_0x2dfdc0; // 0x2dfee4 - g_ps2RecompiledFunctionTable[491480] = njDrawLine3D_0x2dfdc0; // 0x2dff68 - g_ps2RecompiledFunctionTable[491500] = njDrawLine3D_0x2dfdc0; // 0x2dffb8 - g_ps2RecompiledFunctionTable[491525] = njDrawLine3D_0x2dfdc0; // 0x2e001c - g_ps2RecompiledFunctionTable[491561] = njDrawLine3D_0x2dfdc0; // 0x2e00ac - g_ps2RecompiledFunctionTable[491574] = njDrawLine3DEx_0x2e00e0; // 0x2e00e0 - g_ps2RecompiledFunctionTable[491604] = njDrawLine3DEx_0x2e00e0; // 0x2e0158 - g_ps2RecompiledFunctionTable[491624] = njDrawLine3DEx_0x2e00e0; // 0x2e01a8 - g_ps2RecompiledFunctionTable[491649] = njDrawLine3DEx_0x2e00e0; // 0x2e020c - g_ps2RecompiledFunctionTable[491685] = njDrawLine3DEx_0x2e00e0; // 0x2e029c - g_ps2RecompiledFunctionTable[491692] = njDrawLine3DEx_0x2e00e0; // 0x2e02b8 - g_ps2RecompiledFunctionTable[491697] = njDrawLine3DEx_0x2e00e0; // 0x2e02cc - g_ps2RecompiledFunctionTable[491719] = njDrawLine3DEx_0x2e00e0; // 0x2e0324 - g_ps2RecompiledFunctionTable[491731] = njDrawLine3DEx_0x2e00e0; // 0x2e0354 - g_ps2RecompiledFunctionTable[491741] = njDrawLine3DEx_0x2e00e0; // 0x2e037c - g_ps2RecompiledFunctionTable[491749] = njDrawLine3DEx_0x2e00e0; // 0x2e039c - g_ps2RecompiledFunctionTable[491755] = njDrawLine3DEx_0x2e00e0; // 0x2e03b4 - g_ps2RecompiledFunctionTable[491765] = njDrawLine3DEx_0x2e00e0; // 0x2e03dc - g_ps2RecompiledFunctionTable[491773] = njDrawLine3DEx_0x2e00e0; // 0x2e03fc - g_ps2RecompiledFunctionTable[491779] = njDrawLine3DEx_0x2e00e0; // 0x2e0414 - g_ps2RecompiledFunctionTable[491805] = njDrawLine3DEx_0x2e00e0; // 0x2e047c - g_ps2RecompiledFunctionTable[491847] = njDrawLine3DEx_0x2e00e0; // 0x2e0524 - g_ps2RecompiledFunctionTable[491862] = njDrawTriangle3D_0x2e0560; // 0x2e0560 - g_ps2RecompiledFunctionTable[491896] = njDrawTriangle3D_0x2e0560; // 0x2e05e8 - g_ps2RecompiledFunctionTable[491920] = njDrawTriangle3D_0x2e0560; // 0x2e0648 - g_ps2RecompiledFunctionTable[491945] = njDrawTriangle3D_0x2e0560; // 0x2e06ac - g_ps2RecompiledFunctionTable[491981] = njDrawTriangle3D_0x2e0560; // 0x2e073c - g_ps2RecompiledFunctionTable[491994] = njDrawPolygon3D_0x2e0770; // 0x2e0770 - g_ps2RecompiledFunctionTable[492014] = njDrawPolygon3D_0x2e0770; // 0x2e07c0 - g_ps2RecompiledFunctionTable[492016] = njDrawPolygon3D_0x2e0770; // 0x2e07c8 - g_ps2RecompiledFunctionTable[492030] = njDrawPolygon3D_0x2e0770; // 0x2e0800 - g_ps2RecompiledFunctionTable[492114] = njDrawPolygon3D_0x2e0770; // 0x2e0950 - g_ps2RecompiledFunctionTable[492159] = njDrawPolygon3D_0x2e0770; // 0x2e0a04 - g_ps2RecompiledFunctionTable[492172] = njDrawPolygon3D_0x2e0770; // 0x2e0a38 - g_ps2RecompiledFunctionTable[492192] = njDrawPolygon3D_0x2e0770; // 0x2e0a88 - g_ps2RecompiledFunctionTable[492217] = njDrawPolygon3D_0x2e0770; // 0x2e0aec - g_ps2RecompiledFunctionTable[492253] = njDrawPolygon3D_0x2e0770; // 0x2e0b7c - g_ps2RecompiledFunctionTable[492266] = njDrawSprite2D_0x2e0bb0; // 0x2e0bb0 - g_ps2RecompiledFunctionTable[492309] = njDrawSprite2D_0x2e0bb0; // 0x2e0c5c - g_ps2RecompiledFunctionTable[492311] = njDrawSprite2D_0x2e0bb0; // 0x2e0c64 - g_ps2RecompiledFunctionTable[492585] = njDrawSprite2D_0x2e0bb0; // 0x2e10ac - g_ps2RecompiledFunctionTable[492651] = njDrawSprite2D_0x2e0bb0; // 0x2e11b4 - g_ps2RecompiledFunctionTable[492660] = njDrawSprite2D_0x2e0bb0; // 0x2e11d8 - g_ps2RecompiledFunctionTable[492736] = njDrawSprite2D_0x2e0bb0; // 0x2e1308 - g_ps2RecompiledFunctionTable[492738] = njDrawSprite2D_0x2e0bb0; // 0x2e1310 - g_ps2RecompiledFunctionTable[492747] = njDrawSprite2D_0x2e0bb0; // 0x2e1334 - g_ps2RecompiledFunctionTable[492766] = njSetTextureMemorySize_0x2e1380; // 0x2e1380 - g_ps2RecompiledFunctionTable[492770] = njSetVertexBuffer_0x2e1390; // 0x2e1390 - g_ps2RecompiledFunctionTable[492774] = njInitSystem_0x2e13a0; // 0x2e13a0 - g_ps2RecompiledFunctionTable[492778] = njInitVertexBuffer_0x2e13b0; // 0x2e13b0 - g_ps2RecompiledFunctionTable[492782] = njWaitVSync_0x2e13c0; // 0x2e13c0 - g_ps2RecompiledFunctionTable[492786] = null_func_0x2e13d0; // 0x2e13d0 - g_ps2RecompiledFunctionTable[492790] = Ps2InitFunc_0x2e13e0; // 0x2e13e0 - g_ps2RecompiledFunctionTable[492802] = njSetEORFunction_0x2e1410; // 0x2e1410 - g_ps2RecompiledFunctionTable[492814] = Ps2SwapDBuff_0x2e1440; // 0x2e1440 - g_ps2RecompiledFunctionTable[492815] = Ps2SwapDBuff_0x2e1440; // 0x2e1444 - g_ps2RecompiledFunctionTable[492816] = Ps2SwapDBuff_0x2e1440; // 0x2e1448 - g_ps2RecompiledFunctionTable[492817] = Ps2SwapDBuff_0x2e1440; // 0x2e144c - g_ps2RecompiledFunctionTable[492818] = Ps2SwapDBuff_0x2e1440; // 0x2e1450 - g_ps2RecompiledFunctionTable[492819] = Ps2SwapDBuff_0x2e1440; // 0x2e1454 - g_ps2RecompiledFunctionTable[492820] = Ps2SwapDBuff_0x2e1440; // 0x2e1458 - g_ps2RecompiledFunctionTable[492821] = Ps2SwapDBuff_0x2e1440; // 0x2e145c - g_ps2RecompiledFunctionTable[492822] = Ps2SwapDBuff_0x2e1440; // 0x2e1460 - g_ps2RecompiledFunctionTable[492823] = Ps2SwapDBuff_0x2e1440; // 0x2e1464 - g_ps2RecompiledFunctionTable[492824] = Ps2SwapDBuff_0x2e1440; // 0x2e1468 - g_ps2RecompiledFunctionTable[492825] = Ps2SwapDBuff_0x2e1440; // 0x2e146c - g_ps2RecompiledFunctionTable[492826] = Ps2SwapDBuff_0x2e1440; // 0x2e1470 - g_ps2RecompiledFunctionTable[492827] = Ps2SwapDBuff_0x2e1440; // 0x2e1474 - g_ps2RecompiledFunctionTable[492828] = Ps2SwapDBuff_0x2e1440; // 0x2e1478 - g_ps2RecompiledFunctionTable[492829] = Ps2SwapDBuff_0x2e1440; // 0x2e147c - g_ps2RecompiledFunctionTable[492830] = Ps2SwapDBuff_0x2e1440; // 0x2e1480 - g_ps2RecompiledFunctionTable[492831] = Ps2SwapDBuff_0x2e1440; // 0x2e1484 - g_ps2RecompiledFunctionTable[492832] = Ps2SwapDBuff_0x2e1440; // 0x2e1488 - g_ps2RecompiledFunctionTable[492833] = Ps2SwapDBuff_0x2e1440; // 0x2e148c - g_ps2RecompiledFunctionTable[492834] = Ps2SwapDBuff_0x2e1440; // 0x2e1490 - g_ps2RecompiledFunctionTable[492835] = Ps2SwapDBuff_0x2e1440; // 0x2e1494 - g_ps2RecompiledFunctionTable[492836] = Ps2SwapDBuff_0x2e1440; // 0x2e1498 - g_ps2RecompiledFunctionTable[492837] = Ps2SwapDBuff_0x2e1440; // 0x2e149c - g_ps2RecompiledFunctionTable[492838] = Ps2SwapDBuff_0x2e1440; // 0x2e14a0 - g_ps2RecompiledFunctionTable[492839] = Ps2SwapDBuff_0x2e1440; // 0x2e14a4 - g_ps2RecompiledFunctionTable[492840] = Ps2SwapDBuff_0x2e1440; // 0x2e14a8 - g_ps2RecompiledFunctionTable[492841] = Ps2SwapDBuff_0x2e1440; // 0x2e14ac - g_ps2RecompiledFunctionTable[492842] = Ps2SwapDBuff_0x2e1440; // 0x2e14b0 - g_ps2RecompiledFunctionTable[492843] = Ps2SwapDBuff_0x2e1440; // 0x2e14b4 - g_ps2RecompiledFunctionTable[492844] = Ps2SwapDBuff_0x2e1440; // 0x2e14b8 - g_ps2RecompiledFunctionTable[492845] = Ps2SwapDBuff_0x2e1440; // 0x2e14bc - g_ps2RecompiledFunctionTable[492846] = Ps2SwapDBuff_0x2e1440; // 0x2e14c0 - g_ps2RecompiledFunctionTable[492847] = Ps2SwapDBuff_0x2e1440; // 0x2e14c4 - g_ps2RecompiledFunctionTable[492848] = Ps2SwapDBuff_0x2e1440; // 0x2e14c8 - g_ps2RecompiledFunctionTable[492849] = Ps2SwapDBuff_0x2e1440; // 0x2e14cc - g_ps2RecompiledFunctionTable[492850] = Ps2SwapDBuff_0x2e1440; // 0x2e14d0 - g_ps2RecompiledFunctionTable[492851] = Ps2SwapDBuff_0x2e1440; // 0x2e14d4 - g_ps2RecompiledFunctionTable[492852] = Ps2SwapDBuff_0x2e1440; // 0x2e14d8 - g_ps2RecompiledFunctionTable[492853] = Ps2SwapDBuff_0x2e1440; // 0x2e14dc - g_ps2RecompiledFunctionTable[492854] = Ps2SwapDBuff_0x2e1440; // 0x2e14e0 - g_ps2RecompiledFunctionTable[492855] = Ps2SwapDBuff_0x2e1440; // 0x2e14e4 - g_ps2RecompiledFunctionTable[492856] = Ps2SwapDBuff_0x2e1440; // 0x2e14e8 - g_ps2RecompiledFunctionTable[492857] = Ps2SwapDBuff_0x2e1440; // 0x2e14ec - g_ps2RecompiledFunctionTable[492858] = Ps2SwapDBuff_0x2e1440; // 0x2e14f0 - g_ps2RecompiledFunctionTable[492859] = Ps2SwapDBuff_0x2e1440; // 0x2e14f4 - g_ps2RecompiledFunctionTable[492860] = Ps2SwapDBuff_0x2e1440; // 0x2e14f8 - g_ps2RecompiledFunctionTable[492861] = Ps2SwapDBuff_0x2e1440; // 0x2e14fc - g_ps2RecompiledFunctionTable[492862] = Ps2SwapDBuff_0x2e1440; // 0x2e1500 - g_ps2RecompiledFunctionTable[492863] = Ps2SwapDBuff_0x2e1440; // 0x2e1504 - g_ps2RecompiledFunctionTable[492864] = Ps2SwapDBuff_0x2e1440; // 0x2e1508 - g_ps2RecompiledFunctionTable[492865] = Ps2SwapDBuff_0x2e1440; // 0x2e150c - g_ps2RecompiledFunctionTable[492866] = Ps2SwapDBuff_0x2e1440; // 0x2e1510 - g_ps2RecompiledFunctionTable[492867] = Ps2SwapDBuff_0x2e1440; // 0x2e1514 - g_ps2RecompiledFunctionTable[492868] = Ps2SwapDBuff_0x2e1440; // 0x2e1518 - g_ps2RecompiledFunctionTable[492870] = vsync_func_0x2e1520; // 0x2e1520 - g_ps2RecompiledFunctionTable[492906] = Ps2SetVSyncCounter_0x2e15b0; // 0x2e15b0 - g_ps2RecompiledFunctionTable[492910] = Ps2SetVSyncCounter_0x2e15b0; // 0x2e15c0 - g_ps2RecompiledFunctionTable[492915] = Ps2SetVSyncCounter_0x2e15b0; // 0x2e15d4 - g_ps2RecompiledFunctionTable[492917] = Ps2SetVSyncCounter_0x2e15b0; // 0x2e15dc - g_ps2RecompiledFunctionTable[492922] = njSetVSyncFunction_0x2e15f0; // 0x2e15f0 - g_ps2RecompiledFunctionTable[492934] = njExitSystem_0x2e1620; // 0x2e1620 - g_ps2RecompiledFunctionTable[492938] = njSetBackColor_0x2e1630; // 0x2e1630 - g_ps2RecompiledFunctionTable[492962] = njTextureFilterMode_0x2e1690; // 0x2e1690 - g_ps2RecompiledFunctionTable[492966] = njPolygonCullingMode_0x2e16a0; // 0x2e16a0 - g_ps2RecompiledFunctionTable[492970] = njColorBlendingModeSys_0x2e16b0; // 0x2e16b0 - g_ps2RecompiledFunctionTable[493030] = njColorBlendingModeSys_0x2e16b0; // 0x2e17a0 - g_ps2RecompiledFunctionTable[493034] = njColorBlendingModeSys_0x2e16b0; // 0x2e17b0 - g_ps2RecompiledFunctionTable[493070] = njColorBlendingModeSys_0x2e16b0; // 0x2e1840 - g_ps2RecompiledFunctionTable[493072] = njColorBlendingModeSys_0x2e16b0; // 0x2e1848 - g_ps2RecompiledFunctionTable[493078] = njColorBlendingMode_0x2e1860; // 0x2e1860 - g_ps2RecompiledFunctionTable[493094] = njTextureShadingMode_0x2e18a0; // 0x2e18a0 - g_ps2RecompiledFunctionTable[493098] = njSetCheapShadowMode_0x2e18b0; // 0x2e18b0 - g_ps2RecompiledFunctionTable[493102] = njUserClipping_0x2e18c0; // 0x2e18c0 - g_ps2RecompiledFunctionTable[493111] = njUserClipping_0x2e18c0; // 0x2e18e4 - g_ps2RecompiledFunctionTable[493146] = njUserClipping_0x2e18c0; // 0x2e1970 - g_ps2RecompiledFunctionTable[493181] = njUserClipping_0x2e18c0; // 0x2e19fc - g_ps2RecompiledFunctionTable[493183] = njUserClipping_0x2e18c0; // 0x2e1a04 - g_ps2RecompiledFunctionTable[493187] = njUserClipping_0x2e18c0; // 0x2e1a14 - g_ps2RecompiledFunctionTable[493189] = njUserClipping_0x2e18c0; // 0x2e1a1c - g_ps2RecompiledFunctionTable[493198] = njGetSystemAttr_0x2e1a40; // 0x2e1a40 - g_ps2RecompiledFunctionTable[493206] = njSetSystemAttr_0x2e1a60; // 0x2e1a60 - g_ps2RecompiledFunctionTable[493214] = njChangeSystem_0x2e1a80; // 0x2e1a80 - g_ps2RecompiledFunctionTable[493218] = njAdjustDisplay_0x2e1a90; // 0x2e1a90 - g_ps2RecompiledFunctionTable[493274] = njSetBorderColor_0x2e1b70; // 0x2e1b70 - g_ps2RecompiledFunctionTable[493278] = Ps2MemCopy4_0x2e1b80; // 0x2e1b80 - g_ps2RecompiledFunctionTable[493281] = Ps2MemCopy4_0x2e1b80; // 0x2e1b8c - g_ps2RecompiledFunctionTable[493290] = njInitTextureBuffer_0x2e1bb0; // 0x2e1bb0 - g_ps2RecompiledFunctionTable[493294] = njInitTexture_0x2e1bc0; // 0x2e1bc0 - g_ps2RecompiledFunctionTable[493301] = njInitTexture_0x2e1bc0; // 0x2e1bdc - g_ps2RecompiledFunctionTable[493369] = njInitTexture_0x2e1bc0; // 0x2e1cec - g_ps2RecompiledFunctionTable[493398] = njExitTexture_0x2e1d60; // 0x2e1d60 - g_ps2RecompiledFunctionTable[493402] = SearchNumber_0x2e1d70; // 0x2e1d70 - g_ps2RecompiledFunctionTable[493413] = SearchNumber_0x2e1d70; // 0x2e1d9c - g_ps2RecompiledFunctionTable[493434] = SearchNullNumber_0x2e1df0; // 0x2e1df0 - g_ps2RecompiledFunctionTable[493441] = SearchNullNumber_0x2e1df0; // 0x2e1e0c - g_ps2RecompiledFunctionTable[493454] = njLoadTexture_0x2e1e40; // 0x2e1e40 - g_ps2RecompiledFunctionTable[493472] = njLoadTexture_0x2e1e40; // 0x2e1e88 - g_ps2RecompiledFunctionTable[493477] = njLoadTexture_0x2e1e40; // 0x2e1e9c - g_ps2RecompiledFunctionTable[493501] = njLoadTexture_0x2e1e40; // 0x2e1efc - g_ps2RecompiledFunctionTable[493513] = njLoadTexture_0x2e1e40; // 0x2e1f2c - g_ps2RecompiledFunctionTable[493524] = njLoadTexture_0x2e1e40; // 0x2e1f58 - g_ps2RecompiledFunctionTable[493551] = njLoadTexture_0x2e1e40; // 0x2e1fc4 - g_ps2RecompiledFunctionTable[493570] = njLoadTexture_0x2e1e40; // 0x2e2010 - g_ps2RecompiledFunctionTable[493582] = njLoadTexture_0x2e1e40; // 0x2e2040 - g_ps2RecompiledFunctionTable[493622] = njLoadTexture_0x2e1e40; // 0x2e20e0 - g_ps2RecompiledFunctionTable[493626] = njLoadTexture_0x2e1e40; // 0x2e20f0 - g_ps2RecompiledFunctionTable[493630] = njLoadTexture_0x2e1e40; // 0x2e2100 - g_ps2RecompiledFunctionTable[493636] = njLoadTexture_0x2e1e40; // 0x2e2118 - g_ps2RecompiledFunctionTable[493650] = njSetTexture_0x2e2150; // 0x2e2150 - g_ps2RecompiledFunctionTable[493658] = njSetTextureNum_0x2e2170; // 0x2e2170 - g_ps2RecompiledFunctionTable[493682] = njSetTextureNumG_0x2e21d0; // 0x2e21d0 - g_ps2RecompiledFunctionTable[493688] = njSetTextureNumG_0x2e21d0; // 0x2e21e8 - g_ps2RecompiledFunctionTable[493703] = njSetTextureNumG_0x2e21d0; // 0x2e2224 - g_ps2RecompiledFunctionTable[493710] = njSetTextureNumG_0x2e21d0; // 0x2e2240 - g_ps2RecompiledFunctionTable[493712] = njSetTextureNumG_0x2e21d0; // 0x2e2248 - g_ps2RecompiledFunctionTable[493718] = njSetTextureNumSys_0x2e2260; // 0x2e2260 - g_ps2RecompiledFunctionTable[493730] = njReleaseTextureAll_0x2e2290; // 0x2e2290 - g_ps2RecompiledFunctionTable[493738] = njReleaseTexture_0x2e22b0; // 0x2e22b0 - g_ps2RecompiledFunctionTable[493754] = njReleaseTexture_0x2e22b0; // 0x2e22f0 - g_ps2RecompiledFunctionTable[493773] = njReleaseTexture_0x2e22b0; // 0x2e233c - g_ps2RecompiledFunctionTable[493794] = njReleaseTexture_0x2e22b0; // 0x2e2390 - g_ps2RecompiledFunctionTable[493802] = njCalcTexture_0x2e23b0; // 0x2e23b0 - g_ps2RecompiledFunctionTable[493806] = njSetTextureInfo_0x2e23c0; // 0x2e23c0 - g_ps2RecompiledFunctionTable[493814] = njSetTextureName_0x2e23e0; // 0x2e23e0 - g_ps2RecompiledFunctionTable[493818] = njRenderTextureNum_0x2e23f0; // 0x2e23f0 - g_ps2RecompiledFunctionTable[493830] = njRenderTextureNumG_0x2e2420; // 0x2e2420 - g_ps2RecompiledFunctionTable[493834] = njRenderTextureNumG_0x2e2420; // 0x2e2430 - g_ps2RecompiledFunctionTable[493844] = njRenderTextureNumG_0x2e2420; // 0x2e2458 - g_ps2RecompiledFunctionTable[493851] = njRenderTextureNumG_0x2e2420; // 0x2e2474 - g_ps2RecompiledFunctionTable[493853] = njRenderTextureNumG_0x2e2420; // 0x2e247c - g_ps2RecompiledFunctionTable[493858] = njSetRenderWidth_0x2e2490; // 0x2e2490 - g_ps2RecompiledFunctionTable[493862] = njSetPaletteBankNum_0x2e24a0; // 0x2e24a0 - g_ps2RecompiledFunctionTable[493874] = njSetPaletteMode_0x2e24d0; // 0x2e24d0 - g_ps2RecompiledFunctionTable[493878] = njGetPaletteMode_0x2e24e0; // 0x2e24e0 - g_ps2RecompiledFunctionTable[493882] = njSetPaletteData_0x2e24f0; // 0x2e24f0 - g_ps2RecompiledFunctionTable[493886] = njGarbageTexture_0x2e2500; // 0x2e2500 - g_ps2RecompiledFunctionTable[493890] = Ps2GetTim2Size_0x2e2510; // 0x2e2510 - g_ps2RecompiledFunctionTable[493894] = Ps2TextureMalloc_0x2e2520; // 0x2e2520 - g_ps2RecompiledFunctionTable[493918] = Ps2TextureMalloc_0x2e2520; // 0x2e2580 - g_ps2RecompiledFunctionTable[493970] = Ps2TextureMalloc_0x2e2520; // 0x2e2650 - g_ps2RecompiledFunctionTable[494009] = Ps2TextureMalloc_0x2e2520; // 0x2e26ec - g_ps2RecompiledFunctionTable[494012] = Ps2TextureMalloc_0x2e2520; // 0x2e26f8 - g_ps2RecompiledFunctionTable[494030] = Ps2TextureFree_0x2e2740; // 0x2e2740 - g_ps2RecompiledFunctionTable[494038] = Ps2TextureFree_0x2e2740; // 0x2e2760 - g_ps2RecompiledFunctionTable[494064] = Ps2TextureFree_0x2e2740; // 0x2e27c8 - g_ps2RecompiledFunctionTable[494070] = Ps2ReplaceTexAddr_0x2e27e0; // 0x2e27e0 - g_ps2RecompiledFunctionTable[494077] = Ps2ReplaceTexAddr_0x2e27e0; // 0x2e27fc - g_ps2RecompiledFunctionTable[494094] = Ps2TextureGarbageCollectionAll_0x2e2840; // 0x2e2840 - g_ps2RecompiledFunctionTable[494098] = Ps2TextureGarbageCollectionAll_0x2e2840; // 0x2e2850 - g_ps2RecompiledFunctionTable[494102] = Ps2TextureGarbageCollectionAll_0x2e2840; // 0x2e2860 - g_ps2RecompiledFunctionTable[494118] = Ps2TextureGarbageCollectionAll_0x2e2840; // 0x2e28a0 - g_ps2RecompiledFunctionTable[494121] = Ps2TextureGarbageCollectionAll_0x2e2840; // 0x2e28ac - g_ps2RecompiledFunctionTable[494132] = Ps2TextureGarbageCollectionAll_0x2e2840; // 0x2e28d8 - g_ps2RecompiledFunctionTable[494146] = ring_check_0x2e2910; // 0x2e2910 - g_ps2RecompiledFunctionTable[494154] = ring_check_0x2e2910; // 0x2e2930 - g_ps2RecompiledFunctionTable[494164] = ring_check_0x2e2910; // 0x2e2958 - g_ps2RecompiledFunctionTable[494170] = njSetScreen_0x2e2970; // 0x2e2970 - g_ps2RecompiledFunctionTable[494178] = njSetScreen_0x2e2970; // 0x2e2990 - g_ps2RecompiledFunctionTable[494224] = njSetScreen_0x2e2970; // 0x2e2a48 - g_ps2RecompiledFunctionTable[494227] = njSetScreen_0x2e2970; // 0x2e2a54 - g_ps2RecompiledFunctionTable[494232] = njSetScreen_0x2e2970; // 0x2e2a68 - g_ps2RecompiledFunctionTable[494238] = njSetPerspective_0x2e2a80; // 0x2e2a80 - g_ps2RecompiledFunctionTable[494248] = njSetPerspective_0x2e2a80; // 0x2e2aa8 - g_ps2RecompiledFunctionTable[494259] = njSetPerspective_0x2e2a80; // 0x2e2ad4 - g_ps2RecompiledFunctionTable[494262] = njSetPerspective_0x2e2a80; // 0x2e2ae0 - g_ps2RecompiledFunctionTable[494265] = njSetPerspective_0x2e2a80; // 0x2e2aec - g_ps2RecompiledFunctionTable[494270] = njSetScreenProjection_0x2e2b00; // 0x2e2b00 - g_ps2RecompiledFunctionTable[494275] = njSetScreenProjection_0x2e2b00; // 0x2e2b14 - g_ps2RecompiledFunctionTable[494278] = njSetScreenProjection_0x2e2b00; // 0x2e2b20 - g_ps2RecompiledFunctionTable[494281] = njSetScreenProjection_0x2e2b00; // 0x2e2b2c - g_ps2RecompiledFunctionTable[494286] = njSetAspect_0x2e2b40; // 0x2e2b40 - g_ps2RecompiledFunctionTable[494299] = njSetAspect_0x2e2b40; // 0x2e2b74 - g_ps2RecompiledFunctionTable[494302] = njSetAspect_0x2e2b40; // 0x2e2b80 - g_ps2RecompiledFunctionTable[494310] = njInitView_0x2e2ba0; // 0x2e2ba0 - g_ps2RecompiledFunctionTable[494334] = njSetView_0x2e2c00; // 0x2e2c00 - g_ps2RecompiledFunctionTable[494365] = njSetView_0x2e2c00; // 0x2e2c7c - g_ps2RecompiledFunctionTable[494367] = njSetView_0x2e2c00; // 0x2e2c84 - g_ps2RecompiledFunctionTable[494370] = njClipZ_0x2e2c90; // 0x2e2c90 - g_ps2RecompiledFunctionTable[494402] = njClipZ_0x2e2c90; // 0x2e2d10 - g_ps2RecompiledFunctionTable[494404] = njClipZ_0x2e2c90; // 0x2e2d18 - g_ps2RecompiledFunctionTable[494410] = njCalcScreen_0x2e2d30; // 0x2e2d30 - g_ps2RecompiledFunctionTable[494421] = njCalcScreen_0x2e2d30; // 0x2e2d5c - g_ps2RecompiledFunctionTable[494494] = njViewScreenMatrix_0x2e2e80; // 0x2e2e80 - g_ps2RecompiledFunctionTable[494499] = njViewScreenMatrix_0x2e2e80; // 0x2e2e94 - g_ps2RecompiledFunctionTable[494518] = ps2__Make_ClipMatrix_0x2e2ee0; // 0x2e2ee0 - g_ps2RecompiledFunctionTable[494545] = ps2__Make_ClipMatrix_0x2e2ee0; // 0x2e2f4c - g_ps2RecompiledFunctionTable[494594] = ps2__Make_ClipVolume_0x2e3010; // 0x2e3010 - g_ps2RecompiledFunctionTable[494629] = ps2__Make_ClipVolume_0x2e3010; // 0x2e309c - g_ps2RecompiledFunctionTable[494650] = ps2__Make_ClipVolume_0x2e3010; // 0x2e30f0 - g_ps2RecompiledFunctionTable[494654] = njMemCopy_0x2e3100; // 0x2e3100 - g_ps2RecompiledFunctionTable[494656] = njMemCopy_0x2e3100; // 0x2e3108 - g_ps2RecompiledFunctionTable[494666] = njMemCopy4_0x2e3130; // 0x2e3130 - g_ps2RecompiledFunctionTable[494668] = njMemCopy4_0x2e3130; // 0x2e3138 - g_ps2RecompiledFunctionTable[494678] = njIsParalellL2L_0x2e3160; // 0x2e3160 - g_ps2RecompiledFunctionTable[494696] = njIsParalellL2L_0x2e3160; // 0x2e31a8 - g_ps2RecompiledFunctionTable[494707] = njIsParalellL2L_0x2e3160; // 0x2e31d4 - g_ps2RecompiledFunctionTable[494715] = njIsParalellL2L_0x2e3160; // 0x2e31f4 - g_ps2RecompiledFunctionTable[494738] = njIsParalellL2PL_0x2e3250; // 0x2e3250 - g_ps2RecompiledFunctionTable[494756] = njIsParalellL2PL_0x2e3250; // 0x2e3298 - g_ps2RecompiledFunctionTable[494767] = njIsParalellL2PL_0x2e3250; // 0x2e32c4 - g_ps2RecompiledFunctionTable[494775] = njIsParalellL2PL_0x2e3250; // 0x2e32e4 - g_ps2RecompiledFunctionTable[494798] = njDistanceP2P_0x2e3340; // 0x2e3340 - g_ps2RecompiledFunctionTable[494814] = njDistanceP2L_0x2e3380; // 0x2e3380 - g_ps2RecompiledFunctionTable[494833] = njDistanceP2L_0x2e3380; // 0x2e33cc - g_ps2RecompiledFunctionTable[494883] = njDistanceP2L_0x2e3380; // 0x2e3494 - g_ps2RecompiledFunctionTable[494894] = njDistanceP2PL_0x2e34c0; // 0x2e34c0 - g_ps2RecompiledFunctionTable[494913] = njDistanceP2PL_0x2e34c0; // 0x2e350c - g_ps2RecompiledFunctionTable[494943] = njDistanceP2PL_0x2e34c0; // 0x2e3584 - g_ps2RecompiledFunctionTable[494954] = njDistanceL2L_0x2e35b0; // 0x2e35b0 - g_ps2RecompiledFunctionTable[494979] = njDistanceL2L_0x2e35b0; // 0x2e3614 - g_ps2RecompiledFunctionTable[494990] = njDistanceL2L_0x2e35b0; // 0x2e3640 - g_ps2RecompiledFunctionTable[494999] = njDistanceL2L_0x2e35b0; // 0x2e3664 - g_ps2RecompiledFunctionTable[495019] = njDistanceL2L_0x2e35b0; // 0x2e36b4 - g_ps2RecompiledFunctionTable[495089] = njDistanceL2L_0x2e35b0; // 0x2e37cc - g_ps2RecompiledFunctionTable[495095] = njDistanceL2L_0x2e35b0; // 0x2e37e4 - g_ps2RecompiledFunctionTable[495122] = njDistanceL2PL_0x2e3850; // 0x2e3850 - g_ps2RecompiledFunctionTable[495145] = njDistanceL2PL_0x2e3850; // 0x2e38ac - g_ps2RecompiledFunctionTable[495156] = njDistanceL2PL_0x2e3850; // 0x2e38d8 - g_ps2RecompiledFunctionTable[495166] = njDistanceL2PL_0x2e3850; // 0x2e3900 - g_ps2RecompiledFunctionTable[495204] = njDistanceL2PL_0x2e3850; // 0x2e3998 - g_ps2RecompiledFunctionTable[495222] = njGetPlaneNormal_0x2e39e0; // 0x2e39e0 - g_ps2RecompiledFunctionTable[495262] = njGetPlaneNormal2_0x2e3a80; // 0x2e3a80 - g_ps2RecompiledFunctionTable[495302] = njCollisionCheckSS_0x2e3b20; // 0x2e3b20 - g_ps2RecompiledFunctionTable[495330] = njCollisionCheckCC_0x2e3b90; // 0x2e3b90 - g_ps2RecompiledFunctionTable[495381] = njCollisionCheckCC_0x2e3b90; // 0x2e3c5c - g_ps2RecompiledFunctionTable[495396] = njCollisionCheckCC_0x2e3b90; // 0x2e3c98 - g_ps2RecompiledFunctionTable[495409] = njCollisionCheckCC_0x2e3b90; // 0x2e3ccc - g_ps2RecompiledFunctionTable[495421] = njCollisionCheckCC_0x2e3b90; // 0x2e3cfc - g_ps2RecompiledFunctionTable[495430] = njCollisionCheckCC_0x2e3b90; // 0x2e3d20 - g_ps2RecompiledFunctionTable[495434] = njCollisionCheckCC_0x2e3b90; // 0x2e3d30 - g_ps2RecompiledFunctionTable[495448] = njCollisionCheckCC_0x2e3b90; // 0x2e3d68 - g_ps2RecompiledFunctionTable[495461] = njCollisionCheckCC_0x2e3b90; // 0x2e3d9c - g_ps2RecompiledFunctionTable[495465] = njCollisionCheckCC_0x2e3b90; // 0x2e3dac - g_ps2RecompiledFunctionTable[495479] = njCollisionCheckCC_0x2e3b90; // 0x2e3de4 - g_ps2RecompiledFunctionTable[495492] = njCollisionCheckCC_0x2e3b90; // 0x2e3e18 - g_ps2RecompiledFunctionTable[495514] = njCollisionCheckSC_0x2e3e70; // 0x2e3e70 - g_ps2RecompiledFunctionTable[495547] = njCollisionCheckSC_0x2e3e70; // 0x2e3ef4 - g_ps2RecompiledFunctionTable[495556] = njCollisionCheckSC_0x2e3e70; // 0x2e3f18 - g_ps2RecompiledFunctionTable[495560] = njCollisionCheckSC_0x2e3e70; // 0x2e3f28 - g_ps2RecompiledFunctionTable[495574] = njCollisionCheckSC_0x2e3e70; // 0x2e3f60 - g_ps2RecompiledFunctionTable[495587] = njCollisionCheckSC_0x2e3e70; // 0x2e3f94 - g_ps2RecompiledFunctionTable[495606] = njCollisionCheckBS_0x2e3fe0; // 0x2e3fe0 - g_ps2RecompiledFunctionTable[495734] = njCollisionCheckBS_0x2e3fe0; // 0x2e41e0 - g_ps2RecompiledFunctionTable[495747] = njCollisionCheckBS_0x2e3fe0; // 0x2e4214 - g_ps2RecompiledFunctionTable[495760] = njCollisionCheckBS_0x2e3fe0; // 0x2e4248 - g_ps2RecompiledFunctionTable[495773] = njCollisionCheckBS_0x2e3fe0; // 0x2e427c - g_ps2RecompiledFunctionTable[495786] = njCollisionCheckBS_0x2e3fe0; // 0x2e42b0 - g_ps2RecompiledFunctionTable[495799] = njCollisionCheckBS_0x2e3fe0; // 0x2e42e4 - g_ps2RecompiledFunctionTable[495812] = njCollisionCheckBS_0x2e3fe0; // 0x2e4318 - g_ps2RecompiledFunctionTable[495825] = njCollisionCheckBS_0x2e3fe0; // 0x2e434c - g_ps2RecompiledFunctionTable[495838] = njCollisionCheckBS_0x2e3fe0; // 0x2e4380 - g_ps2RecompiledFunctionTable[495851] = njCollisionCheckBS_0x2e3fe0; // 0x2e43b4 - g_ps2RecompiledFunctionTable[495864] = njCollisionCheckBS_0x2e3fe0; // 0x2e43e8 - g_ps2RecompiledFunctionTable[495877] = njCollisionCheckBS_0x2e3fe0; // 0x2e441c - g_ps2RecompiledFunctionTable[495890] = njCollisionCheckBC_0x2e4450; // 0x2e4450 - g_ps2RecompiledFunctionTable[496154] = njCollisionCheckBC_0x2e4450; // 0x2e4870 - g_ps2RecompiledFunctionTable[496167] = njCollisionCheckBC_0x2e4450; // 0x2e48a4 - g_ps2RecompiledFunctionTable[496180] = njCollisionCheckBC_0x2e4450; // 0x2e48d8 - g_ps2RecompiledFunctionTable[496193] = njCollisionCheckBC_0x2e4450; // 0x2e490c - g_ps2RecompiledFunctionTable[496206] = njCollisionCheckBC_0x2e4450; // 0x2e4940 - g_ps2RecompiledFunctionTable[496219] = njCollisionCheckBC_0x2e4450; // 0x2e4974 - g_ps2RecompiledFunctionTable[496232] = njCollisionCheckBC_0x2e4450; // 0x2e49a8 - g_ps2RecompiledFunctionTable[496245] = njCollisionCheckBC_0x2e4450; // 0x2e49dc - g_ps2RecompiledFunctionTable[496258] = njCollisionCheckBC_0x2e4450; // 0x2e4a10 - g_ps2RecompiledFunctionTable[496271] = njCollisionCheckBC_0x2e4450; // 0x2e4a44 - g_ps2RecompiledFunctionTable[496284] = njCollisionCheckBC_0x2e4450; // 0x2e4a78 - g_ps2RecompiledFunctionTable[496297] = njCollisionCheckBC_0x2e4450; // 0x2e4aac - g_ps2RecompiledFunctionTable[496315] = njCollisionCheckBC_0x2e4450; // 0x2e4af4 - g_ps2RecompiledFunctionTable[496338] = njCollisionCheckBC_0x2e4450; // 0x2e4b50 - g_ps2RecompiledFunctionTable[496366] = njCheckPlane4AndLine_0x2e4bc0; // 0x2e4bc0 - g_ps2RecompiledFunctionTable[496405] = njCheckPlane4AndLine_0x2e4bc0; // 0x2e4c5c - g_ps2RecompiledFunctionTable[496414] = njCheckPlane4AndLine_0x2e4bc0; // 0x2e4c80 - g_ps2RecompiledFunctionTable[496489] = njCheckPlane4AndLine_0x2e4bc0; // 0x2e4dac - g_ps2RecompiledFunctionTable[496513] = njCheckPlane4AndLine_0x2e4bc0; // 0x2e4e0c - g_ps2RecompiledFunctionTable[496537] = njCheckPlane4AndLine_0x2e4bc0; // 0x2e4e6c - g_ps2RecompiledFunctionTable[496561] = njCheckPlane4AndLine_0x2e4bc0; // 0x2e4ecc - g_ps2RecompiledFunctionTable[496631] = njCheckPlane4AndLine_0x2e4bc0; // 0x2e4fe4 - g_ps2RecompiledFunctionTable[496634] = njCheckPlane4AndLine_0x2e4bc0; // 0x2e4ff0 - g_ps2RecompiledFunctionTable[496637] = njCheckPlane4AndLine_0x2e4bc0; // 0x2e4ffc - g_ps2RecompiledFunctionTable[496640] = njCheckPlane4AndLine_0x2e4bc0; // 0x2e5008 - g_ps2RecompiledFunctionTable[496674] = njCollisionCheckBC2_0x2e5090; // 0x2e5090 - g_ps2RecompiledFunctionTable[496720] = njCollisionCheckBC2_0x2e5090; // 0x2e5148 - g_ps2RecompiledFunctionTable[496733] = njCollisionCheckBC2_0x2e5090; // 0x2e517c - g_ps2RecompiledFunctionTable[496746] = njCollisionCheckBC2_0x2e5090; // 0x2e51b0 - g_ps2RecompiledFunctionTable[496759] = njCollisionCheckBC2_0x2e5090; // 0x2e51e4 - g_ps2RecompiledFunctionTable[496772] = njCollisionCheckBC2_0x2e5090; // 0x2e5218 - g_ps2RecompiledFunctionTable[496785] = njCollisionCheckBC2_0x2e5090; // 0x2e524c - g_ps2RecompiledFunctionTable[496798] = njCollisionCheckBC2_0x2e5090; // 0x2e5280 - g_ps2RecompiledFunctionTable[496811] = njCollisionCheckBC2_0x2e5090; // 0x2e52b4 - g_ps2RecompiledFunctionTable[496824] = njCollisionCheckBC2_0x2e5090; // 0x2e52e8 - g_ps2RecompiledFunctionTable[496837] = njCollisionCheckBC2_0x2e5090; // 0x2e531c - g_ps2RecompiledFunctionTable[496850] = njCollisionCheckBC2_0x2e5090; // 0x2e5350 - g_ps2RecompiledFunctionTable[496863] = njCollisionCheckBC2_0x2e5090; // 0x2e5384 - g_ps2RecompiledFunctionTable[496891] = njCollisionCheckBC2_0x2e5090; // 0x2e53f4 - g_ps2RecompiledFunctionTable[496901] = njCollisionCheckBC2_0x2e5090; // 0x2e541c - g_ps2RecompiledFunctionTable[496924] = njCollisionCheckBC2_0x2e5090; // 0x2e5478 - g_ps2RecompiledFunctionTable[496934] = njCollisionCheckBC2_0x2e5090; // 0x2e54a0 - g_ps2RecompiledFunctionTable[496957] = njCollisionCheckBC2_0x2e5090; // 0x2e54fc - g_ps2RecompiledFunctionTable[496967] = njCollisionCheckBC2_0x2e5090; // 0x2e5524 - g_ps2RecompiledFunctionTable[496990] = njCollisionCheckBC2_0x2e5090; // 0x2e5580 - g_ps2RecompiledFunctionTable[497000] = njCollisionCheckBC2_0x2e5090; // 0x2e55a8 - g_ps2RecompiledFunctionTable[497023] = njCollisionCheckBC2_0x2e5090; // 0x2e5604 - g_ps2RecompiledFunctionTable[497033] = njCollisionCheckBC2_0x2e5090; // 0x2e562c - g_ps2RecompiledFunctionTable[497056] = njCollisionCheckBC2_0x2e5090; // 0x2e5688 - g_ps2RecompiledFunctionTable[497066] = njCollisionCheckBC2_0x2e5090; // 0x2e56b0 - g_ps2RecompiledFunctionTable[497089] = njCollisionCheckBC2_0x2e5090; // 0x2e570c - g_ps2RecompiledFunctionTable[497099] = njCollisionCheckBC2_0x2e5090; // 0x2e5734 - g_ps2RecompiledFunctionTable[497122] = njCollisionCheckBC2_0x2e5090; // 0x2e5790 - g_ps2RecompiledFunctionTable[497132] = njCollisionCheckBC2_0x2e5090; // 0x2e57b8 - g_ps2RecompiledFunctionTable[497155] = njCollisionCheckBC2_0x2e5090; // 0x2e5814 - g_ps2RecompiledFunctionTable[497165] = njCollisionCheckBC2_0x2e5090; // 0x2e583c - g_ps2RecompiledFunctionTable[497188] = njCollisionCheckBC2_0x2e5090; // 0x2e5898 - g_ps2RecompiledFunctionTable[497198] = njCollisionCheckBC2_0x2e5090; // 0x2e58c0 - g_ps2RecompiledFunctionTable[497221] = njCollisionCheckBC2_0x2e5090; // 0x2e591c - g_ps2RecompiledFunctionTable[497231] = njCollisionCheckBC2_0x2e5090; // 0x2e5944 - g_ps2RecompiledFunctionTable[497254] = njCollisionCheckBC2_0x2e5090; // 0x2e59a0 - g_ps2RecompiledFunctionTable[497264] = njCollisionCheckBC2_0x2e5090; // 0x2e59c8 - g_ps2RecompiledFunctionTable[497282] = njCollisionCheckBC2_0x2e5090; // 0x2e5a10 - g_ps2RecompiledFunctionTable[497305] = njCollisionCheckBC2_0x2e5090; // 0x2e5a6c - g_ps2RecompiledFunctionTable[497334] = njCheckPlane4IncludePoint_0x2e5ae0; // 0x2e5ae0 - g_ps2RecompiledFunctionTable[497377] = njCheckPlane4IncludePoint_0x2e5ae0; // 0x2e5b8c - g_ps2RecompiledFunctionTable[497401] = njCheckPlane4IncludePoint_0x2e5ae0; // 0x2e5bec - g_ps2RecompiledFunctionTable[497425] = njCheckPlane4IncludePoint_0x2e5ae0; // 0x2e5c4c - g_ps2RecompiledFunctionTable[497449] = njCheckPlane4IncludePoint_0x2e5ae0; // 0x2e5cac - g_ps2RecompiledFunctionTable[497519] = njCheckPlane4IncludePoint_0x2e5ae0; // 0x2e5dc4 - g_ps2RecompiledFunctionTable[497522] = njCheckPlane4IncludePoint_0x2e5ae0; // 0x2e5dd0 - g_ps2RecompiledFunctionTable[497525] = njCheckPlane4IncludePoint_0x2e5ae0; // 0x2e5ddc - g_ps2RecompiledFunctionTable[497528] = njCheckPlane4IncludePoint_0x2e5ae0; // 0x2e5de8 - g_ps2RecompiledFunctionTable[497558] = _d_ulltod_0x2e5e60; // 0x2e5e60 - g_ps2RecompiledFunctionTable[497563] = _d_ulltod_0x2e5e60; // 0x2e5e74 - g_ps2RecompiledFunctionTable[497569] = _d_ulltod_0x2e5e60; // 0x2e5e8c - g_ps2RecompiledFunctionTable[497572] = _d_ulltod_0x2e5e60; // 0x2e5e98 - g_ps2RecompiledFunctionTable[497578] = _d_utod_0x2e5eb0; // 0x2e5eb0 - g_ps2RecompiledFunctionTable[497582] = _dpfne_0x2e5ec0; // 0x2e5ec0 - g_ps2RecompiledFunctionTable[497586] = _dpfne_0x2e5ec0; // 0x2e5ed0 - g_ps2RecompiledFunctionTable[497590] = _dpflt_0x2e5ee0; // 0x2e5ee0 - g_ps2RecompiledFunctionTable[497594] = _dpflt_0x2e5ee0; // 0x2e5ef0 - g_ps2RecompiledFunctionTable[497598] = _dpfle_0x2e5f00; // 0x2e5f00 - g_ps2RecompiledFunctionTable[497602] = _dpfle_0x2e5f00; // 0x2e5f10 - g_ps2RecompiledFunctionTable[497610] = _dpfgt_0x2e5f30; // 0x2e5f30 - g_ps2RecompiledFunctionTable[497614] = _dpfgt_0x2e5f30; // 0x2e5f40 - g_ps2RecompiledFunctionTable[497618] = ClutCopy_0x2e5f50; // 0x2e5f50 - g_ps2RecompiledFunctionTable[497621] = ClutCopy_0x2e5f50; // 0x2e5f5c - g_ps2RecompiledFunctionTable[497631] = ClutCopy_0x2e5f50; // 0x2e5f84 - g_ps2RecompiledFunctionTable[497642] = ClutCopy256_0x2e5fb0; // 0x2e5fb0 - g_ps2RecompiledFunctionTable[497643] = ClutCopy256_0x2e5fb0; // 0x2e5fb4 - g_ps2RecompiledFunctionTable[497646] = ClutCopy256_0x2e5fb0; // 0x2e5fc0 - g_ps2RecompiledFunctionTable[497656] = ClutCopy256_0x2e5fb0; // 0x2e5fe8 - g_ps2RecompiledFunctionTable[497666] = ClutCopy256_0x2e5fb0; // 0x2e6010 - g_ps2RecompiledFunctionTable[497676] = ClutCopy256_0x2e5fb0; // 0x2e6038 - g_ps2RecompiledFunctionTable[497690] = isVQ_0x2e6070; // 0x2e6070 - g_ps2RecompiledFunctionTable[497702] = bhSetMemPvpTexture_0x2e60a0; // 0x2e60a0 - g_ps2RecompiledFunctionTable[497723] = bhSetMemPvpTexture_0x2e60a0; // 0x2e60f4 - g_ps2RecompiledFunctionTable[497756] = bhSetMemPvpTexture_0x2e60a0; // 0x2e6178 - g_ps2RecompiledFunctionTable[497767] = bhSetMemPvpTexture_0x2e60a0; // 0x2e61a4 - g_ps2RecompiledFunctionTable[497778] = bhSetMemPvpTexture_0x2e60a0; // 0x2e61d0 - g_ps2RecompiledFunctionTable[497780] = bhSetMemPvpTexture_0x2e60a0; // 0x2e61d8 - g_ps2RecompiledFunctionTable[497804] = bhSetMemPvpTexture_0x2e60a0; // 0x2e6238 - g_ps2RecompiledFunctionTable[497811] = bhSetMemPvpTexture_0x2e60a0; // 0x2e6254 - g_ps2RecompiledFunctionTable[497817] = bhSetMemPvpTexture_0x2e60a0; // 0x2e626c - g_ps2RecompiledFunctionTable[497825] = bhSetMemPvpTexture_0x2e60a0; // 0x2e628c - g_ps2RecompiledFunctionTable[497850] = bhSetMemPvpTexture_0x2e60a0; // 0x2e62f0 - g_ps2RecompiledFunctionTable[497876] = bhSetMemPvpTexture_0x2e60a0; // 0x2e6358 - g_ps2RecompiledFunctionTable[497928] = bhSetMemPvpTexture_0x2e60a0; // 0x2e6428 - g_ps2RecompiledFunctionTable[497934] = bhSetMemPvpTexture_0x2e60a0; // 0x2e6440 - g_ps2RecompiledFunctionTable[497953] = bhSetMemPvpTexture_0x2e60a0; // 0x2e648c - g_ps2RecompiledFunctionTable[497959] = bhSetMemPvpTexture_0x2e60a0; // 0x2e64a4 - g_ps2RecompiledFunctionTable[497968] = bhSetMemPvpTexture_0x2e60a0; // 0x2e64c8 - g_ps2RecompiledFunctionTable[497974] = bhSetMemPvpTexture_0x2e60a0; // 0x2e64e0 - g_ps2RecompiledFunctionTable[497982] = bhSetMemPvpTexture_0x2e60a0; // 0x2e6500 - g_ps2RecompiledFunctionTable[498014] = bhReleaseMainTexture_0x2e6580; // 0x2e6580 - g_ps2RecompiledFunctionTable[498028] = bhReleaseMainTexture_0x2e6580; // 0x2e65b8 - g_ps2RecompiledFunctionTable[498031] = bhReleaseMainTexture_0x2e6580; // 0x2e65c4 - g_ps2RecompiledFunctionTable[498049] = bhReleaseMainTexture_0x2e6580; // 0x2e660c - g_ps2RecompiledFunctionTable[498058] = bhReleaseMainTexture_0x2e6580; // 0x2e6630 - g_ps2RecompiledFunctionTable[498080] = bhReleaseMainTexture_0x2e6580; // 0x2e6688 - g_ps2RecompiledFunctionTable[498093] = bhReleaseMainTexture_0x2e6580; // 0x2e66bc - g_ps2RecompiledFunctionTable[498109] = bhReleaseMainTexture_0x2e6580; // 0x2e66fc - g_ps2RecompiledFunctionTable[498122] = bhReleaseMainTexture_0x2e6580; // 0x2e6730 - g_ps2RecompiledFunctionTable[498164] = bhReleaseMainTexture_0x2e6580; // 0x2e67d8 - g_ps2RecompiledFunctionTable[498191] = bhReleaseMainTexture_0x2e6580; // 0x2e6844 - g_ps2RecompiledFunctionTable[498200] = bhReleaseMainTexture_0x2e6580; // 0x2e6868 - g_ps2RecompiledFunctionTable[498210] = Init_PS2_SAVE_TEX_0x2e6890; // 0x2e6890 - g_ps2RecompiledFunctionTable[498213] = Init_PS2_SAVE_TEX_0x2e6890; // 0x2e689c - g_ps2RecompiledFunctionTable[498222] = bhCopyTexmem2Mainmem_0x2e68c0; // 0x2e68c0 - g_ps2RecompiledFunctionTable[498228] = bhCopyTexmem2Mainmem_0x2e68c0; // 0x2e68d8 - g_ps2RecompiledFunctionTable[498231] = bhCopyTexmem2Mainmem_0x2e68c0; // 0x2e68e4 - g_ps2RecompiledFunctionTable[498238] = bhCopyTexmem2MainmemSub_0x2e6900; // 0x2e6900 - g_ps2RecompiledFunctionTable[498252] = bhCopyTexmem2MainmemSub_0x2e6900; // 0x2e6938 - g_ps2RecompiledFunctionTable[498259] = bhCopyTexmem2MainmemSub_0x2e6900; // 0x2e6954 - g_ps2RecompiledFunctionTable[498266] = bhCopyTexmem2MainmemSub_0x2e6900; // 0x2e6970 - g_ps2RecompiledFunctionTable[498279] = bhCopyTexmem2MainmemSub_0x2e6900; // 0x2e69a4 - g_ps2RecompiledFunctionTable[498306] = bhCopyMainmem2Texmem_0x2e6a10; // 0x2e6a10 - g_ps2RecompiledFunctionTable[498329] = bhCopyMainmem2Texmem_0x2e6a10; // 0x2e6a6c - g_ps2RecompiledFunctionTable[498333] = bhCopyMainmem2Texmem_0x2e6a10; // 0x2e6a7c - g_ps2RecompiledFunctionTable[498352] = bhCopyMainmem2Texmem_0x2e6a10; // 0x2e6ac8 - g_ps2RecompiledFunctionTable[498364] = bhCopyMainmem2Texmem_0x2e6a10; // 0x2e6af8 - g_ps2RecompiledFunctionTable[498370] = bhCopyMainmem2Texmem_0x2e6a10; // 0x2e6b10 - g_ps2RecompiledFunctionTable[498382] = bhCopyMainmem2Texmem_0x2e6a10; // 0x2e6b40 - g_ps2RecompiledFunctionTable[498386] = bhCopyMainmem2Texmem_0x2e6a10; // 0x2e6b50 - g_ps2RecompiledFunctionTable[498410] = bhPushAllTexture_0x2e6bb0; // 0x2e6bb0 - g_ps2RecompiledFunctionTable[498414] = bhPopAllTexture_0x2e6bc0; // 0x2e6bc0 - g_ps2RecompiledFunctionTable[498418] = bhGarbageTexture_0x2e6bd0; // 0x2e6bd0 - g_ps2RecompiledFunctionTable[498422] = Tim2CalcBufWidth_0x2e6be0; // 0x2e6be0 - g_ps2RecompiledFunctionTable[498478] = Set_GsTex_0x2e6cc0; // 0x2e6cc0 - g_ps2RecompiledFunctionTable[498541] = Set_GsTex_0x2e6cc0; // 0x2e6dbc - g_ps2RecompiledFunctionTable[498553] = Set_GsTex_0x2e6cc0; // 0x2e6dec - g_ps2RecompiledFunctionTable[498555] = Set_GsTex_0x2e6cc0; // 0x2e6df4 - g_ps2RecompiledFunctionTable[498569] = Set_GsTex_0x2e6cc0; // 0x2e6e2c - g_ps2RecompiledFunctionTable[498581] = Set_GsTex_0x2e6cc0; // 0x2e6e5c - g_ps2RecompiledFunctionTable[498583] = Set_GsTex_0x2e6cc0; // 0x2e6e64 - g_ps2RecompiledFunctionTable[498660] = Set_GsTex_0x2e6cc0; // 0x2e6f98 - g_ps2RecompiledFunctionTable[498678] = MakeRenderTexHeader_0x2e6fe0; // 0x2e6fe0 - g_ps2RecompiledFunctionTable[498689] = MakeRenderTexHeader_0x2e6fe0; // 0x2e700c - g_ps2RecompiledFunctionTable[498695] = MakeRenderTexHeader_0x2e6fe0; // 0x2e7024 - g_ps2RecompiledFunctionTable[498782] = StoreRenderTex_0x2e7180; // 0x2e7180 - g_ps2RecompiledFunctionTable[498789] = StoreRenderTex_0x2e7180; // 0x2e719c - g_ps2RecompiledFunctionTable[498793] = StoreRenderTex_0x2e7180; // 0x2e71ac - g_ps2RecompiledFunctionTable[498811] = StoreRenderTex_0x2e7180; // 0x2e71f4 - g_ps2RecompiledFunctionTable[498813] = StoreRenderTex_0x2e7180; // 0x2e71fc - g_ps2RecompiledFunctionTable[498816] = StoreRenderTex_0x2e7180; // 0x2e7208 - g_ps2RecompiledFunctionTable[498822] = StoreRenderTex_0x2e7180; // 0x2e7220 - g_ps2RecompiledFunctionTable[498830] = LoadToVram_0x2e7240; // 0x2e7240 - g_ps2RecompiledFunctionTable[498852] = LoadToVram_0x2e7240; // 0x2e7298 - g_ps2RecompiledFunctionTable[498854] = LoadToVram_0x2e7240; // 0x2e72a0 - g_ps2RecompiledFunctionTable[498926] = LoadToVram_0x2e7240; // 0x2e73c0 - g_ps2RecompiledFunctionTable[498929] = LoadToVram_0x2e7240; // 0x2e73cc - g_ps2RecompiledFunctionTable[498942] = UncAddr_0x2e7400; // 0x2e7400 - g_ps2RecompiledFunctionTable[498950] = Send_1024_Clut_data_0x2e7420; // 0x2e7420 - g_ps2RecompiledFunctionTable[498967] = Send_1024_Clut_data_0x2e7420; // 0x2e7464 - g_ps2RecompiledFunctionTable[498976] = Send_1024_Clut_data_0x2e7420; // 0x2e7488 - g_ps2RecompiledFunctionTable[498978] = Send_1024_Clut_data_0x2e7420; // 0x2e7490 - g_ps2RecompiledFunctionTable[499044] = Send_1024_Clut_data_0x2e7420; // 0x2e7598 - g_ps2RecompiledFunctionTable[499047] = Send_1024_Clut_data_0x2e7420; // 0x2e75a4 - g_ps2RecompiledFunctionTable[499066] = Send_Tim2_dataEx_0x2e75f0; // 0x2e75f0 - g_ps2RecompiledFunctionTable[499084] = Send_Tim2_dataEx_0x2e75f0; // 0x2e7638 - g_ps2RecompiledFunctionTable[499089] = Send_Tim2_dataEx_0x2e75f0; // 0x2e764c - g_ps2RecompiledFunctionTable[499115] = Send_Tim2_dataEx_0x2e75f0; // 0x2e76b4 - g_ps2RecompiledFunctionTable[499119] = Send_Tim2_dataEx_0x2e75f0; // 0x2e76c4 - g_ps2RecompiledFunctionTable[499124] = Send_Tim2_dataEx_0x2e75f0; // 0x2e76d8 - g_ps2RecompiledFunctionTable[499128] = Send_Tim2_dataEx_0x2e75f0; // 0x2e76e8 - g_ps2RecompiledFunctionTable[499138] = Clut_Load_Func_0x2e7710; // 0x2e7710 - g_ps2RecompiledFunctionTable[499166] = Clut_Load_Func_0x2e7710; // 0x2e7780 - g_ps2RecompiledFunctionTable[499180] = Clut_Load_Func_0x2e7710; // 0x2e77b8 - g_ps2RecompiledFunctionTable[499202] = P32_Image_Load_0x2e7810; // 0x2e7810 - g_ps2RecompiledFunctionTable[499227] = P32_Image_Load_0x2e7810; // 0x2e7874 - g_ps2RecompiledFunctionTable[499234] = Tim2_Image_Load_0x2e7890; // 0x2e7890 - g_ps2RecompiledFunctionTable[499299] = Tim2_Image_Load_0x2e7890; // 0x2e7994 - g_ps2RecompiledFunctionTable[499321] = Tim2_Image_Load_0x2e7890; // 0x2e79ec - g_ps2RecompiledFunctionTable[499337] = Tim2_Image_Load_0x2e7890; // 0x2e7a2c - g_ps2RecompiledFunctionTable[499350] = Ps2PxlconvCheck_0x2e7a60; // 0x2e7a60 - g_ps2RecompiledFunctionTable[499381] = Ps2PxlconvCheck_0x2e7a60; // 0x2e7adc - g_ps2RecompiledFunctionTable[499386] = SyncPath_0x2e7af0; // 0x2e7af0 - g_ps2RecompiledFunctionTable[499393] = SyncPath_0x2e7af0; // 0x2e7b0c - g_ps2RecompiledFunctionTable[499411] = SyncPath_0x2e7af0; // 0x2e7b54 - g_ps2RecompiledFunctionTable[499427] = SyncPath_0x2e7af0; // 0x2e7b94 - g_ps2RecompiledFunctionTable[499434] = SyncPath_0x2e7af0; // 0x2e7bb0 - g_ps2RecompiledFunctionTable[499443] = SyncPath_0x2e7af0; // 0x2e7bd4 - g_ps2RecompiledFunctionTable[499454] = D2_SyncTag_0x2e7c00; // 0x2e7c00 - g_ps2RecompiledFunctionTable[499466] = D2_SyncTag_0x2e7c00; // 0x2e7c30 - g_ps2RecompiledFunctionTable[499482] = loadImage_0x2e7c70; // 0x2e7c70 - g_ps2RecompiledFunctionTable[499484] = loadImage_0x2e7c70; // 0x2e7c78 - g_ps2RecompiledFunctionTable[499506] = ClearVram_0x2e7cd0; // 0x2e7cd0 - g_ps2RecompiledFunctionTable[499514] = ClearVram_0x2e7cd0; // 0x2e7cf0 - g_ps2RecompiledFunctionTable[499527] = ClearVram_0x2e7cd0; // 0x2e7d24 - g_ps2RecompiledFunctionTable[499536] = ClearVram_0x2e7cd0; // 0x2e7d48 - g_ps2RecompiledFunctionTable[499538] = ClearVram_0x2e7cd0; // 0x2e7d50 - g_ps2RecompiledFunctionTable[499541] = ClearVram_0x2e7cd0; // 0x2e7d5c - g_ps2RecompiledFunctionTable[499544] = ClearVram_0x2e7cd0; // 0x2e7d68 - g_ps2RecompiledFunctionTable[499558] = bhChangeBackColor_0x2e7da0; // 0x2e7da0 - g_ps2RecompiledFunctionTable[499584] = bhChangeBackColor_0x2e7da0; // 0x2e7e08 - g_ps2RecompiledFunctionTable[499663] = bhChangeBackColor_0x2e7da0; // 0x2e7f44 - g_ps2RecompiledFunctionTable[499666] = bhChangeBackColorEvt_0x2e7f50; // 0x2e7f50 - g_ps2RecompiledFunctionTable[499692] = bhChangeBackColorEvt_0x2e7f50; // 0x2e7fb8 - g_ps2RecompiledFunctionTable[499748] = bhChangeBackColorEvt_0x2e7f50; // 0x2e8098 - g_ps2RecompiledFunctionTable[499754] = bhEff085_0x2e80b0; // 0x2e80b0 - g_ps2RecompiledFunctionTable[499850] = bhEff145_0x2e8230; // 0x2e8230 - g_ps2RecompiledFunctionTable[499892] = bhEff145_0x2e8230; // 0x2e82d8 - g_ps2RecompiledFunctionTable[499898] = bhEff146_Init_0x2e82f0; // 0x2e82f0 - g_ps2RecompiledFunctionTable[499957] = bhEff146_Init_0x2e82f0; // 0x2e83dc - g_ps2RecompiledFunctionTable[499960] = bhEff146_Init_0x2e82f0; // 0x2e83e8 - g_ps2RecompiledFunctionTable[499968] = bhEff146_Init_0x2e82f0; // 0x2e8408 - g_ps2RecompiledFunctionTable[499977] = bhEff146_Init_0x2e82f0; // 0x2e842c - g_ps2RecompiledFunctionTable[499988] = bhEff146_Init_0x2e82f0; // 0x2e8458 - g_ps2RecompiledFunctionTable[499993] = bhEff146_Init_0x2e82f0; // 0x2e846c - g_ps2RecompiledFunctionTable[500006] = bhEff146_Init_0x2e82f0; // 0x2e84a0 - g_ps2RecompiledFunctionTable[500011] = bhEff146_Init_0x2e82f0; // 0x2e84b4 - g_ps2RecompiledFunctionTable[500016] = bhEff146_Init_0x2e82f0; // 0x2e84c8 - g_ps2RecompiledFunctionTable[500021] = bhEff146_Init_0x2e82f0; // 0x2e84dc - g_ps2RecompiledFunctionTable[500042] = bhEff_Sub146_0x2e8530; // 0x2e8530 - g_ps2RecompiledFunctionTable[500190] = bhEff147_0x2e8780; // 0x2e8780 - g_ps2RecompiledFunctionTable[500222] = bhEff147_0x2e8780; // 0x2e8800 - g_ps2RecompiledFunctionTable[500227] = bhEff147_0x2e8780; // 0x2e8814 - g_ps2RecompiledFunctionTable[500262] = bhEff148_0x2e88a0; // 0x2e88a0 - g_ps2RecompiledFunctionTable[500317] = bhEff148_0x2e88a0; // 0x2e897c - g_ps2RecompiledFunctionTable[500359] = bhEff148_0x2e88a0; // 0x2e8a24 - g_ps2RecompiledFunctionTable[500363] = bhEff148_0x2e88a0; // 0x2e8a34 - g_ps2RecompiledFunctionTable[500426] = bhEff149_0x2e8b30; // 0x2e8b30 - g_ps2RecompiledFunctionTable[500427] = bhEff149_0x2e8b30; // 0x2e8b34 - g_ps2RecompiledFunctionTable[500428] = bhEff149_0x2e8b30; // 0x2e8b38 - g_ps2RecompiledFunctionTable[500429] = bhEff149_0x2e8b30; // 0x2e8b3c - g_ps2RecompiledFunctionTable[500430] = bhEff149_0x2e8b30; // 0x2e8b40 - g_ps2RecompiledFunctionTable[500431] = bhEff149_0x2e8b30; // 0x2e8b44 - g_ps2RecompiledFunctionTable[500432] = bhEff149_0x2e8b30; // 0x2e8b48 - g_ps2RecompiledFunctionTable[500433] = bhEff149_0x2e8b30; // 0x2e8b4c - g_ps2RecompiledFunctionTable[500434] = bhEff149_0x2e8b30; // 0x2e8b50 - g_ps2RecompiledFunctionTable[500435] = bhEff149_0x2e8b30; // 0x2e8b54 - g_ps2RecompiledFunctionTable[500436] = bhEff149_0x2e8b30; // 0x2e8b58 - g_ps2RecompiledFunctionTable[500437] = bhEff149_0x2e8b30; // 0x2e8b5c - g_ps2RecompiledFunctionTable[500438] = bhEff149_0x2e8b30; // 0x2e8b60 - g_ps2RecompiledFunctionTable[500439] = bhEff149_0x2e8b30; // 0x2e8b64 - g_ps2RecompiledFunctionTable[500440] = bhEff149_0x2e8b30; // 0x2e8b68 - g_ps2RecompiledFunctionTable[500441] = bhEff149_0x2e8b30; // 0x2e8b6c - g_ps2RecompiledFunctionTable[500442] = bhEff149_0x2e8b30; // 0x2e8b70 - g_ps2RecompiledFunctionTable[500443] = bhEff149_0x2e8b30; // 0x2e8b74 - g_ps2RecompiledFunctionTable[500444] = bhEff149_0x2e8b30; // 0x2e8b78 - g_ps2RecompiledFunctionTable[500445] = bhEff149_0x2e8b30; // 0x2e8b7c - g_ps2RecompiledFunctionTable[500446] = bhEff149_0x2e8b30; // 0x2e8b80 - g_ps2RecompiledFunctionTable[500447] = bhEff149_0x2e8b30; // 0x2e8b84 - g_ps2RecompiledFunctionTable[500448] = bhEff149_0x2e8b30; // 0x2e8b88 - g_ps2RecompiledFunctionTable[500449] = bhEff149_0x2e8b30; // 0x2e8b8c - g_ps2RecompiledFunctionTable[500450] = bhEff149_0x2e8b30; // 0x2e8b90 - g_ps2RecompiledFunctionTable[500451] = bhEff149_0x2e8b30; // 0x2e8b94 - g_ps2RecompiledFunctionTable[500452] = bhEff149_0x2e8b30; // 0x2e8b98 - g_ps2RecompiledFunctionTable[500453] = bhEff149_0x2e8b30; // 0x2e8b9c - g_ps2RecompiledFunctionTable[500454] = bhEff149_0x2e8b30; // 0x2e8ba0 - g_ps2RecompiledFunctionTable[500455] = bhEff149_0x2e8b30; // 0x2e8ba4 - g_ps2RecompiledFunctionTable[500456] = bhEff149_0x2e8b30; // 0x2e8ba8 - g_ps2RecompiledFunctionTable[500457] = bhEff149_0x2e8b30; // 0x2e8bac - g_ps2RecompiledFunctionTable[500458] = bhEff149_0x2e8b30; // 0x2e8bb0 - g_ps2RecompiledFunctionTable[500459] = bhEff149_0x2e8b30; // 0x2e8bb4 - g_ps2RecompiledFunctionTable[500460] = bhEff149_0x2e8b30; // 0x2e8bb8 - g_ps2RecompiledFunctionTable[500461] = bhEff149_0x2e8b30; // 0x2e8bbc - g_ps2RecompiledFunctionTable[500462] = bhEff149_0x2e8b30; // 0x2e8bc0 - g_ps2RecompiledFunctionTable[500463] = bhEff149_0x2e8b30; // 0x2e8bc4 - g_ps2RecompiledFunctionTable[500464] = bhEff149_0x2e8b30; // 0x2e8bc8 - g_ps2RecompiledFunctionTable[500465] = bhEff149_0x2e8b30; // 0x2e8bcc - g_ps2RecompiledFunctionTable[500466] = bhEff149_0x2e8b30; // 0x2e8bd0 - g_ps2RecompiledFunctionTable[500467] = bhEff149_0x2e8b30; // 0x2e8bd4 - g_ps2RecompiledFunctionTable[500468] = bhEff149_0x2e8b30; // 0x2e8bd8 - g_ps2RecompiledFunctionTable[500469] = bhEff149_0x2e8b30; // 0x2e8bdc - g_ps2RecompiledFunctionTable[500470] = bhEff149_0x2e8b30; // 0x2e8be0 - g_ps2RecompiledFunctionTable[500471] = bhEff149_0x2e8b30; // 0x2e8be4 - g_ps2RecompiledFunctionTable[500472] = bhEff149_0x2e8b30; // 0x2e8be8 - g_ps2RecompiledFunctionTable[500473] = bhEff149_0x2e8b30; // 0x2e8bec - g_ps2RecompiledFunctionTable[500474] = bhEff149_0x2e8b30; // 0x2e8bf0 - g_ps2RecompiledFunctionTable[500475] = bhEff149_0x2e8b30; // 0x2e8bf4 - g_ps2RecompiledFunctionTable[500476] = bhEff149_0x2e8b30; // 0x2e8bf8 - g_ps2RecompiledFunctionTable[500477] = bhEff149_0x2e8b30; // 0x2e8bfc - g_ps2RecompiledFunctionTable[500478] = bhEff149_0x2e8b30; // 0x2e8c00 - g_ps2RecompiledFunctionTable[500479] = bhEff149_0x2e8b30; // 0x2e8c04 - g_ps2RecompiledFunctionTable[500480] = bhEff149_0x2e8b30; // 0x2e8c08 - g_ps2RecompiledFunctionTable[500481] = bhEff149_0x2e8b30; // 0x2e8c0c - g_ps2RecompiledFunctionTable[500482] = bhEff149_0x2e8b30; // 0x2e8c10 - g_ps2RecompiledFunctionTable[500483] = bhEff149_0x2e8b30; // 0x2e8c14 - g_ps2RecompiledFunctionTable[500484] = bhEff149_0x2e8b30; // 0x2e8c18 - g_ps2RecompiledFunctionTable[500485] = bhEff149_0x2e8b30; // 0x2e8c1c - g_ps2RecompiledFunctionTable[500486] = bhEff149_0x2e8b30; // 0x2e8c20 - g_ps2RecompiledFunctionTable[500487] = bhEff149_0x2e8b30; // 0x2e8c24 - g_ps2RecompiledFunctionTable[500488] = bhEff149_0x2e8b30; // 0x2e8c28 - g_ps2RecompiledFunctionTable[500489] = bhEff149_0x2e8b30; // 0x2e8c2c - g_ps2RecompiledFunctionTable[500490] = bhEff149_0x2e8b30; // 0x2e8c30 - g_ps2RecompiledFunctionTable[500491] = bhEff149_0x2e8b30; // 0x2e8c34 - g_ps2RecompiledFunctionTable[500492] = bhEff149_0x2e8b30; // 0x2e8c38 - g_ps2RecompiledFunctionTable[500493] = bhEff149_0x2e8b30; // 0x2e8c3c - g_ps2RecompiledFunctionTable[500494] = bhEff149_0x2e8b30; // 0x2e8c40 - g_ps2RecompiledFunctionTable[500495] = bhEff149_0x2e8b30; // 0x2e8c44 - g_ps2RecompiledFunctionTable[500496] = bhEff149_0x2e8b30; // 0x2e8c48 - g_ps2RecompiledFunctionTable[500497] = bhEff149_0x2e8b30; // 0x2e8c4c - g_ps2RecompiledFunctionTable[500498] = bhEff149_0x2e8b30; // 0x2e8c50 - g_ps2RecompiledFunctionTable[500499] = bhEff149_0x2e8b30; // 0x2e8c54 - g_ps2RecompiledFunctionTable[500500] = bhEff149_0x2e8b30; // 0x2e8c58 - g_ps2RecompiledFunctionTable[500501] = bhEff149_0x2e8b30; // 0x2e8c5c - g_ps2RecompiledFunctionTable[500502] = bhEff149_0x2e8b30; // 0x2e8c60 - g_ps2RecompiledFunctionTable[500503] = bhEff149_0x2e8b30; // 0x2e8c64 - g_ps2RecompiledFunctionTable[500504] = bhEff149_0x2e8b30; // 0x2e8c68 - g_ps2RecompiledFunctionTable[500505] = bhEff149_0x2e8b30; // 0x2e8c6c - g_ps2RecompiledFunctionTable[500506] = bhEff149_0x2e8b30; // 0x2e8c70 - g_ps2RecompiledFunctionTable[500507] = bhEff149_0x2e8b30; // 0x2e8c74 - g_ps2RecompiledFunctionTable[500508] = bhEff149_0x2e8b30; // 0x2e8c78 - g_ps2RecompiledFunctionTable[500509] = bhEff149_0x2e8b30; // 0x2e8c7c - g_ps2RecompiledFunctionTable[500510] = bhEff149_0x2e8b30; // 0x2e8c80 - g_ps2RecompiledFunctionTable[500511] = bhEff149_0x2e8b30; // 0x2e8c84 - g_ps2RecompiledFunctionTable[500512] = bhEff149_0x2e8b30; // 0x2e8c88 - g_ps2RecompiledFunctionTable[500513] = bhEff149_0x2e8b30; // 0x2e8c8c - g_ps2RecompiledFunctionTable[500514] = bhEff149_0x2e8b30; // 0x2e8c90 - g_ps2RecompiledFunctionTable[500515] = bhEff149_0x2e8b30; // 0x2e8c94 - g_ps2RecompiledFunctionTable[500516] = bhEff149_0x2e8b30; // 0x2e8c98 - g_ps2RecompiledFunctionTable[500517] = bhEff149_0x2e8b30; // 0x2e8c9c - g_ps2RecompiledFunctionTable[500518] = bhEff149_0x2e8b30; // 0x2e8ca0 - g_ps2RecompiledFunctionTable[500519] = bhEff149_0x2e8b30; // 0x2e8ca4 - g_ps2RecompiledFunctionTable[500520] = bhEff149_0x2e8b30; // 0x2e8ca8 - g_ps2RecompiledFunctionTable[500521] = bhEff149_0x2e8b30; // 0x2e8cac - g_ps2RecompiledFunctionTable[500522] = bhEff149_0x2e8b30; // 0x2e8cb0 - g_ps2RecompiledFunctionTable[500523] = bhEff149_0x2e8b30; // 0x2e8cb4 - g_ps2RecompiledFunctionTable[500524] = bhEff149_0x2e8b30; // 0x2e8cb8 - g_ps2RecompiledFunctionTable[500525] = bhEff149_0x2e8b30; // 0x2e8cbc - g_ps2RecompiledFunctionTable[500526] = bhEff149_0x2e8b30; // 0x2e8cc0 - g_ps2RecompiledFunctionTable[500527] = bhEff149_0x2e8b30; // 0x2e8cc4 - g_ps2RecompiledFunctionTable[500528] = bhEff149_0x2e8b30; // 0x2e8cc8 - g_ps2RecompiledFunctionTable[500529] = bhEff149_0x2e8b30; // 0x2e8ccc - g_ps2RecompiledFunctionTable[500530] = bhEff149_0x2e8b30; // 0x2e8cd0 - g_ps2RecompiledFunctionTable[500531] = bhEff149_0x2e8b30; // 0x2e8cd4 - g_ps2RecompiledFunctionTable[500532] = bhEff149_0x2e8b30; // 0x2e8cd8 - g_ps2RecompiledFunctionTable[500533] = bhEff149_0x2e8b30; // 0x2e8cdc - g_ps2RecompiledFunctionTable[500534] = bhEff149_0x2e8b30; // 0x2e8ce0 - g_ps2RecompiledFunctionTable[500535] = bhEff149_0x2e8b30; // 0x2e8ce4 - g_ps2RecompiledFunctionTable[500536] = bhEff149_0x2e8b30; // 0x2e8ce8 - g_ps2RecompiledFunctionTable[500537] = bhEff149_0x2e8b30; // 0x2e8cec - g_ps2RecompiledFunctionTable[500538] = bhEff149_0x2e8b30; // 0x2e8cf0 - g_ps2RecompiledFunctionTable[500539] = bhEff149_0x2e8b30; // 0x2e8cf4 - g_ps2RecompiledFunctionTable[500540] = bhEff149_0x2e8b30; // 0x2e8cf8 - g_ps2RecompiledFunctionTable[500541] = bhEff149_0x2e8b30; // 0x2e8cfc - g_ps2RecompiledFunctionTable[500542] = bhEff149_0x2e8b30; // 0x2e8d00 - g_ps2RecompiledFunctionTable[500543] = bhEff149_0x2e8b30; // 0x2e8d04 - g_ps2RecompiledFunctionTable[500544] = bhEff149_0x2e8b30; // 0x2e8d08 - g_ps2RecompiledFunctionTable[500545] = bhEff149_0x2e8b30; // 0x2e8d0c - g_ps2RecompiledFunctionTable[500546] = bhEff149_0x2e8b30; // 0x2e8d10 - g_ps2RecompiledFunctionTable[500547] = bhEff149_0x2e8b30; // 0x2e8d14 - g_ps2RecompiledFunctionTable[500548] = bhEff149_0x2e8b30; // 0x2e8d18 - g_ps2RecompiledFunctionTable[500549] = bhEff149_0x2e8b30; // 0x2e8d1c - g_ps2RecompiledFunctionTable[500550] = bhEff149_0x2e8b30; // 0x2e8d20 - g_ps2RecompiledFunctionTable[500551] = bhEff149_0x2e8b30; // 0x2e8d24 - g_ps2RecompiledFunctionTable[500552] = bhEff149_0x2e8b30; // 0x2e8d28 - g_ps2RecompiledFunctionTable[500553] = bhEff149_0x2e8b30; // 0x2e8d2c - g_ps2RecompiledFunctionTable[500554] = bhEff149_0x2e8b30; // 0x2e8d30 - g_ps2RecompiledFunctionTable[500555] = bhEff149_0x2e8b30; // 0x2e8d34 - g_ps2RecompiledFunctionTable[500556] = bhEff149_0x2e8b30; // 0x2e8d38 - g_ps2RecompiledFunctionTable[500557] = bhEff149_0x2e8b30; // 0x2e8d3c - g_ps2RecompiledFunctionTable[500558] = bhEff149_0x2e8b30; // 0x2e8d40 - g_ps2RecompiledFunctionTable[500559] = bhEff149_0x2e8b30; // 0x2e8d44 - g_ps2RecompiledFunctionTable[500560] = bhEff149_0x2e8b30; // 0x2e8d48 - g_ps2RecompiledFunctionTable[500561] = bhEff149_0x2e8b30; // 0x2e8d4c - g_ps2RecompiledFunctionTable[500562] = bhEff149_0x2e8b30; // 0x2e8d50 - g_ps2RecompiledFunctionTable[500563] = bhEff149_0x2e8b30; // 0x2e8d54 - g_ps2RecompiledFunctionTable[500564] = bhEff149_0x2e8b30; // 0x2e8d58 - g_ps2RecompiledFunctionTable[500565] = bhEff149_0x2e8b30; // 0x2e8d5c - g_ps2RecompiledFunctionTable[500566] = bhEff149_0x2e8b30; // 0x2e8d60 - g_ps2RecompiledFunctionTable[500567] = bhEff149_0x2e8b30; // 0x2e8d64 - g_ps2RecompiledFunctionTable[500568] = bhEff149_0x2e8b30; // 0x2e8d68 - g_ps2RecompiledFunctionTable[500569] = bhEff149_0x2e8b30; // 0x2e8d6c - g_ps2RecompiledFunctionTable[500570] = bhEff149_0x2e8b30; // 0x2e8d70 - g_ps2RecompiledFunctionTable[500571] = bhEff149_0x2e8b30; // 0x2e8d74 - g_ps2RecompiledFunctionTable[500572] = bhEff149_0x2e8b30; // 0x2e8d78 - g_ps2RecompiledFunctionTable[500573] = bhEff149_0x2e8b30; // 0x2e8d7c - g_ps2RecompiledFunctionTable[500574] = bhEff149_0x2e8b30; // 0x2e8d80 - g_ps2RecompiledFunctionTable[500575] = bhEff149_0x2e8b30; // 0x2e8d84 - g_ps2RecompiledFunctionTable[500576] = bhEff149_0x2e8b30; // 0x2e8d88 - g_ps2RecompiledFunctionTable[500577] = bhEff149_0x2e8b30; // 0x2e8d8c - g_ps2RecompiledFunctionTable[500578] = bhEff149_0x2e8b30; // 0x2e8d90 - g_ps2RecompiledFunctionTable[500579] = bhEff149_0x2e8b30; // 0x2e8d94 - g_ps2RecompiledFunctionTable[500580] = bhEff149_0x2e8b30; // 0x2e8d98 - g_ps2RecompiledFunctionTable[500581] = bhEff149_0x2e8b30; // 0x2e8d9c - g_ps2RecompiledFunctionTable[500582] = bhEff149_0x2e8b30; // 0x2e8da0 - g_ps2RecompiledFunctionTable[500583] = bhEff149_0x2e8b30; // 0x2e8da4 - g_ps2RecompiledFunctionTable[500584] = bhEff149_0x2e8b30; // 0x2e8da8 - g_ps2RecompiledFunctionTable[500585] = bhEff149_0x2e8b30; // 0x2e8dac - g_ps2RecompiledFunctionTable[500586] = bhEff149_0x2e8b30; // 0x2e8db0 - g_ps2RecompiledFunctionTable[500587] = bhEff149_0x2e8b30; // 0x2e8db4 - g_ps2RecompiledFunctionTable[500588] = bhEff149_0x2e8b30; // 0x2e8db8 - g_ps2RecompiledFunctionTable[500589] = bhEff149_0x2e8b30; // 0x2e8dbc - g_ps2RecompiledFunctionTable[500590] = bhEff149_0x2e8b30; // 0x2e8dc0 - g_ps2RecompiledFunctionTable[500591] = bhEff149_0x2e8b30; // 0x2e8dc4 - g_ps2RecompiledFunctionTable[500592] = bhEff149_0x2e8b30; // 0x2e8dc8 - g_ps2RecompiledFunctionTable[500593] = bhEff149_0x2e8b30; // 0x2e8dcc - g_ps2RecompiledFunctionTable[500594] = bhEff149_0x2e8b30; // 0x2e8dd0 - g_ps2RecompiledFunctionTable[500595] = bhEff149_0x2e8b30; // 0x2e8dd4 - g_ps2RecompiledFunctionTable[500596] = bhEff149_0x2e8b30; // 0x2e8dd8 - g_ps2RecompiledFunctionTable[500597] = bhEff149_0x2e8b30; // 0x2e8ddc - g_ps2RecompiledFunctionTable[500598] = bhEff149_0x2e8b30; // 0x2e8de0 - g_ps2RecompiledFunctionTable[500599] = bhEff149_0x2e8b30; // 0x2e8de4 - g_ps2RecompiledFunctionTable[500600] = bhEff149_0x2e8b30; // 0x2e8de8 - g_ps2RecompiledFunctionTable[500601] = bhEff149_0x2e8b30; // 0x2e8dec - g_ps2RecompiledFunctionTable[500602] = bhEff149_0x2e8b30; // 0x2e8df0 - g_ps2RecompiledFunctionTable[500603] = bhEff149_0x2e8b30; // 0x2e8df4 - g_ps2RecompiledFunctionTable[500604] = bhEff149_0x2e8b30; // 0x2e8df8 - g_ps2RecompiledFunctionTable[500605] = bhEff149_0x2e8b30; // 0x2e8dfc - g_ps2RecompiledFunctionTable[500606] = bhEff149_0x2e8b30; // 0x2e8e00 - g_ps2RecompiledFunctionTable[500607] = bhEff149_0x2e8b30; // 0x2e8e04 - g_ps2RecompiledFunctionTable[500608] = bhEff149_0x2e8b30; // 0x2e8e08 - g_ps2RecompiledFunctionTable[500609] = bhEff149_0x2e8b30; // 0x2e8e0c - g_ps2RecompiledFunctionTable[500610] = bhEff149_0x2e8b30; // 0x2e8e10 - g_ps2RecompiledFunctionTable[500611] = bhEff149_0x2e8b30; // 0x2e8e14 - g_ps2RecompiledFunctionTable[500612] = bhEff149_0x2e8b30; // 0x2e8e18 - g_ps2RecompiledFunctionTable[500613] = bhEff149_0x2e8b30; // 0x2e8e1c - g_ps2RecompiledFunctionTable[500614] = bhEff149_0x2e8b30; // 0x2e8e20 - g_ps2RecompiledFunctionTable[500615] = bhEff149_0x2e8b30; // 0x2e8e24 - g_ps2RecompiledFunctionTable[500616] = bhEff149_0x2e8b30; // 0x2e8e28 - g_ps2RecompiledFunctionTable[500617] = bhEff149_0x2e8b30; // 0x2e8e2c - g_ps2RecompiledFunctionTable[500618] = bhEff149_0x2e8b30; // 0x2e8e30 - g_ps2RecompiledFunctionTable[500619] = bhEff149_0x2e8b30; // 0x2e8e34 - g_ps2RecompiledFunctionTable[500620] = bhEff149_0x2e8b30; // 0x2e8e38 - g_ps2RecompiledFunctionTable[500621] = bhEff149_0x2e8b30; // 0x2e8e3c - g_ps2RecompiledFunctionTable[500622] = bhEff149_0x2e8b30; // 0x2e8e40 - g_ps2RecompiledFunctionTable[500623] = bhEff149_0x2e8b30; // 0x2e8e44 - g_ps2RecompiledFunctionTable[500624] = bhEff149_0x2e8b30; // 0x2e8e48 - g_ps2RecompiledFunctionTable[500625] = bhEff149_0x2e8b30; // 0x2e8e4c - g_ps2RecompiledFunctionTable[500626] = bhEff149_0x2e8b30; // 0x2e8e50 - g_ps2RecompiledFunctionTable[500627] = bhEff149_0x2e8b30; // 0x2e8e54 - g_ps2RecompiledFunctionTable[500628] = bhEff149_0x2e8b30; // 0x2e8e58 - g_ps2RecompiledFunctionTable[500629] = bhEff149_0x2e8b30; // 0x2e8e5c - g_ps2RecompiledFunctionTable[500630] = bhEff149_0x2e8b30; // 0x2e8e60 - g_ps2RecompiledFunctionTable[500631] = bhEff149_0x2e8b30; // 0x2e8e64 - g_ps2RecompiledFunctionTable[500632] = bhEff149_0x2e8b30; // 0x2e8e68 - g_ps2RecompiledFunctionTable[500633] = bhEff149_0x2e8b30; // 0x2e8e6c - g_ps2RecompiledFunctionTable[500634] = bhEff149_0x2e8b30; // 0x2e8e70 - g_ps2RecompiledFunctionTable[500635] = bhEff149_0x2e8b30; // 0x2e8e74 - g_ps2RecompiledFunctionTable[500636] = bhEff149_0x2e8b30; // 0x2e8e78 - g_ps2RecompiledFunctionTable[500637] = bhEff149_0x2e8b30; // 0x2e8e7c - g_ps2RecompiledFunctionTable[500638] = bhEff149_0x2e8b30; // 0x2e8e80 - g_ps2RecompiledFunctionTable[500639] = bhEff149_0x2e8b30; // 0x2e8e84 - g_ps2RecompiledFunctionTable[500640] = bhEff149_0x2e8b30; // 0x2e8e88 - g_ps2RecompiledFunctionTable[500641] = bhEff149_0x2e8b30; // 0x2e8e8c - g_ps2RecompiledFunctionTable[500642] = bhEff149_0x2e8b30; // 0x2e8e90 - g_ps2RecompiledFunctionTable[500643] = bhEff149_0x2e8b30; // 0x2e8e94 - g_ps2RecompiledFunctionTable[500644] = bhEff149_0x2e8b30; // 0x2e8e98 - g_ps2RecompiledFunctionTable[500645] = bhEff149_0x2e8b30; // 0x2e8e9c - g_ps2RecompiledFunctionTable[500646] = bhEff149_0x2e8b30; // 0x2e8ea0 - g_ps2RecompiledFunctionTable[500647] = bhEff149_0x2e8b30; // 0x2e8ea4 - g_ps2RecompiledFunctionTable[500648] = bhEff149_0x2e8b30; // 0x2e8ea8 - g_ps2RecompiledFunctionTable[500649] = bhEff149_0x2e8b30; // 0x2e8eac - g_ps2RecompiledFunctionTable[500650] = bhEff149_0x2e8b30; // 0x2e8eb0 - g_ps2RecompiledFunctionTable[500651] = bhEff149_0x2e8b30; // 0x2e8eb4 - g_ps2RecompiledFunctionTable[500652] = bhEff149_0x2e8b30; // 0x2e8eb8 - g_ps2RecompiledFunctionTable[500653] = bhEff149_0x2e8b30; // 0x2e8ebc - g_ps2RecompiledFunctionTable[500654] = bhEff149_0x2e8b30; // 0x2e8ec0 - g_ps2RecompiledFunctionTable[500655] = bhEff149_0x2e8b30; // 0x2e8ec4 - g_ps2RecompiledFunctionTable[500656] = bhEff149_0x2e8b30; // 0x2e8ec8 - g_ps2RecompiledFunctionTable[500657] = bhEff149_0x2e8b30; // 0x2e8ecc - g_ps2RecompiledFunctionTable[500658] = bhEff149_0x2e8b30; // 0x2e8ed0 - g_ps2RecompiledFunctionTable[500659] = bhEff149_0x2e8b30; // 0x2e8ed4 - g_ps2RecompiledFunctionTable[500660] = bhEff149_0x2e8b30; // 0x2e8ed8 - g_ps2RecompiledFunctionTable[500661] = bhEff149_0x2e8b30; // 0x2e8edc - g_ps2RecompiledFunctionTable[500662] = bhEff149_0x2e8b30; // 0x2e8ee0 - g_ps2RecompiledFunctionTable[500663] = bhEff149_0x2e8b30; // 0x2e8ee4 - g_ps2RecompiledFunctionTable[500664] = bhEff149_0x2e8b30; // 0x2e8ee8 - g_ps2RecompiledFunctionTable[500665] = bhEff149_0x2e8b30; // 0x2e8eec - g_ps2RecompiledFunctionTable[500666] = bhEff149_0x2e8b30; // 0x2e8ef0 - g_ps2RecompiledFunctionTable[500667] = bhEff149_0x2e8b30; // 0x2e8ef4 - g_ps2RecompiledFunctionTable[500668] = bhEff149_0x2e8b30; // 0x2e8ef8 - g_ps2RecompiledFunctionTable[500669] = bhEff149_0x2e8b30; // 0x2e8efc - g_ps2RecompiledFunctionTable[500670] = bhEff149_0x2e8b30; // 0x2e8f00 - g_ps2RecompiledFunctionTable[500671] = bhEff149_0x2e8b30; // 0x2e8f04 - g_ps2RecompiledFunctionTable[500672] = bhEff149_0x2e8b30; // 0x2e8f08 - g_ps2RecompiledFunctionTable[500673] = bhEff149_0x2e8b30; // 0x2e8f0c - g_ps2RecompiledFunctionTable[500674] = bhEff149_0x2e8b30; // 0x2e8f10 - g_ps2RecompiledFunctionTable[500675] = bhEff149_0x2e8b30; // 0x2e8f14 - g_ps2RecompiledFunctionTable[500676] = bhEff149_0x2e8b30; // 0x2e8f18 - g_ps2RecompiledFunctionTable[500677] = bhEff149_0x2e8b30; // 0x2e8f1c - g_ps2RecompiledFunctionTable[500678] = bhEff149_0x2e8b30; // 0x2e8f20 - g_ps2RecompiledFunctionTable[500679] = bhEff149_0x2e8b30; // 0x2e8f24 - g_ps2RecompiledFunctionTable[500680] = bhEff149_0x2e8b30; // 0x2e8f28 - g_ps2RecompiledFunctionTable[500681] = bhEff149_0x2e8b30; // 0x2e8f2c - g_ps2RecompiledFunctionTable[500682] = bhEff149_0x2e8b30; // 0x2e8f30 - g_ps2RecompiledFunctionTable[500683] = bhEff149_0x2e8b30; // 0x2e8f34 - g_ps2RecompiledFunctionTable[500684] = bhEff149_0x2e8b30; // 0x2e8f38 - g_ps2RecompiledFunctionTable[500685] = bhEff149_0x2e8b30; // 0x2e8f3c - g_ps2RecompiledFunctionTable[500686] = bhEff149_0x2e8b30; // 0x2e8f40 - g_ps2RecompiledFunctionTable[500687] = bhEff149_0x2e8b30; // 0x2e8f44 - g_ps2RecompiledFunctionTable[500688] = bhEff149_0x2e8b30; // 0x2e8f48 - g_ps2RecompiledFunctionTable[500689] = bhEff149_0x2e8b30; // 0x2e8f4c - g_ps2RecompiledFunctionTable[500690] = bhEff149_0x2e8b30; // 0x2e8f50 - g_ps2RecompiledFunctionTable[500691] = bhEff149_0x2e8b30; // 0x2e8f54 - g_ps2RecompiledFunctionTable[500692] = bhEff149_0x2e8b30; // 0x2e8f58 - g_ps2RecompiledFunctionTable[500693] = bhEff149_0x2e8b30; // 0x2e8f5c - g_ps2RecompiledFunctionTable[500694] = bhEff149_0x2e8b30; // 0x2e8f60 - g_ps2RecompiledFunctionTable[500695] = bhEff149_0x2e8b30; // 0x2e8f64 - g_ps2RecompiledFunctionTable[500696] = bhEff149_0x2e8b30; // 0x2e8f68 - g_ps2RecompiledFunctionTable[500697] = bhEff149_0x2e8b30; // 0x2e8f6c - g_ps2RecompiledFunctionTable[500698] = bhEff149_0x2e8b30; // 0x2e8f70 - g_ps2RecompiledFunctionTable[500699] = bhEff149_0x2e8b30; // 0x2e8f74 - g_ps2RecompiledFunctionTable[500700] = bhEff149_0x2e8b30; // 0x2e8f78 - g_ps2RecompiledFunctionTable[500701] = bhEff149_0x2e8b30; // 0x2e8f7c - g_ps2RecompiledFunctionTable[500702] = bhEff149_0x2e8b30; // 0x2e8f80 - g_ps2RecompiledFunctionTable[500703] = bhEff149_0x2e8b30; // 0x2e8f84 - g_ps2RecompiledFunctionTable[500704] = bhEff149_0x2e8b30; // 0x2e8f88 - g_ps2RecompiledFunctionTable[500705] = bhEff149_0x2e8b30; // 0x2e8f8c - g_ps2RecompiledFunctionTable[500706] = bhEff149_0x2e8b30; // 0x2e8f90 - g_ps2RecompiledFunctionTable[500707] = bhEff149_0x2e8b30; // 0x2e8f94 - g_ps2RecompiledFunctionTable[500708] = bhEff149_0x2e8b30; // 0x2e8f98 - g_ps2RecompiledFunctionTable[500709] = bhEff149_0x2e8b30; // 0x2e8f9c - g_ps2RecompiledFunctionTable[500710] = bhEff149_0x2e8b30; // 0x2e8fa0 - g_ps2RecompiledFunctionTable[500711] = bhEff149_0x2e8b30; // 0x2e8fa4 - g_ps2RecompiledFunctionTable[500712] = bhEff149_0x2e8b30; // 0x2e8fa8 - g_ps2RecompiledFunctionTable[500713] = bhEff149_0x2e8b30; // 0x2e8fac - g_ps2RecompiledFunctionTable[500714] = bhEff149_0x2e8b30; // 0x2e8fb0 - g_ps2RecompiledFunctionTable[500715] = bhEff149_0x2e8b30; // 0x2e8fb4 - g_ps2RecompiledFunctionTable[500716] = bhEff149_0x2e8b30; // 0x2e8fb8 - g_ps2RecompiledFunctionTable[500717] = bhEff149_0x2e8b30; // 0x2e8fbc - g_ps2RecompiledFunctionTable[500718] = bhEff149_0x2e8b30; // 0x2e8fc0 - g_ps2RecompiledFunctionTable[500719] = bhEff149_0x2e8b30; // 0x2e8fc4 - g_ps2RecompiledFunctionTable[500720] = bhEff149_0x2e8b30; // 0x2e8fc8 - g_ps2RecompiledFunctionTable[500721] = bhEff149_0x2e8b30; // 0x2e8fcc - g_ps2RecompiledFunctionTable[500722] = bhEff149_0x2e8b30; // 0x2e8fd0 - g_ps2RecompiledFunctionTable[500723] = bhEff149_0x2e8b30; // 0x2e8fd4 - g_ps2RecompiledFunctionTable[500724] = bhEff149_0x2e8b30; // 0x2e8fd8 - g_ps2RecompiledFunctionTable[500725] = bhEff149_0x2e8b30; // 0x2e8fdc - g_ps2RecompiledFunctionTable[500726] = bhEff149_0x2e8b30; // 0x2e8fe0 - g_ps2RecompiledFunctionTable[500727] = bhEff149_0x2e8b30; // 0x2e8fe4 - g_ps2RecompiledFunctionTable[500728] = bhEff149_0x2e8b30; // 0x2e8fe8 - g_ps2RecompiledFunctionTable[500729] = bhEff149_0x2e8b30; // 0x2e8fec - g_ps2RecompiledFunctionTable[500730] = bhEff149_0x2e8b30; // 0x2e8ff0 - g_ps2RecompiledFunctionTable[500731] = bhEff149_0x2e8b30; // 0x2e8ff4 - g_ps2RecompiledFunctionTable[500732] = bhEff149_0x2e8b30; // 0x2e8ff8 - g_ps2RecompiledFunctionTable[500733] = bhEff149_0x2e8b30; // 0x2e8ffc - g_ps2RecompiledFunctionTable[500734] = bhEff149_0x2e8b30; // 0x2e9000 - g_ps2RecompiledFunctionTable[500735] = bhEff149_0x2e8b30; // 0x2e9004 - g_ps2RecompiledFunctionTable[500736] = bhEff149_0x2e8b30; // 0x2e9008 - g_ps2RecompiledFunctionTable[500737] = bhEff149_0x2e8b30; // 0x2e900c - g_ps2RecompiledFunctionTable[500738] = bhEff149_0x2e8b30; // 0x2e9010 - g_ps2RecompiledFunctionTable[500739] = bhEff149_0x2e8b30; // 0x2e9014 - g_ps2RecompiledFunctionTable[500740] = bhEff149_0x2e8b30; // 0x2e9018 - g_ps2RecompiledFunctionTable[500741] = bhEff149_0x2e8b30; // 0x2e901c - g_ps2RecompiledFunctionTable[500742] = bhEff149_0x2e8b30; // 0x2e9020 - g_ps2RecompiledFunctionTable[500743] = bhEff149_0x2e8b30; // 0x2e9024 - g_ps2RecompiledFunctionTable[500744] = bhEff149_0x2e8b30; // 0x2e9028 - g_ps2RecompiledFunctionTable[500745] = bhEff149_0x2e8b30; // 0x2e902c - g_ps2RecompiledFunctionTable[500746] = bhEff149_0x2e8b30; // 0x2e9030 - g_ps2RecompiledFunctionTable[500747] = bhEff149_0x2e8b30; // 0x2e9034 - g_ps2RecompiledFunctionTable[500748] = bhEff149_0x2e8b30; // 0x2e9038 - g_ps2RecompiledFunctionTable[500749] = bhEff149_0x2e8b30; // 0x2e903c - g_ps2RecompiledFunctionTable[500750] = bhEff149_0x2e8b30; // 0x2e9040 - g_ps2RecompiledFunctionTable[500751] = bhEff149_0x2e8b30; // 0x2e9044 - g_ps2RecompiledFunctionTable[500752] = bhEff149_0x2e8b30; // 0x2e9048 - g_ps2RecompiledFunctionTable[500753] = bhEff149_0x2e8b30; // 0x2e904c - g_ps2RecompiledFunctionTable[500754] = bhEff149_0x2e8b30; // 0x2e9050 - g_ps2RecompiledFunctionTable[500755] = bhEff149_0x2e8b30; // 0x2e9054 - g_ps2RecompiledFunctionTable[500756] = bhEff149_0x2e8b30; // 0x2e9058 - g_ps2RecompiledFunctionTable[500757] = bhEff149_0x2e8b30; // 0x2e905c - g_ps2RecompiledFunctionTable[500758] = bhEff149_0x2e8b30; // 0x2e9060 - g_ps2RecompiledFunctionTable[500759] = bhEff149_0x2e8b30; // 0x2e9064 - g_ps2RecompiledFunctionTable[500760] = bhEff149_0x2e8b30; // 0x2e9068 - g_ps2RecompiledFunctionTable[500761] = bhEff149_0x2e8b30; // 0x2e906c - g_ps2RecompiledFunctionTable[500762] = bhEff149_0x2e8b30; // 0x2e9070 - g_ps2RecompiledFunctionTable[500763] = bhEff149_0x2e8b30; // 0x2e9074 - g_ps2RecompiledFunctionTable[500764] = bhEff149_0x2e8b30; // 0x2e9078 - g_ps2RecompiledFunctionTable[500765] = bhEff149_0x2e8b30; // 0x2e907c - g_ps2RecompiledFunctionTable[500766] = bhEff149_0x2e8b30; // 0x2e9080 - g_ps2RecompiledFunctionTable[500767] = bhEff149_0x2e8b30; // 0x2e9084 - g_ps2RecompiledFunctionTable[500768] = bhEff149_0x2e8b30; // 0x2e9088 - g_ps2RecompiledFunctionTable[500769] = bhEff149_0x2e8b30; // 0x2e908c - g_ps2RecompiledFunctionTable[500770] = bhEff149_0x2e8b30; // 0x2e9090 - g_ps2RecompiledFunctionTable[500771] = bhEff149_0x2e8b30; // 0x2e9094 - g_ps2RecompiledFunctionTable[500772] = bhEff149_0x2e8b30; // 0x2e9098 - g_ps2RecompiledFunctionTable[500773] = bhEff149_0x2e8b30; // 0x2e909c - g_ps2RecompiledFunctionTable[500774] = bhEff149_0x2e8b30; // 0x2e90a0 - g_ps2RecompiledFunctionTable[500775] = bhEff149_0x2e8b30; // 0x2e90a4 - g_ps2RecompiledFunctionTable[500776] = bhEff149_0x2e8b30; // 0x2e90a8 - g_ps2RecompiledFunctionTable[500777] = bhEff149_0x2e8b30; // 0x2e90ac - g_ps2RecompiledFunctionTable[500778] = bhEff149_0x2e8b30; // 0x2e90b0 - g_ps2RecompiledFunctionTable[500779] = bhEff149_0x2e8b30; // 0x2e90b4 - g_ps2RecompiledFunctionTable[500782] = bhEff144_0x2e90c0; // 0x2e90c0 - g_ps2RecompiledFunctionTable[500838] = bhEff143_sub_0x2e91a0; // 0x2e91a0 - g_ps2RecompiledFunctionTable[500853] = bhEff143_sub_0x2e91a0; // 0x2e91dc - g_ps2RecompiledFunctionTable[500857] = bhEff143_sub_0x2e91a0; // 0x2e91ec - g_ps2RecompiledFunctionTable[500864] = bhEff143_sub_0x2e91a0; // 0x2e9208 - g_ps2RecompiledFunctionTable[500869] = bhEff143_sub_0x2e91a0; // 0x2e921c - g_ps2RecompiledFunctionTable[500872] = bhEff143_sub_0x2e91a0; // 0x2e9228 - g_ps2RecompiledFunctionTable[500875] = bhEff143_sub_0x2e91a0; // 0x2e9234 - g_ps2RecompiledFunctionTable[500879] = bhEff143_sub_0x2e91a0; // 0x2e9244 - g_ps2RecompiledFunctionTable[500883] = bhEff143_sub_0x2e91a0; // 0x2e9254 - g_ps2RecompiledFunctionTable[500888] = bhEff143_sub_0x2e91a0; // 0x2e9268 - g_ps2RecompiledFunctionTable[500890] = bhEff143_sub_0x2e91a0; // 0x2e9270 - g_ps2RecompiledFunctionTable[500893] = bhEff143_sub_0x2e91a0; // 0x2e927c - g_ps2RecompiledFunctionTable[500896] = bhEff143_sub_0x2e91a0; // 0x2e9288 - g_ps2RecompiledFunctionTable[500902] = bhEff143_0x2e92a0; // 0x2e92a0 - g_ps2RecompiledFunctionTable[500934] = bhEff143_0x2e92a0; // 0x2e9320 - g_ps2RecompiledFunctionTable[500957] = bhEff143_0x2e92a0; // 0x2e937c - g_ps2RecompiledFunctionTable[500959] = bhEff143_0x2e92a0; // 0x2e9384 - g_ps2RecompiledFunctionTable[500976] = bhEff143_0x2e92a0; // 0x2e93c8 - g_ps2RecompiledFunctionTable[500989] = bhEff143_0x2e92a0; // 0x2e93fc - g_ps2RecompiledFunctionTable[501006] = bhEff143_0x2e92a0; // 0x2e9440 - g_ps2RecompiledFunctionTable[501020] = bhEff143_0x2e92a0; // 0x2e9478 - g_ps2RecompiledFunctionTable[501033] = bhEff143_0x2e92a0; // 0x2e94ac - g_ps2RecompiledFunctionTable[501036] = bhEff143_0x2e92a0; // 0x2e94b8 - g_ps2RecompiledFunctionTable[501041] = bhEff143_0x2e92a0; // 0x2e94cc - g_ps2RecompiledFunctionTable[501055] = bhEff143_0x2e92a0; // 0x2e9504 - g_ps2RecompiledFunctionTable[501072] = bhEff143_0x2e92a0; // 0x2e9548 - g_ps2RecompiledFunctionTable[501086] = bhEff143_0x2e92a0; // 0x2e9580 - g_ps2RecompiledFunctionTable[501105] = bhEff143_0x2e92a0; // 0x2e95cc - g_ps2RecompiledFunctionTable[501107] = bhEff143_0x2e92a0; // 0x2e95d4 - g_ps2RecompiledFunctionTable[501126] = bhEff143_0x2e92a0; // 0x2e9620 - g_ps2RecompiledFunctionTable[501145] = bhEff143_0x2e92a0; // 0x2e966c - g_ps2RecompiledFunctionTable[501196] = bhEff143_0x2e92a0; // 0x2e9738 - g_ps2RecompiledFunctionTable[501209] = bhEff143_0x2e92a0; // 0x2e976c - g_ps2RecompiledFunctionTable[501219] = bhEff143_0x2e92a0; // 0x2e9794 - g_ps2RecompiledFunctionTable[501232] = bhEff143_0x2e92a0; // 0x2e97c8 - g_ps2RecompiledFunctionTable[501286] = wait_alarm_0x2e98a0; // 0x2e98a0 - g_ps2RecompiledFunctionTable[501290] = wait_alarm_0x2e98a0; // 0x2e98b0 - g_ps2RecompiledFunctionTable[501298] = SdrDelayThread_0x2e98d0; // 0x2e98d0 - g_ps2RecompiledFunctionTable[501303] = SdrDelayThread_0x2e98d0; // 0x2e98e4 - g_ps2RecompiledFunctionTable[501308] = SdrDelayThread_0x2e98d0; // 0x2e98f8 - g_ps2RecompiledFunctionTable[501313] = SdrDelayThread_0x2e98d0; // 0x2e990c - g_ps2RecompiledFunctionTable[501317] = SdrDelayThread_0x2e98d0; // 0x2e991c - g_ps2RecompiledFunctionTable[501322] = sdr_initQue_0x2e9930; // 0x2e9930 - g_ps2RecompiledFunctionTable[501332] = sdr_initQue_0x2e9930; // 0x2e9958 - g_ps2RecompiledFunctionTable[501342] = sdr_initDev_0x2e9980; // 0x2e9980 - g_ps2RecompiledFunctionTable[501351] = sdr_initDev_0x2e9980; // 0x2e99a4 - g_ps2RecompiledFunctionTable[501354] = sdr_initDev_0x2e9980; // 0x2e99b0 - g_ps2RecompiledFunctionTable[501364] = sdr_initDev_0x2e9980; // 0x2e99d8 - g_ps2RecompiledFunctionTable[501366] = sdr_initDev_0x2e9980; // 0x2e99e0 - g_ps2RecompiledFunctionTable[501382] = SdrInit_0x2e9a20; // 0x2e9a20 - g_ps2RecompiledFunctionTable[501392] = SdrInit_0x2e9a20; // 0x2e9a48 - g_ps2RecompiledFunctionTable[501396] = SdrInit_0x2e9a20; // 0x2e9a58 - g_ps2RecompiledFunctionTable[501401] = SdrInit_0x2e9a20; // 0x2e9a6c - g_ps2RecompiledFunctionTable[501407] = SdrInit_0x2e9a20; // 0x2e9a84 - g_ps2RecompiledFunctionTable[501412] = SdrInit_0x2e9a20; // 0x2e9a98 - g_ps2RecompiledFunctionTable[501423] = SdrInit_0x2e9a20; // 0x2e9ac4 - g_ps2RecompiledFunctionTable[501428] = SdrInit_0x2e9a20; // 0x2e9ad8 - g_ps2RecompiledFunctionTable[501438] = SdrInit_0x2e9a20; // 0x2e9b00 - g_ps2RecompiledFunctionTable[501443] = SdrInit_0x2e9a20; // 0x2e9b14 - g_ps2RecompiledFunctionTable[501450] = SdrInit_0x2e9a20; // 0x2e9b30 - g_ps2RecompiledFunctionTable[501451] = SdrInit_0x2e9a20; // 0x2e9b34 - g_ps2RecompiledFunctionTable[501453] = SdrInit_0x2e9a20; // 0x2e9b3c - g_ps2RecompiledFunctionTable[501466] = SdrInit_0x2e9a20; // 0x2e9b70 - g_ps2RecompiledFunctionTable[501469] = SdrInit_0x2e9a20; // 0x2e9b7c - g_ps2RecompiledFunctionTable[501471] = SdrInit_0x2e9a20; // 0x2e9b84 - g_ps2RecompiledFunctionTable[501480] = SdrInit_0x2e9a20; // 0x2e9ba8 - g_ps2RecompiledFunctionTable[501598] = SdrSeReq_0x2e9d80; // 0x2e9d80 - g_ps2RecompiledFunctionTable[501612] = SdrSeReq_0x2e9d80; // 0x2e9db8 - g_ps2RecompiledFunctionTable[501678] = SdrSeCancel_0x2e9ec0; // 0x2e9ec0 - g_ps2RecompiledFunctionTable[501692] = SdrSeCancel_0x2e9ec0; // 0x2e9ef8 - g_ps2RecompiledFunctionTable[501718] = SdrSeChg_0x2e9f60; // 0x2e9f60 - g_ps2RecompiledFunctionTable[501732] = SdrSeChg_0x2e9f60; // 0x2e9f98 - g_ps2RecompiledFunctionTable[501806] = SdrSeAllStop_0x2ea0c0; // 0x2ea0c0 - g_ps2RecompiledFunctionTable[501820] = SdrSeAllStop_0x2ea0c0; // 0x2ea0f8 - g_ps2RecompiledFunctionTable[501842] = SdrMasterVol_0x2ea150; // 0x2ea150 - g_ps2RecompiledFunctionTable[501856] = SdrMasterVol_0x2ea150; // 0x2ea188 - g_ps2RecompiledFunctionTable[501882] = SdrBgmReq_0x2ea1f0; // 0x2ea1f0 - g_ps2RecompiledFunctionTable[501896] = SdrBgmReq_0x2ea1f0; // 0x2ea228 - g_ps2RecompiledFunctionTable[501930] = SdrBgmStop_0x2ea2b0; // 0x2ea2b0 - g_ps2RecompiledFunctionTable[501944] = SdrBgmStop_0x2ea2b0; // 0x2ea2e8 - g_ps2RecompiledFunctionTable[501970] = SdrBgmChg_0x2ea350; // 0x2ea350 - g_ps2RecompiledFunctionTable[501984] = SdrBgmChg_0x2ea350; // 0x2ea388 - g_ps2RecompiledFunctionTable[502026] = SdrHDDataSet_0x2ea430; // 0x2ea430 - g_ps2RecompiledFunctionTable[502040] = SdrHDDataSet_0x2ea430; // 0x2ea468 - g_ps2RecompiledFunctionTable[502066] = SdrHDDataSet2_0x2ea4d0; // 0x2ea4d0 - g_ps2RecompiledFunctionTable[502080] = SdrHDDataSet2_0x2ea4d0; // 0x2ea508 - g_ps2RecompiledFunctionTable[502106] = SdrBDDataSet_0x2ea570; // 0x2ea570 - g_ps2RecompiledFunctionTable[502120] = SdrBDDataSet_0x2ea570; // 0x2ea5a8 - g_ps2RecompiledFunctionTable[502146] = SdrBDDataSet2_0x2ea610; // 0x2ea610 - g_ps2RecompiledFunctionTable[502160] = SdrBDDataSet2_0x2ea610; // 0x2ea648 - g_ps2RecompiledFunctionTable[502186] = SdrBDDataTrans_0x2ea6b0; // 0x2ea6b0 - g_ps2RecompiledFunctionTable[502200] = SdrBDDataTrans_0x2ea6b0; // 0x2ea6e8 - g_ps2RecompiledFunctionTable[502242] = SdrSQDataSet_0x2ea790; // 0x2ea790 - g_ps2RecompiledFunctionTable[502256] = SdrSQDataSet_0x2ea790; // 0x2ea7c8 - g_ps2RecompiledFunctionTable[502282] = SdrSetIopData_0x2ea830; // 0x2ea830 - g_ps2RecompiledFunctionTable[502296] = SdrSetIopData_0x2ea830; // 0x2ea868 - g_ps2RecompiledFunctionTable[502330] = SdrSetOutputMode_0x2ea8f0; // 0x2ea8f0 - g_ps2RecompiledFunctionTable[502344] = SdrSetOutputMode_0x2ea8f0; // 0x2ea928 - g_ps2RecompiledFunctionTable[502370] = SdrSetRev_0x2ea990; // 0x2ea990 - g_ps2RecompiledFunctionTable[502377] = SdrSetRev_0x2ea990; // 0x2ea9ac - g_ps2RecompiledFunctionTable[502385] = SdrSetRev_0x2ea990; // 0x2ea9cc - g_ps2RecompiledFunctionTable[502399] = SdrSetRev_0x2ea990; // 0x2eaa04 - g_ps2RecompiledFunctionTable[502434] = SdrSendReq_0x2eaa90; // 0x2eaa90 - g_ps2RecompiledFunctionTable[502444] = SdrSendReq_0x2eaa90; // 0x2eaab8 - g_ps2RecompiledFunctionTable[502451] = SdrSendReq_0x2eaa90; // 0x2eaad4 - g_ps2RecompiledFunctionTable[502454] = SdrSendReq_0x2eaa90; // 0x2eaae0 - g_ps2RecompiledFunctionTable[502456] = SdrSendReq_0x2eaa90; // 0x2eaae8 - g_ps2RecompiledFunctionTable[502461] = SdrSendReq_0x2eaa90; // 0x2eaafc - g_ps2RecompiledFunctionTable[502506] = SdrSendReq_0x2eaa90; // 0x2eabb0 - g_ps2RecompiledFunctionTable[502511] = SdrSendReq_0x2eaa90; // 0x2eabc4 - g_ps2RecompiledFunctionTable[502514] = SdrSendReq_0x2eaa90; // 0x2eabd0 - g_ps2RecompiledFunctionTable[502526] = SdrSendReq_0x2eaa90; // 0x2eac00 - g_ps2RecompiledFunctionTable[502534] = cb_sifRpc_0x2eac20; // 0x2eac20 - g_ps2RecompiledFunctionTable[502538] = cb_sifRpc_snd_0x2eac30; // 0x2eac30 - g_ps2RecompiledFunctionTable[502542] = cb_sifRpc_snd_0x2eac30; // 0x2eac40 - g_ps2RecompiledFunctionTable[502550] = SdrGetStateSend_0x2eac60; // 0x2eac60 - g_ps2RecompiledFunctionTable[502559] = SdrGetStateSend_0x2eac60; // 0x2eac84 - g_ps2RecompiledFunctionTable[502577] = SdrGetStateSend_0x2eac60; // 0x2eaccc - g_ps2RecompiledFunctionTable[502582] = SdrGetStateSend_0x2eac60; // 0x2eace0 - g_ps2RecompiledFunctionTable[502585] = SdrGetStateSend_0x2eac60; // 0x2eacec - g_ps2RecompiledFunctionTable[502594] = SdrGetStateReceive_0x2ead10; // 0x2ead10 - g_ps2RecompiledFunctionTable[502601] = SdrGetStateReceive_0x2ead10; // 0x2ead2c - g_ps2RecompiledFunctionTable[502608] = SdrGetStateReceive_0x2ead10; // 0x2ead48 - g_ps2RecompiledFunctionTable[502613] = SdrGetStateReceive_0x2ead10; // 0x2ead5c - g_ps2RecompiledFunctionTable[502618] = SdrGetState_0x2ead70; // 0x2ead70 - g_ps2RecompiledFunctionTable[502623] = SdrGetState_0x2ead70; // 0x2ead84 - g_ps2RecompiledFunctionTable[502628] = SdrGetState_0x2ead70; // 0x2ead98 - g_ps2RecompiledFunctionTable[502630] = SdrGetState_0x2ead70; // 0x2eada0 - g_ps2RecompiledFunctionTable[502647] = SdrGetState_0x2ead70; // 0x2eade4 - g_ps2RecompiledFunctionTable[502650] = SdrGetState_0x2ead70; // 0x2eadf0 - g_ps2RecompiledFunctionTable[502658] = makebuff_tq_0x2eae10; // 0x2eae10 - g_ps2RecompiledFunctionTable[502714] = makebuff8_0x2eaef0; // 0x2eaef0 - g_ps2RecompiledFunctionTable[502721] = makebuff8_0x2eaef0; // 0x2eaf0c - g_ps2RecompiledFunctionTable[502738] = makebuff8_0x2eaef0; // 0x2eaf50 - g_ps2RecompiledFunctionTable[502818] = makebuff_0x2eb090; // 0x2eb090 - g_ps2RecompiledFunctionTable[502825] = makebuff_0x2eb090; // 0x2eb0ac - g_ps2RecompiledFunctionTable[502841] = makebuff_0x2eb090; // 0x2eb0ec - g_ps2RecompiledFunctionTable[502866] = makebuff_ext_0x2eb150; // 0x2eb150 - g_ps2RecompiledFunctionTable[502876] = makebuff_ext_0x2eb150; // 0x2eb178 - g_ps2RecompiledFunctionTable[502892] = makebuff_ext_0x2eb150; // 0x2eb1b8 - g_ps2RecompiledFunctionTable[502910] = sending_req_0x2eb200; // 0x2eb200 - g_ps2RecompiledFunctionTable[502949] = sending_req_0x2eb200; // 0x2eb29c - g_ps2RecompiledFunctionTable[502957] = sending_req_0x2eb200; // 0x2eb2bc - g_ps2RecompiledFunctionTable[502962] = sending_req_0x2eb200; // 0x2eb2d0 - g_ps2RecompiledFunctionTable[502971] = sending_req_0x2eb200; // 0x2eb2f4 - g_ps2RecompiledFunctionTable[502979] = sending_req_0x2eb200; // 0x2eb314 - g_ps2RecompiledFunctionTable[502990] = sending_req_0x2eb200; // 0x2eb340 - g_ps2RecompiledFunctionTable[503007] = sending_req_0x2eb200; // 0x2eb384 - g_ps2RecompiledFunctionTable[503012] = sending_req_0x2eb200; // 0x2eb398 - g_ps2RecompiledFunctionTable[503025] = sending_req_0x2eb200; // 0x2eb3cc - g_ps2RecompiledFunctionTable[503033] = sending_req_0x2eb200; // 0x2eb3ec - g_ps2RecompiledFunctionTable[503044] = sending_req_0x2eb200; // 0x2eb418 - g_ps2RecompiledFunctionTable[503056] = sending_req_0x2eb200; // 0x2eb448 - g_ps2RecompiledFunctionTable[503066] = sending_req_0x2eb200; // 0x2eb470 - g_ps2RecompiledFunctionTable[503079] = sending_req_0x2eb200; // 0x2eb4a4 - g_ps2RecompiledFunctionTable[503084] = sending_req_0x2eb200; // 0x2eb4b8 - g_ps2RecompiledFunctionTable[503097] = sending_req_0x2eb200; // 0x2eb4ec - g_ps2RecompiledFunctionTable[503102] = sending_req_0x2eb200; // 0x2eb500 - g_ps2RecompiledFunctionTable[503107] = sending_req_0x2eb200; // 0x2eb514 - g_ps2RecompiledFunctionTable[503114] = get_iopsnd_info_0x2eb530; // 0x2eb530 - g_ps2RecompiledFunctionTable[503124] = get_iopsnd_info_0x2eb530; // 0x2eb558 - g_ps2RecompiledFunctionTable[503132] = get_iopsnd_info_0x2eb530; // 0x2eb578 - g_ps2RecompiledFunctionTable[503138] = initAll_0x2eb590; // 0x2eb590 - g_ps2RecompiledFunctionTable[503148] = initAll_0x2eb590; // 0x2eb5b8 - g_ps2RecompiledFunctionTable[503155] = initAll_0x2eb590; // 0x2eb5d4 - g_ps2RecompiledFunctionTable[503166] = initAll_0x2eb590; // 0x2eb600 - g_ps2RecompiledFunctionTable[503168] = initAll_0x2eb590; // 0x2eb608 - g_ps2RecompiledFunctionTable[503175] = initAll_0x2eb590; // 0x2eb624 - g_ps2RecompiledFunctionTable[503182] = initAll_0x2eb590; // 0x2eb640 - g_ps2RecompiledFunctionTable[503189] = initAll_0x2eb590; // 0x2eb65c - g_ps2RecompiledFunctionTable[503196] = initAll_0x2eb590; // 0x2eb678 - g_ps2RecompiledFunctionTable[503203] = initAll_0x2eb590; // 0x2eb694 - g_ps2RecompiledFunctionTable[503210] = initAll_0x2eb590; // 0x2eb6b0 - g_ps2RecompiledFunctionTable[503219] = initAll_0x2eb590; // 0x2eb6d4 - g_ps2RecompiledFunctionTable[503239] = initAll_0x2eb590; // 0x2eb724 - g_ps2RecompiledFunctionTable[503244] = initAll_0x2eb590; // 0x2eb738 - g_ps2RecompiledFunctionTable[503289] = initAll_0x2eb590; // 0x2eb7ec - g_ps2RecompiledFunctionTable[503298] = initAll_0x2eb590; // 0x2eb810 - g_ps2RecompiledFunctionTable[503301] = initAll_0x2eb590; // 0x2eb81c - g_ps2RecompiledFunctionTable[503346] = initAll_0x2eb590; // 0x2eb8d0 - g_ps2RecompiledFunctionTable[503353] = initAll_0x2eb590; // 0x2eb8ec - g_ps2RecompiledFunctionTable[503358] = readMpeg_0x2eb900; // 0x2eb900 - g_ps2RecompiledFunctionTable[503373] = readMpeg_0x2eb900; // 0x2eb93c - g_ps2RecompiledFunctionTable[503375] = readMpeg_0x2eb900; // 0x2eb944 - g_ps2RecompiledFunctionTable[503387] = readMpeg_0x2eb900; // 0x2eb974 - g_ps2RecompiledFunctionTable[503419] = readMpeg_0x2eb900; // 0x2eb9f4 - g_ps2RecompiledFunctionTable[503423] = readMpeg_0x2eb900; // 0x2eba04 - g_ps2RecompiledFunctionTable[503460] = readMpeg_0x2eb900; // 0x2eba98 - g_ps2RecompiledFunctionTable[503489] = readMpeg_0x2eb900; // 0x2ebb0c - g_ps2RecompiledFunctionTable[503496] = readMpeg_0x2eb900; // 0x2ebb28 - g_ps2RecompiledFunctionTable[503506] = readMpeg_0x2eb900; // 0x2ebb50 - g_ps2RecompiledFunctionTable[503546] = readBufEndGet_0x2ebbf0; // 0x2ebbf0 - g_ps2RecompiledFunctionTable[503554] = setImageTag_0x2ebc10; // 0x2ebc10 - g_ps2RecompiledFunctionTable[503603] = setImageTag_0x2ebc10; // 0x2ebcd4 - g_ps2RecompiledFunctionTable[503605] = setImageTag_0x2ebc10; // 0x2ebcdc - g_ps2RecompiledFunctionTable[503648] = setImageTag_0x2ebc10; // 0x2ebd88 - g_ps2RecompiledFunctionTable[503650] = setImageTag_0x2ebc10; // 0x2ebd90 - g_ps2RecompiledFunctionTable[503658] = setImageTag_0x2ebc10; // 0x2ebdb0 - g_ps2RecompiledFunctionTable[503670] = vbrank_draw_0x2ebde0; // 0x2ebde0 - g_ps2RecompiledFunctionTable[503678] = vbrank_draw_0x2ebde0; // 0x2ebe00 - g_ps2RecompiledFunctionTable[503758] = vbrank_draw_0x2ebde0; // 0x2ebf40 - g_ps2RecompiledFunctionTable[503761] = vbrank_draw_0x2ebde0; // 0x2ebf4c - g_ps2RecompiledFunctionTable[503763] = vbrank_draw_0x2ebde0; // 0x2ebf54 - g_ps2RecompiledFunctionTable[503766] = videoDecMain_0x2ebf60; // 0x2ebf60 - g_ps2RecompiledFunctionTable[503772] = videoDecMain_0x2ebf60; // 0x2ebf78 - g_ps2RecompiledFunctionTable[503778] = videoDecMain_0x2ebf60; // 0x2ebf90 - g_ps2RecompiledFunctionTable[503794] = decBs0_0x2ebfd0; // 0x2ebfd0 - g_ps2RecompiledFunctionTable[503801] = decBs0_0x2ebfd0; // 0x2ebfec - g_ps2RecompiledFunctionTable[503803] = decBs0_0x2ebfd0; // 0x2ebff4 - g_ps2RecompiledFunctionTable[503811] = decBs0_0x2ebfd0; // 0x2ec014 - g_ps2RecompiledFunctionTable[503818] = decBs0_0x2ebfd0; // 0x2ec030 - g_ps2RecompiledFunctionTable[503825] = decBs0_0x2ebfd0; // 0x2ec04c - g_ps2RecompiledFunctionTable[503843] = decBs0_0x2ebfd0; // 0x2ec094 - g_ps2RecompiledFunctionTable[503847] = decBs0_0x2ebfd0; // 0x2ec0a4 - g_ps2RecompiledFunctionTable[503849] = decBs0_0x2ebfd0; // 0x2ec0ac - g_ps2RecompiledFunctionTable[503851] = decBs0_0x2ebfd0; // 0x2ec0b4 - g_ps2RecompiledFunctionTable[503857] = decBs0_0x2ebfd0; // 0x2ec0cc - g_ps2RecompiledFunctionTable[503866] = copy2area_0x2ec0f0; // 0x2ec0f0 - g_ps2RecompiledFunctionTable[503895] = copy2area_0x2ec0f0; // 0x2ec164 - g_ps2RecompiledFunctionTable[503900] = copy2area_0x2ec0f0; // 0x2ec178 - g_ps2RecompiledFunctionTable[503904] = copy2area_0x2ec0f0; // 0x2ec188 - g_ps2RecompiledFunctionTable[503913] = copy2area_0x2ec0f0; // 0x2ec1ac - g_ps2RecompiledFunctionTable[503917] = copy2area_0x2ec0f0; // 0x2ec1bc - g_ps2RecompiledFunctionTable[503921] = copy2area_0x2ec0f0; // 0x2ec1cc - g_ps2RecompiledFunctionTable[503926] = copy2area_0x2ec0f0; // 0x2ec1e0 - g_ps2RecompiledFunctionTable[503930] = copy2area_0x2ec0f0; // 0x2ec1f0 - g_ps2RecompiledFunctionTable[503942] = audioDecSendToIOP_0x2ec220; // 0x2ec220 - g_ps2RecompiledFunctionTable[503984] = audioDecSendToIOP_0x2ec220; // 0x2ec2c8 - g_ps2RecompiledFunctionTable[503994] = audioDecSendToIOP_0x2ec220; // 0x2ec2f0 - g_ps2RecompiledFunctionTable[504026] = audioDecSendToIOP_0x2ec220; // 0x2ec370 - g_ps2RecompiledFunctionTable[504050] = iopGetArea_0x2ec3d0; // 0x2ec3d0 - g_ps2RecompiledFunctionTable[504090] = sendToIOP2area_0x2ec470; // 0x2ec470 - g_ps2RecompiledFunctionTable[504127] = sendToIOP2area_0x2ec470; // 0x2ec504 - g_ps2RecompiledFunctionTable[504131] = sendToIOP2area_0x2ec470; // 0x2ec514 - g_ps2RecompiledFunctionTable[504136] = sendToIOP2area_0x2ec470; // 0x2ec528 - g_ps2RecompiledFunctionTable[504146] = sendToIOP2area_0x2ec470; // 0x2ec550 - g_ps2RecompiledFunctionTable[504150] = sendToIOP2area_0x2ec470; // 0x2ec560 - g_ps2RecompiledFunctionTable[504155] = sendToIOP2area_0x2ec470; // 0x2ec574 - g_ps2RecompiledFunctionTable[504161] = sendToIOP2area_0x2ec470; // 0x2ec58c - g_ps2RecompiledFunctionTable[504165] = sendToIOP2area_0x2ec470; // 0x2ec59c - g_ps2RecompiledFunctionTable[504178] = sendToIOP_0x2ec5d0; // 0x2ec5d0 - g_ps2RecompiledFunctionTable[504195] = sendToIOP_0x2ec5d0; // 0x2ec614 - g_ps2RecompiledFunctionTable[504201] = sendToIOP_0x2ec5d0; // 0x2ec62c - g_ps2RecompiledFunctionTable[504202] = sendToIOP_0x2ec5d0; // 0x2ec630 - g_ps2RecompiledFunctionTable[504222] = sendToIOP_0x2ec5d0; // 0x2ec680 - g_ps2RecompiledFunctionTable[504225] = sendToIOP_0x2ec5d0; // 0x2ec68c - g_ps2RecompiledFunctionTable[504226] = sendToIOP_0x2ec5d0; // 0x2ec690 - g_ps2RecompiledFunctionTable[504228] = sendToIOP_0x2ec5d0; // 0x2ec698 - g_ps2RecompiledFunctionTable[504242] = changeInputVolume_0x2ec6d0; // 0x2ec6d0 - g_ps2RecompiledFunctionTable[504251] = changeInputVolume_0x2ec6d0; // 0x2ec6f4 - g_ps2RecompiledFunctionTable[504256] = changeInputVolume_0x2ec6d0; // 0x2ec708 - g_ps2RecompiledFunctionTable[504262] = setD3_CHCR_0x2ec720; // 0x2ec720 - g_ps2RecompiledFunctionTable[504263] = setD3_CHCR_0x2ec720; // 0x2ec724 - g_ps2RecompiledFunctionTable[504286] = setD4_CHCR_0x2ec780; // 0x2ec780 - g_ps2RecompiledFunctionTable[504287] = setD4_CHCR_0x2ec780; // 0x2ec784 - g_ps2RecompiledFunctionTable[504310] = scTag2_0x2ec7e0; // 0x2ec7e0 - g_ps2RecompiledFunctionTable[504322] = viBufReset_0x2ec810; // 0x2ec810 - g_ps2RecompiledFunctionTable[504340] = viBufReset_0x2ec810; // 0x2ec858 - g_ps2RecompiledFunctionTable[504362] = viBufReset_0x2ec810; // 0x2ec8b0 - g_ps2RecompiledFunctionTable[504365] = viBufReset_0x2ec810; // 0x2ec8bc - g_ps2RecompiledFunctionTable[504371] = viBufReset_0x2ec810; // 0x2ec8d4 - g_ps2RecompiledFunctionTable[504380] = viBufReset_0x2ec810; // 0x2ec8f8 - g_ps2RecompiledFunctionTable[504387] = viBufReset_0x2ec810; // 0x2ec914 - g_ps2RecompiledFunctionTable[504391] = viBufReset_0x2ec810; // 0x2ec924 - g_ps2RecompiledFunctionTable[504395] = viBufReset_0x2ec810; // 0x2ec934 - g_ps2RecompiledFunctionTable[504399] = viBufReset_0x2ec810; // 0x2ec944 - g_ps2RecompiledFunctionTable[504410] = DmaAddr_0x2ec970; // 0x2ec970 - g_ps2RecompiledFunctionTable[504414] = viBufBeginPut_0x2ec980; // 0x2ec980 - g_ps2RecompiledFunctionTable[504428] = viBufBeginPut_0x2ec980; // 0x2ec9b8 - g_ps2RecompiledFunctionTable[504469] = viBufBeginPut_0x2ec980; // 0x2eca5c - g_ps2RecompiledFunctionTable[504478] = viBufEndPut_0x2eca80; // 0x2eca80 - g_ps2RecompiledFunctionTable[504486] = viBufEndPut_0x2eca80; // 0x2ecaa0 - g_ps2RecompiledFunctionTable[504496] = viBufEndPut_0x2eca80; // 0x2ecac8 - g_ps2RecompiledFunctionTable[504502] = viBufModifyPts_0x2ecae0; // 0x2ecae0 - g_ps2RecompiledFunctionTable[504526] = viBufModifyPts_0x2ecae0; // 0x2ecb40 - g_ps2RecompiledFunctionTable[504540] = viBufModifyPts_0x2ecae0; // 0x2ecb78 - g_ps2RecompiledFunctionTable[504598] = IsPtsInRegion_0x2ecc60; // 0x2ecc60 - g_ps2RecompiledFunctionTable[504606] = viBufPutTs_0x2ecc80; // 0x2ecc80 - g_ps2RecompiledFunctionTable[504616] = viBufPutTs_0x2ecc80; // 0x2ecca8 - g_ps2RecompiledFunctionTable[504624] = viBufPutTs_0x2ecc80; // 0x2eccc8 - g_ps2RecompiledFunctionTable[504675] = viBufPutTs_0x2ecc80; // 0x2ecd94 - g_ps2RecompiledFunctionTable[504682] = voBufIncCount_0x2ecdb0; // 0x2ecdb0 - g_ps2RecompiledFunctionTable[504683] = voBufIncCount_0x2ecdb0; // 0x2ecdb4 - g_ps2RecompiledFunctionTable[504698] = audioDecResume_0x2ecdf0; // 0x2ecdf0 - g_ps2RecompiledFunctionTable[504704] = audioDecResume_0x2ecdf0; // 0x2ece08 - g_ps2RecompiledFunctionTable[504715] = audioDecResume_0x2ecdf0; // 0x2ece34 - g_ps2RecompiledFunctionTable[504717] = audioDecResume_0x2ecdf0; // 0x2ece3c - g_ps2RecompiledFunctionTable[504726] = getFIFOindex_0x2ece60; // 0x2ece60 - g_ps2RecompiledFunctionTable[504738] = getFIFOindex_0x2ece60; // 0x2ece90 - g_ps2RecompiledFunctionTable[504750] = videoDecPutTs_0x2ecec0; // 0x2ecec0 - g_ps2RecompiledFunctionTable[504762] = videoDecPutTs_0x2ecec0; // 0x2ecef0 - g_ps2RecompiledFunctionTable[504766] = audioDecBeginPut_0x2ecf00; // 0x2ecf00 - g_ps2RecompiledFunctionTable[504814] = termAll_0x2ecfc0; // 0x2ecfc0 - g_ps2RecompiledFunctionTable[504823] = termAll_0x2ecfc0; // 0x2ecfe4 - g_ps2RecompiledFunctionTable[504826] = termAll_0x2ecfc0; // 0x2ecff0 - g_ps2RecompiledFunctionTable[504829] = termAll_0x2ecfc0; // 0x2ecffc - g_ps2RecompiledFunctionTable[504832] = termAll_0x2ecfc0; // 0x2ed008 - g_ps2RecompiledFunctionTable[504835] = termAll_0x2ecfc0; // 0x2ed014 - g_ps2RecompiledFunctionTable[504837] = termAll_0x2ecfc0; // 0x2ed01c - g_ps2RecompiledFunctionTable[504843] = termAll_0x2ecfc0; // 0x2ed034 - g_ps2RecompiledFunctionTable[504854] = viBufDelete_0x2ed060; // 0x2ed060 - g_ps2RecompiledFunctionTable[504860] = viBufDelete_0x2ed060; // 0x2ed078 - g_ps2RecompiledFunctionTable[504868] = viBufDelete_0x2ed060; // 0x2ed098 - g_ps2RecompiledFunctionTable[504874] = videoDecDelete_0x2ed0b0; // 0x2ed0b0 - g_ps2RecompiledFunctionTable[504880] = videoDecDelete_0x2ed0b0; // 0x2ed0c8 - g_ps2RecompiledFunctionTable[504882] = videoDecDelete_0x2ed0b0; // 0x2ed0d0 - g_ps2RecompiledFunctionTable[504890] = audioDecDelete_0x2ed0f0; // 0x2ed0f0 - g_ps2RecompiledFunctionTable[504894] = audioDecDelete_0x2ed0f0; // 0x2ed100 - g_ps2RecompiledFunctionTable[504898] = GetAllWorkMemory_0x2ed110; // 0x2ed110 - g_ps2RecompiledFunctionTable[504902] = GetAllWorkMemory_0x2ed110; // 0x2ed120 - g_ps2RecompiledFunctionTable[504904] = GetAllWorkMemory_0x2ed110; // 0x2ed128 - g_ps2RecompiledFunctionTable[504906] = GetAllWorkMemory_0x2ed110; // 0x2ed130 - g_ps2RecompiledFunctionTable[504908] = GetAllWorkMemory_0x2ed110; // 0x2ed138 - g_ps2RecompiledFunctionTable[504910] = GetAllWorkMemory_0x2ed110; // 0x2ed140 - g_ps2RecompiledFunctionTable[504916] = GetAllWorkMemory_0x2ed110; // 0x2ed158 - g_ps2RecompiledFunctionTable[504964] = GetAllWorkMemory_0x2ed110; // 0x2ed218 - g_ps2RecompiledFunctionTable[504971] = GetAllWorkMemory_0x2ed110; // 0x2ed234 - g_ps2RecompiledFunctionTable[504977] = GetAllWorkMemory_0x2ed110; // 0x2ed24c - g_ps2RecompiledFunctionTable[504983] = GetAllWorkMemory_0x2ed110; // 0x2ed264 - g_ps2RecompiledFunctionTable[504989] = GetAllWorkMemory_0x2ed110; // 0x2ed27c - g_ps2RecompiledFunctionTable[504995] = GetAllWorkMemory_0x2ed110; // 0x2ed294 - g_ps2RecompiledFunctionTable[505001] = GetAllWorkMemory_0x2ed110; // 0x2ed2ac - g_ps2RecompiledFunctionTable[505007] = GetAllWorkMemory_0x2ed110; // 0x2ed2c4 - g_ps2RecompiledFunctionTable[505010] = GetAllWorkMemory_0x2ed110; // 0x2ed2d0 - g_ps2RecompiledFunctionTable[505014] = OutPutCdErrorCode_0x2ed2e0; // 0x2ed2e0 - g_ps2RecompiledFunctionTable[505047] = OutPutCdErrorCode_0x2ed2e0; // 0x2ed364 - g_ps2RecompiledFunctionTable[505052] = OutPutCdErrorCode_0x2ed2e0; // 0x2ed378 - g_ps2RecompiledFunctionTable[505057] = OutPutCdErrorCode_0x2ed2e0; // 0x2ed38c - g_ps2RecompiledFunctionTable[505062] = OutPutCdErrorCode_0x2ed2e0; // 0x2ed3a0 - g_ps2RecompiledFunctionTable[505067] = OutPutCdErrorCode_0x2ed2e0; // 0x2ed3b4 - g_ps2RecompiledFunctionTable[505072] = OutPutCdErrorCode_0x2ed2e0; // 0x2ed3c8 - g_ps2RecompiledFunctionTable[505077] = OutPutCdErrorCode_0x2ed2e0; // 0x2ed3dc - g_ps2RecompiledFunctionTable[505082] = OutPutCdErrorCode_0x2ed2e0; // 0x2ed3f0 - g_ps2RecompiledFunctionTable[505091] = OutPutCdErrorCode_0x2ed2e0; // 0x2ed414 - g_ps2RecompiledFunctionTable[505098] = videoCallback_0x2ed430; // 0x2ed430 - g_ps2RecompiledFunctionTable[505124] = videoCallback_0x2ed430; // 0x2ed498 - g_ps2RecompiledFunctionTable[505126] = videoCallback_0x2ed430; // 0x2ed4a0 - g_ps2RecompiledFunctionTable[505129] = videoCallback_0x2ed430; // 0x2ed4ac - g_ps2RecompiledFunctionTable[505138] = videoCallback_0x2ed430; // 0x2ed4d0 - g_ps2RecompiledFunctionTable[505148] = videoCallback_0x2ed430; // 0x2ed4f8 - g_ps2RecompiledFunctionTable[505153] = videoCallback_0x2ed430; // 0x2ed50c - g_ps2RecompiledFunctionTable[505157] = videoCallback_0x2ed430; // 0x2ed51c - g_ps2RecompiledFunctionTable[505170] = pcmCallback_0x2ed550; // 0x2ed550 - g_ps2RecompiledFunctionTable[505198] = pcmCallback_0x2ed550; // 0x2ed5c0 - g_ps2RecompiledFunctionTable[505207] = pcmCallback_0x2ed550; // 0x2ed5e4 - g_ps2RecompiledFunctionTable[505286] = mpegError_0x2ed720; // 0x2ed720 - g_ps2RecompiledFunctionTable[505292] = mpegError_0x2ed720; // 0x2ed738 - g_ps2RecompiledFunctionTable[505298] = mpegNodata_0x2ed750; // 0x2ed750 - g_ps2RecompiledFunctionTable[505307] = mpegNodata_0x2ed750; // 0x2ed774 - g_ps2RecompiledFunctionTable[505310] = mpegNodata_0x2ed750; // 0x2ed780 - g_ps2RecompiledFunctionTable[505317] = mpegNodata_0x2ed750; // 0x2ed79c - g_ps2RecompiledFunctionTable[505322] = mpegNodata_0x2ed750; // 0x2ed7b0 - g_ps2RecompiledFunctionTable[505329] = mpegNodata_0x2ed750; // 0x2ed7cc - g_ps2RecompiledFunctionTable[505397] = mpegNodata_0x2ed750; // 0x2ed8dc - g_ps2RecompiledFunctionTable[505401] = mpegNodata_0x2ed750; // 0x2ed8ec - g_ps2RecompiledFunctionTable[505416] = mpegNodata_0x2ed750; // 0x2ed928 - g_ps2RecompiledFunctionTable[505446] = mpegNodata_0x2ed750; // 0x2ed9a0 - g_ps2RecompiledFunctionTable[505449] = mpegNodata_0x2ed750; // 0x2ed9ac - g_ps2RecompiledFunctionTable[505458] = mpegStopDMA_0x2ed9d0; // 0x2ed9d0 - g_ps2RecompiledFunctionTable[505463] = mpegStopDMA_0x2ed9d0; // 0x2ed9e4 - g_ps2RecompiledFunctionTable[505467] = mpegStopDMA_0x2ed9d0; // 0x2ed9f4 - g_ps2RecompiledFunctionTable[505483] = mpegStopDMA_0x2ed9d0; // 0x2eda34 - g_ps2RecompiledFunctionTable[505492] = mpegStopDMA_0x2ed9d0; // 0x2eda58 - g_ps2RecompiledFunctionTable[505515] = mpegStopDMA_0x2ed9d0; // 0x2edab4 - g_ps2RecompiledFunctionTable[505522] = mpegRestartDMA_0x2edad0; // 0x2edad0 - g_ps2RecompiledFunctionTable[505554] = mpegRestartDMA_0x2edad0; // 0x2edb50 - g_ps2RecompiledFunctionTable[505568] = mpegRestartDMA_0x2edad0; // 0x2edb88 - g_ps2RecompiledFunctionTable[505623] = mpegRestartDMA_0x2edad0; // 0x2edc64 - g_ps2RecompiledFunctionTable[505628] = mpegRestartDMA_0x2edad0; // 0x2edc78 - g_ps2RecompiledFunctionTable[505635] = mpegRestartDMA_0x2edad0; // 0x2edc94 - g_ps2RecompiledFunctionTable[505713] = mpegRestartDMA_0x2edad0; // 0x2eddcc - g_ps2RecompiledFunctionTable[505717] = mpegRestartDMA_0x2edad0; // 0x2edddc - g_ps2RecompiledFunctionTable[505726] = mpegRestartDMA_0x2edad0; // 0x2ede00 - g_ps2RecompiledFunctionTable[505746] = mpegRestartDMA_0x2edad0; // 0x2ede50 - g_ps2RecompiledFunctionTable[505756] = mpegRestartDMA_0x2edad0; // 0x2ede78 - g_ps2RecompiledFunctionTable[505770] = mpegTS_0x2edeb0; // 0x2edeb0 - g_ps2RecompiledFunctionTable[505800] = mpegTS_0x2edeb0; // 0x2edf28 - g_ps2RecompiledFunctionTable[505822] = mpegTS_0x2edeb0; // 0x2edf80 - g_ps2RecompiledFunctionTable[505841] = mpegTS_0x2edeb0; // 0x2edfcc - g_ps2RecompiledFunctionTable[505877] = mpegTS_0x2edeb0; // 0x2ee05c - g_ps2RecompiledFunctionTable[505894] = ADXAMP_Init_0x2ee0a0; // 0x2ee0a0 - g_ps2RecompiledFunctionTable[505903] = ADXAMP_Init_0x2ee0a0; // 0x2ee0c4 - g_ps2RecompiledFunctionTable[505910] = ADXAMP_Finish_0x2ee0e0; // 0x2ee0e0 - g_ps2RecompiledFunctionTable[505922] = ADXAMP_Create_0x2ee110; // 0x2ee110 - g_ps2RecompiledFunctionTable[505938] = ADXAMP_Create_0x2ee110; // 0x2ee150 - g_ps2RecompiledFunctionTable[505949] = ADXAMP_Create_0x2ee110; // 0x2ee17c - g_ps2RecompiledFunctionTable[505960] = ADXAMP_Create_0x2ee110; // 0x2ee1a8 - g_ps2RecompiledFunctionTable[505985] = ADXAMP_Create_0x2ee110; // 0x2ee20c - g_ps2RecompiledFunctionTable[505994] = ADXAMP_Destroy_0x2ee230; // 0x2ee230 - g_ps2RecompiledFunctionTable[506001] = ADXAMP_Destroy_0x2ee230; // 0x2ee24c - g_ps2RecompiledFunctionTable[506005] = ADXAMP_Destroy_0x2ee230; // 0x2ee25c - g_ps2RecompiledFunctionTable[506014] = ADXAMP_GetStat_0x2ee280; // 0x2ee280 - g_ps2RecompiledFunctionTable[506016] = ADXAMP_Start_0x2ee288; // 0x2ee288 - g_ps2RecompiledFunctionTable[506020] = ADXAMP_Start_0x2ee288; // 0x2ee298 - g_ps2RecompiledFunctionTable[506032] = ADXAMP_Stop_0x2ee2c8; // 0x2ee2c8 - g_ps2RecompiledFunctionTable[506034] = adxamp_extract_0x2ee2d0; // 0x2ee2d0 - g_ps2RecompiledFunctionTable[506035] = adxamp_extract_0x2ee2d0; // 0x2ee2d4 - g_ps2RecompiledFunctionTable[506036] = adxamp_extract_0x2ee2d0; // 0x2ee2d8 - g_ps2RecompiledFunctionTable[506037] = adxamp_extract_0x2ee2d0; // 0x2ee2dc - g_ps2RecompiledFunctionTable[506038] = adxamp_extract_0x2ee2d0; // 0x2ee2e0 - g_ps2RecompiledFunctionTable[506039] = adxamp_extract_0x2ee2d0; // 0x2ee2e4 - g_ps2RecompiledFunctionTable[506040] = adxamp_extract_0x2ee2d0; // 0x2ee2e8 - g_ps2RecompiledFunctionTable[506041] = adxamp_extract_0x2ee2d0; // 0x2ee2ec - g_ps2RecompiledFunctionTable[506042] = adxamp_extract_0x2ee2d0; // 0x2ee2f0 - g_ps2RecompiledFunctionTable[506043] = adxamp_extract_0x2ee2d0; // 0x2ee2f4 - g_ps2RecompiledFunctionTable[506044] = adxamp_extract_0x2ee2d0; // 0x2ee2f8 - g_ps2RecompiledFunctionTable[506045] = adxamp_extract_0x2ee2d0; // 0x2ee2fc - g_ps2RecompiledFunctionTable[506046] = adxamp_extract_0x2ee2d0; // 0x2ee300 - g_ps2RecompiledFunctionTable[506047] = adxamp_extract_0x2ee2d0; // 0x2ee304 - g_ps2RecompiledFunctionTable[506048] = adxamp_extract_0x2ee2d0; // 0x2ee308 - g_ps2RecompiledFunctionTable[506049] = adxamp_extract_0x2ee2d0; // 0x2ee30c - g_ps2RecompiledFunctionTable[506050] = adxamp_extract_0x2ee2d0; // 0x2ee310 - g_ps2RecompiledFunctionTable[506051] = adxamp_extract_0x2ee2d0; // 0x2ee314 - g_ps2RecompiledFunctionTable[506052] = adxamp_extract_0x2ee2d0; // 0x2ee318 - g_ps2RecompiledFunctionTable[506053] = adxamp_extract_0x2ee2d0; // 0x2ee31c - g_ps2RecompiledFunctionTable[506054] = adxamp_extract_0x2ee2d0; // 0x2ee320 - g_ps2RecompiledFunctionTable[506055] = adxamp_extract_0x2ee2d0; // 0x2ee324 - g_ps2RecompiledFunctionTable[506056] = adxamp_extract_0x2ee2d0; // 0x2ee328 - g_ps2RecompiledFunctionTable[506057] = adxamp_extract_0x2ee2d0; // 0x2ee32c - g_ps2RecompiledFunctionTable[506058] = adxamp_extract_0x2ee2d0; // 0x2ee330 - g_ps2RecompiledFunctionTable[506059] = adxamp_extract_0x2ee2d0; // 0x2ee334 - g_ps2RecompiledFunctionTable[506060] = adxamp_extract_0x2ee2d0; // 0x2ee338 - g_ps2RecompiledFunctionTable[506061] = adxamp_extract_0x2ee2d0; // 0x2ee33c - g_ps2RecompiledFunctionTable[506062] = adxamp_extract_0x2ee2d0; // 0x2ee340 - g_ps2RecompiledFunctionTable[506063] = adxamp_extract_0x2ee2d0; // 0x2ee344 - g_ps2RecompiledFunctionTable[506064] = adxamp_extract_0x2ee2d0; // 0x2ee348 - g_ps2RecompiledFunctionTable[506065] = adxamp_extract_0x2ee2d0; // 0x2ee34c - g_ps2RecompiledFunctionTable[506066] = adxamp_extract_0x2ee2d0; // 0x2ee350 - g_ps2RecompiledFunctionTable[506067] = adxamp_extract_0x2ee2d0; // 0x2ee354 - g_ps2RecompiledFunctionTable[506068] = adxamp_extract_0x2ee2d0; // 0x2ee358 - g_ps2RecompiledFunctionTable[506069] = adxamp_extract_0x2ee2d0; // 0x2ee35c - g_ps2RecompiledFunctionTable[506070] = adxamp_extract_0x2ee2d0; // 0x2ee360 - g_ps2RecompiledFunctionTable[506071] = adxamp_extract_0x2ee2d0; // 0x2ee364 - g_ps2RecompiledFunctionTable[506072] = adxamp_extract_0x2ee2d0; // 0x2ee368 - g_ps2RecompiledFunctionTable[506073] = adxamp_extract_0x2ee2d0; // 0x2ee36c - g_ps2RecompiledFunctionTable[506074] = adxamp_extract_0x2ee2d0; // 0x2ee370 - g_ps2RecompiledFunctionTable[506075] = adxamp_extract_0x2ee2d0; // 0x2ee374 - g_ps2RecompiledFunctionTable[506076] = adxamp_extract_0x2ee2d0; // 0x2ee378 - g_ps2RecompiledFunctionTable[506077] = adxamp_extract_0x2ee2d0; // 0x2ee37c - g_ps2RecompiledFunctionTable[506078] = adxamp_extract_0x2ee2d0; // 0x2ee380 - g_ps2RecompiledFunctionTable[506079] = adxamp_extract_0x2ee2d0; // 0x2ee384 - g_ps2RecompiledFunctionTable[506080] = adxamp_extract_0x2ee2d0; // 0x2ee388 - g_ps2RecompiledFunctionTable[506081] = adxamp_extract_0x2ee2d0; // 0x2ee38c - g_ps2RecompiledFunctionTable[506082] = adxamp_extract_0x2ee2d0; // 0x2ee390 - g_ps2RecompiledFunctionTable[506083] = adxamp_extract_0x2ee2d0; // 0x2ee394 - g_ps2RecompiledFunctionTable[506084] = adxamp_extract_0x2ee2d0; // 0x2ee398 - g_ps2RecompiledFunctionTable[506085] = adxamp_extract_0x2ee2d0; // 0x2ee39c - g_ps2RecompiledFunctionTable[506086] = adxamp_extract_0x2ee2d0; // 0x2ee3a0 - g_ps2RecompiledFunctionTable[506087] = adxamp_extract_0x2ee2d0; // 0x2ee3a4 - g_ps2RecompiledFunctionTable[506088] = adxamp_extract_0x2ee2d0; // 0x2ee3a8 - g_ps2RecompiledFunctionTable[506089] = adxamp_extract_0x2ee2d0; // 0x2ee3ac - g_ps2RecompiledFunctionTable[506090] = adxamp_extract_0x2ee2d0; // 0x2ee3b0 - g_ps2RecompiledFunctionTable[506091] = adxamp_extract_0x2ee2d0; // 0x2ee3b4 - g_ps2RecompiledFunctionTable[506092] = adxamp_extract_0x2ee2d0; // 0x2ee3b8 - g_ps2RecompiledFunctionTable[506093] = adxamp_extract_0x2ee2d0; // 0x2ee3bc - g_ps2RecompiledFunctionTable[506094] = adxamp_extract_0x2ee2d0; // 0x2ee3c0 - g_ps2RecompiledFunctionTable[506095] = adxamp_extract_0x2ee2d0; // 0x2ee3c4 - g_ps2RecompiledFunctionTable[506096] = adxamp_extract_0x2ee2d0; // 0x2ee3c8 - g_ps2RecompiledFunctionTable[506097] = adxamp_extract_0x2ee2d0; // 0x2ee3cc - g_ps2RecompiledFunctionTable[506098] = adxamp_extract_0x2ee2d0; // 0x2ee3d0 - g_ps2RecompiledFunctionTable[506099] = adxamp_extract_0x2ee2d0; // 0x2ee3d4 - g_ps2RecompiledFunctionTable[506100] = adxamp_extract_0x2ee2d0; // 0x2ee3d8 - g_ps2RecompiledFunctionTable[506101] = adxamp_extract_0x2ee2d0; // 0x2ee3dc - g_ps2RecompiledFunctionTable[506102] = adxamp_extract_0x2ee2d0; // 0x2ee3e0 - g_ps2RecompiledFunctionTable[506103] = adxamp_extract_0x2ee2d0; // 0x2ee3e4 - g_ps2RecompiledFunctionTable[506104] = adxamp_extract_0x2ee2d0; // 0x2ee3e8 - g_ps2RecompiledFunctionTable[506105] = adxamp_extract_0x2ee2d0; // 0x2ee3ec - g_ps2RecompiledFunctionTable[506106] = adxamp_extract_0x2ee2d0; // 0x2ee3f0 - g_ps2RecompiledFunctionTable[506107] = adxamp_extract_0x2ee2d0; // 0x2ee3f4 - g_ps2RecompiledFunctionTable[506108] = adxamp_extract_0x2ee2d0; // 0x2ee3f8 - g_ps2RecompiledFunctionTable[506109] = adxamp_extract_0x2ee2d0; // 0x2ee3fc - g_ps2RecompiledFunctionTable[506110] = adxamp_extract_0x2ee2d0; // 0x2ee400 - g_ps2RecompiledFunctionTable[506111] = adxamp_extract_0x2ee2d0; // 0x2ee404 - g_ps2RecompiledFunctionTable[506112] = adxamp_extract_0x2ee2d0; // 0x2ee408 - g_ps2RecompiledFunctionTable[506113] = adxamp_extract_0x2ee2d0; // 0x2ee40c - g_ps2RecompiledFunctionTable[506114] = adxamp_extract_0x2ee2d0; // 0x2ee410 - g_ps2RecompiledFunctionTable[506115] = adxamp_extract_0x2ee2d0; // 0x2ee414 - g_ps2RecompiledFunctionTable[506116] = adxamp_extract_0x2ee2d0; // 0x2ee418 - g_ps2RecompiledFunctionTable[506117] = adxamp_extract_0x2ee2d0; // 0x2ee41c - g_ps2RecompiledFunctionTable[506118] = adxamp_extract_0x2ee2d0; // 0x2ee420 - g_ps2RecompiledFunctionTable[506119] = adxamp_extract_0x2ee2d0; // 0x2ee424 - g_ps2RecompiledFunctionTable[506120] = adxamp_extract_0x2ee2d0; // 0x2ee428 - g_ps2RecompiledFunctionTable[506121] = adxamp_extract_0x2ee2d0; // 0x2ee42c - g_ps2RecompiledFunctionTable[506122] = adxamp_extract_0x2ee2d0; // 0x2ee430 - g_ps2RecompiledFunctionTable[506123] = adxamp_extract_0x2ee2d0; // 0x2ee434 - g_ps2RecompiledFunctionTable[506124] = adxamp_extract_0x2ee2d0; // 0x2ee438 - g_ps2RecompiledFunctionTable[506125] = adxamp_extract_0x2ee2d0; // 0x2ee43c - g_ps2RecompiledFunctionTable[506126] = adxamp_extract_0x2ee2d0; // 0x2ee440 - g_ps2RecompiledFunctionTable[506127] = adxamp_extract_0x2ee2d0; // 0x2ee444 - g_ps2RecompiledFunctionTable[506128] = adxamp_extract_0x2ee2d0; // 0x2ee448 - g_ps2RecompiledFunctionTable[506129] = adxamp_extract_0x2ee2d0; // 0x2ee44c - g_ps2RecompiledFunctionTable[506130] = adxamp_extract_0x2ee2d0; // 0x2ee450 - g_ps2RecompiledFunctionTable[506131] = adxamp_extract_0x2ee2d0; // 0x2ee454 - g_ps2RecompiledFunctionTable[506132] = adxamp_extract_0x2ee2d0; // 0x2ee458 - g_ps2RecompiledFunctionTable[506133] = adxamp_extract_0x2ee2d0; // 0x2ee45c - g_ps2RecompiledFunctionTable[506134] = adxamp_extract_0x2ee2d0; // 0x2ee460 - g_ps2RecompiledFunctionTable[506135] = adxamp_extract_0x2ee2d0; // 0x2ee464 - g_ps2RecompiledFunctionTable[506136] = adxamp_extract_0x2ee2d0; // 0x2ee468 - g_ps2RecompiledFunctionTable[506137] = adxamp_extract_0x2ee2d0; // 0x2ee46c - g_ps2RecompiledFunctionTable[506138] = adxamp_extract_0x2ee2d0; // 0x2ee470 - g_ps2RecompiledFunctionTable[506139] = adxamp_extract_0x2ee2d0; // 0x2ee474 - g_ps2RecompiledFunctionTable[506140] = adxamp_extract_0x2ee2d0; // 0x2ee478 - g_ps2RecompiledFunctionTable[506141] = adxamp_extract_0x2ee2d0; // 0x2ee47c - g_ps2RecompiledFunctionTable[506142] = adxamp_extract_0x2ee2d0; // 0x2ee480 - g_ps2RecompiledFunctionTable[506143] = adxamp_extract_0x2ee2d0; // 0x2ee484 - g_ps2RecompiledFunctionTable[506144] = adxamp_extract_0x2ee2d0; // 0x2ee488 - g_ps2RecompiledFunctionTable[506145] = adxamp_extract_0x2ee2d0; // 0x2ee48c - g_ps2RecompiledFunctionTable[506146] = adxamp_extract_0x2ee2d0; // 0x2ee490 - g_ps2RecompiledFunctionTable[506147] = adxamp_extract_0x2ee2d0; // 0x2ee494 - g_ps2RecompiledFunctionTable[506148] = adxamp_extract_0x2ee2d0; // 0x2ee498 - g_ps2RecompiledFunctionTable[506149] = adxamp_extract_0x2ee2d0; // 0x2ee49c - g_ps2RecompiledFunctionTable[506150] = adxamp_extract_0x2ee2d0; // 0x2ee4a0 - g_ps2RecompiledFunctionTable[506151] = adxamp_extract_0x2ee2d0; // 0x2ee4a4 - g_ps2RecompiledFunctionTable[506152] = adxamp_extract_0x2ee2d0; // 0x2ee4a8 - g_ps2RecompiledFunctionTable[506153] = adxamp_extract_0x2ee2d0; // 0x2ee4ac - g_ps2RecompiledFunctionTable[506154] = adxamp_extract_0x2ee2d0; // 0x2ee4b0 - g_ps2RecompiledFunctionTable[506155] = adxamp_extract_0x2ee2d0; // 0x2ee4b4 - g_ps2RecompiledFunctionTable[506156] = adxamp_extract_0x2ee2d0; // 0x2ee4b8 - g_ps2RecompiledFunctionTable[506157] = adxamp_extract_0x2ee2d0; // 0x2ee4bc - g_ps2RecompiledFunctionTable[506158] = adxamp_extract_0x2ee2d0; // 0x2ee4c0 - g_ps2RecompiledFunctionTable[506159] = adxamp_extract_0x2ee2d0; // 0x2ee4c4 - g_ps2RecompiledFunctionTable[506160] = adxamp_extract_0x2ee2d0; // 0x2ee4c8 - g_ps2RecompiledFunctionTable[506161] = adxamp_extract_0x2ee2d0; // 0x2ee4cc - g_ps2RecompiledFunctionTable[506162] = adxamp_extract_0x2ee2d0; // 0x2ee4d0 - g_ps2RecompiledFunctionTable[506163] = adxamp_extract_0x2ee2d0; // 0x2ee4d4 - g_ps2RecompiledFunctionTable[506164] = adxamp_extract_0x2ee2d0; // 0x2ee4d8 - g_ps2RecompiledFunctionTable[506165] = adxamp_extract_0x2ee2d0; // 0x2ee4dc - g_ps2RecompiledFunctionTable[506166] = adxamp_extract_0x2ee2d0; // 0x2ee4e0 - g_ps2RecompiledFunctionTable[506167] = adxamp_extract_0x2ee2d0; // 0x2ee4e4 - g_ps2RecompiledFunctionTable[506168] = adxamp_extract_0x2ee2d0; // 0x2ee4e8 - g_ps2RecompiledFunctionTable[506169] = adxamp_extract_0x2ee2d0; // 0x2ee4ec - g_ps2RecompiledFunctionTable[506170] = adxamp_extract_0x2ee2d0; // 0x2ee4f0 - g_ps2RecompiledFunctionTable[506171] = adxamp_extract_0x2ee2d0; // 0x2ee4f4 - g_ps2RecompiledFunctionTable[506172] = adxamp_extract_0x2ee2d0; // 0x2ee4f8 - g_ps2RecompiledFunctionTable[506173] = adxamp_extract_0x2ee2d0; // 0x2ee4fc - g_ps2RecompiledFunctionTable[506174] = adxamp_extract_0x2ee2d0; // 0x2ee500 - g_ps2RecompiledFunctionTable[506175] = adxamp_extract_0x2ee2d0; // 0x2ee504 - g_ps2RecompiledFunctionTable[506176] = adxamp_extract_0x2ee2d0; // 0x2ee508 - g_ps2RecompiledFunctionTable[506177] = adxamp_extract_0x2ee2d0; // 0x2ee50c - g_ps2RecompiledFunctionTable[506178] = adxamp_extract_0x2ee2d0; // 0x2ee510 - g_ps2RecompiledFunctionTable[506179] = adxamp_extract_0x2ee2d0; // 0x2ee514 - g_ps2RecompiledFunctionTable[506180] = adxamp_extract_0x2ee2d0; // 0x2ee518 - g_ps2RecompiledFunctionTable[506181] = adxamp_extract_0x2ee2d0; // 0x2ee51c - g_ps2RecompiledFunctionTable[506182] = adxamp_extract_0x2ee2d0; // 0x2ee520 - g_ps2RecompiledFunctionTable[506183] = adxamp_extract_0x2ee2d0; // 0x2ee524 - g_ps2RecompiledFunctionTable[506184] = adxamp_extract_0x2ee2d0; // 0x2ee528 - g_ps2RecompiledFunctionTable[506185] = adxamp_extract_0x2ee2d0; // 0x2ee52c - g_ps2RecompiledFunctionTable[506186] = adxamp_extract_0x2ee2d0; // 0x2ee530 - g_ps2RecompiledFunctionTable[506187] = adxamp_extract_0x2ee2d0; // 0x2ee534 - g_ps2RecompiledFunctionTable[506188] = adxamp_extract_0x2ee2d0; // 0x2ee538 - g_ps2RecompiledFunctionTable[506189] = adxamp_extract_0x2ee2d0; // 0x2ee53c - g_ps2RecompiledFunctionTable[506190] = adxamp_extract_0x2ee2d0; // 0x2ee540 - g_ps2RecompiledFunctionTable[506191] = adxamp_extract_0x2ee2d0; // 0x2ee544 - g_ps2RecompiledFunctionTable[506192] = adxamp_extract_0x2ee2d0; // 0x2ee548 - g_ps2RecompiledFunctionTable[506193] = adxamp_extract_0x2ee2d0; // 0x2ee54c - g_ps2RecompiledFunctionTable[506194] = adxamp_extract_0x2ee2d0; // 0x2ee550 - g_ps2RecompiledFunctionTable[506195] = adxamp_extract_0x2ee2d0; // 0x2ee554 - g_ps2RecompiledFunctionTable[506196] = adxamp_extract_0x2ee2d0; // 0x2ee558 - g_ps2RecompiledFunctionTable[506197] = adxamp_extract_0x2ee2d0; // 0x2ee55c - g_ps2RecompiledFunctionTable[506198] = adxamp_extract_0x2ee2d0; // 0x2ee560 - g_ps2RecompiledFunctionTable[506199] = adxamp_extract_0x2ee2d0; // 0x2ee564 - g_ps2RecompiledFunctionTable[506200] = adxamp_extract_0x2ee2d0; // 0x2ee568 - g_ps2RecompiledFunctionTable[506202] = ADXAMP_ExecHndl_0x2ee570; // 0x2ee570 - g_ps2RecompiledFunctionTable[506210] = ADXAMP_ExecServer_0x2ee590; // 0x2ee590 - g_ps2RecompiledFunctionTable[506220] = ADXAMP_ExecServer_0x2ee590; // 0x2ee5b8 - g_ps2RecompiledFunctionTable[506224] = ADXAMP_ExecServer_0x2ee590; // 0x2ee5c8 - g_ps2RecompiledFunctionTable[506234] = ADXAMP_GetExtractNumSmpl_0x2ee5f0; // 0x2ee5f0 - g_ps2RecompiledFunctionTable[506236] = ADXAMP_SetSfreq_0x2ee5f8; // 0x2ee5f8 - g_ps2RecompiledFunctionTable[506238] = ADXAMP_GetSfreq_0x2ee600; // 0x2ee600 - g_ps2RecompiledFunctionTable[506240] = ADXAMP_SetFrmLen_0x2ee608; // 0x2ee608 - g_ps2RecompiledFunctionTable[506242] = ADXAMP_GetFrmLen_0x2ee610; // 0x2ee610 - g_ps2RecompiledFunctionTable[506244] = ADXAMP_SetFrmPrd_0x2ee618; // 0x2ee618 - g_ps2RecompiledFunctionTable[506246] = ADXAMP_GetFrmPrd_0x2ee620; // 0x2ee620 - g_ps2RecompiledFunctionTable[506248] = AIFF_GetInfo_0x2ee628; // 0x2ee628 - g_ps2RecompiledFunctionTable[506313] = AIFF_GetInfo_0x2ee628; // 0x2ee72c - g_ps2RecompiledFunctionTable[506322] = AIFF_GetInfo_0x2ee628; // 0x2ee750 - g_ps2RecompiledFunctionTable[506470] = ADXB_CheckAiff_0x2ee9a0; // 0x2ee9a0 - g_ps2RecompiledFunctionTable[506478] = ADXB_CheckAiff_0x2ee9a0; // 0x2ee9c0 - g_ps2RecompiledFunctionTable[506485] = ADXB_CheckAiff_0x2ee9a0; // 0x2ee9dc - g_ps2RecompiledFunctionTable[506494] = ADX_DecodeInfoAiff_0x2eea00; // 0x2eea00 - g_ps2RecompiledFunctionTable[506513] = ADX_DecodeInfoAiff_0x2eea00; // 0x2eea4c - g_ps2RecompiledFunctionTable[506521] = ADX_DecodeInfoAiff_0x2eea00; // 0x2eea6c - g_ps2RecompiledFunctionTable[506560] = ADXB_DecodeHeaderAiff_0x2eeb08; // 0x2eeb08 - g_ps2RecompiledFunctionTable[506580] = ADXB_DecodeHeaderAiff_0x2eeb08; // 0x2eeb58 - g_ps2RecompiledFunctionTable[506623] = ADXB_DecodeHeaderAiff_0x2eeb08; // 0x2eec04 - g_ps2RecompiledFunctionTable[506630] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eec20 - g_ps2RecompiledFunctionTable[506631] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eec24 - g_ps2RecompiledFunctionTable[506632] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eec28 - g_ps2RecompiledFunctionTable[506633] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eec2c - g_ps2RecompiledFunctionTable[506634] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eec30 - g_ps2RecompiledFunctionTable[506635] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eec34 - g_ps2RecompiledFunctionTable[506636] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eec38 - g_ps2RecompiledFunctionTable[506637] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eec3c - g_ps2RecompiledFunctionTable[506638] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eec40 - g_ps2RecompiledFunctionTable[506639] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eec44 - g_ps2RecompiledFunctionTable[506640] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eec48 - g_ps2RecompiledFunctionTable[506641] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eec4c - g_ps2RecompiledFunctionTable[506642] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eec50 - g_ps2RecompiledFunctionTable[506643] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eec54 - g_ps2RecompiledFunctionTable[506644] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eec58 - g_ps2RecompiledFunctionTable[506645] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eec5c - g_ps2RecompiledFunctionTable[506646] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eec60 - g_ps2RecompiledFunctionTable[506647] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eec64 - g_ps2RecompiledFunctionTable[506648] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eec68 - g_ps2RecompiledFunctionTable[506649] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eec6c - g_ps2RecompiledFunctionTable[506650] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eec70 - g_ps2RecompiledFunctionTable[506651] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eec74 - g_ps2RecompiledFunctionTable[506652] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eec78 - g_ps2RecompiledFunctionTable[506653] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eec7c - g_ps2RecompiledFunctionTable[506654] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eec80 - g_ps2RecompiledFunctionTable[506655] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eec84 - g_ps2RecompiledFunctionTable[506656] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eec88 - g_ps2RecompiledFunctionTable[506657] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eec8c - g_ps2RecompiledFunctionTable[506658] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eec90 - g_ps2RecompiledFunctionTable[506659] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eec94 - g_ps2RecompiledFunctionTable[506660] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eec98 - g_ps2RecompiledFunctionTable[506661] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eec9c - g_ps2RecompiledFunctionTable[506662] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eeca0 - g_ps2RecompiledFunctionTable[506663] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eeca4 - g_ps2RecompiledFunctionTable[506664] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eeca8 - g_ps2RecompiledFunctionTable[506665] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eecac - g_ps2RecompiledFunctionTable[506666] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eecb0 - g_ps2RecompiledFunctionTable[506667] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eecb4 - g_ps2RecompiledFunctionTable[506668] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eecb8 - g_ps2RecompiledFunctionTable[506669] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eecbc - g_ps2RecompiledFunctionTable[506670] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eecc0 - g_ps2RecompiledFunctionTable[506671] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eecc4 - g_ps2RecompiledFunctionTable[506672] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eecc8 - g_ps2RecompiledFunctionTable[506673] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eeccc - g_ps2RecompiledFunctionTable[506674] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eecd0 - g_ps2RecompiledFunctionTable[506675] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eecd4 - g_ps2RecompiledFunctionTable[506676] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eecd8 - g_ps2RecompiledFunctionTable[506677] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eecdc - g_ps2RecompiledFunctionTable[506678] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eece0 - g_ps2RecompiledFunctionTable[506679] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eece4 - g_ps2RecompiledFunctionTable[506680] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eece8 - g_ps2RecompiledFunctionTable[506681] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eecec - g_ps2RecompiledFunctionTable[506682] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eecf0 - g_ps2RecompiledFunctionTable[506683] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eecf4 - g_ps2RecompiledFunctionTable[506684] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eecf8 - g_ps2RecompiledFunctionTable[506685] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eecfc - g_ps2RecompiledFunctionTable[506686] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eed00 - g_ps2RecompiledFunctionTable[506687] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eed04 - g_ps2RecompiledFunctionTable[506688] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eed08 - g_ps2RecompiledFunctionTable[506689] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eed0c - g_ps2RecompiledFunctionTable[506690] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eed10 - g_ps2RecompiledFunctionTable[506691] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eed14 - g_ps2RecompiledFunctionTable[506692] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eed18 - g_ps2RecompiledFunctionTable[506693] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eed1c - g_ps2RecompiledFunctionTable[506694] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eed20 - g_ps2RecompiledFunctionTable[506695] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eed24 - g_ps2RecompiledFunctionTable[506696] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eed28 - g_ps2RecompiledFunctionTable[506697] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eed2c - g_ps2RecompiledFunctionTable[506698] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eed30 - g_ps2RecompiledFunctionTable[506699] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eed34 - g_ps2RecompiledFunctionTable[506700] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eed38 - g_ps2RecompiledFunctionTable[506701] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eed3c - g_ps2RecompiledFunctionTable[506702] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eed40 - g_ps2RecompiledFunctionTable[506703] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eed44 - g_ps2RecompiledFunctionTable[506704] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eed48 - g_ps2RecompiledFunctionTable[506705] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eed4c - g_ps2RecompiledFunctionTable[506706] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eed50 - g_ps2RecompiledFunctionTable[506707] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eed54 - g_ps2RecompiledFunctionTable[506708] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eed58 - g_ps2RecompiledFunctionTable[506709] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eed5c - g_ps2RecompiledFunctionTable[506710] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eed60 - g_ps2RecompiledFunctionTable[506711] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eed64 - g_ps2RecompiledFunctionTable[506712] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eed68 - g_ps2RecompiledFunctionTable[506713] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eed6c - g_ps2RecompiledFunctionTable[506714] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eed70 - g_ps2RecompiledFunctionTable[506715] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eed74 - g_ps2RecompiledFunctionTable[506716] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eed78 - g_ps2RecompiledFunctionTable[506717] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eed7c - g_ps2RecompiledFunctionTable[506718] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eed80 - g_ps2RecompiledFunctionTable[506719] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eed84 - g_ps2RecompiledFunctionTable[506720] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eed88 - g_ps2RecompiledFunctionTable[506721] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eed8c - g_ps2RecompiledFunctionTable[506722] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eed90 - g_ps2RecompiledFunctionTable[506723] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eed94 - g_ps2RecompiledFunctionTable[506724] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eed98 - g_ps2RecompiledFunctionTable[506725] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eed9c - g_ps2RecompiledFunctionTable[506726] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eeda0 - g_ps2RecompiledFunctionTable[506727] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eeda4 - g_ps2RecompiledFunctionTable[506728] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eeda8 - g_ps2RecompiledFunctionTable[506729] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eedac - g_ps2RecompiledFunctionTable[506730] = ADXB_ExecOneAiff16_0x2eec20; // 0x2eedb0 - g_ps2RecompiledFunctionTable[506732] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eedb8 - g_ps2RecompiledFunctionTable[506733] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eedbc - g_ps2RecompiledFunctionTable[506734] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eedc0 - g_ps2RecompiledFunctionTable[506735] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eedc4 - g_ps2RecompiledFunctionTable[506736] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eedc8 - g_ps2RecompiledFunctionTable[506737] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eedcc - g_ps2RecompiledFunctionTable[506738] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eedd0 - g_ps2RecompiledFunctionTable[506739] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eedd4 - g_ps2RecompiledFunctionTable[506740] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eedd8 - g_ps2RecompiledFunctionTable[506741] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eeddc - g_ps2RecompiledFunctionTable[506742] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eede0 - g_ps2RecompiledFunctionTable[506743] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eede4 - g_ps2RecompiledFunctionTable[506744] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eede8 - g_ps2RecompiledFunctionTable[506745] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eedec - g_ps2RecompiledFunctionTable[506746] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eedf0 - g_ps2RecompiledFunctionTable[506747] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eedf4 - g_ps2RecompiledFunctionTable[506748] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eedf8 - g_ps2RecompiledFunctionTable[506749] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eedfc - g_ps2RecompiledFunctionTable[506750] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eee00 - g_ps2RecompiledFunctionTable[506751] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eee04 - g_ps2RecompiledFunctionTable[506752] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eee08 - g_ps2RecompiledFunctionTable[506753] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eee0c - g_ps2RecompiledFunctionTable[506754] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eee10 - g_ps2RecompiledFunctionTable[506755] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eee14 - g_ps2RecompiledFunctionTable[506756] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eee18 - g_ps2RecompiledFunctionTable[506757] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eee1c - g_ps2RecompiledFunctionTable[506758] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eee20 - g_ps2RecompiledFunctionTable[506759] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eee24 - g_ps2RecompiledFunctionTable[506760] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eee28 - g_ps2RecompiledFunctionTable[506761] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eee2c - g_ps2RecompiledFunctionTable[506762] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eee30 - g_ps2RecompiledFunctionTable[506763] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eee34 - g_ps2RecompiledFunctionTable[506764] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eee38 - g_ps2RecompiledFunctionTable[506765] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eee3c - g_ps2RecompiledFunctionTable[506766] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eee40 - g_ps2RecompiledFunctionTable[506767] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eee44 - g_ps2RecompiledFunctionTable[506768] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eee48 - g_ps2RecompiledFunctionTable[506769] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eee4c - g_ps2RecompiledFunctionTable[506770] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eee50 - g_ps2RecompiledFunctionTable[506771] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eee54 - g_ps2RecompiledFunctionTable[506772] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eee58 - g_ps2RecompiledFunctionTable[506773] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eee5c - g_ps2RecompiledFunctionTable[506774] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eee60 - g_ps2RecompiledFunctionTable[506775] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eee64 - g_ps2RecompiledFunctionTable[506776] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eee68 - g_ps2RecompiledFunctionTable[506777] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eee6c - g_ps2RecompiledFunctionTable[506778] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eee70 - g_ps2RecompiledFunctionTable[506779] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eee74 - g_ps2RecompiledFunctionTable[506780] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eee78 - g_ps2RecompiledFunctionTable[506781] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eee7c - g_ps2RecompiledFunctionTable[506782] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eee80 - g_ps2RecompiledFunctionTable[506783] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eee84 - g_ps2RecompiledFunctionTable[506784] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eee88 - g_ps2RecompiledFunctionTable[506785] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eee8c - g_ps2RecompiledFunctionTable[506786] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eee90 - g_ps2RecompiledFunctionTable[506787] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eee94 - g_ps2RecompiledFunctionTable[506788] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eee98 - g_ps2RecompiledFunctionTable[506789] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eee9c - g_ps2RecompiledFunctionTable[506790] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eeea0 - g_ps2RecompiledFunctionTable[506791] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eeea4 - g_ps2RecompiledFunctionTable[506792] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eeea8 - g_ps2RecompiledFunctionTable[506793] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eeeac - g_ps2RecompiledFunctionTable[506794] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eeeb0 - g_ps2RecompiledFunctionTable[506795] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eeeb4 - g_ps2RecompiledFunctionTable[506796] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eeeb8 - g_ps2RecompiledFunctionTable[506797] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eeebc - g_ps2RecompiledFunctionTable[506798] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eeec0 - g_ps2RecompiledFunctionTable[506799] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eeec4 - g_ps2RecompiledFunctionTable[506800] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eeec8 - g_ps2RecompiledFunctionTable[506801] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eeecc - g_ps2RecompiledFunctionTable[506802] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eeed0 - g_ps2RecompiledFunctionTable[506803] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eeed4 - g_ps2RecompiledFunctionTable[506804] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eeed8 - g_ps2RecompiledFunctionTable[506805] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eeedc - g_ps2RecompiledFunctionTable[506806] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eeee0 - g_ps2RecompiledFunctionTable[506807] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eeee4 - g_ps2RecompiledFunctionTable[506808] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eeee8 - g_ps2RecompiledFunctionTable[506809] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eeeec - g_ps2RecompiledFunctionTable[506810] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eeef0 - g_ps2RecompiledFunctionTable[506811] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eeef4 - g_ps2RecompiledFunctionTable[506812] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eeef8 - g_ps2RecompiledFunctionTable[506813] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eeefc - g_ps2RecompiledFunctionTable[506814] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eef00 - g_ps2RecompiledFunctionTable[506815] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eef04 - g_ps2RecompiledFunctionTable[506816] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eef08 - g_ps2RecompiledFunctionTable[506817] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eef0c - g_ps2RecompiledFunctionTable[506818] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eef10 - g_ps2RecompiledFunctionTable[506819] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eef14 - g_ps2RecompiledFunctionTable[506820] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eef18 - g_ps2RecompiledFunctionTable[506821] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eef1c - g_ps2RecompiledFunctionTable[506822] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eef20 - g_ps2RecompiledFunctionTable[506823] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eef24 - g_ps2RecompiledFunctionTable[506824] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eef28 - g_ps2RecompiledFunctionTable[506825] = ADXB_ExecOneAiff8_0x2eedb8; // 0x2eef2c - g_ps2RecompiledFunctionTable[506826] = ADXB_ExecOneAiff_0x2eef30; // 0x2eef30 - g_ps2RecompiledFunctionTable[506834] = AU_GetInfo_0x2eef50; // 0x2eef50 - g_ps2RecompiledFunctionTable[507030] = ADXB_CheckAu_0x2ef260; // 0x2ef260 - g_ps2RecompiledFunctionTable[507038] = ADXB_CheckAu_0x2ef260; // 0x2ef280 - g_ps2RecompiledFunctionTable[507044] = ADXB_CheckAu_0x2ef260; // 0x2ef298 - g_ps2RecompiledFunctionTable[507052] = ADX_DecodeInfoAu_0x2ef2b8; // 0x2ef2b8 - g_ps2RecompiledFunctionTable[507071] = ADX_DecodeInfoAu_0x2ef2b8; // 0x2ef304 - g_ps2RecompiledFunctionTable[507080] = ADX_DecodeInfoAu_0x2ef2b8; // 0x2ef328 - g_ps2RecompiledFunctionTable[507120] = ADXB_DecodeHeaderAu_0x2ef3c8; // 0x2ef3c8 - g_ps2RecompiledFunctionTable[507141] = ADXB_DecodeHeaderAu_0x2ef3c8; // 0x2ef41c - g_ps2RecompiledFunctionTable[507180] = ADXB_DecodeHeaderAu_0x2ef3c8; // 0x2ef4b8 - g_ps2RecompiledFunctionTable[507186] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef4d0 - g_ps2RecompiledFunctionTable[507187] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef4d4 - g_ps2RecompiledFunctionTable[507188] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef4d8 - g_ps2RecompiledFunctionTable[507189] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef4dc - g_ps2RecompiledFunctionTable[507190] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef4e0 - g_ps2RecompiledFunctionTable[507191] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef4e4 - g_ps2RecompiledFunctionTable[507192] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef4e8 - g_ps2RecompiledFunctionTable[507193] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef4ec - g_ps2RecompiledFunctionTable[507194] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef4f0 - g_ps2RecompiledFunctionTable[507195] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef4f4 - g_ps2RecompiledFunctionTable[507196] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef4f8 - g_ps2RecompiledFunctionTable[507197] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef4fc - g_ps2RecompiledFunctionTable[507198] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef500 - g_ps2RecompiledFunctionTable[507199] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef504 - g_ps2RecompiledFunctionTable[507200] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef508 - g_ps2RecompiledFunctionTable[507201] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef50c - g_ps2RecompiledFunctionTable[507202] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef510 - g_ps2RecompiledFunctionTable[507203] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef514 - g_ps2RecompiledFunctionTable[507204] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef518 - g_ps2RecompiledFunctionTable[507205] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef51c - g_ps2RecompiledFunctionTable[507206] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef520 - g_ps2RecompiledFunctionTable[507207] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef524 - g_ps2RecompiledFunctionTable[507208] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef528 - g_ps2RecompiledFunctionTable[507209] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef52c - g_ps2RecompiledFunctionTable[507210] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef530 - g_ps2RecompiledFunctionTable[507211] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef534 - g_ps2RecompiledFunctionTable[507212] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef538 - g_ps2RecompiledFunctionTable[507213] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef53c - g_ps2RecompiledFunctionTable[507214] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef540 - g_ps2RecompiledFunctionTable[507215] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef544 - g_ps2RecompiledFunctionTable[507216] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef548 - g_ps2RecompiledFunctionTable[507217] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef54c - g_ps2RecompiledFunctionTable[507218] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef550 - g_ps2RecompiledFunctionTable[507219] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef554 - g_ps2RecompiledFunctionTable[507220] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef558 - g_ps2RecompiledFunctionTable[507221] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef55c - g_ps2RecompiledFunctionTable[507222] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef560 - g_ps2RecompiledFunctionTable[507223] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef564 - g_ps2RecompiledFunctionTable[507224] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef568 - g_ps2RecompiledFunctionTable[507225] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef56c - g_ps2RecompiledFunctionTable[507226] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef570 - g_ps2RecompiledFunctionTable[507227] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef574 - g_ps2RecompiledFunctionTable[507228] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef578 - g_ps2RecompiledFunctionTable[507229] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef57c - g_ps2RecompiledFunctionTable[507230] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef580 - g_ps2RecompiledFunctionTable[507231] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef584 - g_ps2RecompiledFunctionTable[507232] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef588 - g_ps2RecompiledFunctionTable[507233] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef58c - g_ps2RecompiledFunctionTable[507234] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef590 - g_ps2RecompiledFunctionTable[507235] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef594 - g_ps2RecompiledFunctionTable[507236] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef598 - g_ps2RecompiledFunctionTable[507237] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef59c - g_ps2RecompiledFunctionTable[507238] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef5a0 - g_ps2RecompiledFunctionTable[507239] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef5a4 - g_ps2RecompiledFunctionTable[507240] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef5a8 - g_ps2RecompiledFunctionTable[507241] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef5ac - g_ps2RecompiledFunctionTable[507242] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef5b0 - g_ps2RecompiledFunctionTable[507243] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef5b4 - g_ps2RecompiledFunctionTable[507244] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef5b8 - g_ps2RecompiledFunctionTable[507245] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef5bc - g_ps2RecompiledFunctionTable[507246] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef5c0 - g_ps2RecompiledFunctionTable[507247] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef5c4 - g_ps2RecompiledFunctionTable[507248] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef5c8 - g_ps2RecompiledFunctionTable[507249] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef5cc - g_ps2RecompiledFunctionTable[507250] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef5d0 - g_ps2RecompiledFunctionTable[507251] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef5d4 - g_ps2RecompiledFunctionTable[507252] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef5d8 - g_ps2RecompiledFunctionTable[507253] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef5dc - g_ps2RecompiledFunctionTable[507254] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef5e0 - g_ps2RecompiledFunctionTable[507255] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef5e4 - g_ps2RecompiledFunctionTable[507256] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef5e8 - g_ps2RecompiledFunctionTable[507257] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef5ec - g_ps2RecompiledFunctionTable[507258] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef5f0 - g_ps2RecompiledFunctionTable[507259] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef5f4 - g_ps2RecompiledFunctionTable[507260] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef5f8 - g_ps2RecompiledFunctionTable[507261] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef5fc - g_ps2RecompiledFunctionTable[507262] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef600 - g_ps2RecompiledFunctionTable[507263] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef604 - g_ps2RecompiledFunctionTable[507264] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef608 - g_ps2RecompiledFunctionTable[507265] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef60c - g_ps2RecompiledFunctionTable[507266] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef610 - g_ps2RecompiledFunctionTable[507267] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef614 - g_ps2RecompiledFunctionTable[507268] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef618 - g_ps2RecompiledFunctionTable[507269] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef61c - g_ps2RecompiledFunctionTable[507270] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef620 - g_ps2RecompiledFunctionTable[507271] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef624 - g_ps2RecompiledFunctionTable[507272] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef628 - g_ps2RecompiledFunctionTable[507273] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef62c - g_ps2RecompiledFunctionTable[507274] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef630 - g_ps2RecompiledFunctionTable[507275] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef634 - g_ps2RecompiledFunctionTable[507276] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef638 - g_ps2RecompiledFunctionTable[507277] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef63c - g_ps2RecompiledFunctionTable[507278] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef640 - g_ps2RecompiledFunctionTable[507279] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef644 - g_ps2RecompiledFunctionTable[507280] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef648 - g_ps2RecompiledFunctionTable[507281] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef64c - g_ps2RecompiledFunctionTable[507282] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef650 - g_ps2RecompiledFunctionTable[507283] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef654 - g_ps2RecompiledFunctionTable[507284] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef658 - g_ps2RecompiledFunctionTable[507285] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef65c - g_ps2RecompiledFunctionTable[507286] = ADXB_ExecOneAu16_0x2ef4d0; // 0x2ef660 - g_ps2RecompiledFunctionTable[507288] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef668 - g_ps2RecompiledFunctionTable[507289] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef66c - g_ps2RecompiledFunctionTable[507290] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef670 - g_ps2RecompiledFunctionTable[507291] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef674 - g_ps2RecompiledFunctionTable[507292] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef678 - g_ps2RecompiledFunctionTable[507293] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef67c - g_ps2RecompiledFunctionTable[507294] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef680 - g_ps2RecompiledFunctionTable[507295] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef684 - g_ps2RecompiledFunctionTable[507296] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef688 - g_ps2RecompiledFunctionTable[507297] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef68c - g_ps2RecompiledFunctionTable[507298] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef690 - g_ps2RecompiledFunctionTable[507299] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef694 - g_ps2RecompiledFunctionTable[507300] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef698 - g_ps2RecompiledFunctionTable[507301] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef69c - g_ps2RecompiledFunctionTable[507302] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef6a0 - g_ps2RecompiledFunctionTable[507303] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef6a4 - g_ps2RecompiledFunctionTable[507304] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef6a8 - g_ps2RecompiledFunctionTable[507305] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef6ac - g_ps2RecompiledFunctionTable[507306] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef6b0 - g_ps2RecompiledFunctionTable[507307] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef6b4 - g_ps2RecompiledFunctionTable[507308] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef6b8 - g_ps2RecompiledFunctionTable[507309] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef6bc - g_ps2RecompiledFunctionTable[507310] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef6c0 - g_ps2RecompiledFunctionTable[507311] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef6c4 - g_ps2RecompiledFunctionTable[507312] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef6c8 - g_ps2RecompiledFunctionTable[507313] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef6cc - g_ps2RecompiledFunctionTable[507314] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef6d0 - g_ps2RecompiledFunctionTable[507315] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef6d4 - g_ps2RecompiledFunctionTable[507316] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef6d8 - g_ps2RecompiledFunctionTable[507317] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef6dc - g_ps2RecompiledFunctionTable[507318] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef6e0 - g_ps2RecompiledFunctionTable[507319] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef6e4 - g_ps2RecompiledFunctionTable[507320] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef6e8 - g_ps2RecompiledFunctionTable[507321] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef6ec - g_ps2RecompiledFunctionTable[507322] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef6f0 - g_ps2RecompiledFunctionTable[507323] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef6f4 - g_ps2RecompiledFunctionTable[507324] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef6f8 - g_ps2RecompiledFunctionTable[507325] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef6fc - g_ps2RecompiledFunctionTable[507326] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef700 - g_ps2RecompiledFunctionTable[507327] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef704 - g_ps2RecompiledFunctionTable[507328] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef708 - g_ps2RecompiledFunctionTable[507329] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef70c - g_ps2RecompiledFunctionTable[507330] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef710 - g_ps2RecompiledFunctionTable[507331] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef714 - g_ps2RecompiledFunctionTable[507332] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef718 - g_ps2RecompiledFunctionTable[507333] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef71c - g_ps2RecompiledFunctionTable[507334] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef720 - g_ps2RecompiledFunctionTable[507335] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef724 - g_ps2RecompiledFunctionTable[507336] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef728 - g_ps2RecompiledFunctionTable[507337] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef72c - g_ps2RecompiledFunctionTable[507338] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef730 - g_ps2RecompiledFunctionTable[507339] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef734 - g_ps2RecompiledFunctionTable[507340] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef738 - g_ps2RecompiledFunctionTable[507341] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef73c - g_ps2RecompiledFunctionTable[507342] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef740 - g_ps2RecompiledFunctionTable[507343] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef744 - g_ps2RecompiledFunctionTable[507344] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef748 - g_ps2RecompiledFunctionTable[507345] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef74c - g_ps2RecompiledFunctionTable[507346] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef750 - g_ps2RecompiledFunctionTable[507347] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef754 - g_ps2RecompiledFunctionTable[507348] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef758 - g_ps2RecompiledFunctionTable[507349] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef75c - g_ps2RecompiledFunctionTable[507350] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef760 - g_ps2RecompiledFunctionTable[507351] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef764 - g_ps2RecompiledFunctionTable[507352] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef768 - g_ps2RecompiledFunctionTable[507353] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef76c - g_ps2RecompiledFunctionTable[507354] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef770 - g_ps2RecompiledFunctionTable[507355] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef774 - g_ps2RecompiledFunctionTable[507356] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef778 - g_ps2RecompiledFunctionTable[507357] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef77c - g_ps2RecompiledFunctionTable[507358] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef780 - g_ps2RecompiledFunctionTable[507359] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef784 - g_ps2RecompiledFunctionTable[507360] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef788 - g_ps2RecompiledFunctionTable[507361] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef78c - g_ps2RecompiledFunctionTable[507362] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef790 - g_ps2RecompiledFunctionTable[507363] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef794 - g_ps2RecompiledFunctionTable[507364] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef798 - g_ps2RecompiledFunctionTable[507365] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef79c - g_ps2RecompiledFunctionTable[507366] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef7a0 - g_ps2RecompiledFunctionTable[507367] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef7a4 - g_ps2RecompiledFunctionTable[507368] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef7a8 - g_ps2RecompiledFunctionTable[507369] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef7ac - g_ps2RecompiledFunctionTable[507370] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef7b0 - g_ps2RecompiledFunctionTable[507371] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef7b4 - g_ps2RecompiledFunctionTable[507372] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef7b8 - g_ps2RecompiledFunctionTable[507373] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef7bc - g_ps2RecompiledFunctionTable[507374] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef7c0 - g_ps2RecompiledFunctionTable[507375] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef7c4 - g_ps2RecompiledFunctionTable[507376] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef7c8 - g_ps2RecompiledFunctionTable[507377] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef7cc - g_ps2RecompiledFunctionTable[507378] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef7d0 - g_ps2RecompiledFunctionTable[507379] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef7d4 - g_ps2RecompiledFunctionTable[507380] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef7d8 - g_ps2RecompiledFunctionTable[507381] = ADXB_ExecOneAu8_0x2ef668; // 0x2ef7dc - g_ps2RecompiledFunctionTable[507382] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef7e0 - g_ps2RecompiledFunctionTable[507383] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef7e4 - g_ps2RecompiledFunctionTable[507384] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef7e8 - g_ps2RecompiledFunctionTable[507385] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef7ec - g_ps2RecompiledFunctionTable[507386] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef7f0 - g_ps2RecompiledFunctionTable[507387] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef7f4 - g_ps2RecompiledFunctionTable[507388] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef7f8 - g_ps2RecompiledFunctionTable[507389] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef7fc - g_ps2RecompiledFunctionTable[507390] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef800 - g_ps2RecompiledFunctionTable[507391] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef804 - g_ps2RecompiledFunctionTable[507392] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef808 - g_ps2RecompiledFunctionTable[507393] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef80c - g_ps2RecompiledFunctionTable[507394] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef810 - g_ps2RecompiledFunctionTable[507395] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef814 - g_ps2RecompiledFunctionTable[507396] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef818 - g_ps2RecompiledFunctionTable[507397] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef81c - g_ps2RecompiledFunctionTable[507398] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef820 - g_ps2RecompiledFunctionTable[507399] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef824 - g_ps2RecompiledFunctionTable[507400] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef828 - g_ps2RecompiledFunctionTable[507401] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef82c - g_ps2RecompiledFunctionTable[507402] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef830 - g_ps2RecompiledFunctionTable[507403] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef834 - g_ps2RecompiledFunctionTable[507404] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef838 - g_ps2RecompiledFunctionTable[507405] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef83c - g_ps2RecompiledFunctionTable[507406] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef840 - g_ps2RecompiledFunctionTable[507407] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef844 - g_ps2RecompiledFunctionTable[507408] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef848 - g_ps2RecompiledFunctionTable[507409] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef84c - g_ps2RecompiledFunctionTable[507410] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef850 - g_ps2RecompiledFunctionTable[507411] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef854 - g_ps2RecompiledFunctionTable[507412] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef858 - g_ps2RecompiledFunctionTable[507413] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef85c - g_ps2RecompiledFunctionTable[507414] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef860 - g_ps2RecompiledFunctionTable[507415] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef864 - g_ps2RecompiledFunctionTable[507416] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef868 - g_ps2RecompiledFunctionTable[507417] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef86c - g_ps2RecompiledFunctionTable[507418] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef870 - g_ps2RecompiledFunctionTable[507419] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef874 - g_ps2RecompiledFunctionTable[507420] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef878 - g_ps2RecompiledFunctionTable[507421] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef87c - g_ps2RecompiledFunctionTable[507422] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef880 - g_ps2RecompiledFunctionTable[507423] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef884 - g_ps2RecompiledFunctionTable[507424] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef888 - g_ps2RecompiledFunctionTable[507425] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef88c - g_ps2RecompiledFunctionTable[507426] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef890 - g_ps2RecompiledFunctionTable[507427] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef894 - g_ps2RecompiledFunctionTable[507428] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef898 - g_ps2RecompiledFunctionTable[507429] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef89c - g_ps2RecompiledFunctionTable[507430] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef8a0 - g_ps2RecompiledFunctionTable[507431] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef8a4 - g_ps2RecompiledFunctionTable[507432] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef8a8 - g_ps2RecompiledFunctionTable[507433] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef8ac - g_ps2RecompiledFunctionTable[507434] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef8b0 - g_ps2RecompiledFunctionTable[507435] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef8b4 - g_ps2RecompiledFunctionTable[507436] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef8b8 - g_ps2RecompiledFunctionTable[507437] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef8bc - g_ps2RecompiledFunctionTable[507438] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef8c0 - g_ps2RecompiledFunctionTable[507439] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef8c4 - g_ps2RecompiledFunctionTable[507440] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef8c8 - g_ps2RecompiledFunctionTable[507441] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef8cc - g_ps2RecompiledFunctionTable[507442] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef8d0 - g_ps2RecompiledFunctionTable[507443] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef8d4 - g_ps2RecompiledFunctionTable[507444] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef8d8 - g_ps2RecompiledFunctionTable[507445] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef8dc - g_ps2RecompiledFunctionTable[507446] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef8e0 - g_ps2RecompiledFunctionTable[507447] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef8e4 - g_ps2RecompiledFunctionTable[507448] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef8e8 - g_ps2RecompiledFunctionTable[507449] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef8ec - g_ps2RecompiledFunctionTable[507450] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef8f0 - g_ps2RecompiledFunctionTable[507451] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef8f4 - g_ps2RecompiledFunctionTable[507452] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef8f8 - g_ps2RecompiledFunctionTable[507453] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef8fc - g_ps2RecompiledFunctionTable[507454] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef900 - g_ps2RecompiledFunctionTable[507455] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef904 - g_ps2RecompiledFunctionTable[507456] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef908 - g_ps2RecompiledFunctionTable[507457] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef90c - g_ps2RecompiledFunctionTable[507458] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef910 - g_ps2RecompiledFunctionTable[507459] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef914 - g_ps2RecompiledFunctionTable[507460] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef918 - g_ps2RecompiledFunctionTable[507461] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef91c - g_ps2RecompiledFunctionTable[507462] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef920 - g_ps2RecompiledFunctionTable[507463] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef924 - g_ps2RecompiledFunctionTable[507464] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef928 - g_ps2RecompiledFunctionTable[507465] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef92c - g_ps2RecompiledFunctionTable[507466] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef930 - g_ps2RecompiledFunctionTable[507467] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef934 - g_ps2RecompiledFunctionTable[507468] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef938 - g_ps2RecompiledFunctionTable[507469] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef93c - g_ps2RecompiledFunctionTable[507470] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef940 - g_ps2RecompiledFunctionTable[507471] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef944 - g_ps2RecompiledFunctionTable[507472] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef948 - g_ps2RecompiledFunctionTable[507473] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef94c - g_ps2RecompiledFunctionTable[507474] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef950 - g_ps2RecompiledFunctionTable[507475] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef954 - g_ps2RecompiledFunctionTable[507476] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef958 - g_ps2RecompiledFunctionTable[507477] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef95c - g_ps2RecompiledFunctionTable[507478] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef960 - g_ps2RecompiledFunctionTable[507479] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef964 - g_ps2RecompiledFunctionTable[507480] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef968 - g_ps2RecompiledFunctionTable[507481] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef96c - g_ps2RecompiledFunctionTable[507482] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef970 - g_ps2RecompiledFunctionTable[507483] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef974 - g_ps2RecompiledFunctionTable[507484] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef978 - g_ps2RecompiledFunctionTable[507485] = ADXB_ExecOneAuUlaw_0x2ef7e0; // 0x2ef97c - g_ps2RecompiledFunctionTable[507486] = ADXB_ExecOneAu_0x2ef980; // 0x2ef980 - g_ps2RecompiledFunctionTable[507498] = ADXB_Init_0x2ef9b0; // 0x2ef9b0 - g_ps2RecompiledFunctionTable[507502] = ADXB_Init_0x2ef9b0; // 0x2ef9c0 - g_ps2RecompiledFunctionTable[507510] = adxb_DefGetWr_0x2ef9e0; // 0x2ef9e0 - g_ps2RecompiledFunctionTable[507522] = adxb_DefAddWr_0x2efa10; // 0x2efa10 - g_ps2RecompiledFunctionTable[507530] = ADXB_Create_0x2efa30; // 0x2efa30 - g_ps2RecompiledFunctionTable[507548] = ADXB_Create_0x2efa30; // 0x2efa78 - g_ps2RecompiledFunctionTable[507566] = ADXB_Create_0x2efa30; // 0x2efac0 - g_ps2RecompiledFunctionTable[507569] = ADXB_Create_0x2efa30; // 0x2efacc - g_ps2RecompiledFunctionTable[507573] = ADXB_Create_0x2efa30; // 0x2efadc - g_ps2RecompiledFunctionTable[507596] = ADXB_Destroy_0x2efb38; // 0x2efb38 - g_ps2RecompiledFunctionTable[507603] = ADXB_Destroy_0x2efb38; // 0x2efb54 - g_ps2RecompiledFunctionTable[507607] = ADXB_Destroy_0x2efb38; // 0x2efb64 - g_ps2RecompiledFunctionTable[507612] = ADXB_DecodeHeaderAdx_0x2efb78; // 0x2efb78 - g_ps2RecompiledFunctionTable[507635] = ADXB_DecodeHeaderAdx_0x2efb78; // 0x2efbd4 - g_ps2RecompiledFunctionTable[507640] = ADXB_DecodeHeaderAdx_0x2efb78; // 0x2efbe8 - g_ps2RecompiledFunctionTable[507647] = ADXB_DecodeHeaderAdx_0x2efb78; // 0x2efc04 - g_ps2RecompiledFunctionTable[507658] = ADXB_DecodeHeaderAdx_0x2efb78; // 0x2efc30 - g_ps2RecompiledFunctionTable[507682] = ADXB_DecodeHeaderAdx_0x2efb78; // 0x2efc90 - g_ps2RecompiledFunctionTable[507690] = ADXB_DecodeHeader_0x2efcb0; // 0x2efcb0 - g_ps2RecompiledFunctionTable[507707] = ADXB_DecodeHeader_0x2efcb0; // 0x2efcf4 - g_ps2RecompiledFunctionTable[507711] = ADXB_DecodeHeader_0x2efcb0; // 0x2efd04 - g_ps2RecompiledFunctionTable[507716] = ADXB_DecodeHeader_0x2efcb0; // 0x2efd18 - g_ps2RecompiledFunctionTable[507720] = ADXB_DecodeHeader_0x2efcb0; // 0x2efd28 - g_ps2RecompiledFunctionTable[507725] = ADXB_DecodeHeader_0x2efcb0; // 0x2efd3c - g_ps2RecompiledFunctionTable[507729] = ADXB_DecodeHeader_0x2efcb0; // 0x2efd4c - g_ps2RecompiledFunctionTable[507734] = ADXB_DecodeHeader_0x2efcb0; // 0x2efd60 - g_ps2RecompiledFunctionTable[507738] = ADXB_DecodeHeader_0x2efcb0; // 0x2efd70 - g_ps2RecompiledFunctionTable[507743] = ADXB_DecodeHeader_0x2efcb0; // 0x2efd84 - g_ps2RecompiledFunctionTable[507752] = ADXB_EntryGetWrFunc_0x2efda8; // 0x2efda8 - g_ps2RecompiledFunctionTable[507756] = ADXB_EntryAddWrFunc_0x2efdb8; // 0x2efdb8 - g_ps2RecompiledFunctionTable[507760] = ADXB_GetPcmBuf_0x2efdc8; // 0x2efdc8 - g_ps2RecompiledFunctionTable[507762] = ADXB_GetFormat_0x2efdd0; // 0x2efdd0 - g_ps2RecompiledFunctionTable[507764] = ADXB_GetSfreq_0x2efdd8; // 0x2efdd8 - g_ps2RecompiledFunctionTable[507766] = ADXB_GetNumChan_0x2efde0; // 0x2efde0 - g_ps2RecompiledFunctionTable[507768] = ADXB_GetFmtBps_0x2efde8; // 0x2efde8 - g_ps2RecompiledFunctionTable[507770] = ADXB_GetOutBps_0x2efdf0; // 0x2efdf0 - g_ps2RecompiledFunctionTable[507794] = ADXB_GetBlkSmpl_0x2efe50; // 0x2efe50 - g_ps2RecompiledFunctionTable[507796] = ADXB_GetBlkLen_0x2efe58; // 0x2efe58 - g_ps2RecompiledFunctionTable[507798] = ADXB_GetTotalNumSmpl_0x2efe60; // 0x2efe60 - g_ps2RecompiledFunctionTable[507800] = ADXB_GetCof_0x2efe68; // 0x2efe68 - g_ps2RecompiledFunctionTable[507802] = ADXB_GetLpInsNsmpl_0x2efe70; // 0x2efe70 - g_ps2RecompiledFunctionTable[507804] = ADXB_GetNumLoop_0x2efe78; // 0x2efe78 - g_ps2RecompiledFunctionTable[507806] = ADXB_GetLpStartPos_0x2efe80; // 0x2efe80 - g_ps2RecompiledFunctionTable[507808] = ADXB_GetLpStartOfst_0x2efe88; // 0x2efe88 - g_ps2RecompiledFunctionTable[507810] = ADXB_GetLpEndPos_0x2efe90; // 0x2efe90 - g_ps2RecompiledFunctionTable[507812] = ADXB_GetLpEndOfst_0x2efe98; // 0x2efe98 - g_ps2RecompiledFunctionTable[507814] = ADXB_GetStat_0x2efea0; // 0x2efea0 - g_ps2RecompiledFunctionTable[507816] = ADXB_EntryData_0x2efea8; // 0x2efea8 - g_ps2RecompiledFunctionTable[507850] = ADXB_Start_0x2eff30; // 0x2eff30 - g_ps2RecompiledFunctionTable[507856] = ADXB_Stop_0x2eff48; // 0x2eff48 - g_ps2RecompiledFunctionTable[507862] = ADXB_Stop_0x2eff48; // 0x2eff60 - g_ps2RecompiledFunctionTable[507868] = ADXB_Reset_0x2eff78; // 0x2eff78 - g_ps2RecompiledFunctionTable[507878] = ADXB_Reset_0x2eff78; // 0x2effa0 - g_ps2RecompiledFunctionTable[507884] = ADXB_GetDecDtLen_0x2effb8; // 0x2effb8 - g_ps2RecompiledFunctionTable[507886] = ADXB_GetDecNumSmpl_0x2effc0; // 0x2effc0 - g_ps2RecompiledFunctionTable[507888] = ADXB_GetAdxpd_0x2effc8; // 0x2effc8 - g_ps2RecompiledFunctionTable[507890] = ADXB_EvokeExpandMono_0x2effd0; // 0x2effd0 - g_ps2RecompiledFunctionTable[507903] = ADXB_EvokeExpandMono_0x2effd0; // 0x2f0004 - g_ps2RecompiledFunctionTable[507908] = ADXB_EvokeExpandSte_0x2f0018; // 0x2f0018 - g_ps2RecompiledFunctionTable[507924] = ADXB_EvokeExpandSte_0x2f0018; // 0x2f0058 - g_ps2RecompiledFunctionTable[507930] = ADXB_EvokeDecode_0x2f0070; // 0x2f0070 - g_ps2RecompiledFunctionTable[507984] = memcpy2_0x2f0148; // 0x2f0148 - g_ps2RecompiledFunctionTable[507986] = memcpy2_0x2f0148; // 0x2f0150 - g_ps2RecompiledFunctionTable[507996] = ADXB_CopyExtraBufSte_0x2f0178; // 0x2f0178 - g_ps2RecompiledFunctionTable[508010] = ADXB_CopyExtraBufSte_0x2f0178; // 0x2f01b0 - g_ps2RecompiledFunctionTable[508024] = ADXB_CopyExtraBufMono_0x2f01e8; // 0x2f01e8 - g_ps2RecompiledFunctionTable[508028] = ADXB_EndDecode_0x2f01f8; // 0x2f01f8 - g_ps2RecompiledFunctionTable[508060] = ADXB_EndDecode_0x2f01f8; // 0x2f0278 - g_ps2RecompiledFunctionTable[508124] = ADXB_ExecOneAdx_0x2f0378; // 0x2f0378 - g_ps2RecompiledFunctionTable[508125] = ADXB_ExecOneAdx_0x2f0378; // 0x2f037c - g_ps2RecompiledFunctionTable[508126] = ADXB_ExecOneAdx_0x2f0378; // 0x2f0380 - g_ps2RecompiledFunctionTable[508127] = ADXB_ExecOneAdx_0x2f0378; // 0x2f0384 - g_ps2RecompiledFunctionTable[508128] = ADXB_ExecOneAdx_0x2f0378; // 0x2f0388 - g_ps2RecompiledFunctionTable[508129] = ADXB_ExecOneAdx_0x2f0378; // 0x2f038c - g_ps2RecompiledFunctionTable[508130] = ADXB_ExecOneAdx_0x2f0378; // 0x2f0390 - g_ps2RecompiledFunctionTable[508131] = ADXB_ExecOneAdx_0x2f0378; // 0x2f0394 - g_ps2RecompiledFunctionTable[508132] = ADXB_ExecOneAdx_0x2f0378; // 0x2f0398 - g_ps2RecompiledFunctionTable[508133] = ADXB_ExecOneAdx_0x2f0378; // 0x2f039c - g_ps2RecompiledFunctionTable[508134] = ADXB_ExecOneAdx_0x2f0378; // 0x2f03a0 - g_ps2RecompiledFunctionTable[508135] = ADXB_ExecOneAdx_0x2f0378; // 0x2f03a4 - g_ps2RecompiledFunctionTable[508136] = ADXB_ExecOneAdx_0x2f0378; // 0x2f03a8 - g_ps2RecompiledFunctionTable[508137] = ADXB_ExecOneAdx_0x2f0378; // 0x2f03ac - g_ps2RecompiledFunctionTable[508138] = ADXB_ExecOneAdx_0x2f0378; // 0x2f03b0 - g_ps2RecompiledFunctionTable[508139] = ADXB_ExecOneAdx_0x2f0378; // 0x2f03b4 - g_ps2RecompiledFunctionTable[508140] = ADXB_ExecOneAdx_0x2f0378; // 0x2f03b8 - g_ps2RecompiledFunctionTable[508141] = ADXB_ExecOneAdx_0x2f0378; // 0x2f03bc - g_ps2RecompiledFunctionTable[508142] = ADXB_ExecOneAdx_0x2f0378; // 0x2f03c0 - g_ps2RecompiledFunctionTable[508143] = ADXB_ExecOneAdx_0x2f0378; // 0x2f03c4 - g_ps2RecompiledFunctionTable[508144] = ADXB_ExecOneAdx_0x2f0378; // 0x2f03c8 - g_ps2RecompiledFunctionTable[508145] = ADXB_ExecOneAdx_0x2f0378; // 0x2f03cc - g_ps2RecompiledFunctionTable[508146] = ADXB_ExecOneAdx_0x2f0378; // 0x2f03d0 - g_ps2RecompiledFunctionTable[508147] = ADXB_ExecOneAdx_0x2f0378; // 0x2f03d4 - g_ps2RecompiledFunctionTable[508148] = ADXB_ExecOneAdx_0x2f0378; // 0x2f03d8 - g_ps2RecompiledFunctionTable[508149] = ADXB_ExecOneAdx_0x2f0378; // 0x2f03dc - g_ps2RecompiledFunctionTable[508150] = ADXB_ExecOneAdx_0x2f0378; // 0x2f03e0 - g_ps2RecompiledFunctionTable[508151] = ADXB_ExecOneAdx_0x2f0378; // 0x2f03e4 - g_ps2RecompiledFunctionTable[508152] = ADXB_ExecOneAdx_0x2f0378; // 0x2f03e8 - g_ps2RecompiledFunctionTable[508153] = ADXB_ExecOneAdx_0x2f0378; // 0x2f03ec - g_ps2RecompiledFunctionTable[508154] = ADXB_ExecOneAdx_0x2f0378; // 0x2f03f0 - g_ps2RecompiledFunctionTable[508155] = ADXB_ExecOneAdx_0x2f0378; // 0x2f03f4 - g_ps2RecompiledFunctionTable[508156] = ADXB_ExecOneAdx_0x2f0378; // 0x2f03f8 - g_ps2RecompiledFunctionTable[508157] = ADXB_ExecOneAdx_0x2f0378; // 0x2f03fc - g_ps2RecompiledFunctionTable[508158] = ADXB_ExecOneAdx_0x2f0378; // 0x2f0400 - g_ps2RecompiledFunctionTable[508159] = ADXB_ExecOneAdx_0x2f0378; // 0x2f0404 - g_ps2RecompiledFunctionTable[508160] = ADXB_ExecOneAdx_0x2f0378; // 0x2f0408 - g_ps2RecompiledFunctionTable[508161] = ADXB_ExecOneAdx_0x2f0378; // 0x2f040c - g_ps2RecompiledFunctionTable[508162] = ADXB_ExecOneAdx_0x2f0378; // 0x2f0410 - g_ps2RecompiledFunctionTable[508163] = ADXB_ExecOneAdx_0x2f0378; // 0x2f0414 - g_ps2RecompiledFunctionTable[508164] = ADXB_ExecOneAdx_0x2f0378; // 0x2f0418 - g_ps2RecompiledFunctionTable[508165] = ADXB_ExecOneAdx_0x2f0378; // 0x2f041c - g_ps2RecompiledFunctionTable[508166] = ADXB_ExecOneAdx_0x2f0378; // 0x2f0420 - g_ps2RecompiledFunctionTable[508167] = ADXB_ExecOneAdx_0x2f0378; // 0x2f0424 - g_ps2RecompiledFunctionTable[508168] = ADXB_ExecOneAdx_0x2f0378; // 0x2f0428 - g_ps2RecompiledFunctionTable[508169] = ADXB_ExecOneAdx_0x2f0378; // 0x2f042c - g_ps2RecompiledFunctionTable[508170] = ADXB_ExecOneAdx_0x2f0378; // 0x2f0430 - g_ps2RecompiledFunctionTable[508171] = ADXB_ExecOneAdx_0x2f0378; // 0x2f0434 - g_ps2RecompiledFunctionTable[508172] = ADXB_ExecOneAdx_0x2f0378; // 0x2f0438 - g_ps2RecompiledFunctionTable[508173] = ADXB_ExecOneAdx_0x2f0378; // 0x2f043c - g_ps2RecompiledFunctionTable[508174] = ADXB_ExecOneAdx_0x2f0378; // 0x2f0440 - g_ps2RecompiledFunctionTable[508176] = ADXB_ExecHndl_0x2f0448; // 0x2f0448 - g_ps2RecompiledFunctionTable[508200] = ADXB_ExecServer_0x2f04a8; // 0x2f04a8 - g_ps2RecompiledFunctionTable[508210] = ADXB_ExecServer_0x2f04a8; // 0x2f04d0 - g_ps2RecompiledFunctionTable[508214] = ADXB_ExecServer_0x2f04a8; // 0x2f04e0 - g_ps2RecompiledFunctionTable[508224] = ADX_DecodeInfoSpsd_0x2f0508; // 0x2f0508 - g_ps2RecompiledFunctionTable[508292] = ADXB_DecodeHeaderSpsd_0x2f0618; // 0x2f0618 - g_ps2RecompiledFunctionTable[508313] = ADXB_DecodeHeaderSpsd_0x2f0618; // 0x2f066c - g_ps2RecompiledFunctionTable[508350] = ADXB_DecodeHeaderSpsd_0x2f0618; // 0x2f0700 - g_ps2RecompiledFunctionTable[508356] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f0718 - g_ps2RecompiledFunctionTable[508357] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f071c - g_ps2RecompiledFunctionTable[508358] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f0720 - g_ps2RecompiledFunctionTable[508359] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f0724 - g_ps2RecompiledFunctionTable[508360] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f0728 - g_ps2RecompiledFunctionTable[508361] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f072c - g_ps2RecompiledFunctionTable[508362] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f0730 - g_ps2RecompiledFunctionTable[508363] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f0734 - g_ps2RecompiledFunctionTable[508364] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f0738 - g_ps2RecompiledFunctionTable[508365] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f073c - g_ps2RecompiledFunctionTable[508366] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f0740 - g_ps2RecompiledFunctionTable[508367] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f0744 - g_ps2RecompiledFunctionTable[508368] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f0748 - g_ps2RecompiledFunctionTable[508369] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f074c - g_ps2RecompiledFunctionTable[508370] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f0750 - g_ps2RecompiledFunctionTable[508371] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f0754 - g_ps2RecompiledFunctionTable[508372] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f0758 - g_ps2RecompiledFunctionTable[508373] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f075c - g_ps2RecompiledFunctionTable[508374] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f0760 - g_ps2RecompiledFunctionTable[508375] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f0764 - g_ps2RecompiledFunctionTable[508376] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f0768 - g_ps2RecompiledFunctionTable[508377] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f076c - g_ps2RecompiledFunctionTable[508378] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f0770 - g_ps2RecompiledFunctionTable[508379] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f0774 - g_ps2RecompiledFunctionTable[508380] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f0778 - g_ps2RecompiledFunctionTable[508381] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f077c - g_ps2RecompiledFunctionTable[508382] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f0780 - g_ps2RecompiledFunctionTable[508383] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f0784 - g_ps2RecompiledFunctionTable[508384] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f0788 - g_ps2RecompiledFunctionTable[508385] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f078c - g_ps2RecompiledFunctionTable[508386] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f0790 - g_ps2RecompiledFunctionTable[508387] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f0794 - g_ps2RecompiledFunctionTable[508388] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f0798 - g_ps2RecompiledFunctionTable[508389] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f079c - g_ps2RecompiledFunctionTable[508390] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f07a0 - g_ps2RecompiledFunctionTable[508391] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f07a4 - g_ps2RecompiledFunctionTable[508392] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f07a8 - g_ps2RecompiledFunctionTable[508393] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f07ac - g_ps2RecompiledFunctionTable[508394] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f07b0 - g_ps2RecompiledFunctionTable[508395] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f07b4 - g_ps2RecompiledFunctionTable[508396] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f07b8 - g_ps2RecompiledFunctionTable[508397] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f07bc - g_ps2RecompiledFunctionTable[508398] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f07c0 - g_ps2RecompiledFunctionTable[508399] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f07c4 - g_ps2RecompiledFunctionTable[508400] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f07c8 - g_ps2RecompiledFunctionTable[508401] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f07cc - g_ps2RecompiledFunctionTable[508402] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f07d0 - g_ps2RecompiledFunctionTable[508403] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f07d4 - g_ps2RecompiledFunctionTable[508404] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f07d8 - g_ps2RecompiledFunctionTable[508405] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f07dc - g_ps2RecompiledFunctionTable[508406] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f07e0 - g_ps2RecompiledFunctionTable[508407] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f07e4 - g_ps2RecompiledFunctionTable[508408] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f07e8 - g_ps2RecompiledFunctionTable[508409] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f07ec - g_ps2RecompiledFunctionTable[508410] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f07f0 - g_ps2RecompiledFunctionTable[508411] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f07f4 - g_ps2RecompiledFunctionTable[508412] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f07f8 - g_ps2RecompiledFunctionTable[508413] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f07fc - g_ps2RecompiledFunctionTable[508414] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f0800 - g_ps2RecompiledFunctionTable[508415] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f0804 - g_ps2RecompiledFunctionTable[508416] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f0808 - g_ps2RecompiledFunctionTable[508417] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f080c - g_ps2RecompiledFunctionTable[508418] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f0810 - g_ps2RecompiledFunctionTable[508419] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f0814 - g_ps2RecompiledFunctionTable[508420] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f0818 - g_ps2RecompiledFunctionTable[508421] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f081c - g_ps2RecompiledFunctionTable[508422] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f0820 - g_ps2RecompiledFunctionTable[508423] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f0824 - g_ps2RecompiledFunctionTable[508424] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f0828 - g_ps2RecompiledFunctionTable[508425] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f082c - g_ps2RecompiledFunctionTable[508426] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f0830 - g_ps2RecompiledFunctionTable[508427] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f0834 - g_ps2RecompiledFunctionTable[508428] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f0838 - g_ps2RecompiledFunctionTable[508429] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f083c - g_ps2RecompiledFunctionTable[508430] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f0840 - g_ps2RecompiledFunctionTable[508431] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f0844 - g_ps2RecompiledFunctionTable[508432] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f0848 - g_ps2RecompiledFunctionTable[508433] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f084c - g_ps2RecompiledFunctionTable[508434] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f0850 - g_ps2RecompiledFunctionTable[508435] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f0854 - g_ps2RecompiledFunctionTable[508436] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f0858 - g_ps2RecompiledFunctionTable[508437] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f085c - g_ps2RecompiledFunctionTable[508438] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f0860 - g_ps2RecompiledFunctionTable[508439] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f0864 - g_ps2RecompiledFunctionTable[508440] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f0868 - g_ps2RecompiledFunctionTable[508441] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f086c - g_ps2RecompiledFunctionTable[508442] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f0870 - g_ps2RecompiledFunctionTable[508443] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f0874 - g_ps2RecompiledFunctionTable[508444] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f0878 - g_ps2RecompiledFunctionTable[508445] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f087c - g_ps2RecompiledFunctionTable[508446] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f0880 - g_ps2RecompiledFunctionTable[508447] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f0884 - g_ps2RecompiledFunctionTable[508448] = ADXB_ExecOneSpsd_0x2f0718; // 0x2f0888 - g_ps2RecompiledFunctionTable[508450] = ADXB_CheckSpsd_0x2f0890; // 0x2f0890 - g_ps2RecompiledFunctionTable[508456] = ADXB_CheckSpsd_0x2f0890; // 0x2f08a8 - g_ps2RecompiledFunctionTable[508460] = ADX_DecodeInfoWav_0x2f08b8; // 0x2f08b8 - g_ps2RecompiledFunctionTable[508480] = ADX_DecodeInfoWav_0x2f08b8; // 0x2f0908 - g_ps2RecompiledFunctionTable[508486] = ADX_DecodeInfoWav_0x2f08b8; // 0x2f0920 - g_ps2RecompiledFunctionTable[508500] = ADX_DecodeInfoWav_0x2f08b8; // 0x2f0958 - g_ps2RecompiledFunctionTable[508506] = ADX_DecodeInfoWav_0x2f08b8; // 0x2f0970 - g_ps2RecompiledFunctionTable[508616] = ADXB_DecodeHeaderWav_0x2f0b28; // 0x2f0b28 - g_ps2RecompiledFunctionTable[508638] = ADXB_DecodeHeaderWav_0x2f0b28; // 0x2f0b80 - g_ps2RecompiledFunctionTable[508674] = ADXB_DecodeHeaderWav_0x2f0b28; // 0x2f0c10 - g_ps2RecompiledFunctionTable[508680] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0c28 - g_ps2RecompiledFunctionTable[508681] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0c2c - g_ps2RecompiledFunctionTable[508682] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0c30 - g_ps2RecompiledFunctionTable[508683] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0c34 - g_ps2RecompiledFunctionTable[508684] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0c38 - g_ps2RecompiledFunctionTable[508685] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0c3c - g_ps2RecompiledFunctionTable[508686] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0c40 - g_ps2RecompiledFunctionTable[508687] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0c44 - g_ps2RecompiledFunctionTable[508688] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0c48 - g_ps2RecompiledFunctionTable[508689] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0c4c - g_ps2RecompiledFunctionTable[508690] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0c50 - g_ps2RecompiledFunctionTable[508691] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0c54 - g_ps2RecompiledFunctionTable[508692] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0c58 - g_ps2RecompiledFunctionTable[508693] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0c5c - g_ps2RecompiledFunctionTable[508694] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0c60 - g_ps2RecompiledFunctionTable[508695] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0c64 - g_ps2RecompiledFunctionTable[508696] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0c68 - g_ps2RecompiledFunctionTable[508697] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0c6c - g_ps2RecompiledFunctionTable[508698] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0c70 - g_ps2RecompiledFunctionTable[508699] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0c74 - g_ps2RecompiledFunctionTable[508700] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0c78 - g_ps2RecompiledFunctionTable[508701] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0c7c - g_ps2RecompiledFunctionTable[508702] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0c80 - g_ps2RecompiledFunctionTable[508703] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0c84 - g_ps2RecompiledFunctionTable[508704] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0c88 - g_ps2RecompiledFunctionTable[508705] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0c8c - g_ps2RecompiledFunctionTable[508706] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0c90 - g_ps2RecompiledFunctionTable[508707] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0c94 - g_ps2RecompiledFunctionTable[508708] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0c98 - g_ps2RecompiledFunctionTable[508709] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0c9c - g_ps2RecompiledFunctionTable[508710] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0ca0 - g_ps2RecompiledFunctionTable[508711] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0ca4 - g_ps2RecompiledFunctionTable[508712] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0ca8 - g_ps2RecompiledFunctionTable[508713] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0cac - g_ps2RecompiledFunctionTable[508714] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0cb0 - g_ps2RecompiledFunctionTable[508715] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0cb4 - g_ps2RecompiledFunctionTable[508716] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0cb8 - g_ps2RecompiledFunctionTable[508717] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0cbc - g_ps2RecompiledFunctionTable[508718] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0cc0 - g_ps2RecompiledFunctionTable[508719] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0cc4 - g_ps2RecompiledFunctionTable[508720] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0cc8 - g_ps2RecompiledFunctionTable[508721] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0ccc - g_ps2RecompiledFunctionTable[508722] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0cd0 - g_ps2RecompiledFunctionTable[508723] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0cd4 - g_ps2RecompiledFunctionTable[508724] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0cd8 - g_ps2RecompiledFunctionTable[508725] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0cdc - g_ps2RecompiledFunctionTable[508726] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0ce0 - g_ps2RecompiledFunctionTable[508727] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0ce4 - g_ps2RecompiledFunctionTable[508728] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0ce8 - g_ps2RecompiledFunctionTable[508729] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0cec - g_ps2RecompiledFunctionTable[508730] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0cf0 - g_ps2RecompiledFunctionTable[508731] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0cf4 - g_ps2RecompiledFunctionTable[508732] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0cf8 - g_ps2RecompiledFunctionTable[508733] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0cfc - g_ps2RecompiledFunctionTable[508734] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0d00 - g_ps2RecompiledFunctionTable[508735] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0d04 - g_ps2RecompiledFunctionTable[508736] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0d08 - g_ps2RecompiledFunctionTable[508737] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0d0c - g_ps2RecompiledFunctionTable[508738] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0d10 - g_ps2RecompiledFunctionTable[508739] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0d14 - g_ps2RecompiledFunctionTable[508740] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0d18 - g_ps2RecompiledFunctionTable[508741] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0d1c - g_ps2RecompiledFunctionTable[508742] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0d20 - g_ps2RecompiledFunctionTable[508743] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0d24 - g_ps2RecompiledFunctionTable[508744] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0d28 - g_ps2RecompiledFunctionTable[508745] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0d2c - g_ps2RecompiledFunctionTable[508746] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0d30 - g_ps2RecompiledFunctionTable[508747] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0d34 - g_ps2RecompiledFunctionTable[508748] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0d38 - g_ps2RecompiledFunctionTable[508749] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0d3c - g_ps2RecompiledFunctionTable[508750] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0d40 - g_ps2RecompiledFunctionTable[508751] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0d44 - g_ps2RecompiledFunctionTable[508752] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0d48 - g_ps2RecompiledFunctionTable[508753] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0d4c - g_ps2RecompiledFunctionTable[508754] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0d50 - g_ps2RecompiledFunctionTable[508755] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0d54 - g_ps2RecompiledFunctionTable[508756] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0d58 - g_ps2RecompiledFunctionTable[508757] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0d5c - g_ps2RecompiledFunctionTable[508758] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0d60 - g_ps2RecompiledFunctionTable[508759] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0d64 - g_ps2RecompiledFunctionTable[508760] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0d68 - g_ps2RecompiledFunctionTable[508761] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0d6c - g_ps2RecompiledFunctionTable[508762] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0d70 - g_ps2RecompiledFunctionTable[508763] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0d74 - g_ps2RecompiledFunctionTable[508764] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0d78 - g_ps2RecompiledFunctionTable[508765] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0d7c - g_ps2RecompiledFunctionTable[508766] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0d80 - g_ps2RecompiledFunctionTable[508767] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0d84 - g_ps2RecompiledFunctionTable[508768] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0d88 - g_ps2RecompiledFunctionTable[508769] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0d8c - g_ps2RecompiledFunctionTable[508770] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0d90 - g_ps2RecompiledFunctionTable[508771] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0d94 - g_ps2RecompiledFunctionTable[508772] = ADXB_ExecOneWav16_0x2f0c28; // 0x2f0d98 - g_ps2RecompiledFunctionTable[508774] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0da0 - g_ps2RecompiledFunctionTable[508775] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0da4 - g_ps2RecompiledFunctionTable[508776] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0da8 - g_ps2RecompiledFunctionTable[508777] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0dac - g_ps2RecompiledFunctionTable[508778] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0db0 - g_ps2RecompiledFunctionTable[508779] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0db4 - g_ps2RecompiledFunctionTable[508780] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0db8 - g_ps2RecompiledFunctionTable[508781] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0dbc - g_ps2RecompiledFunctionTable[508782] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0dc0 - g_ps2RecompiledFunctionTable[508783] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0dc4 - g_ps2RecompiledFunctionTable[508784] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0dc8 - g_ps2RecompiledFunctionTable[508785] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0dcc - g_ps2RecompiledFunctionTable[508786] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0dd0 - g_ps2RecompiledFunctionTable[508787] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0dd4 - g_ps2RecompiledFunctionTable[508788] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0dd8 - g_ps2RecompiledFunctionTable[508789] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0ddc - g_ps2RecompiledFunctionTable[508790] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0de0 - g_ps2RecompiledFunctionTable[508791] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0de4 - g_ps2RecompiledFunctionTable[508792] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0de8 - g_ps2RecompiledFunctionTable[508793] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0dec - g_ps2RecompiledFunctionTable[508794] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0df0 - g_ps2RecompiledFunctionTable[508795] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0df4 - g_ps2RecompiledFunctionTable[508796] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0df8 - g_ps2RecompiledFunctionTable[508797] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0dfc - g_ps2RecompiledFunctionTable[508798] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0e00 - g_ps2RecompiledFunctionTable[508799] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0e04 - g_ps2RecompiledFunctionTable[508800] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0e08 - g_ps2RecompiledFunctionTable[508801] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0e0c - g_ps2RecompiledFunctionTable[508802] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0e10 - g_ps2RecompiledFunctionTable[508803] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0e14 - g_ps2RecompiledFunctionTable[508804] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0e18 - g_ps2RecompiledFunctionTable[508805] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0e1c - g_ps2RecompiledFunctionTable[508806] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0e20 - g_ps2RecompiledFunctionTable[508807] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0e24 - g_ps2RecompiledFunctionTable[508808] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0e28 - g_ps2RecompiledFunctionTable[508809] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0e2c - g_ps2RecompiledFunctionTable[508810] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0e30 - g_ps2RecompiledFunctionTable[508811] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0e34 - g_ps2RecompiledFunctionTable[508812] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0e38 - g_ps2RecompiledFunctionTable[508813] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0e3c - g_ps2RecompiledFunctionTable[508814] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0e40 - g_ps2RecompiledFunctionTable[508815] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0e44 - g_ps2RecompiledFunctionTable[508816] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0e48 - g_ps2RecompiledFunctionTable[508817] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0e4c - g_ps2RecompiledFunctionTable[508818] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0e50 - g_ps2RecompiledFunctionTable[508819] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0e54 - g_ps2RecompiledFunctionTable[508820] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0e58 - g_ps2RecompiledFunctionTable[508821] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0e5c - g_ps2RecompiledFunctionTable[508822] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0e60 - g_ps2RecompiledFunctionTable[508823] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0e64 - g_ps2RecompiledFunctionTable[508824] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0e68 - g_ps2RecompiledFunctionTable[508825] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0e6c - g_ps2RecompiledFunctionTable[508826] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0e70 - g_ps2RecompiledFunctionTable[508827] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0e74 - g_ps2RecompiledFunctionTable[508828] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0e78 - g_ps2RecompiledFunctionTable[508829] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0e7c - g_ps2RecompiledFunctionTable[508830] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0e80 - g_ps2RecompiledFunctionTable[508831] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0e84 - g_ps2RecompiledFunctionTable[508832] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0e88 - g_ps2RecompiledFunctionTable[508833] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0e8c - g_ps2RecompiledFunctionTable[508834] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0e90 - g_ps2RecompiledFunctionTable[508835] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0e94 - g_ps2RecompiledFunctionTable[508836] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0e98 - g_ps2RecompiledFunctionTable[508837] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0e9c - g_ps2RecompiledFunctionTable[508838] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0ea0 - g_ps2RecompiledFunctionTable[508839] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0ea4 - g_ps2RecompiledFunctionTable[508840] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0ea8 - g_ps2RecompiledFunctionTable[508841] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0eac - g_ps2RecompiledFunctionTable[508842] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0eb0 - g_ps2RecompiledFunctionTable[508843] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0eb4 - g_ps2RecompiledFunctionTable[508844] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0eb8 - g_ps2RecompiledFunctionTable[508845] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0ebc - g_ps2RecompiledFunctionTable[508846] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0ec0 - g_ps2RecompiledFunctionTable[508847] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0ec4 - g_ps2RecompiledFunctionTable[508848] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0ec8 - g_ps2RecompiledFunctionTable[508849] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0ecc - g_ps2RecompiledFunctionTable[508850] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0ed0 - g_ps2RecompiledFunctionTable[508851] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0ed4 - g_ps2RecompiledFunctionTable[508852] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0ed8 - g_ps2RecompiledFunctionTable[508853] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0edc - g_ps2RecompiledFunctionTable[508854] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0ee0 - g_ps2RecompiledFunctionTable[508855] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0ee4 - g_ps2RecompiledFunctionTable[508856] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0ee8 - g_ps2RecompiledFunctionTable[508857] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0eec - g_ps2RecompiledFunctionTable[508858] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0ef0 - g_ps2RecompiledFunctionTable[508859] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0ef4 - g_ps2RecompiledFunctionTable[508860] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0ef8 - g_ps2RecompiledFunctionTable[508861] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0efc - g_ps2RecompiledFunctionTable[508862] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0f00 - g_ps2RecompiledFunctionTable[508863] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0f04 - g_ps2RecompiledFunctionTable[508864] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0f08 - g_ps2RecompiledFunctionTable[508865] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0f0c - g_ps2RecompiledFunctionTable[508866] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0f10 - g_ps2RecompiledFunctionTable[508867] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0f14 - g_ps2RecompiledFunctionTable[508868] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0f18 - g_ps2RecompiledFunctionTable[508869] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0f1c - g_ps2RecompiledFunctionTable[508870] = ADXB_ExecOneWav8_0x2f0da0; // 0x2f0f20 - g_ps2RecompiledFunctionTable[508872] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f0f28 - g_ps2RecompiledFunctionTable[508873] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f0f2c - g_ps2RecompiledFunctionTable[508874] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f0f30 - g_ps2RecompiledFunctionTable[508875] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f0f34 - g_ps2RecompiledFunctionTable[508876] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f0f38 - g_ps2RecompiledFunctionTable[508877] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f0f3c - g_ps2RecompiledFunctionTable[508878] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f0f40 - g_ps2RecompiledFunctionTable[508879] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f0f44 - g_ps2RecompiledFunctionTable[508880] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f0f48 - g_ps2RecompiledFunctionTable[508881] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f0f4c - g_ps2RecompiledFunctionTable[508882] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f0f50 - g_ps2RecompiledFunctionTable[508883] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f0f54 - g_ps2RecompiledFunctionTable[508884] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f0f58 - g_ps2RecompiledFunctionTable[508885] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f0f5c - g_ps2RecompiledFunctionTable[508886] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f0f60 - g_ps2RecompiledFunctionTable[508887] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f0f64 - g_ps2RecompiledFunctionTable[508888] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f0f68 - g_ps2RecompiledFunctionTable[508889] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f0f6c - g_ps2RecompiledFunctionTable[508890] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f0f70 - g_ps2RecompiledFunctionTable[508891] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f0f74 - g_ps2RecompiledFunctionTable[508892] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f0f78 - g_ps2RecompiledFunctionTable[508893] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f0f7c - g_ps2RecompiledFunctionTable[508894] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f0f80 - g_ps2RecompiledFunctionTable[508895] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f0f84 - g_ps2RecompiledFunctionTable[508896] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f0f88 - g_ps2RecompiledFunctionTable[508897] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f0f8c - g_ps2RecompiledFunctionTable[508898] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f0f90 - g_ps2RecompiledFunctionTable[508899] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f0f94 - g_ps2RecompiledFunctionTable[508900] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f0f98 - g_ps2RecompiledFunctionTable[508901] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f0f9c - g_ps2RecompiledFunctionTable[508902] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f0fa0 - g_ps2RecompiledFunctionTable[508903] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f0fa4 - g_ps2RecompiledFunctionTable[508904] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f0fa8 - g_ps2RecompiledFunctionTable[508905] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f0fac - g_ps2RecompiledFunctionTable[508906] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f0fb0 - g_ps2RecompiledFunctionTable[508907] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f0fb4 - g_ps2RecompiledFunctionTable[508908] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f0fb8 - g_ps2RecompiledFunctionTable[508909] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f0fbc - g_ps2RecompiledFunctionTable[508910] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f0fc0 - g_ps2RecompiledFunctionTable[508911] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f0fc4 - g_ps2RecompiledFunctionTable[508912] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f0fc8 - g_ps2RecompiledFunctionTable[508913] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f0fcc - g_ps2RecompiledFunctionTable[508914] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f0fd0 - g_ps2RecompiledFunctionTable[508915] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f0fd4 - g_ps2RecompiledFunctionTable[508916] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f0fd8 - g_ps2RecompiledFunctionTable[508917] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f0fdc - g_ps2RecompiledFunctionTable[508918] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f0fe0 - g_ps2RecompiledFunctionTable[508919] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f0fe4 - g_ps2RecompiledFunctionTable[508920] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f0fe8 - g_ps2RecompiledFunctionTable[508921] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f0fec - g_ps2RecompiledFunctionTable[508922] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f0ff0 - g_ps2RecompiledFunctionTable[508923] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f0ff4 - g_ps2RecompiledFunctionTable[508924] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f0ff8 - g_ps2RecompiledFunctionTable[508925] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f0ffc - g_ps2RecompiledFunctionTable[508926] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f1000 - g_ps2RecompiledFunctionTable[508927] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f1004 - g_ps2RecompiledFunctionTable[508928] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f1008 - g_ps2RecompiledFunctionTable[508929] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f100c - g_ps2RecompiledFunctionTable[508930] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f1010 - g_ps2RecompiledFunctionTable[508931] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f1014 - g_ps2RecompiledFunctionTable[508932] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f1018 - g_ps2RecompiledFunctionTable[508933] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f101c - g_ps2RecompiledFunctionTable[508934] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f1020 - g_ps2RecompiledFunctionTable[508935] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f1024 - g_ps2RecompiledFunctionTable[508936] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f1028 - g_ps2RecompiledFunctionTable[508937] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f102c - g_ps2RecompiledFunctionTable[508938] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f1030 - g_ps2RecompiledFunctionTable[508939] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f1034 - g_ps2RecompiledFunctionTable[508940] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f1038 - g_ps2RecompiledFunctionTable[508941] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f103c - g_ps2RecompiledFunctionTable[508942] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f1040 - g_ps2RecompiledFunctionTable[508943] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f1044 - g_ps2RecompiledFunctionTable[508944] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f1048 - g_ps2RecompiledFunctionTable[508945] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f104c - g_ps2RecompiledFunctionTable[508946] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f1050 - g_ps2RecompiledFunctionTable[508947] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f1054 - g_ps2RecompiledFunctionTable[508948] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f1058 - g_ps2RecompiledFunctionTable[508949] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f105c - g_ps2RecompiledFunctionTable[508950] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f1060 - g_ps2RecompiledFunctionTable[508951] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f1064 - g_ps2RecompiledFunctionTable[508952] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f1068 - g_ps2RecompiledFunctionTable[508953] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f106c - g_ps2RecompiledFunctionTable[508954] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f1070 - g_ps2RecompiledFunctionTable[508955] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f1074 - g_ps2RecompiledFunctionTable[508956] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f1078 - g_ps2RecompiledFunctionTable[508957] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f107c - g_ps2RecompiledFunctionTable[508958] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f1080 - g_ps2RecompiledFunctionTable[508959] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f1084 - g_ps2RecompiledFunctionTable[508960] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f1088 - g_ps2RecompiledFunctionTable[508961] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f108c - g_ps2RecompiledFunctionTable[508962] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f1090 - g_ps2RecompiledFunctionTable[508963] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f1094 - g_ps2RecompiledFunctionTable[508964] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f1098 - g_ps2RecompiledFunctionTable[508965] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f109c - g_ps2RecompiledFunctionTable[508966] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f10a0 - g_ps2RecompiledFunctionTable[508967] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f10a4 - g_ps2RecompiledFunctionTable[508968] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f10a8 - g_ps2RecompiledFunctionTable[508969] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f10ac - g_ps2RecompiledFunctionTable[508970] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f10b0 - g_ps2RecompiledFunctionTable[508971] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f10b4 - g_ps2RecompiledFunctionTable[508972] = ADXB_ExecOneWav4_0x2f0f28; // 0x2f10b8 - g_ps2RecompiledFunctionTable[508974] = ADXB_CheckWav_0x2f10c0; // 0x2f10c0 - g_ps2RecompiledFunctionTable[508982] = ADXB_CheckWav_0x2f10c0; // 0x2f10e0 - g_ps2RecompiledFunctionTable[508989] = ADXB_CheckWav_0x2f10c0; // 0x2f10fc - g_ps2RecompiledFunctionTable[508998] = ADXB_ExecOneWav_0x2f1120; // 0x2f1120 - g_ps2RecompiledFunctionTable[509014] = ADXCRS_Init_0x2f1160; // 0x2f1160 - g_ps2RecompiledFunctionTable[509016] = ADXCRS_Lock_0x2f1168; // 0x2f1168 - g_ps2RecompiledFunctionTable[509022] = ADXCRS_Lock_0x2f1168; // 0x2f1180 - g_ps2RecompiledFunctionTable[509028] = ADXCRS_Unlock_0x2f1198; // 0x2f1198 - g_ps2RecompiledFunctionTable[509036] = ADX_GetCoefficient_0x2f11b8; // 0x2f11b8 - g_ps2RecompiledFunctionTable[509061] = ADX_GetCoefficient_0x2f11b8; // 0x2f121c - g_ps2RecompiledFunctionTable[509064] = ADX_GetCoefficient_0x2f11b8; // 0x2f1228 - g_ps2RecompiledFunctionTable[509068] = ADX_GetCoefficient_0x2f11b8; // 0x2f1238 - g_ps2RecompiledFunctionTable[509071] = ADX_GetCoefficient_0x2f11b8; // 0x2f1244 - g_ps2RecompiledFunctionTable[509074] = ADX_GetCoefficient_0x2f11b8; // 0x2f1250 - g_ps2RecompiledFunctionTable[509076] = ADX_GetCoefficient_0x2f11b8; // 0x2f1258 - g_ps2RecompiledFunctionTable[509078] = ADX_GetCoefficient_0x2f11b8; // 0x2f1260 - g_ps2RecompiledFunctionTable[509080] = ADX_GetCoefficient_0x2f11b8; // 0x2f1268 - g_ps2RecompiledFunctionTable[509087] = ADX_GetCoefficient_0x2f11b8; // 0x2f1284 - g_ps2RecompiledFunctionTable[509089] = ADX_GetCoefficient_0x2f11b8; // 0x2f128c - g_ps2RecompiledFunctionTable[509093] = ADX_GetCoefficient_0x2f11b8; // 0x2f129c - g_ps2RecompiledFunctionTable[509097] = ADX_GetCoefficient_0x2f11b8; // 0x2f12ac - g_ps2RecompiledFunctionTable[509101] = ADX_GetCoefficient_0x2f11b8; // 0x2f12bc - g_ps2RecompiledFunctionTable[509104] = ADX_GetCoefficient_0x2f11b8; // 0x2f12c8 - g_ps2RecompiledFunctionTable[509107] = ADX_GetCoefficient_0x2f11b8; // 0x2f12d4 - g_ps2RecompiledFunctionTable[509115] = ADX_GetCoefficient_0x2f11b8; // 0x2f12f4 - g_ps2RecompiledFunctionTable[509117] = ADX_GetCoefficient_0x2f11b8; // 0x2f12fc - g_ps2RecompiledFunctionTable[509121] = ADX_GetCoefficient_0x2f11b8; // 0x2f130c - g_ps2RecompiledFunctionTable[509124] = ADX_GetCoefficient_0x2f11b8; // 0x2f1318 - g_ps2RecompiledFunctionTable[509127] = ADX_GetCoefficient_0x2f11b8; // 0x2f1324 - g_ps2RecompiledFunctionTable[509131] = ADX_GetCoefficient_0x2f11b8; // 0x2f1334 - g_ps2RecompiledFunctionTable[509134] = ADX_GetCoefficient_0x2f11b8; // 0x2f1340 - g_ps2RecompiledFunctionTable[509136] = ADX_GetCoefficient_0x2f11b8; // 0x2f1348 - g_ps2RecompiledFunctionTable[509140] = ADX_GetCoefficient_0x2f11b8; // 0x2f1358 - g_ps2RecompiledFunctionTable[509143] = ADX_GetCoefficient_0x2f11b8; // 0x2f1364 - g_ps2RecompiledFunctionTable[509146] = ADX_GetCoefficient_0x2f11b8; // 0x2f1370 - g_ps2RecompiledFunctionTable[509148] = ADX_GetCoefficient_0x2f11b8; // 0x2f1378 - g_ps2RecompiledFunctionTable[509162] = ADX_ScanInfoCode_0x2f13b0; // 0x2f13b0 - g_ps2RecompiledFunctionTable[509174] = ADX_ScanInfoCode_0x2f13b0; // 0x2f13e0 - g_ps2RecompiledFunctionTable[509192] = ADX_DecodeInfo_0x2f1428; // 0x2f1428 - g_ps2RecompiledFunctionTable[509254] = ADX_DecodeInfoExADPCM2_0x2f1520; // 0x2f1520 - g_ps2RecompiledFunctionTable[509257] = ADX_DecodeInfoExADPCM2_0x2f1520; // 0x2f152c - g_ps2RecompiledFunctionTable[509286] = ADX_DecodeInfoExLoop_0x2f15a0; // 0x2f15a0 - g_ps2RecompiledFunctionTable[509292] = ADX_DecodeInfoExLoop_0x2f15a0; // 0x2f15b8 - g_ps2RecompiledFunctionTable[509302] = ADX_DecodeInfoExLoop_0x2f15a0; // 0x2f15e0 - g_ps2RecompiledFunctionTable[509386] = ADX_DecodeFooter_0x2f1730; // 0x2f1730 - g_ps2RecompiledFunctionTable[509410] = ADX_SetDecodeSteAsMonoSw_0x2f1790; // 0x2f1790 - g_ps2RecompiledFunctionTable[509412] = ADX_DecodeMonoFloat_0x2f1798; // 0x2f1798 - g_ps2RecompiledFunctionTable[509438] = ADX_DecodeMonoFloat_0x2f1798; // 0x2f1800 - g_ps2RecompiledFunctionTable[509458] = ADX_DecodeMonoFloat_0x2f1798; // 0x2f1850 - g_ps2RecompiledFunctionTable[509504] = ADX_DecodeSteFloatAsSte_0x2f1908; // 0x2f1908 - g_ps2RecompiledFunctionTable[509552] = ADX_DecodeSteFloatAsSte_0x2f1908; // 0x2f19c8 - g_ps2RecompiledFunctionTable[509588] = ADX_DecodeSteFloatAsSte_0x2f1908; // 0x2f1a58 - g_ps2RecompiledFunctionTable[509674] = ADX_DecodeSteFloatAsMono_0x2f1bb0; // 0x2f1bb0 - g_ps2RecompiledFunctionTable[509722] = ADX_DecodeSteFloatAsMono_0x2f1bb0; // 0x2f1c70 - g_ps2RecompiledFunctionTable[509760] = ADX_DecodeSteFloatAsMono_0x2f1bb0; // 0x2f1d08 - g_ps2RecompiledFunctionTable[509844] = ADX_DecodeSteFloat_0x2f1e58; // 0x2f1e58 - g_ps2RecompiledFunctionTable[509854] = ADX_DecodeSteFloat_0x2f1e58; // 0x2f1e80 - g_ps2RecompiledFunctionTable[509858] = ADX_DecodeSteFloat_0x2f1e58; // 0x2f1e90 - g_ps2RecompiledFunctionTable[509862] = ADXERR_Init_0x2f1ea0; // 0x2f1ea0 - g_ps2RecompiledFunctionTable[509869] = ADXERR_Init_0x2f1ea0; // 0x2f1ebc - g_ps2RecompiledFunctionTable[509874] = ADXERR_Finish_0x2f1ed0; // 0x2f1ed0 - g_ps2RecompiledFunctionTable[509881] = ADXERR_Finish_0x2f1ed0; // 0x2f1eec - g_ps2RecompiledFunctionTable[509886] = ADXERR_EntryErrFunc_0x2f1f00; // 0x2f1f00 - g_ps2RecompiledFunctionTable[509890] = ADXERR_CallErrFunc1_0x2f1f10; // 0x2f1f10 - g_ps2RecompiledFunctionTable[509891] = ADXERR_CallErrFunc1_0x2f1f10; // 0x2f1f14 - g_ps2RecompiledFunctionTable[509892] = ADXERR_CallErrFunc1_0x2f1f10; // 0x2f1f18 - g_ps2RecompiledFunctionTable[509893] = ADXERR_CallErrFunc1_0x2f1f10; // 0x2f1f1c - g_ps2RecompiledFunctionTable[509894] = ADXERR_CallErrFunc1_0x2f1f10; // 0x2f1f20 - g_ps2RecompiledFunctionTable[509895] = ADXERR_CallErrFunc1_0x2f1f10; // 0x2f1f24 - g_ps2RecompiledFunctionTable[509896] = ADXERR_CallErrFunc1_0x2f1f10; // 0x2f1f28 - g_ps2RecompiledFunctionTable[509897] = ADXERR_CallErrFunc1_0x2f1f10; // 0x2f1f2c - g_ps2RecompiledFunctionTable[509898] = ADXERR_CallErrFunc1_0x2f1f10; // 0x2f1f30 - g_ps2RecompiledFunctionTable[509899] = ADXERR_CallErrFunc1_0x2f1f10; // 0x2f1f34 - g_ps2RecompiledFunctionTable[509900] = ADXERR_CallErrFunc1_0x2f1f10; // 0x2f1f38 - g_ps2RecompiledFunctionTable[509901] = ADXERR_CallErrFunc1_0x2f1f10; // 0x2f1f3c - g_ps2RecompiledFunctionTable[509902] = ADXERR_CallErrFunc1_0x2f1f10; // 0x2f1f40 - g_ps2RecompiledFunctionTable[509903] = ADXERR_CallErrFunc1_0x2f1f10; // 0x2f1f44 - g_ps2RecompiledFunctionTable[509904] = ADXERR_CallErrFunc1_0x2f1f10; // 0x2f1f48 - g_ps2RecompiledFunctionTable[509905] = ADXERR_CallErrFunc1_0x2f1f10; // 0x2f1f4c - g_ps2RecompiledFunctionTable[509906] = ADXERR_CallErrFunc1_0x2f1f10; // 0x2f1f50 - g_ps2RecompiledFunctionTable[509907] = ADXERR_CallErrFunc1_0x2f1f10; // 0x2f1f54 - g_ps2RecompiledFunctionTable[509908] = ADXERR_CallErrFunc2_0x2f1f58; // 0x2f1f58 - g_ps2RecompiledFunctionTable[509909] = ADXERR_CallErrFunc2_0x2f1f58; // 0x2f1f5c - g_ps2RecompiledFunctionTable[509910] = ADXERR_CallErrFunc2_0x2f1f58; // 0x2f1f60 - g_ps2RecompiledFunctionTable[509911] = ADXERR_CallErrFunc2_0x2f1f58; // 0x2f1f64 - g_ps2RecompiledFunctionTable[509912] = ADXERR_CallErrFunc2_0x2f1f58; // 0x2f1f68 - g_ps2RecompiledFunctionTable[509913] = ADXERR_CallErrFunc2_0x2f1f58; // 0x2f1f6c - g_ps2RecompiledFunctionTable[509914] = ADXERR_CallErrFunc2_0x2f1f58; // 0x2f1f70 - g_ps2RecompiledFunctionTable[509915] = ADXERR_CallErrFunc2_0x2f1f58; // 0x2f1f74 - g_ps2RecompiledFunctionTable[509916] = ADXERR_CallErrFunc2_0x2f1f58; // 0x2f1f78 - g_ps2RecompiledFunctionTable[509917] = ADXERR_CallErrFunc2_0x2f1f58; // 0x2f1f7c - g_ps2RecompiledFunctionTable[509918] = ADXERR_CallErrFunc2_0x2f1f58; // 0x2f1f80 - g_ps2RecompiledFunctionTable[509919] = ADXERR_CallErrFunc2_0x2f1f58; // 0x2f1f84 - g_ps2RecompiledFunctionTable[509920] = ADXERR_CallErrFunc2_0x2f1f58; // 0x2f1f88 - g_ps2RecompiledFunctionTable[509921] = ADXERR_CallErrFunc2_0x2f1f58; // 0x2f1f8c - g_ps2RecompiledFunctionTable[509922] = ADXERR_CallErrFunc2_0x2f1f58; // 0x2f1f90 - g_ps2RecompiledFunctionTable[509923] = ADXERR_CallErrFunc2_0x2f1f58; // 0x2f1f94 - g_ps2RecompiledFunctionTable[509924] = ADXERR_CallErrFunc2_0x2f1f58; // 0x2f1f98 - g_ps2RecompiledFunctionTable[509925] = ADXERR_CallErrFunc2_0x2f1f58; // 0x2f1f9c - g_ps2RecompiledFunctionTable[509926] = ADXERR_CallErrFunc2_0x2f1f58; // 0x2f1fa0 - g_ps2RecompiledFunctionTable[509927] = ADXERR_CallErrFunc2_0x2f1f58; // 0x2f1fa4 - g_ps2RecompiledFunctionTable[509928] = ADXERR_CallErrFunc2_0x2f1f58; // 0x2f1fa8 - g_ps2RecompiledFunctionTable[509929] = ADXERR_CallErrFunc2_0x2f1f58; // 0x2f1fac - g_ps2RecompiledFunctionTable[509930] = ADXERR_CallErrFunc2_0x2f1f58; // 0x2f1fb0 - g_ps2RecompiledFunctionTable[509931] = ADXERR_CallErrFunc2_0x2f1f58; // 0x2f1fb4 - g_ps2RecompiledFunctionTable[509932] = ADXERR_CallErrFunc2_0x2f1f58; // 0x2f1fb8 - g_ps2RecompiledFunctionTable[509934] = ADXERR_ItoA_0x2f1fc0; // 0x2f1fc0 - g_ps2RecompiledFunctionTable[509956] = ADXERR_ItoA_0x2f1fc0; // 0x2f2018 - g_ps2RecompiledFunctionTable[509973] = ADXERR_ItoA_0x2f1fc0; // 0x2f205c - g_ps2RecompiledFunctionTable[509980] = ADXERR_ItoA_0x2f1fc0; // 0x2f2078 - g_ps2RecompiledFunctionTable[509996] = ADXERR_ItoA2_0x2f20b8; // 0x2f20b8 - g_ps2RecompiledFunctionTable[510008] = ADXERR_ItoA2_0x2f20b8; // 0x2f20e8 - g_ps2RecompiledFunctionTable[510012] = ADXERR_ItoA2_0x2f20b8; // 0x2f20f8 - g_ps2RecompiledFunctionTable[510017] = ADXERR_ItoA2_0x2f20b8; // 0x2f210c - g_ps2RecompiledFunctionTable[510019] = ADXERR_ItoA2_0x2f20b8; // 0x2f2114 - g_ps2RecompiledFunctionTable[510022] = ADXERR_ItoA2_0x2f20b8; // 0x2f2120 - g_ps2RecompiledFunctionTable[510034] = ADXF_Ocbi_0x2f2150; // 0x2f2150 - g_ps2RecompiledFunctionTable[510040] = ADXF_Init_0x2f2168; // 0x2f2168 - g_ps2RecompiledFunctionTable[510054] = ADXF_Init_0x2f2168; // 0x2f21a0 - g_ps2RecompiledFunctionTable[510059] = ADXF_Init_0x2f2168; // 0x2f21b4 - g_ps2RecompiledFunctionTable[510064] = ADXF_Init_0x2f2168; // 0x2f21c8 - g_ps2RecompiledFunctionTable[510069] = ADXF_Init_0x2f2168; // 0x2f21dc - g_ps2RecompiledFunctionTable[510088] = ADXF_Finish_0x2f2228; // 0x2f2228 - g_ps2RecompiledFunctionTable[510097] = ADXF_Finish_0x2f2228; // 0x2f224c - g_ps2RecompiledFunctionTable[510113] = ADXF_Finish_0x2f2228; // 0x2f228c - g_ps2RecompiledFunctionTable[510118] = ADXF_Finish_0x2f2228; // 0x2f22a0 - g_ps2RecompiledFunctionTable[510123] = ADXF_Finish_0x2f2228; // 0x2f22b4 - g_ps2RecompiledFunctionTable[510134] = adxf_SetCmdHstry_0x2f22e0; // 0x2f22e0 - g_ps2RecompiledFunctionTable[510174] = adxf_wait_1ms_0x2f2380; // 0x2f2380 - g_ps2RecompiledFunctionTable[510176] = adxf_wait_1ms_0x2f2380; // 0x2f2388 - g_ps2RecompiledFunctionTable[510186] = adxf_ChkPrmPt_0x2f23b0; // 0x2f23b0 - g_ps2RecompiledFunctionTable[510199] = adxf_ChkPrmPt_0x2f23b0; // 0x2f23e4 - g_ps2RecompiledFunctionTable[510204] = adxf_LoadData_0x2f23f8; // 0x2f23f8 - g_ps2RecompiledFunctionTable[510214] = adxf_LoadData_0x2f23f8; // 0x2f2420 - g_ps2RecompiledFunctionTable[510216] = adxf_LoadData_0x2f23f8; // 0x2f2428 - g_ps2RecompiledFunctionTable[510218] = adxf_LoadData_0x2f23f8; // 0x2f2430 - g_ps2RecompiledFunctionTable[510220] = adxf_LoadData_0x2f23f8; // 0x2f2438 - g_ps2RecompiledFunctionTable[510222] = adxf_LoadData_0x2f23f8; // 0x2f2440 - g_ps2RecompiledFunctionTable[510226] = adxf_LoadData_0x2f23f8; // 0x2f2450 - g_ps2RecompiledFunctionTable[510230] = adxf_LoadData_0x2f23f8; // 0x2f2460 - g_ps2RecompiledFunctionTable[510232] = adxf_LoadData_0x2f23f8; // 0x2f2468 - g_ps2RecompiledFunctionTable[510234] = adxf_LoadData_0x2f23f8; // 0x2f2470 - g_ps2RecompiledFunctionTable[510236] = adxf_LoadData_0x2f23f8; // 0x2f2478 - g_ps2RecompiledFunctionTable[510238] = adxf_LoadData_0x2f23f8; // 0x2f2480 - g_ps2RecompiledFunctionTable[510240] = adxf_LoadData_0x2f23f8; // 0x2f2488 - g_ps2RecompiledFunctionTable[510244] = adxf_LoadData_0x2f23f8; // 0x2f2498 - g_ps2RecompiledFunctionTable[510250] = ADXF_LoadPartition_0x2f24b0; // 0x2f24b0 - g_ps2RecompiledFunctionTable[510267] = ADXF_LoadPartition_0x2f24b0; // 0x2f24f4 - g_ps2RecompiledFunctionTable[510273] = ADXF_LoadPartition_0x2f24b0; // 0x2f250c - g_ps2RecompiledFunctionTable[510278] = ADXF_LoadPartition_0x2f24b0; // 0x2f2520 - g_ps2RecompiledFunctionTable[510280] = ADXF_LoadPartition_0x2f24b0; // 0x2f2528 - g_ps2RecompiledFunctionTable[510283] = ADXF_LoadPartition_0x2f24b0; // 0x2f2534 - g_ps2RecompiledFunctionTable[510290] = ADXF_LoadPartition_0x2f24b0; // 0x2f2550 - g_ps2RecompiledFunctionTable[510302] = ADXF_LoadPartition_0x2f24b0; // 0x2f2580 - g_ps2RecompiledFunctionTable[510318] = ADXF_LoadPartition_0x2f24b0; // 0x2f25c0 - g_ps2RecompiledFunctionTable[510321] = ADXF_LoadPartition_0x2f24b0; // 0x2f25cc - g_ps2RecompiledFunctionTable[510354] = ADXF_LoadPartition_0x2f24b0; // 0x2f2650 - g_ps2RecompiledFunctionTable[510381] = ADXF_LoadPartition_0x2f24b0; // 0x2f26bc - g_ps2RecompiledFunctionTable[510386] = ADXF_LoadPartition_0x2f24b0; // 0x2f26d0 - g_ps2RecompiledFunctionTable[510388] = ADXF_LoadPartition_0x2f24b0; // 0x2f26d8 - g_ps2RecompiledFunctionTable[510402] = ADXF_LoadPartitionEx_0x2f2710; // 0x2f2710 - g_ps2RecompiledFunctionTable[510419] = ADXF_LoadPartitionEx_0x2f2710; // 0x2f2754 - g_ps2RecompiledFunctionTable[510425] = ADXF_LoadPartitionEx_0x2f2710; // 0x2f276c - g_ps2RecompiledFunctionTable[510431] = ADXF_LoadPartitionEx_0x2f2710; // 0x2f2784 - g_ps2RecompiledFunctionTable[510433] = ADXF_LoadPartitionEx_0x2f2710; // 0x2f278c - g_ps2RecompiledFunctionTable[510438] = ADXF_LoadPartitionEx_0x2f2710; // 0x2f27a0 - g_ps2RecompiledFunctionTable[510440] = ADXF_LoadPartitionEx_0x2f2710; // 0x2f27a8 - g_ps2RecompiledFunctionTable[510446] = ADXF_LoadPartitionEx_0x2f2710; // 0x2f27c0 - g_ps2RecompiledFunctionTable[510458] = ADXF_LoadPartitionEx_0x2f2710; // 0x2f27f0 - g_ps2RecompiledFunctionTable[510474] = ADXF_LoadPartitionEx_0x2f2710; // 0x2f2830 - g_ps2RecompiledFunctionTable[510477] = ADXF_LoadPartitionEx_0x2f2710; // 0x2f283c - g_ps2RecompiledFunctionTable[510508] = ADXF_LoadPartitionEx_0x2f2710; // 0x2f28b8 - g_ps2RecompiledFunctionTable[510534] = ADXF_LoadPartitionEx_0x2f2710; // 0x2f2920 - g_ps2RecompiledFunctionTable[510536] = ADXF_LoadPartitionEx_0x2f2710; // 0x2f2928 - g_ps2RecompiledFunctionTable[510550] = ADXF_LoadPartitionNw_0x2f2960; // 0x2f2960 - g_ps2RecompiledFunctionTable[510564] = ADXF_LoadPartitionNw_0x2f2960; // 0x2f2998 - g_ps2RecompiledFunctionTable[510574] = ADXF_LoadPartitionNw_0x2f2960; // 0x2f29c0 - g_ps2RecompiledFunctionTable[510581] = ADXF_LoadPartitionNw_0x2f2960; // 0x2f29dc - g_ps2RecompiledFunctionTable[510590] = ADXF_LoadPartitionNw_0x2f2960; // 0x2f2a00 - g_ps2RecompiledFunctionTable[510600] = ADXF_LoadPartitionNw_0x2f2960; // 0x2f2a28 - g_ps2RecompiledFunctionTable[510615] = ADXF_LoadPartitionNw_0x2f2960; // 0x2f2a64 - g_ps2RecompiledFunctionTable[510620] = ADXF_LoadPartitionNw_0x2f2960; // 0x2f2a78 - g_ps2RecompiledFunctionTable[510632] = adxf_CloseLdptnwHn_0x2f2aa8; // 0x2f2aa8 - g_ps2RecompiledFunctionTable[510638] = adxf_CloseLdptnwHn_0x2f2aa8; // 0x2f2ac0 - g_ps2RecompiledFunctionTable[510648] = ADXF_StopPtLd_0x2f2ae8; // 0x2f2ae8 - g_ps2RecompiledFunctionTable[510660] = ADXF_StopPtLd_0x2f2ae8; // 0x2f2b18 - g_ps2RecompiledFunctionTable[510665] = ADXF_StopPtLd_0x2f2ae8; // 0x2f2b2c - g_ps2RecompiledFunctionTable[510674] = ADXF_GetPtStat_0x2f2b50; // 0x2f2b50 - g_ps2RecompiledFunctionTable[510690] = ADXF_GetPtStat_0x2f2b50; // 0x2f2b90 - g_ps2RecompiledFunctionTable[510696] = ADXF_GetPtStat_0x2f2b50; // 0x2f2ba8 - g_ps2RecompiledFunctionTable[510714] = ADXF_GetPtStat_0x2f2b50; // 0x2f2bf0 - g_ps2RecompiledFunctionTable[510727] = ADXF_GetPtStat_0x2f2b50; // 0x2f2c24 - g_ps2RecompiledFunctionTable[510729] = ADXF_GetPtStat_0x2f2b50; // 0x2f2c2c - g_ps2RecompiledFunctionTable[510748] = ADXF_GetPtStat_0x2f2b50; // 0x2f2c78 - g_ps2RecompiledFunctionTable[510750] = ADXF_GetPtStat_0x2f2b50; // 0x2f2c80 - g_ps2RecompiledFunctionTable[510758] = ADXF_GetPtStat_0x2f2b50; // 0x2f2ca0 - g_ps2RecompiledFunctionTable[510786] = ADXF_GetPtStat_0x2f2b50; // 0x2f2d10 - g_ps2RecompiledFunctionTable[510790] = ADXF_GetPtStat_0x2f2b50; // 0x2f2d20 - g_ps2RecompiledFunctionTable[510804] = ADXF_AddPartition_0x2f2d58; // 0x2f2d58 - g_ps2RecompiledFunctionTable[510821] = ADXF_AddPartition_0x2f2d58; // 0x2f2d9c - g_ps2RecompiledFunctionTable[510826] = ADXF_AddPartition_0x2f2d58; // 0x2f2db0 - g_ps2RecompiledFunctionTable[510832] = ADXF_AddPartition_0x2f2d58; // 0x2f2dc8 - g_ps2RecompiledFunctionTable[510834] = ADXF_AddPartition_0x2f2d58; // 0x2f2dd0 - g_ps2RecompiledFunctionTable[510839] = ADXF_AddPartition_0x2f2d58; // 0x2f2de4 - g_ps2RecompiledFunctionTable[510841] = ADXF_AddPartition_0x2f2d58; // 0x2f2dec - g_ps2RecompiledFunctionTable[510855] = ADXF_AddPartition_0x2f2d58; // 0x2f2e24 - g_ps2RecompiledFunctionTable[510872] = ADXF_AddPartition_0x2f2d58; // 0x2f2e68 - g_ps2RecompiledFunctionTable[510876] = ADXF_AddPartition_0x2f2d58; // 0x2f2e78 - g_ps2RecompiledFunctionTable[510902] = ADXF_AddPartition_0x2f2d58; // 0x2f2ee0 - g_ps2RecompiledFunctionTable[510942] = ADXF_AddPartition_0x2f2d58; // 0x2f2f80 - g_ps2RecompiledFunctionTable[510952] = ADXF_AddPartition_0x2f2d58; // 0x2f2fa8 - g_ps2RecompiledFunctionTable[510966] = ADXF_GetPtinfoSize_0x2f2fe0; // 0x2f2fe0 - g_ps2RecompiledFunctionTable[510974] = adxf_AllocAdxFs_0x2f3000; // 0x2f3000 - g_ps2RecompiledFunctionTable[510983] = adxf_AllocAdxFs_0x2f3000; // 0x2f3024 - g_ps2RecompiledFunctionTable[510996] = adxf_CreateAdxFs_0x2f3058; // 0x2f3058 - g_ps2RecompiledFunctionTable[511000] = adxf_CreateAdxFs_0x2f3058; // 0x2f3068 - g_ps2RecompiledFunctionTable[511020] = adxf_SetFileInfoEx_0x2f30b8; // 0x2f30b8 - g_ps2RecompiledFunctionTable[511033] = adxf_SetFileInfoEx_0x2f30b8; // 0x2f30ec - g_ps2RecompiledFunctionTable[511039] = adxf_SetFileInfoEx_0x2f30b8; // 0x2f3104 - g_ps2RecompiledFunctionTable[511043] = adxf_SetFileInfoEx_0x2f30b8; // 0x2f3114 - g_ps2RecompiledFunctionTable[511056] = ADXF_Open_0x2f3148; // 0x2f3148 - g_ps2RecompiledFunctionTable[511069] = ADXF_Open_0x2f3148; // 0x2f317c - g_ps2RecompiledFunctionTable[511071] = ADXF_Open_0x2f3148; // 0x2f3184 - g_ps2RecompiledFunctionTable[511073] = ADXF_Open_0x2f3148; // 0x2f318c - g_ps2RecompiledFunctionTable[511079] = ADXF_Open_0x2f3148; // 0x2f31a4 - g_ps2RecompiledFunctionTable[511083] = ADXF_Open_0x2f3148; // 0x2f31b4 - g_ps2RecompiledFunctionTable[511086] = ADXF_Open_0x2f3148; // 0x2f31c0 - g_ps2RecompiledFunctionTable[511092] = ADXF_Open_0x2f3148; // 0x2f31d8 - g_ps2RecompiledFunctionTable[511100] = adxf_SetAfsFileInfo_0x2f31f8; // 0x2f31f8 - g_ps2RecompiledFunctionTable[511111] = adxf_SetAfsFileInfo_0x2f31f8; // 0x2f3224 - g_ps2RecompiledFunctionTable[511122] = adxf_SetAfsFileInfo_0x2f31f8; // 0x2f3250 - g_ps2RecompiledFunctionTable[511127] = adxf_SetAfsFileInfo_0x2f31f8; // 0x2f3264 - g_ps2RecompiledFunctionTable[511138] = ADXF_OpenAfs_0x2f3290; // 0x2f3290 - g_ps2RecompiledFunctionTable[511151] = ADXF_OpenAfs_0x2f3290; // 0x2f32c4 - g_ps2RecompiledFunctionTable[511153] = ADXF_OpenAfs_0x2f3290; // 0x2f32cc - g_ps2RecompiledFunctionTable[511155] = ADXF_OpenAfs_0x2f3290; // 0x2f32d4 - g_ps2RecompiledFunctionTable[511161] = ADXF_OpenAfs_0x2f3290; // 0x2f32ec - g_ps2RecompiledFunctionTable[511165] = ADXF_OpenAfs_0x2f3290; // 0x2f32fc - g_ps2RecompiledFunctionTable[511168] = ADXF_OpenAfs_0x2f3290; // 0x2f3308 - g_ps2RecompiledFunctionTable[511174] = ADXF_OpenAfs_0x2f3290; // 0x2f3320 - g_ps2RecompiledFunctionTable[511182] = adxf_CloseSjStm_0x2f3340; // 0x2f3340 - g_ps2RecompiledFunctionTable[511183] = adxf_CloseSjStm_0x2f3340; // 0x2f3344 - g_ps2RecompiledFunctionTable[511184] = adxf_CloseSjStm_0x2f3340; // 0x2f3348 - g_ps2RecompiledFunctionTable[511185] = adxf_CloseSjStm_0x2f3340; // 0x2f334c - g_ps2RecompiledFunctionTable[511186] = adxf_CloseSjStm_0x2f3340; // 0x2f3350 - g_ps2RecompiledFunctionTable[511187] = adxf_CloseSjStm_0x2f3340; // 0x2f3354 - g_ps2RecompiledFunctionTable[511188] = adxf_CloseSjStm_0x2f3340; // 0x2f3358 - g_ps2RecompiledFunctionTable[511189] = adxf_CloseSjStm_0x2f3340; // 0x2f335c - g_ps2RecompiledFunctionTable[511190] = adxf_CloseSjStm_0x2f3340; // 0x2f3360 - g_ps2RecompiledFunctionTable[511191] = adxf_CloseSjStm_0x2f3340; // 0x2f3364 - g_ps2RecompiledFunctionTable[511192] = adxf_CloseSjStm_0x2f3340; // 0x2f3368 - g_ps2RecompiledFunctionTable[511193] = adxf_CloseSjStm_0x2f3340; // 0x2f336c - g_ps2RecompiledFunctionTable[511194] = adxf_CloseSjStm_0x2f3340; // 0x2f3370 - g_ps2RecompiledFunctionTable[511195] = adxf_CloseSjStm_0x2f3340; // 0x2f3374 - g_ps2RecompiledFunctionTable[511196] = adxf_CloseSjStm_0x2f3340; // 0x2f3378 - g_ps2RecompiledFunctionTable[511197] = adxf_CloseSjStm_0x2f3340; // 0x2f337c - g_ps2RecompiledFunctionTable[511198] = adxf_CloseSjStm_0x2f3340; // 0x2f3380 - g_ps2RecompiledFunctionTable[511199] = adxf_CloseSjStm_0x2f3340; // 0x2f3384 - g_ps2RecompiledFunctionTable[511200] = adxf_CloseSjStm_0x2f3340; // 0x2f3388 - g_ps2RecompiledFunctionTable[511201] = adxf_CloseSjStm_0x2f3340; // 0x2f338c - g_ps2RecompiledFunctionTable[511202] = adxf_CloseSjStm_0x2f3340; // 0x2f3390 - g_ps2RecompiledFunctionTable[511203] = adxf_CloseSjStm_0x2f3340; // 0x2f3394 - g_ps2RecompiledFunctionTable[511204] = adxf_CloseSjStm_0x2f3340; // 0x2f3398 - g_ps2RecompiledFunctionTable[511205] = adxf_CloseSjStm_0x2f3340; // 0x2f339c - g_ps2RecompiledFunctionTable[511206] = adxf_CloseSjStm_0x2f3340; // 0x2f33a0 - g_ps2RecompiledFunctionTable[511207] = adxf_CloseSjStm_0x2f3340; // 0x2f33a4 - g_ps2RecompiledFunctionTable[511208] = adxf_CloseSjStm_0x2f3340; // 0x2f33a8 - g_ps2RecompiledFunctionTable[511209] = adxf_CloseSjStm_0x2f3340; // 0x2f33ac - g_ps2RecompiledFunctionTable[511210] = ADXF_Close_0x2f33b0; // 0x2f33b0 - g_ps2RecompiledFunctionTable[511220] = ADXF_Close_0x2f33b0; // 0x2f33d8 - g_ps2RecompiledFunctionTable[511224] = ADXF_Close_0x2f33b0; // 0x2f33e8 - g_ps2RecompiledFunctionTable[511230] = ADXF_Close_0x2f33b0; // 0x2f3400 - g_ps2RecompiledFunctionTable[511235] = ADXF_Close_0x2f33b0; // 0x2f3414 - g_ps2RecompiledFunctionTable[511239] = ADXF_Close_0x2f33b0; // 0x2f3424 - g_ps2RecompiledFunctionTable[511241] = ADXF_Close_0x2f33b0; // 0x2f342c - g_ps2RecompiledFunctionTable[511254] = ADXF_CloseAll_0x2f3460; // 0x2f3460 - g_ps2RecompiledFunctionTable[511264] = ADXF_CloseAll_0x2f3460; // 0x2f3488 - g_ps2RecompiledFunctionTable[511268] = ADXF_CloseAll_0x2f3460; // 0x2f3498 - g_ps2RecompiledFunctionTable[511278] = adxf_read_sj32_0x2f34c0; // 0x2f34c0 - g_ps2RecompiledFunctionTable[511288] = adxf_read_sj32_0x2f34c0; // 0x2f34e8 - g_ps2RecompiledFunctionTable[511293] = adxf_read_sj32_0x2f34c0; // 0x2f34fc - g_ps2RecompiledFunctionTable[511295] = adxf_read_sj32_0x2f34c0; // 0x2f3504 - g_ps2RecompiledFunctionTable[511312] = adxf_read_sj32_0x2f34c0; // 0x2f3548 - g_ps2RecompiledFunctionTable[511315] = adxf_read_sj32_0x2f34c0; // 0x2f3554 - g_ps2RecompiledFunctionTable[511318] = adxf_read_sj32_0x2f34c0; // 0x2f3560 - g_ps2RecompiledFunctionTable[511322] = adxf_read_sj32_0x2f34c0; // 0x2f3570 - g_ps2RecompiledFunctionTable[511325] = adxf_read_sj32_0x2f34c0; // 0x2f357c - g_ps2RecompiledFunctionTable[511332] = ADXF_ReadSj32_0x2f3598; // 0x2f3598 - g_ps2RecompiledFunctionTable[511354] = ADXF_ReadSj32_0x2f3598; // 0x2f35f0 - g_ps2RecompiledFunctionTable[511361] = ADXF_ReadSj32_0x2f3598; // 0x2f360c - g_ps2RecompiledFunctionTable[511365] = ADXF_ReadSj32_0x2f3598; // 0x2f361c - g_ps2RecompiledFunctionTable[511369] = ADXF_ReadSj32_0x2f3598; // 0x2f362c - g_ps2RecompiledFunctionTable[511376] = ADXF_ReadNw32_0x2f3648; // 0x2f3648 - g_ps2RecompiledFunctionTable[511377] = ADXF_ReadNw32_0x2f3648; // 0x2f364c - g_ps2RecompiledFunctionTable[511378] = ADXF_ReadNw32_0x2f3648; // 0x2f3650 - g_ps2RecompiledFunctionTable[511379] = ADXF_ReadNw32_0x2f3648; // 0x2f3654 - g_ps2RecompiledFunctionTable[511380] = ADXF_ReadNw32_0x2f3648; // 0x2f3658 - g_ps2RecompiledFunctionTable[511381] = ADXF_ReadNw32_0x2f3648; // 0x2f365c - g_ps2RecompiledFunctionTable[511382] = ADXF_ReadNw32_0x2f3648; // 0x2f3660 - g_ps2RecompiledFunctionTable[511383] = ADXF_ReadNw32_0x2f3648; // 0x2f3664 - g_ps2RecompiledFunctionTable[511384] = ADXF_ReadNw32_0x2f3648; // 0x2f3668 - g_ps2RecompiledFunctionTable[511385] = ADXF_ReadNw32_0x2f3648; // 0x2f366c - g_ps2RecompiledFunctionTable[511386] = ADXF_ReadNw32_0x2f3648; // 0x2f3670 - g_ps2RecompiledFunctionTable[511387] = ADXF_ReadNw32_0x2f3648; // 0x2f3674 - g_ps2RecompiledFunctionTable[511388] = ADXF_ReadNw32_0x2f3648; // 0x2f3678 - g_ps2RecompiledFunctionTable[511389] = ADXF_ReadNw32_0x2f3648; // 0x2f367c - g_ps2RecompiledFunctionTable[511390] = ADXF_ReadNw32_0x2f3648; // 0x2f3680 - g_ps2RecompiledFunctionTable[511391] = ADXF_ReadNw32_0x2f3648; // 0x2f3684 - g_ps2RecompiledFunctionTable[511392] = ADXF_ReadNw32_0x2f3648; // 0x2f3688 - g_ps2RecompiledFunctionTable[511393] = ADXF_ReadNw32_0x2f3648; // 0x2f368c - g_ps2RecompiledFunctionTable[511394] = ADXF_ReadNw32_0x2f3648; // 0x2f3690 - g_ps2RecompiledFunctionTable[511395] = ADXF_ReadNw32_0x2f3648; // 0x2f3694 - g_ps2RecompiledFunctionTable[511396] = ADXF_ReadNw32_0x2f3648; // 0x2f3698 - g_ps2RecompiledFunctionTable[511397] = ADXF_ReadNw32_0x2f3648; // 0x2f369c - g_ps2RecompiledFunctionTable[511398] = ADXF_ReadNw32_0x2f3648; // 0x2f36a0 - g_ps2RecompiledFunctionTable[511399] = ADXF_ReadNw32_0x2f3648; // 0x2f36a4 - g_ps2RecompiledFunctionTable[511400] = ADXF_ReadNw32_0x2f3648; // 0x2f36a8 - g_ps2RecompiledFunctionTable[511401] = ADXF_ReadNw32_0x2f3648; // 0x2f36ac - g_ps2RecompiledFunctionTable[511402] = ADXF_ReadNw32_0x2f3648; // 0x2f36b0 - g_ps2RecompiledFunctionTable[511403] = ADXF_ReadNw32_0x2f3648; // 0x2f36b4 - g_ps2RecompiledFunctionTable[511404] = ADXF_ReadNw32_0x2f3648; // 0x2f36b8 - g_ps2RecompiledFunctionTable[511405] = ADXF_ReadNw32_0x2f3648; // 0x2f36bc - g_ps2RecompiledFunctionTable[511406] = ADXF_ReadNw32_0x2f3648; // 0x2f36c0 - g_ps2RecompiledFunctionTable[511407] = ADXF_ReadNw32_0x2f3648; // 0x2f36c4 - g_ps2RecompiledFunctionTable[511408] = ADXF_ReadNw32_0x2f3648; // 0x2f36c8 - g_ps2RecompiledFunctionTable[511409] = ADXF_ReadNw32_0x2f3648; // 0x2f36cc - g_ps2RecompiledFunctionTable[511410] = ADXF_ReadNw32_0x2f3648; // 0x2f36d0 - g_ps2RecompiledFunctionTable[511411] = ADXF_ReadNw32_0x2f3648; // 0x2f36d4 - g_ps2RecompiledFunctionTable[511412] = ADXF_ReadNw32_0x2f3648; // 0x2f36d8 - g_ps2RecompiledFunctionTable[511413] = ADXF_ReadNw32_0x2f3648; // 0x2f36dc - g_ps2RecompiledFunctionTable[511414] = ADXF_ReadNw32_0x2f3648; // 0x2f36e0 - g_ps2RecompiledFunctionTable[511415] = ADXF_ReadNw32_0x2f3648; // 0x2f36e4 - g_ps2RecompiledFunctionTable[511416] = ADXF_ReadNw32_0x2f3648; // 0x2f36e8 - g_ps2RecompiledFunctionTable[511417] = ADXF_ReadNw32_0x2f3648; // 0x2f36ec - g_ps2RecompiledFunctionTable[511418] = ADXF_ReadNw32_0x2f3648; // 0x2f36f0 - g_ps2RecompiledFunctionTable[511419] = ADXF_ReadNw32_0x2f3648; // 0x2f36f4 - g_ps2RecompiledFunctionTable[511420] = ADXF_ReadNw32_0x2f3648; // 0x2f36f8 - g_ps2RecompiledFunctionTable[511421] = ADXF_ReadNw32_0x2f3648; // 0x2f36fc - g_ps2RecompiledFunctionTable[511422] = ADXF_ReadNw32_0x2f3648; // 0x2f3700 - g_ps2RecompiledFunctionTable[511423] = ADXF_ReadNw32_0x2f3648; // 0x2f3704 - g_ps2RecompiledFunctionTable[511424] = ADXF_ReadNw32_0x2f3648; // 0x2f3708 - g_ps2RecompiledFunctionTable[511425] = ADXF_ReadNw32_0x2f3648; // 0x2f370c - g_ps2RecompiledFunctionTable[511426] = ADXF_ReadNw32_0x2f3648; // 0x2f3710 - g_ps2RecompiledFunctionTable[511427] = ADXF_ReadNw32_0x2f3648; // 0x2f3714 - g_ps2RecompiledFunctionTable[511428] = ADXF_ReadNw32_0x2f3648; // 0x2f3718 - g_ps2RecompiledFunctionTable[511429] = ADXF_ReadNw32_0x2f3648; // 0x2f371c - g_ps2RecompiledFunctionTable[511430] = ADXF_ReadNw32_0x2f3648; // 0x2f3720 - g_ps2RecompiledFunctionTable[511431] = ADXF_ReadNw32_0x2f3648; // 0x2f3724 - g_ps2RecompiledFunctionTable[511432] = ADXF_ReadNw32_0x2f3648; // 0x2f3728 - g_ps2RecompiledFunctionTable[511433] = ADXF_ReadNw32_0x2f3648; // 0x2f372c - g_ps2RecompiledFunctionTable[511434] = ADXF_ReadNw32_0x2f3648; // 0x2f3730 - g_ps2RecompiledFunctionTable[511435] = ADXF_ReadNw32_0x2f3648; // 0x2f3734 - g_ps2RecompiledFunctionTable[511436] = ADXF_ReadNw32_0x2f3648; // 0x2f3738 - g_ps2RecompiledFunctionTable[511437] = ADXF_ReadNw32_0x2f3648; // 0x2f373c - g_ps2RecompiledFunctionTable[511438] = ADXF_ReadNw32_0x2f3648; // 0x2f3740 - g_ps2RecompiledFunctionTable[511439] = ADXF_ReadNw32_0x2f3648; // 0x2f3744 - g_ps2RecompiledFunctionTable[511440] = ADXF_ReadNw32_0x2f3648; // 0x2f3748 - g_ps2RecompiledFunctionTable[511441] = ADXF_ReadNw32_0x2f3648; // 0x2f374c - g_ps2RecompiledFunctionTable[511442] = ADXF_ReadNw32_0x2f3648; // 0x2f3750 - g_ps2RecompiledFunctionTable[511443] = ADXF_ReadNw32_0x2f3648; // 0x2f3754 - g_ps2RecompiledFunctionTable[511444] = ADXF_ReadNw32_0x2f3648; // 0x2f3758 - g_ps2RecompiledFunctionTable[511445] = ADXF_ReadNw32_0x2f3648; // 0x2f375c - g_ps2RecompiledFunctionTable[511446] = ADXF_ReadNw32_0x2f3648; // 0x2f3760 - g_ps2RecompiledFunctionTable[511447] = ADXF_ReadNw32_0x2f3648; // 0x2f3764 - g_ps2RecompiledFunctionTable[511448] = ADXF_ReadNw32_0x2f3648; // 0x2f3768 - g_ps2RecompiledFunctionTable[511449] = ADXF_ReadNw32_0x2f3648; // 0x2f376c - g_ps2RecompiledFunctionTable[511450] = ADXF_ReadNw32_0x2f3648; // 0x2f3770 - g_ps2RecompiledFunctionTable[511451] = ADXF_ReadNw32_0x2f3648; // 0x2f3774 - g_ps2RecompiledFunctionTable[511452] = ADXF_ReadNw32_0x2f3648; // 0x2f3778 - g_ps2RecompiledFunctionTable[511453] = ADXF_ReadNw32_0x2f3648; // 0x2f377c - g_ps2RecompiledFunctionTable[511454] = ADXF_ReadNw32_0x2f3648; // 0x2f3780 - g_ps2RecompiledFunctionTable[511455] = ADXF_ReadNw32_0x2f3648; // 0x2f3784 - g_ps2RecompiledFunctionTable[511456] = ADXF_ReadNw32_0x2f3648; // 0x2f3788 - g_ps2RecompiledFunctionTable[511457] = ADXF_ReadNw32_0x2f3648; // 0x2f378c - g_ps2RecompiledFunctionTable[511458] = ADXF_ReadNw32_0x2f3648; // 0x2f3790 - g_ps2RecompiledFunctionTable[511459] = ADXF_ReadNw32_0x2f3648; // 0x2f3794 - g_ps2RecompiledFunctionTable[511460] = ADXF_ReadNw32_0x2f3648; // 0x2f3798 - g_ps2RecompiledFunctionTable[511461] = ADXF_ReadNw32_0x2f3648; // 0x2f379c - g_ps2RecompiledFunctionTable[511462] = ADXF_ReadNw32_0x2f3648; // 0x2f37a0 - g_ps2RecompiledFunctionTable[511463] = ADXF_ReadNw32_0x2f3648; // 0x2f37a4 - g_ps2RecompiledFunctionTable[511464] = ADXF_ReadNw32_0x2f3648; // 0x2f37a8 - g_ps2RecompiledFunctionTable[511465] = ADXF_ReadNw32_0x2f3648; // 0x2f37ac - g_ps2RecompiledFunctionTable[511466] = ADXF_ReadNw32_0x2f3648; // 0x2f37b0 - g_ps2RecompiledFunctionTable[511467] = ADXF_ReadNw32_0x2f3648; // 0x2f37b4 - g_ps2RecompiledFunctionTable[511468] = ADXF_ReadNw32_0x2f3648; // 0x2f37b8 - g_ps2RecompiledFunctionTable[511469] = ADXF_ReadNw32_0x2f3648; // 0x2f37bc - g_ps2RecompiledFunctionTable[511470] = ADXF_ReadNw32_0x2f3648; // 0x2f37c0 - g_ps2RecompiledFunctionTable[511471] = ADXF_ReadNw32_0x2f3648; // 0x2f37c4 - g_ps2RecompiledFunctionTable[511472] = ADXF_ReadNw32_0x2f3648; // 0x2f37c8 - g_ps2RecompiledFunctionTable[511473] = ADXF_ReadNw32_0x2f3648; // 0x2f37cc - g_ps2RecompiledFunctionTable[511474] = ADXF_ReadNw32_0x2f3648; // 0x2f37d0 - g_ps2RecompiledFunctionTable[511475] = ADXF_ReadNw32_0x2f3648; // 0x2f37d4 - g_ps2RecompiledFunctionTable[511476] = ADXF_ReadNw32_0x2f3648; // 0x2f37d8 - g_ps2RecompiledFunctionTable[511477] = ADXF_ReadNw32_0x2f3648; // 0x2f37dc - g_ps2RecompiledFunctionTable[511478] = ADXF_ReadNw32_0x2f3648; // 0x2f37e0 - g_ps2RecompiledFunctionTable[511479] = ADXF_ReadNw32_0x2f3648; // 0x2f37e4 - g_ps2RecompiledFunctionTable[511480] = ADXF_ReadNw32_0x2f3648; // 0x2f37e8 - g_ps2RecompiledFunctionTable[511481] = ADXF_ReadNw32_0x2f3648; // 0x2f37ec - g_ps2RecompiledFunctionTable[511482] = ADXF_ReadNw32_0x2f3648; // 0x2f37f0 - g_ps2RecompiledFunctionTable[511483] = ADXF_ReadNw32_0x2f3648; // 0x2f37f4 - g_ps2RecompiledFunctionTable[511484] = ADXF_ReadNw32_0x2f3648; // 0x2f37f8 - g_ps2RecompiledFunctionTable[511485] = ADXF_ReadNw32_0x2f3648; // 0x2f37fc - g_ps2RecompiledFunctionTable[511486] = ADXF_ReadNw32_0x2f3648; // 0x2f3800 - g_ps2RecompiledFunctionTable[511487] = ADXF_ReadNw32_0x2f3648; // 0x2f3804 - g_ps2RecompiledFunctionTable[511488] = ADXF_ReadNw32_0x2f3648; // 0x2f3808 - g_ps2RecompiledFunctionTable[511489] = ADXF_ReadNw32_0x2f3648; // 0x2f380c - g_ps2RecompiledFunctionTable[511490] = ADXF_ReadNw32_0x2f3648; // 0x2f3810 - g_ps2RecompiledFunctionTable[511491] = ADXF_ReadNw32_0x2f3648; // 0x2f3814 - g_ps2RecompiledFunctionTable[511492] = ADXF_ReadNw32_0x2f3648; // 0x2f3818 - g_ps2RecompiledFunctionTable[511493] = ADXF_ReadNw32_0x2f3648; // 0x2f381c - g_ps2RecompiledFunctionTable[511494] = ADXF_ReadNw32_0x2f3648; // 0x2f3820 - g_ps2RecompiledFunctionTable[511495] = ADXF_ReadNw32_0x2f3648; // 0x2f3824 - g_ps2RecompiledFunctionTable[511496] = ADXF_ReadNw32_0x2f3648; // 0x2f3828 - g_ps2RecompiledFunctionTable[511497] = ADXF_ReadNw32_0x2f3648; // 0x2f382c - g_ps2RecompiledFunctionTable[511498] = ADXF_ReadNw32_0x2f3648; // 0x2f3830 - g_ps2RecompiledFunctionTable[511499] = ADXF_ReadNw32_0x2f3648; // 0x2f3834 - g_ps2RecompiledFunctionTable[511500] = ADXF_ReadNw32_0x2f3648; // 0x2f3838 - g_ps2RecompiledFunctionTable[511501] = ADXF_ReadNw32_0x2f3648; // 0x2f383c - g_ps2RecompiledFunctionTable[511502] = ADXF_ReadNw32_0x2f3648; // 0x2f3840 - g_ps2RecompiledFunctionTable[511503] = ADXF_ReadNw32_0x2f3648; // 0x2f3844 - g_ps2RecompiledFunctionTable[511504] = ADXF_ReadNw32_0x2f3648; // 0x2f3848 - g_ps2RecompiledFunctionTable[511505] = ADXF_ReadNw32_0x2f3648; // 0x2f384c - g_ps2RecompiledFunctionTable[511506] = ADXF_ReadNw32_0x2f3648; // 0x2f3850 - g_ps2RecompiledFunctionTable[511507] = ADXF_ReadNw32_0x2f3648; // 0x2f3854 - g_ps2RecompiledFunctionTable[511508] = ADXF_ReadNw32_0x2f3648; // 0x2f3858 - g_ps2RecompiledFunctionTable[511509] = ADXF_ReadNw32_0x2f3648; // 0x2f385c - g_ps2RecompiledFunctionTable[511510] = ADXF_ReadNw32_0x2f3648; // 0x2f3860 - g_ps2RecompiledFunctionTable[511511] = ADXF_ReadNw32_0x2f3648; // 0x2f3864 - g_ps2RecompiledFunctionTable[511512] = ADXF_ReadNw32_0x2f3648; // 0x2f3868 - g_ps2RecompiledFunctionTable[511513] = ADXF_ReadNw32_0x2f3648; // 0x2f386c - g_ps2RecompiledFunctionTable[511514] = ADXF_ReadNw32_0x2f3648; // 0x2f3870 - g_ps2RecompiledFunctionTable[511515] = ADXF_ReadNw32_0x2f3648; // 0x2f3874 - g_ps2RecompiledFunctionTable[511516] = ADXF_ReadNw32_0x2f3648; // 0x2f3878 - g_ps2RecompiledFunctionTable[511517] = ADXF_ReadNw32_0x2f3648; // 0x2f387c - g_ps2RecompiledFunctionTable[511518] = ADXF_ReadNw32_0x2f3648; // 0x2f3880 - g_ps2RecompiledFunctionTable[511519] = ADXF_ReadNw32_0x2f3648; // 0x2f3884 - g_ps2RecompiledFunctionTable[511520] = ADXF_ReadNw32_0x2f3648; // 0x2f3888 - g_ps2RecompiledFunctionTable[511521] = ADXF_ReadNw32_0x2f3648; // 0x2f388c - g_ps2RecompiledFunctionTable[511522] = ADXF_ReadNw32_0x2f3648; // 0x2f3890 - g_ps2RecompiledFunctionTable[511523] = ADXF_ReadNw32_0x2f3648; // 0x2f3894 - g_ps2RecompiledFunctionTable[511524] = ADXF_ReadNw32_0x2f3648; // 0x2f3898 - g_ps2RecompiledFunctionTable[511525] = ADXF_ReadNw32_0x2f3648; // 0x2f389c - g_ps2RecompiledFunctionTable[511526] = ADXF_ReadNw32_0x2f3648; // 0x2f38a0 - g_ps2RecompiledFunctionTable[511527] = ADXF_ReadNw32_0x2f3648; // 0x2f38a4 - g_ps2RecompiledFunctionTable[511528] = ADXF_ReadNw32_0x2f3648; // 0x2f38a8 - g_ps2RecompiledFunctionTable[511529] = ADXF_ReadNw32_0x2f3648; // 0x2f38ac - g_ps2RecompiledFunctionTable[511530] = ADXF_ReadNw32_0x2f3648; // 0x2f38b0 - g_ps2RecompiledFunctionTable[511531] = ADXF_ReadNw32_0x2f3648; // 0x2f38b4 - g_ps2RecompiledFunctionTable[511532] = ADXF_ReadNw32_0x2f3648; // 0x2f38b8 - g_ps2RecompiledFunctionTable[511534] = ADXF_ReadNw_0x2f38c0; // 0x2f38c0 - g_ps2RecompiledFunctionTable[511541] = ADXF_ReadNw_0x2f38c0; // 0x2f38dc - g_ps2RecompiledFunctionTable[511545] = ADXF_ReadNw_0x2f38c0; // 0x2f38ec - g_ps2RecompiledFunctionTable[511548] = ADXF_Stop_0x2f38f8; // 0x2f38f8 - g_ps2RecompiledFunctionTable[511559] = ADXF_Stop_0x2f38f8; // 0x2f3924 - g_ps2RecompiledFunctionTable[511564] = ADXF_Stop_0x2f38f8; // 0x2f3938 - g_ps2RecompiledFunctionTable[511577] = ADXF_Stop_0x2f38f8; // 0x2f396c - g_ps2RecompiledFunctionTable[511581] = ADXF_Stop_0x2f38f8; // 0x2f397c - g_ps2RecompiledFunctionTable[511583] = ADXF_Stop_0x2f38f8; // 0x2f3984 - g_ps2RecompiledFunctionTable[511586] = ADXF_Stop_0x2f38f8; // 0x2f3990 - g_ps2RecompiledFunctionTable[511590] = ADXF_Stop_0x2f38f8; // 0x2f39a0 - g_ps2RecompiledFunctionTable[511592] = ADXF_Stop_0x2f38f8; // 0x2f39a8 - g_ps2RecompiledFunctionTable[511598] = ADXF_Stop_0x2f38f8; // 0x2f39c0 - g_ps2RecompiledFunctionTable[511604] = adxf_ExecOne_0x2f39d8; // 0x2f39d8 - g_ps2RecompiledFunctionTable[511614] = adxf_ExecOne_0x2f39d8; // 0x2f3a00 - g_ps2RecompiledFunctionTable[511618] = adxf_ExecOne_0x2f39d8; // 0x2f3a10 - g_ps2RecompiledFunctionTable[511629] = adxf_ExecOne_0x2f39d8; // 0x2f3a3c - g_ps2RecompiledFunctionTable[511634] = ADXF_ExecServer_0x2f3a50; // 0x2f3a50 - g_ps2RecompiledFunctionTable[511641] = ADXF_ExecServer_0x2f3a50; // 0x2f3a6c - g_ps2RecompiledFunctionTable[511646] = ADXF_ExecServer_0x2f3a50; // 0x2f3a80 - g_ps2RecompiledFunctionTable[511650] = ADXF_ExecServer_0x2f3a50; // 0x2f3a90 - g_ps2RecompiledFunctionTable[511660] = ADXF_Seek_0x2f3ab8; // 0x2f3ab8 - g_ps2RecompiledFunctionTable[511675] = ADXF_Seek_0x2f3ab8; // 0x2f3af4 - g_ps2RecompiledFunctionTable[511685] = ADXF_Seek_0x2f3ab8; // 0x2f3b1c - g_ps2RecompiledFunctionTable[511698] = ADXF_Seek_0x2f3ab8; // 0x2f3b50 - g_ps2RecompiledFunctionTable[511718] = ADXF_Seek_0x2f3ab8; // 0x2f3ba0 - g_ps2RecompiledFunctionTable[511724] = ADXF_Seek_0x2f3ab8; // 0x2f3bb8 - g_ps2RecompiledFunctionTable[511732] = ADXF_Tell_0x2f3bd8; // 0x2f3bd8 - g_ps2RecompiledFunctionTable[511738] = ADXF_Tell_0x2f3bd8; // 0x2f3bf0 - g_ps2RecompiledFunctionTable[511744] = ADXF_GetFsizeSct_0x2f3c08; // 0x2f3c08 - g_ps2RecompiledFunctionTable[511750] = ADXF_GetFsizeSct_0x2f3c08; // 0x2f3c20 - g_ps2RecompiledFunctionTable[511756] = ADXF_GetFsizeByte_0x2f3c38; // 0x2f3c38 - g_ps2RecompiledFunctionTable[511762] = ADXF_GetFsizeByte_0x2f3c38; // 0x2f3c50 - g_ps2RecompiledFunctionTable[511768] = ADXF_GetNumReqSct_0x2f3c68; // 0x2f3c68 - g_ps2RecompiledFunctionTable[511776] = ADXF_GetNumReqSct_0x2f3c68; // 0x2f3c88 - g_ps2RecompiledFunctionTable[511786] = ADXF_GetNumReadSct_0x2f3cb0; // 0x2f3cb0 - g_ps2RecompiledFunctionTable[511792] = ADXF_GetNumReadSct_0x2f3cb0; // 0x2f3cc8 - g_ps2RecompiledFunctionTable[511798] = ADXF_GetStat_0x2f3ce0; // 0x2f3ce0 - g_ps2RecompiledFunctionTable[511804] = ADXF_GetStat_0x2f3ce0; // 0x2f3cf8 - g_ps2RecompiledFunctionTable[511810] = adxf_ChkPrmGfr_0x2f3d10; // 0x2f3d10 - g_ps2RecompiledFunctionTable[511836] = adxf_ChkPrmGfr_0x2f3d10; // 0x2f3d78 - g_ps2RecompiledFunctionTable[511840] = ADXF_GetFnameRange_0x2f3d88; // 0x2f3d88 - g_ps2RecompiledFunctionTable[511856] = ADXF_GetFnameRange_0x2f3d88; // 0x2f3dc8 - g_ps2RecompiledFunctionTable[511870] = ADXF_GetFnameRange_0x2f3d88; // 0x2f3e00 - g_ps2RecompiledFunctionTable[511876] = ADXF_GetFnameRange_0x2f3d88; // 0x2f3e18 - g_ps2RecompiledFunctionTable[511894] = ADXF_GetFnameRange_0x2f3d88; // 0x2f3e60 - g_ps2RecompiledFunctionTable[511908] = ADXF_GetFnameRange_0x2f3d88; // 0x2f3e98 - g_ps2RecompiledFunctionTable[511919] = ADXF_GetFnameRange_0x2f3d88; // 0x2f3ec4 - g_ps2RecompiledFunctionTable[511936] = ADXF_GetFnameRangeEx_0x2f3f08; // 0x2f3f08 - g_ps2RecompiledFunctionTable[511954] = ADXF_GetFnameRangeEx_0x2f3f08; // 0x2f3f50 - g_ps2RecompiledFunctionTable[511970] = ADXF_GetFnameRangeEx_0x2f3f08; // 0x2f3f90 - g_ps2RecompiledFunctionTable[511976] = ADXF_GetFnameRangeEx_0x2f3f08; // 0x2f3fa8 - g_ps2RecompiledFunctionTable[511994] = ADXF_GetFnameRangeEx_0x2f3f08; // 0x2f3ff0 - g_ps2RecompiledFunctionTable[512008] = ADXF_GetFnameRangeEx_0x2f3f08; // 0x2f4028 - g_ps2RecompiledFunctionTable[512019] = ADXF_GetFnameRangeEx_0x2f3f08; // 0x2f4054 - g_ps2RecompiledFunctionTable[512038] = ADXF_SetOcbiSw_0x2f40a0; // 0x2f40a0 - g_ps2RecompiledFunctionTable[512042] = ADXF_SetReqRdSct_0x2f40b0; // 0x2f40b0 - g_ps2RecompiledFunctionTable[512052] = ADXT_ExecFsSvr_0x2f40d8; // 0x2f40d8 - g_ps2RecompiledFunctionTable[512056] = ADXT_ExecFsSvr_0x2f40d8; // 0x2f40e8 - g_ps2RecompiledFunctionTable[512058] = ADXT_ExecFsSvr_0x2f40d8; // 0x2f40f0 - g_ps2RecompiledFunctionTable[512062] = ADXT_ConfigVsyncSvr_0x2f4100; // 0x2f4100 - g_ps2RecompiledFunctionTable[512064] = adxini_rnaerr_cbfn_0x2f4108; // 0x2f4108 - g_ps2RecompiledFunctionTable[512066] = ADXT_VsyncProc_0x2f4110; // 0x2f4110 - g_ps2RecompiledFunctionTable[512070] = ADXT_Init_0x2f4120; // 0x2f4120 - g_ps2RecompiledFunctionTable[512076] = ADXT_Init_0x2f4120; // 0x2f4138 - g_ps2RecompiledFunctionTable[512078] = ADXT_Init_0x2f4120; // 0x2f4140 - g_ps2RecompiledFunctionTable[512080] = ADXT_Init_0x2f4120; // 0x2f4148 - g_ps2RecompiledFunctionTable[512082] = ADXT_Init_0x2f4120; // 0x2f4150 - g_ps2RecompiledFunctionTable[512084] = ADXT_Init_0x2f4120; // 0x2f4158 - g_ps2RecompiledFunctionTable[512086] = ADXT_Init_0x2f4120; // 0x2f4160 - g_ps2RecompiledFunctionTable[512088] = ADXT_Init_0x2f4120; // 0x2f4168 - g_ps2RecompiledFunctionTable[512090] = ADXT_Init_0x2f4120; // 0x2f4170 - g_ps2RecompiledFunctionTable[512092] = ADXT_Init_0x2f4120; // 0x2f4178 - g_ps2RecompiledFunctionTable[512094] = ADXT_Init_0x2f4120; // 0x2f4180 - g_ps2RecompiledFunctionTable[512099] = ADXT_Init_0x2f4120; // 0x2f4194 - g_ps2RecompiledFunctionTable[512101] = ADXT_Init_0x2f4120; // 0x2f419c - g_ps2RecompiledFunctionTable[512103] = ADXT_Init_0x2f4120; // 0x2f41a4 - g_ps2RecompiledFunctionTable[512110] = ADXT_ResetLibrary_0x2f41c0; // 0x2f41c0 - g_ps2RecompiledFunctionTable[512112] = ADXT_Finish_0x2f41c8; // 0x2f41c8 - g_ps2RecompiledFunctionTable[512120] = ADXT_Finish_0x2f41c8; // 0x2f41e8 - g_ps2RecompiledFunctionTable[512122] = ADXT_Finish_0x2f41c8; // 0x2f41f0 - g_ps2RecompiledFunctionTable[512124] = ADXT_Finish_0x2f41c8; // 0x2f41f8 - g_ps2RecompiledFunctionTable[512126] = ADXT_Finish_0x2f41c8; // 0x2f4200 - g_ps2RecompiledFunctionTable[512128] = ADXT_Finish_0x2f41c8; // 0x2f4208 - g_ps2RecompiledFunctionTable[512130] = ADXT_Finish_0x2f41c8; // 0x2f4210 - g_ps2RecompiledFunctionTable[512132] = ADXT_Finish_0x2f41c8; // 0x2f4218 - g_ps2RecompiledFunctionTable[512134] = ADXT_Finish_0x2f41c8; // 0x2f4220 - g_ps2RecompiledFunctionTable[512136] = ADXT_Finish_0x2f41c8; // 0x2f4228 - g_ps2RecompiledFunctionTable[512138] = ADXT_Finish_0x2f41c8; // 0x2f4230 - g_ps2RecompiledFunctionTable[512140] = ADXT_Finish_0x2f41c8; // 0x2f4238 - g_ps2RecompiledFunctionTable[512142] = ADXT_Finish_0x2f41c8; // 0x2f4240 - g_ps2RecompiledFunctionTable[512148] = adxps2_adx_thrd_func_0x2f4258; // 0x2f4258 - g_ps2RecompiledFunctionTable[512152] = adxps2_adx_thrd_func_0x2f4258; // 0x2f4268 - g_ps2RecompiledFunctionTable[512155] = adxps2_adx_thrd_func_0x2f4258; // 0x2f4274 - g_ps2RecompiledFunctionTable[512157] = adxps2_adx_thrd_func_0x2f4258; // 0x2f427c - g_ps2RecompiledFunctionTable[512159] = adxps2_adx_thrd_func_0x2f4258; // 0x2f4284 - g_ps2RecompiledFunctionTable[512161] = adxps2_adx_thrd_func_0x2f4258; // 0x2f428c - g_ps2RecompiledFunctionTable[512164] = adxps2_adx_thrd_func_0x2f4258; // 0x2f4298 - g_ps2RecompiledFunctionTable[512166] = adxps2_safe_thrd_func_0x2f42a0; // 0x2f42a0 - g_ps2RecompiledFunctionTable[512174] = ADXPS2_VsyncCallback_0x2f42c0; // 0x2f42c0 - g_ps2RecompiledFunctionTable[512175] = ADXPS2_VsyncCallback_0x2f42c0; // 0x2f42c4 - g_ps2RecompiledFunctionTable[512176] = ADXPS2_VsyncCallback_0x2f42c0; // 0x2f42c8 - g_ps2RecompiledFunctionTable[512177] = ADXPS2_VsyncCallback_0x2f42c0; // 0x2f42cc - g_ps2RecompiledFunctionTable[512178] = ADXPS2_VsyncCallback_0x2f42c0; // 0x2f42d0 - g_ps2RecompiledFunctionTable[512179] = ADXPS2_VsyncCallback_0x2f42c0; // 0x2f42d4 - g_ps2RecompiledFunctionTable[512180] = ADXPS2_VsyncCallback_0x2f42c0; // 0x2f42d8 - g_ps2RecompiledFunctionTable[512181] = ADXPS2_VsyncCallback_0x2f42c0; // 0x2f42dc - g_ps2RecompiledFunctionTable[512182] = ADXPS2_VsyncCallback_0x2f42c0; // 0x2f42e0 - g_ps2RecompiledFunctionTable[512183] = ADXPS2_VsyncCallback_0x2f42c0; // 0x2f42e4 - g_ps2RecompiledFunctionTable[512184] = ADXPS2_VsyncCallback_0x2f42c0; // 0x2f42e8 - g_ps2RecompiledFunctionTable[512185] = ADXPS2_VsyncCallback_0x2f42c0; // 0x2f42ec - g_ps2RecompiledFunctionTable[512186] = ADXPS2_VsyncCallback_0x2f42c0; // 0x2f42f0 - g_ps2RecompiledFunctionTable[512187] = ADXPS2_VsyncCallback_0x2f42c0; // 0x2f42f4 - g_ps2RecompiledFunctionTable[512188] = ADXPS2_VsyncCallback_0x2f42c0; // 0x2f42f8 - g_ps2RecompiledFunctionTable[512189] = ADXPS2_VsyncCallback_0x2f42c0; // 0x2f42fc - g_ps2RecompiledFunctionTable[512190] = ADXPS2_VsyncCallback_0x2f42c0; // 0x2f4300 - g_ps2RecompiledFunctionTable[512191] = ADXPS2_VsyncCallback_0x2f42c0; // 0x2f4304 - g_ps2RecompiledFunctionTable[512192] = ADXPS2_VsyncCallback_0x2f42c0; // 0x2f4308 - g_ps2RecompiledFunctionTable[512193] = ADXPS2_VsyncCallback_0x2f42c0; // 0x2f430c - g_ps2RecompiledFunctionTable[512194] = ADXPS2_VsyncCallback_0x2f42c0; // 0x2f4310 - g_ps2RecompiledFunctionTable[512195] = ADXPS2_VsyncCallback_0x2f42c0; // 0x2f4314 - g_ps2RecompiledFunctionTable[512196] = ADXPS2_VsyncCallback_0x2f42c0; // 0x2f4318 - g_ps2RecompiledFunctionTable[512197] = ADXPS2_VsyncCallback_0x2f42c0; // 0x2f431c - g_ps2RecompiledFunctionTable[512198] = ADXPS2_VsyncCallback_0x2f42c0; // 0x2f4320 - g_ps2RecompiledFunctionTable[512199] = ADXPS2_VsyncCallback_0x2f42c0; // 0x2f4324 - g_ps2RecompiledFunctionTable[512200] = ADXPS2_RestoreVsyncCallback_0x2f4328; // 0x2f4328 - g_ps2RecompiledFunctionTable[512205] = ADXPS2_RestoreVsyncCallback_0x2f4328; // 0x2f433c - g_ps2RecompiledFunctionTable[512210] = ADXPS2_SetupThrd_0x2f4350; // 0x2f4350 - g_ps2RecompiledFunctionTable[512253] = ADXPS2_SetupThrd_0x2f4350; // 0x2f43fc - g_ps2RecompiledFunctionTable[512259] = ADXPS2_SetupThrd_0x2f4350; // 0x2f4414 - g_ps2RecompiledFunctionTable[512265] = ADXPS2_SetupThrd_0x2f4350; // 0x2f442c - g_ps2RecompiledFunctionTable[512278] = ADXPS2_SetupThrd_0x2f4350; // 0x2f4460 - g_ps2RecompiledFunctionTable[512284] = ADXPS2_SetupThrd_0x2f4350; // 0x2f4478 - g_ps2RecompiledFunctionTable[512286] = ADXPS2_SetupThrd_0x2f4350; // 0x2f4480 - g_ps2RecompiledFunctionTable[512291] = ADXPS2_SetupThrd_0x2f4350; // 0x2f4494 - g_ps2RecompiledFunctionTable[512296] = ADXPS2_SetupThrd_0x2f4350; // 0x2f44a8 - g_ps2RecompiledFunctionTable[512298] = ADXPS2_SetupThrd_0x2f4350; // 0x2f44b0 - g_ps2RecompiledFunctionTable[512304] = ADXPS2_ShutdownThrd_0x2f44c8; // 0x2f44c8 - g_ps2RecompiledFunctionTable[512309] = ADXPS2_ShutdownThrd_0x2f44c8; // 0x2f44dc - g_ps2RecompiledFunctionTable[512313] = ADXPS2_ShutdownThrd_0x2f44c8; // 0x2f44ec - g_ps2RecompiledFunctionTable[512317] = ADXPS2_ShutdownThrd_0x2f44c8; // 0x2f44fc - g_ps2RecompiledFunctionTable[512321] = ADXPS2_ShutdownThrd_0x2f44c8; // 0x2f450c - g_ps2RecompiledFunctionTable[512324] = ADXPS2_ShutdownThrd_0x2f44c8; // 0x2f4518 - g_ps2RecompiledFunctionTable[512330] = ADXPS2_Lock_0x2f4530; // 0x2f4530 - g_ps2RecompiledFunctionTable[512337] = ADXPS2_Lock_0x2f4530; // 0x2f454c - g_ps2RecompiledFunctionTable[512341] = ADXPS2_Lock_0x2f4530; // 0x2f455c - g_ps2RecompiledFunctionTable[512345] = ADXPS2_Lock_0x2f4530; // 0x2f456c - g_ps2RecompiledFunctionTable[512353] = ADXPS2_Lock_0x2f4530; // 0x2f458c - g_ps2RecompiledFunctionTable[512362] = ADXPS2_Unlock_0x2f45b0; // 0x2f45b0 - g_ps2RecompiledFunctionTable[512376] = ADXPS2_Unlock_0x2f45b0; // 0x2f45e8 - g_ps2RecompiledFunctionTable[512379] = ADXPS2_Unlock_0x2f45b0; // 0x2f45f4 - g_ps2RecompiledFunctionTable[512382] = ADXPS2_Unlock_0x2f45b0; // 0x2f4600 - g_ps2RecompiledFunctionTable[512388] = ADXPS2_ExecServer_0x2f4618; // 0x2f4618 - g_ps2RecompiledFunctionTable[512392] = ADXPS2_ExecServer_0x2f4618; // 0x2f4628 - g_ps2RecompiledFunctionTable[512396] = ADXPS2_SetupUsvr_0x2f4638; // 0x2f4638 - g_ps2RecompiledFunctionTable[512398] = ADXPS2_Shutdown_0x2f4640; // 0x2f4640 - g_ps2RecompiledFunctionTable[512400] = ADXRNA_Init_0x2f4648; // 0x2f4648 - g_ps2RecompiledFunctionTable[512402] = ADXRNA_Finish_0x2f4650; // 0x2f4650 - g_ps2RecompiledFunctionTable[512404] = ADXRNA_Create_0x2f4658; // 0x2f4658 - g_ps2RecompiledFunctionTable[512408] = ADXRNA_Create_0x2f4658; // 0x2f4668 - g_ps2RecompiledFunctionTable[512412] = ADXRNA_Destroy_0x2f4678; // 0x2f4678 - g_ps2RecompiledFunctionTable[512418] = ADXRNA_Destroy_0x2f4678; // 0x2f4690 - g_ps2RecompiledFunctionTable[512421] = ADXRNA_Destroy_0x2f4678; // 0x2f469c - g_ps2RecompiledFunctionTable[512426] = ADXRNA_Start_0x2f46b0; // 0x2f46b0 - g_ps2RecompiledFunctionTable[512428] = ADXRNA_Stop_0x2f46b8; // 0x2f46b8 - g_ps2RecompiledFunctionTable[512430] = ADXRNA_SetTransSw_0x2f46c0; // 0x2f46c0 - g_ps2RecompiledFunctionTable[512432] = ADXRNA_SetPlaySw_0x2f46c8; // 0x2f46c8 - g_ps2RecompiledFunctionTable[512434] = ADXRNA_GetTime_0x2f46d0; // 0x2f46d0 - g_ps2RecompiledFunctionTable[512436] = ADXRNA_GetNumData_0x2f46d8; // 0x2f46d8 - g_ps2RecompiledFunctionTable[512440] = ADXRNA_GetNumData_0x2f46d8; // 0x2f46e8 - g_ps2RecompiledFunctionTable[512444] = ADXRNA_GetNumRoom_0x2f46f8; // 0x2f46f8 - g_ps2RecompiledFunctionTable[512448] = ADXRNA_GetNumRoom_0x2f46f8; // 0x2f4708 - g_ps2RecompiledFunctionTable[512452] = ADXRNA_GetStat_0x2f4718; // 0x2f4718 - g_ps2RecompiledFunctionTable[512457] = ADXRNA_GetStat_0x2f4718; // 0x2f472c - g_ps2RecompiledFunctionTable[512458] = ADXRNA_GetStat_0x2f4718; // 0x2f4730 - g_ps2RecompiledFunctionTable[512466] = ADXRNA_ExecServer_0x2f4750; // 0x2f4750 - g_ps2RecompiledFunctionTable[512468] = ADXRNA_SetStartSmpl_0x2f4758; // 0x2f4758 - g_ps2RecompiledFunctionTable[512470] = ADXRNA_SetNumChan_0x2f4760; // 0x2f4760 - g_ps2RecompiledFunctionTable[512472] = ADXRNA_SetSfreq_0x2f4768; // 0x2f4768 - g_ps2RecompiledFunctionTable[512474] = ADXRNA_SetOutVol_0x2f4770; // 0x2f4770 - g_ps2RecompiledFunctionTable[512476] = ADXRNA_SetOutPan_0x2f4778; // 0x2f4778 - g_ps2RecompiledFunctionTable[512478] = ADXRNA_SetBitPerSmpl_0x2f4780; // 0x2f4780 - g_ps2RecompiledFunctionTable[512480] = ADXRNA_GetSfreq_0x2f4788; // 0x2f4788 - g_ps2RecompiledFunctionTable[512484] = ADXRNA_GetSfreq_0x2f4788; // 0x2f4798 - g_ps2RecompiledFunctionTable[512488] = ADXRNA_GetOutVol_0x2f47a8; // 0x2f47a8 - g_ps2RecompiledFunctionTable[512492] = ADXRNA_GetOutVol_0x2f47a8; // 0x2f47b8 - g_ps2RecompiledFunctionTable[512496] = ADXRNA_GetOutPan_0x2f47c8; // 0x2f47c8 - g_ps2RecompiledFunctionTable[512500] = ADXRNA_GetOutPan_0x2f47c8; // 0x2f47d8 - g_ps2RecompiledFunctionTable[512504] = ADXRNA_GetBitPerSmpl_0x2f47e8; // 0x2f47e8 - g_ps2RecompiledFunctionTable[512508] = ADXRNA_GetBitPerSmpl_0x2f47e8; // 0x2f47f8 - g_ps2RecompiledFunctionTable[512512] = ADXRNA_DiscardData_0x2f4808; // 0x2f4808 - g_ps2RecompiledFunctionTable[512516] = ADXRNA_DiscardData_0x2f4808; // 0x2f4818 - g_ps2RecompiledFunctionTable[512520] = ADXRNA_ClearBuf_0x2f4828; // 0x2f4828 - g_ps2RecompiledFunctionTable[512522] = ADXRNA_SetPcmType_0x2f4830; // 0x2f4830 - g_ps2RecompiledFunctionTable[512524] = ADXRNA_SetTotalNumSmpl_0x2f4838; // 0x2f4838 - g_ps2RecompiledFunctionTable[512526] = ADXRNA_SetWavFname_0x2f4840; // 0x2f4840 - g_ps2RecompiledFunctionTable[512528] = ADXRNA_SetStmHdInfo_0x2f4848; // 0x2f4848 - g_ps2RecompiledFunctionTable[512532] = ADXRNA_SetStmHdInfo_0x2f4848; // 0x2f4858 - g_ps2RecompiledFunctionTable[512536] = ADXSJD_Init_0x2f4868; // 0x2f4868 - g_ps2RecompiledFunctionTable[512540] = ADXSJD_Init_0x2f4868; // 0x2f4878 - g_ps2RecompiledFunctionTable[512548] = ADXSJD_Finish_0x2f4898; // 0x2f4898 - g_ps2RecompiledFunctionTable[512554] = adxsjd_clear_0x2f48b0; // 0x2f48b0 - g_ps2RecompiledFunctionTable[512568] = ADXSJD_Create_0x2f48e8; // 0x2f48e8 - g_ps2RecompiledFunctionTable[512588] = ADXSJD_Create_0x2f48e8; // 0x2f4938 - g_ps2RecompiledFunctionTable[512602] = ADXSJD_Create_0x2f48e8; // 0x2f4970 - g_ps2RecompiledFunctionTable[512605] = ADXSJD_Create_0x2f48e8; // 0x2f497c - g_ps2RecompiledFunctionTable[512608] = ADXSJD_Create_0x2f48e8; // 0x2f4988 - g_ps2RecompiledFunctionTable[512614] = ADXSJD_Create_0x2f48e8; // 0x2f49a0 - g_ps2RecompiledFunctionTable[512620] = ADXSJD_Create_0x2f48e8; // 0x2f49b8 - g_ps2RecompiledFunctionTable[512630] = ADXSJD_Create_0x2f48e8; // 0x2f49e0 - g_ps2RecompiledFunctionTable[512641] = ADXSJD_Create_0x2f48e8; // 0x2f4a0c - g_ps2RecompiledFunctionTable[512658] = ADXSJD_Destroy_0x2f4a50; // 0x2f4a50 - g_ps2RecompiledFunctionTable[512668] = ADXSJD_Destroy_0x2f4a50; // 0x2f4a78 - g_ps2RecompiledFunctionTable[512670] = ADXSJD_Destroy_0x2f4a50; // 0x2f4a80 - g_ps2RecompiledFunctionTable[512674] = ADXSJD_Destroy_0x2f4a50; // 0x2f4a90 - g_ps2RecompiledFunctionTable[512682] = ADXSJD_GetStat_0x2f4ab0; // 0x2f4ab0 - g_ps2RecompiledFunctionTable[512684] = ADXSJD_SetInSj_0x2f4ab8; // 0x2f4ab8 - g_ps2RecompiledFunctionTable[512686] = ADXSJD_SetOutSj_0x2f4ac0; // 0x2f4ac0 - g_ps2RecompiledFunctionTable[512690] = ADXSJD_SetMaxDecSmpl_0x2f4ad0; // 0x2f4ad0 - g_ps2RecompiledFunctionTable[512692] = ADXSJD_Start_0x2f4ad8; // 0x2f4ad8 - g_ps2RecompiledFunctionTable[512697] = ADXSJD_Start_0x2f4ad8; // 0x2f4aec - g_ps2RecompiledFunctionTable[512704] = ADXSJD_Stop_0x2f4b08; // 0x2f4b08 - g_ps2RecompiledFunctionTable[512710] = ADXSJD_Stop_0x2f4b08; // 0x2f4b20 - g_ps2RecompiledFunctionTable[512716] = adxsjd_decode_prep_0x2f4b38; // 0x2f4b38 - g_ps2RecompiledFunctionTable[512717] = adxsjd_decode_prep_0x2f4b38; // 0x2f4b3c - g_ps2RecompiledFunctionTable[512718] = adxsjd_decode_prep_0x2f4b38; // 0x2f4b40 - g_ps2RecompiledFunctionTable[512719] = adxsjd_decode_prep_0x2f4b38; // 0x2f4b44 - g_ps2RecompiledFunctionTable[512720] = adxsjd_decode_prep_0x2f4b38; // 0x2f4b48 - g_ps2RecompiledFunctionTable[512721] = adxsjd_decode_prep_0x2f4b38; // 0x2f4b4c - g_ps2RecompiledFunctionTable[512722] = adxsjd_decode_prep_0x2f4b38; // 0x2f4b50 - g_ps2RecompiledFunctionTable[512723] = adxsjd_decode_prep_0x2f4b38; // 0x2f4b54 - g_ps2RecompiledFunctionTable[512724] = adxsjd_decode_prep_0x2f4b38; // 0x2f4b58 - g_ps2RecompiledFunctionTable[512725] = adxsjd_decode_prep_0x2f4b38; // 0x2f4b5c - g_ps2RecompiledFunctionTable[512726] = adxsjd_decode_prep_0x2f4b38; // 0x2f4b60 - g_ps2RecompiledFunctionTable[512727] = adxsjd_decode_prep_0x2f4b38; // 0x2f4b64 - g_ps2RecompiledFunctionTable[512728] = adxsjd_decode_prep_0x2f4b38; // 0x2f4b68 - g_ps2RecompiledFunctionTable[512729] = adxsjd_decode_prep_0x2f4b38; // 0x2f4b6c - g_ps2RecompiledFunctionTable[512730] = adxsjd_decode_prep_0x2f4b38; // 0x2f4b70 - g_ps2RecompiledFunctionTable[512731] = adxsjd_decode_prep_0x2f4b38; // 0x2f4b74 - g_ps2RecompiledFunctionTable[512732] = adxsjd_decode_prep_0x2f4b38; // 0x2f4b78 - g_ps2RecompiledFunctionTable[512733] = adxsjd_decode_prep_0x2f4b38; // 0x2f4b7c - g_ps2RecompiledFunctionTable[512734] = adxsjd_decode_prep_0x2f4b38; // 0x2f4b80 - g_ps2RecompiledFunctionTable[512735] = adxsjd_decode_prep_0x2f4b38; // 0x2f4b84 - g_ps2RecompiledFunctionTable[512736] = adxsjd_decode_prep_0x2f4b38; // 0x2f4b88 - g_ps2RecompiledFunctionTable[512737] = adxsjd_decode_prep_0x2f4b38; // 0x2f4b8c - g_ps2RecompiledFunctionTable[512738] = adxsjd_decode_prep_0x2f4b38; // 0x2f4b90 - g_ps2RecompiledFunctionTable[512739] = adxsjd_decode_prep_0x2f4b38; // 0x2f4b94 - g_ps2RecompiledFunctionTable[512740] = adxsjd_decode_prep_0x2f4b38; // 0x2f4b98 - g_ps2RecompiledFunctionTable[512741] = adxsjd_decode_prep_0x2f4b38; // 0x2f4b9c - g_ps2RecompiledFunctionTable[512742] = adxsjd_decode_prep_0x2f4b38; // 0x2f4ba0 - g_ps2RecompiledFunctionTable[512743] = adxsjd_decode_prep_0x2f4b38; // 0x2f4ba4 - g_ps2RecompiledFunctionTable[512744] = adxsjd_decode_prep_0x2f4b38; // 0x2f4ba8 - g_ps2RecompiledFunctionTable[512745] = adxsjd_decode_prep_0x2f4b38; // 0x2f4bac - g_ps2RecompiledFunctionTable[512746] = adxsjd_decode_prep_0x2f4b38; // 0x2f4bb0 - g_ps2RecompiledFunctionTable[512747] = adxsjd_decode_prep_0x2f4b38; // 0x2f4bb4 - g_ps2RecompiledFunctionTable[512748] = adxsjd_decode_prep_0x2f4b38; // 0x2f4bb8 - g_ps2RecompiledFunctionTable[512749] = adxsjd_decode_prep_0x2f4b38; // 0x2f4bbc - g_ps2RecompiledFunctionTable[512750] = adxsjd_decode_prep_0x2f4b38; // 0x2f4bc0 - g_ps2RecompiledFunctionTable[512751] = adxsjd_decode_prep_0x2f4b38; // 0x2f4bc4 - g_ps2RecompiledFunctionTable[512752] = adxsjd_decode_prep_0x2f4b38; // 0x2f4bc8 - g_ps2RecompiledFunctionTable[512753] = adxsjd_decode_prep_0x2f4b38; // 0x2f4bcc - g_ps2RecompiledFunctionTable[512754] = adxsjd_decode_prep_0x2f4b38; // 0x2f4bd0 - g_ps2RecompiledFunctionTable[512755] = adxsjd_decode_prep_0x2f4b38; // 0x2f4bd4 - g_ps2RecompiledFunctionTable[512756] = adxsjd_decode_prep_0x2f4b38; // 0x2f4bd8 - g_ps2RecompiledFunctionTable[512757] = adxsjd_decode_prep_0x2f4b38; // 0x2f4bdc - g_ps2RecompiledFunctionTable[512758] = adxsjd_decode_prep_0x2f4b38; // 0x2f4be0 - g_ps2RecompiledFunctionTable[512759] = adxsjd_decode_prep_0x2f4b38; // 0x2f4be4 - g_ps2RecompiledFunctionTable[512760] = adxsjd_decode_prep_0x2f4b38; // 0x2f4be8 - g_ps2RecompiledFunctionTable[512761] = adxsjd_decode_prep_0x2f4b38; // 0x2f4bec - g_ps2RecompiledFunctionTable[512762] = adxsjd_decode_prep_0x2f4b38; // 0x2f4bf0 - g_ps2RecompiledFunctionTable[512763] = adxsjd_decode_prep_0x2f4b38; // 0x2f4bf4 - g_ps2RecompiledFunctionTable[512764] = adxsjd_decode_prep_0x2f4b38; // 0x2f4bf8 - g_ps2RecompiledFunctionTable[512765] = adxsjd_decode_prep_0x2f4b38; // 0x2f4bfc - g_ps2RecompiledFunctionTable[512766] = adxsjd_decode_prep_0x2f4b38; // 0x2f4c00 - g_ps2RecompiledFunctionTable[512767] = adxsjd_decode_prep_0x2f4b38; // 0x2f4c04 - g_ps2RecompiledFunctionTable[512768] = adxsjd_decode_prep_0x2f4b38; // 0x2f4c08 - g_ps2RecompiledFunctionTable[512769] = adxsjd_decode_prep_0x2f4b38; // 0x2f4c0c - g_ps2RecompiledFunctionTable[512770] = adxsjd_decode_prep_0x2f4b38; // 0x2f4c10 - g_ps2RecompiledFunctionTable[512771] = adxsjd_decode_prep_0x2f4b38; // 0x2f4c14 - g_ps2RecompiledFunctionTable[512772] = adxsjd_decode_prep_0x2f4b38; // 0x2f4c18 - g_ps2RecompiledFunctionTable[512773] = adxsjd_decode_prep_0x2f4b38; // 0x2f4c1c - g_ps2RecompiledFunctionTable[512774] = adxsjd_decode_prep_0x2f4b38; // 0x2f4c20 - g_ps2RecompiledFunctionTable[512775] = adxsjd_decode_prep_0x2f4b38; // 0x2f4c24 - g_ps2RecompiledFunctionTable[512776] = adxsjd_decode_prep_0x2f4b38; // 0x2f4c28 - g_ps2RecompiledFunctionTable[512777] = adxsjd_decode_prep_0x2f4b38; // 0x2f4c2c - g_ps2RecompiledFunctionTable[512778] = adxsjd_decode_prep_0x2f4b38; // 0x2f4c30 - g_ps2RecompiledFunctionTable[512779] = adxsjd_decode_prep_0x2f4b38; // 0x2f4c34 - g_ps2RecompiledFunctionTable[512780] = adxsjd_decode_prep_0x2f4b38; // 0x2f4c38 - g_ps2RecompiledFunctionTable[512781] = adxsjd_decode_prep_0x2f4b38; // 0x2f4c3c - g_ps2RecompiledFunctionTable[512782] = adxsjd_decode_prep_0x2f4b38; // 0x2f4c40 - g_ps2RecompiledFunctionTable[512783] = adxsjd_decode_prep_0x2f4b38; // 0x2f4c44 - g_ps2RecompiledFunctionTable[512784] = adxsjd_decode_prep_0x2f4b38; // 0x2f4c48 - g_ps2RecompiledFunctionTable[512785] = adxsjd_decode_prep_0x2f4b38; // 0x2f4c4c - g_ps2RecompiledFunctionTable[512786] = adxsjd_decode_prep_0x2f4b38; // 0x2f4c50 - g_ps2RecompiledFunctionTable[512787] = adxsjd_decode_prep_0x2f4b38; // 0x2f4c54 - g_ps2RecompiledFunctionTable[512788] = adxsjd_decode_prep_0x2f4b38; // 0x2f4c58 - g_ps2RecompiledFunctionTable[512789] = adxsjd_decode_prep_0x2f4b38; // 0x2f4c5c - g_ps2RecompiledFunctionTable[512790] = adxsjd_decode_prep_0x2f4b38; // 0x2f4c60 - g_ps2RecompiledFunctionTable[512791] = adxsjd_decode_prep_0x2f4b38; // 0x2f4c64 - g_ps2RecompiledFunctionTable[512792] = adxsjd_decode_prep_0x2f4b38; // 0x2f4c68 - g_ps2RecompiledFunctionTable[512793] = adxsjd_decode_prep_0x2f4b38; // 0x2f4c6c - g_ps2RecompiledFunctionTable[512794] = adxsjd_decode_prep_0x2f4b38; // 0x2f4c70 - g_ps2RecompiledFunctionTable[512795] = adxsjd_decode_prep_0x2f4b38; // 0x2f4c74 - g_ps2RecompiledFunctionTable[512796] = adxsjd_decode_prep_0x2f4b38; // 0x2f4c78 - g_ps2RecompiledFunctionTable[512797] = adxsjd_decode_prep_0x2f4b38; // 0x2f4c7c - g_ps2RecompiledFunctionTable[512798] = adxsjd_decode_prep_0x2f4b38; // 0x2f4c80 - g_ps2RecompiledFunctionTable[512800] = adxsjd_get_wr_0x2f4c88; // 0x2f4c88 - g_ps2RecompiledFunctionTable[512801] = adxsjd_get_wr_0x2f4c88; // 0x2f4c8c - g_ps2RecompiledFunctionTable[512802] = adxsjd_get_wr_0x2f4c88; // 0x2f4c90 - g_ps2RecompiledFunctionTable[512803] = adxsjd_get_wr_0x2f4c88; // 0x2f4c94 - g_ps2RecompiledFunctionTable[512804] = adxsjd_get_wr_0x2f4c88; // 0x2f4c98 - g_ps2RecompiledFunctionTable[512805] = adxsjd_get_wr_0x2f4c88; // 0x2f4c9c - g_ps2RecompiledFunctionTable[512806] = adxsjd_get_wr_0x2f4c88; // 0x2f4ca0 - g_ps2RecompiledFunctionTable[512807] = adxsjd_get_wr_0x2f4c88; // 0x2f4ca4 - g_ps2RecompiledFunctionTable[512808] = adxsjd_get_wr_0x2f4c88; // 0x2f4ca8 - g_ps2RecompiledFunctionTable[512809] = adxsjd_get_wr_0x2f4c88; // 0x2f4cac - g_ps2RecompiledFunctionTable[512810] = adxsjd_get_wr_0x2f4c88; // 0x2f4cb0 - g_ps2RecompiledFunctionTable[512811] = adxsjd_get_wr_0x2f4c88; // 0x2f4cb4 - g_ps2RecompiledFunctionTable[512812] = adxsjd_get_wr_0x2f4c88; // 0x2f4cb8 - g_ps2RecompiledFunctionTable[512813] = adxsjd_get_wr_0x2f4c88; // 0x2f4cbc - g_ps2RecompiledFunctionTable[512814] = adxsjd_get_wr_0x2f4c88; // 0x2f4cc0 - g_ps2RecompiledFunctionTable[512815] = adxsjd_get_wr_0x2f4c88; // 0x2f4cc4 - g_ps2RecompiledFunctionTable[512816] = adxsjd_get_wr_0x2f4c88; // 0x2f4cc8 - g_ps2RecompiledFunctionTable[512817] = adxsjd_get_wr_0x2f4c88; // 0x2f4ccc - g_ps2RecompiledFunctionTable[512818] = adxsjd_get_wr_0x2f4c88; // 0x2f4cd0 - g_ps2RecompiledFunctionTable[512819] = adxsjd_get_wr_0x2f4c88; // 0x2f4cd4 - g_ps2RecompiledFunctionTable[512820] = adxsjd_get_wr_0x2f4c88; // 0x2f4cd8 - g_ps2RecompiledFunctionTable[512821] = adxsjd_get_wr_0x2f4c88; // 0x2f4cdc - g_ps2RecompiledFunctionTable[512822] = adxsjd_get_wr_0x2f4c88; // 0x2f4ce0 - g_ps2RecompiledFunctionTable[512823] = adxsjd_get_wr_0x2f4c88; // 0x2f4ce4 - g_ps2RecompiledFunctionTable[512824] = adxsjd_get_wr_0x2f4c88; // 0x2f4ce8 - g_ps2RecompiledFunctionTable[512825] = adxsjd_get_wr_0x2f4c88; // 0x2f4cec - g_ps2RecompiledFunctionTable[512826] = adxsjd_get_wr_0x2f4c88; // 0x2f4cf0 - g_ps2RecompiledFunctionTable[512827] = adxsjd_get_wr_0x2f4c88; // 0x2f4cf4 - g_ps2RecompiledFunctionTable[512828] = adxsjd_get_wr_0x2f4c88; // 0x2f4cf8 - g_ps2RecompiledFunctionTable[512829] = adxsjd_get_wr_0x2f4c88; // 0x2f4cfc - g_ps2RecompiledFunctionTable[512830] = adxsjd_get_wr_0x2f4c88; // 0x2f4d00 - g_ps2RecompiledFunctionTable[512831] = adxsjd_get_wr_0x2f4c88; // 0x2f4d04 - g_ps2RecompiledFunctionTable[512832] = adxsjd_get_wr_0x2f4c88; // 0x2f4d08 - g_ps2RecompiledFunctionTable[512833] = adxsjd_get_wr_0x2f4c88; // 0x2f4d0c - g_ps2RecompiledFunctionTable[512834] = adxsjd_get_wr_0x2f4c88; // 0x2f4d10 - g_ps2RecompiledFunctionTable[512835] = adxsjd_get_wr_0x2f4c88; // 0x2f4d14 - g_ps2RecompiledFunctionTable[512836] = adxsjd_get_wr_0x2f4c88; // 0x2f4d18 - g_ps2RecompiledFunctionTable[512837] = adxsjd_get_wr_0x2f4c88; // 0x2f4d1c - g_ps2RecompiledFunctionTable[512838] = adxsjd_get_wr_0x2f4c88; // 0x2f4d20 - g_ps2RecompiledFunctionTable[512839] = adxsjd_get_wr_0x2f4c88; // 0x2f4d24 - g_ps2RecompiledFunctionTable[512840] = adxsjd_get_wr_0x2f4c88; // 0x2f4d28 - g_ps2RecompiledFunctionTable[512841] = adxsjd_get_wr_0x2f4c88; // 0x2f4d2c - g_ps2RecompiledFunctionTable[512842] = adxsjd_get_wr_0x2f4c88; // 0x2f4d30 - g_ps2RecompiledFunctionTable[512843] = adxsjd_get_wr_0x2f4c88; // 0x2f4d34 - g_ps2RecompiledFunctionTable[512844] = adxsjd_get_wr_0x2f4c88; // 0x2f4d38 - g_ps2RecompiledFunctionTable[512845] = adxsjd_get_wr_0x2f4c88; // 0x2f4d3c - g_ps2RecompiledFunctionTable[512846] = adxsjd_get_wr_0x2f4c88; // 0x2f4d40 - g_ps2RecompiledFunctionTable[512847] = adxsjd_get_wr_0x2f4c88; // 0x2f4d44 - g_ps2RecompiledFunctionTable[512848] = adxsjd_get_wr_0x2f4c88; // 0x2f4d48 - g_ps2RecompiledFunctionTable[512849] = adxsjd_get_wr_0x2f4c88; // 0x2f4d4c - g_ps2RecompiledFunctionTable[512850] = adxsjd_get_wr_0x2f4c88; // 0x2f4d50 - g_ps2RecompiledFunctionTable[512851] = adxsjd_get_wr_0x2f4c88; // 0x2f4d54 - g_ps2RecompiledFunctionTable[512852] = adxsjd_get_wr_0x2f4c88; // 0x2f4d58 - g_ps2RecompiledFunctionTable[512853] = adxsjd_get_wr_0x2f4c88; // 0x2f4d5c - g_ps2RecompiledFunctionTable[512854] = adxsjd_get_wr_0x2f4c88; // 0x2f4d60 - g_ps2RecompiledFunctionTable[512855] = adxsjd_get_wr_0x2f4c88; // 0x2f4d64 - g_ps2RecompiledFunctionTable[512856] = adxsjd_get_wr_0x2f4c88; // 0x2f4d68 - g_ps2RecompiledFunctionTable[512857] = adxsjd_get_wr_0x2f4c88; // 0x2f4d6c - g_ps2RecompiledFunctionTable[512858] = adxsjd_get_wr_0x2f4c88; // 0x2f4d70 - g_ps2RecompiledFunctionTable[512859] = adxsjd_get_wr_0x2f4c88; // 0x2f4d74 - g_ps2RecompiledFunctionTable[512860] = adxsjd_get_wr_0x2f4c88; // 0x2f4d78 - g_ps2RecompiledFunctionTable[512861] = adxsjd_get_wr_0x2f4c88; // 0x2f4d7c - g_ps2RecompiledFunctionTable[512862] = adxsjd_get_wr_0x2f4c88; // 0x2f4d80 - g_ps2RecompiledFunctionTable[512863] = adxsjd_get_wr_0x2f4c88; // 0x2f4d84 - g_ps2RecompiledFunctionTable[512864] = adxsjd_get_wr_0x2f4c88; // 0x2f4d88 - g_ps2RecompiledFunctionTable[512865] = adxsjd_get_wr_0x2f4c88; // 0x2f4d8c - g_ps2RecompiledFunctionTable[512866] = adxsjd_get_wr_0x2f4c88; // 0x2f4d90 - g_ps2RecompiledFunctionTable[512868] = adxsjd_decexec_start_0x2f4d98; // 0x2f4d98 - g_ps2RecompiledFunctionTable[512869] = adxsjd_decexec_start_0x2f4d98; // 0x2f4d9c - g_ps2RecompiledFunctionTable[512870] = adxsjd_decexec_start_0x2f4d98; // 0x2f4da0 - g_ps2RecompiledFunctionTable[512871] = adxsjd_decexec_start_0x2f4d98; // 0x2f4da4 - g_ps2RecompiledFunctionTable[512872] = adxsjd_decexec_start_0x2f4d98; // 0x2f4da8 - g_ps2RecompiledFunctionTable[512873] = adxsjd_decexec_start_0x2f4d98; // 0x2f4dac - g_ps2RecompiledFunctionTable[512874] = adxsjd_decexec_start_0x2f4d98; // 0x2f4db0 - g_ps2RecompiledFunctionTable[512875] = adxsjd_decexec_start_0x2f4d98; // 0x2f4db4 - g_ps2RecompiledFunctionTable[512876] = adxsjd_decexec_start_0x2f4d98; // 0x2f4db8 - g_ps2RecompiledFunctionTable[512877] = adxsjd_decexec_start_0x2f4d98; // 0x2f4dbc - g_ps2RecompiledFunctionTable[512878] = adxsjd_decexec_start_0x2f4d98; // 0x2f4dc0 - g_ps2RecompiledFunctionTable[512879] = adxsjd_decexec_start_0x2f4d98; // 0x2f4dc4 - g_ps2RecompiledFunctionTable[512880] = adxsjd_decexec_start_0x2f4d98; // 0x2f4dc8 - g_ps2RecompiledFunctionTable[512881] = adxsjd_decexec_start_0x2f4d98; // 0x2f4dcc - g_ps2RecompiledFunctionTable[512882] = adxsjd_decexec_start_0x2f4d98; // 0x2f4dd0 - g_ps2RecompiledFunctionTable[512883] = adxsjd_decexec_start_0x2f4d98; // 0x2f4dd4 - g_ps2RecompiledFunctionTable[512884] = adxsjd_decexec_start_0x2f4d98; // 0x2f4dd8 - g_ps2RecompiledFunctionTable[512885] = adxsjd_decexec_start_0x2f4d98; // 0x2f4ddc - g_ps2RecompiledFunctionTable[512886] = adxsjd_decexec_start_0x2f4d98; // 0x2f4de0 - g_ps2RecompiledFunctionTable[512887] = adxsjd_decexec_start_0x2f4d98; // 0x2f4de4 - g_ps2RecompiledFunctionTable[512888] = adxsjd_decexec_start_0x2f4d98; // 0x2f4de8 - g_ps2RecompiledFunctionTable[512889] = adxsjd_decexec_start_0x2f4d98; // 0x2f4dec - g_ps2RecompiledFunctionTable[512890] = adxsjd_decexec_start_0x2f4d98; // 0x2f4df0 - g_ps2RecompiledFunctionTable[512891] = adxsjd_decexec_start_0x2f4d98; // 0x2f4df4 - g_ps2RecompiledFunctionTable[512892] = adxsjd_decexec_start_0x2f4d98; // 0x2f4df8 - g_ps2RecompiledFunctionTable[512893] = adxsjd_decexec_start_0x2f4d98; // 0x2f4dfc - g_ps2RecompiledFunctionTable[512894] = adxsjd_decexec_start_0x2f4d98; // 0x2f4e00 - g_ps2RecompiledFunctionTable[512895] = adxsjd_decexec_start_0x2f4d98; // 0x2f4e04 - g_ps2RecompiledFunctionTable[512896] = adxsjd_decexec_start_0x2f4d98; // 0x2f4e08 - g_ps2RecompiledFunctionTable[512897] = adxsjd_decexec_start_0x2f4d98; // 0x2f4e0c - g_ps2RecompiledFunctionTable[512898] = adxsjd_decexec_start_0x2f4d98; // 0x2f4e10 - g_ps2RecompiledFunctionTable[512899] = adxsjd_decexec_start_0x2f4d98; // 0x2f4e14 - g_ps2RecompiledFunctionTable[512900] = adxsjd_decexec_start_0x2f4d98; // 0x2f4e18 - g_ps2RecompiledFunctionTable[512901] = adxsjd_decexec_start_0x2f4d98; // 0x2f4e1c - g_ps2RecompiledFunctionTable[512902] = adxsjd_decexec_start_0x2f4d98; // 0x2f4e20 - g_ps2RecompiledFunctionTable[512903] = adxsjd_decexec_start_0x2f4d98; // 0x2f4e24 - g_ps2RecompiledFunctionTable[512904] = adxsjd_decexec_start_0x2f4d98; // 0x2f4e28 - g_ps2RecompiledFunctionTable[512905] = adxsjd_decexec_start_0x2f4d98; // 0x2f4e2c - g_ps2RecompiledFunctionTable[512906] = adxsjd_decexec_start_0x2f4d98; // 0x2f4e30 - g_ps2RecompiledFunctionTable[512907] = adxsjd_decexec_start_0x2f4d98; // 0x2f4e34 - g_ps2RecompiledFunctionTable[512908] = adxsjd_decexec_start_0x2f4d98; // 0x2f4e38 - g_ps2RecompiledFunctionTable[512909] = adxsjd_decexec_start_0x2f4d98; // 0x2f4e3c - g_ps2RecompiledFunctionTable[512910] = adxsjd_decexec_start_0x2f4d98; // 0x2f4e40 - g_ps2RecompiledFunctionTable[512911] = adxsjd_decexec_start_0x2f4d98; // 0x2f4e44 - g_ps2RecompiledFunctionTable[512912] = adxsjd_decexec_start_0x2f4d98; // 0x2f4e48 - g_ps2RecompiledFunctionTable[512913] = adxsjd_decexec_start_0x2f4d98; // 0x2f4e4c - g_ps2RecompiledFunctionTable[512914] = adxsjd_decexec_start_0x2f4d98; // 0x2f4e50 - g_ps2RecompiledFunctionTable[512915] = adxsjd_decexec_start_0x2f4d98; // 0x2f4e54 - g_ps2RecompiledFunctionTable[512916] = adxsjd_decexec_start_0x2f4d98; // 0x2f4e58 - g_ps2RecompiledFunctionTable[512917] = adxsjd_decexec_start_0x2f4d98; // 0x2f4e5c - g_ps2RecompiledFunctionTable[512918] = adxsjd_decexec_start_0x2f4d98; // 0x2f4e60 - g_ps2RecompiledFunctionTable[512919] = adxsjd_decexec_start_0x2f4d98; // 0x2f4e64 - g_ps2RecompiledFunctionTable[512920] = adxsjd_decexec_start_0x2f4d98; // 0x2f4e68 - g_ps2RecompiledFunctionTable[512921] = adxsjd_decexec_start_0x2f4d98; // 0x2f4e6c - g_ps2RecompiledFunctionTable[512922] = adxsjd_decexec_start_0x2f4d98; // 0x2f4e70 - g_ps2RecompiledFunctionTable[512923] = adxsjd_decexec_start_0x2f4d98; // 0x2f4e74 - g_ps2RecompiledFunctionTable[512924] = adxsjd_decexec_start_0x2f4d98; // 0x2f4e78 - g_ps2RecompiledFunctionTable[512925] = adxsjd_decexec_start_0x2f4d98; // 0x2f4e7c - g_ps2RecompiledFunctionTable[512926] = adxsjd_decexec_start_0x2f4d98; // 0x2f4e80 - g_ps2RecompiledFunctionTable[512927] = adxsjd_decexec_start_0x2f4d98; // 0x2f4e84 - g_ps2RecompiledFunctionTable[512928] = adxsjd_decexec_start_0x2f4d98; // 0x2f4e88 - g_ps2RecompiledFunctionTable[512929] = adxsjd_decexec_start_0x2f4d98; // 0x2f4e8c - g_ps2RecompiledFunctionTable[512930] = adxsjd_decexec_start_0x2f4d98; // 0x2f4e90 - g_ps2RecompiledFunctionTable[512931] = adxsjd_decexec_start_0x2f4d98; // 0x2f4e94 - g_ps2RecompiledFunctionTable[512932] = adxsjd_decexec_start_0x2f4d98; // 0x2f4e98 - g_ps2RecompiledFunctionTable[512933] = adxsjd_decexec_start_0x2f4d98; // 0x2f4e9c - g_ps2RecompiledFunctionTable[512934] = adxsjd_decexec_start_0x2f4d98; // 0x2f4ea0 - g_ps2RecompiledFunctionTable[512935] = adxsjd_decexec_start_0x2f4d98; // 0x2f4ea4 - g_ps2RecompiledFunctionTable[512936] = adxsjd_decexec_start_0x2f4d98; // 0x2f4ea8 - g_ps2RecompiledFunctionTable[512937] = adxsjd_decexec_start_0x2f4d98; // 0x2f4eac - g_ps2RecompiledFunctionTable[512938] = adxsjd_decexec_start_0x2f4d98; // 0x2f4eb0 - g_ps2RecompiledFunctionTable[512939] = adxsjd_decexec_start_0x2f4d98; // 0x2f4eb4 - g_ps2RecompiledFunctionTable[512940] = adxsjd_decexec_start_0x2f4d98; // 0x2f4eb8 - g_ps2RecompiledFunctionTable[512941] = adxsjd_decexec_start_0x2f4d98; // 0x2f4ebc - g_ps2RecompiledFunctionTable[512942] = adxsjd_decexec_start_0x2f4d98; // 0x2f4ec0 - g_ps2RecompiledFunctionTable[512943] = adxsjd_decexec_start_0x2f4d98; // 0x2f4ec4 - g_ps2RecompiledFunctionTable[512944] = adxsjd_decexec_start_0x2f4d98; // 0x2f4ec8 - g_ps2RecompiledFunctionTable[512945] = adxsjd_decexec_start_0x2f4d98; // 0x2f4ecc - g_ps2RecompiledFunctionTable[512946] = adxsjd_decexec_start_0x2f4d98; // 0x2f4ed0 - g_ps2RecompiledFunctionTable[512947] = adxsjd_decexec_start_0x2f4d98; // 0x2f4ed4 - g_ps2RecompiledFunctionTable[512948] = adxsjd_decexec_start_0x2f4d98; // 0x2f4ed8 - g_ps2RecompiledFunctionTable[512949] = adxsjd_decexec_start_0x2f4d98; // 0x2f4edc - g_ps2RecompiledFunctionTable[512950] = adxsjd_decexec_start_0x2f4d98; // 0x2f4ee0 - g_ps2RecompiledFunctionTable[512951] = adxsjd_decexec_start_0x2f4d98; // 0x2f4ee4 - g_ps2RecompiledFunctionTable[512952] = adxsjd_decexec_start_0x2f4d98; // 0x2f4ee8 - g_ps2RecompiledFunctionTable[512953] = adxsjd_decexec_start_0x2f4d98; // 0x2f4eec - g_ps2RecompiledFunctionTable[512954] = adxsjd_decexec_start_0x2f4d98; // 0x2f4ef0 - g_ps2RecompiledFunctionTable[512955] = adxsjd_decexec_start_0x2f4d98; // 0x2f4ef4 - g_ps2RecompiledFunctionTable[512956] = adxsjd_decexec_start_0x2f4d98; // 0x2f4ef8 - g_ps2RecompiledFunctionTable[512957] = adxsjd_decexec_start_0x2f4d98; // 0x2f4efc - g_ps2RecompiledFunctionTable[512958] = adxsjd_decexec_start_0x2f4d98; // 0x2f4f00 - g_ps2RecompiledFunctionTable[512959] = adxsjd_decexec_start_0x2f4d98; // 0x2f4f04 - g_ps2RecompiledFunctionTable[512960] = adxsjd_decexec_start_0x2f4d98; // 0x2f4f08 - g_ps2RecompiledFunctionTable[512961] = adxsjd_decexec_start_0x2f4d98; // 0x2f4f0c - g_ps2RecompiledFunctionTable[512962] = adxsjd_decexec_start_0x2f4d98; // 0x2f4f10 - g_ps2RecompiledFunctionTable[512963] = adxsjd_decexec_start_0x2f4d98; // 0x2f4f14 - g_ps2RecompiledFunctionTable[512964] = adxsjd_decexec_start_0x2f4d98; // 0x2f4f18 - g_ps2RecompiledFunctionTable[512965] = adxsjd_decexec_start_0x2f4d98; // 0x2f4f1c - g_ps2RecompiledFunctionTable[512966] = adxsjd_decexec_start_0x2f4d98; // 0x2f4f20 - g_ps2RecompiledFunctionTable[512967] = adxsjd_decexec_start_0x2f4d98; // 0x2f4f24 - g_ps2RecompiledFunctionTable[512968] = adxsjd_decexec_start_0x2f4d98; // 0x2f4f28 - g_ps2RecompiledFunctionTable[512969] = adxsjd_decexec_start_0x2f4d98; // 0x2f4f2c - g_ps2RecompiledFunctionTable[512970] = adxsjd_decexec_start_0x2f4d98; // 0x2f4f30 - g_ps2RecompiledFunctionTable[512972] = adxsjd_decexec_end_0x2f4f38; // 0x2f4f38 - g_ps2RecompiledFunctionTable[512973] = adxsjd_decexec_end_0x2f4f38; // 0x2f4f3c - g_ps2RecompiledFunctionTable[512974] = adxsjd_decexec_end_0x2f4f38; // 0x2f4f40 - g_ps2RecompiledFunctionTable[512975] = adxsjd_decexec_end_0x2f4f38; // 0x2f4f44 - g_ps2RecompiledFunctionTable[512976] = adxsjd_decexec_end_0x2f4f38; // 0x2f4f48 - g_ps2RecompiledFunctionTable[512977] = adxsjd_decexec_end_0x2f4f38; // 0x2f4f4c - g_ps2RecompiledFunctionTable[512978] = adxsjd_decexec_end_0x2f4f38; // 0x2f4f50 - g_ps2RecompiledFunctionTable[512979] = adxsjd_decexec_end_0x2f4f38; // 0x2f4f54 - g_ps2RecompiledFunctionTable[512980] = adxsjd_decexec_end_0x2f4f38; // 0x2f4f58 - g_ps2RecompiledFunctionTable[512981] = adxsjd_decexec_end_0x2f4f38; // 0x2f4f5c - g_ps2RecompiledFunctionTable[512982] = adxsjd_decexec_end_0x2f4f38; // 0x2f4f60 - g_ps2RecompiledFunctionTable[512983] = adxsjd_decexec_end_0x2f4f38; // 0x2f4f64 - g_ps2RecompiledFunctionTable[512984] = adxsjd_decexec_end_0x2f4f38; // 0x2f4f68 - g_ps2RecompiledFunctionTable[512985] = adxsjd_decexec_end_0x2f4f38; // 0x2f4f6c - g_ps2RecompiledFunctionTable[512986] = adxsjd_decexec_end_0x2f4f38; // 0x2f4f70 - g_ps2RecompiledFunctionTable[512987] = adxsjd_decexec_end_0x2f4f38; // 0x2f4f74 - g_ps2RecompiledFunctionTable[512988] = adxsjd_decexec_end_0x2f4f38; // 0x2f4f78 - g_ps2RecompiledFunctionTable[512989] = adxsjd_decexec_end_0x2f4f38; // 0x2f4f7c - g_ps2RecompiledFunctionTable[512990] = adxsjd_decexec_end_0x2f4f38; // 0x2f4f80 - g_ps2RecompiledFunctionTable[512991] = adxsjd_decexec_end_0x2f4f38; // 0x2f4f84 - g_ps2RecompiledFunctionTable[512992] = adxsjd_decexec_end_0x2f4f38; // 0x2f4f88 - g_ps2RecompiledFunctionTable[512993] = adxsjd_decexec_end_0x2f4f38; // 0x2f4f8c - g_ps2RecompiledFunctionTable[512994] = adxsjd_decexec_end_0x2f4f38; // 0x2f4f90 - g_ps2RecompiledFunctionTable[512995] = adxsjd_decexec_end_0x2f4f38; // 0x2f4f94 - g_ps2RecompiledFunctionTable[512996] = adxsjd_decexec_end_0x2f4f38; // 0x2f4f98 - g_ps2RecompiledFunctionTable[512997] = adxsjd_decexec_end_0x2f4f38; // 0x2f4f9c - g_ps2RecompiledFunctionTable[512998] = adxsjd_decexec_end_0x2f4f38; // 0x2f4fa0 - g_ps2RecompiledFunctionTable[512999] = adxsjd_decexec_end_0x2f4f38; // 0x2f4fa4 - g_ps2RecompiledFunctionTable[513000] = adxsjd_decexec_end_0x2f4f38; // 0x2f4fa8 - g_ps2RecompiledFunctionTable[513001] = adxsjd_decexec_end_0x2f4f38; // 0x2f4fac - g_ps2RecompiledFunctionTable[513002] = adxsjd_decexec_end_0x2f4f38; // 0x2f4fb0 - g_ps2RecompiledFunctionTable[513003] = adxsjd_decexec_end_0x2f4f38; // 0x2f4fb4 - g_ps2RecompiledFunctionTable[513004] = adxsjd_decexec_end_0x2f4f38; // 0x2f4fb8 - g_ps2RecompiledFunctionTable[513005] = adxsjd_decexec_end_0x2f4f38; // 0x2f4fbc - g_ps2RecompiledFunctionTable[513006] = adxsjd_decexec_end_0x2f4f38; // 0x2f4fc0 - g_ps2RecompiledFunctionTable[513007] = adxsjd_decexec_end_0x2f4f38; // 0x2f4fc4 - g_ps2RecompiledFunctionTable[513008] = adxsjd_decexec_end_0x2f4f38; // 0x2f4fc8 - g_ps2RecompiledFunctionTable[513009] = adxsjd_decexec_end_0x2f4f38; // 0x2f4fcc - g_ps2RecompiledFunctionTable[513010] = adxsjd_decexec_end_0x2f4f38; // 0x2f4fd0 - g_ps2RecompiledFunctionTable[513011] = adxsjd_decexec_end_0x2f4f38; // 0x2f4fd4 - g_ps2RecompiledFunctionTable[513012] = adxsjd_decexec_end_0x2f4f38; // 0x2f4fd8 - g_ps2RecompiledFunctionTable[513013] = adxsjd_decexec_end_0x2f4f38; // 0x2f4fdc - g_ps2RecompiledFunctionTable[513014] = adxsjd_decexec_end_0x2f4f38; // 0x2f4fe0 - g_ps2RecompiledFunctionTable[513015] = adxsjd_decexec_end_0x2f4f38; // 0x2f4fe4 - g_ps2RecompiledFunctionTable[513016] = adxsjd_decexec_end_0x2f4f38; // 0x2f4fe8 - g_ps2RecompiledFunctionTable[513017] = adxsjd_decexec_end_0x2f4f38; // 0x2f4fec - g_ps2RecompiledFunctionTable[513018] = adxsjd_decexec_end_0x2f4f38; // 0x2f4ff0 - g_ps2RecompiledFunctionTable[513019] = adxsjd_decexec_end_0x2f4f38; // 0x2f4ff4 - g_ps2RecompiledFunctionTable[513020] = adxsjd_decexec_end_0x2f4f38; // 0x2f4ff8 - g_ps2RecompiledFunctionTable[513021] = adxsjd_decexec_end_0x2f4f38; // 0x2f4ffc - g_ps2RecompiledFunctionTable[513022] = adxsjd_decexec_end_0x2f4f38; // 0x2f5000 - g_ps2RecompiledFunctionTable[513023] = adxsjd_decexec_end_0x2f4f38; // 0x2f5004 - g_ps2RecompiledFunctionTable[513024] = adxsjd_decexec_end_0x2f4f38; // 0x2f5008 - g_ps2RecompiledFunctionTable[513025] = adxsjd_decexec_end_0x2f4f38; // 0x2f500c - g_ps2RecompiledFunctionTable[513026] = adxsjd_decexec_end_0x2f4f38; // 0x2f5010 - g_ps2RecompiledFunctionTable[513027] = adxsjd_decexec_end_0x2f4f38; // 0x2f5014 - g_ps2RecompiledFunctionTable[513028] = adxsjd_decexec_end_0x2f4f38; // 0x2f5018 - g_ps2RecompiledFunctionTable[513029] = adxsjd_decexec_end_0x2f4f38; // 0x2f501c - g_ps2RecompiledFunctionTable[513030] = adxsjd_decexec_end_0x2f4f38; // 0x2f5020 - g_ps2RecompiledFunctionTable[513031] = adxsjd_decexec_end_0x2f4f38; // 0x2f5024 - g_ps2RecompiledFunctionTable[513032] = adxsjd_decexec_end_0x2f4f38; // 0x2f5028 - g_ps2RecompiledFunctionTable[513033] = adxsjd_decexec_end_0x2f4f38; // 0x2f502c - g_ps2RecompiledFunctionTable[513034] = adxsjd_decexec_end_0x2f4f38; // 0x2f5030 - g_ps2RecompiledFunctionTable[513035] = adxsjd_decexec_end_0x2f4f38; // 0x2f5034 - g_ps2RecompiledFunctionTable[513036] = adxsjd_decexec_end_0x2f4f38; // 0x2f5038 - g_ps2RecompiledFunctionTable[513037] = adxsjd_decexec_end_0x2f4f38; // 0x2f503c - g_ps2RecompiledFunctionTable[513038] = adxsjd_decexec_end_0x2f4f38; // 0x2f5040 - g_ps2RecompiledFunctionTable[513039] = adxsjd_decexec_end_0x2f4f38; // 0x2f5044 - g_ps2RecompiledFunctionTable[513040] = adxsjd_decexec_end_0x2f4f38; // 0x2f5048 - g_ps2RecompiledFunctionTable[513041] = adxsjd_decexec_end_0x2f4f38; // 0x2f504c - g_ps2RecompiledFunctionTable[513042] = adxsjd_decexec_end_0x2f4f38; // 0x2f5050 - g_ps2RecompiledFunctionTable[513043] = adxsjd_decexec_end_0x2f4f38; // 0x2f5054 - g_ps2RecompiledFunctionTable[513044] = adxsjd_decexec_end_0x2f4f38; // 0x2f5058 - g_ps2RecompiledFunctionTable[513045] = adxsjd_decexec_end_0x2f4f38; // 0x2f505c - g_ps2RecompiledFunctionTable[513046] = adxsjd_decexec_end_0x2f4f38; // 0x2f5060 - g_ps2RecompiledFunctionTable[513047] = adxsjd_decexec_end_0x2f4f38; // 0x2f5064 - g_ps2RecompiledFunctionTable[513048] = adxsjd_decexec_end_0x2f4f38; // 0x2f5068 - g_ps2RecompiledFunctionTable[513049] = adxsjd_decexec_end_0x2f4f38; // 0x2f506c - g_ps2RecompiledFunctionTable[513050] = adxsjd_decexec_end_0x2f4f38; // 0x2f5070 - g_ps2RecompiledFunctionTable[513051] = adxsjd_decexec_end_0x2f4f38; // 0x2f5074 - g_ps2RecompiledFunctionTable[513052] = adxsjd_decexec_end_0x2f4f38; // 0x2f5078 - g_ps2RecompiledFunctionTable[513053] = adxsjd_decexec_end_0x2f4f38; // 0x2f507c - g_ps2RecompiledFunctionTable[513054] = adxsjd_decexec_end_0x2f4f38; // 0x2f5080 - g_ps2RecompiledFunctionTable[513055] = adxsjd_decexec_end_0x2f4f38; // 0x2f5084 - g_ps2RecompiledFunctionTable[513056] = adxsjd_decexec_end_0x2f4f38; // 0x2f5088 - g_ps2RecompiledFunctionTable[513057] = adxsjd_decexec_end_0x2f4f38; // 0x2f508c - g_ps2RecompiledFunctionTable[513058] = adxsjd_decexec_end_0x2f4f38; // 0x2f5090 - g_ps2RecompiledFunctionTable[513059] = adxsjd_decexec_end_0x2f4f38; // 0x2f5094 - g_ps2RecompiledFunctionTable[513060] = adxsjd_decexec_end_0x2f4f38; // 0x2f5098 - g_ps2RecompiledFunctionTable[513061] = adxsjd_decexec_end_0x2f4f38; // 0x2f509c - g_ps2RecompiledFunctionTable[513062] = adxsjd_decexec_end_0x2f4f38; // 0x2f50a0 - g_ps2RecompiledFunctionTable[513063] = adxsjd_decexec_end_0x2f4f38; // 0x2f50a4 - g_ps2RecompiledFunctionTable[513064] = adxsjd_decexec_end_0x2f4f38; // 0x2f50a8 - g_ps2RecompiledFunctionTable[513065] = adxsjd_decexec_end_0x2f4f38; // 0x2f50ac - g_ps2RecompiledFunctionTable[513066] = adxsjd_decexec_end_0x2f4f38; // 0x2f50b0 - g_ps2RecompiledFunctionTable[513067] = adxsjd_decexec_end_0x2f4f38; // 0x2f50b4 - g_ps2RecompiledFunctionTable[513068] = adxsjd_decexec_end_0x2f4f38; // 0x2f50b8 - g_ps2RecompiledFunctionTable[513069] = adxsjd_decexec_end_0x2f4f38; // 0x2f50bc - g_ps2RecompiledFunctionTable[513070] = adxsjd_decexec_end_0x2f4f38; // 0x2f50c0 - g_ps2RecompiledFunctionTable[513071] = adxsjd_decexec_end_0x2f4f38; // 0x2f50c4 - g_ps2RecompiledFunctionTable[513072] = adxsjd_decexec_end_0x2f4f38; // 0x2f50c8 - g_ps2RecompiledFunctionTable[513073] = adxsjd_decexec_end_0x2f4f38; // 0x2f50cc - g_ps2RecompiledFunctionTable[513074] = adxsjd_decexec_end_0x2f4f38; // 0x2f50d0 - g_ps2RecompiledFunctionTable[513075] = adxsjd_decexec_end_0x2f4f38; // 0x2f50d4 - g_ps2RecompiledFunctionTable[513076] = adxsjd_decexec_end_0x2f4f38; // 0x2f50d8 - g_ps2RecompiledFunctionTable[513077] = adxsjd_decexec_end_0x2f4f38; // 0x2f50dc - g_ps2RecompiledFunctionTable[513078] = adxsjd_decexec_end_0x2f4f38; // 0x2f50e0 - g_ps2RecompiledFunctionTable[513079] = adxsjd_decexec_end_0x2f4f38; // 0x2f50e4 - g_ps2RecompiledFunctionTable[513080] = adxsjd_decexec_end_0x2f4f38; // 0x2f50e8 - g_ps2RecompiledFunctionTable[513081] = adxsjd_decexec_end_0x2f4f38; // 0x2f50ec - g_ps2RecompiledFunctionTable[513082] = adxsjd_decexec_end_0x2f4f38; // 0x2f50f0 - g_ps2RecompiledFunctionTable[513083] = adxsjd_decexec_end_0x2f4f38; // 0x2f50f4 - g_ps2RecompiledFunctionTable[513084] = adxsjd_decexec_end_0x2f4f38; // 0x2f50f8 - g_ps2RecompiledFunctionTable[513085] = adxsjd_decexec_end_0x2f4f38; // 0x2f50fc - g_ps2RecompiledFunctionTable[513086] = adxsjd_decexec_end_0x2f4f38; // 0x2f5100 - g_ps2RecompiledFunctionTable[513087] = adxsjd_decexec_end_0x2f4f38; // 0x2f5104 - g_ps2RecompiledFunctionTable[513088] = adxsjd_decexec_end_0x2f4f38; // 0x2f5108 - g_ps2RecompiledFunctionTable[513089] = adxsjd_decexec_end_0x2f4f38; // 0x2f510c - g_ps2RecompiledFunctionTable[513090] = adxsjd_decexec_end_0x2f4f38; // 0x2f5110 - g_ps2RecompiledFunctionTable[513091] = adxsjd_decexec_end_0x2f4f38; // 0x2f5114 - g_ps2RecompiledFunctionTable[513092] = adxsjd_decexec_end_0x2f4f38; // 0x2f5118 - g_ps2RecompiledFunctionTable[513093] = adxsjd_decexec_end_0x2f4f38; // 0x2f511c - g_ps2RecompiledFunctionTable[513094] = adxsjd_decode_exec_0x2f5120; // 0x2f5120 - g_ps2RecompiledFunctionTable[513102] = adxsjd_decode_exec_0x2f5120; // 0x2f5140 - g_ps2RecompiledFunctionTable[513106] = adxsjd_decode_exec_0x2f5120; // 0x2f5150 - g_ps2RecompiledFunctionTable[513108] = adxsjd_decode_exec_0x2f5120; // 0x2f5158 - g_ps2RecompiledFunctionTable[513110] = adxsjd_decode_exec_0x2f5120; // 0x2f5160 - g_ps2RecompiledFunctionTable[513122] = ADXSJD_ExecHndl_0x2f5190; // 0x2f5190 - g_ps2RecompiledFunctionTable[513134] = ADXSJD_ExecServer_0x2f51c0; // 0x2f51c0 - g_ps2RecompiledFunctionTable[513144] = ADXSJD_ExecServer_0x2f51c0; // 0x2f51e8 - g_ps2RecompiledFunctionTable[513148] = ADXSJD_ExecServer_0x2f51c0; // 0x2f51f8 - g_ps2RecompiledFunctionTable[513158] = ADXSJD_GetDecDtLen_0x2f5220; // 0x2f5220 - g_ps2RecompiledFunctionTable[513160] = ADXSJD_GetDecNumSmpl_0x2f5228; // 0x2f5228 - g_ps2RecompiledFunctionTable[513162] = ADXSJD_SetDecPos_0x2f5230; // 0x2f5230 - g_ps2RecompiledFunctionTable[513164] = ADXSJD_GetDecPos_0x2f5238; // 0x2f5238 - g_ps2RecompiledFunctionTable[513166] = ADXSJD_EntryFltFunc_0x2f5240; // 0x2f5240 - g_ps2RecompiledFunctionTable[513170] = ADXSJD_EntryTrapFunc_0x2f5250; // 0x2f5250 - g_ps2RecompiledFunctionTable[513174] = ADXSJD_SetTrapNumSmpl_0x2f5260; // 0x2f5260 - g_ps2RecompiledFunctionTable[513176] = ADXSJD_GetTrapNumSmpl_0x2f5268; // 0x2f5268 - g_ps2RecompiledFunctionTable[513178] = ADXSJD_SetTrapCnt_0x2f5270; // 0x2f5270 - g_ps2RecompiledFunctionTable[513180] = ADXSJD_GetTrapCnt_0x2f5278; // 0x2f5278 - g_ps2RecompiledFunctionTable[513182] = ADXSJD_SetTrapDtLen_0x2f5280; // 0x2f5280 - g_ps2RecompiledFunctionTable[513184] = ADXSJD_GetTrapDtLen_0x2f5288; // 0x2f5288 - g_ps2RecompiledFunctionTable[513186] = ADXSJD_GetFormat_0x2f5290; // 0x2f5290 - g_ps2RecompiledFunctionTable[513190] = ADXSJD_GetFormat_0x2f5290; // 0x2f52a0 - g_ps2RecompiledFunctionTable[513194] = ADXSJD_GetSfreq_0x2f52b0; // 0x2f52b0 - g_ps2RecompiledFunctionTable[513198] = ADXSJD_GetSfreq_0x2f52b0; // 0x2f52c0 - g_ps2RecompiledFunctionTable[513202] = ADXSJD_GetNumChan_0x2f52d0; // 0x2f52d0 - g_ps2RecompiledFunctionTable[513206] = ADXSJD_GetNumChan_0x2f52d0; // 0x2f52e0 - g_ps2RecompiledFunctionTable[513210] = ADXSJD_GetOutBps_0x2f52f0; // 0x2f52f0 - g_ps2RecompiledFunctionTable[513214] = ADXSJD_GetOutBps_0x2f52f0; // 0x2f5300 - g_ps2RecompiledFunctionTable[513218] = ADXSJD_GetBlkSmpl_0x2f5310; // 0x2f5310 - g_ps2RecompiledFunctionTable[513222] = ADXSJD_GetBlkSmpl_0x2f5310; // 0x2f5320 - g_ps2RecompiledFunctionTable[513226] = ADXSJD_GetBlkLen_0x2f5330; // 0x2f5330 - g_ps2RecompiledFunctionTable[513230] = ADXSJD_GetBlkLen_0x2f5330; // 0x2f5340 - g_ps2RecompiledFunctionTable[513234] = ADXSJD_GetTotalNumSmpl_0x2f5350; // 0x2f5350 - g_ps2RecompiledFunctionTable[513238] = ADXSJD_GetTotalNumSmpl_0x2f5350; // 0x2f5360 - g_ps2RecompiledFunctionTable[513242] = ADXSJD_GetCof_0x2f5370; // 0x2f5370 - g_ps2RecompiledFunctionTable[513246] = ADXSJD_GetCof_0x2f5370; // 0x2f5380 - g_ps2RecompiledFunctionTable[513250] = ADXSJD_GetNumLoop_0x2f5390; // 0x2f5390 - g_ps2RecompiledFunctionTable[513254] = ADXSJD_GetNumLoop_0x2f5390; // 0x2f53a0 - g_ps2RecompiledFunctionTable[513258] = ADXSJD_GetLpInsNsmpl_0x2f53b0; // 0x2f53b0 - g_ps2RecompiledFunctionTable[513262] = ADXSJD_GetLpInsNsmpl_0x2f53b0; // 0x2f53c0 - g_ps2RecompiledFunctionTable[513266] = ADXSJD_GetLpStartPos_0x2f53d0; // 0x2f53d0 - g_ps2RecompiledFunctionTable[513270] = ADXSJD_GetLpStartPos_0x2f53d0; // 0x2f53e0 - g_ps2RecompiledFunctionTable[513274] = ADXSJD_GetLpStartOfst_0x2f53f0; // 0x2f53f0 - g_ps2RecompiledFunctionTable[513278] = ADXSJD_GetLpStartOfst_0x2f53f0; // 0x2f5400 - g_ps2RecompiledFunctionTable[513282] = ADXSJD_GetLpEndPos_0x2f5410; // 0x2f5410 - g_ps2RecompiledFunctionTable[513286] = ADXSJD_GetLpEndPos_0x2f5410; // 0x2f5420 - g_ps2RecompiledFunctionTable[513290] = ADXSJD_GetLpEndOfst_0x2f5430; // 0x2f5430 - g_ps2RecompiledFunctionTable[513294] = ADXSJD_GetLpEndOfst_0x2f5430; // 0x2f5440 - g_ps2RecompiledFunctionTable[513298] = ADXSJD_GetHdrLen_0x2f5450; // 0x2f5450 - g_ps2RecompiledFunctionTable[513300] = ADXSJD_GetFmtBps_0x2f5458; // 0x2f5458 - g_ps2RecompiledFunctionTable[513304] = ADXSJD_GetFmtBps_0x2f5458; // 0x2f5468 - g_ps2RecompiledFunctionTable[513308] = ADXSJD_GetSpsdInfo_0x2f5478; // 0x2f5478 - g_ps2RecompiledFunctionTable[513310] = ADXT_SetupRtimeNumStm_0x2f5480; // 0x2f5480 - g_ps2RecompiledFunctionTable[513312] = ADXT_SetupNrmlNumStm_0x2f5488; // 0x2f5488 - g_ps2RecompiledFunctionTable[513318] = ADXSTM_Init_0x2f54a0; // 0x2f54a0 - g_ps2RecompiledFunctionTable[513325] = ADXSTM_Init_0x2f54a0; // 0x2f54bc - g_ps2RecompiledFunctionTable[513330] = ADXSTM_Reset_0x2f54d0; // 0x2f54d0 - g_ps2RecompiledFunctionTable[513332] = ADXSTM_Finish_0x2f54d8; // 0x2f54d8 - g_ps2RecompiledFunctionTable[513334] = ADXSTMF_SetupHandleMember_0x2f54e0; // 0x2f54e0 - g_ps2RecompiledFunctionTable[513354] = ADXSTMF_CreateCvfsRt_0x2f5530; // 0x2f5530 - g_ps2RecompiledFunctionTable[513376] = ADXSTMF_CreateCvfsRt_0x2f5530; // 0x2f5588 - g_ps2RecompiledFunctionTable[513392] = ADXSTMF_CreateCvfsRt_0x2f5530; // 0x2f55c8 - g_ps2RecompiledFunctionTable[513398] = ADXSTMF_CreateCvfs_0x2f55e0; // 0x2f55e0 - g_ps2RecompiledFunctionTable[513420] = ADXSTMF_CreateCvfs_0x2f55e0; // 0x2f5638 - g_ps2RecompiledFunctionTable[513436] = ADXSTMF_CreateCvfs_0x2f55e0; // 0x2f5678 - g_ps2RecompiledFunctionTable[513442] = ADXSTMF_Destroy_0x2f5690; // 0x2f5690 - g_ps2RecompiledFunctionTable[513446] = ADXSTM_OpenFileRangeEx_0x2f56a0; // 0x2f56a0 - g_ps2RecompiledFunctionTable[513458] = ADXSTM_OpenFileRangeEx_0x2f56a0; // 0x2f56d0 - g_ps2RecompiledFunctionTable[513464] = ADXSTM_OpenFileRangeEx_0x2f56a0; // 0x2f56e8 - g_ps2RecompiledFunctionTable[513470] = ADXSTM_OpenFileRangeEx_0x2f56a0; // 0x2f5700 - g_ps2RecompiledFunctionTable[513475] = ADXSTM_OpenFileRangeEx_0x2f56a0; // 0x2f5714 - g_ps2RecompiledFunctionTable[513484] = ADXSTM_OpenFileRangeExRt_0x2f5738; // 0x2f5738 - g_ps2RecompiledFunctionTable[513496] = ADXSTM_OpenFileRangeExRt_0x2f5738; // 0x2f5768 - g_ps2RecompiledFunctionTable[513502] = ADXSTM_OpenFileRangeExRt_0x2f5738; // 0x2f5780 - g_ps2RecompiledFunctionTable[513508] = ADXSTM_OpenFileRangeExRt_0x2f5738; // 0x2f5798 - g_ps2RecompiledFunctionTable[513513] = ADXSTM_OpenFileRangeExRt_0x2f5738; // 0x2f57ac - g_ps2RecompiledFunctionTable[513522] = ADXSTM_OpenFnameEx_0x2f57d0; // 0x2f57d0 - g_ps2RecompiledFunctionTable[513533] = ADXSTM_OpenFnameEx_0x2f57d0; // 0x2f57fc - g_ps2RecompiledFunctionTable[513537] = ADXSTM_OpenFnameEx_0x2f57d0; // 0x2f580c - g_ps2RecompiledFunctionTable[513542] = ADXSTM_OpenFnameEx_0x2f57d0; // 0x2f5820 - g_ps2RecompiledFunctionTable[513548] = ADXSTM_OpenFnameEx_0x2f57d0; // 0x2f5838 - g_ps2RecompiledFunctionTable[513554] = ADXSTM_OpenFnameEx_0x2f57d0; // 0x2f5850 - g_ps2RecompiledFunctionTable[513559] = ADXSTM_OpenFnameEx_0x2f57d0; // 0x2f5864 - g_ps2RecompiledFunctionTable[513566] = ADXSTM_OpenFname_0x2f5880; // 0x2f5880 - g_ps2RecompiledFunctionTable[513574] = ADXSTM_OpenFname_0x2f5880; // 0x2f58a0 - g_ps2RecompiledFunctionTable[513579] = ADXSTM_OpenFname_0x2f5880; // 0x2f58b4 - g_ps2RecompiledFunctionTable[513585] = ADXSTM_OpenFname_0x2f5880; // 0x2f58cc - g_ps2RecompiledFunctionTable[513591] = ADXSTM_OpenFname_0x2f5880; // 0x2f58e4 - g_ps2RecompiledFunctionTable[513596] = ADXSTM_OpenFname_0x2f5880; // 0x2f58f8 - g_ps2RecompiledFunctionTable[513604] = ADXSTM_OpenFileRange_0x2f5918; // 0x2f5918 - g_ps2RecompiledFunctionTable[513612] = ADXSTM_OpenFileRange_0x2f5918; // 0x2f5938 - g_ps2RecompiledFunctionTable[513616] = ADXSTM_Close_0x2f5948; // 0x2f5948 - g_ps2RecompiledFunctionTable[513623] = ADXSTM_Close_0x2f5948; // 0x2f5964 - g_ps2RecompiledFunctionTable[513628] = ADXSTM_Close_0x2f5948; // 0x2f5978 - g_ps2RecompiledFunctionTable[513638] = ADXSTM_GetStat_0x2f59a0; // 0x2f59a0 - g_ps2RecompiledFunctionTable[513640] = ADXSTM_Seek_0x2f59a8; // 0x2f59a8 - g_ps2RecompiledFunctionTable[513649] = ADXSTM_Seek_0x2f59a8; // 0x2f59cc - g_ps2RecompiledFunctionTable[513651] = ADXSTM_Seek_0x2f59a8; // 0x2f59d4 - g_ps2RecompiledFunctionTable[513658] = ADXSTM_Tell_0x2f59f0; // 0x2f59f0 - g_ps2RecompiledFunctionTable[513667] = ADXSTM_Tell_0x2f59f0; // 0x2f5a14 - g_ps2RecompiledFunctionTable[513674] = ADXSTM_Start_0x2f5a30; // 0x2f5a30 - g_ps2RecompiledFunctionTable[513690] = ADXSTM_Start_0x2f5a30; // 0x2f5a70 - g_ps2RecompiledFunctionTable[513698] = ADXSTM_Stop_0x2f5a90; // 0x2f5a90 - g_ps2RecompiledFunctionTable[513703] = ADXSTM_Stop_0x2f5a90; // 0x2f5aa4 - g_ps2RecompiledFunctionTable[513712] = ADXSTM_Stop_0x2f5a90; // 0x2f5ac8 - g_ps2RecompiledFunctionTable[513715] = ADXSTM_Stop_0x2f5a90; // 0x2f5ad4 - g_ps2RecompiledFunctionTable[513722] = ADXSTM_EntryEosFunc_0x2f5af0; // 0x2f5af0 - g_ps2RecompiledFunctionTable[513726] = ADXSTM_SetEos_0x2f5b00; // 0x2f5b00 - g_ps2RecompiledFunctionTable[513740] = adxstm_sj_internal_error_0x2f5b38; // 0x2f5b38 - g_ps2RecompiledFunctionTable[513744] = adxstmf_stat_exec_0x2f5b48; // 0x2f5b48 - g_ps2RecompiledFunctionTable[513745] = adxstmf_stat_exec_0x2f5b48; // 0x2f5b4c - g_ps2RecompiledFunctionTable[513746] = adxstmf_stat_exec_0x2f5b48; // 0x2f5b50 - g_ps2RecompiledFunctionTable[513747] = adxstmf_stat_exec_0x2f5b48; // 0x2f5b54 - g_ps2RecompiledFunctionTable[513748] = adxstmf_stat_exec_0x2f5b48; // 0x2f5b58 - g_ps2RecompiledFunctionTable[513749] = adxstmf_stat_exec_0x2f5b48; // 0x2f5b5c - g_ps2RecompiledFunctionTable[513750] = adxstmf_stat_exec_0x2f5b48; // 0x2f5b60 - g_ps2RecompiledFunctionTable[513751] = adxstmf_stat_exec_0x2f5b48; // 0x2f5b64 - g_ps2RecompiledFunctionTable[513752] = adxstmf_stat_exec_0x2f5b48; // 0x2f5b68 - g_ps2RecompiledFunctionTable[513753] = adxstmf_stat_exec_0x2f5b48; // 0x2f5b6c - g_ps2RecompiledFunctionTable[513754] = adxstmf_stat_exec_0x2f5b48; // 0x2f5b70 - g_ps2RecompiledFunctionTable[513755] = adxstmf_stat_exec_0x2f5b48; // 0x2f5b74 - g_ps2RecompiledFunctionTable[513756] = adxstmf_stat_exec_0x2f5b48; // 0x2f5b78 - g_ps2RecompiledFunctionTable[513757] = adxstmf_stat_exec_0x2f5b48; // 0x2f5b7c - g_ps2RecompiledFunctionTable[513758] = adxstmf_stat_exec_0x2f5b48; // 0x2f5b80 - g_ps2RecompiledFunctionTable[513759] = adxstmf_stat_exec_0x2f5b48; // 0x2f5b84 - g_ps2RecompiledFunctionTable[513760] = adxstmf_stat_exec_0x2f5b48; // 0x2f5b88 - g_ps2RecompiledFunctionTable[513761] = adxstmf_stat_exec_0x2f5b48; // 0x2f5b8c - g_ps2RecompiledFunctionTable[513762] = adxstmf_stat_exec_0x2f5b48; // 0x2f5b90 - g_ps2RecompiledFunctionTable[513763] = adxstmf_stat_exec_0x2f5b48; // 0x2f5b94 - g_ps2RecompiledFunctionTable[513764] = adxstmf_stat_exec_0x2f5b48; // 0x2f5b98 - g_ps2RecompiledFunctionTable[513765] = adxstmf_stat_exec_0x2f5b48; // 0x2f5b9c - g_ps2RecompiledFunctionTable[513766] = adxstmf_stat_exec_0x2f5b48; // 0x2f5ba0 - g_ps2RecompiledFunctionTable[513767] = adxstmf_stat_exec_0x2f5b48; // 0x2f5ba4 - g_ps2RecompiledFunctionTable[513768] = adxstmf_stat_exec_0x2f5b48; // 0x2f5ba8 - g_ps2RecompiledFunctionTable[513769] = adxstmf_stat_exec_0x2f5b48; // 0x2f5bac - g_ps2RecompiledFunctionTable[513770] = adxstmf_stat_exec_0x2f5b48; // 0x2f5bb0 - g_ps2RecompiledFunctionTable[513771] = adxstmf_stat_exec_0x2f5b48; // 0x2f5bb4 - g_ps2RecompiledFunctionTable[513772] = adxstmf_stat_exec_0x2f5b48; // 0x2f5bb8 - g_ps2RecompiledFunctionTable[513773] = adxstmf_stat_exec_0x2f5b48; // 0x2f5bbc - g_ps2RecompiledFunctionTable[513774] = adxstmf_stat_exec_0x2f5b48; // 0x2f5bc0 - g_ps2RecompiledFunctionTable[513775] = adxstmf_stat_exec_0x2f5b48; // 0x2f5bc4 - g_ps2RecompiledFunctionTable[513776] = adxstmf_stat_exec_0x2f5b48; // 0x2f5bc8 - g_ps2RecompiledFunctionTable[513777] = adxstmf_stat_exec_0x2f5b48; // 0x2f5bcc - g_ps2RecompiledFunctionTable[513778] = adxstmf_stat_exec_0x2f5b48; // 0x2f5bd0 - g_ps2RecompiledFunctionTable[513779] = adxstmf_stat_exec_0x2f5b48; // 0x2f5bd4 - g_ps2RecompiledFunctionTable[513780] = adxstmf_stat_exec_0x2f5b48; // 0x2f5bd8 - g_ps2RecompiledFunctionTable[513781] = adxstmf_stat_exec_0x2f5b48; // 0x2f5bdc - g_ps2RecompiledFunctionTable[513782] = adxstmf_stat_exec_0x2f5b48; // 0x2f5be0 - g_ps2RecompiledFunctionTable[513783] = adxstmf_stat_exec_0x2f5b48; // 0x2f5be4 - g_ps2RecompiledFunctionTable[513784] = adxstmf_stat_exec_0x2f5b48; // 0x2f5be8 - g_ps2RecompiledFunctionTable[513785] = adxstmf_stat_exec_0x2f5b48; // 0x2f5bec - g_ps2RecompiledFunctionTable[513786] = adxstmf_stat_exec_0x2f5b48; // 0x2f5bf0 - g_ps2RecompiledFunctionTable[513787] = adxstmf_stat_exec_0x2f5b48; // 0x2f5bf4 - g_ps2RecompiledFunctionTable[513788] = adxstmf_stat_exec_0x2f5b48; // 0x2f5bf8 - g_ps2RecompiledFunctionTable[513789] = adxstmf_stat_exec_0x2f5b48; // 0x2f5bfc - g_ps2RecompiledFunctionTable[513790] = adxstmf_stat_exec_0x2f5b48; // 0x2f5c00 - g_ps2RecompiledFunctionTable[513791] = adxstmf_stat_exec_0x2f5b48; // 0x2f5c04 - g_ps2RecompiledFunctionTable[513792] = adxstmf_stat_exec_0x2f5b48; // 0x2f5c08 - g_ps2RecompiledFunctionTable[513793] = adxstmf_stat_exec_0x2f5b48; // 0x2f5c0c - g_ps2RecompiledFunctionTable[513794] = adxstmf_stat_exec_0x2f5b48; // 0x2f5c10 - g_ps2RecompiledFunctionTable[513795] = adxstmf_stat_exec_0x2f5b48; // 0x2f5c14 - g_ps2RecompiledFunctionTable[513796] = adxstmf_stat_exec_0x2f5b48; // 0x2f5c18 - g_ps2RecompiledFunctionTable[513797] = adxstmf_stat_exec_0x2f5b48; // 0x2f5c1c - g_ps2RecompiledFunctionTable[513798] = adxstmf_stat_exec_0x2f5b48; // 0x2f5c20 - g_ps2RecompiledFunctionTable[513799] = adxstmf_stat_exec_0x2f5b48; // 0x2f5c24 - g_ps2RecompiledFunctionTable[513800] = adxstmf_stat_exec_0x2f5b48; // 0x2f5c28 - g_ps2RecompiledFunctionTable[513801] = adxstmf_stat_exec_0x2f5b48; // 0x2f5c2c - g_ps2RecompiledFunctionTable[513802] = adxstmf_stat_exec_0x2f5b48; // 0x2f5c30 - g_ps2RecompiledFunctionTable[513803] = adxstmf_stat_exec_0x2f5b48; // 0x2f5c34 - g_ps2RecompiledFunctionTable[513804] = adxstmf_stat_exec_0x2f5b48; // 0x2f5c38 - g_ps2RecompiledFunctionTable[513805] = adxstmf_stat_exec_0x2f5b48; // 0x2f5c3c - g_ps2RecompiledFunctionTable[513806] = adxstmf_stat_exec_0x2f5b48; // 0x2f5c40 - g_ps2RecompiledFunctionTable[513807] = adxstmf_stat_exec_0x2f5b48; // 0x2f5c44 - g_ps2RecompiledFunctionTable[513808] = adxstmf_stat_exec_0x2f5b48; // 0x2f5c48 - g_ps2RecompiledFunctionTable[513809] = adxstmf_stat_exec_0x2f5b48; // 0x2f5c4c - g_ps2RecompiledFunctionTable[513810] = adxstmf_stat_exec_0x2f5b48; // 0x2f5c50 - g_ps2RecompiledFunctionTable[513811] = adxstmf_stat_exec_0x2f5b48; // 0x2f5c54 - g_ps2RecompiledFunctionTable[513812] = adxstmf_stat_exec_0x2f5b48; // 0x2f5c58 - g_ps2RecompiledFunctionTable[513813] = adxstmf_stat_exec_0x2f5b48; // 0x2f5c5c - g_ps2RecompiledFunctionTable[513814] = adxstmf_stat_exec_0x2f5b48; // 0x2f5c60 - g_ps2RecompiledFunctionTable[513815] = adxstmf_stat_exec_0x2f5b48; // 0x2f5c64 - g_ps2RecompiledFunctionTable[513816] = adxstmf_stat_exec_0x2f5b48; // 0x2f5c68 - g_ps2RecompiledFunctionTable[513817] = adxstmf_stat_exec_0x2f5b48; // 0x2f5c6c - g_ps2RecompiledFunctionTable[513818] = adxstmf_stat_exec_0x2f5b48; // 0x2f5c70 - g_ps2RecompiledFunctionTable[513819] = adxstmf_stat_exec_0x2f5b48; // 0x2f5c74 - g_ps2RecompiledFunctionTable[513820] = adxstmf_stat_exec_0x2f5b48; // 0x2f5c78 - g_ps2RecompiledFunctionTable[513821] = adxstmf_stat_exec_0x2f5b48; // 0x2f5c7c - g_ps2RecompiledFunctionTable[513822] = adxstmf_stat_exec_0x2f5b48; // 0x2f5c80 - g_ps2RecompiledFunctionTable[513823] = adxstmf_stat_exec_0x2f5b48; // 0x2f5c84 - g_ps2RecompiledFunctionTable[513824] = adxstmf_stat_exec_0x2f5b48; // 0x2f5c88 - g_ps2RecompiledFunctionTable[513825] = adxstmf_stat_exec_0x2f5b48; // 0x2f5c8c - g_ps2RecompiledFunctionTable[513826] = adxstmf_stat_exec_0x2f5b48; // 0x2f5c90 - g_ps2RecompiledFunctionTable[513827] = adxstmf_stat_exec_0x2f5b48; // 0x2f5c94 - g_ps2RecompiledFunctionTable[513828] = adxstmf_stat_exec_0x2f5b48; // 0x2f5c98 - g_ps2RecompiledFunctionTable[513829] = adxstmf_stat_exec_0x2f5b48; // 0x2f5c9c - g_ps2RecompiledFunctionTable[513830] = adxstmf_stat_exec_0x2f5b48; // 0x2f5ca0 - g_ps2RecompiledFunctionTable[513831] = adxstmf_stat_exec_0x2f5b48; // 0x2f5ca4 - g_ps2RecompiledFunctionTable[513832] = adxstmf_stat_exec_0x2f5b48; // 0x2f5ca8 - g_ps2RecompiledFunctionTable[513833] = adxstmf_stat_exec_0x2f5b48; // 0x2f5cac - g_ps2RecompiledFunctionTable[513834] = adxstmf_stat_exec_0x2f5b48; // 0x2f5cb0 - g_ps2RecompiledFunctionTable[513835] = adxstmf_stat_exec_0x2f5b48; // 0x2f5cb4 - g_ps2RecompiledFunctionTable[513836] = adxstmf_stat_exec_0x2f5b48; // 0x2f5cb8 - g_ps2RecompiledFunctionTable[513837] = adxstmf_stat_exec_0x2f5b48; // 0x2f5cbc - g_ps2RecompiledFunctionTable[513838] = adxstmf_stat_exec_0x2f5b48; // 0x2f5cc0 - g_ps2RecompiledFunctionTable[513839] = adxstmf_stat_exec_0x2f5b48; // 0x2f5cc4 - g_ps2RecompiledFunctionTable[513840] = adxstmf_stat_exec_0x2f5b48; // 0x2f5cc8 - g_ps2RecompiledFunctionTable[513841] = adxstmf_stat_exec_0x2f5b48; // 0x2f5ccc - g_ps2RecompiledFunctionTable[513842] = adxstmf_stat_exec_0x2f5b48; // 0x2f5cd0 - g_ps2RecompiledFunctionTable[513843] = adxstmf_stat_exec_0x2f5b48; // 0x2f5cd4 - g_ps2RecompiledFunctionTable[513844] = adxstmf_stat_exec_0x2f5b48; // 0x2f5cd8 - g_ps2RecompiledFunctionTable[513845] = adxstmf_stat_exec_0x2f5b48; // 0x2f5cdc - g_ps2RecompiledFunctionTable[513846] = adxstmf_stat_exec_0x2f5b48; // 0x2f5ce0 - g_ps2RecompiledFunctionTable[513847] = adxstmf_stat_exec_0x2f5b48; // 0x2f5ce4 - g_ps2RecompiledFunctionTable[513848] = adxstmf_stat_exec_0x2f5b48; // 0x2f5ce8 - g_ps2RecompiledFunctionTable[513849] = adxstmf_stat_exec_0x2f5b48; // 0x2f5cec - g_ps2RecompiledFunctionTable[513850] = adxstmf_stat_exec_0x2f5b48; // 0x2f5cf0 - g_ps2RecompiledFunctionTable[513851] = adxstmf_stat_exec_0x2f5b48; // 0x2f5cf4 - g_ps2RecompiledFunctionTable[513852] = adxstmf_stat_exec_0x2f5b48; // 0x2f5cf8 - g_ps2RecompiledFunctionTable[513853] = adxstmf_stat_exec_0x2f5b48; // 0x2f5cfc - g_ps2RecompiledFunctionTable[513854] = adxstmf_stat_exec_0x2f5b48; // 0x2f5d00 - g_ps2RecompiledFunctionTable[513855] = adxstmf_stat_exec_0x2f5b48; // 0x2f5d04 - g_ps2RecompiledFunctionTable[513856] = adxstmf_stat_exec_0x2f5b48; // 0x2f5d08 - g_ps2RecompiledFunctionTable[513857] = adxstmf_stat_exec_0x2f5b48; // 0x2f5d0c - g_ps2RecompiledFunctionTable[513858] = adxstmf_stat_exec_0x2f5b48; // 0x2f5d10 - g_ps2RecompiledFunctionTable[513859] = adxstmf_stat_exec_0x2f5b48; // 0x2f5d14 - g_ps2RecompiledFunctionTable[513860] = adxstmf_stat_exec_0x2f5b48; // 0x2f5d18 - g_ps2RecompiledFunctionTable[513861] = adxstmf_stat_exec_0x2f5b48; // 0x2f5d1c - g_ps2RecompiledFunctionTable[513862] = adxstmf_stat_exec_0x2f5b48; // 0x2f5d20 - g_ps2RecompiledFunctionTable[513863] = adxstmf_stat_exec_0x2f5b48; // 0x2f5d24 - g_ps2RecompiledFunctionTable[513864] = adxstmf_stat_exec_0x2f5b48; // 0x2f5d28 - g_ps2RecompiledFunctionTable[513865] = adxstmf_stat_exec_0x2f5b48; // 0x2f5d2c - g_ps2RecompiledFunctionTable[513866] = adxstmf_stat_exec_0x2f5b48; // 0x2f5d30 - g_ps2RecompiledFunctionTable[513867] = adxstmf_stat_exec_0x2f5b48; // 0x2f5d34 - g_ps2RecompiledFunctionTable[513868] = adxstmf_stat_exec_0x2f5b48; // 0x2f5d38 - g_ps2RecompiledFunctionTable[513869] = adxstmf_stat_exec_0x2f5b48; // 0x2f5d3c - g_ps2RecompiledFunctionTable[513870] = adxstmf_stat_exec_0x2f5b48; // 0x2f5d40 - g_ps2RecompiledFunctionTable[513871] = adxstmf_stat_exec_0x2f5b48; // 0x2f5d44 - g_ps2RecompiledFunctionTable[513872] = adxstmf_stat_exec_0x2f5b48; // 0x2f5d48 - g_ps2RecompiledFunctionTable[513873] = adxstmf_stat_exec_0x2f5b48; // 0x2f5d4c - g_ps2RecompiledFunctionTable[513874] = adxstmf_stat_exec_0x2f5b48; // 0x2f5d50 - g_ps2RecompiledFunctionTable[513875] = adxstmf_stat_exec_0x2f5b48; // 0x2f5d54 - g_ps2RecompiledFunctionTable[513876] = adxstmf_stat_exec_0x2f5b48; // 0x2f5d58 - g_ps2RecompiledFunctionTable[513877] = adxstmf_stat_exec_0x2f5b48; // 0x2f5d5c - g_ps2RecompiledFunctionTable[513878] = adxstmf_stat_exec_0x2f5b48; // 0x2f5d60 - g_ps2RecompiledFunctionTable[513879] = adxstmf_stat_exec_0x2f5b48; // 0x2f5d64 - g_ps2RecompiledFunctionTable[513880] = adxstmf_stat_exec_0x2f5b48; // 0x2f5d68 - g_ps2RecompiledFunctionTable[513881] = adxstmf_stat_exec_0x2f5b48; // 0x2f5d6c - g_ps2RecompiledFunctionTable[513882] = adxstmf_stat_exec_0x2f5b48; // 0x2f5d70 - g_ps2RecompiledFunctionTable[513883] = adxstmf_stat_exec_0x2f5b48; // 0x2f5d74 - g_ps2RecompiledFunctionTable[513884] = adxstmf_stat_exec_0x2f5b48; // 0x2f5d78 - g_ps2RecompiledFunctionTable[513885] = adxstmf_stat_exec_0x2f5b48; // 0x2f5d7c - g_ps2RecompiledFunctionTable[513886] = adxstmf_stat_exec_0x2f5b48; // 0x2f5d80 - g_ps2RecompiledFunctionTable[513887] = adxstmf_stat_exec_0x2f5b48; // 0x2f5d84 - g_ps2RecompiledFunctionTable[513888] = adxstmf_stat_exec_0x2f5b48; // 0x2f5d88 - g_ps2RecompiledFunctionTable[513889] = adxstmf_stat_exec_0x2f5b48; // 0x2f5d8c - g_ps2RecompiledFunctionTable[513890] = adxstmf_stat_exec_0x2f5b48; // 0x2f5d90 - g_ps2RecompiledFunctionTable[513891] = adxstmf_stat_exec_0x2f5b48; // 0x2f5d94 - g_ps2RecompiledFunctionTable[513892] = adxstmf_stat_exec_0x2f5b48; // 0x2f5d98 - g_ps2RecompiledFunctionTable[513893] = adxstmf_stat_exec_0x2f5b48; // 0x2f5d9c - g_ps2RecompiledFunctionTable[513894] = adxstmf_stat_exec_0x2f5b48; // 0x2f5da0 - g_ps2RecompiledFunctionTable[513895] = adxstmf_stat_exec_0x2f5b48; // 0x2f5da4 - g_ps2RecompiledFunctionTable[513896] = adxstmf_stat_exec_0x2f5b48; // 0x2f5da8 - g_ps2RecompiledFunctionTable[513897] = adxstmf_stat_exec_0x2f5b48; // 0x2f5dac - g_ps2RecompiledFunctionTable[513898] = adxstmf_stat_exec_0x2f5b48; // 0x2f5db0 - g_ps2RecompiledFunctionTable[513899] = adxstmf_stat_exec_0x2f5b48; // 0x2f5db4 - g_ps2RecompiledFunctionTable[513900] = adxstmf_stat_exec_0x2f5b48; // 0x2f5db8 - g_ps2RecompiledFunctionTable[513901] = adxstmf_stat_exec_0x2f5b48; // 0x2f5dbc - g_ps2RecompiledFunctionTable[513902] = adxstmf_stat_exec_0x2f5b48; // 0x2f5dc0 - g_ps2RecompiledFunctionTable[513903] = adxstmf_stat_exec_0x2f5b48; // 0x2f5dc4 - g_ps2RecompiledFunctionTable[513904] = adxstmf_stat_exec_0x2f5b48; // 0x2f5dc8 - g_ps2RecompiledFunctionTable[513905] = adxstmf_stat_exec_0x2f5b48; // 0x2f5dcc - g_ps2RecompiledFunctionTable[513906] = adxstmf_stat_exec_0x2f5b48; // 0x2f5dd0 - g_ps2RecompiledFunctionTable[513907] = adxstmf_stat_exec_0x2f5b48; // 0x2f5dd4 - g_ps2RecompiledFunctionTable[513908] = adxstmf_stat_exec_0x2f5b48; // 0x2f5dd8 - g_ps2RecompiledFunctionTable[513909] = adxstmf_stat_exec_0x2f5b48; // 0x2f5ddc - g_ps2RecompiledFunctionTable[513910] = adxstmf_stat_exec_0x2f5b48; // 0x2f5de0 - g_ps2RecompiledFunctionTable[513911] = adxstmf_stat_exec_0x2f5b48; // 0x2f5de4 - g_ps2RecompiledFunctionTable[513912] = adxstmf_stat_exec_0x2f5b48; // 0x2f5de8 - g_ps2RecompiledFunctionTable[513913] = adxstmf_stat_exec_0x2f5b48; // 0x2f5dec - g_ps2RecompiledFunctionTable[513914] = adxstmf_stat_exec_0x2f5b48; // 0x2f5df0 - g_ps2RecompiledFunctionTable[513915] = adxstmf_stat_exec_0x2f5b48; // 0x2f5df4 - g_ps2RecompiledFunctionTable[513916] = adxstmf_stat_exec_0x2f5b48; // 0x2f5df8 - g_ps2RecompiledFunctionTable[513917] = adxstmf_stat_exec_0x2f5b48; // 0x2f5dfc - g_ps2RecompiledFunctionTable[513918] = adxstmf_stat_exec_0x2f5b48; // 0x2f5e00 - g_ps2RecompiledFunctionTable[513919] = adxstmf_stat_exec_0x2f5b48; // 0x2f5e04 - g_ps2RecompiledFunctionTable[513920] = adxstmf_stat_exec_0x2f5b48; // 0x2f5e08 - g_ps2RecompiledFunctionTable[513921] = adxstmf_stat_exec_0x2f5b48; // 0x2f5e0c - g_ps2RecompiledFunctionTable[513922] = adxstmf_stat_exec_0x2f5b48; // 0x2f5e10 - g_ps2RecompiledFunctionTable[513923] = adxstmf_stat_exec_0x2f5b48; // 0x2f5e14 - g_ps2RecompiledFunctionTable[513924] = adxstmf_stat_exec_0x2f5b48; // 0x2f5e18 - g_ps2RecompiledFunctionTable[513926] = ADXSTMF_ExecHndl_0x2f5e20; // 0x2f5e20 - g_ps2RecompiledFunctionTable[513934] = ADXSTM_ExecServer_0x2f5e40; // 0x2f5e40 - g_ps2RecompiledFunctionTable[513944] = ADXSTM_ExecServer_0x2f5e40; // 0x2f5e68 - g_ps2RecompiledFunctionTable[513950] = ADXSTM_ExecServer_0x2f5e40; // 0x2f5e80 - g_ps2RecompiledFunctionTable[513958] = ADXSTM_GetCurOfst_0x2f5ea0; // 0x2f5ea0 - g_ps2RecompiledFunctionTable[513965] = ADXSTM_GetCurOfst_0x2f5ea0; // 0x2f5ebc - g_ps2RecompiledFunctionTable[513974] = ADXSTM_GetBufSize_0x2f5ee0; // 0x2f5ee0 - g_ps2RecompiledFunctionTable[513980] = ADXSTM_GetSj_0x2f5ef8; // 0x2f5ef8 - g_ps2RecompiledFunctionTable[513982] = ADXSTM_SetBufSize_0x2f5f00; // 0x2f5f00 - g_ps2RecompiledFunctionTable[513986] = ADXSTM_SetReqRdSize_0x2f5f10; // 0x2f5f10 - g_ps2RecompiledFunctionTable[513990] = ADXSTM_EntryErrFunc_0x2f5f20; // 0x2f5f20 - g_ps2RecompiledFunctionTable[513992] = ADXSTM_GetFileLen_0x2f5f28; // 0x2f5f28 - g_ps2RecompiledFunctionTable[513994] = ADXSTM_GetCvdfsStat_0x2f5f30; // 0x2f5f30 - g_ps2RecompiledFunctionTable[514000] = ADXSTM_GetCvdfsStat_0x2f5f30; // 0x2f5f48 - g_ps2RecompiledFunctionTable[514006] = ADXSTM_GetFad_0x2f5f60; // 0x2f5f60 - g_ps2RecompiledFunctionTable[514010] = ADXSTM_GetFsizeSct_0x2f5f70; // 0x2f5f70 - g_ps2RecompiledFunctionTable[514015] = ADXSTM_GetFsizeSct_0x2f5f70; // 0x2f5f84 - g_ps2RecompiledFunctionTable[514028] = ADXSTM_GetFsizeByte_0x2f5fb8; // 0x2f5fb8 - g_ps2RecompiledFunctionTable[514033] = ADXSTM_GetFsizeByte_0x2f5fb8; // 0x2f5fcc - g_ps2RecompiledFunctionTable[514040] = ADXSTM_SetSj_0x2f5fe8; // 0x2f5fe8 - g_ps2RecompiledFunctionTable[514041] = ADXSTM_SetSj_0x2f5fe8; // 0x2f5fec - g_ps2RecompiledFunctionTable[514042] = ADXSTM_SetSj_0x2f5fe8; // 0x2f5ff0 - g_ps2RecompiledFunctionTable[514043] = ADXSTM_SetSj_0x2f5fe8; // 0x2f5ff4 - g_ps2RecompiledFunctionTable[514044] = ADXSTM_SetSj_0x2f5fe8; // 0x2f5ff8 - g_ps2RecompiledFunctionTable[514045] = ADXSTM_SetSj_0x2f5fe8; // 0x2f5ffc - g_ps2RecompiledFunctionTable[514046] = ADXSTM_SetSj_0x2f5fe8; // 0x2f6000 - g_ps2RecompiledFunctionTable[514047] = ADXSTM_SetSj_0x2f5fe8; // 0x2f6004 - g_ps2RecompiledFunctionTable[514048] = ADXSTM_SetSj_0x2f5fe8; // 0x2f6008 - g_ps2RecompiledFunctionTable[514049] = ADXSTM_SetSj_0x2f5fe8; // 0x2f600c - g_ps2RecompiledFunctionTable[514050] = ADXSTM_SetSj_0x2f5fe8; // 0x2f6010 - g_ps2RecompiledFunctionTable[514051] = ADXSTM_SetSj_0x2f5fe8; // 0x2f6014 - g_ps2RecompiledFunctionTable[514052] = ADXSTM_SetSj_0x2f5fe8; // 0x2f6018 - g_ps2RecompiledFunctionTable[514053] = ADXSTM_SetSj_0x2f5fe8; // 0x2f601c - g_ps2RecompiledFunctionTable[514054] = ADXSTM_SetSj_0x2f5fe8; // 0x2f6020 - g_ps2RecompiledFunctionTable[514055] = ADXSTM_SetSj_0x2f5fe8; // 0x2f6024 - g_ps2RecompiledFunctionTable[514056] = ADXSTM_SetRdSct_0x2f6028; // 0x2f6028 - g_ps2RecompiledFunctionTable[514060] = ADXSTM_SetOfst_0x2f6038; // 0x2f6038 - g_ps2RecompiledFunctionTable[514064] = ADXT_SetNumRetry_0x2f6048; // 0x2f6048 - g_ps2RecompiledFunctionTable[514066] = adxt_err_dvd_0x2f6050; // 0x2f6050 - g_ps2RecompiledFunctionTable[514068] = ADXT_SetupDvdFs_0x2f6058; // 0x2f6058 - g_ps2RecompiledFunctionTable[514077] = ADXT_SetupDvdFs_0x2f6058; // 0x2f607c - g_ps2RecompiledFunctionTable[514084] = ADXT_SetupDvdFs_0x2f6058; // 0x2f6098 - g_ps2RecompiledFunctionTable[514086] = ADXT_SetupDvdFs_0x2f6058; // 0x2f60a0 - g_ps2RecompiledFunctionTable[514092] = ADXT_SetupDvdFs_0x2f6058; // 0x2f60b8 - g_ps2RecompiledFunctionTable[514104] = ADXT_LoadFpCacheDvd_0x2f60e8; // 0x2f60e8 - g_ps2RecompiledFunctionTable[514113] = ADXT_LoadFpCacheDvd_0x2f60e8; // 0x2f610c - g_ps2RecompiledFunctionTable[514116] = ADXT_SetRdMode_0x2f6118; // 0x2f6118 - g_ps2RecompiledFunctionTable[514122] = adxt_err_host_0x2f6130; // 0x2f6130 - g_ps2RecompiledFunctionTable[514124] = ADXT_SetupHostFs_0x2f6138; // 0x2f6138 - g_ps2RecompiledFunctionTable[514133] = ADXT_SetupHostFs_0x2f6138; // 0x2f615c - g_ps2RecompiledFunctionTable[514140] = ADXT_SetupHostFs_0x2f6138; // 0x2f6178 - g_ps2RecompiledFunctionTable[514142] = ADXT_SetupHostFs_0x2f6138; // 0x2f6180 - g_ps2RecompiledFunctionTable[514146] = ADXT_SetupHostFs_0x2f6138; // 0x2f6190 - g_ps2RecompiledFunctionTable[514158] = ADXT_LoadFpCacheHost_0x2f61c0; // 0x2f61c0 - g_ps2RecompiledFunctionTable[514167] = ADXT_LoadFpCacheHost_0x2f61c0; // 0x2f61e4 - g_ps2RecompiledFunctionTable[514170] = ADXT_SetOpMode_0x2f61f0; // 0x2f61f0 - g_ps2RecompiledFunctionTable[514172] = adxt_disp_rna_stat_0x2f61f8; // 0x2f61f8 - g_ps2RecompiledFunctionTable[514173] = adxt_disp_rna_stat_0x2f61f8; // 0x2f61fc - g_ps2RecompiledFunctionTable[514174] = adxt_disp_rna_stat_0x2f61f8; // 0x2f6200 - g_ps2RecompiledFunctionTable[514175] = adxt_disp_rna_stat_0x2f61f8; // 0x2f6204 - g_ps2RecompiledFunctionTable[514176] = adxt_disp_rna_stat_0x2f61f8; // 0x2f6208 - g_ps2RecompiledFunctionTable[514177] = adxt_disp_rna_stat_0x2f61f8; // 0x2f620c - g_ps2RecompiledFunctionTable[514178] = adxt_disp_rna_stat_0x2f61f8; // 0x2f6210 - g_ps2RecompiledFunctionTable[514179] = adxt_disp_rna_stat_0x2f61f8; // 0x2f6214 - g_ps2RecompiledFunctionTable[514180] = adxt_disp_rna_stat_0x2f61f8; // 0x2f6218 - g_ps2RecompiledFunctionTable[514181] = adxt_disp_rna_stat_0x2f61f8; // 0x2f621c - g_ps2RecompiledFunctionTable[514182] = adxt_disp_rna_stat_0x2f61f8; // 0x2f6220 - g_ps2RecompiledFunctionTable[514183] = adxt_disp_rna_stat_0x2f61f8; // 0x2f6224 - g_ps2RecompiledFunctionTable[514184] = adxt_disp_rna_stat_0x2f61f8; // 0x2f6228 - g_ps2RecompiledFunctionTable[514185] = adxt_disp_rna_stat_0x2f61f8; // 0x2f622c - g_ps2RecompiledFunctionTable[514186] = adxt_disp_rna_stat_0x2f61f8; // 0x2f6230 - g_ps2RecompiledFunctionTable[514187] = adxt_disp_rna_stat_0x2f61f8; // 0x2f6234 - g_ps2RecompiledFunctionTable[514188] = adxt_disp_rna_stat_0x2f61f8; // 0x2f6238 - g_ps2RecompiledFunctionTable[514189] = adxt_disp_rna_stat_0x2f61f8; // 0x2f623c - g_ps2RecompiledFunctionTable[514190] = adxt_disp_rna_stat_0x2f61f8; // 0x2f6240 - g_ps2RecompiledFunctionTable[514191] = adxt_disp_rna_stat_0x2f61f8; // 0x2f6244 - g_ps2RecompiledFunctionTable[514192] = adxt_disp_rna_stat_0x2f61f8; // 0x2f6248 - g_ps2RecompiledFunctionTable[514193] = adxt_disp_rna_stat_0x2f61f8; // 0x2f624c - g_ps2RecompiledFunctionTable[514194] = adxt_disp_rna_stat_0x2f61f8; // 0x2f6250 - g_ps2RecompiledFunctionTable[514195] = adxt_disp_rna_stat_0x2f61f8; // 0x2f6254 - g_ps2RecompiledFunctionTable[514196] = adxt_disp_rna_stat_0x2f61f8; // 0x2f6258 - g_ps2RecompiledFunctionTable[514197] = adxt_disp_rna_stat_0x2f61f8; // 0x2f625c - g_ps2RecompiledFunctionTable[514198] = adxt_disp_rna_stat_0x2f61f8; // 0x2f6260 - g_ps2RecompiledFunctionTable[514199] = adxt_disp_rna_stat_0x2f61f8; // 0x2f6264 - g_ps2RecompiledFunctionTable[514200] = adxt_disp_rna_stat_0x2f61f8; // 0x2f6268 - g_ps2RecompiledFunctionTable[514201] = adxt_disp_rna_stat_0x2f61f8; // 0x2f626c - g_ps2RecompiledFunctionTable[514202] = adxt_disp_rna_stat_0x2f61f8; // 0x2f6270 - g_ps2RecompiledFunctionTable[514203] = adxt_disp_rna_stat_0x2f61f8; // 0x2f6274 - g_ps2RecompiledFunctionTable[514204] = adxt_disp_rna_stat_0x2f61f8; // 0x2f6278 - g_ps2RecompiledFunctionTable[514205] = adxt_disp_rna_stat_0x2f61f8; // 0x2f627c - g_ps2RecompiledFunctionTable[514206] = adxt_disp_rna_stat_0x2f61f8; // 0x2f6280 - g_ps2RecompiledFunctionTable[514207] = adxt_disp_rna_stat_0x2f61f8; // 0x2f6284 - g_ps2RecompiledFunctionTable[514208] = adxt_disp_rna_stat_0x2f61f8; // 0x2f6288 - g_ps2RecompiledFunctionTable[514209] = adxt_disp_rna_stat_0x2f61f8; // 0x2f628c - g_ps2RecompiledFunctionTable[514210] = adxt_disp_rna_stat_0x2f61f8; // 0x2f6290 - g_ps2RecompiledFunctionTable[514211] = adxt_disp_rna_stat_0x2f61f8; // 0x2f6294 - g_ps2RecompiledFunctionTable[514212] = adxt_disp_rna_stat_0x2f61f8; // 0x2f6298 - g_ps2RecompiledFunctionTable[514213] = adxt_disp_rna_stat_0x2f61f8; // 0x2f629c - g_ps2RecompiledFunctionTable[514214] = adxt_disp_rna_stat_0x2f61f8; // 0x2f62a0 - g_ps2RecompiledFunctionTable[514215] = adxt_disp_rna_stat_0x2f61f8; // 0x2f62a4 - g_ps2RecompiledFunctionTable[514216] = adxt_disp_rna_stat_0x2f61f8; // 0x2f62a8 - g_ps2RecompiledFunctionTable[514217] = adxt_disp_rna_stat_0x2f61f8; // 0x2f62ac - g_ps2RecompiledFunctionTable[514218] = adxt_disp_rna_stat_0x2f61f8; // 0x2f62b0 - g_ps2RecompiledFunctionTable[514219] = adxt_disp_rna_stat_0x2f61f8; // 0x2f62b4 - g_ps2RecompiledFunctionTable[514220] = adxt_disp_rna_stat_0x2f61f8; // 0x2f62b8 - g_ps2RecompiledFunctionTable[514221] = adxt_disp_rna_stat_0x2f61f8; // 0x2f62bc - g_ps2RecompiledFunctionTable[514222] = adxt_disp_rna_stat_0x2f61f8; // 0x2f62c0 - g_ps2RecompiledFunctionTable[514223] = adxt_disp_rna_stat_0x2f61f8; // 0x2f62c4 - g_ps2RecompiledFunctionTable[514224] = adxt_disp_rna_stat_0x2f61f8; // 0x2f62c8 - g_ps2RecompiledFunctionTable[514225] = adxt_disp_rna_stat_0x2f61f8; // 0x2f62cc - g_ps2RecompiledFunctionTable[514226] = adxt_disp_rna_stat_0x2f61f8; // 0x2f62d0 - g_ps2RecompiledFunctionTable[514227] = adxt_disp_rna_stat_0x2f61f8; // 0x2f62d4 - g_ps2RecompiledFunctionTable[514228] = adxt_disp_rna_stat_0x2f61f8; // 0x2f62d8 - g_ps2RecompiledFunctionTable[514229] = adxt_disp_rna_stat_0x2f61f8; // 0x2f62dc - g_ps2RecompiledFunctionTable[514230] = adxt_disp_rna_stat_0x2f61f8; // 0x2f62e0 - g_ps2RecompiledFunctionTable[514231] = adxt_disp_rna_stat_0x2f61f8; // 0x2f62e4 - g_ps2RecompiledFunctionTable[514232] = adxt_disp_rna_stat_0x2f61f8; // 0x2f62e8 - g_ps2RecompiledFunctionTable[514233] = adxt_disp_rna_stat_0x2f61f8; // 0x2f62ec - g_ps2RecompiledFunctionTable[514234] = adxt_disp_rna_stat_0x2f61f8; // 0x2f62f0 - g_ps2RecompiledFunctionTable[514235] = adxt_disp_rna_stat_0x2f61f8; // 0x2f62f4 - g_ps2RecompiledFunctionTable[514236] = adxt_disp_rna_stat_0x2f61f8; // 0x2f62f8 - g_ps2RecompiledFunctionTable[514238] = ADXT_Create_0x2f6300; // 0x2f6300 - g_ps2RecompiledFunctionTable[514258] = ADXT_Create_0x2f6300; // 0x2f6350 - g_ps2RecompiledFunctionTable[514276] = ADXT_Create_0x2f6300; // 0x2f6398 - g_ps2RecompiledFunctionTable[514298] = ADXT_Create_0x2f6300; // 0x2f63f0 - g_ps2RecompiledFunctionTable[514304] = ADXT_Create_0x2f6300; // 0x2f6408 - g_ps2RecompiledFunctionTable[514313] = ADXT_Create_0x2f6300; // 0x2f642c - g_ps2RecompiledFunctionTable[514328] = ADXT_Create_0x2f6300; // 0x2f6468 - g_ps2RecompiledFunctionTable[514333] = ADXT_Create_0x2f6300; // 0x2f647c - g_ps2RecompiledFunctionTable[514337] = ADXT_Create_0x2f6300; // 0x2f648c - g_ps2RecompiledFunctionTable[514341] = ADXT_Create_0x2f6300; // 0x2f649c - g_ps2RecompiledFunctionTable[514345] = ADXT_Create_0x2f6300; // 0x2f64ac - g_ps2RecompiledFunctionTable[514360] = ADXT_Create_0x2f6300; // 0x2f64e8 - g_ps2RecompiledFunctionTable[514364] = ADXT_Create_0x2f6300; // 0x2f64f8 - g_ps2RecompiledFunctionTable[514366] = ADXT_Create_0x2f6300; // 0x2f6500 - g_ps2RecompiledFunctionTable[514370] = ADXT_Create_0x2f6300; // 0x2f6510 - g_ps2RecompiledFunctionTable[514400] = ADXT_Destroy_0x2f6588; // 0x2f6588 - g_ps2RecompiledFunctionTable[514401] = ADXT_Destroy_0x2f6588; // 0x2f658c - g_ps2RecompiledFunctionTable[514402] = ADXT_Destroy_0x2f6588; // 0x2f6590 - g_ps2RecompiledFunctionTable[514403] = ADXT_Destroy_0x2f6588; // 0x2f6594 - g_ps2RecompiledFunctionTable[514404] = ADXT_Destroy_0x2f6588; // 0x2f6598 - g_ps2RecompiledFunctionTable[514405] = ADXT_Destroy_0x2f6588; // 0x2f659c - g_ps2RecompiledFunctionTable[514406] = ADXT_Destroy_0x2f6588; // 0x2f65a0 - g_ps2RecompiledFunctionTable[514407] = ADXT_Destroy_0x2f6588; // 0x2f65a4 - g_ps2RecompiledFunctionTable[514408] = ADXT_Destroy_0x2f6588; // 0x2f65a8 - g_ps2RecompiledFunctionTable[514409] = ADXT_Destroy_0x2f6588; // 0x2f65ac - g_ps2RecompiledFunctionTable[514410] = ADXT_Destroy_0x2f6588; // 0x2f65b0 - g_ps2RecompiledFunctionTable[514411] = ADXT_Destroy_0x2f6588; // 0x2f65b4 - g_ps2RecompiledFunctionTable[514412] = ADXT_Destroy_0x2f6588; // 0x2f65b8 - g_ps2RecompiledFunctionTable[514413] = ADXT_Destroy_0x2f6588; // 0x2f65bc - g_ps2RecompiledFunctionTable[514414] = ADXT_Destroy_0x2f6588; // 0x2f65c0 - g_ps2RecompiledFunctionTable[514415] = ADXT_Destroy_0x2f6588; // 0x2f65c4 - g_ps2RecompiledFunctionTable[514416] = ADXT_Destroy_0x2f6588; // 0x2f65c8 - g_ps2RecompiledFunctionTable[514417] = ADXT_Destroy_0x2f6588; // 0x2f65cc - g_ps2RecompiledFunctionTable[514418] = ADXT_Destroy_0x2f6588; // 0x2f65d0 - g_ps2RecompiledFunctionTable[514419] = ADXT_Destroy_0x2f6588; // 0x2f65d4 - g_ps2RecompiledFunctionTable[514420] = ADXT_Destroy_0x2f6588; // 0x2f65d8 - g_ps2RecompiledFunctionTable[514421] = ADXT_Destroy_0x2f6588; // 0x2f65dc - g_ps2RecompiledFunctionTable[514422] = ADXT_Destroy_0x2f6588; // 0x2f65e0 - g_ps2RecompiledFunctionTable[514423] = ADXT_Destroy_0x2f6588; // 0x2f65e4 - g_ps2RecompiledFunctionTable[514424] = ADXT_Destroy_0x2f6588; // 0x2f65e8 - g_ps2RecompiledFunctionTable[514425] = ADXT_Destroy_0x2f6588; // 0x2f65ec - g_ps2RecompiledFunctionTable[514426] = ADXT_Destroy_0x2f6588; // 0x2f65f0 - g_ps2RecompiledFunctionTable[514427] = ADXT_Destroy_0x2f6588; // 0x2f65f4 - g_ps2RecompiledFunctionTable[514428] = ADXT_Destroy_0x2f6588; // 0x2f65f8 - g_ps2RecompiledFunctionTable[514429] = ADXT_Destroy_0x2f6588; // 0x2f65fc - g_ps2RecompiledFunctionTable[514430] = ADXT_Destroy_0x2f6588; // 0x2f6600 - g_ps2RecompiledFunctionTable[514431] = ADXT_Destroy_0x2f6588; // 0x2f6604 - g_ps2RecompiledFunctionTable[514432] = ADXT_Destroy_0x2f6588; // 0x2f6608 - g_ps2RecompiledFunctionTable[514433] = ADXT_Destroy_0x2f6588; // 0x2f660c - g_ps2RecompiledFunctionTable[514434] = ADXT_Destroy_0x2f6588; // 0x2f6610 - g_ps2RecompiledFunctionTable[514435] = ADXT_Destroy_0x2f6588; // 0x2f6614 - g_ps2RecompiledFunctionTable[514436] = ADXT_Destroy_0x2f6588; // 0x2f6618 - g_ps2RecompiledFunctionTable[514437] = ADXT_Destroy_0x2f6588; // 0x2f661c - g_ps2RecompiledFunctionTable[514438] = ADXT_Destroy_0x2f6588; // 0x2f6620 - g_ps2RecompiledFunctionTable[514439] = ADXT_Destroy_0x2f6588; // 0x2f6624 - g_ps2RecompiledFunctionTable[514440] = ADXT_Destroy_0x2f6588; // 0x2f6628 - g_ps2RecompiledFunctionTable[514441] = ADXT_Destroy_0x2f6588; // 0x2f662c - g_ps2RecompiledFunctionTable[514442] = ADXT_Destroy_0x2f6588; // 0x2f6630 - g_ps2RecompiledFunctionTable[514443] = ADXT_Destroy_0x2f6588; // 0x2f6634 - g_ps2RecompiledFunctionTable[514444] = ADXT_Destroy_0x2f6588; // 0x2f6638 - g_ps2RecompiledFunctionTable[514445] = ADXT_Destroy_0x2f6588; // 0x2f663c - g_ps2RecompiledFunctionTable[514446] = ADXT_Destroy_0x2f6588; // 0x2f6640 - g_ps2RecompiledFunctionTable[514447] = ADXT_Destroy_0x2f6588; // 0x2f6644 - g_ps2RecompiledFunctionTable[514448] = ADXT_Destroy_0x2f6588; // 0x2f6648 - g_ps2RecompiledFunctionTable[514449] = ADXT_Destroy_0x2f6588; // 0x2f664c - g_ps2RecompiledFunctionTable[514450] = ADXT_Destroy_0x2f6588; // 0x2f6650 - g_ps2RecompiledFunctionTable[514451] = ADXT_Destroy_0x2f6588; // 0x2f6654 - g_ps2RecompiledFunctionTable[514452] = ADXT_Destroy_0x2f6588; // 0x2f6658 - g_ps2RecompiledFunctionTable[514453] = ADXT_Destroy_0x2f6588; // 0x2f665c - g_ps2RecompiledFunctionTable[514454] = ADXT_Destroy_0x2f6588; // 0x2f6660 - g_ps2RecompiledFunctionTable[514455] = ADXT_Destroy_0x2f6588; // 0x2f6664 - g_ps2RecompiledFunctionTable[514456] = ADXT_Destroy_0x2f6588; // 0x2f6668 - g_ps2RecompiledFunctionTable[514457] = ADXT_Destroy_0x2f6588; // 0x2f666c - g_ps2RecompiledFunctionTable[514458] = ADXT_Destroy_0x2f6588; // 0x2f6670 - g_ps2RecompiledFunctionTable[514459] = ADXT_Destroy_0x2f6588; // 0x2f6674 - g_ps2RecompiledFunctionTable[514460] = ADXT_Destroy_0x2f6588; // 0x2f6678 - g_ps2RecompiledFunctionTable[514461] = ADXT_Destroy_0x2f6588; // 0x2f667c - g_ps2RecompiledFunctionTable[514462] = ADXT_Destroy_0x2f6588; // 0x2f6680 - g_ps2RecompiledFunctionTable[514463] = ADXT_Destroy_0x2f6588; // 0x2f6684 - g_ps2RecompiledFunctionTable[514464] = ADXT_Destroy_0x2f6588; // 0x2f6688 - g_ps2RecompiledFunctionTable[514465] = ADXT_Destroy_0x2f6588; // 0x2f668c - g_ps2RecompiledFunctionTable[514466] = ADXT_Destroy_0x2f6588; // 0x2f6690 - g_ps2RecompiledFunctionTable[514467] = ADXT_Destroy_0x2f6588; // 0x2f6694 - g_ps2RecompiledFunctionTable[514468] = ADXT_Destroy_0x2f6588; // 0x2f6698 - g_ps2RecompiledFunctionTable[514469] = ADXT_Destroy_0x2f6588; // 0x2f669c - g_ps2RecompiledFunctionTable[514470] = ADXT_Destroy_0x2f6588; // 0x2f66a0 - g_ps2RecompiledFunctionTable[514471] = ADXT_Destroy_0x2f6588; // 0x2f66a4 - g_ps2RecompiledFunctionTable[514472] = ADXT_Destroy_0x2f6588; // 0x2f66a8 - g_ps2RecompiledFunctionTable[514473] = ADXT_Destroy_0x2f6588; // 0x2f66ac - g_ps2RecompiledFunctionTable[514474] = ADXT_Destroy_0x2f6588; // 0x2f66b0 - g_ps2RecompiledFunctionTable[514475] = ADXT_Destroy_0x2f6588; // 0x2f66b4 - g_ps2RecompiledFunctionTable[514476] = ADXT_Destroy_0x2f6588; // 0x2f66b8 - g_ps2RecompiledFunctionTable[514477] = ADXT_Destroy_0x2f6588; // 0x2f66bc - g_ps2RecompiledFunctionTable[514478] = ADXT_Destroy_0x2f6588; // 0x2f66c0 - g_ps2RecompiledFunctionTable[514479] = ADXT_Destroy_0x2f6588; // 0x2f66c4 - g_ps2RecompiledFunctionTable[514480] = ADXT_Destroy_0x2f6588; // 0x2f66c8 - g_ps2RecompiledFunctionTable[514481] = ADXT_Destroy_0x2f6588; // 0x2f66cc - g_ps2RecompiledFunctionTable[514482] = ADXT_Destroy_0x2f6588; // 0x2f66d0 - g_ps2RecompiledFunctionTable[514483] = ADXT_Destroy_0x2f6588; // 0x2f66d4 - g_ps2RecompiledFunctionTable[514484] = ADXT_Destroy_0x2f6588; // 0x2f66d8 - g_ps2RecompiledFunctionTable[514485] = ADXT_Destroy_0x2f6588; // 0x2f66dc - g_ps2RecompiledFunctionTable[514486] = ADXT_Destroy_0x2f6588; // 0x2f66e0 - g_ps2RecompiledFunctionTable[514487] = ADXT_Destroy_0x2f6588; // 0x2f66e4 - g_ps2RecompiledFunctionTable[514488] = ADXT_Destroy_0x2f6588; // 0x2f66e8 - g_ps2RecompiledFunctionTable[514489] = ADXT_Destroy_0x2f6588; // 0x2f66ec - g_ps2RecompiledFunctionTable[514490] = ADXT_Destroy_0x2f6588; // 0x2f66f0 - g_ps2RecompiledFunctionTable[514491] = ADXT_Destroy_0x2f6588; // 0x2f66f4 - g_ps2RecompiledFunctionTable[514492] = ADXT_Destroy_0x2f6588; // 0x2f66f8 - g_ps2RecompiledFunctionTable[514493] = ADXT_Destroy_0x2f6588; // 0x2f66fc - g_ps2RecompiledFunctionTable[514494] = ADXT_Destroy_0x2f6588; // 0x2f6700 - g_ps2RecompiledFunctionTable[514495] = ADXT_Destroy_0x2f6588; // 0x2f6704 - g_ps2RecompiledFunctionTable[514496] = ADXT_Destroy_0x2f6588; // 0x2f6708 - g_ps2RecompiledFunctionTable[514497] = ADXT_Destroy_0x2f6588; // 0x2f670c - g_ps2RecompiledFunctionTable[514498] = ADXT_Destroy_0x2f6588; // 0x2f6710 - g_ps2RecompiledFunctionTable[514499] = ADXT_Destroy_0x2f6588; // 0x2f6714 - g_ps2RecompiledFunctionTable[514500] = ADXT_Destroy_0x2f6588; // 0x2f6718 - g_ps2RecompiledFunctionTable[514501] = ADXT_Destroy_0x2f6588; // 0x2f671c - g_ps2RecompiledFunctionTable[514502] = ADXT_Destroy_0x2f6588; // 0x2f6720 - g_ps2RecompiledFunctionTable[514503] = ADXT_Destroy_0x2f6588; // 0x2f6724 - g_ps2RecompiledFunctionTable[514504] = ADXT_Destroy_0x2f6588; // 0x2f6728 - g_ps2RecompiledFunctionTable[514505] = ADXT_Destroy_0x2f6588; // 0x2f672c - g_ps2RecompiledFunctionTable[514506] = ADXT_Destroy_0x2f6588; // 0x2f6730 - g_ps2RecompiledFunctionTable[514507] = ADXT_Destroy_0x2f6588; // 0x2f6734 - g_ps2RecompiledFunctionTable[514508] = ADXT_Destroy_0x2f6588; // 0x2f6738 - g_ps2RecompiledFunctionTable[514510] = ADXT_DestroyAll_0x2f6740; // 0x2f6740 - g_ps2RecompiledFunctionTable[514520] = ADXT_DestroyAll_0x2f6740; // 0x2f6768 - g_ps2RecompiledFunctionTable[514524] = ADXT_DestroyAll_0x2f6740; // 0x2f6778 - g_ps2RecompiledFunctionTable[514534] = ADXT_CloseAllHandles_0x2f67a0; // 0x2f67a0 - g_ps2RecompiledFunctionTable[514536] = adxt_start_sj_0x2f67a8; // 0x2f67a8 - g_ps2RecompiledFunctionTable[514537] = adxt_start_sj_0x2f67a8; // 0x2f67ac - g_ps2RecompiledFunctionTable[514538] = adxt_start_sj_0x2f67a8; // 0x2f67b0 - g_ps2RecompiledFunctionTable[514539] = adxt_start_sj_0x2f67a8; // 0x2f67b4 - g_ps2RecompiledFunctionTable[514540] = adxt_start_sj_0x2f67a8; // 0x2f67b8 - g_ps2RecompiledFunctionTable[514541] = adxt_start_sj_0x2f67a8; // 0x2f67bc - g_ps2RecompiledFunctionTable[514542] = adxt_start_sj_0x2f67a8; // 0x2f67c0 - g_ps2RecompiledFunctionTable[514543] = adxt_start_sj_0x2f67a8; // 0x2f67c4 - g_ps2RecompiledFunctionTable[514544] = adxt_start_sj_0x2f67a8; // 0x2f67c8 - g_ps2RecompiledFunctionTable[514545] = adxt_start_sj_0x2f67a8; // 0x2f67cc - g_ps2RecompiledFunctionTable[514546] = adxt_start_sj_0x2f67a8; // 0x2f67d0 - g_ps2RecompiledFunctionTable[514547] = adxt_start_sj_0x2f67a8; // 0x2f67d4 - g_ps2RecompiledFunctionTable[514548] = adxt_start_sj_0x2f67a8; // 0x2f67d8 - g_ps2RecompiledFunctionTable[514549] = adxt_start_sj_0x2f67a8; // 0x2f67dc - g_ps2RecompiledFunctionTable[514550] = adxt_start_sj_0x2f67a8; // 0x2f67e0 - g_ps2RecompiledFunctionTable[514551] = adxt_start_sj_0x2f67a8; // 0x2f67e4 - g_ps2RecompiledFunctionTable[514552] = adxt_start_sj_0x2f67a8; // 0x2f67e8 - g_ps2RecompiledFunctionTable[514553] = adxt_start_sj_0x2f67a8; // 0x2f67ec - g_ps2RecompiledFunctionTable[514554] = adxt_start_sj_0x2f67a8; // 0x2f67f0 - g_ps2RecompiledFunctionTable[514555] = adxt_start_sj_0x2f67a8; // 0x2f67f4 - g_ps2RecompiledFunctionTable[514556] = adxt_start_sj_0x2f67a8; // 0x2f67f8 - g_ps2RecompiledFunctionTable[514557] = adxt_start_sj_0x2f67a8; // 0x2f67fc - g_ps2RecompiledFunctionTable[514558] = adxt_start_sj_0x2f67a8; // 0x2f6800 - g_ps2RecompiledFunctionTable[514559] = adxt_start_sj_0x2f67a8; // 0x2f6804 - g_ps2RecompiledFunctionTable[514560] = adxt_start_sj_0x2f67a8; // 0x2f6808 - g_ps2RecompiledFunctionTable[514561] = adxt_start_sj_0x2f67a8; // 0x2f680c - g_ps2RecompiledFunctionTable[514562] = adxt_start_sj_0x2f67a8; // 0x2f6810 - g_ps2RecompiledFunctionTable[514563] = adxt_start_sj_0x2f67a8; // 0x2f6814 - g_ps2RecompiledFunctionTable[514564] = adxt_start_sj_0x2f67a8; // 0x2f6818 - g_ps2RecompiledFunctionTable[514565] = adxt_start_sj_0x2f67a8; // 0x2f681c - g_ps2RecompiledFunctionTable[514566] = adxt_start_sj_0x2f67a8; // 0x2f6820 - g_ps2RecompiledFunctionTable[514567] = adxt_start_sj_0x2f67a8; // 0x2f6824 - g_ps2RecompiledFunctionTable[514568] = adxt_start_sj_0x2f67a8; // 0x2f6828 - g_ps2RecompiledFunctionTable[514569] = adxt_start_sj_0x2f67a8; // 0x2f682c - g_ps2RecompiledFunctionTable[514570] = adxt_start_sj_0x2f67a8; // 0x2f6830 - g_ps2RecompiledFunctionTable[514571] = adxt_start_sj_0x2f67a8; // 0x2f6834 - g_ps2RecompiledFunctionTable[514572] = adxt_start_sj_0x2f67a8; // 0x2f6838 - g_ps2RecompiledFunctionTable[514573] = adxt_start_sj_0x2f67a8; // 0x2f683c - g_ps2RecompiledFunctionTable[514574] = adxt_start_sj_0x2f67a8; // 0x2f6840 - g_ps2RecompiledFunctionTable[514575] = adxt_start_sj_0x2f67a8; // 0x2f6844 - g_ps2RecompiledFunctionTable[514576] = adxt_start_sj_0x2f67a8; // 0x2f6848 - g_ps2RecompiledFunctionTable[514577] = adxt_start_sj_0x2f67a8; // 0x2f684c - g_ps2RecompiledFunctionTable[514578] = adxt_start_sj_0x2f67a8; // 0x2f6850 - g_ps2RecompiledFunctionTable[514579] = adxt_start_sj_0x2f67a8; // 0x2f6854 - g_ps2RecompiledFunctionTable[514580] = adxt_start_sj_0x2f67a8; // 0x2f6858 - g_ps2RecompiledFunctionTable[514581] = adxt_start_sj_0x2f67a8; // 0x2f685c - g_ps2RecompiledFunctionTable[514582] = adxt_start_sj_0x2f67a8; // 0x2f6860 - g_ps2RecompiledFunctionTable[514583] = adxt_start_sj_0x2f67a8; // 0x2f6864 - g_ps2RecompiledFunctionTable[514584] = adxt_start_sj_0x2f67a8; // 0x2f6868 - g_ps2RecompiledFunctionTable[514586] = adxt_start_stm_0x2f6870; // 0x2f6870 - g_ps2RecompiledFunctionTable[514596] = adxt_start_stm_0x2f6870; // 0x2f6898 - g_ps2RecompiledFunctionTable[514599] = adxt_start_stm_0x2f6870; // 0x2f68a4 - g_ps2RecompiledFunctionTable[514601] = adxt_start_stm_0x2f6870; // 0x2f68ac - g_ps2RecompiledFunctionTable[514604] = adxt_start_stm_0x2f6870; // 0x2f68b8 - g_ps2RecompiledFunctionTable[514610] = ADXT_StartSj_0x2f68d0; // 0x2f68d0 - g_ps2RecompiledFunctionTable[514611] = ADXT_StartSj_0x2f68d0; // 0x2f68d4 - g_ps2RecompiledFunctionTable[514612] = ADXT_StartSj_0x2f68d0; // 0x2f68d8 - g_ps2RecompiledFunctionTable[514613] = ADXT_StartSj_0x2f68d0; // 0x2f68dc - g_ps2RecompiledFunctionTable[514614] = ADXT_StartSj_0x2f68d0; // 0x2f68e0 - g_ps2RecompiledFunctionTable[514615] = ADXT_StartSj_0x2f68d0; // 0x2f68e4 - g_ps2RecompiledFunctionTable[514616] = ADXT_StartSj_0x2f68d0; // 0x2f68e8 - g_ps2RecompiledFunctionTable[514617] = ADXT_StartSj_0x2f68d0; // 0x2f68ec - g_ps2RecompiledFunctionTable[514618] = ADXT_StartSj_0x2f68d0; // 0x2f68f0 - g_ps2RecompiledFunctionTable[514619] = ADXT_StartSj_0x2f68d0; // 0x2f68f4 - g_ps2RecompiledFunctionTable[514620] = ADXT_StartSj_0x2f68d0; // 0x2f68f8 - g_ps2RecompiledFunctionTable[514621] = ADXT_StartSj_0x2f68d0; // 0x2f68fc - g_ps2RecompiledFunctionTable[514622] = ADXT_StartSj_0x2f68d0; // 0x2f6900 - g_ps2RecompiledFunctionTable[514623] = ADXT_StartSj_0x2f68d0; // 0x2f6904 - g_ps2RecompiledFunctionTable[514624] = ADXT_StartSj_0x2f68d0; // 0x2f6908 - g_ps2RecompiledFunctionTable[514625] = ADXT_StartSj_0x2f68d0; // 0x2f690c - g_ps2RecompiledFunctionTable[514626] = ADXT_StartSj_0x2f68d0; // 0x2f6910 - g_ps2RecompiledFunctionTable[514627] = ADXT_StartSj_0x2f68d0; // 0x2f6914 - g_ps2RecompiledFunctionTable[514628] = ADXT_StartSj_0x2f68d0; // 0x2f6918 - g_ps2RecompiledFunctionTable[514629] = ADXT_StartSj_0x2f68d0; // 0x2f691c - g_ps2RecompiledFunctionTable[514630] = ADXT_StartSj_0x2f68d0; // 0x2f6920 - g_ps2RecompiledFunctionTable[514631] = ADXT_StartSj_0x2f68d0; // 0x2f6924 - g_ps2RecompiledFunctionTable[514632] = ADXT_StartSj_0x2f68d0; // 0x2f6928 - g_ps2RecompiledFunctionTable[514633] = ADXT_StartSj_0x2f68d0; // 0x2f692c - g_ps2RecompiledFunctionTable[514634] = ADXT_StartSj_0x2f68d0; // 0x2f6930 - g_ps2RecompiledFunctionTable[514635] = ADXT_StartSj_0x2f68d0; // 0x2f6934 - g_ps2RecompiledFunctionTable[514636] = ADXT_StartSj_0x2f68d0; // 0x2f6938 - g_ps2RecompiledFunctionTable[514637] = ADXT_StartSj_0x2f68d0; // 0x2f693c - g_ps2RecompiledFunctionTable[514638] = ADXT_StartSj_0x2f68d0; // 0x2f6940 - g_ps2RecompiledFunctionTable[514639] = ADXT_StartSj_0x2f68d0; // 0x2f6944 - g_ps2RecompiledFunctionTable[514640] = ADXT_StartSj_0x2f68d0; // 0x2f6948 - g_ps2RecompiledFunctionTable[514641] = ADXT_StartSj_0x2f68d0; // 0x2f694c - g_ps2RecompiledFunctionTable[514642] = ADXT_StartSj_0x2f68d0; // 0x2f6950 - g_ps2RecompiledFunctionTable[514643] = ADXT_StartSj_0x2f68d0; // 0x2f6954 - g_ps2RecompiledFunctionTable[514644] = ADXT_StartSj_0x2f68d0; // 0x2f6958 - g_ps2RecompiledFunctionTable[514645] = ADXT_StartSj_0x2f68d0; // 0x2f695c - g_ps2RecompiledFunctionTable[514646] = ADXT_StartSj_0x2f68d0; // 0x2f6960 - g_ps2RecompiledFunctionTable[514647] = ADXT_StartSj_0x2f68d0; // 0x2f6964 - g_ps2RecompiledFunctionTable[514648] = ADXT_StartSj_0x2f68d0; // 0x2f6968 - g_ps2RecompiledFunctionTable[514649] = ADXT_StartSj_0x2f68d0; // 0x2f696c - g_ps2RecompiledFunctionTable[514650] = ADXT_StartSj_0x2f68d0; // 0x2f6970 - g_ps2RecompiledFunctionTable[514651] = ADXT_StartSj_0x2f68d0; // 0x2f6974 - g_ps2RecompiledFunctionTable[514652] = ADXT_StartSj_0x2f68d0; // 0x2f6978 - g_ps2RecompiledFunctionTable[514653] = ADXT_StartSj_0x2f68d0; // 0x2f697c - g_ps2RecompiledFunctionTable[514654] = ADXT_StartSj_0x2f68d0; // 0x2f6980 - g_ps2RecompiledFunctionTable[514655] = ADXT_StartSj_0x2f68d0; // 0x2f6984 - g_ps2RecompiledFunctionTable[514656] = ADXT_StartSj_0x2f68d0; // 0x2f6988 - g_ps2RecompiledFunctionTable[514657] = ADXT_StartSj_0x2f68d0; // 0x2f698c - g_ps2RecompiledFunctionTable[514658] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6990 - g_ps2RecompiledFunctionTable[514659] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6994 - g_ps2RecompiledFunctionTable[514660] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6998 - g_ps2RecompiledFunctionTable[514661] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f699c - g_ps2RecompiledFunctionTable[514662] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f69a0 - g_ps2RecompiledFunctionTable[514663] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f69a4 - g_ps2RecompiledFunctionTable[514664] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f69a8 - g_ps2RecompiledFunctionTable[514665] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f69ac - g_ps2RecompiledFunctionTable[514666] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f69b0 - g_ps2RecompiledFunctionTable[514667] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f69b4 - g_ps2RecompiledFunctionTable[514668] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f69b8 - g_ps2RecompiledFunctionTable[514669] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f69bc - g_ps2RecompiledFunctionTable[514670] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f69c0 - g_ps2RecompiledFunctionTable[514671] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f69c4 - g_ps2RecompiledFunctionTable[514672] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f69c8 - g_ps2RecompiledFunctionTable[514673] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f69cc - g_ps2RecompiledFunctionTable[514674] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f69d0 - g_ps2RecompiledFunctionTable[514675] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f69d4 - g_ps2RecompiledFunctionTable[514676] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f69d8 - g_ps2RecompiledFunctionTable[514677] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f69dc - g_ps2RecompiledFunctionTable[514678] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f69e0 - g_ps2RecompiledFunctionTable[514679] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f69e4 - g_ps2RecompiledFunctionTable[514680] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f69e8 - g_ps2RecompiledFunctionTable[514681] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f69ec - g_ps2RecompiledFunctionTable[514682] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f69f0 - g_ps2RecompiledFunctionTable[514683] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f69f4 - g_ps2RecompiledFunctionTable[514684] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f69f8 - g_ps2RecompiledFunctionTable[514685] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f69fc - g_ps2RecompiledFunctionTable[514686] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6a00 - g_ps2RecompiledFunctionTable[514687] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6a04 - g_ps2RecompiledFunctionTable[514688] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6a08 - g_ps2RecompiledFunctionTable[514689] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6a0c - g_ps2RecompiledFunctionTable[514690] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6a10 - g_ps2RecompiledFunctionTable[514691] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6a14 - g_ps2RecompiledFunctionTable[514692] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6a18 - g_ps2RecompiledFunctionTable[514693] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6a1c - g_ps2RecompiledFunctionTable[514694] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6a20 - g_ps2RecompiledFunctionTable[514695] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6a24 - g_ps2RecompiledFunctionTable[514696] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6a28 - g_ps2RecompiledFunctionTable[514697] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6a2c - g_ps2RecompiledFunctionTable[514698] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6a30 - g_ps2RecompiledFunctionTable[514699] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6a34 - g_ps2RecompiledFunctionTable[514700] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6a38 - g_ps2RecompiledFunctionTable[514701] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6a3c - g_ps2RecompiledFunctionTable[514702] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6a40 - g_ps2RecompiledFunctionTable[514703] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6a44 - g_ps2RecompiledFunctionTable[514704] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6a48 - g_ps2RecompiledFunctionTable[514705] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6a4c - g_ps2RecompiledFunctionTable[514706] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6a50 - g_ps2RecompiledFunctionTable[514707] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6a54 - g_ps2RecompiledFunctionTable[514708] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6a58 - g_ps2RecompiledFunctionTable[514709] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6a5c - g_ps2RecompiledFunctionTable[514710] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6a60 - g_ps2RecompiledFunctionTable[514711] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6a64 - g_ps2RecompiledFunctionTable[514712] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6a68 - g_ps2RecompiledFunctionTable[514713] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6a6c - g_ps2RecompiledFunctionTable[514714] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6a70 - g_ps2RecompiledFunctionTable[514715] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6a74 - g_ps2RecompiledFunctionTable[514716] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6a78 - g_ps2RecompiledFunctionTable[514717] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6a7c - g_ps2RecompiledFunctionTable[514718] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6a80 - g_ps2RecompiledFunctionTable[514719] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6a84 - g_ps2RecompiledFunctionTable[514720] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6a88 - g_ps2RecompiledFunctionTable[514721] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6a8c - g_ps2RecompiledFunctionTable[514722] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6a90 - g_ps2RecompiledFunctionTable[514723] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6a94 - g_ps2RecompiledFunctionTable[514724] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6a98 - g_ps2RecompiledFunctionTable[514725] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6a9c - g_ps2RecompiledFunctionTable[514726] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6aa0 - g_ps2RecompiledFunctionTable[514727] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6aa4 - g_ps2RecompiledFunctionTable[514728] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6aa8 - g_ps2RecompiledFunctionTable[514729] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6aac - g_ps2RecompiledFunctionTable[514730] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6ab0 - g_ps2RecompiledFunctionTable[514731] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6ab4 - g_ps2RecompiledFunctionTable[514732] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6ab8 - g_ps2RecompiledFunctionTable[514733] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6abc - g_ps2RecompiledFunctionTable[514734] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6ac0 - g_ps2RecompiledFunctionTable[514735] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6ac4 - g_ps2RecompiledFunctionTable[514736] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6ac8 - g_ps2RecompiledFunctionTable[514737] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6acc - g_ps2RecompiledFunctionTable[514738] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6ad0 - g_ps2RecompiledFunctionTable[514739] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6ad4 - g_ps2RecompiledFunctionTable[514740] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6ad8 - g_ps2RecompiledFunctionTable[514741] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6adc - g_ps2RecompiledFunctionTable[514742] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6ae0 - g_ps2RecompiledFunctionTable[514743] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6ae4 - g_ps2RecompiledFunctionTable[514744] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6ae8 - g_ps2RecompiledFunctionTable[514745] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6aec - g_ps2RecompiledFunctionTable[514746] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6af0 - g_ps2RecompiledFunctionTable[514747] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6af4 - g_ps2RecompiledFunctionTable[514748] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6af8 - g_ps2RecompiledFunctionTable[514749] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6afc - g_ps2RecompiledFunctionTable[514750] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6b00 - g_ps2RecompiledFunctionTable[514751] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6b04 - g_ps2RecompiledFunctionTable[514752] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6b08 - g_ps2RecompiledFunctionTable[514753] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6b0c - g_ps2RecompiledFunctionTable[514754] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6b10 - g_ps2RecompiledFunctionTable[514755] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6b14 - g_ps2RecompiledFunctionTable[514756] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6b18 - g_ps2RecompiledFunctionTable[514757] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6b1c - g_ps2RecompiledFunctionTable[514758] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6b20 - g_ps2RecompiledFunctionTable[514759] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6b24 - g_ps2RecompiledFunctionTable[514760] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6b28 - g_ps2RecompiledFunctionTable[514761] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6b2c - g_ps2RecompiledFunctionTable[514762] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6b30 - g_ps2RecompiledFunctionTable[514763] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6b34 - g_ps2RecompiledFunctionTable[514764] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6b38 - g_ps2RecompiledFunctionTable[514765] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6b3c - g_ps2RecompiledFunctionTable[514766] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6b40 - g_ps2RecompiledFunctionTable[514767] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6b44 - g_ps2RecompiledFunctionTable[514768] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6b48 - g_ps2RecompiledFunctionTable[514769] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6b4c - g_ps2RecompiledFunctionTable[514770] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6b50 - g_ps2RecompiledFunctionTable[514771] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6b54 - g_ps2RecompiledFunctionTable[514772] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6b58 - g_ps2RecompiledFunctionTable[514773] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6b5c - g_ps2RecompiledFunctionTable[514774] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6b60 - g_ps2RecompiledFunctionTable[514775] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6b64 - g_ps2RecompiledFunctionTable[514776] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6b68 - g_ps2RecompiledFunctionTable[514777] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6b6c - g_ps2RecompiledFunctionTable[514778] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6b70 - g_ps2RecompiledFunctionTable[514779] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6b74 - g_ps2RecompiledFunctionTable[514780] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6b78 - g_ps2RecompiledFunctionTable[514781] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6b7c - g_ps2RecompiledFunctionTable[514782] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6b80 - g_ps2RecompiledFunctionTable[514783] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6b84 - g_ps2RecompiledFunctionTable[514784] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6b88 - g_ps2RecompiledFunctionTable[514785] = ADXT_StopWithoutLsc_0x2f6990; // 0x2f6b8c - g_ps2RecompiledFunctionTable[514786] = ADXT_Stop_0x2f6b90; // 0x2f6b90 - g_ps2RecompiledFunctionTable[514787] = ADXT_Stop_0x2f6b90; // 0x2f6b94 - g_ps2RecompiledFunctionTable[514788] = ADXT_Stop_0x2f6b90; // 0x2f6b98 - g_ps2RecompiledFunctionTable[514789] = ADXT_Stop_0x2f6b90; // 0x2f6b9c - g_ps2RecompiledFunctionTable[514790] = ADXT_Stop_0x2f6b90; // 0x2f6ba0 - g_ps2RecompiledFunctionTable[514791] = ADXT_Stop_0x2f6b90; // 0x2f6ba4 - g_ps2RecompiledFunctionTable[514792] = ADXT_Stop_0x2f6b90; // 0x2f6ba8 - g_ps2RecompiledFunctionTable[514793] = ADXT_Stop_0x2f6b90; // 0x2f6bac - g_ps2RecompiledFunctionTable[514794] = ADXT_Stop_0x2f6b90; // 0x2f6bb0 - g_ps2RecompiledFunctionTable[514795] = ADXT_Stop_0x2f6b90; // 0x2f6bb4 - g_ps2RecompiledFunctionTable[514796] = ADXT_Stop_0x2f6b90; // 0x2f6bb8 - g_ps2RecompiledFunctionTable[514797] = ADXT_Stop_0x2f6b90; // 0x2f6bbc - g_ps2RecompiledFunctionTable[514798] = ADXT_Stop_0x2f6b90; // 0x2f6bc0 - g_ps2RecompiledFunctionTable[514799] = ADXT_Stop_0x2f6b90; // 0x2f6bc4 - g_ps2RecompiledFunctionTable[514800] = ADXT_Stop_0x2f6b90; // 0x2f6bc8 - g_ps2RecompiledFunctionTable[514801] = ADXT_Stop_0x2f6b90; // 0x2f6bcc - g_ps2RecompiledFunctionTable[514802] = ADXT_Stop_0x2f6b90; // 0x2f6bd0 - g_ps2RecompiledFunctionTable[514803] = ADXT_Stop_0x2f6b90; // 0x2f6bd4 - g_ps2RecompiledFunctionTable[514804] = ADXT_Stop_0x2f6b90; // 0x2f6bd8 - g_ps2RecompiledFunctionTable[514805] = ADXT_Stop_0x2f6b90; // 0x2f6bdc - g_ps2RecompiledFunctionTable[514806] = ADXT_Stop_0x2f6b90; // 0x2f6be0 - g_ps2RecompiledFunctionTable[514807] = ADXT_Stop_0x2f6b90; // 0x2f6be4 - g_ps2RecompiledFunctionTable[514808] = ADXT_GetStat_0x2f6be8; // 0x2f6be8 - g_ps2RecompiledFunctionTable[514810] = ADXT_SetTimeMode_0x2f6bf0; // 0x2f6bf0 - g_ps2RecompiledFunctionTable[514820] = ADXT_GetTimeSfreq_0x2f6c18; // 0x2f6c18 - g_ps2RecompiledFunctionTable[514834] = ADXT_GetTimeSfreq_0x2f6c18; // 0x2f6c50 - g_ps2RecompiledFunctionTable[514843] = ADXT_GetTimeSfreq_0x2f6c18; // 0x2f6c74 - g_ps2RecompiledFunctionTable[514846] = ADXT_GetTimeSfreq_0x2f6c18; // 0x2f6c80 - g_ps2RecompiledFunctionTable[514849] = ADXT_GetTimeSfreq_0x2f6c18; // 0x2f6c8c - g_ps2RecompiledFunctionTable[514870] = ADXT_GetTimeSfreq2_0x2f6ce0; // 0x2f6ce0 - g_ps2RecompiledFunctionTable[514884] = ADXT_GetTimeSfreq2_0x2f6ce0; // 0x2f6d18 - g_ps2RecompiledFunctionTable[514887] = ADXT_GetTimeSfreq2_0x2f6ce0; // 0x2f6d24 - g_ps2RecompiledFunctionTable[514890] = ADXT_GetTimeSfreq2_0x2f6ce0; // 0x2f6d30 - g_ps2RecompiledFunctionTable[514900] = ADXT_GetTimeSfreq2_0x2f6ce0; // 0x2f6d58 - g_ps2RecompiledFunctionTable[514903] = ADXT_GetTimeSfreq2_0x2f6ce0; // 0x2f6d64 - g_ps2RecompiledFunctionTable[514906] = ADXT_GetTimeSfreq2_0x2f6ce0; // 0x2f6d70 - g_ps2RecompiledFunctionTable[514928] = ADXT_GetTime_0x2f6dc8; // 0x2f6dc8 - g_ps2RecompiledFunctionTable[514941] = ADXT_GetTime_0x2f6dc8; // 0x2f6dfc - g_ps2RecompiledFunctionTable[514965] = ADXT_GetTime_0x2f6dc8; // 0x2f6e5c - g_ps2RecompiledFunctionTable[515001] = ADXT_GetTime_0x2f6dc8; // 0x2f6eec - g_ps2RecompiledFunctionTable[515024] = ADXT_GetTime_0x2f6dc8; // 0x2f6f48 - g_ps2RecompiledFunctionTable[515027] = ADXT_GetTime_0x2f6dc8; // 0x2f6f54 - g_ps2RecompiledFunctionTable[515030] = ADXT_GetTime_0x2f6dc8; // 0x2f6f60 - g_ps2RecompiledFunctionTable[515072] = ADXT_GetTimeReal_0x2f7008; // 0x2f7008 - g_ps2RecompiledFunctionTable[515078] = ADXT_GetTimeReal_0x2f7008; // 0x2f7020 - g_ps2RecompiledFunctionTable[515080] = ADXT_GetTimeReal_0x2f7008; // 0x2f7028 - g_ps2RecompiledFunctionTable[515083] = ADXT_GetTimeReal_0x2f7008; // 0x2f7034 - g_ps2RecompiledFunctionTable[515086] = ADXT_GetTimeReal_0x2f7008; // 0x2f7040 - g_ps2RecompiledFunctionTable[515090] = ADXT_GetTimeReal_0x2f7008; // 0x2f7050 - g_ps2RecompiledFunctionTable[515092] = ADXT_GetTimeReal_0x2f7008; // 0x2f7058 - g_ps2RecompiledFunctionTable[515096] = ADXT_GetNumSmpl_0x2f7068; // 0x2f7068 - g_ps2RecompiledFunctionTable[515104] = ADXT_GetNumSmpl_0x2f7068; // 0x2f7088 - g_ps2RecompiledFunctionTable[515110] = ADXT_GetSfreq_0x2f70a0; // 0x2f70a0 - g_ps2RecompiledFunctionTable[515118] = ADXT_GetSfreq_0x2f70a0; // 0x2f70c0 - g_ps2RecompiledFunctionTable[515124] = ADXT_GetNumChan_0x2f70d8; // 0x2f70d8 - g_ps2RecompiledFunctionTable[515132] = ADXT_GetNumChan_0x2f70d8; // 0x2f70f8 - g_ps2RecompiledFunctionTable[515138] = ADXT_GetHdrLen_0x2f7110; // 0x2f7110 - g_ps2RecompiledFunctionTable[515146] = ADXT_GetHdrLen_0x2f7110; // 0x2f7130 - g_ps2RecompiledFunctionTable[515152] = ADXT_GetFmtBps_0x2f7148; // 0x2f7148 - g_ps2RecompiledFunctionTable[515160] = ADXT_GetFmtBps_0x2f7148; // 0x2f7168 - g_ps2RecompiledFunctionTable[515166] = ADXT_SetOutPan_0x2f7180; // 0x2f7180 - g_ps2RecompiledFunctionTable[515178] = ADXT_GetOutPan_0x2f71b0; // 0x2f71b0 - g_ps2RecompiledFunctionTable[515182] = ADXT_SetOutVol_0x2f71c0; // 0x2f71c0 - g_ps2RecompiledFunctionTable[515188] = ADXT_GetOutVol_0x2f71d8; // 0x2f71d8 - g_ps2RecompiledFunctionTable[515190] = ADXT_SetSvrFreq_0x2f71e0; // 0x2f71e0 - g_ps2RecompiledFunctionTable[515192] = ADXT_SetReloadTime_0x2f71e8; // 0x2f71e8 - g_ps2RecompiledFunctionTable[515214] = ADXT_SetReloadSct_0x2f7240; // 0x2f7240 - g_ps2RecompiledFunctionTable[515216] = ADXT_GetNumSctIbuf_0x2f7248; // 0x2f7248 - g_ps2RecompiledFunctionTable[515217] = ADXT_GetNumSctIbuf_0x2f7248; // 0x2f724c - g_ps2RecompiledFunctionTable[515218] = ADXT_GetNumSctIbuf_0x2f7248; // 0x2f7250 - g_ps2RecompiledFunctionTable[515219] = ADXT_GetNumSctIbuf_0x2f7248; // 0x2f7254 - g_ps2RecompiledFunctionTable[515220] = ADXT_GetNumSctIbuf_0x2f7248; // 0x2f7258 - g_ps2RecompiledFunctionTable[515221] = ADXT_GetNumSctIbuf_0x2f7248; // 0x2f725c - g_ps2RecompiledFunctionTable[515222] = ADXT_GetNumSctIbuf_0x2f7248; // 0x2f7260 - g_ps2RecompiledFunctionTable[515223] = ADXT_GetNumSctIbuf_0x2f7248; // 0x2f7264 - g_ps2RecompiledFunctionTable[515224] = ADXT_GetNumSctIbuf_0x2f7248; // 0x2f7268 - g_ps2RecompiledFunctionTable[515225] = ADXT_GetNumSctIbuf_0x2f7248; // 0x2f726c - g_ps2RecompiledFunctionTable[515226] = ADXT_GetNumSctIbuf_0x2f7248; // 0x2f7270 - g_ps2RecompiledFunctionTable[515227] = ADXT_GetNumSctIbuf_0x2f7248; // 0x2f7274 - g_ps2RecompiledFunctionTable[515228] = ADXT_GetNumSctIbuf_0x2f7248; // 0x2f7278 - g_ps2RecompiledFunctionTable[515229] = ADXT_GetNumSctIbuf_0x2f7248; // 0x2f727c - g_ps2RecompiledFunctionTable[515230] = ADXT_GetNumSctIbuf_0x2f7248; // 0x2f7280 - g_ps2RecompiledFunctionTable[515231] = ADXT_GetNumSctIbuf_0x2f7248; // 0x2f7284 - g_ps2RecompiledFunctionTable[515232] = ADXT_GetNumSctIbuf_0x2f7248; // 0x2f7288 - g_ps2RecompiledFunctionTable[515234] = ADXT_GetNumSmplObuf_0x2f7290; // 0x2f7290 - g_ps2RecompiledFunctionTable[515235] = ADXT_GetNumSmplObuf_0x2f7290; // 0x2f7294 - g_ps2RecompiledFunctionTable[515236] = ADXT_GetNumSmplObuf_0x2f7290; // 0x2f7298 - g_ps2RecompiledFunctionTable[515237] = ADXT_GetNumSmplObuf_0x2f7290; // 0x2f729c - g_ps2RecompiledFunctionTable[515238] = ADXT_GetNumSmplObuf_0x2f7290; // 0x2f72a0 - g_ps2RecompiledFunctionTable[515239] = ADXT_GetNumSmplObuf_0x2f7290; // 0x2f72a4 - g_ps2RecompiledFunctionTable[515240] = ADXT_GetNumSmplObuf_0x2f7290; // 0x2f72a8 - g_ps2RecompiledFunctionTable[515241] = ADXT_GetNumSmplObuf_0x2f7290; // 0x2f72ac - g_ps2RecompiledFunctionTable[515242] = ADXT_GetNumSmplObuf_0x2f7290; // 0x2f72b0 - g_ps2RecompiledFunctionTable[515243] = ADXT_GetNumSmplObuf_0x2f7290; // 0x2f72b4 - g_ps2RecompiledFunctionTable[515244] = ADXT_GetNumSmplObuf_0x2f7290; // 0x2f72b8 - g_ps2RecompiledFunctionTable[515245] = ADXT_GetNumSmplObuf_0x2f7290; // 0x2f72bc - g_ps2RecompiledFunctionTable[515246] = ADXT_GetNumSmplObuf_0x2f7290; // 0x2f72c0 - g_ps2RecompiledFunctionTable[515247] = ADXT_GetNumSmplObuf_0x2f7290; // 0x2f72c4 - g_ps2RecompiledFunctionTable[515248] = ADXT_GetNumSmplObuf_0x2f7290; // 0x2f72c8 - g_ps2RecompiledFunctionTable[515249] = ADXT_GetNumSmplObuf_0x2f7290; // 0x2f72cc - g_ps2RecompiledFunctionTable[515250] = ADXT_GetNumSmplObuf_0x2f7290; // 0x2f72d0 - g_ps2RecompiledFunctionTable[515252] = ADXT_GetIbufRemainTime_0x2f72d8; // 0x2f72d8 - g_ps2RecompiledFunctionTable[515253] = ADXT_GetIbufRemainTime_0x2f72d8; // 0x2f72dc - g_ps2RecompiledFunctionTable[515254] = ADXT_GetIbufRemainTime_0x2f72d8; // 0x2f72e0 - g_ps2RecompiledFunctionTable[515255] = ADXT_GetIbufRemainTime_0x2f72d8; // 0x2f72e4 - g_ps2RecompiledFunctionTable[515256] = ADXT_GetIbufRemainTime_0x2f72d8; // 0x2f72e8 - g_ps2RecompiledFunctionTable[515257] = ADXT_GetIbufRemainTime_0x2f72d8; // 0x2f72ec - g_ps2RecompiledFunctionTable[515258] = ADXT_GetIbufRemainTime_0x2f72d8; // 0x2f72f0 - g_ps2RecompiledFunctionTable[515259] = ADXT_GetIbufRemainTime_0x2f72d8; // 0x2f72f4 - g_ps2RecompiledFunctionTable[515260] = ADXT_GetIbufRemainTime_0x2f72d8; // 0x2f72f8 - g_ps2RecompiledFunctionTable[515261] = ADXT_GetIbufRemainTime_0x2f72d8; // 0x2f72fc - g_ps2RecompiledFunctionTable[515262] = ADXT_GetIbufRemainTime_0x2f72d8; // 0x2f7300 - g_ps2RecompiledFunctionTable[515263] = ADXT_GetIbufRemainTime_0x2f72d8; // 0x2f7304 - g_ps2RecompiledFunctionTable[515264] = ADXT_GetIbufRemainTime_0x2f72d8; // 0x2f7308 - g_ps2RecompiledFunctionTable[515265] = ADXT_GetIbufRemainTime_0x2f72d8; // 0x2f730c - g_ps2RecompiledFunctionTable[515266] = ADXT_GetIbufRemainTime_0x2f72d8; // 0x2f7310 - g_ps2RecompiledFunctionTable[515267] = ADXT_GetIbufRemainTime_0x2f72d8; // 0x2f7314 - g_ps2RecompiledFunctionTable[515268] = ADXT_GetIbufRemainTime_0x2f72d8; // 0x2f7318 - g_ps2RecompiledFunctionTable[515269] = ADXT_GetIbufRemainTime_0x2f72d8; // 0x2f731c - g_ps2RecompiledFunctionTable[515270] = ADXT_GetIbufRemainTime_0x2f72d8; // 0x2f7320 - g_ps2RecompiledFunctionTable[515271] = ADXT_GetIbufRemainTime_0x2f72d8; // 0x2f7324 - g_ps2RecompiledFunctionTable[515272] = ADXT_GetIbufRemainTime_0x2f72d8; // 0x2f7328 - g_ps2RecompiledFunctionTable[515273] = ADXT_GetIbufRemainTime_0x2f72d8; // 0x2f732c - g_ps2RecompiledFunctionTable[515274] = ADXT_GetIbufRemainTime_0x2f72d8; // 0x2f7330 - g_ps2RecompiledFunctionTable[515275] = ADXT_GetIbufRemainTime_0x2f72d8; // 0x2f7334 - g_ps2RecompiledFunctionTable[515276] = ADXT_GetIbufRemainTime_0x2f72d8; // 0x2f7338 - g_ps2RecompiledFunctionTable[515277] = ADXT_GetIbufRemainTime_0x2f72d8; // 0x2f733c - g_ps2RecompiledFunctionTable[515278] = ADXT_GetIbufRemainTime_0x2f72d8; // 0x2f7340 - g_ps2RecompiledFunctionTable[515279] = ADXT_GetIbufRemainTime_0x2f72d8; // 0x2f7344 - g_ps2RecompiledFunctionTable[515280] = ADXT_GetIbufRemainTime_0x2f72d8; // 0x2f7348 - g_ps2RecompiledFunctionTable[515281] = ADXT_GetIbufRemainTime_0x2f72d8; // 0x2f734c - g_ps2RecompiledFunctionTable[515282] = ADXT_GetIbufRemainTime_0x2f72d8; // 0x2f7350 - g_ps2RecompiledFunctionTable[515283] = ADXT_GetIbufRemainTime_0x2f72d8; // 0x2f7354 - g_ps2RecompiledFunctionTable[515284] = ADXT_GetIbufRemainTime_0x2f72d8; // 0x2f7358 - g_ps2RecompiledFunctionTable[515285] = ADXT_GetIbufRemainTime_0x2f72d8; // 0x2f735c - g_ps2RecompiledFunctionTable[515286] = ADXT_GetIbufRemainTime_0x2f72d8; // 0x2f7360 - g_ps2RecompiledFunctionTable[515287] = ADXT_GetIbufRemainTime_0x2f72d8; // 0x2f7364 - g_ps2RecompiledFunctionTable[515288] = ADXT_GetIbufRemainTime_0x2f72d8; // 0x2f7368 - g_ps2RecompiledFunctionTable[515289] = ADXT_GetIbufRemainTime_0x2f72d8; // 0x2f736c - g_ps2RecompiledFunctionTable[515290] = ADXT_GetIbufRemainTime_0x2f72d8; // 0x2f7370 - g_ps2RecompiledFunctionTable[515291] = ADXT_GetIbufRemainTime_0x2f72d8; // 0x2f7374 - g_ps2RecompiledFunctionTable[515292] = ADXT_GetIbufRemainTime_0x2f72d8; // 0x2f7378 - g_ps2RecompiledFunctionTable[515293] = ADXT_GetIbufRemainTime_0x2f72d8; // 0x2f737c - g_ps2RecompiledFunctionTable[515294] = ADXT_GetIbufRemainTime_0x2f72d8; // 0x2f7380 - g_ps2RecompiledFunctionTable[515295] = ADXT_GetIbufRemainTime_0x2f72d8; // 0x2f7384 - g_ps2RecompiledFunctionTable[515296] = ADXT_GetIbufRemainTime_0x2f72d8; // 0x2f7388 - g_ps2RecompiledFunctionTable[515297] = ADXT_GetIbufRemainTime_0x2f72d8; // 0x2f738c - g_ps2RecompiledFunctionTable[515298] = ADXT_GetIbufRemainTime_0x2f72d8; // 0x2f7390 - g_ps2RecompiledFunctionTable[515300] = ADXT_IsIbufSafety_0x2f7398; // 0x2f7398 - g_ps2RecompiledFunctionTable[515301] = ADXT_IsIbufSafety_0x2f7398; // 0x2f739c - g_ps2RecompiledFunctionTable[515302] = ADXT_IsIbufSafety_0x2f7398; // 0x2f73a0 - g_ps2RecompiledFunctionTable[515303] = ADXT_IsIbufSafety_0x2f7398; // 0x2f73a4 - g_ps2RecompiledFunctionTable[515304] = ADXT_IsIbufSafety_0x2f7398; // 0x2f73a8 - g_ps2RecompiledFunctionTable[515305] = ADXT_IsIbufSafety_0x2f7398; // 0x2f73ac - g_ps2RecompiledFunctionTable[515306] = ADXT_IsIbufSafety_0x2f7398; // 0x2f73b0 - g_ps2RecompiledFunctionTable[515307] = ADXT_IsIbufSafety_0x2f7398; // 0x2f73b4 - g_ps2RecompiledFunctionTable[515308] = ADXT_IsIbufSafety_0x2f7398; // 0x2f73b8 - g_ps2RecompiledFunctionTable[515309] = ADXT_IsIbufSafety_0x2f7398; // 0x2f73bc - g_ps2RecompiledFunctionTable[515310] = ADXT_IsIbufSafety_0x2f7398; // 0x2f73c0 - g_ps2RecompiledFunctionTable[515311] = ADXT_IsIbufSafety_0x2f7398; // 0x2f73c4 - g_ps2RecompiledFunctionTable[515312] = ADXT_IsIbufSafety_0x2f7398; // 0x2f73c8 - g_ps2RecompiledFunctionTable[515313] = ADXT_IsIbufSafety_0x2f7398; // 0x2f73cc - g_ps2RecompiledFunctionTable[515314] = ADXT_IsIbufSafety_0x2f7398; // 0x2f73d0 - g_ps2RecompiledFunctionTable[515315] = ADXT_IsIbufSafety_0x2f7398; // 0x2f73d4 - g_ps2RecompiledFunctionTable[515316] = ADXT_IsIbufSafety_0x2f7398; // 0x2f73d8 - g_ps2RecompiledFunctionTable[515317] = ADXT_IsIbufSafety_0x2f7398; // 0x2f73dc - g_ps2RecompiledFunctionTable[515318] = ADXT_IsIbufSafety_0x2f7398; // 0x2f73e0 - g_ps2RecompiledFunctionTable[515320] = ADXT_SetAutoRcvr_0x2f73e8; // 0x2f73e8 - g_ps2RecompiledFunctionTable[515322] = ADXT_IsCompleted_0x2f73f0; // 0x2f73f0 - g_ps2RecompiledFunctionTable[515326] = ADXT_ExecServer_0x2f7400; // 0x2f7400 - g_ps2RecompiledFunctionTable[515333] = ADXT_ExecServer_0x2f7400; // 0x2f741c - g_ps2RecompiledFunctionTable[515335] = ADXT_ExecServer_0x2f7400; // 0x2f7424 - g_ps2RecompiledFunctionTable[515340] = ADXT_ExecServer_0x2f7400; // 0x2f7438 - g_ps2RecompiledFunctionTable[515344] = ADXT_ExecServer_0x2f7400; // 0x2f7448 - g_ps2RecompiledFunctionTable[515350] = ADXT_ExecServer_0x2f7400; // 0x2f7460 - g_ps2RecompiledFunctionTable[515358] = ADXT_GetErrCode_0x2f7480; // 0x2f7480 - g_ps2RecompiledFunctionTable[515360] = ADXT_ClearErrCode_0x2f7488; // 0x2f7488 - g_ps2RecompiledFunctionTable[515366] = ADXT_GetLpCnt_0x2f74a0; // 0x2f74a0 - g_ps2RecompiledFunctionTable[515368] = ADXT_SetLpFlg_0x2f74a8; // 0x2f74a8 - g_ps2RecompiledFunctionTable[515370] = ADXT_GetInputSj_0x2f74b0; // 0x2f74b0 - g_ps2RecompiledFunctionTable[515372] = ADXT_SetWaitPlayStart_0x2f74b8; // 0x2f74b8 - g_ps2RecompiledFunctionTable[515374] = ADXT_IsReadyPlayStart_0x2f74c0; // 0x2f74c0 - g_ps2RecompiledFunctionTable[515376] = ADXT_EntryErrFunc_0x2f74c8; // 0x2f74c8 - g_ps2RecompiledFunctionTable[515378] = ADXT_SetPauseBuf_0x2f74d0; // 0x2f74d0 - g_ps2RecompiledFunctionTable[515380] = ADXT_DiscardSmpl_0x2f74d8; // 0x2f74d8 - g_ps2RecompiledFunctionTable[515390] = ADXT_DiscardSmpl_0x2f74d8; // 0x2f7500 - g_ps2RecompiledFunctionTable[515392] = ADXT_DiscardSmpl_0x2f74d8; // 0x2f7508 - g_ps2RecompiledFunctionTable[515396] = ADXT_DiscardSmpl_0x2f74d8; // 0x2f7518 - g_ps2RecompiledFunctionTable[515418] = ADXT_SetTimeOfst_0x2f7570; // 0x2f7570 - g_ps2RecompiledFunctionTable[515420] = ADXT_SetLnkSw_0x2f7578; // 0x2f7578 - g_ps2RecompiledFunctionTable[515422] = ADXT_GetLnkSw_0x2f7580; // 0x2f7580 - g_ps2RecompiledFunctionTable[515424] = ADXT_EntryFltFunc_0x2f7588; // 0x2f7588 - g_ps2RecompiledFunctionTable[515426] = ADXT_GetDecNumSmpl_0x2f7590; // 0x2f7590 - g_ps2RecompiledFunctionTable[515430] = ADXT_GetDecNumSmpl_0x2f7590; // 0x2f75a0 - g_ps2RecompiledFunctionTable[515434] = ADXT_IsHeader_0x2f75b0; // 0x2f75b0 - g_ps2RecompiledFunctionTable[515449] = ADXT_IsHeader_0x2f75b0; // 0x2f75ec - g_ps2RecompiledFunctionTable[515462] = ADXT_IsHeader_0x2f75b0; // 0x2f7620 - g_ps2RecompiledFunctionTable[515470] = ADXT_IsEndcode_0x2f7640; // 0x2f7640 - g_ps2RecompiledFunctionTable[515473] = ADXT_IsEndcode_0x2f7640; // 0x2f764c - g_ps2RecompiledFunctionTable[515484] = ADXT_InsertSilence_0x2f7678; // 0x2f7678 - g_ps2RecompiledFunctionTable[515485] = ADXT_InsertSilence_0x2f7678; // 0x2f767c - g_ps2RecompiledFunctionTable[515486] = ADXT_InsertSilence_0x2f7678; // 0x2f7680 - g_ps2RecompiledFunctionTable[515487] = ADXT_InsertSilence_0x2f7678; // 0x2f7684 - g_ps2RecompiledFunctionTable[515488] = ADXT_InsertSilence_0x2f7678; // 0x2f7688 - g_ps2RecompiledFunctionTable[515489] = ADXT_InsertSilence_0x2f7678; // 0x2f768c - g_ps2RecompiledFunctionTable[515490] = ADXT_InsertSilence_0x2f7678; // 0x2f7690 - g_ps2RecompiledFunctionTable[515491] = ADXT_InsertSilence_0x2f7678; // 0x2f7694 - g_ps2RecompiledFunctionTable[515492] = ADXT_InsertSilence_0x2f7678; // 0x2f7698 - g_ps2RecompiledFunctionTable[515493] = ADXT_InsertSilence_0x2f7678; // 0x2f769c - g_ps2RecompiledFunctionTable[515494] = ADXT_InsertSilence_0x2f7678; // 0x2f76a0 - g_ps2RecompiledFunctionTable[515495] = ADXT_InsertSilence_0x2f7678; // 0x2f76a4 - g_ps2RecompiledFunctionTable[515496] = ADXT_InsertSilence_0x2f7678; // 0x2f76a8 - g_ps2RecompiledFunctionTable[515497] = ADXT_InsertSilence_0x2f7678; // 0x2f76ac - g_ps2RecompiledFunctionTable[515498] = ADXT_InsertSilence_0x2f7678; // 0x2f76b0 - g_ps2RecompiledFunctionTable[515499] = ADXT_InsertSilence_0x2f7678; // 0x2f76b4 - g_ps2RecompiledFunctionTable[515500] = ADXT_InsertSilence_0x2f7678; // 0x2f76b8 - g_ps2RecompiledFunctionTable[515501] = ADXT_InsertSilence_0x2f7678; // 0x2f76bc - g_ps2RecompiledFunctionTable[515502] = ADXT_InsertSilence_0x2f7678; // 0x2f76c0 - g_ps2RecompiledFunctionTable[515503] = ADXT_InsertSilence_0x2f7678; // 0x2f76c4 - g_ps2RecompiledFunctionTable[515504] = ADXT_InsertSilence_0x2f7678; // 0x2f76c8 - g_ps2RecompiledFunctionTable[515505] = ADXT_InsertSilence_0x2f7678; // 0x2f76cc - g_ps2RecompiledFunctionTable[515506] = ADXT_InsertSilence_0x2f7678; // 0x2f76d0 - g_ps2RecompiledFunctionTable[515507] = ADXT_InsertSilence_0x2f7678; // 0x2f76d4 - g_ps2RecompiledFunctionTable[515508] = ADXT_InsertSilence_0x2f7678; // 0x2f76d8 - g_ps2RecompiledFunctionTable[515509] = ADXT_InsertSilence_0x2f7678; // 0x2f76dc - g_ps2RecompiledFunctionTable[515510] = ADXT_InsertSilence_0x2f7678; // 0x2f76e0 - g_ps2RecompiledFunctionTable[515511] = ADXT_InsertSilence_0x2f7678; // 0x2f76e4 - g_ps2RecompiledFunctionTable[515512] = ADXT_InsertSilence_0x2f7678; // 0x2f76e8 - g_ps2RecompiledFunctionTable[515513] = ADXT_InsertSilence_0x2f7678; // 0x2f76ec - g_ps2RecompiledFunctionTable[515514] = ADXT_InsertSilence_0x2f7678; // 0x2f76f0 - g_ps2RecompiledFunctionTable[515515] = ADXT_InsertSilence_0x2f7678; // 0x2f76f4 - g_ps2RecompiledFunctionTable[515516] = ADXT_InsertSilence_0x2f7678; // 0x2f76f8 - g_ps2RecompiledFunctionTable[515517] = ADXT_InsertSilence_0x2f7678; // 0x2f76fc - g_ps2RecompiledFunctionTable[515518] = ADXT_InsertSilence_0x2f7678; // 0x2f7700 - g_ps2RecompiledFunctionTable[515519] = ADXT_InsertSilence_0x2f7678; // 0x2f7704 - g_ps2RecompiledFunctionTable[515520] = ADXT_InsertSilence_0x2f7678; // 0x2f7708 - g_ps2RecompiledFunctionTable[515521] = ADXT_InsertSilence_0x2f7678; // 0x2f770c - g_ps2RecompiledFunctionTable[515522] = ADXT_InsertSilence_0x2f7678; // 0x2f7710 - g_ps2RecompiledFunctionTable[515523] = ADXT_InsertSilence_0x2f7678; // 0x2f7714 - g_ps2RecompiledFunctionTable[515524] = ADXT_InsertSilence_0x2f7678; // 0x2f7718 - g_ps2RecompiledFunctionTable[515525] = ADXT_InsertSilence_0x2f7678; // 0x2f771c - g_ps2RecompiledFunctionTable[515526] = ADXT_InsertSilence_0x2f7678; // 0x2f7720 - g_ps2RecompiledFunctionTable[515527] = ADXT_InsertSilence_0x2f7678; // 0x2f7724 - g_ps2RecompiledFunctionTable[515528] = ADXT_InsertSilence_0x2f7678; // 0x2f7728 - g_ps2RecompiledFunctionTable[515529] = ADXT_InsertSilence_0x2f7678; // 0x2f772c - g_ps2RecompiledFunctionTable[515530] = ADXT_InsertSilence_0x2f7678; // 0x2f7730 - g_ps2RecompiledFunctionTable[515531] = ADXT_InsertSilence_0x2f7678; // 0x2f7734 - g_ps2RecompiledFunctionTable[515532] = ADXT_InsertSilence_0x2f7678; // 0x2f7738 - g_ps2RecompiledFunctionTable[515533] = ADXT_InsertSilence_0x2f7678; // 0x2f773c - g_ps2RecompiledFunctionTable[515534] = ADXT_InsertSilence_0x2f7678; // 0x2f7740 - g_ps2RecompiledFunctionTable[515535] = ADXT_InsertSilence_0x2f7678; // 0x2f7744 - g_ps2RecompiledFunctionTable[515536] = ADXT_InsertSilence_0x2f7678; // 0x2f7748 - g_ps2RecompiledFunctionTable[515537] = ADXT_InsertSilence_0x2f7678; // 0x2f774c - g_ps2RecompiledFunctionTable[515538] = ADXT_InsertSilence_0x2f7678; // 0x2f7750 - g_ps2RecompiledFunctionTable[515539] = ADXT_InsertSilence_0x2f7678; // 0x2f7754 - g_ps2RecompiledFunctionTable[515540] = ADXT_InsertSilence_0x2f7678; // 0x2f7758 - g_ps2RecompiledFunctionTable[515541] = ADXT_InsertSilence_0x2f7678; // 0x2f775c - g_ps2RecompiledFunctionTable[515542] = ADXT_InsertSilence_0x2f7678; // 0x2f7760 - g_ps2RecompiledFunctionTable[515543] = ADXT_InsertSilence_0x2f7678; // 0x2f7764 - g_ps2RecompiledFunctionTable[515544] = ADXT_InsertSilence_0x2f7678; // 0x2f7768 - g_ps2RecompiledFunctionTable[515545] = ADXT_InsertSilence_0x2f7678; // 0x2f776c - g_ps2RecompiledFunctionTable[515546] = ADXT_InsertSilence_0x2f7678; // 0x2f7770 - g_ps2RecompiledFunctionTable[515547] = ADXT_InsertSilence_0x2f7678; // 0x2f7774 - g_ps2RecompiledFunctionTable[515548] = ADXT_InsertSilence_0x2f7678; // 0x2f7778 - g_ps2RecompiledFunctionTable[515549] = ADXT_InsertSilence_0x2f7678; // 0x2f777c - g_ps2RecompiledFunctionTable[515550] = ADXT_InsertSilence_0x2f7678; // 0x2f7780 - g_ps2RecompiledFunctionTable[515551] = ADXT_InsertSilence_0x2f7678; // 0x2f7784 - g_ps2RecompiledFunctionTable[515552] = ADXT_InsertSilence_0x2f7678; // 0x2f7788 - g_ps2RecompiledFunctionTable[515553] = ADXT_InsertSilence_0x2f7678; // 0x2f778c - g_ps2RecompiledFunctionTable[515554] = ADXT_InsertSilence_0x2f7678; // 0x2f7790 - g_ps2RecompiledFunctionTable[515555] = ADXT_InsertSilence_0x2f7678; // 0x2f7794 - g_ps2RecompiledFunctionTable[515556] = ADXT_InsertSilence_0x2f7678; // 0x2f7798 - g_ps2RecompiledFunctionTable[515557] = ADXT_InsertSilence_0x2f7678; // 0x2f779c - g_ps2RecompiledFunctionTable[515558] = ADXT_InsertSilence_0x2f7678; // 0x2f77a0 - g_ps2RecompiledFunctionTable[515559] = ADXT_InsertSilence_0x2f7678; // 0x2f77a4 - g_ps2RecompiledFunctionTable[515560] = ADXT_InsertSilence_0x2f7678; // 0x2f77a8 - g_ps2RecompiledFunctionTable[515561] = ADXT_InsertSilence_0x2f7678; // 0x2f77ac - g_ps2RecompiledFunctionTable[515562] = ADXT_InsertSilence_0x2f7678; // 0x2f77b0 - g_ps2RecompiledFunctionTable[515563] = ADXT_InsertSilence_0x2f7678; // 0x2f77b4 - g_ps2RecompiledFunctionTable[515564] = ADXT_InsertSilence_0x2f7678; // 0x2f77b8 - g_ps2RecompiledFunctionTable[515565] = ADXT_InsertSilence_0x2f7678; // 0x2f77bc - g_ps2RecompiledFunctionTable[515566] = ADXT_InsertSilence_0x2f7678; // 0x2f77c0 - g_ps2RecompiledFunctionTable[515567] = ADXT_InsertSilence_0x2f7678; // 0x2f77c4 - g_ps2RecompiledFunctionTable[515568] = ADXT_InsertSilence_0x2f7678; // 0x2f77c8 - g_ps2RecompiledFunctionTable[515569] = ADXT_InsertSilence_0x2f7678; // 0x2f77cc - g_ps2RecompiledFunctionTable[515570] = ADXT_InsertSilence_0x2f7678; // 0x2f77d0 - g_ps2RecompiledFunctionTable[515571] = ADXT_InsertSilence_0x2f7678; // 0x2f77d4 - g_ps2RecompiledFunctionTable[515572] = ADXT_InsertSilence_0x2f7678; // 0x2f77d8 - g_ps2RecompiledFunctionTable[515573] = ADXT_InsertSilence_0x2f7678; // 0x2f77dc - g_ps2RecompiledFunctionTable[515574] = ADXT_InsertSilence_0x2f7678; // 0x2f77e0 - g_ps2RecompiledFunctionTable[515575] = ADXT_InsertSilence_0x2f7678; // 0x2f77e4 - g_ps2RecompiledFunctionTable[515576] = ADXT_InsertSilence_0x2f7678; // 0x2f77e8 - g_ps2RecompiledFunctionTable[515577] = ADXT_InsertSilence_0x2f7678; // 0x2f77ec - g_ps2RecompiledFunctionTable[515578] = ADXT_InsertSilence_0x2f7678; // 0x2f77f0 - g_ps2RecompiledFunctionTable[515579] = ADXT_InsertSilence_0x2f7678; // 0x2f77f4 - g_ps2RecompiledFunctionTable[515580] = ADXT_InsertSilence_0x2f7678; // 0x2f77f8 - g_ps2RecompiledFunctionTable[515581] = ADXT_InsertSilence_0x2f7678; // 0x2f77fc - g_ps2RecompiledFunctionTable[515582] = ADXT_InsertSilence_0x2f7678; // 0x2f7800 - g_ps2RecompiledFunctionTable[515583] = ADXT_InsertSilence_0x2f7678; // 0x2f7804 - g_ps2RecompiledFunctionTable[515584] = ADXT_InsertSilence_0x2f7678; // 0x2f7808 - g_ps2RecompiledFunctionTable[515585] = ADXT_InsertSilence_0x2f7678; // 0x2f780c - g_ps2RecompiledFunctionTable[515586] = ADXT_InsertSilence_0x2f7678; // 0x2f7810 - g_ps2RecompiledFunctionTable[515587] = ADXT_InsertSilence_0x2f7678; // 0x2f7814 - g_ps2RecompiledFunctionTable[515588] = ADXT_InsertSilence_0x2f7678; // 0x2f7818 - g_ps2RecompiledFunctionTable[515590] = ADXT_SetOutputMono_0x2f7820; // 0x2f7820 - g_ps2RecompiledFunctionTable[515592] = ADXT_StartAfs_0x2f7828; // 0x2f7828 - g_ps2RecompiledFunctionTable[515602] = ADXT_StartAfs_0x2f7828; // 0x2f7850 - g_ps2RecompiledFunctionTable[515604] = ADXT_StartAfs_0x2f7828; // 0x2f7858 - g_ps2RecompiledFunctionTable[515613] = ADXT_StartAfs_0x2f7828; // 0x2f787c - g_ps2RecompiledFunctionTable[515620] = ADXT_StartAfs_0x2f7828; // 0x2f7898 - g_ps2RecompiledFunctionTable[515624] = ADXT_StartAfs_0x2f7828; // 0x2f78a8 - g_ps2RecompiledFunctionTable[515629] = ADXT_StartAfs_0x2f7828; // 0x2f78bc - g_ps2RecompiledFunctionTable[515633] = ADXT_StartAfs_0x2f7828; // 0x2f78cc - g_ps2RecompiledFunctionTable[515637] = ADXT_StartAfs_0x2f7828; // 0x2f78dc - g_ps2RecompiledFunctionTable[515640] = ADXT_StartAfs_0x2f7828; // 0x2f78e8 - g_ps2RecompiledFunctionTable[515648] = ADXT_StartFname_0x2f7908; // 0x2f7908 - g_ps2RecompiledFunctionTable[515655] = ADXT_StartFname_0x2f7908; // 0x2f7924 - g_ps2RecompiledFunctionTable[515657] = ADXT_StartFname_0x2f7908; // 0x2f792c - g_ps2RecompiledFunctionTable[515660] = ADXT_StartFname_0x2f7908; // 0x2f7938 - g_ps2RecompiledFunctionTable[515664] = ADXT_StartFname_0x2f7908; // 0x2f7948 - g_ps2RecompiledFunctionTable[515668] = ADXT_StartFname_0x2f7908; // 0x2f7958 - g_ps2RecompiledFunctionTable[515672] = ADXT_StartFname_0x2f7908; // 0x2f7968 - g_ps2RecompiledFunctionTable[515678] = ADXT_StartMem_0x2f7980; // 0x2f7980 - g_ps2RecompiledFunctionTable[515680] = ADXT_StartMem2_0x2f7988; // 0x2f7988 - g_ps2RecompiledFunctionTable[515689] = ADXT_StartMem2_0x2f7988; // 0x2f79ac - g_ps2RecompiledFunctionTable[515691] = ADXT_StartMem2_0x2f7988; // 0x2f79b4 - g_ps2RecompiledFunctionTable[515694] = ADXT_StartMem2_0x2f7988; // 0x2f79c0 - g_ps2RecompiledFunctionTable[515698] = ADXT_StartMem2_0x2f7988; // 0x2f79d0 - g_ps2RecompiledFunctionTable[515701] = ADXT_StartMem2_0x2f7988; // 0x2f79dc - g_ps2RecompiledFunctionTable[515705] = ADXT_StartMem2_0x2f7988; // 0x2f79ec - g_ps2RecompiledFunctionTable[515714] = ADXT_StartMemIdx_0x2f7a10; // 0x2f7a10 - g_ps2RecompiledFunctionTable[515724] = ADXT_StartMemIdx_0x2f7a10; // 0x2f7a38 - g_ps2RecompiledFunctionTable[515742] = ADXT_StartMemIdx_0x2f7a10; // 0x2f7a80 - g_ps2RecompiledFunctionTable[515757] = ADXT_StartMemIdx_0x2f7a10; // 0x2f7abc - g_ps2RecompiledFunctionTable[515761] = ADXT_StartMemIdx_0x2f7a10; // 0x2f7acc - g_ps2RecompiledFunctionTable[515764] = ADXT_StartMemIdx_0x2f7a10; // 0x2f7ad8 - g_ps2RecompiledFunctionTable[515768] = ADXT_StartMemIdx_0x2f7a10; // 0x2f7ae8 - g_ps2RecompiledFunctionTable[515784] = adxt_trap_entry_0x2f7b28; // 0x2f7b28 - g_ps2RecompiledFunctionTable[515785] = adxt_trap_entry_0x2f7b28; // 0x2f7b2c - g_ps2RecompiledFunctionTable[515786] = adxt_trap_entry_0x2f7b28; // 0x2f7b30 - g_ps2RecompiledFunctionTable[515787] = adxt_trap_entry_0x2f7b28; // 0x2f7b34 - g_ps2RecompiledFunctionTable[515788] = adxt_trap_entry_0x2f7b28; // 0x2f7b38 - g_ps2RecompiledFunctionTable[515789] = adxt_trap_entry_0x2f7b28; // 0x2f7b3c - g_ps2RecompiledFunctionTable[515790] = adxt_trap_entry_0x2f7b28; // 0x2f7b40 - g_ps2RecompiledFunctionTable[515791] = adxt_trap_entry_0x2f7b28; // 0x2f7b44 - g_ps2RecompiledFunctionTable[515792] = adxt_trap_entry_0x2f7b28; // 0x2f7b48 - g_ps2RecompiledFunctionTable[515793] = adxt_trap_entry_0x2f7b28; // 0x2f7b4c - g_ps2RecompiledFunctionTable[515794] = adxt_trap_entry_0x2f7b28; // 0x2f7b50 - g_ps2RecompiledFunctionTable[515795] = adxt_trap_entry_0x2f7b28; // 0x2f7b54 - g_ps2RecompiledFunctionTable[515796] = adxt_trap_entry_0x2f7b28; // 0x2f7b58 - g_ps2RecompiledFunctionTable[515797] = adxt_trap_entry_0x2f7b28; // 0x2f7b5c - g_ps2RecompiledFunctionTable[515798] = adxt_trap_entry_0x2f7b28; // 0x2f7b60 - g_ps2RecompiledFunctionTable[515799] = adxt_trap_entry_0x2f7b28; // 0x2f7b64 - g_ps2RecompiledFunctionTable[515800] = adxt_trap_entry_0x2f7b28; // 0x2f7b68 - g_ps2RecompiledFunctionTable[515801] = adxt_trap_entry_0x2f7b28; // 0x2f7b6c - g_ps2RecompiledFunctionTable[515802] = adxt_trap_entry_0x2f7b28; // 0x2f7b70 - g_ps2RecompiledFunctionTable[515803] = adxt_trap_entry_0x2f7b28; // 0x2f7b74 - g_ps2RecompiledFunctionTable[515804] = adxt_trap_entry_0x2f7b28; // 0x2f7b78 - g_ps2RecompiledFunctionTable[515805] = adxt_trap_entry_0x2f7b28; // 0x2f7b7c - g_ps2RecompiledFunctionTable[515806] = adxt_trap_entry_0x2f7b28; // 0x2f7b80 - g_ps2RecompiledFunctionTable[515807] = adxt_trap_entry_0x2f7b28; // 0x2f7b84 - g_ps2RecompiledFunctionTable[515808] = adxt_trap_entry_0x2f7b28; // 0x2f7b88 - g_ps2RecompiledFunctionTable[515809] = adxt_trap_entry_0x2f7b28; // 0x2f7b8c - g_ps2RecompiledFunctionTable[515810] = adxt_trap_entry_0x2f7b28; // 0x2f7b90 - g_ps2RecompiledFunctionTable[515811] = adxt_trap_entry_0x2f7b28; // 0x2f7b94 - g_ps2RecompiledFunctionTable[515812] = adxt_trap_entry_0x2f7b28; // 0x2f7b98 - g_ps2RecompiledFunctionTable[515813] = adxt_trap_entry_0x2f7b28; // 0x2f7b9c - g_ps2RecompiledFunctionTable[515814] = adxt_trap_entry_0x2f7b28; // 0x2f7ba0 - g_ps2RecompiledFunctionTable[515815] = adxt_trap_entry_0x2f7b28; // 0x2f7ba4 - g_ps2RecompiledFunctionTable[515816] = adxt_trap_entry_0x2f7b28; // 0x2f7ba8 - g_ps2RecompiledFunctionTable[515817] = adxt_trap_entry_0x2f7b28; // 0x2f7bac - g_ps2RecompiledFunctionTable[515818] = adxt_trap_entry_0x2f7b28; // 0x2f7bb0 - g_ps2RecompiledFunctionTable[515819] = adxt_trap_entry_0x2f7b28; // 0x2f7bb4 - g_ps2RecompiledFunctionTable[515820] = adxt_trap_entry_0x2f7b28; // 0x2f7bb8 - g_ps2RecompiledFunctionTable[515821] = adxt_trap_entry_0x2f7b28; // 0x2f7bbc - g_ps2RecompiledFunctionTable[515822] = adxt_trap_entry_0x2f7b28; // 0x2f7bc0 - g_ps2RecompiledFunctionTable[515823] = adxt_trap_entry_0x2f7b28; // 0x2f7bc4 - g_ps2RecompiledFunctionTable[515824] = adxt_trap_entry_0x2f7b28; // 0x2f7bc8 - g_ps2RecompiledFunctionTable[515825] = adxt_trap_entry_0x2f7b28; // 0x2f7bcc - g_ps2RecompiledFunctionTable[515826] = adxt_trap_entry_0x2f7b28; // 0x2f7bd0 - g_ps2RecompiledFunctionTable[515827] = adxt_trap_entry_0x2f7b28; // 0x2f7bd4 - g_ps2RecompiledFunctionTable[515828] = adxt_trap_entry_0x2f7b28; // 0x2f7bd8 - g_ps2RecompiledFunctionTable[515829] = adxt_trap_entry_0x2f7b28; // 0x2f7bdc - g_ps2RecompiledFunctionTable[515830] = adxt_trap_entry_0x2f7b28; // 0x2f7be0 - g_ps2RecompiledFunctionTable[515831] = adxt_trap_entry_0x2f7b28; // 0x2f7be4 - g_ps2RecompiledFunctionTable[515832] = adxt_trap_entry_0x2f7b28; // 0x2f7be8 - g_ps2RecompiledFunctionTable[515833] = adxt_trap_entry_0x2f7b28; // 0x2f7bec - g_ps2RecompiledFunctionTable[515834] = adxt_trap_entry_0x2f7b28; // 0x2f7bf0 - g_ps2RecompiledFunctionTable[515835] = adxt_trap_entry_0x2f7b28; // 0x2f7bf4 - g_ps2RecompiledFunctionTable[515836] = adxt_trap_entry_0x2f7b28; // 0x2f7bf8 - g_ps2RecompiledFunctionTable[515837] = adxt_trap_entry_0x2f7b28; // 0x2f7bfc - g_ps2RecompiledFunctionTable[515838] = adxt_trap_entry_0x2f7b28; // 0x2f7c00 - g_ps2RecompiledFunctionTable[515839] = adxt_trap_entry_0x2f7b28; // 0x2f7c04 - g_ps2RecompiledFunctionTable[515840] = adxt_trap_entry_0x2f7b28; // 0x2f7c08 - g_ps2RecompiledFunctionTable[515841] = adxt_trap_entry_0x2f7b28; // 0x2f7c0c - g_ps2RecompiledFunctionTable[515842] = adxt_trap_entry_0x2f7b28; // 0x2f7c10 - g_ps2RecompiledFunctionTable[515843] = adxt_trap_entry_0x2f7b28; // 0x2f7c14 - g_ps2RecompiledFunctionTable[515844] = adxt_trap_entry_0x2f7b28; // 0x2f7c18 - g_ps2RecompiledFunctionTable[515845] = adxt_trap_entry_0x2f7b28; // 0x2f7c1c - g_ps2RecompiledFunctionTable[515846] = adxt_trap_entry_0x2f7b28; // 0x2f7c20 - g_ps2RecompiledFunctionTable[515847] = adxt_trap_entry_0x2f7b28; // 0x2f7c24 - g_ps2RecompiledFunctionTable[515848] = adxt_trap_entry_0x2f7b28; // 0x2f7c28 - g_ps2RecompiledFunctionTable[515849] = adxt_trap_entry_0x2f7b28; // 0x2f7c2c - g_ps2RecompiledFunctionTable[515850] = adxt_trap_entry_0x2f7b28; // 0x2f7c30 - g_ps2RecompiledFunctionTable[515851] = adxt_trap_entry_0x2f7b28; // 0x2f7c34 - g_ps2RecompiledFunctionTable[515852] = adxt_trap_entry_0x2f7b28; // 0x2f7c38 - g_ps2RecompiledFunctionTable[515853] = adxt_trap_entry_0x2f7b28; // 0x2f7c3c - g_ps2RecompiledFunctionTable[515854] = adxt_trap_entry_0x2f7b28; // 0x2f7c40 - g_ps2RecompiledFunctionTable[515855] = adxt_trap_entry_0x2f7b28; // 0x2f7c44 - g_ps2RecompiledFunctionTable[515856] = adxt_trap_entry_0x2f7b28; // 0x2f7c48 - g_ps2RecompiledFunctionTable[515857] = adxt_trap_entry_0x2f7b28; // 0x2f7c4c - g_ps2RecompiledFunctionTable[515858] = adxt_trap_entry_0x2f7b28; // 0x2f7c50 - g_ps2RecompiledFunctionTable[515859] = adxt_trap_entry_0x2f7b28; // 0x2f7c54 - g_ps2RecompiledFunctionTable[515860] = adxt_trap_entry_0x2f7b28; // 0x2f7c58 - g_ps2RecompiledFunctionTable[515861] = adxt_trap_entry_0x2f7b28; // 0x2f7c5c - g_ps2RecompiledFunctionTable[515862] = adxt_trap_entry_0x2f7b28; // 0x2f7c60 - g_ps2RecompiledFunctionTable[515863] = adxt_trap_entry_0x2f7b28; // 0x2f7c64 - g_ps2RecompiledFunctionTable[515864] = adxt_trap_entry_0x2f7b28; // 0x2f7c68 - g_ps2RecompiledFunctionTable[515865] = adxt_trap_entry_0x2f7b28; // 0x2f7c6c - g_ps2RecompiledFunctionTable[515866] = adxt_trap_entry_0x2f7b28; // 0x2f7c70 - g_ps2RecompiledFunctionTable[515867] = adxt_trap_entry_0x2f7b28; // 0x2f7c74 - g_ps2RecompiledFunctionTable[515868] = adxt_trap_entry_0x2f7b28; // 0x2f7c78 - g_ps2RecompiledFunctionTable[515869] = adxt_trap_entry_0x2f7b28; // 0x2f7c7c - g_ps2RecompiledFunctionTable[515870] = adxt_trap_entry_0x2f7b28; // 0x2f7c80 - g_ps2RecompiledFunctionTable[515871] = adxt_trap_entry_0x2f7b28; // 0x2f7c84 - g_ps2RecompiledFunctionTable[515872] = adxt_trap_entry_0x2f7b28; // 0x2f7c88 - g_ps2RecompiledFunctionTable[515873] = adxt_trap_entry_0x2f7b28; // 0x2f7c8c - g_ps2RecompiledFunctionTable[515874] = adxt_trap_entry_0x2f7b28; // 0x2f7c90 - g_ps2RecompiledFunctionTable[515875] = adxt_trap_entry_0x2f7b28; // 0x2f7c94 - g_ps2RecompiledFunctionTable[515876] = adxt_trap_entry_0x2f7b28; // 0x2f7c98 - g_ps2RecompiledFunctionTable[515877] = adxt_trap_entry_0x2f7b28; // 0x2f7c9c - g_ps2RecompiledFunctionTable[515878] = adxt_trap_entry_0x2f7b28; // 0x2f7ca0 - g_ps2RecompiledFunctionTable[515879] = adxt_trap_entry_0x2f7b28; // 0x2f7ca4 - g_ps2RecompiledFunctionTable[515880] = adxt_trap_entry_0x2f7b28; // 0x2f7ca8 - g_ps2RecompiledFunctionTable[515882] = adxt_eos_entry_0x2f7cb0; // 0x2f7cb0 - g_ps2RecompiledFunctionTable[515890] = adxt_eos_entry_0x2f7cb0; // 0x2f7cd0 - g_ps2RecompiledFunctionTable[515897] = adxt_eos_entry_0x2f7cb0; // 0x2f7cec - g_ps2RecompiledFunctionTable[515916] = adxt_set_outpan_0x2f7d38; // 0x2f7d38 - g_ps2RecompiledFunctionTable[515922] = adxt_set_outpan_0x2f7d38; // 0x2f7d50 - g_ps2RecompiledFunctionTable[515945] = adxt_set_outpan_0x2f7d38; // 0x2f7dac - g_ps2RecompiledFunctionTable[515949] = adxt_set_outpan_0x2f7d38; // 0x2f7dbc - g_ps2RecompiledFunctionTable[515964] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7df8 - g_ps2RecompiledFunctionTable[515965] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7dfc - g_ps2RecompiledFunctionTable[515966] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7e00 - g_ps2RecompiledFunctionTable[515967] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7e04 - g_ps2RecompiledFunctionTable[515968] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7e08 - g_ps2RecompiledFunctionTable[515969] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7e0c - g_ps2RecompiledFunctionTable[515970] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7e10 - g_ps2RecompiledFunctionTable[515971] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7e14 - g_ps2RecompiledFunctionTable[515972] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7e18 - g_ps2RecompiledFunctionTable[515973] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7e1c - g_ps2RecompiledFunctionTable[515974] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7e20 - g_ps2RecompiledFunctionTable[515975] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7e24 - g_ps2RecompiledFunctionTable[515976] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7e28 - g_ps2RecompiledFunctionTable[515977] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7e2c - g_ps2RecompiledFunctionTable[515978] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7e30 - g_ps2RecompiledFunctionTable[515979] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7e34 - g_ps2RecompiledFunctionTable[515980] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7e38 - g_ps2RecompiledFunctionTable[515981] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7e3c - g_ps2RecompiledFunctionTable[515982] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7e40 - g_ps2RecompiledFunctionTable[515983] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7e44 - g_ps2RecompiledFunctionTable[515984] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7e48 - g_ps2RecompiledFunctionTable[515985] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7e4c - g_ps2RecompiledFunctionTable[515986] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7e50 - g_ps2RecompiledFunctionTable[515987] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7e54 - g_ps2RecompiledFunctionTable[515988] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7e58 - g_ps2RecompiledFunctionTable[515989] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7e5c - g_ps2RecompiledFunctionTable[515990] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7e60 - g_ps2RecompiledFunctionTable[515991] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7e64 - g_ps2RecompiledFunctionTable[515992] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7e68 - g_ps2RecompiledFunctionTable[515993] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7e6c - g_ps2RecompiledFunctionTable[515994] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7e70 - g_ps2RecompiledFunctionTable[515995] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7e74 - g_ps2RecompiledFunctionTable[515996] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7e78 - g_ps2RecompiledFunctionTable[515997] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7e7c - g_ps2RecompiledFunctionTable[515998] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7e80 - g_ps2RecompiledFunctionTable[515999] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7e84 - g_ps2RecompiledFunctionTable[516000] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7e88 - g_ps2RecompiledFunctionTable[516001] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7e8c - g_ps2RecompiledFunctionTable[516002] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7e90 - g_ps2RecompiledFunctionTable[516003] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7e94 - g_ps2RecompiledFunctionTable[516004] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7e98 - g_ps2RecompiledFunctionTable[516005] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7e9c - g_ps2RecompiledFunctionTable[516006] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7ea0 - g_ps2RecompiledFunctionTable[516007] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7ea4 - g_ps2RecompiledFunctionTable[516008] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7ea8 - g_ps2RecompiledFunctionTable[516009] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7eac - g_ps2RecompiledFunctionTable[516010] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7eb0 - g_ps2RecompiledFunctionTable[516011] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7eb4 - g_ps2RecompiledFunctionTable[516012] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7eb8 - g_ps2RecompiledFunctionTable[516013] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7ebc - g_ps2RecompiledFunctionTable[516014] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7ec0 - g_ps2RecompiledFunctionTable[516015] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7ec4 - g_ps2RecompiledFunctionTable[516016] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7ec8 - g_ps2RecompiledFunctionTable[516017] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7ecc - g_ps2RecompiledFunctionTable[516018] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7ed0 - g_ps2RecompiledFunctionTable[516019] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7ed4 - g_ps2RecompiledFunctionTable[516020] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7ed8 - g_ps2RecompiledFunctionTable[516021] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7edc - g_ps2RecompiledFunctionTable[516022] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7ee0 - g_ps2RecompiledFunctionTable[516023] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7ee4 - g_ps2RecompiledFunctionTable[516024] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7ee8 - g_ps2RecompiledFunctionTable[516025] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7eec - g_ps2RecompiledFunctionTable[516026] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7ef0 - g_ps2RecompiledFunctionTable[516027] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7ef4 - g_ps2RecompiledFunctionTable[516028] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7ef8 - g_ps2RecompiledFunctionTable[516029] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7efc - g_ps2RecompiledFunctionTable[516030] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7f00 - g_ps2RecompiledFunctionTable[516031] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7f04 - g_ps2RecompiledFunctionTable[516032] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7f08 - g_ps2RecompiledFunctionTable[516033] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7f0c - g_ps2RecompiledFunctionTable[516034] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7f10 - g_ps2RecompiledFunctionTable[516035] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7f14 - g_ps2RecompiledFunctionTable[516036] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7f18 - g_ps2RecompiledFunctionTable[516037] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7f1c - g_ps2RecompiledFunctionTable[516038] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7f20 - g_ps2RecompiledFunctionTable[516039] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7f24 - g_ps2RecompiledFunctionTable[516040] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7f28 - g_ps2RecompiledFunctionTable[516041] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7f2c - g_ps2RecompiledFunctionTable[516042] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7f30 - g_ps2RecompiledFunctionTable[516043] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7f34 - g_ps2RecompiledFunctionTable[516044] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7f38 - g_ps2RecompiledFunctionTable[516045] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7f3c - g_ps2RecompiledFunctionTable[516046] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7f40 - g_ps2RecompiledFunctionTable[516047] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7f44 - g_ps2RecompiledFunctionTable[516048] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7f48 - g_ps2RecompiledFunctionTable[516049] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7f4c - g_ps2RecompiledFunctionTable[516050] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7f50 - g_ps2RecompiledFunctionTable[516051] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7f54 - g_ps2RecompiledFunctionTable[516052] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7f58 - g_ps2RecompiledFunctionTable[516053] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7f5c - g_ps2RecompiledFunctionTable[516054] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7f60 - g_ps2RecompiledFunctionTable[516055] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7f64 - g_ps2RecompiledFunctionTable[516056] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7f68 - g_ps2RecompiledFunctionTable[516057] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7f6c - g_ps2RecompiledFunctionTable[516058] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7f70 - g_ps2RecompiledFunctionTable[516059] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7f74 - g_ps2RecompiledFunctionTable[516060] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7f78 - g_ps2RecompiledFunctionTable[516061] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7f7c - g_ps2RecompiledFunctionTable[516062] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7f80 - g_ps2RecompiledFunctionTable[516063] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7f84 - g_ps2RecompiledFunctionTable[516064] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7f88 - g_ps2RecompiledFunctionTable[516065] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7f8c - g_ps2RecompiledFunctionTable[516066] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7f90 - g_ps2RecompiledFunctionTable[516067] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7f94 - g_ps2RecompiledFunctionTable[516068] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7f98 - g_ps2RecompiledFunctionTable[516069] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7f9c - g_ps2RecompiledFunctionTable[516070] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7fa0 - g_ps2RecompiledFunctionTable[516071] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7fa4 - g_ps2RecompiledFunctionTable[516072] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7fa8 - g_ps2RecompiledFunctionTable[516073] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7fac - g_ps2RecompiledFunctionTable[516074] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7fb0 - g_ps2RecompiledFunctionTable[516075] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7fb4 - g_ps2RecompiledFunctionTable[516076] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7fb8 - g_ps2RecompiledFunctionTable[516077] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7fbc - g_ps2RecompiledFunctionTable[516078] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7fc0 - g_ps2RecompiledFunctionTable[516079] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7fc4 - g_ps2RecompiledFunctionTable[516080] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7fc8 - g_ps2RecompiledFunctionTable[516081] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7fcc - g_ps2RecompiledFunctionTable[516082] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7fd0 - g_ps2RecompiledFunctionTable[516083] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7fd4 - g_ps2RecompiledFunctionTable[516084] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7fd8 - g_ps2RecompiledFunctionTable[516085] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7fdc - g_ps2RecompiledFunctionTable[516086] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7fe0 - g_ps2RecompiledFunctionTable[516087] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7fe4 - g_ps2RecompiledFunctionTable[516088] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7fe8 - g_ps2RecompiledFunctionTable[516089] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7fec - g_ps2RecompiledFunctionTable[516090] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7ff0 - g_ps2RecompiledFunctionTable[516091] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7ff4 - g_ps2RecompiledFunctionTable[516092] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7ff8 - g_ps2RecompiledFunctionTable[516093] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f7ffc - g_ps2RecompiledFunctionTable[516094] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f8000 - g_ps2RecompiledFunctionTable[516095] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f8004 - g_ps2RecompiledFunctionTable[516096] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f8008 - g_ps2RecompiledFunctionTable[516097] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f800c - g_ps2RecompiledFunctionTable[516098] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f8010 - g_ps2RecompiledFunctionTable[516099] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f8014 - g_ps2RecompiledFunctionTable[516100] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f8018 - g_ps2RecompiledFunctionTable[516101] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f801c - g_ps2RecompiledFunctionTable[516102] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f8020 - g_ps2RecompiledFunctionTable[516103] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f8024 - g_ps2RecompiledFunctionTable[516104] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f8028 - g_ps2RecompiledFunctionTable[516105] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f802c - g_ps2RecompiledFunctionTable[516106] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f8030 - g_ps2RecompiledFunctionTable[516107] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f8034 - g_ps2RecompiledFunctionTable[516108] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f8038 - g_ps2RecompiledFunctionTable[516109] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f803c - g_ps2RecompiledFunctionTable[516110] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f8040 - g_ps2RecompiledFunctionTable[516111] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f8044 - g_ps2RecompiledFunctionTable[516112] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f8048 - g_ps2RecompiledFunctionTable[516113] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f804c - g_ps2RecompiledFunctionTable[516114] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f8050 - g_ps2RecompiledFunctionTable[516115] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f8054 - g_ps2RecompiledFunctionTable[516116] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f8058 - g_ps2RecompiledFunctionTable[516117] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f805c - g_ps2RecompiledFunctionTable[516118] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f8060 - g_ps2RecompiledFunctionTable[516119] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f8064 - g_ps2RecompiledFunctionTable[516120] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f8068 - g_ps2RecompiledFunctionTable[516121] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f806c - g_ps2RecompiledFunctionTable[516122] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f8070 - g_ps2RecompiledFunctionTable[516123] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f8074 - g_ps2RecompiledFunctionTable[516124] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f8078 - g_ps2RecompiledFunctionTable[516125] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f807c - g_ps2RecompiledFunctionTable[516126] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f8080 - g_ps2RecompiledFunctionTable[516127] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f8084 - g_ps2RecompiledFunctionTable[516128] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f8088 - g_ps2RecompiledFunctionTable[516129] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f808c - g_ps2RecompiledFunctionTable[516130] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f8090 - g_ps2RecompiledFunctionTable[516131] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f8094 - g_ps2RecompiledFunctionTable[516132] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f8098 - g_ps2RecompiledFunctionTable[516133] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f809c - g_ps2RecompiledFunctionTable[516134] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f80a0 - g_ps2RecompiledFunctionTable[516135] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f80a4 - g_ps2RecompiledFunctionTable[516136] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f80a8 - g_ps2RecompiledFunctionTable[516137] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f80ac - g_ps2RecompiledFunctionTable[516138] = adxt_nlp_trap_entry_0x2f7df8; // 0x2f80b0 - g_ps2RecompiledFunctionTable[516140] = adxt_stat_decinfo_0x2f80b8; // 0x2f80b8 - g_ps2RecompiledFunctionTable[516152] = adxt_stat_decinfo_0x2f80b8; // 0x2f80e8 - g_ps2RecompiledFunctionTable[516157] = adxt_stat_decinfo_0x2f80b8; // 0x2f80fc - g_ps2RecompiledFunctionTable[516165] = adxt_stat_decinfo_0x2f80b8; // 0x2f811c - g_ps2RecompiledFunctionTable[516169] = adxt_stat_decinfo_0x2f80b8; // 0x2f812c - g_ps2RecompiledFunctionTable[516171] = adxt_stat_decinfo_0x2f80b8; // 0x2f8134 - g_ps2RecompiledFunctionTable[516175] = adxt_stat_decinfo_0x2f80b8; // 0x2f8144 - g_ps2RecompiledFunctionTable[516178] = adxt_stat_decinfo_0x2f80b8; // 0x2f8150 - g_ps2RecompiledFunctionTable[516202] = adxt_stat_decinfo_0x2f80b8; // 0x2f81b0 - g_ps2RecompiledFunctionTable[516214] = adxt_stat_decinfo_0x2f80b8; // 0x2f81e0 - g_ps2RecompiledFunctionTable[516223] = adxt_stat_decinfo_0x2f80b8; // 0x2f8204 - g_ps2RecompiledFunctionTable[516238] = adxt_stat_decinfo_0x2f80b8; // 0x2f8240 - g_ps2RecompiledFunctionTable[516243] = adxt_stat_decinfo_0x2f80b8; // 0x2f8254 - g_ps2RecompiledFunctionTable[516245] = adxt_stat_decinfo_0x2f80b8; // 0x2f825c - g_ps2RecompiledFunctionTable[516249] = adxt_stat_decinfo_0x2f80b8; // 0x2f826c - g_ps2RecompiledFunctionTable[516252] = adxt_stat_decinfo_0x2f80b8; // 0x2f8278 - g_ps2RecompiledFunctionTable[516255] = adxt_stat_decinfo_0x2f80b8; // 0x2f8284 - g_ps2RecompiledFunctionTable[516260] = adxt_stat_decinfo_0x2f80b8; // 0x2f8298 - g_ps2RecompiledFunctionTable[516268] = adxt_stat_decinfo_0x2f80b8; // 0x2f82b8 - g_ps2RecompiledFunctionTable[516270] = adxt_stat_decinfo_0x2f80b8; // 0x2f82c0 - g_ps2RecompiledFunctionTable[516273] = adxt_stat_decinfo_0x2f80b8; // 0x2f82cc - g_ps2RecompiledFunctionTable[516276] = adxt_stat_decinfo_0x2f80b8; // 0x2f82d8 - g_ps2RecompiledFunctionTable[516279] = adxt_stat_decinfo_0x2f80b8; // 0x2f82e4 - g_ps2RecompiledFunctionTable[516284] = adxt_stat_decinfo_0x2f80b8; // 0x2f82f8 - g_ps2RecompiledFunctionTable[516286] = adxt_stat_decinfo_0x2f80b8; // 0x2f8300 - g_ps2RecompiledFunctionTable[516289] = adxt_stat_decinfo_0x2f80b8; // 0x2f830c - g_ps2RecompiledFunctionTable[516292] = adxt_stat_decinfo_0x2f80b8; // 0x2f8318 - g_ps2RecompiledFunctionTable[516295] = adxt_stat_decinfo_0x2f80b8; // 0x2f8324 - g_ps2RecompiledFunctionTable[516298] = adxt_stat_decinfo_0x2f80b8; // 0x2f8330 - g_ps2RecompiledFunctionTable[516301] = adxt_stat_decinfo_0x2f80b8; // 0x2f833c - g_ps2RecompiledFunctionTable[516304] = adxt_stat_decinfo_0x2f80b8; // 0x2f8348 - g_ps2RecompiledFunctionTable[516307] = adxt_stat_decinfo_0x2f80b8; // 0x2f8354 - g_ps2RecompiledFunctionTable[516310] = adxt_stat_decinfo_0x2f80b8; // 0x2f8360 - g_ps2RecompiledFunctionTable[516312] = adxt_stat_decinfo_0x2f80b8; // 0x2f8368 - g_ps2RecompiledFunctionTable[516317] = adxt_stat_decinfo_0x2f80b8; // 0x2f837c - g_ps2RecompiledFunctionTable[516320] = adxt_stat_decinfo_0x2f80b8; // 0x2f8388 - g_ps2RecompiledFunctionTable[516324] = adxt_stat_decinfo_0x2f80b8; // 0x2f8398 - g_ps2RecompiledFunctionTable[516327] = adxt_stat_decinfo_0x2f80b8; // 0x2f83a4 - g_ps2RecompiledFunctionTable[516330] = adxt_stat_decinfo_0x2f80b8; // 0x2f83b0 - g_ps2RecompiledFunctionTable[516340] = adxt_stat_prep_0x2f83d8; // 0x2f83d8 - g_ps2RecompiledFunctionTable[516341] = adxt_stat_prep_0x2f83d8; // 0x2f83dc - g_ps2RecompiledFunctionTable[516342] = adxt_stat_prep_0x2f83d8; // 0x2f83e0 - g_ps2RecompiledFunctionTable[516343] = adxt_stat_prep_0x2f83d8; // 0x2f83e4 - g_ps2RecompiledFunctionTable[516344] = adxt_stat_prep_0x2f83d8; // 0x2f83e8 - g_ps2RecompiledFunctionTable[516345] = adxt_stat_prep_0x2f83d8; // 0x2f83ec - g_ps2RecompiledFunctionTable[516346] = adxt_stat_prep_0x2f83d8; // 0x2f83f0 - g_ps2RecompiledFunctionTable[516347] = adxt_stat_prep_0x2f83d8; // 0x2f83f4 - g_ps2RecompiledFunctionTable[516348] = adxt_stat_prep_0x2f83d8; // 0x2f83f8 - g_ps2RecompiledFunctionTable[516349] = adxt_stat_prep_0x2f83d8; // 0x2f83fc - g_ps2RecompiledFunctionTable[516350] = adxt_stat_prep_0x2f83d8; // 0x2f8400 - g_ps2RecompiledFunctionTable[516351] = adxt_stat_prep_0x2f83d8; // 0x2f8404 - g_ps2RecompiledFunctionTable[516352] = adxt_stat_prep_0x2f83d8; // 0x2f8408 - g_ps2RecompiledFunctionTable[516353] = adxt_stat_prep_0x2f83d8; // 0x2f840c - g_ps2RecompiledFunctionTable[516354] = adxt_stat_prep_0x2f83d8; // 0x2f8410 - g_ps2RecompiledFunctionTable[516355] = adxt_stat_prep_0x2f83d8; // 0x2f8414 - g_ps2RecompiledFunctionTable[516356] = adxt_stat_prep_0x2f83d8; // 0x2f8418 - g_ps2RecompiledFunctionTable[516357] = adxt_stat_prep_0x2f83d8; // 0x2f841c - g_ps2RecompiledFunctionTable[516358] = adxt_stat_prep_0x2f83d8; // 0x2f8420 - g_ps2RecompiledFunctionTable[516359] = adxt_stat_prep_0x2f83d8; // 0x2f8424 - g_ps2RecompiledFunctionTable[516360] = adxt_stat_prep_0x2f83d8; // 0x2f8428 - g_ps2RecompiledFunctionTable[516361] = adxt_stat_prep_0x2f83d8; // 0x2f842c - g_ps2RecompiledFunctionTable[516362] = adxt_stat_prep_0x2f83d8; // 0x2f8430 - g_ps2RecompiledFunctionTable[516363] = adxt_stat_prep_0x2f83d8; // 0x2f8434 - g_ps2RecompiledFunctionTable[516364] = adxt_stat_prep_0x2f83d8; // 0x2f8438 - g_ps2RecompiledFunctionTable[516365] = adxt_stat_prep_0x2f83d8; // 0x2f843c - g_ps2RecompiledFunctionTable[516366] = adxt_stat_prep_0x2f83d8; // 0x2f8440 - g_ps2RecompiledFunctionTable[516367] = adxt_stat_prep_0x2f83d8; // 0x2f8444 - g_ps2RecompiledFunctionTable[516368] = adxt_stat_prep_0x2f83d8; // 0x2f8448 - g_ps2RecompiledFunctionTable[516369] = adxt_stat_prep_0x2f83d8; // 0x2f844c - g_ps2RecompiledFunctionTable[516370] = adxt_stat_prep_0x2f83d8; // 0x2f8450 - g_ps2RecompiledFunctionTable[516371] = adxt_stat_prep_0x2f83d8; // 0x2f8454 - g_ps2RecompiledFunctionTable[516372] = adxt_stat_prep_0x2f83d8; // 0x2f8458 - g_ps2RecompiledFunctionTable[516373] = adxt_stat_prep_0x2f83d8; // 0x2f845c - g_ps2RecompiledFunctionTable[516374] = adxt_stat_prep_0x2f83d8; // 0x2f8460 - g_ps2RecompiledFunctionTable[516375] = adxt_stat_prep_0x2f83d8; // 0x2f8464 - g_ps2RecompiledFunctionTable[516376] = adxt_stat_prep_0x2f83d8; // 0x2f8468 - g_ps2RecompiledFunctionTable[516377] = adxt_stat_prep_0x2f83d8; // 0x2f846c - g_ps2RecompiledFunctionTable[516378] = adxt_stat_prep_0x2f83d8; // 0x2f8470 - g_ps2RecompiledFunctionTable[516379] = adxt_stat_prep_0x2f83d8; // 0x2f8474 - g_ps2RecompiledFunctionTable[516380] = adxt_stat_prep_0x2f83d8; // 0x2f8478 - g_ps2RecompiledFunctionTable[516381] = adxt_stat_prep_0x2f83d8; // 0x2f847c - g_ps2RecompiledFunctionTable[516382] = adxt_stat_prep_0x2f83d8; // 0x2f8480 - g_ps2RecompiledFunctionTable[516383] = adxt_stat_prep_0x2f83d8; // 0x2f8484 - g_ps2RecompiledFunctionTable[516384] = adxt_stat_prep_0x2f83d8; // 0x2f8488 - g_ps2RecompiledFunctionTable[516385] = adxt_stat_prep_0x2f83d8; // 0x2f848c - g_ps2RecompiledFunctionTable[516386] = adxt_stat_prep_0x2f83d8; // 0x2f8490 - g_ps2RecompiledFunctionTable[516387] = adxt_stat_prep_0x2f83d8; // 0x2f8494 - g_ps2RecompiledFunctionTable[516388] = adxt_stat_prep_0x2f83d8; // 0x2f8498 - g_ps2RecompiledFunctionTable[516389] = adxt_stat_prep_0x2f83d8; // 0x2f849c - g_ps2RecompiledFunctionTable[516390] = adxt_stat_prep_0x2f83d8; // 0x2f84a0 - g_ps2RecompiledFunctionTable[516391] = adxt_stat_prep_0x2f83d8; // 0x2f84a4 - g_ps2RecompiledFunctionTable[516392] = adxt_stat_prep_0x2f83d8; // 0x2f84a8 - g_ps2RecompiledFunctionTable[516393] = adxt_stat_prep_0x2f83d8; // 0x2f84ac - g_ps2RecompiledFunctionTable[516394] = adxt_stat_prep_0x2f83d8; // 0x2f84b0 - g_ps2RecompiledFunctionTable[516395] = adxt_stat_prep_0x2f83d8; // 0x2f84b4 - g_ps2RecompiledFunctionTable[516396] = adxt_stat_prep_0x2f83d8; // 0x2f84b8 - g_ps2RecompiledFunctionTable[516397] = adxt_stat_prep_0x2f83d8; // 0x2f84bc - g_ps2RecompiledFunctionTable[516398] = adxt_stat_prep_0x2f83d8; // 0x2f84c0 - g_ps2RecompiledFunctionTable[516399] = adxt_stat_prep_0x2f83d8; // 0x2f84c4 - g_ps2RecompiledFunctionTable[516400] = adxt_stat_prep_0x2f83d8; // 0x2f84c8 - g_ps2RecompiledFunctionTable[516401] = adxt_stat_prep_0x2f83d8; // 0x2f84cc - g_ps2RecompiledFunctionTable[516402] = adxt_stat_prep_0x2f83d8; // 0x2f84d0 - g_ps2RecompiledFunctionTable[516403] = adxt_stat_prep_0x2f83d8; // 0x2f84d4 - g_ps2RecompiledFunctionTable[516404] = adxt_stat_prep_0x2f83d8; // 0x2f84d8 - g_ps2RecompiledFunctionTable[516405] = adxt_stat_prep_0x2f83d8; // 0x2f84dc - g_ps2RecompiledFunctionTable[516406] = adxt_stat_prep_0x2f83d8; // 0x2f84e0 - g_ps2RecompiledFunctionTable[516407] = adxt_stat_prep_0x2f83d8; // 0x2f84e4 - g_ps2RecompiledFunctionTable[516408] = adxt_stat_prep_0x2f83d8; // 0x2f84e8 - g_ps2RecompiledFunctionTable[516409] = adxt_stat_prep_0x2f83d8; // 0x2f84ec - g_ps2RecompiledFunctionTable[516410] = adxt_stat_prep_0x2f83d8; // 0x2f84f0 - g_ps2RecompiledFunctionTable[516411] = adxt_stat_prep_0x2f83d8; // 0x2f84f4 - g_ps2RecompiledFunctionTable[516412] = adxt_stat_prep_0x2f83d8; // 0x2f84f8 - g_ps2RecompiledFunctionTable[516413] = adxt_stat_prep_0x2f83d8; // 0x2f84fc - g_ps2RecompiledFunctionTable[516414] = adxt_stat_prep_0x2f83d8; // 0x2f8500 - g_ps2RecompiledFunctionTable[516415] = adxt_stat_prep_0x2f83d8; // 0x2f8504 - g_ps2RecompiledFunctionTable[516416] = adxt_stat_prep_0x2f83d8; // 0x2f8508 - g_ps2RecompiledFunctionTable[516417] = adxt_stat_prep_0x2f83d8; // 0x2f850c - g_ps2RecompiledFunctionTable[516418] = adxt_stat_prep_0x2f83d8; // 0x2f8510 - g_ps2RecompiledFunctionTable[516419] = adxt_stat_prep_0x2f83d8; // 0x2f8514 - g_ps2RecompiledFunctionTable[516420] = adxt_stat_prep_0x2f83d8; // 0x2f8518 - g_ps2RecompiledFunctionTable[516421] = adxt_stat_prep_0x2f83d8; // 0x2f851c - g_ps2RecompiledFunctionTable[516422] = adxt_stat_prep_0x2f83d8; // 0x2f8520 - g_ps2RecompiledFunctionTable[516423] = adxt_stat_prep_0x2f83d8; // 0x2f8524 - g_ps2RecompiledFunctionTable[516424] = adxt_stat_prep_0x2f83d8; // 0x2f8528 - g_ps2RecompiledFunctionTable[516425] = adxt_stat_prep_0x2f83d8; // 0x2f852c - g_ps2RecompiledFunctionTable[516426] = adxt_stat_prep_0x2f83d8; // 0x2f8530 - g_ps2RecompiledFunctionTable[516427] = adxt_stat_prep_0x2f83d8; // 0x2f8534 - g_ps2RecompiledFunctionTable[516428] = adxt_stat_prep_0x2f83d8; // 0x2f8538 - g_ps2RecompiledFunctionTable[516429] = adxt_stat_prep_0x2f83d8; // 0x2f853c - g_ps2RecompiledFunctionTable[516430] = adxt_stat_prep_0x2f83d8; // 0x2f8540 - g_ps2RecompiledFunctionTable[516431] = adxt_stat_prep_0x2f83d8; // 0x2f8544 - g_ps2RecompiledFunctionTable[516432] = adxt_stat_prep_0x2f83d8; // 0x2f8548 - g_ps2RecompiledFunctionTable[516434] = adxt_stat_playing_0x2f8550; // 0x2f8550 - g_ps2RecompiledFunctionTable[516435] = adxt_stat_playing_0x2f8550; // 0x2f8554 - g_ps2RecompiledFunctionTable[516436] = adxt_stat_playing_0x2f8550; // 0x2f8558 - g_ps2RecompiledFunctionTable[516437] = adxt_stat_playing_0x2f8550; // 0x2f855c - g_ps2RecompiledFunctionTable[516438] = adxt_stat_playing_0x2f8550; // 0x2f8560 - g_ps2RecompiledFunctionTable[516439] = adxt_stat_playing_0x2f8550; // 0x2f8564 - g_ps2RecompiledFunctionTable[516440] = adxt_stat_playing_0x2f8550; // 0x2f8568 - g_ps2RecompiledFunctionTable[516441] = adxt_stat_playing_0x2f8550; // 0x2f856c - g_ps2RecompiledFunctionTable[516442] = adxt_stat_playing_0x2f8550; // 0x2f8570 - g_ps2RecompiledFunctionTable[516443] = adxt_stat_playing_0x2f8550; // 0x2f8574 - g_ps2RecompiledFunctionTable[516444] = adxt_stat_playing_0x2f8550; // 0x2f8578 - g_ps2RecompiledFunctionTable[516445] = adxt_stat_playing_0x2f8550; // 0x2f857c - g_ps2RecompiledFunctionTable[516446] = adxt_stat_playing_0x2f8550; // 0x2f8580 - g_ps2RecompiledFunctionTable[516447] = adxt_stat_playing_0x2f8550; // 0x2f8584 - g_ps2RecompiledFunctionTable[516448] = adxt_stat_playing_0x2f8550; // 0x2f8588 - g_ps2RecompiledFunctionTable[516449] = adxt_stat_playing_0x2f8550; // 0x2f858c - g_ps2RecompiledFunctionTable[516450] = adxt_stat_playing_0x2f8550; // 0x2f8590 - g_ps2RecompiledFunctionTable[516451] = adxt_stat_playing_0x2f8550; // 0x2f8594 - g_ps2RecompiledFunctionTable[516452] = adxt_stat_playing_0x2f8550; // 0x2f8598 - g_ps2RecompiledFunctionTable[516453] = adxt_stat_playing_0x2f8550; // 0x2f859c - g_ps2RecompiledFunctionTable[516454] = adxt_stat_playing_0x2f8550; // 0x2f85a0 - g_ps2RecompiledFunctionTable[516455] = adxt_stat_playing_0x2f8550; // 0x2f85a4 - g_ps2RecompiledFunctionTable[516456] = adxt_stat_playing_0x2f8550; // 0x2f85a8 - g_ps2RecompiledFunctionTable[516457] = adxt_stat_playing_0x2f8550; // 0x2f85ac - g_ps2RecompiledFunctionTable[516458] = adxt_stat_playing_0x2f8550; // 0x2f85b0 - g_ps2RecompiledFunctionTable[516459] = adxt_stat_playing_0x2f8550; // 0x2f85b4 - g_ps2RecompiledFunctionTable[516460] = adxt_stat_playing_0x2f8550; // 0x2f85b8 - g_ps2RecompiledFunctionTable[516461] = adxt_stat_playing_0x2f8550; // 0x2f85bc - g_ps2RecompiledFunctionTable[516462] = adxt_stat_playing_0x2f8550; // 0x2f85c0 - g_ps2RecompiledFunctionTable[516463] = adxt_stat_playing_0x2f8550; // 0x2f85c4 - g_ps2RecompiledFunctionTable[516464] = adxt_stat_playing_0x2f8550; // 0x2f85c8 - g_ps2RecompiledFunctionTable[516465] = adxt_stat_playing_0x2f8550; // 0x2f85cc - g_ps2RecompiledFunctionTable[516466] = adxt_stat_playing_0x2f8550; // 0x2f85d0 - g_ps2RecompiledFunctionTable[516467] = adxt_stat_playing_0x2f8550; // 0x2f85d4 - g_ps2RecompiledFunctionTable[516468] = adxt_stat_playing_0x2f8550; // 0x2f85d8 - g_ps2RecompiledFunctionTable[516469] = adxt_stat_playing_0x2f8550; // 0x2f85dc - g_ps2RecompiledFunctionTable[516470] = adxt_stat_playing_0x2f8550; // 0x2f85e0 - g_ps2RecompiledFunctionTable[516471] = adxt_stat_playing_0x2f8550; // 0x2f85e4 - g_ps2RecompiledFunctionTable[516472] = adxt_stat_playing_0x2f8550; // 0x2f85e8 - g_ps2RecompiledFunctionTable[516473] = adxt_stat_playing_0x2f8550; // 0x2f85ec - g_ps2RecompiledFunctionTable[516474] = adxt_stat_playing_0x2f8550; // 0x2f85f0 - g_ps2RecompiledFunctionTable[516475] = adxt_stat_playing_0x2f8550; // 0x2f85f4 - g_ps2RecompiledFunctionTable[516476] = adxt_stat_playing_0x2f8550; // 0x2f85f8 - g_ps2RecompiledFunctionTable[516477] = adxt_stat_playing_0x2f8550; // 0x2f85fc - g_ps2RecompiledFunctionTable[516478] = adxt_stat_playing_0x2f8550; // 0x2f8600 - g_ps2RecompiledFunctionTable[516479] = adxt_stat_playing_0x2f8550; // 0x2f8604 - g_ps2RecompiledFunctionTable[516480] = adxt_stat_playing_0x2f8550; // 0x2f8608 - g_ps2RecompiledFunctionTable[516481] = adxt_stat_playing_0x2f8550; // 0x2f860c - g_ps2RecompiledFunctionTable[516482] = adxt_stat_playing_0x2f8550; // 0x2f8610 - g_ps2RecompiledFunctionTable[516483] = adxt_stat_playing_0x2f8550; // 0x2f8614 - g_ps2RecompiledFunctionTable[516484] = adxt_stat_playing_0x2f8550; // 0x2f8618 - g_ps2RecompiledFunctionTable[516486] = adxt_stat_decend_0x2f8620; // 0x2f8620 - g_ps2RecompiledFunctionTable[516492] = adxt_stat_decend_0x2f8620; // 0x2f8638 - g_ps2RecompiledFunctionTable[516495] = adxt_stat_decend_0x2f8620; // 0x2f8644 - g_ps2RecompiledFunctionTable[516500] = adxt_stat_decend_0x2f8620; // 0x2f8658 - g_ps2RecompiledFunctionTable[516506] = adxt_stat_playend_0x2f8670; // 0x2f8670 - g_ps2RecompiledFunctionTable[516508] = adxt_RcvrReplay_0x2f8678; // 0x2f8678 - g_ps2RecompiledFunctionTable[516509] = adxt_RcvrReplay_0x2f8678; // 0x2f867c - g_ps2RecompiledFunctionTable[516510] = adxt_RcvrReplay_0x2f8678; // 0x2f8680 - g_ps2RecompiledFunctionTable[516511] = adxt_RcvrReplay_0x2f8678; // 0x2f8684 - g_ps2RecompiledFunctionTable[516512] = adxt_RcvrReplay_0x2f8678; // 0x2f8688 - g_ps2RecompiledFunctionTable[516513] = adxt_RcvrReplay_0x2f8678; // 0x2f868c - g_ps2RecompiledFunctionTable[516514] = adxt_RcvrReplay_0x2f8678; // 0x2f8690 - g_ps2RecompiledFunctionTable[516515] = adxt_RcvrReplay_0x2f8678; // 0x2f8694 - g_ps2RecompiledFunctionTable[516516] = adxt_RcvrReplay_0x2f8678; // 0x2f8698 - g_ps2RecompiledFunctionTable[516517] = adxt_RcvrReplay_0x2f8678; // 0x2f869c - g_ps2RecompiledFunctionTable[516518] = adxt_RcvrReplay_0x2f8678; // 0x2f86a0 - g_ps2RecompiledFunctionTable[516519] = adxt_RcvrReplay_0x2f8678; // 0x2f86a4 - g_ps2RecompiledFunctionTable[516520] = adxt_RcvrReplay_0x2f8678; // 0x2f86a8 - g_ps2RecompiledFunctionTable[516521] = adxt_RcvrReplay_0x2f8678; // 0x2f86ac - g_ps2RecompiledFunctionTable[516522] = adxt_RcvrReplay_0x2f8678; // 0x2f86b0 - g_ps2RecompiledFunctionTable[516523] = adxt_RcvrReplay_0x2f8678; // 0x2f86b4 - g_ps2RecompiledFunctionTable[516524] = adxt_RcvrReplay_0x2f8678; // 0x2f86b8 - g_ps2RecompiledFunctionTable[516525] = adxt_RcvrReplay_0x2f8678; // 0x2f86bc - g_ps2RecompiledFunctionTable[516526] = adxt_RcvrReplay_0x2f8678; // 0x2f86c0 - g_ps2RecompiledFunctionTable[516527] = adxt_RcvrReplay_0x2f8678; // 0x2f86c4 - g_ps2RecompiledFunctionTable[516528] = adxt_RcvrReplay_0x2f8678; // 0x2f86c8 - g_ps2RecompiledFunctionTable[516529] = adxt_RcvrReplay_0x2f8678; // 0x2f86cc - g_ps2RecompiledFunctionTable[516530] = adxt_RcvrReplay_0x2f8678; // 0x2f86d0 - g_ps2RecompiledFunctionTable[516531] = adxt_RcvrReplay_0x2f8678; // 0x2f86d4 - g_ps2RecompiledFunctionTable[516532] = adxt_RcvrReplay_0x2f8678; // 0x2f86d8 - g_ps2RecompiledFunctionTable[516533] = adxt_RcvrReplay_0x2f8678; // 0x2f86dc - g_ps2RecompiledFunctionTable[516534] = adxt_RcvrReplay_0x2f8678; // 0x2f86e0 - g_ps2RecompiledFunctionTable[516535] = adxt_RcvrReplay_0x2f8678; // 0x2f86e4 - g_ps2RecompiledFunctionTable[516536] = adxt_RcvrReplay_0x2f8678; // 0x2f86e8 - g_ps2RecompiledFunctionTable[516537] = adxt_RcvrReplay_0x2f8678; // 0x2f86ec - g_ps2RecompiledFunctionTable[516538] = adxt_RcvrReplay_0x2f8678; // 0x2f86f0 - g_ps2RecompiledFunctionTable[516539] = adxt_RcvrReplay_0x2f8678; // 0x2f86f4 - g_ps2RecompiledFunctionTable[516540] = adxt_RcvrReplay_0x2f8678; // 0x2f86f8 - g_ps2RecompiledFunctionTable[516541] = adxt_RcvrReplay_0x2f8678; // 0x2f86fc - g_ps2RecompiledFunctionTable[516542] = adxt_RcvrReplay_0x2f8678; // 0x2f8700 - g_ps2RecompiledFunctionTable[516543] = adxt_RcvrReplay_0x2f8678; // 0x2f8704 - g_ps2RecompiledFunctionTable[516544] = adxt_RcvrReplay_0x2f8678; // 0x2f8708 - g_ps2RecompiledFunctionTable[516545] = adxt_RcvrReplay_0x2f8678; // 0x2f870c - g_ps2RecompiledFunctionTable[516546] = adxt_RcvrReplay_0x2f8678; // 0x2f8710 - g_ps2RecompiledFunctionTable[516547] = adxt_RcvrReplay_0x2f8678; // 0x2f8714 - g_ps2RecompiledFunctionTable[516548] = adxt_RcvrReplay_0x2f8678; // 0x2f8718 - g_ps2RecompiledFunctionTable[516549] = adxt_RcvrReplay_0x2f8678; // 0x2f871c - g_ps2RecompiledFunctionTable[516550] = adxt_RcvrReplay_0x2f8678; // 0x2f8720 - g_ps2RecompiledFunctionTable[516551] = adxt_RcvrReplay_0x2f8678; // 0x2f8724 - g_ps2RecompiledFunctionTable[516552] = adxt_RcvrReplay_0x2f8678; // 0x2f8728 - g_ps2RecompiledFunctionTable[516553] = adxt_RcvrReplay_0x2f8678; // 0x2f872c - g_ps2RecompiledFunctionTable[516554] = adxt_RcvrReplay_0x2f8678; // 0x2f8730 - g_ps2RecompiledFunctionTable[516555] = adxt_RcvrReplay_0x2f8678; // 0x2f8734 - g_ps2RecompiledFunctionTable[516556] = adxt_RcvrReplay_0x2f8678; // 0x2f8738 - g_ps2RecompiledFunctionTable[516557] = adxt_RcvrReplay_0x2f8678; // 0x2f873c - g_ps2RecompiledFunctionTable[516558] = adxt_RcvrReplay_0x2f8678; // 0x2f8740 - g_ps2RecompiledFunctionTable[516559] = adxt_RcvrReplay_0x2f8678; // 0x2f8744 - g_ps2RecompiledFunctionTable[516560] = adxt_RcvrReplay_0x2f8678; // 0x2f8748 - g_ps2RecompiledFunctionTable[516561] = adxt_RcvrReplay_0x2f8678; // 0x2f874c - g_ps2RecompiledFunctionTable[516562] = adxt_RcvrReplay_0x2f8678; // 0x2f8750 - g_ps2RecompiledFunctionTable[516563] = adxt_RcvrReplay_0x2f8678; // 0x2f8754 - g_ps2RecompiledFunctionTable[516564] = ADXT_ExecErrChk_0x2f8758; // 0x2f8758 - g_ps2RecompiledFunctionTable[516565] = ADXT_ExecErrChk_0x2f8758; // 0x2f875c - g_ps2RecompiledFunctionTable[516566] = ADXT_ExecErrChk_0x2f8758; // 0x2f8760 - g_ps2RecompiledFunctionTable[516567] = ADXT_ExecErrChk_0x2f8758; // 0x2f8764 - g_ps2RecompiledFunctionTable[516568] = ADXT_ExecErrChk_0x2f8758; // 0x2f8768 - g_ps2RecompiledFunctionTable[516569] = ADXT_ExecErrChk_0x2f8758; // 0x2f876c - g_ps2RecompiledFunctionTable[516570] = ADXT_ExecErrChk_0x2f8758; // 0x2f8770 - g_ps2RecompiledFunctionTable[516571] = ADXT_ExecErrChk_0x2f8758; // 0x2f8774 - g_ps2RecompiledFunctionTable[516572] = ADXT_ExecErrChk_0x2f8758; // 0x2f8778 - g_ps2RecompiledFunctionTable[516573] = ADXT_ExecErrChk_0x2f8758; // 0x2f877c - g_ps2RecompiledFunctionTable[516574] = ADXT_ExecErrChk_0x2f8758; // 0x2f8780 - g_ps2RecompiledFunctionTable[516575] = ADXT_ExecErrChk_0x2f8758; // 0x2f8784 - g_ps2RecompiledFunctionTable[516576] = ADXT_ExecErrChk_0x2f8758; // 0x2f8788 - g_ps2RecompiledFunctionTable[516577] = ADXT_ExecErrChk_0x2f8758; // 0x2f878c - g_ps2RecompiledFunctionTable[516578] = ADXT_ExecErrChk_0x2f8758; // 0x2f8790 - g_ps2RecompiledFunctionTable[516579] = ADXT_ExecErrChk_0x2f8758; // 0x2f8794 - g_ps2RecompiledFunctionTable[516580] = ADXT_ExecErrChk_0x2f8758; // 0x2f8798 - g_ps2RecompiledFunctionTable[516581] = ADXT_ExecErrChk_0x2f8758; // 0x2f879c - g_ps2RecompiledFunctionTable[516582] = ADXT_ExecErrChk_0x2f8758; // 0x2f87a0 - g_ps2RecompiledFunctionTable[516583] = ADXT_ExecErrChk_0x2f8758; // 0x2f87a4 - g_ps2RecompiledFunctionTable[516584] = ADXT_ExecErrChk_0x2f8758; // 0x2f87a8 - g_ps2RecompiledFunctionTable[516585] = ADXT_ExecErrChk_0x2f8758; // 0x2f87ac - g_ps2RecompiledFunctionTable[516586] = ADXT_ExecErrChk_0x2f8758; // 0x2f87b0 - g_ps2RecompiledFunctionTable[516587] = ADXT_ExecErrChk_0x2f8758; // 0x2f87b4 - g_ps2RecompiledFunctionTable[516588] = ADXT_ExecErrChk_0x2f8758; // 0x2f87b8 - g_ps2RecompiledFunctionTable[516589] = ADXT_ExecErrChk_0x2f8758; // 0x2f87bc - g_ps2RecompiledFunctionTable[516590] = ADXT_ExecErrChk_0x2f8758; // 0x2f87c0 - g_ps2RecompiledFunctionTable[516591] = ADXT_ExecErrChk_0x2f8758; // 0x2f87c4 - g_ps2RecompiledFunctionTable[516592] = ADXT_ExecErrChk_0x2f8758; // 0x2f87c8 - g_ps2RecompiledFunctionTable[516593] = ADXT_ExecErrChk_0x2f8758; // 0x2f87cc - g_ps2RecompiledFunctionTable[516594] = ADXT_ExecErrChk_0x2f8758; // 0x2f87d0 - g_ps2RecompiledFunctionTable[516595] = ADXT_ExecErrChk_0x2f8758; // 0x2f87d4 - g_ps2RecompiledFunctionTable[516596] = ADXT_ExecErrChk_0x2f8758; // 0x2f87d8 - g_ps2RecompiledFunctionTable[516597] = ADXT_ExecErrChk_0x2f8758; // 0x2f87dc - g_ps2RecompiledFunctionTable[516598] = ADXT_ExecErrChk_0x2f8758; // 0x2f87e0 - g_ps2RecompiledFunctionTable[516599] = ADXT_ExecErrChk_0x2f8758; // 0x2f87e4 - g_ps2RecompiledFunctionTable[516600] = ADXT_ExecErrChk_0x2f8758; // 0x2f87e8 - g_ps2RecompiledFunctionTable[516601] = ADXT_ExecErrChk_0x2f8758; // 0x2f87ec - g_ps2RecompiledFunctionTable[516602] = ADXT_ExecErrChk_0x2f8758; // 0x2f87f0 - g_ps2RecompiledFunctionTable[516603] = ADXT_ExecErrChk_0x2f8758; // 0x2f87f4 - g_ps2RecompiledFunctionTable[516604] = ADXT_ExecErrChk_0x2f8758; // 0x2f87f8 - g_ps2RecompiledFunctionTable[516605] = ADXT_ExecErrChk_0x2f8758; // 0x2f87fc - g_ps2RecompiledFunctionTable[516606] = ADXT_ExecErrChk_0x2f8758; // 0x2f8800 - g_ps2RecompiledFunctionTable[516607] = ADXT_ExecErrChk_0x2f8758; // 0x2f8804 - g_ps2RecompiledFunctionTable[516608] = ADXT_ExecErrChk_0x2f8758; // 0x2f8808 - g_ps2RecompiledFunctionTable[516609] = ADXT_ExecErrChk_0x2f8758; // 0x2f880c - g_ps2RecompiledFunctionTable[516610] = ADXT_ExecErrChk_0x2f8758; // 0x2f8810 - g_ps2RecompiledFunctionTable[516611] = ADXT_ExecErrChk_0x2f8758; // 0x2f8814 - g_ps2RecompiledFunctionTable[516612] = ADXT_ExecErrChk_0x2f8758; // 0x2f8818 - g_ps2RecompiledFunctionTable[516613] = ADXT_ExecErrChk_0x2f8758; // 0x2f881c - g_ps2RecompiledFunctionTable[516614] = ADXT_ExecErrChk_0x2f8758; // 0x2f8820 - g_ps2RecompiledFunctionTable[516615] = ADXT_ExecErrChk_0x2f8758; // 0x2f8824 - g_ps2RecompiledFunctionTable[516616] = ADXT_ExecErrChk_0x2f8758; // 0x2f8828 - g_ps2RecompiledFunctionTable[516617] = ADXT_ExecErrChk_0x2f8758; // 0x2f882c - g_ps2RecompiledFunctionTable[516618] = ADXT_ExecErrChk_0x2f8758; // 0x2f8830 - g_ps2RecompiledFunctionTable[516619] = ADXT_ExecErrChk_0x2f8758; // 0x2f8834 - g_ps2RecompiledFunctionTable[516620] = ADXT_ExecErrChk_0x2f8758; // 0x2f8838 - g_ps2RecompiledFunctionTable[516621] = ADXT_ExecErrChk_0x2f8758; // 0x2f883c - g_ps2RecompiledFunctionTable[516622] = ADXT_ExecErrChk_0x2f8758; // 0x2f8840 - g_ps2RecompiledFunctionTable[516623] = ADXT_ExecErrChk_0x2f8758; // 0x2f8844 - g_ps2RecompiledFunctionTable[516624] = ADXT_ExecErrChk_0x2f8758; // 0x2f8848 - g_ps2RecompiledFunctionTable[516625] = ADXT_ExecErrChk_0x2f8758; // 0x2f884c - g_ps2RecompiledFunctionTable[516626] = ADXT_ExecErrChk_0x2f8758; // 0x2f8850 - g_ps2RecompiledFunctionTable[516627] = ADXT_ExecErrChk_0x2f8758; // 0x2f8854 - g_ps2RecompiledFunctionTable[516628] = ADXT_ExecErrChk_0x2f8758; // 0x2f8858 - g_ps2RecompiledFunctionTable[516629] = ADXT_ExecErrChk_0x2f8758; // 0x2f885c - g_ps2RecompiledFunctionTable[516630] = ADXT_ExecErrChk_0x2f8758; // 0x2f8860 - g_ps2RecompiledFunctionTable[516631] = ADXT_ExecErrChk_0x2f8758; // 0x2f8864 - g_ps2RecompiledFunctionTable[516632] = ADXT_ExecErrChk_0x2f8758; // 0x2f8868 - g_ps2RecompiledFunctionTable[516633] = ADXT_ExecErrChk_0x2f8758; // 0x2f886c - g_ps2RecompiledFunctionTable[516634] = ADXT_ExecErrChk_0x2f8758; // 0x2f8870 - g_ps2RecompiledFunctionTable[516635] = ADXT_ExecErrChk_0x2f8758; // 0x2f8874 - g_ps2RecompiledFunctionTable[516636] = ADXT_ExecErrChk_0x2f8758; // 0x2f8878 - g_ps2RecompiledFunctionTable[516637] = ADXT_ExecErrChk_0x2f8758; // 0x2f887c - g_ps2RecompiledFunctionTable[516638] = ADXT_ExecErrChk_0x2f8758; // 0x2f8880 - g_ps2RecompiledFunctionTable[516639] = ADXT_ExecErrChk_0x2f8758; // 0x2f8884 - g_ps2RecompiledFunctionTable[516640] = ADXT_ExecErrChk_0x2f8758; // 0x2f8888 - g_ps2RecompiledFunctionTable[516641] = ADXT_ExecErrChk_0x2f8758; // 0x2f888c - g_ps2RecompiledFunctionTable[516642] = ADXT_ExecErrChk_0x2f8758; // 0x2f8890 - g_ps2RecompiledFunctionTable[516643] = ADXT_ExecErrChk_0x2f8758; // 0x2f8894 - g_ps2RecompiledFunctionTable[516644] = ADXT_ExecErrChk_0x2f8758; // 0x2f8898 - g_ps2RecompiledFunctionTable[516645] = ADXT_ExecErrChk_0x2f8758; // 0x2f889c - g_ps2RecompiledFunctionTable[516646] = ADXT_ExecErrChk_0x2f8758; // 0x2f88a0 - g_ps2RecompiledFunctionTable[516647] = ADXT_ExecErrChk_0x2f8758; // 0x2f88a4 - g_ps2RecompiledFunctionTable[516648] = ADXT_ExecErrChk_0x2f8758; // 0x2f88a8 - g_ps2RecompiledFunctionTable[516649] = ADXT_ExecErrChk_0x2f8758; // 0x2f88ac - g_ps2RecompiledFunctionTable[516650] = ADXT_ExecErrChk_0x2f8758; // 0x2f88b0 - g_ps2RecompiledFunctionTable[516651] = ADXT_ExecErrChk_0x2f8758; // 0x2f88b4 - g_ps2RecompiledFunctionTable[516652] = ADXT_ExecErrChk_0x2f8758; // 0x2f88b8 - g_ps2RecompiledFunctionTable[516653] = ADXT_ExecErrChk_0x2f8758; // 0x2f88bc - g_ps2RecompiledFunctionTable[516654] = ADXT_ExecErrChk_0x2f8758; // 0x2f88c0 - g_ps2RecompiledFunctionTable[516655] = ADXT_ExecErrChk_0x2f8758; // 0x2f88c4 - g_ps2RecompiledFunctionTable[516656] = ADXT_ExecErrChk_0x2f8758; // 0x2f88c8 - g_ps2RecompiledFunctionTable[516657] = ADXT_ExecErrChk_0x2f8758; // 0x2f88cc - g_ps2RecompiledFunctionTable[516658] = ADXT_ExecErrChk_0x2f8758; // 0x2f88d0 - g_ps2RecompiledFunctionTable[516659] = ADXT_ExecErrChk_0x2f8758; // 0x2f88d4 - g_ps2RecompiledFunctionTable[516660] = ADXT_ExecErrChk_0x2f8758; // 0x2f88d8 - g_ps2RecompiledFunctionTable[516661] = ADXT_ExecErrChk_0x2f8758; // 0x2f88dc - g_ps2RecompiledFunctionTable[516662] = ADXT_ExecErrChk_0x2f8758; // 0x2f88e0 - g_ps2RecompiledFunctionTable[516663] = ADXT_ExecErrChk_0x2f8758; // 0x2f88e4 - g_ps2RecompiledFunctionTable[516664] = ADXT_ExecErrChk_0x2f8758; // 0x2f88e8 - g_ps2RecompiledFunctionTable[516665] = ADXT_ExecErrChk_0x2f8758; // 0x2f88ec - g_ps2RecompiledFunctionTable[516666] = ADXT_ExecErrChk_0x2f8758; // 0x2f88f0 - g_ps2RecompiledFunctionTable[516667] = ADXT_ExecErrChk_0x2f8758; // 0x2f88f4 - g_ps2RecompiledFunctionTable[516668] = ADXT_ExecErrChk_0x2f8758; // 0x2f88f8 - g_ps2RecompiledFunctionTable[516669] = ADXT_ExecErrChk_0x2f8758; // 0x2f88fc - g_ps2RecompiledFunctionTable[516670] = ADXT_ExecErrChk_0x2f8758; // 0x2f8900 - g_ps2RecompiledFunctionTable[516671] = ADXT_ExecErrChk_0x2f8758; // 0x2f8904 - g_ps2RecompiledFunctionTable[516672] = ADXT_ExecErrChk_0x2f8758; // 0x2f8908 - g_ps2RecompiledFunctionTable[516673] = ADXT_ExecErrChk_0x2f8758; // 0x2f890c - g_ps2RecompiledFunctionTable[516674] = ADXT_ExecErrChk_0x2f8758; // 0x2f8910 - g_ps2RecompiledFunctionTable[516675] = ADXT_ExecErrChk_0x2f8758; // 0x2f8914 - g_ps2RecompiledFunctionTable[516676] = ADXT_ExecErrChk_0x2f8758; // 0x2f8918 - g_ps2RecompiledFunctionTable[516677] = ADXT_ExecErrChk_0x2f8758; // 0x2f891c - g_ps2RecompiledFunctionTable[516678] = ADXT_ExecErrChk_0x2f8758; // 0x2f8920 - g_ps2RecompiledFunctionTable[516679] = ADXT_ExecErrChk_0x2f8758; // 0x2f8924 - g_ps2RecompiledFunctionTable[516680] = ADXT_ExecErrChk_0x2f8758; // 0x2f8928 - g_ps2RecompiledFunctionTable[516681] = ADXT_ExecErrChk_0x2f8758; // 0x2f892c - g_ps2RecompiledFunctionTable[516682] = ADXT_ExecErrChk_0x2f8758; // 0x2f8930 - g_ps2RecompiledFunctionTable[516683] = ADXT_ExecErrChk_0x2f8758; // 0x2f8934 - g_ps2RecompiledFunctionTable[516684] = ADXT_ExecErrChk_0x2f8758; // 0x2f8938 - g_ps2RecompiledFunctionTable[516685] = ADXT_ExecErrChk_0x2f8758; // 0x2f893c - g_ps2RecompiledFunctionTable[516686] = ADXT_ExecErrChk_0x2f8758; // 0x2f8940 - g_ps2RecompiledFunctionTable[516687] = ADXT_ExecErrChk_0x2f8758; // 0x2f8944 - g_ps2RecompiledFunctionTable[516688] = ADXT_ExecErrChk_0x2f8758; // 0x2f8948 - g_ps2RecompiledFunctionTable[516689] = ADXT_ExecErrChk_0x2f8758; // 0x2f894c - g_ps2RecompiledFunctionTable[516690] = ADXT_ExecErrChk_0x2f8758; // 0x2f8950 - g_ps2RecompiledFunctionTable[516691] = ADXT_ExecErrChk_0x2f8758; // 0x2f8954 - g_ps2RecompiledFunctionTable[516692] = ADXT_ExecErrChk_0x2f8758; // 0x2f8958 - g_ps2RecompiledFunctionTable[516693] = ADXT_ExecErrChk_0x2f8758; // 0x2f895c - g_ps2RecompiledFunctionTable[516694] = ADXT_ExecErrChk_0x2f8758; // 0x2f8960 - g_ps2RecompiledFunctionTable[516695] = ADXT_ExecErrChk_0x2f8758; // 0x2f8964 - g_ps2RecompiledFunctionTable[516696] = ADXT_ExecErrChk_0x2f8758; // 0x2f8968 - g_ps2RecompiledFunctionTable[516697] = ADXT_ExecErrChk_0x2f8758; // 0x2f896c - g_ps2RecompiledFunctionTable[516698] = ADXT_ExecErrChk_0x2f8758; // 0x2f8970 - g_ps2RecompiledFunctionTable[516699] = ADXT_ExecErrChk_0x2f8758; // 0x2f8974 - g_ps2RecompiledFunctionTable[516700] = ADXT_ExecErrChk_0x2f8758; // 0x2f8978 - g_ps2RecompiledFunctionTable[516701] = ADXT_ExecErrChk_0x2f8758; // 0x2f897c - g_ps2RecompiledFunctionTable[516702] = ADXT_ExecErrChk_0x2f8758; // 0x2f8980 - g_ps2RecompiledFunctionTable[516703] = ADXT_ExecErrChk_0x2f8758; // 0x2f8984 - g_ps2RecompiledFunctionTable[516704] = ADXT_ExecErrChk_0x2f8758; // 0x2f8988 - g_ps2RecompiledFunctionTable[516705] = ADXT_ExecErrChk_0x2f8758; // 0x2f898c - g_ps2RecompiledFunctionTable[516706] = ADXT_ExecErrChk_0x2f8758; // 0x2f8990 - g_ps2RecompiledFunctionTable[516707] = ADXT_ExecErrChk_0x2f8758; // 0x2f8994 - g_ps2RecompiledFunctionTable[516708] = ADXT_ExecErrChk_0x2f8758; // 0x2f8998 - g_ps2RecompiledFunctionTable[516709] = ADXT_ExecErrChk_0x2f8758; // 0x2f899c - g_ps2RecompiledFunctionTable[516710] = ADXT_ExecErrChkPS2_0x2f89a0; // 0x2f89a0 - g_ps2RecompiledFunctionTable[516719] = ADXT_ExecErrChkPS2_0x2f89a0; // 0x2f89c4 - g_ps2RecompiledFunctionTable[516728] = ADXT_ExecHndl_0x2f89e8; // 0x2f89e8 - g_ps2RecompiledFunctionTable[516738] = ADXT_ExecHndl_0x2f89e8; // 0x2f8a10 - g_ps2RecompiledFunctionTable[516744] = ADXT_ExecHndl_0x2f89e8; // 0x2f8a28 - g_ps2RecompiledFunctionTable[516750] = ADXT_ExecHndl_0x2f89e8; // 0x2f8a40 - g_ps2RecompiledFunctionTable[516756] = ADXT_ExecHndl_0x2f89e8; // 0x2f8a58 - g_ps2RecompiledFunctionTable[516762] = ADXT_ExecHndl_0x2f89e8; // 0x2f8a70 - g_ps2RecompiledFunctionTable[516768] = ADXPD_Init_0x2f8a88; // 0x2f8a88 - g_ps2RecompiledFunctionTable[516774] = ADXPD_Create_0x2f8aa0; // 0x2f8aa0 - g_ps2RecompiledFunctionTable[516784] = ADXPD_Create_0x2f8aa0; // 0x2f8ac8 - g_ps2RecompiledFunctionTable[516802] = ADXPD_Create_0x2f8aa0; // 0x2f8b10 - g_ps2RecompiledFunctionTable[516812] = ADXPD_Create_0x2f8aa0; // 0x2f8b38 - g_ps2RecompiledFunctionTable[516816] = ADXPD_Create_0x2f8aa0; // 0x2f8b48 - g_ps2RecompiledFunctionTable[516822] = ADXPD_SetCoef_0x2f8b60; // 0x2f8b60 - g_ps2RecompiledFunctionTable[516828] = ADXPD_Destroy_0x2f8b78; // 0x2f8b78 - g_ps2RecompiledFunctionTable[516836] = ADXPD_SetMode_0x2f8b98; // 0x2f8b98 - g_ps2RecompiledFunctionTable[516838] = ADXPD_GetStat_0x2f8ba0; // 0x2f8ba0 - g_ps2RecompiledFunctionTable[516840] = ADXPD_EntryMono_0x2f8ba8; // 0x2f8ba8 - g_ps2RecompiledFunctionTable[516852] = ADXPD_EntrySte_0x2f8bd8; // 0x2f8bd8 - g_ps2RecompiledFunctionTable[516864] = ADXPD_Start_0x2f8c08; // 0x2f8c08 - g_ps2RecompiledFunctionTable[516872] = ADXPD_Stop_0x2f8c28; // 0x2f8c28 - g_ps2RecompiledFunctionTable[516878] = ADXPD_Reset_0x2f8c40; // 0x2f8c40 - g_ps2RecompiledFunctionTable[516884] = ADXPD_GetNumBlk_0x2f8c58; // 0x2f8c58 - g_ps2RecompiledFunctionTable[516886] = adxpd_error_0x2f8c60; // 0x2f8c60 - g_ps2RecompiledFunctionTable[516890] = ADXPD_ExecHndl_0x2f8c70; // 0x2f8c70 - g_ps2RecompiledFunctionTable[516913] = ADXPD_ExecHndl_0x2f8c70; // 0x2f8ccc - g_ps2RecompiledFunctionTable[516923] = ADXPD_ExecHndl_0x2f8c70; // 0x2f8cf4 - g_ps2RecompiledFunctionTable[516933] = ADXPD_ExecHndl_0x2f8c70; // 0x2f8d1c - g_ps2RecompiledFunctionTable[516940] = ADXPD_ExecServer_0x2f8d38; // 0x2f8d38 - g_ps2RecompiledFunctionTable[516950] = ADXPD_ExecServer_0x2f8d38; // 0x2f8d60 - g_ps2RecompiledFunctionTable[516954] = ADXPD_ExecServer_0x2f8d38; // 0x2f8d70 - g_ps2RecompiledFunctionTable[516964] = cvFsCallUsrErrFn_0x2f8d98; // 0x2f8d98 - g_ps2RecompiledFunctionTable[516965] = cvFsCallUsrErrFn_0x2f8d98; // 0x2f8d9c - g_ps2RecompiledFunctionTable[516966] = cvFsCallUsrErrFn_0x2f8d98; // 0x2f8da0 - g_ps2RecompiledFunctionTable[516967] = cvFsCallUsrErrFn_0x2f8d98; // 0x2f8da4 - g_ps2RecompiledFunctionTable[516968] = cvFsCallUsrErrFn_0x2f8d98; // 0x2f8da8 - g_ps2RecompiledFunctionTable[516969] = cvFsCallUsrErrFn_0x2f8d98; // 0x2f8dac - g_ps2RecompiledFunctionTable[516970] = cvFsCallUsrErrFn_0x2f8d98; // 0x2f8db0 - g_ps2RecompiledFunctionTable[516971] = cvFsCallUsrErrFn_0x2f8d98; // 0x2f8db4 - g_ps2RecompiledFunctionTable[516972] = cvFsCallUsrErrFn_0x2f8d98; // 0x2f8db8 - g_ps2RecompiledFunctionTable[516973] = cvFsCallUsrErrFn_0x2f8d98; // 0x2f8dbc - g_ps2RecompiledFunctionTable[516974] = cvFsCallUsrErrFn_0x2f8d98; // 0x2f8dc0 - g_ps2RecompiledFunctionTable[516976] = cvFsError_0x2f8dc8; // 0x2f8dc8 - g_ps2RecompiledFunctionTable[516982] = cvFsInit_0x2f8de0; // 0x2f8de0 - g_ps2RecompiledFunctionTable[516994] = cvFsInit_0x2f8de0; // 0x2f8e10 - g_ps2RecompiledFunctionTable[517006] = cvFsInit_0x2f8de0; // 0x2f8e40 - g_ps2RecompiledFunctionTable[517017] = cvFsInit_0x2f8de0; // 0x2f8e6c - g_ps2RecompiledFunctionTable[517026] = cvFsFinish_0x2f8e90; // 0x2f8e90 - g_ps2RecompiledFunctionTable[517027] = cvFsFinish_0x2f8e90; // 0x2f8e94 - g_ps2RecompiledFunctionTable[517028] = cvFsFinish_0x2f8e90; // 0x2f8e98 - g_ps2RecompiledFunctionTable[517029] = cvFsFinish_0x2f8e90; // 0x2f8e9c - g_ps2RecompiledFunctionTable[517030] = cvFsFinish_0x2f8e90; // 0x2f8ea0 - g_ps2RecompiledFunctionTable[517031] = cvFsFinish_0x2f8e90; // 0x2f8ea4 - g_ps2RecompiledFunctionTable[517032] = cvFsFinish_0x2f8e90; // 0x2f8ea8 - g_ps2RecompiledFunctionTable[517033] = cvFsFinish_0x2f8e90; // 0x2f8eac - g_ps2RecompiledFunctionTable[517034] = cvFsFinish_0x2f8e90; // 0x2f8eb0 - g_ps2RecompiledFunctionTable[517035] = cvFsFinish_0x2f8e90; // 0x2f8eb4 - g_ps2RecompiledFunctionTable[517036] = cvFsFinish_0x2f8e90; // 0x2f8eb8 - g_ps2RecompiledFunctionTable[517037] = cvFsFinish_0x2f8e90; // 0x2f8ebc - g_ps2RecompiledFunctionTable[517038] = cvFsFinish_0x2f8e90; // 0x2f8ec0 - g_ps2RecompiledFunctionTable[517039] = cvFsFinish_0x2f8e90; // 0x2f8ec4 - g_ps2RecompiledFunctionTable[517040] = cvFsFinish_0x2f8e90; // 0x2f8ec8 - g_ps2RecompiledFunctionTable[517041] = cvFsFinish_0x2f8e90; // 0x2f8ecc - g_ps2RecompiledFunctionTable[517042] = cvFsFinish_0x2f8e90; // 0x2f8ed0 - g_ps2RecompiledFunctionTable[517043] = cvFsFinish_0x2f8e90; // 0x2f8ed4 - g_ps2RecompiledFunctionTable[517044] = cvFsFinish_0x2f8e90; // 0x2f8ed8 - g_ps2RecompiledFunctionTable[517045] = cvFsFinish_0x2f8e90; // 0x2f8edc - g_ps2RecompiledFunctionTable[517046] = cvFsFinish_0x2f8e90; // 0x2f8ee0 - g_ps2RecompiledFunctionTable[517047] = cvFsFinish_0x2f8e90; // 0x2f8ee4 - g_ps2RecompiledFunctionTable[517048] = cvFsFinish_0x2f8e90; // 0x2f8ee8 - g_ps2RecompiledFunctionTable[517049] = cvFsFinish_0x2f8e90; // 0x2f8eec - g_ps2RecompiledFunctionTable[517050] = cvFsFinish_0x2f8e90; // 0x2f8ef0 - g_ps2RecompiledFunctionTable[517051] = cvFsFinish_0x2f8e90; // 0x2f8ef4 - g_ps2RecompiledFunctionTable[517052] = cvFsFinish_0x2f8e90; // 0x2f8ef8 - g_ps2RecompiledFunctionTable[517053] = cvFsFinish_0x2f8e90; // 0x2f8efc - g_ps2RecompiledFunctionTable[517054] = cvFsFinish_0x2f8e90; // 0x2f8f00 - g_ps2RecompiledFunctionTable[517055] = cvFsFinish_0x2f8e90; // 0x2f8f04 - g_ps2RecompiledFunctionTable[517056] = cvFsFinish_0x2f8e90; // 0x2f8f08 - g_ps2RecompiledFunctionTable[517057] = cvFsFinish_0x2f8e90; // 0x2f8f0c - g_ps2RecompiledFunctionTable[517058] = cvFsFinish_0x2f8e90; // 0x2f8f10 - g_ps2RecompiledFunctionTable[517059] = cvFsFinish_0x2f8e90; // 0x2f8f14 - g_ps2RecompiledFunctionTable[517060] = cvFsFinish_0x2f8e90; // 0x2f8f18 - g_ps2RecompiledFunctionTable[517061] = cvFsFinish_0x2f8e90; // 0x2f8f1c - g_ps2RecompiledFunctionTable[517062] = cvFsFinish_0x2f8e90; // 0x2f8f20 - g_ps2RecompiledFunctionTable[517063] = cvFsFinish_0x2f8e90; // 0x2f8f24 - g_ps2RecompiledFunctionTable[517064] = cvFsFinish_0x2f8e90; // 0x2f8f28 - g_ps2RecompiledFunctionTable[517065] = cvFsFinish_0x2f8e90; // 0x2f8f2c - g_ps2RecompiledFunctionTable[517066] = cvFsFinish_0x2f8e90; // 0x2f8f30 - g_ps2RecompiledFunctionTable[517067] = cvFsFinish_0x2f8e90; // 0x2f8f34 - g_ps2RecompiledFunctionTable[517068] = cvFsFinish_0x2f8e90; // 0x2f8f38 - g_ps2RecompiledFunctionTable[517069] = cvFsFinish_0x2f8e90; // 0x2f8f3c - g_ps2RecompiledFunctionTable[517070] = cvFsFinish_0x2f8e90; // 0x2f8f40 - g_ps2RecompiledFunctionTable[517071] = cvFsFinish_0x2f8e90; // 0x2f8f44 - g_ps2RecompiledFunctionTable[517072] = cvFsFinish_0x2f8e90; // 0x2f8f48 - g_ps2RecompiledFunctionTable[517073] = cvFsFinish_0x2f8e90; // 0x2f8f4c - g_ps2RecompiledFunctionTable[517074] = cvFsFinish_0x2f8e90; // 0x2f8f50 - g_ps2RecompiledFunctionTable[517075] = cvFsFinish_0x2f8e90; // 0x2f8f54 - g_ps2RecompiledFunctionTable[517076] = cvFsFinish_0x2f8e90; // 0x2f8f58 - g_ps2RecompiledFunctionTable[517077] = cvFsFinish_0x2f8e90; // 0x2f8f5c - g_ps2RecompiledFunctionTable[517078] = cvFsFinish_0x2f8e90; // 0x2f8f60 - g_ps2RecompiledFunctionTable[517079] = cvFsFinish_0x2f8e90; // 0x2f8f64 - g_ps2RecompiledFunctionTable[517080] = cvFsFinish_0x2f8e90; // 0x2f8f68 - g_ps2RecompiledFunctionTable[517081] = cvFsFinish_0x2f8e90; // 0x2f8f6c - g_ps2RecompiledFunctionTable[517082] = cvFsFinish_0x2f8e90; // 0x2f8f70 - g_ps2RecompiledFunctionTable[517083] = cvFsFinish_0x2f8e90; // 0x2f8f74 - g_ps2RecompiledFunctionTable[517084] = cvFsFinish_0x2f8e90; // 0x2f8f78 - g_ps2RecompiledFunctionTable[517085] = cvFsFinish_0x2f8e90; // 0x2f8f7c - g_ps2RecompiledFunctionTable[517086] = cvFsFinish_0x2f8e90; // 0x2f8f80 - g_ps2RecompiledFunctionTable[517087] = cvFsFinish_0x2f8e90; // 0x2f8f84 - g_ps2RecompiledFunctionTable[517088] = cvFsFinish_0x2f8e90; // 0x2f8f88 - g_ps2RecompiledFunctionTable[517089] = cvFsFinish_0x2f8e90; // 0x2f8f8c - g_ps2RecompiledFunctionTable[517090] = cvFsAddDev_0x2f8f90; // 0x2f8f90 - g_ps2RecompiledFunctionTable[517091] = cvFsAddDev_0x2f8f90; // 0x2f8f94 - g_ps2RecompiledFunctionTable[517092] = cvFsAddDev_0x2f8f90; // 0x2f8f98 - g_ps2RecompiledFunctionTable[517093] = cvFsAddDev_0x2f8f90; // 0x2f8f9c - g_ps2RecompiledFunctionTable[517094] = cvFsAddDev_0x2f8f90; // 0x2f8fa0 - g_ps2RecompiledFunctionTable[517095] = cvFsAddDev_0x2f8f90; // 0x2f8fa4 - g_ps2RecompiledFunctionTable[517096] = cvFsAddDev_0x2f8f90; // 0x2f8fa8 - g_ps2RecompiledFunctionTable[517097] = cvFsAddDev_0x2f8f90; // 0x2f8fac - g_ps2RecompiledFunctionTable[517098] = cvFsAddDev_0x2f8f90; // 0x2f8fb0 - g_ps2RecompiledFunctionTable[517099] = cvFsAddDev_0x2f8f90; // 0x2f8fb4 - g_ps2RecompiledFunctionTable[517100] = cvFsAddDev_0x2f8f90; // 0x2f8fb8 - g_ps2RecompiledFunctionTable[517101] = cvFsAddDev_0x2f8f90; // 0x2f8fbc - g_ps2RecompiledFunctionTable[517102] = cvFsAddDev_0x2f8f90; // 0x2f8fc0 - g_ps2RecompiledFunctionTable[517103] = cvFsAddDev_0x2f8f90; // 0x2f8fc4 - g_ps2RecompiledFunctionTable[517104] = cvFsAddDev_0x2f8f90; // 0x2f8fc8 - g_ps2RecompiledFunctionTable[517105] = cvFsAddDev_0x2f8f90; // 0x2f8fcc - g_ps2RecompiledFunctionTable[517106] = cvFsAddDev_0x2f8f90; // 0x2f8fd0 - g_ps2RecompiledFunctionTable[517107] = cvFsAddDev_0x2f8f90; // 0x2f8fd4 - g_ps2RecompiledFunctionTable[517108] = cvFsAddDev_0x2f8f90; // 0x2f8fd8 - g_ps2RecompiledFunctionTable[517109] = cvFsAddDev_0x2f8f90; // 0x2f8fdc - g_ps2RecompiledFunctionTable[517110] = cvFsAddDev_0x2f8f90; // 0x2f8fe0 - g_ps2RecompiledFunctionTable[517111] = cvFsAddDev_0x2f8f90; // 0x2f8fe4 - g_ps2RecompiledFunctionTable[517112] = cvFsAddDev_0x2f8f90; // 0x2f8fe8 - g_ps2RecompiledFunctionTable[517113] = cvFsAddDev_0x2f8f90; // 0x2f8fec - g_ps2RecompiledFunctionTable[517114] = cvFsAddDev_0x2f8f90; // 0x2f8ff0 - g_ps2RecompiledFunctionTable[517116] = addDevice_0x2f8ff8; // 0x2f8ff8 - g_ps2RecompiledFunctionTable[517117] = addDevice_0x2f8ff8; // 0x2f8ffc - g_ps2RecompiledFunctionTable[517118] = addDevice_0x2f8ff8; // 0x2f9000 - g_ps2RecompiledFunctionTable[517119] = addDevice_0x2f8ff8; // 0x2f9004 - g_ps2RecompiledFunctionTable[517120] = addDevice_0x2f8ff8; // 0x2f9008 - g_ps2RecompiledFunctionTable[517121] = addDevice_0x2f8ff8; // 0x2f900c - g_ps2RecompiledFunctionTable[517122] = addDevice_0x2f8ff8; // 0x2f9010 - g_ps2RecompiledFunctionTable[517123] = addDevice_0x2f8ff8; // 0x2f9014 - g_ps2RecompiledFunctionTable[517124] = addDevice_0x2f8ff8; // 0x2f9018 - g_ps2RecompiledFunctionTable[517125] = addDevice_0x2f8ff8; // 0x2f901c - g_ps2RecompiledFunctionTable[517126] = addDevice_0x2f8ff8; // 0x2f9020 - g_ps2RecompiledFunctionTable[517127] = addDevice_0x2f8ff8; // 0x2f9024 - g_ps2RecompiledFunctionTable[517128] = addDevice_0x2f8ff8; // 0x2f9028 - g_ps2RecompiledFunctionTable[517129] = addDevice_0x2f8ff8; // 0x2f902c - g_ps2RecompiledFunctionTable[517130] = addDevice_0x2f8ff8; // 0x2f9030 - g_ps2RecompiledFunctionTable[517131] = addDevice_0x2f8ff8; // 0x2f9034 - g_ps2RecompiledFunctionTable[517132] = addDevice_0x2f8ff8; // 0x2f9038 - g_ps2RecompiledFunctionTable[517133] = addDevice_0x2f8ff8; // 0x2f903c - g_ps2RecompiledFunctionTable[517134] = addDevice_0x2f8ff8; // 0x2f9040 - g_ps2RecompiledFunctionTable[517135] = addDevice_0x2f8ff8; // 0x2f9044 - g_ps2RecompiledFunctionTable[517136] = addDevice_0x2f8ff8; // 0x2f9048 - g_ps2RecompiledFunctionTable[517137] = addDevice_0x2f8ff8; // 0x2f904c - g_ps2RecompiledFunctionTable[517138] = addDevice_0x2f8ff8; // 0x2f9050 - g_ps2RecompiledFunctionTable[517139] = addDevice_0x2f8ff8; // 0x2f9054 - g_ps2RecompiledFunctionTable[517140] = addDevice_0x2f8ff8; // 0x2f9058 - g_ps2RecompiledFunctionTable[517141] = addDevice_0x2f8ff8; // 0x2f905c - g_ps2RecompiledFunctionTable[517142] = addDevice_0x2f8ff8; // 0x2f9060 - g_ps2RecompiledFunctionTable[517143] = addDevice_0x2f8ff8; // 0x2f9064 - g_ps2RecompiledFunctionTable[517144] = addDevice_0x2f8ff8; // 0x2f9068 - g_ps2RecompiledFunctionTable[517145] = addDevice_0x2f8ff8; // 0x2f906c - g_ps2RecompiledFunctionTable[517146] = addDevice_0x2f8ff8; // 0x2f9070 - g_ps2RecompiledFunctionTable[517147] = addDevice_0x2f8ff8; // 0x2f9074 - g_ps2RecompiledFunctionTable[517148] = addDevice_0x2f8ff8; // 0x2f9078 - g_ps2RecompiledFunctionTable[517149] = addDevice_0x2f8ff8; // 0x2f907c - g_ps2RecompiledFunctionTable[517150] = addDevice_0x2f8ff8; // 0x2f9080 - g_ps2RecompiledFunctionTable[517151] = addDevice_0x2f8ff8; // 0x2f9084 - g_ps2RecompiledFunctionTable[517152] = addDevice_0x2f8ff8; // 0x2f9088 - g_ps2RecompiledFunctionTable[517153] = addDevice_0x2f8ff8; // 0x2f908c - g_ps2RecompiledFunctionTable[517154] = addDevice_0x2f8ff8; // 0x2f9090 - g_ps2RecompiledFunctionTable[517155] = addDevice_0x2f8ff8; // 0x2f9094 - g_ps2RecompiledFunctionTable[517156] = addDevice_0x2f8ff8; // 0x2f9098 - g_ps2RecompiledFunctionTable[517157] = addDevice_0x2f8ff8; // 0x2f909c - g_ps2RecompiledFunctionTable[517158] = addDevice_0x2f8ff8; // 0x2f90a0 - g_ps2RecompiledFunctionTable[517159] = addDevice_0x2f8ff8; // 0x2f90a4 - g_ps2RecompiledFunctionTable[517160] = addDevice_0x2f8ff8; // 0x2f90a8 - g_ps2RecompiledFunctionTable[517161] = addDevice_0x2f8ff8; // 0x2f90ac - g_ps2RecompiledFunctionTable[517162] = addDevice_0x2f8ff8; // 0x2f90b0 - g_ps2RecompiledFunctionTable[517163] = addDevice_0x2f8ff8; // 0x2f90b4 - g_ps2RecompiledFunctionTable[517164] = addDevice_0x2f8ff8; // 0x2f90b8 - g_ps2RecompiledFunctionTable[517165] = addDevice_0x2f8ff8; // 0x2f90bc - g_ps2RecompiledFunctionTable[517166] = addDevice_0x2f8ff8; // 0x2f90c0 - g_ps2RecompiledFunctionTable[517167] = addDevice_0x2f8ff8; // 0x2f90c4 - g_ps2RecompiledFunctionTable[517168] = getDevice_0x2f90c8; // 0x2f90c8 - g_ps2RecompiledFunctionTable[517178] = getDevice_0x2f90c8; // 0x2f90f0 - g_ps2RecompiledFunctionTable[517184] = getDevice_0x2f90c8; // 0x2f9108 - g_ps2RecompiledFunctionTable[517188] = getDevice_0x2f90c8; // 0x2f9118 - g_ps2RecompiledFunctionTable[517206] = toUpperStr_0x2f9160; // 0x2f9160 - g_ps2RecompiledFunctionTable[517211] = toUpperStr_0x2f9160; // 0x2f9174 - g_ps2RecompiledFunctionTable[517216] = toUpperStr_0x2f9160; // 0x2f9188 - g_ps2RecompiledFunctionTable[517230] = cvFsDelDev_0x2f91c0; // 0x2f91c0 - g_ps2RecompiledFunctionTable[517251] = cvFsDelDev_0x2f91c0; // 0x2f9214 - g_ps2RecompiledFunctionTable[517258] = cvFsDelDev_0x2f91c0; // 0x2f9230 - g_ps2RecompiledFunctionTable[517262] = cvFsDelDev_0x2f91c0; // 0x2f9240 - g_ps2RecompiledFunctionTable[517267] = cvFsDelDev_0x2f91c0; // 0x2f9254 - g_ps2RecompiledFunctionTable[517282] = cvFsSetDefDev_0x2f9290; // 0x2f9290 - g_ps2RecompiledFunctionTable[517297] = cvFsSetDefDev_0x2f9290; // 0x2f92cc - g_ps2RecompiledFunctionTable[517302] = cvFsSetDefDev_0x2f9290; // 0x2f92e0 - g_ps2RecompiledFunctionTable[517305] = cvFsSetDefDev_0x2f9290; // 0x2f92ec - g_ps2RecompiledFunctionTable[517330] = isExistDev_0x2f9350; // 0x2f9350 - g_ps2RecompiledFunctionTable[517342] = isExistDev_0x2f9350; // 0x2f9380 - g_ps2RecompiledFunctionTable[517346] = isExistDev_0x2f9350; // 0x2f9390 - g_ps2RecompiledFunctionTable[517362] = cvFsGetDefDev_0x2f93d0; // 0x2f93d0 - g_ps2RecompiledFunctionTable[517366] = cvFsOpen_0x2f93e0; // 0x2f93e0 - g_ps2RecompiledFunctionTable[517367] = cvFsOpen_0x2f93e0; // 0x2f93e4 - g_ps2RecompiledFunctionTable[517368] = cvFsOpen_0x2f93e0; // 0x2f93e8 - g_ps2RecompiledFunctionTable[517369] = cvFsOpen_0x2f93e0; // 0x2f93ec - g_ps2RecompiledFunctionTable[517370] = cvFsOpen_0x2f93e0; // 0x2f93f0 - g_ps2RecompiledFunctionTable[517371] = cvFsOpen_0x2f93e0; // 0x2f93f4 - g_ps2RecompiledFunctionTable[517372] = cvFsOpen_0x2f93e0; // 0x2f93f8 - g_ps2RecompiledFunctionTable[517373] = cvFsOpen_0x2f93e0; // 0x2f93fc - g_ps2RecompiledFunctionTable[517374] = cvFsOpen_0x2f93e0; // 0x2f9400 - g_ps2RecompiledFunctionTable[517375] = cvFsOpen_0x2f93e0; // 0x2f9404 - g_ps2RecompiledFunctionTable[517376] = cvFsOpen_0x2f93e0; // 0x2f9408 - g_ps2RecompiledFunctionTable[517377] = cvFsOpen_0x2f93e0; // 0x2f940c - g_ps2RecompiledFunctionTable[517378] = cvFsOpen_0x2f93e0; // 0x2f9410 - g_ps2RecompiledFunctionTable[517379] = cvFsOpen_0x2f93e0; // 0x2f9414 - g_ps2RecompiledFunctionTable[517380] = cvFsOpen_0x2f93e0; // 0x2f9418 - g_ps2RecompiledFunctionTable[517381] = cvFsOpen_0x2f93e0; // 0x2f941c - g_ps2RecompiledFunctionTable[517382] = cvFsOpen_0x2f93e0; // 0x2f9420 - g_ps2RecompiledFunctionTable[517383] = cvFsOpen_0x2f93e0; // 0x2f9424 - g_ps2RecompiledFunctionTable[517384] = cvFsOpen_0x2f93e0; // 0x2f9428 - g_ps2RecompiledFunctionTable[517385] = cvFsOpen_0x2f93e0; // 0x2f942c - g_ps2RecompiledFunctionTable[517386] = cvFsOpen_0x2f93e0; // 0x2f9430 - g_ps2RecompiledFunctionTable[517387] = cvFsOpen_0x2f93e0; // 0x2f9434 - g_ps2RecompiledFunctionTable[517388] = cvFsOpen_0x2f93e0; // 0x2f9438 - g_ps2RecompiledFunctionTable[517389] = cvFsOpen_0x2f93e0; // 0x2f943c - g_ps2RecompiledFunctionTable[517390] = cvFsOpen_0x2f93e0; // 0x2f9440 - g_ps2RecompiledFunctionTable[517391] = cvFsOpen_0x2f93e0; // 0x2f9444 - g_ps2RecompiledFunctionTable[517392] = cvFsOpen_0x2f93e0; // 0x2f9448 - g_ps2RecompiledFunctionTable[517393] = cvFsOpen_0x2f93e0; // 0x2f944c - g_ps2RecompiledFunctionTable[517394] = cvFsOpen_0x2f93e0; // 0x2f9450 - g_ps2RecompiledFunctionTable[517395] = cvFsOpen_0x2f93e0; // 0x2f9454 - g_ps2RecompiledFunctionTable[517396] = cvFsOpen_0x2f93e0; // 0x2f9458 - g_ps2RecompiledFunctionTable[517397] = cvFsOpen_0x2f93e0; // 0x2f945c - g_ps2RecompiledFunctionTable[517398] = cvFsOpen_0x2f93e0; // 0x2f9460 - g_ps2RecompiledFunctionTable[517399] = cvFsOpen_0x2f93e0; // 0x2f9464 - g_ps2RecompiledFunctionTable[517400] = cvFsOpen_0x2f93e0; // 0x2f9468 - g_ps2RecompiledFunctionTable[517401] = cvFsOpen_0x2f93e0; // 0x2f946c - g_ps2RecompiledFunctionTable[517402] = cvFsOpen_0x2f93e0; // 0x2f9470 - g_ps2RecompiledFunctionTable[517403] = cvFsOpen_0x2f93e0; // 0x2f9474 - g_ps2RecompiledFunctionTable[517404] = cvFsOpen_0x2f93e0; // 0x2f9478 - g_ps2RecompiledFunctionTable[517405] = cvFsOpen_0x2f93e0; // 0x2f947c - g_ps2RecompiledFunctionTable[517406] = cvFsOpen_0x2f93e0; // 0x2f9480 - g_ps2RecompiledFunctionTable[517407] = cvFsOpen_0x2f93e0; // 0x2f9484 - g_ps2RecompiledFunctionTable[517408] = cvFsOpen_0x2f93e0; // 0x2f9488 - g_ps2RecompiledFunctionTable[517409] = cvFsOpen_0x2f93e0; // 0x2f948c - g_ps2RecompiledFunctionTable[517410] = cvFsOpen_0x2f93e0; // 0x2f9490 - g_ps2RecompiledFunctionTable[517411] = cvFsOpen_0x2f93e0; // 0x2f9494 - g_ps2RecompiledFunctionTable[517412] = cvFsOpen_0x2f93e0; // 0x2f9498 - g_ps2RecompiledFunctionTable[517413] = cvFsOpen_0x2f93e0; // 0x2f949c - g_ps2RecompiledFunctionTable[517414] = cvFsOpen_0x2f93e0; // 0x2f94a0 - g_ps2RecompiledFunctionTable[517415] = cvFsOpen_0x2f93e0; // 0x2f94a4 - g_ps2RecompiledFunctionTable[517416] = cvFsOpen_0x2f93e0; // 0x2f94a8 - g_ps2RecompiledFunctionTable[517417] = cvFsOpen_0x2f93e0; // 0x2f94ac - g_ps2RecompiledFunctionTable[517418] = cvFsOpen_0x2f93e0; // 0x2f94b0 - g_ps2RecompiledFunctionTable[517419] = cvFsOpen_0x2f93e0; // 0x2f94b4 - g_ps2RecompiledFunctionTable[517420] = cvFsOpen_0x2f93e0; // 0x2f94b8 - g_ps2RecompiledFunctionTable[517421] = cvFsOpen_0x2f93e0; // 0x2f94bc - g_ps2RecompiledFunctionTable[517422] = cvFsOpen_0x2f93e0; // 0x2f94c0 - g_ps2RecompiledFunctionTable[517423] = cvFsOpen_0x2f93e0; // 0x2f94c4 - g_ps2RecompiledFunctionTable[517424] = cvFsOpen_0x2f93e0; // 0x2f94c8 - g_ps2RecompiledFunctionTable[517425] = cvFsOpen_0x2f93e0; // 0x2f94cc - g_ps2RecompiledFunctionTable[517426] = cvFsOpen_0x2f93e0; // 0x2f94d0 - g_ps2RecompiledFunctionTable[517427] = cvFsOpen_0x2f93e0; // 0x2f94d4 - g_ps2RecompiledFunctionTable[517428] = cvFsOpen_0x2f93e0; // 0x2f94d8 - g_ps2RecompiledFunctionTable[517429] = cvFsOpen_0x2f93e0; // 0x2f94dc - g_ps2RecompiledFunctionTable[517430] = cvFsOpen_0x2f93e0; // 0x2f94e0 - g_ps2RecompiledFunctionTable[517431] = cvFsOpen_0x2f93e0; // 0x2f94e4 - g_ps2RecompiledFunctionTable[517432] = cvFsOpen_0x2f93e0; // 0x2f94e8 - g_ps2RecompiledFunctionTable[517433] = cvFsOpen_0x2f93e0; // 0x2f94ec - g_ps2RecompiledFunctionTable[517434] = cvFsOpen_0x2f93e0; // 0x2f94f0 - g_ps2RecompiledFunctionTable[517435] = cvFsOpen_0x2f93e0; // 0x2f94f4 - g_ps2RecompiledFunctionTable[517436] = cvFsOpen_0x2f93e0; // 0x2f94f8 - g_ps2RecompiledFunctionTable[517437] = cvFsOpen_0x2f93e0; // 0x2f94fc - g_ps2RecompiledFunctionTable[517438] = cvFsOpen_0x2f93e0; // 0x2f9500 - g_ps2RecompiledFunctionTable[517439] = cvFsOpen_0x2f93e0; // 0x2f9504 - g_ps2RecompiledFunctionTable[517440] = cvFsOpen_0x2f93e0; // 0x2f9508 - g_ps2RecompiledFunctionTable[517442] = allocCvFsHn_0x2f9510; // 0x2f9510 - g_ps2RecompiledFunctionTable[517450] = allocCvFsHn_0x2f9510; // 0x2f9530 - g_ps2RecompiledFunctionTable[517464] = releaseCvFsHn_0x2f9568; // 0x2f9568 - g_ps2RecompiledFunctionTable[517468] = getDevName_0x2f9578; // 0x2f9578 - g_ps2RecompiledFunctionTable[517482] = getDevName_0x2f9578; // 0x2f95b0 - g_ps2RecompiledFunctionTable[517506] = getDevName_0x2f9578; // 0x2f9610 - g_ps2RecompiledFunctionTable[517510] = getDevName_0x2f9578; // 0x2f9620 - g_ps2RecompiledFunctionTable[517526] = getDevName_0x2f9578; // 0x2f9660 - g_ps2RecompiledFunctionTable[517554] = getDefDev_0x2f96d0; // 0x2f96d0 - g_ps2RecompiledFunctionTable[517564] = getDefDev_0x2f96d0; // 0x2f96f8 - g_ps2RecompiledFunctionTable[517584] = cvFsClose_0x2f9748; // 0x2f9748 - g_ps2RecompiledFunctionTable[517585] = cvFsClose_0x2f9748; // 0x2f974c - g_ps2RecompiledFunctionTable[517586] = cvFsClose_0x2f9748; // 0x2f9750 - g_ps2RecompiledFunctionTable[517587] = cvFsClose_0x2f9748; // 0x2f9754 - g_ps2RecompiledFunctionTable[517588] = cvFsClose_0x2f9748; // 0x2f9758 - g_ps2RecompiledFunctionTable[517589] = cvFsClose_0x2f9748; // 0x2f975c - g_ps2RecompiledFunctionTable[517590] = cvFsClose_0x2f9748; // 0x2f9760 - g_ps2RecompiledFunctionTable[517591] = cvFsClose_0x2f9748; // 0x2f9764 - g_ps2RecompiledFunctionTable[517592] = cvFsClose_0x2f9748; // 0x2f9768 - g_ps2RecompiledFunctionTable[517593] = cvFsClose_0x2f9748; // 0x2f976c - g_ps2RecompiledFunctionTable[517594] = cvFsClose_0x2f9748; // 0x2f9770 - g_ps2RecompiledFunctionTable[517595] = cvFsClose_0x2f9748; // 0x2f9774 - g_ps2RecompiledFunctionTable[517596] = cvFsClose_0x2f9748; // 0x2f9778 - g_ps2RecompiledFunctionTable[517597] = cvFsClose_0x2f9748; // 0x2f977c - g_ps2RecompiledFunctionTable[517598] = cvFsClose_0x2f9748; // 0x2f9780 - g_ps2RecompiledFunctionTable[517599] = cvFsClose_0x2f9748; // 0x2f9784 - g_ps2RecompiledFunctionTable[517600] = cvFsClose_0x2f9748; // 0x2f9788 - g_ps2RecompiledFunctionTable[517601] = cvFsClose_0x2f9748; // 0x2f978c - g_ps2RecompiledFunctionTable[517602] = cvFsClose_0x2f9748; // 0x2f9790 - g_ps2RecompiledFunctionTable[517603] = cvFsClose_0x2f9748; // 0x2f9794 - g_ps2RecompiledFunctionTable[517604] = cvFsClose_0x2f9748; // 0x2f9798 - g_ps2RecompiledFunctionTable[517605] = cvFsClose_0x2f9748; // 0x2f979c - g_ps2RecompiledFunctionTable[517606] = cvFsClose_0x2f9748; // 0x2f97a0 - g_ps2RecompiledFunctionTable[517607] = cvFsClose_0x2f9748; // 0x2f97a4 - g_ps2RecompiledFunctionTable[517608] = cvFsClose_0x2f9748; // 0x2f97a8 - g_ps2RecompiledFunctionTable[517609] = cvFsClose_0x2f9748; // 0x2f97ac - g_ps2RecompiledFunctionTable[517610] = cvFsClose_0x2f9748; // 0x2f97b0 - g_ps2RecompiledFunctionTable[517612] = cvFsTell_0x2f97b8; // 0x2f97b8 - g_ps2RecompiledFunctionTable[517613] = cvFsTell_0x2f97b8; // 0x2f97bc - g_ps2RecompiledFunctionTable[517614] = cvFsTell_0x2f97b8; // 0x2f97c0 - g_ps2RecompiledFunctionTable[517615] = cvFsTell_0x2f97b8; // 0x2f97c4 - g_ps2RecompiledFunctionTable[517616] = cvFsTell_0x2f97b8; // 0x2f97c8 - g_ps2RecompiledFunctionTable[517617] = cvFsTell_0x2f97b8; // 0x2f97cc - g_ps2RecompiledFunctionTable[517618] = cvFsTell_0x2f97b8; // 0x2f97d0 - g_ps2RecompiledFunctionTable[517619] = cvFsTell_0x2f97b8; // 0x2f97d4 - g_ps2RecompiledFunctionTable[517620] = cvFsTell_0x2f97b8; // 0x2f97d8 - g_ps2RecompiledFunctionTable[517621] = cvFsTell_0x2f97b8; // 0x2f97dc - g_ps2RecompiledFunctionTable[517622] = cvFsTell_0x2f97b8; // 0x2f97e0 - g_ps2RecompiledFunctionTable[517623] = cvFsTell_0x2f97b8; // 0x2f97e4 - g_ps2RecompiledFunctionTable[517624] = cvFsTell_0x2f97b8; // 0x2f97e8 - g_ps2RecompiledFunctionTable[517625] = cvFsTell_0x2f97b8; // 0x2f97ec - g_ps2RecompiledFunctionTable[517626] = cvFsTell_0x2f97b8; // 0x2f97f0 - g_ps2RecompiledFunctionTable[517627] = cvFsTell_0x2f97b8; // 0x2f97f4 - g_ps2RecompiledFunctionTable[517628] = cvFsTell_0x2f97b8; // 0x2f97f8 - g_ps2RecompiledFunctionTable[517629] = cvFsTell_0x2f97b8; // 0x2f97fc - g_ps2RecompiledFunctionTable[517630] = cvFsTell_0x2f97b8; // 0x2f9800 - g_ps2RecompiledFunctionTable[517631] = cvFsTell_0x2f97b8; // 0x2f9804 - g_ps2RecompiledFunctionTable[517632] = cvFsTell_0x2f97b8; // 0x2f9808 - g_ps2RecompiledFunctionTable[517633] = cvFsTell_0x2f97b8; // 0x2f980c - g_ps2RecompiledFunctionTable[517634] = cvFsTell_0x2f97b8; // 0x2f9810 - g_ps2RecompiledFunctionTable[517635] = cvFsTell_0x2f97b8; // 0x2f9814 - g_ps2RecompiledFunctionTable[517636] = cvFsTell_0x2f97b8; // 0x2f9818 - g_ps2RecompiledFunctionTable[517638] = cvFsSeek_0x2f9820; // 0x2f9820 - g_ps2RecompiledFunctionTable[517639] = cvFsSeek_0x2f9820; // 0x2f9824 - g_ps2RecompiledFunctionTable[517640] = cvFsSeek_0x2f9820; // 0x2f9828 - g_ps2RecompiledFunctionTable[517641] = cvFsSeek_0x2f9820; // 0x2f982c - g_ps2RecompiledFunctionTable[517642] = cvFsSeek_0x2f9820; // 0x2f9830 - g_ps2RecompiledFunctionTable[517643] = cvFsSeek_0x2f9820; // 0x2f9834 - g_ps2RecompiledFunctionTable[517644] = cvFsSeek_0x2f9820; // 0x2f9838 - g_ps2RecompiledFunctionTable[517645] = cvFsSeek_0x2f9820; // 0x2f983c - g_ps2RecompiledFunctionTable[517646] = cvFsSeek_0x2f9820; // 0x2f9840 - g_ps2RecompiledFunctionTable[517647] = cvFsSeek_0x2f9820; // 0x2f9844 - g_ps2RecompiledFunctionTable[517648] = cvFsSeek_0x2f9820; // 0x2f9848 - g_ps2RecompiledFunctionTable[517649] = cvFsSeek_0x2f9820; // 0x2f984c - g_ps2RecompiledFunctionTable[517650] = cvFsSeek_0x2f9820; // 0x2f9850 - g_ps2RecompiledFunctionTable[517651] = cvFsSeek_0x2f9820; // 0x2f9854 - g_ps2RecompiledFunctionTable[517652] = cvFsSeek_0x2f9820; // 0x2f9858 - g_ps2RecompiledFunctionTable[517653] = cvFsSeek_0x2f9820; // 0x2f985c - g_ps2RecompiledFunctionTable[517654] = cvFsSeek_0x2f9820; // 0x2f9860 - g_ps2RecompiledFunctionTable[517655] = cvFsSeek_0x2f9820; // 0x2f9864 - g_ps2RecompiledFunctionTable[517656] = cvFsSeek_0x2f9820; // 0x2f9868 - g_ps2RecompiledFunctionTable[517657] = cvFsSeek_0x2f9820; // 0x2f986c - g_ps2RecompiledFunctionTable[517658] = cvFsSeek_0x2f9820; // 0x2f9870 - g_ps2RecompiledFunctionTable[517659] = cvFsSeek_0x2f9820; // 0x2f9874 - g_ps2RecompiledFunctionTable[517660] = cvFsSeek_0x2f9820; // 0x2f9878 - g_ps2RecompiledFunctionTable[517661] = cvFsSeek_0x2f9820; // 0x2f987c - g_ps2RecompiledFunctionTable[517662] = cvFsSeek_0x2f9820; // 0x2f9880 - g_ps2RecompiledFunctionTable[517664] = cvFsReqRd_0x2f9888; // 0x2f9888 - g_ps2RecompiledFunctionTable[517665] = cvFsReqRd_0x2f9888; // 0x2f988c - g_ps2RecompiledFunctionTable[517666] = cvFsReqRd_0x2f9888; // 0x2f9890 - g_ps2RecompiledFunctionTable[517667] = cvFsReqRd_0x2f9888; // 0x2f9894 - g_ps2RecompiledFunctionTable[517668] = cvFsReqRd_0x2f9888; // 0x2f9898 - g_ps2RecompiledFunctionTable[517669] = cvFsReqRd_0x2f9888; // 0x2f989c - g_ps2RecompiledFunctionTable[517670] = cvFsReqRd_0x2f9888; // 0x2f98a0 - g_ps2RecompiledFunctionTable[517671] = cvFsReqRd_0x2f9888; // 0x2f98a4 - g_ps2RecompiledFunctionTable[517672] = cvFsReqRd_0x2f9888; // 0x2f98a8 - g_ps2RecompiledFunctionTable[517673] = cvFsReqRd_0x2f9888; // 0x2f98ac - g_ps2RecompiledFunctionTable[517674] = cvFsReqRd_0x2f9888; // 0x2f98b0 - g_ps2RecompiledFunctionTable[517675] = cvFsReqRd_0x2f9888; // 0x2f98b4 - g_ps2RecompiledFunctionTable[517676] = cvFsReqRd_0x2f9888; // 0x2f98b8 - g_ps2RecompiledFunctionTable[517677] = cvFsReqRd_0x2f9888; // 0x2f98bc - g_ps2RecompiledFunctionTable[517678] = cvFsReqRd_0x2f9888; // 0x2f98c0 - g_ps2RecompiledFunctionTable[517679] = cvFsReqRd_0x2f9888; // 0x2f98c4 - g_ps2RecompiledFunctionTable[517680] = cvFsReqRd_0x2f9888; // 0x2f98c8 - g_ps2RecompiledFunctionTable[517681] = cvFsReqRd_0x2f9888; // 0x2f98cc - g_ps2RecompiledFunctionTable[517682] = cvFsReqRd_0x2f9888; // 0x2f98d0 - g_ps2RecompiledFunctionTable[517683] = cvFsReqRd_0x2f9888; // 0x2f98d4 - g_ps2RecompiledFunctionTable[517684] = cvFsReqRd_0x2f9888; // 0x2f98d8 - g_ps2RecompiledFunctionTable[517685] = cvFsReqRd_0x2f9888; // 0x2f98dc - g_ps2RecompiledFunctionTable[517686] = cvFsReqRd_0x2f9888; // 0x2f98e0 - g_ps2RecompiledFunctionTable[517687] = cvFsReqRd_0x2f9888; // 0x2f98e4 - g_ps2RecompiledFunctionTable[517688] = cvFsReqRd_0x2f9888; // 0x2f98e8 - g_ps2RecompiledFunctionTable[517690] = cvFsReqWr_0x2f98f0; // 0x2f98f0 - g_ps2RecompiledFunctionTable[517691] = cvFsReqWr_0x2f98f0; // 0x2f98f4 - g_ps2RecompiledFunctionTable[517692] = cvFsReqWr_0x2f98f0; // 0x2f98f8 - g_ps2RecompiledFunctionTable[517693] = cvFsReqWr_0x2f98f0; // 0x2f98fc - g_ps2RecompiledFunctionTable[517694] = cvFsReqWr_0x2f98f0; // 0x2f9900 - g_ps2RecompiledFunctionTable[517695] = cvFsReqWr_0x2f98f0; // 0x2f9904 - g_ps2RecompiledFunctionTable[517696] = cvFsReqWr_0x2f98f0; // 0x2f9908 - g_ps2RecompiledFunctionTable[517697] = cvFsReqWr_0x2f98f0; // 0x2f990c - g_ps2RecompiledFunctionTable[517698] = cvFsReqWr_0x2f98f0; // 0x2f9910 - g_ps2RecompiledFunctionTable[517699] = cvFsReqWr_0x2f98f0; // 0x2f9914 - g_ps2RecompiledFunctionTable[517700] = cvFsReqWr_0x2f98f0; // 0x2f9918 - g_ps2RecompiledFunctionTable[517701] = cvFsReqWr_0x2f98f0; // 0x2f991c - g_ps2RecompiledFunctionTable[517702] = cvFsReqWr_0x2f98f0; // 0x2f9920 - g_ps2RecompiledFunctionTable[517703] = cvFsReqWr_0x2f98f0; // 0x2f9924 - g_ps2RecompiledFunctionTable[517704] = cvFsReqWr_0x2f98f0; // 0x2f9928 - g_ps2RecompiledFunctionTable[517705] = cvFsReqWr_0x2f98f0; // 0x2f992c - g_ps2RecompiledFunctionTable[517706] = cvFsReqWr_0x2f98f0; // 0x2f9930 - g_ps2RecompiledFunctionTable[517707] = cvFsReqWr_0x2f98f0; // 0x2f9934 - g_ps2RecompiledFunctionTable[517708] = cvFsReqWr_0x2f98f0; // 0x2f9938 - g_ps2RecompiledFunctionTable[517709] = cvFsReqWr_0x2f98f0; // 0x2f993c - g_ps2RecompiledFunctionTable[517710] = cvFsReqWr_0x2f98f0; // 0x2f9940 - g_ps2RecompiledFunctionTable[517711] = cvFsReqWr_0x2f98f0; // 0x2f9944 - g_ps2RecompiledFunctionTable[517712] = cvFsReqWr_0x2f98f0; // 0x2f9948 - g_ps2RecompiledFunctionTable[517713] = cvFsReqWr_0x2f98f0; // 0x2f994c - g_ps2RecompiledFunctionTable[517714] = cvFsReqWr_0x2f98f0; // 0x2f9950 - g_ps2RecompiledFunctionTable[517716] = cvFsStopTr_0x2f9958; // 0x2f9958 - g_ps2RecompiledFunctionTable[517717] = cvFsStopTr_0x2f9958; // 0x2f995c - g_ps2RecompiledFunctionTable[517718] = cvFsStopTr_0x2f9958; // 0x2f9960 - g_ps2RecompiledFunctionTable[517719] = cvFsStopTr_0x2f9958; // 0x2f9964 - g_ps2RecompiledFunctionTable[517720] = cvFsStopTr_0x2f9958; // 0x2f9968 - g_ps2RecompiledFunctionTable[517721] = cvFsStopTr_0x2f9958; // 0x2f996c - g_ps2RecompiledFunctionTable[517722] = cvFsStopTr_0x2f9958; // 0x2f9970 - g_ps2RecompiledFunctionTable[517723] = cvFsStopTr_0x2f9958; // 0x2f9974 - g_ps2RecompiledFunctionTable[517724] = cvFsStopTr_0x2f9958; // 0x2f9978 - g_ps2RecompiledFunctionTable[517725] = cvFsStopTr_0x2f9958; // 0x2f997c - g_ps2RecompiledFunctionTable[517726] = cvFsStopTr_0x2f9958; // 0x2f9980 - g_ps2RecompiledFunctionTable[517727] = cvFsStopTr_0x2f9958; // 0x2f9984 - g_ps2RecompiledFunctionTable[517728] = cvFsStopTr_0x2f9958; // 0x2f9988 - g_ps2RecompiledFunctionTable[517729] = cvFsStopTr_0x2f9958; // 0x2f998c - g_ps2RecompiledFunctionTable[517730] = cvFsStopTr_0x2f9958; // 0x2f9990 - g_ps2RecompiledFunctionTable[517731] = cvFsStopTr_0x2f9958; // 0x2f9994 - g_ps2RecompiledFunctionTable[517732] = cvFsStopTr_0x2f9958; // 0x2f9998 - g_ps2RecompiledFunctionTable[517733] = cvFsStopTr_0x2f9958; // 0x2f999c - g_ps2RecompiledFunctionTable[517734] = cvFsStopTr_0x2f9958; // 0x2f99a0 - g_ps2RecompiledFunctionTable[517735] = cvFsStopTr_0x2f9958; // 0x2f99a4 - g_ps2RecompiledFunctionTable[517736] = cvFsStopTr_0x2f9958; // 0x2f99a8 - g_ps2RecompiledFunctionTable[517738] = cvFsExecServer_0x2f99b0; // 0x2f99b0 - g_ps2RecompiledFunctionTable[517739] = cvFsExecServer_0x2f99b0; // 0x2f99b4 - g_ps2RecompiledFunctionTable[517740] = cvFsExecServer_0x2f99b0; // 0x2f99b8 - g_ps2RecompiledFunctionTable[517741] = cvFsExecServer_0x2f99b0; // 0x2f99bc - g_ps2RecompiledFunctionTable[517742] = cvFsExecServer_0x2f99b0; // 0x2f99c0 - g_ps2RecompiledFunctionTable[517743] = cvFsExecServer_0x2f99b0; // 0x2f99c4 - g_ps2RecompiledFunctionTable[517744] = cvFsExecServer_0x2f99b0; // 0x2f99c8 - g_ps2RecompiledFunctionTable[517745] = cvFsExecServer_0x2f99b0; // 0x2f99cc - g_ps2RecompiledFunctionTable[517746] = cvFsExecServer_0x2f99b0; // 0x2f99d0 - g_ps2RecompiledFunctionTable[517747] = cvFsExecServer_0x2f99b0; // 0x2f99d4 - g_ps2RecompiledFunctionTable[517748] = cvFsExecServer_0x2f99b0; // 0x2f99d8 - g_ps2RecompiledFunctionTable[517749] = cvFsExecServer_0x2f99b0; // 0x2f99dc - g_ps2RecompiledFunctionTable[517750] = cvFsExecServer_0x2f99b0; // 0x2f99e0 - g_ps2RecompiledFunctionTable[517751] = cvFsExecServer_0x2f99b0; // 0x2f99e4 - g_ps2RecompiledFunctionTable[517752] = cvFsExecServer_0x2f99b0; // 0x2f99e8 - g_ps2RecompiledFunctionTable[517753] = cvFsExecServer_0x2f99b0; // 0x2f99ec - g_ps2RecompiledFunctionTable[517754] = cvFsExecServer_0x2f99b0; // 0x2f99f0 - g_ps2RecompiledFunctionTable[517755] = cvFsExecServer_0x2f99b0; // 0x2f99f4 - g_ps2RecompiledFunctionTable[517756] = cvFsExecServer_0x2f99b0; // 0x2f99f8 - g_ps2RecompiledFunctionTable[517757] = cvFsExecServer_0x2f99b0; // 0x2f99fc - g_ps2RecompiledFunctionTable[517758] = cvFsExecServer_0x2f99b0; // 0x2f9a00 - g_ps2RecompiledFunctionTable[517759] = cvFsExecServer_0x2f99b0; // 0x2f9a04 - g_ps2RecompiledFunctionTable[517760] = cvFsExecServer_0x2f99b0; // 0x2f9a08 - g_ps2RecompiledFunctionTable[517762] = cvFsGetStat_0x2f9a10; // 0x2f9a10 - g_ps2RecompiledFunctionTable[517763] = cvFsGetStat_0x2f9a10; // 0x2f9a14 - g_ps2RecompiledFunctionTable[517764] = cvFsGetStat_0x2f9a10; // 0x2f9a18 - g_ps2RecompiledFunctionTable[517765] = cvFsGetStat_0x2f9a10; // 0x2f9a1c - g_ps2RecompiledFunctionTable[517766] = cvFsGetStat_0x2f9a10; // 0x2f9a20 - g_ps2RecompiledFunctionTable[517767] = cvFsGetStat_0x2f9a10; // 0x2f9a24 - g_ps2RecompiledFunctionTable[517768] = cvFsGetStat_0x2f9a10; // 0x2f9a28 - g_ps2RecompiledFunctionTable[517769] = cvFsGetStat_0x2f9a10; // 0x2f9a2c - g_ps2RecompiledFunctionTable[517770] = cvFsGetStat_0x2f9a10; // 0x2f9a30 - g_ps2RecompiledFunctionTable[517771] = cvFsGetStat_0x2f9a10; // 0x2f9a34 - g_ps2RecompiledFunctionTable[517772] = cvFsGetStat_0x2f9a10; // 0x2f9a38 - g_ps2RecompiledFunctionTable[517773] = cvFsGetStat_0x2f9a10; // 0x2f9a3c - g_ps2RecompiledFunctionTable[517774] = cvFsGetStat_0x2f9a10; // 0x2f9a40 - g_ps2RecompiledFunctionTable[517775] = cvFsGetStat_0x2f9a10; // 0x2f9a44 - g_ps2RecompiledFunctionTable[517776] = cvFsGetStat_0x2f9a10; // 0x2f9a48 - g_ps2RecompiledFunctionTable[517777] = cvFsGetStat_0x2f9a10; // 0x2f9a4c - g_ps2RecompiledFunctionTable[517778] = cvFsGetStat_0x2f9a10; // 0x2f9a50 - g_ps2RecompiledFunctionTable[517779] = cvFsGetStat_0x2f9a10; // 0x2f9a54 - g_ps2RecompiledFunctionTable[517780] = cvFsGetStat_0x2f9a10; // 0x2f9a58 - g_ps2RecompiledFunctionTable[517781] = cvFsGetStat_0x2f9a10; // 0x2f9a5c - g_ps2RecompiledFunctionTable[517782] = cvFsGetStat_0x2f9a10; // 0x2f9a60 - g_ps2RecompiledFunctionTable[517783] = cvFsGetStat_0x2f9a10; // 0x2f9a64 - g_ps2RecompiledFunctionTable[517784] = cvFsGetStat_0x2f9a10; // 0x2f9a68 - g_ps2RecompiledFunctionTable[517785] = cvFsGetStat_0x2f9a10; // 0x2f9a6c - g_ps2RecompiledFunctionTable[517786] = cvFsGetStat_0x2f9a10; // 0x2f9a70 - g_ps2RecompiledFunctionTable[517788] = cvFsGetFileSize_0x2f9a78; // 0x2f9a78 - g_ps2RecompiledFunctionTable[517789] = cvFsGetFileSize_0x2f9a78; // 0x2f9a7c - g_ps2RecompiledFunctionTable[517790] = cvFsGetFileSize_0x2f9a78; // 0x2f9a80 - g_ps2RecompiledFunctionTable[517791] = cvFsGetFileSize_0x2f9a78; // 0x2f9a84 - g_ps2RecompiledFunctionTable[517792] = cvFsGetFileSize_0x2f9a78; // 0x2f9a88 - g_ps2RecompiledFunctionTable[517793] = cvFsGetFileSize_0x2f9a78; // 0x2f9a8c - g_ps2RecompiledFunctionTable[517794] = cvFsGetFileSize_0x2f9a78; // 0x2f9a90 - g_ps2RecompiledFunctionTable[517795] = cvFsGetFileSize_0x2f9a78; // 0x2f9a94 - g_ps2RecompiledFunctionTable[517796] = cvFsGetFileSize_0x2f9a78; // 0x2f9a98 - g_ps2RecompiledFunctionTable[517797] = cvFsGetFileSize_0x2f9a78; // 0x2f9a9c - g_ps2RecompiledFunctionTable[517798] = cvFsGetFileSize_0x2f9a78; // 0x2f9aa0 - g_ps2RecompiledFunctionTable[517799] = cvFsGetFileSize_0x2f9a78; // 0x2f9aa4 - g_ps2RecompiledFunctionTable[517800] = cvFsGetFileSize_0x2f9a78; // 0x2f9aa8 - g_ps2RecompiledFunctionTable[517801] = cvFsGetFileSize_0x2f9a78; // 0x2f9aac - g_ps2RecompiledFunctionTable[517802] = cvFsGetFileSize_0x2f9a78; // 0x2f9ab0 - g_ps2RecompiledFunctionTable[517803] = cvFsGetFileSize_0x2f9a78; // 0x2f9ab4 - g_ps2RecompiledFunctionTable[517804] = cvFsGetFileSize_0x2f9a78; // 0x2f9ab8 - g_ps2RecompiledFunctionTable[517805] = cvFsGetFileSize_0x2f9a78; // 0x2f9abc - g_ps2RecompiledFunctionTable[517806] = cvFsGetFileSize_0x2f9a78; // 0x2f9ac0 - g_ps2RecompiledFunctionTable[517807] = cvFsGetFileSize_0x2f9a78; // 0x2f9ac4 - g_ps2RecompiledFunctionTable[517808] = cvFsGetFileSize_0x2f9a78; // 0x2f9ac8 - g_ps2RecompiledFunctionTable[517809] = cvFsGetFileSize_0x2f9a78; // 0x2f9acc - g_ps2RecompiledFunctionTable[517810] = cvFsGetFileSize_0x2f9a78; // 0x2f9ad0 - g_ps2RecompiledFunctionTable[517811] = cvFsGetFileSize_0x2f9a78; // 0x2f9ad4 - g_ps2RecompiledFunctionTable[517812] = cvFsGetFileSize_0x2f9a78; // 0x2f9ad8 - g_ps2RecompiledFunctionTable[517813] = cvFsGetFileSize_0x2f9a78; // 0x2f9adc - g_ps2RecompiledFunctionTable[517814] = cvFsGetFileSize_0x2f9a78; // 0x2f9ae0 - g_ps2RecompiledFunctionTable[517815] = cvFsGetFileSize_0x2f9a78; // 0x2f9ae4 - g_ps2RecompiledFunctionTable[517816] = cvFsGetFileSize_0x2f9a78; // 0x2f9ae8 - g_ps2RecompiledFunctionTable[517817] = cvFsGetFileSize_0x2f9a78; // 0x2f9aec - g_ps2RecompiledFunctionTable[517818] = cvFsGetFileSize_0x2f9a78; // 0x2f9af0 - g_ps2RecompiledFunctionTable[517819] = cvFsGetFileSize_0x2f9a78; // 0x2f9af4 - g_ps2RecompiledFunctionTable[517820] = cvFsGetFileSize_0x2f9a78; // 0x2f9af8 - g_ps2RecompiledFunctionTable[517821] = cvFsGetFileSize_0x2f9a78; // 0x2f9afc - g_ps2RecompiledFunctionTable[517822] = cvFsGetFileSize_0x2f9a78; // 0x2f9b00 - g_ps2RecompiledFunctionTable[517823] = cvFsGetFileSize_0x2f9a78; // 0x2f9b04 - g_ps2RecompiledFunctionTable[517824] = cvFsGetFileSize_0x2f9a78; // 0x2f9b08 - g_ps2RecompiledFunctionTable[517825] = cvFsGetFileSize_0x2f9a78; // 0x2f9b0c - g_ps2RecompiledFunctionTable[517826] = cvFsGetFileSize_0x2f9a78; // 0x2f9b10 - g_ps2RecompiledFunctionTable[517827] = cvFsGetFileSize_0x2f9a78; // 0x2f9b14 - g_ps2RecompiledFunctionTable[517828] = cvFsGetFileSize_0x2f9a78; // 0x2f9b18 - g_ps2RecompiledFunctionTable[517829] = cvFsGetFileSize_0x2f9a78; // 0x2f9b1c - g_ps2RecompiledFunctionTable[517830] = cvFsGetFileSize_0x2f9a78; // 0x2f9b20 - g_ps2RecompiledFunctionTable[517831] = cvFsGetFileSize_0x2f9a78; // 0x2f9b24 - g_ps2RecompiledFunctionTable[517832] = cvFsGetFileSize_0x2f9a78; // 0x2f9b28 - g_ps2RecompiledFunctionTable[517833] = cvFsGetFileSize_0x2f9a78; // 0x2f9b2c - g_ps2RecompiledFunctionTable[517834] = cvFsGetFileSize_0x2f9a78; // 0x2f9b30 - g_ps2RecompiledFunctionTable[517836] = cvFsGetFileSizeEx_0x2f9b38; // 0x2f9b38 - g_ps2RecompiledFunctionTable[517837] = cvFsGetFileSizeEx_0x2f9b38; // 0x2f9b3c - g_ps2RecompiledFunctionTable[517838] = cvFsGetFileSizeEx_0x2f9b38; // 0x2f9b40 - g_ps2RecompiledFunctionTable[517839] = cvFsGetFileSizeEx_0x2f9b38; // 0x2f9b44 - g_ps2RecompiledFunctionTable[517840] = cvFsGetFileSizeEx_0x2f9b38; // 0x2f9b48 - g_ps2RecompiledFunctionTable[517841] = cvFsGetFileSizeEx_0x2f9b38; // 0x2f9b4c - g_ps2RecompiledFunctionTable[517842] = cvFsGetFileSizeEx_0x2f9b38; // 0x2f9b50 - g_ps2RecompiledFunctionTable[517843] = cvFsGetFileSizeEx_0x2f9b38; // 0x2f9b54 - g_ps2RecompiledFunctionTable[517844] = cvFsGetFileSizeEx_0x2f9b38; // 0x2f9b58 - g_ps2RecompiledFunctionTable[517845] = cvFsGetFileSizeEx_0x2f9b38; // 0x2f9b5c - g_ps2RecompiledFunctionTable[517846] = cvFsGetFileSizeEx_0x2f9b38; // 0x2f9b60 - g_ps2RecompiledFunctionTable[517847] = cvFsGetFileSizeEx_0x2f9b38; // 0x2f9b64 - g_ps2RecompiledFunctionTable[517848] = cvFsGetFileSizeEx_0x2f9b38; // 0x2f9b68 - g_ps2RecompiledFunctionTable[517849] = cvFsGetFileSizeEx_0x2f9b38; // 0x2f9b6c - g_ps2RecompiledFunctionTable[517850] = cvFsGetFileSizeEx_0x2f9b38; // 0x2f9b70 - g_ps2RecompiledFunctionTable[517851] = cvFsGetFileSizeEx_0x2f9b38; // 0x2f9b74 - g_ps2RecompiledFunctionTable[517852] = cvFsGetFileSizeEx_0x2f9b38; // 0x2f9b78 - g_ps2RecompiledFunctionTable[517853] = cvFsGetFileSizeEx_0x2f9b38; // 0x2f9b7c - g_ps2RecompiledFunctionTable[517854] = cvFsGetFileSizeEx_0x2f9b38; // 0x2f9b80 - g_ps2RecompiledFunctionTable[517855] = cvFsGetFileSizeEx_0x2f9b38; // 0x2f9b84 - g_ps2RecompiledFunctionTable[517856] = cvFsGetFileSizeEx_0x2f9b38; // 0x2f9b88 - g_ps2RecompiledFunctionTable[517857] = cvFsGetFileSizeEx_0x2f9b38; // 0x2f9b8c - g_ps2RecompiledFunctionTable[517858] = cvFsGetFileSizeEx_0x2f9b38; // 0x2f9b90 - g_ps2RecompiledFunctionTable[517859] = cvFsGetFileSizeEx_0x2f9b38; // 0x2f9b94 - g_ps2RecompiledFunctionTable[517860] = cvFsGetFileSizeEx_0x2f9b38; // 0x2f9b98 - g_ps2RecompiledFunctionTable[517861] = cvFsGetFileSizeEx_0x2f9b38; // 0x2f9b9c - g_ps2RecompiledFunctionTable[517862] = cvFsGetFileSizeEx_0x2f9b38; // 0x2f9ba0 - g_ps2RecompiledFunctionTable[517863] = cvFsGetFileSizeEx_0x2f9b38; // 0x2f9ba4 - g_ps2RecompiledFunctionTable[517864] = cvFsGetFileSizeEx_0x2f9b38; // 0x2f9ba8 - g_ps2RecompiledFunctionTable[517865] = cvFsGetFileSizeEx_0x2f9b38; // 0x2f9bac - g_ps2RecompiledFunctionTable[517866] = cvFsGetFileSizeEx_0x2f9b38; // 0x2f9bb0 - g_ps2RecompiledFunctionTable[517867] = cvFsGetFileSizeEx_0x2f9b38; // 0x2f9bb4 - g_ps2RecompiledFunctionTable[517868] = cvFsGetFileSizeEx_0x2f9b38; // 0x2f9bb8 - g_ps2RecompiledFunctionTable[517869] = cvFsGetFileSizeEx_0x2f9b38; // 0x2f9bbc - g_ps2RecompiledFunctionTable[517870] = cvFsGetFileSizeEx_0x2f9b38; // 0x2f9bc0 - g_ps2RecompiledFunctionTable[517871] = cvFsGetFileSizeEx_0x2f9b38; // 0x2f9bc4 - g_ps2RecompiledFunctionTable[517872] = cvFsGetFileSizeEx_0x2f9b38; // 0x2f9bc8 - g_ps2RecompiledFunctionTable[517873] = cvFsGetFileSizeEx_0x2f9b38; // 0x2f9bcc - g_ps2RecompiledFunctionTable[517874] = cvFsGetFileSizeEx_0x2f9b38; // 0x2f9bd0 - g_ps2RecompiledFunctionTable[517875] = cvFsGetFileSizeEx_0x2f9b38; // 0x2f9bd4 - g_ps2RecompiledFunctionTable[517876] = cvFsGetFileSizeEx_0x2f9b38; // 0x2f9bd8 - g_ps2RecompiledFunctionTable[517877] = cvFsGetFileSizeEx_0x2f9b38; // 0x2f9bdc - g_ps2RecompiledFunctionTable[517878] = cvFsGetFileSizeEx_0x2f9b38; // 0x2f9be0 - g_ps2RecompiledFunctionTable[517879] = cvFsGetFileSizeEx_0x2f9b38; // 0x2f9be4 - g_ps2RecompiledFunctionTable[517880] = cvFsGetFileSizeEx_0x2f9b38; // 0x2f9be8 - g_ps2RecompiledFunctionTable[517881] = cvFsGetFileSizeEx_0x2f9b38; // 0x2f9bec - g_ps2RecompiledFunctionTable[517882] = cvFsGetFileSizeEx_0x2f9b38; // 0x2f9bf0 - g_ps2RecompiledFunctionTable[517883] = cvFsGetFileSizeEx_0x2f9b38; // 0x2f9bf4 - g_ps2RecompiledFunctionTable[517884] = cvFsGetFileSizeEx_0x2f9b38; // 0x2f9bf8 - g_ps2RecompiledFunctionTable[517885] = cvFsGetFileSizeEx_0x2f9b38; // 0x2f9bfc - g_ps2RecompiledFunctionTable[517886] = cvFsGetFileSizeEx_0x2f9b38; // 0x2f9c00 - g_ps2RecompiledFunctionTable[517888] = cvFsGetFreeSize_0x2f9c08; // 0x2f9c08 - g_ps2RecompiledFunctionTable[517889] = cvFsGetFreeSize_0x2f9c08; // 0x2f9c0c - g_ps2RecompiledFunctionTable[517890] = cvFsGetFreeSize_0x2f9c08; // 0x2f9c10 - g_ps2RecompiledFunctionTable[517891] = cvFsGetFreeSize_0x2f9c08; // 0x2f9c14 - g_ps2RecompiledFunctionTable[517892] = cvFsGetFreeSize_0x2f9c08; // 0x2f9c18 - g_ps2RecompiledFunctionTable[517893] = cvFsGetFreeSize_0x2f9c08; // 0x2f9c1c - g_ps2RecompiledFunctionTable[517894] = cvFsGetFreeSize_0x2f9c08; // 0x2f9c20 - g_ps2RecompiledFunctionTable[517895] = cvFsGetFreeSize_0x2f9c08; // 0x2f9c24 - g_ps2RecompiledFunctionTable[517896] = cvFsGetFreeSize_0x2f9c08; // 0x2f9c28 - g_ps2RecompiledFunctionTable[517897] = cvFsGetFreeSize_0x2f9c08; // 0x2f9c2c - g_ps2RecompiledFunctionTable[517898] = cvFsGetFreeSize_0x2f9c08; // 0x2f9c30 - g_ps2RecompiledFunctionTable[517899] = cvFsGetFreeSize_0x2f9c08; // 0x2f9c34 - g_ps2RecompiledFunctionTable[517900] = cvFsGetFreeSize_0x2f9c08; // 0x2f9c38 - g_ps2RecompiledFunctionTable[517901] = cvFsGetFreeSize_0x2f9c08; // 0x2f9c3c - g_ps2RecompiledFunctionTable[517902] = cvFsGetFreeSize_0x2f9c08; // 0x2f9c40 - g_ps2RecompiledFunctionTable[517903] = cvFsGetFreeSize_0x2f9c08; // 0x2f9c44 - g_ps2RecompiledFunctionTable[517904] = cvFsGetFreeSize_0x2f9c08; // 0x2f9c48 - g_ps2RecompiledFunctionTable[517905] = cvFsGetFreeSize_0x2f9c08; // 0x2f9c4c - g_ps2RecompiledFunctionTable[517906] = cvFsGetFreeSize_0x2f9c08; // 0x2f9c50 - g_ps2RecompiledFunctionTable[517907] = cvFsGetFreeSize_0x2f9c08; // 0x2f9c54 - g_ps2RecompiledFunctionTable[517908] = cvFsGetFreeSize_0x2f9c08; // 0x2f9c58 - g_ps2RecompiledFunctionTable[517909] = cvFsGetFreeSize_0x2f9c08; // 0x2f9c5c - g_ps2RecompiledFunctionTable[517910] = cvFsGetFreeSize_0x2f9c08; // 0x2f9c60 - g_ps2RecompiledFunctionTable[517911] = cvFsGetFreeSize_0x2f9c08; // 0x2f9c64 - g_ps2RecompiledFunctionTable[517912] = cvFsGetFreeSize_0x2f9c08; // 0x2f9c68 - g_ps2RecompiledFunctionTable[517913] = cvFsGetFreeSize_0x2f9c08; // 0x2f9c6c - g_ps2RecompiledFunctionTable[517914] = cvFsGetFreeSize_0x2f9c08; // 0x2f9c70 - g_ps2RecompiledFunctionTable[517915] = cvFsGetFreeSize_0x2f9c08; // 0x2f9c74 - g_ps2RecompiledFunctionTable[517916] = cvFsGetFreeSize_0x2f9c08; // 0x2f9c78 - g_ps2RecompiledFunctionTable[517917] = cvFsGetFreeSize_0x2f9c08; // 0x2f9c7c - g_ps2RecompiledFunctionTable[517918] = cvFsGetFreeSize_0x2f9c08; // 0x2f9c80 - g_ps2RecompiledFunctionTable[517919] = cvFsGetFreeSize_0x2f9c08; // 0x2f9c84 - g_ps2RecompiledFunctionTable[517920] = cvFsGetFreeSize_0x2f9c08; // 0x2f9c88 - g_ps2RecompiledFunctionTable[517921] = cvFsGetFreeSize_0x2f9c08; // 0x2f9c8c - g_ps2RecompiledFunctionTable[517922] = cvFsGetFreeSize_0x2f9c08; // 0x2f9c90 - g_ps2RecompiledFunctionTable[517923] = cvFsGetFreeSize_0x2f9c08; // 0x2f9c94 - g_ps2RecompiledFunctionTable[517924] = cvFsGetFreeSize_0x2f9c08; // 0x2f9c98 - g_ps2RecompiledFunctionTable[517925] = cvFsGetFreeSize_0x2f9c08; // 0x2f9c9c - g_ps2RecompiledFunctionTable[517926] = cvFsGetFreeSize_0x2f9c08; // 0x2f9ca0 - g_ps2RecompiledFunctionTable[517927] = cvFsGetFreeSize_0x2f9c08; // 0x2f9ca4 - g_ps2RecompiledFunctionTable[517928] = cvFsGetFreeSize_0x2f9c08; // 0x2f9ca8 - g_ps2RecompiledFunctionTable[517929] = cvFsGetFreeSize_0x2f9c08; // 0x2f9cac - g_ps2RecompiledFunctionTable[517930] = cvFsGetFreeSize_0x2f9c08; // 0x2f9cb0 - g_ps2RecompiledFunctionTable[517931] = cvFsGetFreeSize_0x2f9c08; // 0x2f9cb4 - g_ps2RecompiledFunctionTable[517932] = cvFsGetFreeSize_0x2f9c08; // 0x2f9cb8 - g_ps2RecompiledFunctionTable[517933] = cvFsGetFreeSize_0x2f9c08; // 0x2f9cbc - g_ps2RecompiledFunctionTable[517934] = cvFsGetFreeSize_0x2f9c08; // 0x2f9cc0 - g_ps2RecompiledFunctionTable[517935] = cvFsGetFreeSize_0x2f9c08; // 0x2f9cc4 - g_ps2RecompiledFunctionTable[517936] = cvFsGetFreeSize_0x2f9c08; // 0x2f9cc8 - g_ps2RecompiledFunctionTable[517937] = cvFsGetFreeSize_0x2f9c08; // 0x2f9ccc - g_ps2RecompiledFunctionTable[517938] = cvFsGetFreeSize_0x2f9c08; // 0x2f9cd0 - g_ps2RecompiledFunctionTable[517939] = cvFsGetFreeSize_0x2f9c08; // 0x2f9cd4 - g_ps2RecompiledFunctionTable[517940] = cvFsGetFreeSize_0x2f9c08; // 0x2f9cd8 - g_ps2RecompiledFunctionTable[517941] = cvFsGetFreeSize_0x2f9c08; // 0x2f9cdc - g_ps2RecompiledFunctionTable[517942] = cvFsGetFreeSize_0x2f9c08; // 0x2f9ce0 - g_ps2RecompiledFunctionTable[517943] = cvFsGetFreeSize_0x2f9c08; // 0x2f9ce4 - g_ps2RecompiledFunctionTable[517944] = cvFsGetFreeSize_0x2f9c08; // 0x2f9ce8 - g_ps2RecompiledFunctionTable[517945] = cvFsGetFreeSize_0x2f9c08; // 0x2f9cec - g_ps2RecompiledFunctionTable[517946] = cvFsGetFreeSize_0x2f9c08; // 0x2f9cf0 - g_ps2RecompiledFunctionTable[517947] = cvFsGetFreeSize_0x2f9c08; // 0x2f9cf4 - g_ps2RecompiledFunctionTable[517948] = cvFsGetFreeSize_0x2f9c08; // 0x2f9cf8 - g_ps2RecompiledFunctionTable[517949] = cvFsGetFreeSize_0x2f9c08; // 0x2f9cfc - g_ps2RecompiledFunctionTable[517950] = cvFsGetFreeSize_0x2f9c08; // 0x2f9d00 - g_ps2RecompiledFunctionTable[517951] = cvFsGetFreeSize_0x2f9c08; // 0x2f9d04 - g_ps2RecompiledFunctionTable[517952] = cvFsGetFreeSize_0x2f9c08; // 0x2f9d08 - g_ps2RecompiledFunctionTable[517953] = cvFsGetFreeSize_0x2f9c08; // 0x2f9d0c - g_ps2RecompiledFunctionTable[517954] = cvFsGetFreeSize_0x2f9c08; // 0x2f9d10 - g_ps2RecompiledFunctionTable[517955] = cvFsGetFreeSize_0x2f9c08; // 0x2f9d14 - g_ps2RecompiledFunctionTable[517956] = cvFsGetFreeSize_0x2f9c08; // 0x2f9d18 - g_ps2RecompiledFunctionTable[517957] = cvFsGetFreeSize_0x2f9c08; // 0x2f9d1c - g_ps2RecompiledFunctionTable[517958] = cvFsGetFreeSize_0x2f9c08; // 0x2f9d20 - g_ps2RecompiledFunctionTable[517959] = cvFsGetFreeSize_0x2f9c08; // 0x2f9d24 - g_ps2RecompiledFunctionTable[517960] = cvFsGetSctLen_0x2f9d28; // 0x2f9d28 - g_ps2RecompiledFunctionTable[517961] = cvFsGetSctLen_0x2f9d28; // 0x2f9d2c - g_ps2RecompiledFunctionTable[517962] = cvFsGetSctLen_0x2f9d28; // 0x2f9d30 - g_ps2RecompiledFunctionTable[517963] = cvFsGetSctLen_0x2f9d28; // 0x2f9d34 - g_ps2RecompiledFunctionTable[517964] = cvFsGetSctLen_0x2f9d28; // 0x2f9d38 - g_ps2RecompiledFunctionTable[517965] = cvFsGetSctLen_0x2f9d28; // 0x2f9d3c - g_ps2RecompiledFunctionTable[517966] = cvFsGetSctLen_0x2f9d28; // 0x2f9d40 - g_ps2RecompiledFunctionTable[517967] = cvFsGetSctLen_0x2f9d28; // 0x2f9d44 - g_ps2RecompiledFunctionTable[517968] = cvFsGetSctLen_0x2f9d28; // 0x2f9d48 - g_ps2RecompiledFunctionTable[517969] = cvFsGetSctLen_0x2f9d28; // 0x2f9d4c - g_ps2RecompiledFunctionTable[517970] = cvFsGetSctLen_0x2f9d28; // 0x2f9d50 - g_ps2RecompiledFunctionTable[517971] = cvFsGetSctLen_0x2f9d28; // 0x2f9d54 - g_ps2RecompiledFunctionTable[517972] = cvFsGetSctLen_0x2f9d28; // 0x2f9d58 - g_ps2RecompiledFunctionTable[517973] = cvFsGetSctLen_0x2f9d28; // 0x2f9d5c - g_ps2RecompiledFunctionTable[517974] = cvFsGetSctLen_0x2f9d28; // 0x2f9d60 - g_ps2RecompiledFunctionTable[517975] = cvFsGetSctLen_0x2f9d28; // 0x2f9d64 - g_ps2RecompiledFunctionTable[517976] = cvFsGetSctLen_0x2f9d28; // 0x2f9d68 - g_ps2RecompiledFunctionTable[517977] = cvFsGetSctLen_0x2f9d28; // 0x2f9d6c - g_ps2RecompiledFunctionTable[517978] = cvFsGetSctLen_0x2f9d28; // 0x2f9d70 - g_ps2RecompiledFunctionTable[517979] = cvFsGetSctLen_0x2f9d28; // 0x2f9d74 - g_ps2RecompiledFunctionTable[517980] = cvFsGetSctLen_0x2f9d28; // 0x2f9d78 - g_ps2RecompiledFunctionTable[517981] = cvFsGetSctLen_0x2f9d28; // 0x2f9d7c - g_ps2RecompiledFunctionTable[517982] = cvFsGetSctLen_0x2f9d28; // 0x2f9d80 - g_ps2RecompiledFunctionTable[517983] = cvFsGetSctLen_0x2f9d28; // 0x2f9d84 - g_ps2RecompiledFunctionTable[517984] = cvFsGetSctLen_0x2f9d28; // 0x2f9d88 - g_ps2RecompiledFunctionTable[517986] = cvFsSetSctLen_0x2f9d90; // 0x2f9d90 - g_ps2RecompiledFunctionTable[517987] = cvFsSetSctLen_0x2f9d90; // 0x2f9d94 - g_ps2RecompiledFunctionTable[517988] = cvFsSetSctLen_0x2f9d90; // 0x2f9d98 - g_ps2RecompiledFunctionTable[517989] = cvFsSetSctLen_0x2f9d90; // 0x2f9d9c - g_ps2RecompiledFunctionTable[517990] = cvFsSetSctLen_0x2f9d90; // 0x2f9da0 - g_ps2RecompiledFunctionTable[517991] = cvFsSetSctLen_0x2f9d90; // 0x2f9da4 - g_ps2RecompiledFunctionTable[517992] = cvFsSetSctLen_0x2f9d90; // 0x2f9da8 - g_ps2RecompiledFunctionTable[517993] = cvFsSetSctLen_0x2f9d90; // 0x2f9dac - g_ps2RecompiledFunctionTable[517994] = cvFsSetSctLen_0x2f9d90; // 0x2f9db0 - g_ps2RecompiledFunctionTable[517995] = cvFsSetSctLen_0x2f9d90; // 0x2f9db4 - g_ps2RecompiledFunctionTable[517996] = cvFsSetSctLen_0x2f9d90; // 0x2f9db8 - g_ps2RecompiledFunctionTable[517997] = cvFsSetSctLen_0x2f9d90; // 0x2f9dbc - g_ps2RecompiledFunctionTable[517998] = cvFsSetSctLen_0x2f9d90; // 0x2f9dc0 - g_ps2RecompiledFunctionTable[517999] = cvFsSetSctLen_0x2f9d90; // 0x2f9dc4 - g_ps2RecompiledFunctionTable[518000] = cvFsSetSctLen_0x2f9d90; // 0x2f9dc8 - g_ps2RecompiledFunctionTable[518001] = cvFsSetSctLen_0x2f9d90; // 0x2f9dcc - g_ps2RecompiledFunctionTable[518002] = cvFsSetSctLen_0x2f9d90; // 0x2f9dd0 - g_ps2RecompiledFunctionTable[518003] = cvFsSetSctLen_0x2f9d90; // 0x2f9dd4 - g_ps2RecompiledFunctionTable[518004] = cvFsSetSctLen_0x2f9d90; // 0x2f9dd8 - g_ps2RecompiledFunctionTable[518005] = cvFsSetSctLen_0x2f9d90; // 0x2f9ddc - g_ps2RecompiledFunctionTable[518006] = cvFsSetSctLen_0x2f9d90; // 0x2f9de0 - g_ps2RecompiledFunctionTable[518008] = cvFsGetNumTr_0x2f9de8; // 0x2f9de8 - g_ps2RecompiledFunctionTable[518009] = cvFsGetNumTr_0x2f9de8; // 0x2f9dec - g_ps2RecompiledFunctionTable[518010] = cvFsGetNumTr_0x2f9de8; // 0x2f9df0 - g_ps2RecompiledFunctionTable[518011] = cvFsGetNumTr_0x2f9de8; // 0x2f9df4 - g_ps2RecompiledFunctionTable[518012] = cvFsGetNumTr_0x2f9de8; // 0x2f9df8 - g_ps2RecompiledFunctionTable[518013] = cvFsGetNumTr_0x2f9de8; // 0x2f9dfc - g_ps2RecompiledFunctionTable[518014] = cvFsGetNumTr_0x2f9de8; // 0x2f9e00 - g_ps2RecompiledFunctionTable[518015] = cvFsGetNumTr_0x2f9de8; // 0x2f9e04 - g_ps2RecompiledFunctionTable[518016] = cvFsGetNumTr_0x2f9de8; // 0x2f9e08 - g_ps2RecompiledFunctionTable[518017] = cvFsGetNumTr_0x2f9de8; // 0x2f9e0c - g_ps2RecompiledFunctionTable[518018] = cvFsGetNumTr_0x2f9de8; // 0x2f9e10 - g_ps2RecompiledFunctionTable[518019] = cvFsGetNumTr_0x2f9de8; // 0x2f9e14 - g_ps2RecompiledFunctionTable[518020] = cvFsGetNumTr_0x2f9de8; // 0x2f9e18 - g_ps2RecompiledFunctionTable[518021] = cvFsGetNumTr_0x2f9de8; // 0x2f9e1c - g_ps2RecompiledFunctionTable[518022] = cvFsGetNumTr_0x2f9de8; // 0x2f9e20 - g_ps2RecompiledFunctionTable[518023] = cvFsGetNumTr_0x2f9de8; // 0x2f9e24 - g_ps2RecompiledFunctionTable[518024] = cvFsGetNumTr_0x2f9de8; // 0x2f9e28 - g_ps2RecompiledFunctionTable[518025] = cvFsGetNumTr_0x2f9de8; // 0x2f9e2c - g_ps2RecompiledFunctionTable[518026] = cvFsGetNumTr_0x2f9de8; // 0x2f9e30 - g_ps2RecompiledFunctionTable[518027] = cvFsGetNumTr_0x2f9de8; // 0x2f9e34 - g_ps2RecompiledFunctionTable[518028] = cvFsGetNumTr_0x2f9de8; // 0x2f9e38 - g_ps2RecompiledFunctionTable[518029] = cvFsGetNumTr_0x2f9de8; // 0x2f9e3c - g_ps2RecompiledFunctionTable[518030] = cvFsGetNumTr_0x2f9de8; // 0x2f9e40 - g_ps2RecompiledFunctionTable[518031] = cvFsGetNumTr_0x2f9de8; // 0x2f9e44 - g_ps2RecompiledFunctionTable[518032] = cvFsGetNumTr_0x2f9de8; // 0x2f9e48 - g_ps2RecompiledFunctionTable[518034] = cvFsChangeDir_0x2f9e50; // 0x2f9e50 - g_ps2RecompiledFunctionTable[518035] = cvFsChangeDir_0x2f9e50; // 0x2f9e54 - g_ps2RecompiledFunctionTable[518036] = cvFsChangeDir_0x2f9e50; // 0x2f9e58 - g_ps2RecompiledFunctionTable[518037] = cvFsChangeDir_0x2f9e50; // 0x2f9e5c - g_ps2RecompiledFunctionTable[518038] = cvFsChangeDir_0x2f9e50; // 0x2f9e60 - g_ps2RecompiledFunctionTable[518039] = cvFsChangeDir_0x2f9e50; // 0x2f9e64 - g_ps2RecompiledFunctionTable[518040] = cvFsChangeDir_0x2f9e50; // 0x2f9e68 - g_ps2RecompiledFunctionTable[518041] = cvFsChangeDir_0x2f9e50; // 0x2f9e6c - g_ps2RecompiledFunctionTable[518042] = cvFsChangeDir_0x2f9e50; // 0x2f9e70 - g_ps2RecompiledFunctionTable[518043] = cvFsChangeDir_0x2f9e50; // 0x2f9e74 - g_ps2RecompiledFunctionTable[518044] = cvFsChangeDir_0x2f9e50; // 0x2f9e78 - g_ps2RecompiledFunctionTable[518045] = cvFsChangeDir_0x2f9e50; // 0x2f9e7c - g_ps2RecompiledFunctionTable[518046] = cvFsChangeDir_0x2f9e50; // 0x2f9e80 - g_ps2RecompiledFunctionTable[518047] = cvFsChangeDir_0x2f9e50; // 0x2f9e84 - g_ps2RecompiledFunctionTable[518048] = cvFsChangeDir_0x2f9e50; // 0x2f9e88 - g_ps2RecompiledFunctionTable[518049] = cvFsChangeDir_0x2f9e50; // 0x2f9e8c - g_ps2RecompiledFunctionTable[518050] = cvFsChangeDir_0x2f9e50; // 0x2f9e90 - g_ps2RecompiledFunctionTable[518051] = cvFsChangeDir_0x2f9e50; // 0x2f9e94 - g_ps2RecompiledFunctionTable[518052] = cvFsChangeDir_0x2f9e50; // 0x2f9e98 - g_ps2RecompiledFunctionTable[518053] = cvFsChangeDir_0x2f9e50; // 0x2f9e9c - g_ps2RecompiledFunctionTable[518054] = cvFsChangeDir_0x2f9e50; // 0x2f9ea0 - g_ps2RecompiledFunctionTable[518055] = cvFsChangeDir_0x2f9e50; // 0x2f9ea4 - g_ps2RecompiledFunctionTable[518056] = cvFsChangeDir_0x2f9e50; // 0x2f9ea8 - g_ps2RecompiledFunctionTable[518057] = cvFsChangeDir_0x2f9e50; // 0x2f9eac - g_ps2RecompiledFunctionTable[518058] = cvFsChangeDir_0x2f9e50; // 0x2f9eb0 - g_ps2RecompiledFunctionTable[518059] = cvFsChangeDir_0x2f9e50; // 0x2f9eb4 - g_ps2RecompiledFunctionTable[518060] = cvFsChangeDir_0x2f9e50; // 0x2f9eb8 - g_ps2RecompiledFunctionTable[518061] = cvFsChangeDir_0x2f9e50; // 0x2f9ebc - g_ps2RecompiledFunctionTable[518062] = cvFsChangeDir_0x2f9e50; // 0x2f9ec0 - g_ps2RecompiledFunctionTable[518063] = cvFsChangeDir_0x2f9e50; // 0x2f9ec4 - g_ps2RecompiledFunctionTable[518064] = cvFsChangeDir_0x2f9e50; // 0x2f9ec8 - g_ps2RecompiledFunctionTable[518065] = cvFsChangeDir_0x2f9e50; // 0x2f9ecc - g_ps2RecompiledFunctionTable[518066] = cvFsChangeDir_0x2f9e50; // 0x2f9ed0 - g_ps2RecompiledFunctionTable[518067] = cvFsChangeDir_0x2f9e50; // 0x2f9ed4 - g_ps2RecompiledFunctionTable[518068] = cvFsChangeDir_0x2f9e50; // 0x2f9ed8 - g_ps2RecompiledFunctionTable[518069] = cvFsChangeDir_0x2f9e50; // 0x2f9edc - g_ps2RecompiledFunctionTable[518070] = cvFsChangeDir_0x2f9e50; // 0x2f9ee0 - g_ps2RecompiledFunctionTable[518071] = cvFsChangeDir_0x2f9e50; // 0x2f9ee4 - g_ps2RecompiledFunctionTable[518072] = cvFsChangeDir_0x2f9e50; // 0x2f9ee8 - g_ps2RecompiledFunctionTable[518073] = cvFsChangeDir_0x2f9e50; // 0x2f9eec - g_ps2RecompiledFunctionTable[518074] = cvFsChangeDir_0x2f9e50; // 0x2f9ef0 - g_ps2RecompiledFunctionTable[518075] = cvFsChangeDir_0x2f9e50; // 0x2f9ef4 - g_ps2RecompiledFunctionTable[518076] = cvFsChangeDir_0x2f9e50; // 0x2f9ef8 - g_ps2RecompiledFunctionTable[518077] = cvFsChangeDir_0x2f9e50; // 0x2f9efc - g_ps2RecompiledFunctionTable[518078] = cvFsChangeDir_0x2f9e50; // 0x2f9f00 - g_ps2RecompiledFunctionTable[518079] = cvFsChangeDir_0x2f9e50; // 0x2f9f04 - g_ps2RecompiledFunctionTable[518080] = cvFsChangeDir_0x2f9e50; // 0x2f9f08 - g_ps2RecompiledFunctionTable[518082] = cvFsIsExistFile_0x2f9f10; // 0x2f9f10 - g_ps2RecompiledFunctionTable[518083] = cvFsIsExistFile_0x2f9f10; // 0x2f9f14 - g_ps2RecompiledFunctionTable[518084] = cvFsIsExistFile_0x2f9f10; // 0x2f9f18 - g_ps2RecompiledFunctionTable[518085] = cvFsIsExistFile_0x2f9f10; // 0x2f9f1c - g_ps2RecompiledFunctionTable[518086] = cvFsIsExistFile_0x2f9f10; // 0x2f9f20 - g_ps2RecompiledFunctionTable[518087] = cvFsIsExistFile_0x2f9f10; // 0x2f9f24 - g_ps2RecompiledFunctionTable[518088] = cvFsIsExistFile_0x2f9f10; // 0x2f9f28 - g_ps2RecompiledFunctionTable[518089] = cvFsIsExistFile_0x2f9f10; // 0x2f9f2c - g_ps2RecompiledFunctionTable[518090] = cvFsIsExistFile_0x2f9f10; // 0x2f9f30 - g_ps2RecompiledFunctionTable[518091] = cvFsIsExistFile_0x2f9f10; // 0x2f9f34 - g_ps2RecompiledFunctionTable[518092] = cvFsIsExistFile_0x2f9f10; // 0x2f9f38 - g_ps2RecompiledFunctionTable[518093] = cvFsIsExistFile_0x2f9f10; // 0x2f9f3c - g_ps2RecompiledFunctionTable[518094] = cvFsIsExistFile_0x2f9f10; // 0x2f9f40 - g_ps2RecompiledFunctionTable[518095] = cvFsIsExistFile_0x2f9f10; // 0x2f9f44 - g_ps2RecompiledFunctionTable[518096] = cvFsIsExistFile_0x2f9f10; // 0x2f9f48 - g_ps2RecompiledFunctionTable[518097] = cvFsIsExistFile_0x2f9f10; // 0x2f9f4c - g_ps2RecompiledFunctionTable[518098] = cvFsIsExistFile_0x2f9f10; // 0x2f9f50 - g_ps2RecompiledFunctionTable[518099] = cvFsIsExistFile_0x2f9f10; // 0x2f9f54 - g_ps2RecompiledFunctionTable[518100] = cvFsIsExistFile_0x2f9f10; // 0x2f9f58 - g_ps2RecompiledFunctionTable[518101] = cvFsIsExistFile_0x2f9f10; // 0x2f9f5c - g_ps2RecompiledFunctionTable[518102] = cvFsIsExistFile_0x2f9f10; // 0x2f9f60 - g_ps2RecompiledFunctionTable[518103] = cvFsIsExistFile_0x2f9f10; // 0x2f9f64 - g_ps2RecompiledFunctionTable[518104] = cvFsIsExistFile_0x2f9f10; // 0x2f9f68 - g_ps2RecompiledFunctionTable[518105] = cvFsIsExistFile_0x2f9f10; // 0x2f9f6c - g_ps2RecompiledFunctionTable[518106] = cvFsIsExistFile_0x2f9f10; // 0x2f9f70 - g_ps2RecompiledFunctionTable[518107] = cvFsIsExistFile_0x2f9f10; // 0x2f9f74 - g_ps2RecompiledFunctionTable[518108] = cvFsIsExistFile_0x2f9f10; // 0x2f9f78 - g_ps2RecompiledFunctionTable[518109] = cvFsIsExistFile_0x2f9f10; // 0x2f9f7c - g_ps2RecompiledFunctionTable[518110] = cvFsIsExistFile_0x2f9f10; // 0x2f9f80 - g_ps2RecompiledFunctionTable[518111] = cvFsIsExistFile_0x2f9f10; // 0x2f9f84 - g_ps2RecompiledFunctionTable[518112] = cvFsIsExistFile_0x2f9f10; // 0x2f9f88 - g_ps2RecompiledFunctionTable[518113] = cvFsIsExistFile_0x2f9f10; // 0x2f9f8c - g_ps2RecompiledFunctionTable[518114] = cvFsIsExistFile_0x2f9f10; // 0x2f9f90 - g_ps2RecompiledFunctionTable[518115] = cvFsIsExistFile_0x2f9f10; // 0x2f9f94 - g_ps2RecompiledFunctionTable[518116] = cvFsIsExistFile_0x2f9f10; // 0x2f9f98 - g_ps2RecompiledFunctionTable[518117] = cvFsIsExistFile_0x2f9f10; // 0x2f9f9c - g_ps2RecompiledFunctionTable[518118] = cvFsIsExistFile_0x2f9f10; // 0x2f9fa0 - g_ps2RecompiledFunctionTable[518119] = cvFsIsExistFile_0x2f9f10; // 0x2f9fa4 - g_ps2RecompiledFunctionTable[518120] = cvFsIsExistFile_0x2f9f10; // 0x2f9fa8 - g_ps2RecompiledFunctionTable[518121] = cvFsIsExistFile_0x2f9f10; // 0x2f9fac - g_ps2RecompiledFunctionTable[518122] = cvFsIsExistFile_0x2f9f10; // 0x2f9fb0 - g_ps2RecompiledFunctionTable[518123] = cvFsIsExistFile_0x2f9f10; // 0x2f9fb4 - g_ps2RecompiledFunctionTable[518124] = cvFsIsExistFile_0x2f9f10; // 0x2f9fb8 - g_ps2RecompiledFunctionTable[518126] = cvFsGetNumFiles_0x2f9fc0; // 0x2f9fc0 - g_ps2RecompiledFunctionTable[518132] = cvFsGetNumFiles_0x2f9fc0; // 0x2f9fd8 - g_ps2RecompiledFunctionTable[518136] = cvFsGetNumFiles_0x2f9fc0; // 0x2f9fe8 - g_ps2RecompiledFunctionTable[518142] = cvFsGetNumFiles_0x2f9fc0; // 0x2fa000 - g_ps2RecompiledFunctionTable[518148] = getNumFilesAll_0x2fa018; // 0x2fa018 - g_ps2RecompiledFunctionTable[518149] = getNumFilesAll_0x2fa018; // 0x2fa01c - g_ps2RecompiledFunctionTable[518150] = getNumFilesAll_0x2fa018; // 0x2fa020 - g_ps2RecompiledFunctionTable[518151] = getNumFilesAll_0x2fa018; // 0x2fa024 - g_ps2RecompiledFunctionTable[518152] = getNumFilesAll_0x2fa018; // 0x2fa028 - g_ps2RecompiledFunctionTable[518153] = getNumFilesAll_0x2fa018; // 0x2fa02c - g_ps2RecompiledFunctionTable[518154] = getNumFilesAll_0x2fa018; // 0x2fa030 - g_ps2RecompiledFunctionTable[518155] = getNumFilesAll_0x2fa018; // 0x2fa034 - g_ps2RecompiledFunctionTable[518156] = getNumFilesAll_0x2fa018; // 0x2fa038 - g_ps2RecompiledFunctionTable[518157] = getNumFilesAll_0x2fa018; // 0x2fa03c - g_ps2RecompiledFunctionTable[518158] = getNumFilesAll_0x2fa018; // 0x2fa040 - g_ps2RecompiledFunctionTable[518159] = getNumFilesAll_0x2fa018; // 0x2fa044 - g_ps2RecompiledFunctionTable[518160] = getNumFilesAll_0x2fa018; // 0x2fa048 - g_ps2RecompiledFunctionTable[518161] = getNumFilesAll_0x2fa018; // 0x2fa04c - g_ps2RecompiledFunctionTable[518162] = getNumFilesAll_0x2fa018; // 0x2fa050 - g_ps2RecompiledFunctionTable[518163] = getNumFilesAll_0x2fa018; // 0x2fa054 - g_ps2RecompiledFunctionTable[518164] = getNumFilesAll_0x2fa018; // 0x2fa058 - g_ps2RecompiledFunctionTable[518165] = getNumFilesAll_0x2fa018; // 0x2fa05c - g_ps2RecompiledFunctionTable[518166] = getNumFilesAll_0x2fa018; // 0x2fa060 - g_ps2RecompiledFunctionTable[518167] = getNumFilesAll_0x2fa018; // 0x2fa064 - g_ps2RecompiledFunctionTable[518168] = getNumFilesAll_0x2fa018; // 0x2fa068 - g_ps2RecompiledFunctionTable[518169] = getNumFilesAll_0x2fa018; // 0x2fa06c - g_ps2RecompiledFunctionTable[518170] = getNumFilesAll_0x2fa018; // 0x2fa070 - g_ps2RecompiledFunctionTable[518171] = getNumFilesAll_0x2fa018; // 0x2fa074 - g_ps2RecompiledFunctionTable[518172] = getNumFilesAll_0x2fa018; // 0x2fa078 - g_ps2RecompiledFunctionTable[518173] = getNumFilesAll_0x2fa018; // 0x2fa07c - g_ps2RecompiledFunctionTable[518174] = getNumFilesAll_0x2fa018; // 0x2fa080 - g_ps2RecompiledFunctionTable[518175] = getNumFilesAll_0x2fa018; // 0x2fa084 - g_ps2RecompiledFunctionTable[518176] = getNumFiles_0x2fa088; // 0x2fa088 - g_ps2RecompiledFunctionTable[518177] = getNumFiles_0x2fa088; // 0x2fa08c - g_ps2RecompiledFunctionTable[518178] = getNumFiles_0x2fa088; // 0x2fa090 - g_ps2RecompiledFunctionTable[518179] = getNumFiles_0x2fa088; // 0x2fa094 - g_ps2RecompiledFunctionTable[518180] = getNumFiles_0x2fa088; // 0x2fa098 - g_ps2RecompiledFunctionTable[518181] = getNumFiles_0x2fa088; // 0x2fa09c - g_ps2RecompiledFunctionTable[518182] = getNumFiles_0x2fa088; // 0x2fa0a0 - g_ps2RecompiledFunctionTable[518183] = getNumFiles_0x2fa088; // 0x2fa0a4 - g_ps2RecompiledFunctionTable[518184] = getNumFiles_0x2fa088; // 0x2fa0a8 - g_ps2RecompiledFunctionTable[518185] = getNumFiles_0x2fa088; // 0x2fa0ac - g_ps2RecompiledFunctionTable[518186] = getNumFiles_0x2fa088; // 0x2fa0b0 - g_ps2RecompiledFunctionTable[518187] = getNumFiles_0x2fa088; // 0x2fa0b4 - g_ps2RecompiledFunctionTable[518188] = getNumFiles_0x2fa088; // 0x2fa0b8 - g_ps2RecompiledFunctionTable[518189] = getNumFiles_0x2fa088; // 0x2fa0bc - g_ps2RecompiledFunctionTable[518190] = getNumFiles_0x2fa088; // 0x2fa0c0 - g_ps2RecompiledFunctionTable[518191] = getNumFiles_0x2fa088; // 0x2fa0c4 - g_ps2RecompiledFunctionTable[518192] = getNumFiles_0x2fa088; // 0x2fa0c8 - g_ps2RecompiledFunctionTable[518193] = getNumFiles_0x2fa088; // 0x2fa0cc - g_ps2RecompiledFunctionTable[518194] = getNumFiles_0x2fa088; // 0x2fa0d0 - g_ps2RecompiledFunctionTable[518195] = getNumFiles_0x2fa088; // 0x2fa0d4 - g_ps2RecompiledFunctionTable[518196] = getNumFiles_0x2fa088; // 0x2fa0d8 - g_ps2RecompiledFunctionTable[518197] = getNumFiles_0x2fa088; // 0x2fa0dc - g_ps2RecompiledFunctionTable[518198] = getNumFiles_0x2fa088; // 0x2fa0e0 - g_ps2RecompiledFunctionTable[518199] = getNumFiles_0x2fa088; // 0x2fa0e4 - g_ps2RecompiledFunctionTable[518200] = getNumFiles_0x2fa088; // 0x2fa0e8 - g_ps2RecompiledFunctionTable[518201] = getNumFiles_0x2fa088; // 0x2fa0ec - g_ps2RecompiledFunctionTable[518202] = getNumFiles_0x2fa088; // 0x2fa0f0 - g_ps2RecompiledFunctionTable[518203] = getNumFiles_0x2fa088; // 0x2fa0f4 - g_ps2RecompiledFunctionTable[518204] = getNumFiles_0x2fa088; // 0x2fa0f8 - g_ps2RecompiledFunctionTable[518205] = getNumFiles_0x2fa088; // 0x2fa0fc - g_ps2RecompiledFunctionTable[518206] = getNumFiles_0x2fa088; // 0x2fa100 - g_ps2RecompiledFunctionTable[518207] = getNumFiles_0x2fa088; // 0x2fa104 - g_ps2RecompiledFunctionTable[518208] = getNumFiles_0x2fa088; // 0x2fa108 - g_ps2RecompiledFunctionTable[518209] = getNumFiles_0x2fa088; // 0x2fa10c - g_ps2RecompiledFunctionTable[518210] = getNumFiles_0x2fa088; // 0x2fa110 - g_ps2RecompiledFunctionTable[518211] = getNumFiles_0x2fa088; // 0x2fa114 - g_ps2RecompiledFunctionTable[518212] = getNumFiles_0x2fa088; // 0x2fa118 - g_ps2RecompiledFunctionTable[518213] = getNumFiles_0x2fa088; // 0x2fa11c - g_ps2RecompiledFunctionTable[518214] = getNumFiles_0x2fa088; // 0x2fa120 - g_ps2RecompiledFunctionTable[518215] = getNumFiles_0x2fa088; // 0x2fa124 - g_ps2RecompiledFunctionTable[518216] = getNumFiles_0x2fa088; // 0x2fa128 - g_ps2RecompiledFunctionTable[518217] = getNumFiles_0x2fa088; // 0x2fa12c - g_ps2RecompiledFunctionTable[518218] = getNumFiles_0x2fa088; // 0x2fa130 - g_ps2RecompiledFunctionTable[518219] = getNumFiles_0x2fa088; // 0x2fa134 - g_ps2RecompiledFunctionTable[518220] = getNumFiles_0x2fa088; // 0x2fa138 - g_ps2RecompiledFunctionTable[518221] = getNumFiles_0x2fa088; // 0x2fa13c - g_ps2RecompiledFunctionTable[518222] = getNumFiles_0x2fa088; // 0x2fa140 - g_ps2RecompiledFunctionTable[518224] = cvFsLoadDirInfo_0x2fa148; // 0x2fa148 - g_ps2RecompiledFunctionTable[518225] = cvFsLoadDirInfo_0x2fa148; // 0x2fa14c - g_ps2RecompiledFunctionTable[518226] = cvFsLoadDirInfo_0x2fa148; // 0x2fa150 - g_ps2RecompiledFunctionTable[518227] = cvFsLoadDirInfo_0x2fa148; // 0x2fa154 - g_ps2RecompiledFunctionTable[518228] = cvFsLoadDirInfo_0x2fa148; // 0x2fa158 - g_ps2RecompiledFunctionTable[518229] = cvFsLoadDirInfo_0x2fa148; // 0x2fa15c - g_ps2RecompiledFunctionTable[518230] = cvFsLoadDirInfo_0x2fa148; // 0x2fa160 - g_ps2RecompiledFunctionTable[518231] = cvFsLoadDirInfo_0x2fa148; // 0x2fa164 - g_ps2RecompiledFunctionTable[518232] = cvFsLoadDirInfo_0x2fa148; // 0x2fa168 - g_ps2RecompiledFunctionTable[518233] = cvFsLoadDirInfo_0x2fa148; // 0x2fa16c - g_ps2RecompiledFunctionTable[518234] = cvFsLoadDirInfo_0x2fa148; // 0x2fa170 - g_ps2RecompiledFunctionTable[518235] = cvFsLoadDirInfo_0x2fa148; // 0x2fa174 - g_ps2RecompiledFunctionTable[518236] = cvFsLoadDirInfo_0x2fa148; // 0x2fa178 - g_ps2RecompiledFunctionTable[518237] = cvFsLoadDirInfo_0x2fa148; // 0x2fa17c - g_ps2RecompiledFunctionTable[518238] = cvFsLoadDirInfo_0x2fa148; // 0x2fa180 - g_ps2RecompiledFunctionTable[518239] = cvFsLoadDirInfo_0x2fa148; // 0x2fa184 - g_ps2RecompiledFunctionTable[518240] = cvFsLoadDirInfo_0x2fa148; // 0x2fa188 - g_ps2RecompiledFunctionTable[518241] = cvFsLoadDirInfo_0x2fa148; // 0x2fa18c - g_ps2RecompiledFunctionTable[518242] = cvFsLoadDirInfo_0x2fa148; // 0x2fa190 - g_ps2RecompiledFunctionTable[518243] = cvFsLoadDirInfo_0x2fa148; // 0x2fa194 - g_ps2RecompiledFunctionTable[518244] = cvFsLoadDirInfo_0x2fa148; // 0x2fa198 - g_ps2RecompiledFunctionTable[518245] = cvFsLoadDirInfo_0x2fa148; // 0x2fa19c - g_ps2RecompiledFunctionTable[518246] = cvFsLoadDirInfo_0x2fa148; // 0x2fa1a0 - g_ps2RecompiledFunctionTable[518247] = cvFsLoadDirInfo_0x2fa148; // 0x2fa1a4 - g_ps2RecompiledFunctionTable[518248] = cvFsLoadDirInfo_0x2fa148; // 0x2fa1a8 - g_ps2RecompiledFunctionTable[518249] = cvFsLoadDirInfo_0x2fa148; // 0x2fa1ac - g_ps2RecompiledFunctionTable[518250] = cvFsLoadDirInfo_0x2fa148; // 0x2fa1b0 - g_ps2RecompiledFunctionTable[518251] = cvFsLoadDirInfo_0x2fa148; // 0x2fa1b4 - g_ps2RecompiledFunctionTable[518252] = cvFsLoadDirInfo_0x2fa148; // 0x2fa1b8 - g_ps2RecompiledFunctionTable[518253] = cvFsLoadDirInfo_0x2fa148; // 0x2fa1bc - g_ps2RecompiledFunctionTable[518254] = cvFsLoadDirInfo_0x2fa148; // 0x2fa1c0 - g_ps2RecompiledFunctionTable[518255] = cvFsLoadDirInfo_0x2fa148; // 0x2fa1c4 - g_ps2RecompiledFunctionTable[518256] = cvFsLoadDirInfo_0x2fa148; // 0x2fa1c8 - g_ps2RecompiledFunctionTable[518257] = cvFsLoadDirInfo_0x2fa148; // 0x2fa1cc - g_ps2RecompiledFunctionTable[518258] = cvFsLoadDirInfo_0x2fa148; // 0x2fa1d0 - g_ps2RecompiledFunctionTable[518259] = cvFsLoadDirInfo_0x2fa148; // 0x2fa1d4 - g_ps2RecompiledFunctionTable[518260] = cvFsLoadDirInfo_0x2fa148; // 0x2fa1d8 - g_ps2RecompiledFunctionTable[518261] = cvFsLoadDirInfo_0x2fa148; // 0x2fa1dc - g_ps2RecompiledFunctionTable[518262] = cvFsLoadDirInfo_0x2fa148; // 0x2fa1e0 - g_ps2RecompiledFunctionTable[518263] = cvFsLoadDirInfo_0x2fa148; // 0x2fa1e4 - g_ps2RecompiledFunctionTable[518264] = cvFsLoadDirInfo_0x2fa148; // 0x2fa1e8 - g_ps2RecompiledFunctionTable[518265] = cvFsLoadDirInfo_0x2fa148; // 0x2fa1ec - g_ps2RecompiledFunctionTable[518266] = cvFsLoadDirInfo_0x2fa148; // 0x2fa1f0 - g_ps2RecompiledFunctionTable[518267] = cvFsLoadDirInfo_0x2fa148; // 0x2fa1f4 - g_ps2RecompiledFunctionTable[518268] = cvFsGetMaxByteRate_0x2fa1f8; // 0x2fa1f8 - g_ps2RecompiledFunctionTable[518269] = cvFsGetMaxByteRate_0x2fa1f8; // 0x2fa1fc - g_ps2RecompiledFunctionTable[518270] = cvFsGetMaxByteRate_0x2fa1f8; // 0x2fa200 - g_ps2RecompiledFunctionTable[518271] = cvFsGetMaxByteRate_0x2fa1f8; // 0x2fa204 - g_ps2RecompiledFunctionTable[518272] = cvFsGetMaxByteRate_0x2fa1f8; // 0x2fa208 - g_ps2RecompiledFunctionTable[518273] = cvFsGetMaxByteRate_0x2fa1f8; // 0x2fa20c - g_ps2RecompiledFunctionTable[518274] = cvFsGetMaxByteRate_0x2fa1f8; // 0x2fa210 - g_ps2RecompiledFunctionTable[518275] = cvFsGetMaxByteRate_0x2fa1f8; // 0x2fa214 - g_ps2RecompiledFunctionTable[518276] = cvFsGetMaxByteRate_0x2fa1f8; // 0x2fa218 - g_ps2RecompiledFunctionTable[518277] = cvFsGetMaxByteRate_0x2fa1f8; // 0x2fa21c - g_ps2RecompiledFunctionTable[518278] = cvFsGetMaxByteRate_0x2fa1f8; // 0x2fa220 - g_ps2RecompiledFunctionTable[518279] = cvFsGetMaxByteRate_0x2fa1f8; // 0x2fa224 - g_ps2RecompiledFunctionTable[518280] = cvFsGetMaxByteRate_0x2fa1f8; // 0x2fa228 - g_ps2RecompiledFunctionTable[518281] = cvFsGetMaxByteRate_0x2fa1f8; // 0x2fa22c - g_ps2RecompiledFunctionTable[518282] = cvFsGetMaxByteRate_0x2fa1f8; // 0x2fa230 - g_ps2RecompiledFunctionTable[518283] = cvFsGetMaxByteRate_0x2fa1f8; // 0x2fa234 - g_ps2RecompiledFunctionTable[518284] = cvFsGetMaxByteRate_0x2fa1f8; // 0x2fa238 - g_ps2RecompiledFunctionTable[518285] = cvFsGetMaxByteRate_0x2fa1f8; // 0x2fa23c - g_ps2RecompiledFunctionTable[518286] = cvFsGetMaxByteRate_0x2fa1f8; // 0x2fa240 - g_ps2RecompiledFunctionTable[518287] = cvFsGetMaxByteRate_0x2fa1f8; // 0x2fa244 - g_ps2RecompiledFunctionTable[518288] = cvFsGetMaxByteRate_0x2fa1f8; // 0x2fa248 - g_ps2RecompiledFunctionTable[518289] = cvFsGetMaxByteRate_0x2fa1f8; // 0x2fa24c - g_ps2RecompiledFunctionTable[518290] = cvFsMakeDir_0x2fa250; // 0x2fa250 - g_ps2RecompiledFunctionTable[518291] = cvFsMakeDir_0x2fa250; // 0x2fa254 - g_ps2RecompiledFunctionTable[518292] = cvFsMakeDir_0x2fa250; // 0x2fa258 - g_ps2RecompiledFunctionTable[518293] = cvFsMakeDir_0x2fa250; // 0x2fa25c - g_ps2RecompiledFunctionTable[518294] = cvFsMakeDir_0x2fa250; // 0x2fa260 - g_ps2RecompiledFunctionTable[518295] = cvFsMakeDir_0x2fa250; // 0x2fa264 - g_ps2RecompiledFunctionTable[518296] = cvFsMakeDir_0x2fa250; // 0x2fa268 - g_ps2RecompiledFunctionTable[518297] = cvFsMakeDir_0x2fa250; // 0x2fa26c - g_ps2RecompiledFunctionTable[518298] = cvFsMakeDir_0x2fa250; // 0x2fa270 - g_ps2RecompiledFunctionTable[518299] = cvFsMakeDir_0x2fa250; // 0x2fa274 - g_ps2RecompiledFunctionTable[518300] = cvFsMakeDir_0x2fa250; // 0x2fa278 - g_ps2RecompiledFunctionTable[518301] = cvFsMakeDir_0x2fa250; // 0x2fa27c - g_ps2RecompiledFunctionTable[518302] = cvFsMakeDir_0x2fa250; // 0x2fa280 - g_ps2RecompiledFunctionTable[518303] = cvFsMakeDir_0x2fa250; // 0x2fa284 - g_ps2RecompiledFunctionTable[518304] = cvFsMakeDir_0x2fa250; // 0x2fa288 - g_ps2RecompiledFunctionTable[518305] = cvFsMakeDir_0x2fa250; // 0x2fa28c - g_ps2RecompiledFunctionTable[518306] = cvFsMakeDir_0x2fa250; // 0x2fa290 - g_ps2RecompiledFunctionTable[518307] = cvFsMakeDir_0x2fa250; // 0x2fa294 - g_ps2RecompiledFunctionTable[518308] = cvFsMakeDir_0x2fa250; // 0x2fa298 - g_ps2RecompiledFunctionTable[518309] = cvFsMakeDir_0x2fa250; // 0x2fa29c - g_ps2RecompiledFunctionTable[518310] = cvFsMakeDir_0x2fa250; // 0x2fa2a0 - g_ps2RecompiledFunctionTable[518311] = cvFsMakeDir_0x2fa250; // 0x2fa2a4 - g_ps2RecompiledFunctionTable[518312] = cvFsMakeDir_0x2fa250; // 0x2fa2a8 - g_ps2RecompiledFunctionTable[518313] = cvFsMakeDir_0x2fa250; // 0x2fa2ac - g_ps2RecompiledFunctionTable[518314] = cvFsMakeDir_0x2fa250; // 0x2fa2b0 - g_ps2RecompiledFunctionTable[518315] = cvFsMakeDir_0x2fa250; // 0x2fa2b4 - g_ps2RecompiledFunctionTable[518316] = cvFsMakeDir_0x2fa250; // 0x2fa2b8 - g_ps2RecompiledFunctionTable[518317] = cvFsMakeDir_0x2fa250; // 0x2fa2bc - g_ps2RecompiledFunctionTable[518318] = cvFsMakeDir_0x2fa250; // 0x2fa2c0 - g_ps2RecompiledFunctionTable[518319] = cvFsMakeDir_0x2fa250; // 0x2fa2c4 - g_ps2RecompiledFunctionTable[518320] = cvFsMakeDir_0x2fa250; // 0x2fa2c8 - g_ps2RecompiledFunctionTable[518321] = cvFsMakeDir_0x2fa250; // 0x2fa2cc - g_ps2RecompiledFunctionTable[518322] = cvFsMakeDir_0x2fa250; // 0x2fa2d0 - g_ps2RecompiledFunctionTable[518323] = cvFsMakeDir_0x2fa250; // 0x2fa2d4 - g_ps2RecompiledFunctionTable[518324] = cvFsMakeDir_0x2fa250; // 0x2fa2d8 - g_ps2RecompiledFunctionTable[518325] = cvFsMakeDir_0x2fa250; // 0x2fa2dc - g_ps2RecompiledFunctionTable[518326] = cvFsMakeDir_0x2fa250; // 0x2fa2e0 - g_ps2RecompiledFunctionTable[518327] = cvFsMakeDir_0x2fa250; // 0x2fa2e4 - g_ps2RecompiledFunctionTable[518328] = cvFsMakeDir_0x2fa250; // 0x2fa2e8 - g_ps2RecompiledFunctionTable[518329] = cvFsMakeDir_0x2fa250; // 0x2fa2ec - g_ps2RecompiledFunctionTable[518330] = cvFsMakeDir_0x2fa250; // 0x2fa2f0 - g_ps2RecompiledFunctionTable[518331] = cvFsMakeDir_0x2fa250; // 0x2fa2f4 - g_ps2RecompiledFunctionTable[518332] = cvFsMakeDir_0x2fa250; // 0x2fa2f8 - g_ps2RecompiledFunctionTable[518333] = cvFsMakeDir_0x2fa250; // 0x2fa2fc - g_ps2RecompiledFunctionTable[518334] = cvFsMakeDir_0x2fa250; // 0x2fa300 - g_ps2RecompiledFunctionTable[518335] = cvFsMakeDir_0x2fa250; // 0x2fa304 - g_ps2RecompiledFunctionTable[518336] = cvFsMakeDir_0x2fa250; // 0x2fa308 - g_ps2RecompiledFunctionTable[518338] = cvFsRemoveDir_0x2fa310; // 0x2fa310 - g_ps2RecompiledFunctionTable[518339] = cvFsRemoveDir_0x2fa310; // 0x2fa314 - g_ps2RecompiledFunctionTable[518340] = cvFsRemoveDir_0x2fa310; // 0x2fa318 - g_ps2RecompiledFunctionTable[518341] = cvFsRemoveDir_0x2fa310; // 0x2fa31c - g_ps2RecompiledFunctionTable[518342] = cvFsRemoveDir_0x2fa310; // 0x2fa320 - g_ps2RecompiledFunctionTable[518343] = cvFsRemoveDir_0x2fa310; // 0x2fa324 - g_ps2RecompiledFunctionTable[518344] = cvFsRemoveDir_0x2fa310; // 0x2fa328 - g_ps2RecompiledFunctionTable[518345] = cvFsRemoveDir_0x2fa310; // 0x2fa32c - g_ps2RecompiledFunctionTable[518346] = cvFsRemoveDir_0x2fa310; // 0x2fa330 - g_ps2RecompiledFunctionTable[518347] = cvFsRemoveDir_0x2fa310; // 0x2fa334 - g_ps2RecompiledFunctionTable[518348] = cvFsRemoveDir_0x2fa310; // 0x2fa338 - g_ps2RecompiledFunctionTable[518349] = cvFsRemoveDir_0x2fa310; // 0x2fa33c - g_ps2RecompiledFunctionTable[518350] = cvFsRemoveDir_0x2fa310; // 0x2fa340 - g_ps2RecompiledFunctionTable[518351] = cvFsRemoveDir_0x2fa310; // 0x2fa344 - g_ps2RecompiledFunctionTable[518352] = cvFsRemoveDir_0x2fa310; // 0x2fa348 - g_ps2RecompiledFunctionTable[518353] = cvFsRemoveDir_0x2fa310; // 0x2fa34c - g_ps2RecompiledFunctionTable[518354] = cvFsRemoveDir_0x2fa310; // 0x2fa350 - g_ps2RecompiledFunctionTable[518355] = cvFsRemoveDir_0x2fa310; // 0x2fa354 - g_ps2RecompiledFunctionTable[518356] = cvFsRemoveDir_0x2fa310; // 0x2fa358 - g_ps2RecompiledFunctionTable[518357] = cvFsRemoveDir_0x2fa310; // 0x2fa35c - g_ps2RecompiledFunctionTable[518358] = cvFsRemoveDir_0x2fa310; // 0x2fa360 - g_ps2RecompiledFunctionTable[518359] = cvFsRemoveDir_0x2fa310; // 0x2fa364 - g_ps2RecompiledFunctionTable[518360] = cvFsRemoveDir_0x2fa310; // 0x2fa368 - g_ps2RecompiledFunctionTable[518361] = cvFsRemoveDir_0x2fa310; // 0x2fa36c - g_ps2RecompiledFunctionTable[518362] = cvFsRemoveDir_0x2fa310; // 0x2fa370 - g_ps2RecompiledFunctionTable[518363] = cvFsRemoveDir_0x2fa310; // 0x2fa374 - g_ps2RecompiledFunctionTable[518364] = cvFsRemoveDir_0x2fa310; // 0x2fa378 - g_ps2RecompiledFunctionTable[518365] = cvFsRemoveDir_0x2fa310; // 0x2fa37c - g_ps2RecompiledFunctionTable[518366] = cvFsRemoveDir_0x2fa310; // 0x2fa380 - g_ps2RecompiledFunctionTable[518367] = cvFsRemoveDir_0x2fa310; // 0x2fa384 - g_ps2RecompiledFunctionTable[518368] = cvFsRemoveDir_0x2fa310; // 0x2fa388 - g_ps2RecompiledFunctionTable[518369] = cvFsRemoveDir_0x2fa310; // 0x2fa38c - g_ps2RecompiledFunctionTable[518370] = cvFsRemoveDir_0x2fa310; // 0x2fa390 - g_ps2RecompiledFunctionTable[518371] = cvFsRemoveDir_0x2fa310; // 0x2fa394 - g_ps2RecompiledFunctionTable[518372] = cvFsRemoveDir_0x2fa310; // 0x2fa398 - g_ps2RecompiledFunctionTable[518373] = cvFsRemoveDir_0x2fa310; // 0x2fa39c - g_ps2RecompiledFunctionTable[518374] = cvFsRemoveDir_0x2fa310; // 0x2fa3a0 - g_ps2RecompiledFunctionTable[518375] = cvFsRemoveDir_0x2fa310; // 0x2fa3a4 - g_ps2RecompiledFunctionTable[518376] = cvFsRemoveDir_0x2fa310; // 0x2fa3a8 - g_ps2RecompiledFunctionTable[518377] = cvFsRemoveDir_0x2fa310; // 0x2fa3ac - g_ps2RecompiledFunctionTable[518378] = cvFsRemoveDir_0x2fa310; // 0x2fa3b0 - g_ps2RecompiledFunctionTable[518379] = cvFsRemoveDir_0x2fa310; // 0x2fa3b4 - g_ps2RecompiledFunctionTable[518380] = cvFsRemoveDir_0x2fa310; // 0x2fa3b8 - g_ps2RecompiledFunctionTable[518381] = cvFsRemoveDir_0x2fa310; // 0x2fa3bc - g_ps2RecompiledFunctionTable[518382] = cvFsRemoveDir_0x2fa310; // 0x2fa3c0 - g_ps2RecompiledFunctionTable[518383] = cvFsRemoveDir_0x2fa310; // 0x2fa3c4 - g_ps2RecompiledFunctionTable[518384] = cvFsRemoveDir_0x2fa310; // 0x2fa3c8 - g_ps2RecompiledFunctionTable[518386] = cvFsDeleteFile_0x2fa3d0; // 0x2fa3d0 - g_ps2RecompiledFunctionTable[518387] = cvFsDeleteFile_0x2fa3d0; // 0x2fa3d4 - g_ps2RecompiledFunctionTable[518388] = cvFsDeleteFile_0x2fa3d0; // 0x2fa3d8 - g_ps2RecompiledFunctionTable[518389] = cvFsDeleteFile_0x2fa3d0; // 0x2fa3dc - g_ps2RecompiledFunctionTable[518390] = cvFsDeleteFile_0x2fa3d0; // 0x2fa3e0 - g_ps2RecompiledFunctionTable[518391] = cvFsDeleteFile_0x2fa3d0; // 0x2fa3e4 - g_ps2RecompiledFunctionTable[518392] = cvFsDeleteFile_0x2fa3d0; // 0x2fa3e8 - g_ps2RecompiledFunctionTable[518393] = cvFsDeleteFile_0x2fa3d0; // 0x2fa3ec - g_ps2RecompiledFunctionTable[518394] = cvFsDeleteFile_0x2fa3d0; // 0x2fa3f0 - g_ps2RecompiledFunctionTable[518395] = cvFsDeleteFile_0x2fa3d0; // 0x2fa3f4 - g_ps2RecompiledFunctionTable[518396] = cvFsDeleteFile_0x2fa3d0; // 0x2fa3f8 - g_ps2RecompiledFunctionTable[518397] = cvFsDeleteFile_0x2fa3d0; // 0x2fa3fc - g_ps2RecompiledFunctionTable[518398] = cvFsDeleteFile_0x2fa3d0; // 0x2fa400 - g_ps2RecompiledFunctionTable[518399] = cvFsDeleteFile_0x2fa3d0; // 0x2fa404 - g_ps2RecompiledFunctionTable[518400] = cvFsDeleteFile_0x2fa3d0; // 0x2fa408 - g_ps2RecompiledFunctionTable[518401] = cvFsDeleteFile_0x2fa3d0; // 0x2fa40c - g_ps2RecompiledFunctionTable[518402] = cvFsDeleteFile_0x2fa3d0; // 0x2fa410 - g_ps2RecompiledFunctionTable[518403] = cvFsDeleteFile_0x2fa3d0; // 0x2fa414 - g_ps2RecompiledFunctionTable[518404] = cvFsDeleteFile_0x2fa3d0; // 0x2fa418 - g_ps2RecompiledFunctionTable[518405] = cvFsDeleteFile_0x2fa3d0; // 0x2fa41c - g_ps2RecompiledFunctionTable[518406] = cvFsDeleteFile_0x2fa3d0; // 0x2fa420 - g_ps2RecompiledFunctionTable[518407] = cvFsDeleteFile_0x2fa3d0; // 0x2fa424 - g_ps2RecompiledFunctionTable[518408] = cvFsDeleteFile_0x2fa3d0; // 0x2fa428 - g_ps2RecompiledFunctionTable[518409] = cvFsDeleteFile_0x2fa3d0; // 0x2fa42c - g_ps2RecompiledFunctionTable[518410] = cvFsDeleteFile_0x2fa3d0; // 0x2fa430 - g_ps2RecompiledFunctionTable[518411] = cvFsDeleteFile_0x2fa3d0; // 0x2fa434 - g_ps2RecompiledFunctionTable[518412] = cvFsDeleteFile_0x2fa3d0; // 0x2fa438 - g_ps2RecompiledFunctionTable[518413] = cvFsDeleteFile_0x2fa3d0; // 0x2fa43c - g_ps2RecompiledFunctionTable[518414] = cvFsDeleteFile_0x2fa3d0; // 0x2fa440 - g_ps2RecompiledFunctionTable[518415] = cvFsDeleteFile_0x2fa3d0; // 0x2fa444 - g_ps2RecompiledFunctionTable[518416] = cvFsDeleteFile_0x2fa3d0; // 0x2fa448 - g_ps2RecompiledFunctionTable[518417] = cvFsDeleteFile_0x2fa3d0; // 0x2fa44c - g_ps2RecompiledFunctionTable[518418] = cvFsDeleteFile_0x2fa3d0; // 0x2fa450 - g_ps2RecompiledFunctionTable[518419] = cvFsDeleteFile_0x2fa3d0; // 0x2fa454 - g_ps2RecompiledFunctionTable[518420] = cvFsDeleteFile_0x2fa3d0; // 0x2fa458 - g_ps2RecompiledFunctionTable[518421] = cvFsDeleteFile_0x2fa3d0; // 0x2fa45c - g_ps2RecompiledFunctionTable[518422] = cvFsDeleteFile_0x2fa3d0; // 0x2fa460 - g_ps2RecompiledFunctionTable[518423] = cvFsDeleteFile_0x2fa3d0; // 0x2fa464 - g_ps2RecompiledFunctionTable[518424] = cvFsDeleteFile_0x2fa3d0; // 0x2fa468 - g_ps2RecompiledFunctionTable[518425] = cvFsDeleteFile_0x2fa3d0; // 0x2fa46c - g_ps2RecompiledFunctionTable[518426] = cvFsDeleteFile_0x2fa3d0; // 0x2fa470 - g_ps2RecompiledFunctionTable[518427] = cvFsDeleteFile_0x2fa3d0; // 0x2fa474 - g_ps2RecompiledFunctionTable[518428] = cvFsDeleteFile_0x2fa3d0; // 0x2fa478 - g_ps2RecompiledFunctionTable[518429] = cvFsDeleteFile_0x2fa3d0; // 0x2fa47c - g_ps2RecompiledFunctionTable[518430] = cvFsDeleteFile_0x2fa3d0; // 0x2fa480 - g_ps2RecompiledFunctionTable[518431] = cvFsDeleteFile_0x2fa3d0; // 0x2fa484 - g_ps2RecompiledFunctionTable[518432] = cvFsDeleteFile_0x2fa3d0; // 0x2fa488 - g_ps2RecompiledFunctionTable[518434] = cvFsGetDevName_0x2fa490; // 0x2fa490 - g_ps2RecompiledFunctionTable[518440] = cvFsGetDevName_0x2fa490; // 0x2fa4a8 - g_ps2RecompiledFunctionTable[518450] = cvFsGetDevName_0x2fa490; // 0x2fa4d0 - g_ps2RecompiledFunctionTable[518470] = cvFsEntryErrFunc_0x2fa520; // 0x2fa520 - g_ps2RecompiledFunctionTable[518480] = cvFsOptFn1_0x2fa548; // 0x2fa548 - g_ps2RecompiledFunctionTable[518481] = cvFsOptFn1_0x2fa548; // 0x2fa54c - g_ps2RecompiledFunctionTable[518482] = cvFsOptFn1_0x2fa548; // 0x2fa550 - g_ps2RecompiledFunctionTable[518483] = cvFsOptFn1_0x2fa548; // 0x2fa554 - g_ps2RecompiledFunctionTable[518484] = cvFsOptFn1_0x2fa548; // 0x2fa558 - g_ps2RecompiledFunctionTable[518485] = cvFsOptFn1_0x2fa548; // 0x2fa55c - g_ps2RecompiledFunctionTable[518486] = cvFsOptFn1_0x2fa548; // 0x2fa560 - g_ps2RecompiledFunctionTable[518487] = cvFsOptFn1_0x2fa548; // 0x2fa564 - g_ps2RecompiledFunctionTable[518488] = cvFsOptFn1_0x2fa548; // 0x2fa568 - g_ps2RecompiledFunctionTable[518489] = cvFsOptFn1_0x2fa548; // 0x2fa56c - g_ps2RecompiledFunctionTable[518490] = cvFsOptFn1_0x2fa548; // 0x2fa570 - g_ps2RecompiledFunctionTable[518491] = cvFsOptFn1_0x2fa548; // 0x2fa574 - g_ps2RecompiledFunctionTable[518492] = cvFsOptFn1_0x2fa548; // 0x2fa578 - g_ps2RecompiledFunctionTable[518493] = cvFsOptFn1_0x2fa548; // 0x2fa57c - g_ps2RecompiledFunctionTable[518494] = cvFsOptFn1_0x2fa548; // 0x2fa580 - g_ps2RecompiledFunctionTable[518495] = cvFsOptFn1_0x2fa548; // 0x2fa584 - g_ps2RecompiledFunctionTable[518496] = cvFsOptFn1_0x2fa548; // 0x2fa588 - g_ps2RecompiledFunctionTable[518497] = cvFsOptFn1_0x2fa548; // 0x2fa58c - g_ps2RecompiledFunctionTable[518498] = cvFsOptFn1_0x2fa548; // 0x2fa590 - g_ps2RecompiledFunctionTable[518499] = cvFsOptFn1_0x2fa548; // 0x2fa594 - g_ps2RecompiledFunctionTable[518500] = cvFsOptFn1_0x2fa548; // 0x2fa598 - g_ps2RecompiledFunctionTable[518501] = cvFsOptFn1_0x2fa548; // 0x2fa59c - g_ps2RecompiledFunctionTable[518502] = cvFsOptFn1_0x2fa548; // 0x2fa5a0 - g_ps2RecompiledFunctionTable[518503] = cvFsOptFn1_0x2fa548; // 0x2fa5a4 - g_ps2RecompiledFunctionTable[518504] = cvFsOptFn1_0x2fa548; // 0x2fa5a8 - g_ps2RecompiledFunctionTable[518506] = cvFsOptFn2_0x2fa5b0; // 0x2fa5b0 - g_ps2RecompiledFunctionTable[518507] = cvFsOptFn2_0x2fa5b0; // 0x2fa5b4 - g_ps2RecompiledFunctionTable[518508] = cvFsOptFn2_0x2fa5b0; // 0x2fa5b8 - g_ps2RecompiledFunctionTable[518509] = cvFsOptFn2_0x2fa5b0; // 0x2fa5bc - g_ps2RecompiledFunctionTable[518510] = cvFsOptFn2_0x2fa5b0; // 0x2fa5c0 - g_ps2RecompiledFunctionTable[518511] = cvFsOptFn2_0x2fa5b0; // 0x2fa5c4 - g_ps2RecompiledFunctionTable[518512] = cvFsOptFn2_0x2fa5b0; // 0x2fa5c8 - g_ps2RecompiledFunctionTable[518513] = cvFsOptFn2_0x2fa5b0; // 0x2fa5cc - g_ps2RecompiledFunctionTable[518514] = cvFsOptFn2_0x2fa5b0; // 0x2fa5d0 - g_ps2RecompiledFunctionTable[518515] = cvFsOptFn2_0x2fa5b0; // 0x2fa5d4 - g_ps2RecompiledFunctionTable[518516] = cvFsOptFn2_0x2fa5b0; // 0x2fa5d8 - g_ps2RecompiledFunctionTable[518517] = cvFsOptFn2_0x2fa5b0; // 0x2fa5dc - g_ps2RecompiledFunctionTable[518518] = cvFsOptFn2_0x2fa5b0; // 0x2fa5e0 - g_ps2RecompiledFunctionTable[518519] = cvFsOptFn2_0x2fa5b0; // 0x2fa5e4 - g_ps2RecompiledFunctionTable[518520] = cvFsOptFn2_0x2fa5b0; // 0x2fa5e8 - g_ps2RecompiledFunctionTable[518521] = cvFsOptFn2_0x2fa5b0; // 0x2fa5ec - g_ps2RecompiledFunctionTable[518522] = cvFsOptFn2_0x2fa5b0; // 0x2fa5f0 - g_ps2RecompiledFunctionTable[518523] = cvFsOptFn2_0x2fa5b0; // 0x2fa5f4 - g_ps2RecompiledFunctionTable[518524] = cvFsOptFn2_0x2fa5b0; // 0x2fa5f8 - g_ps2RecompiledFunctionTable[518525] = cvFsOptFn2_0x2fa5b0; // 0x2fa5fc - g_ps2RecompiledFunctionTable[518526] = cvFsOptFn2_0x2fa5b0; // 0x2fa600 - g_ps2RecompiledFunctionTable[518527] = cvFsOptFn2_0x2fa5b0; // 0x2fa604 - g_ps2RecompiledFunctionTable[518528] = cvFsOptFn2_0x2fa5b0; // 0x2fa608 - g_ps2RecompiledFunctionTable[518529] = cvFsOptFn2_0x2fa5b0; // 0x2fa60c - g_ps2RecompiledFunctionTable[518530] = cvFsOptFn2_0x2fa5b0; // 0x2fa610 - g_ps2RecompiledFunctionTable[518532] = DTR_ExecHndl_0x2fa618; // 0x2fa618 - g_ps2RecompiledFunctionTable[518533] = DTR_ExecHndl_0x2fa618; // 0x2fa61c - g_ps2RecompiledFunctionTable[518534] = DTR_ExecHndl_0x2fa618; // 0x2fa620 - g_ps2RecompiledFunctionTable[518535] = DTR_ExecHndl_0x2fa618; // 0x2fa624 - g_ps2RecompiledFunctionTable[518536] = DTR_ExecHndl_0x2fa618; // 0x2fa628 - g_ps2RecompiledFunctionTable[518537] = DTR_ExecHndl_0x2fa618; // 0x2fa62c - g_ps2RecompiledFunctionTable[518538] = DTR_ExecHndl_0x2fa618; // 0x2fa630 - g_ps2RecompiledFunctionTable[518539] = DTR_ExecHndl_0x2fa618; // 0x2fa634 - g_ps2RecompiledFunctionTable[518540] = DTR_ExecHndl_0x2fa618; // 0x2fa638 - g_ps2RecompiledFunctionTable[518541] = DTR_ExecHndl_0x2fa618; // 0x2fa63c - g_ps2RecompiledFunctionTable[518542] = DTR_ExecHndl_0x2fa618; // 0x2fa640 - g_ps2RecompiledFunctionTable[518543] = DTR_ExecHndl_0x2fa618; // 0x2fa644 - g_ps2RecompiledFunctionTable[518544] = DTR_ExecHndl_0x2fa618; // 0x2fa648 - g_ps2RecompiledFunctionTable[518545] = DTR_ExecHndl_0x2fa618; // 0x2fa64c - g_ps2RecompiledFunctionTable[518546] = DTR_ExecHndl_0x2fa618; // 0x2fa650 - g_ps2RecompiledFunctionTable[518547] = DTR_ExecHndl_0x2fa618; // 0x2fa654 - g_ps2RecompiledFunctionTable[518548] = DTR_ExecHndl_0x2fa618; // 0x2fa658 - g_ps2RecompiledFunctionTable[518549] = DTR_ExecHndl_0x2fa618; // 0x2fa65c - g_ps2RecompiledFunctionTable[518550] = DTR_ExecHndl_0x2fa618; // 0x2fa660 - g_ps2RecompiledFunctionTable[518551] = DTR_ExecHndl_0x2fa618; // 0x2fa664 - g_ps2RecompiledFunctionTable[518552] = DTR_ExecHndl_0x2fa618; // 0x2fa668 - g_ps2RecompiledFunctionTable[518553] = DTR_ExecHndl_0x2fa618; // 0x2fa66c - g_ps2RecompiledFunctionTable[518554] = DTR_ExecHndl_0x2fa618; // 0x2fa670 - g_ps2RecompiledFunctionTable[518555] = DTR_ExecHndl_0x2fa618; // 0x2fa674 - g_ps2RecompiledFunctionTable[518556] = DTR_ExecHndl_0x2fa618; // 0x2fa678 - g_ps2RecompiledFunctionTable[518557] = DTR_ExecHndl_0x2fa618; // 0x2fa67c - g_ps2RecompiledFunctionTable[518558] = DTR_ExecHndl_0x2fa618; // 0x2fa680 - g_ps2RecompiledFunctionTable[518559] = DTR_ExecHndl_0x2fa618; // 0x2fa684 - g_ps2RecompiledFunctionTable[518560] = DTR_ExecHndl_0x2fa618; // 0x2fa688 - g_ps2RecompiledFunctionTable[518561] = DTR_ExecHndl_0x2fa618; // 0x2fa68c - g_ps2RecompiledFunctionTable[518562] = DTR_ExecHndl_0x2fa618; // 0x2fa690 - g_ps2RecompiledFunctionTable[518563] = DTR_ExecHndl_0x2fa618; // 0x2fa694 - g_ps2RecompiledFunctionTable[518564] = DTR_ExecHndl_0x2fa618; // 0x2fa698 - g_ps2RecompiledFunctionTable[518565] = DTR_ExecHndl_0x2fa618; // 0x2fa69c - g_ps2RecompiledFunctionTable[518566] = DTR_ExecHndl_0x2fa618; // 0x2fa6a0 - g_ps2RecompiledFunctionTable[518567] = DTR_ExecHndl_0x2fa618; // 0x2fa6a4 - g_ps2RecompiledFunctionTable[518568] = DTR_ExecHndl_0x2fa618; // 0x2fa6a8 - g_ps2RecompiledFunctionTable[518569] = DTR_ExecHndl_0x2fa618; // 0x2fa6ac - g_ps2RecompiledFunctionTable[518570] = DTR_ExecHndl_0x2fa618; // 0x2fa6b0 - g_ps2RecompiledFunctionTable[518571] = DTR_ExecHndl_0x2fa618; // 0x2fa6b4 - g_ps2RecompiledFunctionTable[518572] = DTR_ExecHndl_0x2fa618; // 0x2fa6b8 - g_ps2RecompiledFunctionTable[518573] = DTR_ExecHndl_0x2fa618; // 0x2fa6bc - g_ps2RecompiledFunctionTable[518574] = DTR_ExecHndl_0x2fa618; // 0x2fa6c0 - g_ps2RecompiledFunctionTable[518575] = DTR_ExecHndl_0x2fa618; // 0x2fa6c4 - g_ps2RecompiledFunctionTable[518576] = DTR_ExecHndl_0x2fa618; // 0x2fa6c8 - g_ps2RecompiledFunctionTable[518577] = DTR_ExecHndl_0x2fa618; // 0x2fa6cc - g_ps2RecompiledFunctionTable[518578] = DTR_ExecHndl_0x2fa618; // 0x2fa6d0 - g_ps2RecompiledFunctionTable[518579] = DTR_ExecHndl_0x2fa618; // 0x2fa6d4 - g_ps2RecompiledFunctionTable[518580] = DTR_ExecHndl_0x2fa618; // 0x2fa6d8 - g_ps2RecompiledFunctionTable[518581] = DTR_ExecHndl_0x2fa618; // 0x2fa6dc - g_ps2RecompiledFunctionTable[518582] = DTR_ExecHndl_0x2fa618; // 0x2fa6e0 - g_ps2RecompiledFunctionTable[518583] = DTR_ExecHndl_0x2fa618; // 0x2fa6e4 - g_ps2RecompiledFunctionTable[518584] = DTR_ExecHndl_0x2fa618; // 0x2fa6e8 - g_ps2RecompiledFunctionTable[518585] = DTR_ExecHndl_0x2fa618; // 0x2fa6ec - g_ps2RecompiledFunctionTable[518586] = DTR_ExecHndl_0x2fa618; // 0x2fa6f0 - g_ps2RecompiledFunctionTable[518587] = DTR_ExecHndl_0x2fa618; // 0x2fa6f4 - g_ps2RecompiledFunctionTable[518588] = DTR_ExecHndl_0x2fa618; // 0x2fa6f8 - g_ps2RecompiledFunctionTable[518589] = DTR_ExecHndl_0x2fa618; // 0x2fa6fc - g_ps2RecompiledFunctionTable[518590] = DTR_ExecHndl_0x2fa618; // 0x2fa700 - g_ps2RecompiledFunctionTable[518591] = DTR_ExecHndl_0x2fa618; // 0x2fa704 - g_ps2RecompiledFunctionTable[518592] = DTR_ExecHndl_0x2fa618; // 0x2fa708 - g_ps2RecompiledFunctionTable[518593] = DTR_ExecHndl_0x2fa618; // 0x2fa70c - g_ps2RecompiledFunctionTable[518594] = DTR_ExecHndl_0x2fa618; // 0x2fa710 - g_ps2RecompiledFunctionTable[518595] = DTR_ExecHndl_0x2fa618; // 0x2fa714 - g_ps2RecompiledFunctionTable[518596] = DTR_ExecHndl_0x2fa618; // 0x2fa718 - g_ps2RecompiledFunctionTable[518597] = DTR_ExecHndl_0x2fa618; // 0x2fa71c - g_ps2RecompiledFunctionTable[518598] = DTR_ExecHndl_0x2fa618; // 0x2fa720 - g_ps2RecompiledFunctionTable[518599] = DTR_ExecHndl_0x2fa618; // 0x2fa724 - g_ps2RecompiledFunctionTable[518600] = DTR_ExecHndl_0x2fa618; // 0x2fa728 - g_ps2RecompiledFunctionTable[518601] = DTR_ExecHndl_0x2fa618; // 0x2fa72c - g_ps2RecompiledFunctionTable[518602] = DTR_ExecHndl_0x2fa618; // 0x2fa730 - g_ps2RecompiledFunctionTable[518603] = DTR_ExecHndl_0x2fa618; // 0x2fa734 - g_ps2RecompiledFunctionTable[518604] = DTR_ExecHndl_0x2fa618; // 0x2fa738 - g_ps2RecompiledFunctionTable[518605] = DTR_ExecHndl_0x2fa618; // 0x2fa73c - g_ps2RecompiledFunctionTable[518606] = DTR_ExecHndl_0x2fa618; // 0x2fa740 - g_ps2RecompiledFunctionTable[518607] = DTR_ExecHndl_0x2fa618; // 0x2fa744 - g_ps2RecompiledFunctionTable[518608] = DTR_ExecHndl_0x2fa618; // 0x2fa748 - g_ps2RecompiledFunctionTable[518609] = DTR_ExecHndl_0x2fa618; // 0x2fa74c - g_ps2RecompiledFunctionTable[518610] = DTR_ExecHndl_0x2fa618; // 0x2fa750 - g_ps2RecompiledFunctionTable[518611] = DTR_ExecHndl_0x2fa618; // 0x2fa754 - g_ps2RecompiledFunctionTable[518612] = DTR_ExecHndl_0x2fa618; // 0x2fa758 - g_ps2RecompiledFunctionTable[518613] = DTR_ExecHndl_0x2fa618; // 0x2fa75c - g_ps2RecompiledFunctionTable[518614] = DTR_ExecHndl_0x2fa618; // 0x2fa760 - g_ps2RecompiledFunctionTable[518615] = DTR_ExecHndl_0x2fa618; // 0x2fa764 - g_ps2RecompiledFunctionTable[518616] = DTR_ExecHndl_0x2fa618; // 0x2fa768 - g_ps2RecompiledFunctionTable[518617] = DTR_ExecHndl_0x2fa618; // 0x2fa76c - g_ps2RecompiledFunctionTable[518618] = DTR_ExecHndl_0x2fa618; // 0x2fa770 - g_ps2RecompiledFunctionTable[518619] = DTR_ExecHndl_0x2fa618; // 0x2fa774 - g_ps2RecompiledFunctionTable[518620] = DTR_ExecHndl_0x2fa618; // 0x2fa778 - g_ps2RecompiledFunctionTable[518621] = DTR_ExecHndl_0x2fa618; // 0x2fa77c - g_ps2RecompiledFunctionTable[518622] = DTR_ExecHndl_0x2fa618; // 0x2fa780 - g_ps2RecompiledFunctionTable[518623] = DTR_ExecHndl_0x2fa618; // 0x2fa784 - g_ps2RecompiledFunctionTable[518624] = DTR_ExecHndl_0x2fa618; // 0x2fa788 - g_ps2RecompiledFunctionTable[518625] = DTR_ExecHndl_0x2fa618; // 0x2fa78c - g_ps2RecompiledFunctionTable[518626] = DTR_ExecHndl_0x2fa618; // 0x2fa790 - g_ps2RecompiledFunctionTable[518627] = DTR_ExecHndl_0x2fa618; // 0x2fa794 - g_ps2RecompiledFunctionTable[518628] = DTR_ExecHndl_0x2fa618; // 0x2fa798 - g_ps2RecompiledFunctionTable[518629] = DTR_ExecHndl_0x2fa618; // 0x2fa79c - g_ps2RecompiledFunctionTable[518630] = DTR_ExecHndl_0x2fa618; // 0x2fa7a0 - g_ps2RecompiledFunctionTable[518631] = DTR_ExecHndl_0x2fa618; // 0x2fa7a4 - g_ps2RecompiledFunctionTable[518632] = DTR_ExecHndl_0x2fa618; // 0x2fa7a8 - g_ps2RecompiledFunctionTable[518633] = DTR_ExecHndl_0x2fa618; // 0x2fa7ac - g_ps2RecompiledFunctionTable[518634] = DTR_ExecHndl_0x2fa618; // 0x2fa7b0 - g_ps2RecompiledFunctionTable[518635] = DTR_ExecHndl_0x2fa618; // 0x2fa7b4 - g_ps2RecompiledFunctionTable[518636] = DTR_ExecHndl_0x2fa618; // 0x2fa7b8 - g_ps2RecompiledFunctionTable[518637] = DTR_ExecHndl_0x2fa618; // 0x2fa7bc - g_ps2RecompiledFunctionTable[518638] = DTR_ExecHndl_0x2fa618; // 0x2fa7c0 - g_ps2RecompiledFunctionTable[518639] = DTR_ExecHndl_0x2fa618; // 0x2fa7c4 - g_ps2RecompiledFunctionTable[518640] = DTR_ExecHndl_0x2fa618; // 0x2fa7c8 - g_ps2RecompiledFunctionTable[518641] = DTR_ExecHndl_0x2fa618; // 0x2fa7cc - g_ps2RecompiledFunctionTable[518642] = DTR_ExecHndl_0x2fa618; // 0x2fa7d0 - g_ps2RecompiledFunctionTable[518643] = DTR_ExecHndl_0x2fa618; // 0x2fa7d4 - g_ps2RecompiledFunctionTable[518644] = DTR_ExecHndl_0x2fa618; // 0x2fa7d8 - g_ps2RecompiledFunctionTable[518645] = DTR_ExecHndl_0x2fa618; // 0x2fa7dc - g_ps2RecompiledFunctionTable[518646] = DTR_ExecHndl_0x2fa618; // 0x2fa7e0 - g_ps2RecompiledFunctionTable[518647] = DTR_ExecHndl_0x2fa618; // 0x2fa7e4 - g_ps2RecompiledFunctionTable[518648] = DTR_ExecHndl_0x2fa618; // 0x2fa7e8 - g_ps2RecompiledFunctionTable[518649] = DTR_ExecHndl_0x2fa618; // 0x2fa7ec - g_ps2RecompiledFunctionTable[518650] = DTR_ExecHndl_0x2fa618; // 0x2fa7f0 - g_ps2RecompiledFunctionTable[518651] = DTR_ExecHndl_0x2fa618; // 0x2fa7f4 - g_ps2RecompiledFunctionTable[518652] = DTR_ExecHndl_0x2fa618; // 0x2fa7f8 - g_ps2RecompiledFunctionTable[518653] = DTR_ExecHndl_0x2fa618; // 0x2fa7fc - g_ps2RecompiledFunctionTable[518654] = DTR_ExecHndl_0x2fa618; // 0x2fa800 - g_ps2RecompiledFunctionTable[518655] = DTR_ExecHndl_0x2fa618; // 0x2fa804 - g_ps2RecompiledFunctionTable[518656] = DTR_ExecHndl_0x2fa618; // 0x2fa808 - g_ps2RecompiledFunctionTable[518657] = DTR_ExecHndl_0x2fa618; // 0x2fa80c - g_ps2RecompiledFunctionTable[518658] = DTR_ExecHndl_0x2fa618; // 0x2fa810 - g_ps2RecompiledFunctionTable[518659] = DTR_ExecHndl_0x2fa618; // 0x2fa814 - g_ps2RecompiledFunctionTable[518660] = DTR_ExecHndl_0x2fa618; // 0x2fa818 - g_ps2RecompiledFunctionTable[518661] = DTR_ExecHndl_0x2fa618; // 0x2fa81c - g_ps2RecompiledFunctionTable[518662] = DTR_ExecHndl_0x2fa618; // 0x2fa820 - g_ps2RecompiledFunctionTable[518663] = DTR_ExecHndl_0x2fa618; // 0x2fa824 - g_ps2RecompiledFunctionTable[518664] = DTR_ExecHndl_0x2fa618; // 0x2fa828 - g_ps2RecompiledFunctionTable[518665] = DTR_ExecHndl_0x2fa618; // 0x2fa82c - g_ps2RecompiledFunctionTable[518666] = DTR_ExecHndl_0x2fa618; // 0x2fa830 - g_ps2RecompiledFunctionTable[518667] = DTR_ExecHndl_0x2fa618; // 0x2fa834 - g_ps2RecompiledFunctionTable[518668] = DTR_ExecHndl_0x2fa618; // 0x2fa838 - g_ps2RecompiledFunctionTable[518669] = DTR_ExecHndl_0x2fa618; // 0x2fa83c - g_ps2RecompiledFunctionTable[518670] = DTR_ExecHndl_0x2fa618; // 0x2fa840 - g_ps2RecompiledFunctionTable[518671] = DTR_ExecHndl_0x2fa618; // 0x2fa844 - g_ps2RecompiledFunctionTable[518672] = DTR_ExecHndl_0x2fa618; // 0x2fa848 - g_ps2RecompiledFunctionTable[518673] = DTR_ExecHndl_0x2fa618; // 0x2fa84c - g_ps2RecompiledFunctionTable[518674] = DTR_ExecHndl_0x2fa618; // 0x2fa850 - g_ps2RecompiledFunctionTable[518675] = DTR_ExecHndl_0x2fa618; // 0x2fa854 - g_ps2RecompiledFunctionTable[518676] = DTR_ExecHndl_0x2fa618; // 0x2fa858 - g_ps2RecompiledFunctionTable[518677] = DTR_ExecHndl_0x2fa618; // 0x2fa85c - g_ps2RecompiledFunctionTable[518678] = DTR_ExecHndl_0x2fa618; // 0x2fa860 - g_ps2RecompiledFunctionTable[518679] = DTR_ExecHndl_0x2fa618; // 0x2fa864 - g_ps2RecompiledFunctionTable[518680] = DTR_ExecHndl_0x2fa618; // 0x2fa868 - g_ps2RecompiledFunctionTable[518681] = DTR_ExecHndl_0x2fa618; // 0x2fa86c - g_ps2RecompiledFunctionTable[518682] = DTR_ExecHndl_0x2fa618; // 0x2fa870 - g_ps2RecompiledFunctionTable[518683] = DTR_ExecHndl_0x2fa618; // 0x2fa874 - g_ps2RecompiledFunctionTable[518684] = DTR_ExecHndl_0x2fa618; // 0x2fa878 - g_ps2RecompiledFunctionTable[518685] = DTR_ExecHndl_0x2fa618; // 0x2fa87c - g_ps2RecompiledFunctionTable[518686] = DTR_ExecHndl_0x2fa618; // 0x2fa880 - g_ps2RecompiledFunctionTable[518687] = DTR_ExecHndl_0x2fa618; // 0x2fa884 - g_ps2RecompiledFunctionTable[518688] = DTR_ExecHndl_0x2fa618; // 0x2fa888 - g_ps2RecompiledFunctionTable[518689] = DTR_ExecHndl_0x2fa618; // 0x2fa88c - g_ps2RecompiledFunctionTable[518690] = DTR_ExecHndl_0x2fa618; // 0x2fa890 - g_ps2RecompiledFunctionTable[518691] = DTR_ExecHndl_0x2fa618; // 0x2fa894 - g_ps2RecompiledFunctionTable[518692] = DTR_ExecHndl_0x2fa618; // 0x2fa898 - g_ps2RecompiledFunctionTable[518693] = DTR_ExecHndl_0x2fa618; // 0x2fa89c - g_ps2RecompiledFunctionTable[518694] = DTR_ExecHndl_0x2fa618; // 0x2fa8a0 - g_ps2RecompiledFunctionTable[518695] = DTR_ExecHndl_0x2fa618; // 0x2fa8a4 - g_ps2RecompiledFunctionTable[518696] = DTR_ExecHndl_0x2fa618; // 0x2fa8a8 - g_ps2RecompiledFunctionTable[518697] = DTR_ExecHndl_0x2fa618; // 0x2fa8ac - g_ps2RecompiledFunctionTable[518698] = DTR_ExecHndl_0x2fa618; // 0x2fa8b0 - g_ps2RecompiledFunctionTable[518699] = DTR_ExecHndl_0x2fa618; // 0x2fa8b4 - g_ps2RecompiledFunctionTable[518700] = DTR_ExecHndl_0x2fa618; // 0x2fa8b8 - g_ps2RecompiledFunctionTable[518701] = DTR_ExecHndl_0x2fa618; // 0x2fa8bc - g_ps2RecompiledFunctionTable[518702] = DTR_ExecHndl_0x2fa618; // 0x2fa8c0 - g_ps2RecompiledFunctionTable[518703] = DTR_ExecHndl_0x2fa618; // 0x2fa8c4 - g_ps2RecompiledFunctionTable[518704] = DTR_ExecHndl_0x2fa618; // 0x2fa8c8 - g_ps2RecompiledFunctionTable[518705] = DTR_ExecHndl_0x2fa618; // 0x2fa8cc - g_ps2RecompiledFunctionTable[518706] = DTR_ExecHndl_0x2fa618; // 0x2fa8d0 - g_ps2RecompiledFunctionTable[518707] = DTR_ExecHndl_0x2fa618; // 0x2fa8d4 - g_ps2RecompiledFunctionTable[518708] = DTR_ExecHndl_0x2fa618; // 0x2fa8d8 - g_ps2RecompiledFunctionTable[518709] = DTR_ExecHndl_0x2fa618; // 0x2fa8dc - g_ps2RecompiledFunctionTable[518710] = DTR_ExecHndl_0x2fa618; // 0x2fa8e0 - g_ps2RecompiledFunctionTable[518711] = DTR_ExecHndl_0x2fa618; // 0x2fa8e4 - g_ps2RecompiledFunctionTable[518712] = DTR_ExecHndl_0x2fa618; // 0x2fa8e8 - g_ps2RecompiledFunctionTable[518713] = DTR_ExecHndl_0x2fa618; // 0x2fa8ec - g_ps2RecompiledFunctionTable[518714] = DTR_ExecHndl_0x2fa618; // 0x2fa8f0 - g_ps2RecompiledFunctionTable[518715] = DTR_ExecHndl_0x2fa618; // 0x2fa8f4 - g_ps2RecompiledFunctionTable[518716] = DTR_ExecHndl_0x2fa618; // 0x2fa8f8 - g_ps2RecompiledFunctionTable[518717] = DTR_ExecHndl_0x2fa618; // 0x2fa8fc - g_ps2RecompiledFunctionTable[518718] = DTR_ExecHndl_0x2fa618; // 0x2fa900 - g_ps2RecompiledFunctionTable[518719] = DTR_ExecHndl_0x2fa618; // 0x2fa904 - g_ps2RecompiledFunctionTable[518720] = DTR_ExecHndl_0x2fa618; // 0x2fa908 - g_ps2RecompiledFunctionTable[518721] = DTR_ExecHndl_0x2fa618; // 0x2fa90c - g_ps2RecompiledFunctionTable[518722] = DTR_ExecHndl_0x2fa618; // 0x2fa910 - g_ps2RecompiledFunctionTable[518723] = DTR_ExecHndl_0x2fa618; // 0x2fa914 - g_ps2RecompiledFunctionTable[518724] = DTR_ExecHndl_0x2fa618; // 0x2fa918 - g_ps2RecompiledFunctionTable[518725] = DTR_ExecHndl_0x2fa618; // 0x2fa91c - g_ps2RecompiledFunctionTable[518726] = DTR_ExecHndl_0x2fa618; // 0x2fa920 - g_ps2RecompiledFunctionTable[518727] = DTR_ExecHndl_0x2fa618; // 0x2fa924 - g_ps2RecompiledFunctionTable[518728] = DTR_ExecHndl_0x2fa618; // 0x2fa928 - g_ps2RecompiledFunctionTable[518729] = DTR_ExecHndl_0x2fa618; // 0x2fa92c - g_ps2RecompiledFunctionTable[518730] = DTR_ExecHndl_0x2fa618; // 0x2fa930 - g_ps2RecompiledFunctionTable[518731] = DTR_ExecHndl_0x2fa618; // 0x2fa934 - g_ps2RecompiledFunctionTable[518732] = DTR_ExecHndl_0x2fa618; // 0x2fa938 - g_ps2RecompiledFunctionTable[518733] = DTR_ExecHndl_0x2fa618; // 0x2fa93c - g_ps2RecompiledFunctionTable[518734] = DTR_ExecHndl_0x2fa618; // 0x2fa940 - g_ps2RecompiledFunctionTable[518735] = DTR_ExecHndl_0x2fa618; // 0x2fa944 - g_ps2RecompiledFunctionTable[518736] = DTR_ExecHndl_0x2fa618; // 0x2fa948 - g_ps2RecompiledFunctionTable[518737] = DTR_ExecHndl_0x2fa618; // 0x2fa94c - g_ps2RecompiledFunctionTable[518738] = DTR_ExecHndl_0x2fa618; // 0x2fa950 - g_ps2RecompiledFunctionTable[518739] = DTR_ExecHndl_0x2fa618; // 0x2fa954 - g_ps2RecompiledFunctionTable[518740] = DTR_ExecHndl_0x2fa618; // 0x2fa958 - g_ps2RecompiledFunctionTable[518741] = DTR_ExecHndl_0x2fa618; // 0x2fa95c - g_ps2RecompiledFunctionTable[518742] = DTR_ExecHndl_0x2fa618; // 0x2fa960 - g_ps2RecompiledFunctionTable[518743] = DTR_ExecHndl_0x2fa618; // 0x2fa964 - g_ps2RecompiledFunctionTable[518744] = DTR_ExecHndl_0x2fa618; // 0x2fa968 - g_ps2RecompiledFunctionTable[518745] = DTR_ExecHndl_0x2fa618; // 0x2fa96c - g_ps2RecompiledFunctionTable[518746] = DTR_ExecHndl_0x2fa618; // 0x2fa970 - g_ps2RecompiledFunctionTable[518747] = DTR_ExecHndl_0x2fa618; // 0x2fa974 - g_ps2RecompiledFunctionTable[518748] = DTR_ExecServer_0x2fa978; // 0x2fa978 - g_ps2RecompiledFunctionTable[518758] = DTR_ExecServer_0x2fa978; // 0x2fa9a0 - g_ps2RecompiledFunctionTable[518763] = DTR_ExecServer_0x2fa978; // 0x2fa9b4 - g_ps2RecompiledFunctionTable[518772] = DTR_Init_0x2fa9d8; // 0x2fa9d8 - g_ps2RecompiledFunctionTable[518778] = DTR_Init_0x2fa9d8; // 0x2fa9f0 - g_ps2RecompiledFunctionTable[518786] = DTR_Init_0x2fa9d8; // 0x2faa10 - g_ps2RecompiledFunctionTable[518794] = DTR_Finish_0x2faa30; // 0x2faa30 - g_ps2RecompiledFunctionTable[518798] = DTR_Create_0x2faa40; // 0x2faa40 - g_ps2RecompiledFunctionTable[518806] = DTR_Create_0x2faa40; // 0x2faa60 - g_ps2RecompiledFunctionTable[518814] = DTR_Create_0x2faa40; // 0x2faa80 - g_ps2RecompiledFunctionTable[518830] = DTR_Create_0x2faa40; // 0x2faac0 - g_ps2RecompiledFunctionTable[518842] = DTR_Create_0x2faa40; // 0x2faaf0 - g_ps2RecompiledFunctionTable[518850] = DTR_Destroy_0x2fab10; // 0x2fab10 - g_ps2RecompiledFunctionTable[518855] = DTR_Destroy_0x2fab10; // 0x2fab24 - g_ps2RecompiledFunctionTable[518860] = DTR_Start_0x2fab38; // 0x2fab38 - g_ps2RecompiledFunctionTable[518864] = DTR_Stop_0x2fab48; // 0x2fab48 - g_ps2RecompiledFunctionTable[518865] = DTR_Stop_0x2fab48; // 0x2fab4c - g_ps2RecompiledFunctionTable[518866] = DTR_Stop_0x2fab48; // 0x2fab50 - g_ps2RecompiledFunctionTable[518867] = DTR_Stop_0x2fab48; // 0x2fab54 - g_ps2RecompiledFunctionTable[518868] = DTR_Stop_0x2fab48; // 0x2fab58 - g_ps2RecompiledFunctionTable[518869] = DTR_Stop_0x2fab48; // 0x2fab5c - g_ps2RecompiledFunctionTable[518870] = DTR_Stop_0x2fab48; // 0x2fab60 - g_ps2RecompiledFunctionTable[518871] = DTR_Stop_0x2fab48; // 0x2fab64 - g_ps2RecompiledFunctionTable[518872] = DTR_Stop_0x2fab48; // 0x2fab68 - g_ps2RecompiledFunctionTable[518873] = DTR_Stop_0x2fab48; // 0x2fab6c - g_ps2RecompiledFunctionTable[518874] = DTR_Stop_0x2fab48; // 0x2fab70 - g_ps2RecompiledFunctionTable[518875] = DTR_Stop_0x2fab48; // 0x2fab74 - g_ps2RecompiledFunctionTable[518876] = DTR_Stop_0x2fab48; // 0x2fab78 - g_ps2RecompiledFunctionTable[518877] = DTR_Stop_0x2fab48; // 0x2fab7c - g_ps2RecompiledFunctionTable[518878] = DTR_Stop_0x2fab48; // 0x2fab80 - g_ps2RecompiledFunctionTable[518879] = DTR_Stop_0x2fab48; // 0x2fab84 - g_ps2RecompiledFunctionTable[518880] = DTR_Stop_0x2fab48; // 0x2fab88 - g_ps2RecompiledFunctionTable[518881] = DTR_Stop_0x2fab48; // 0x2fab8c - g_ps2RecompiledFunctionTable[518882] = DTR_Stop_0x2fab48; // 0x2fab90 - g_ps2RecompiledFunctionTable[518883] = DTR_Stop_0x2fab48; // 0x2fab94 - g_ps2RecompiledFunctionTable[518884] = DTR_Stop_0x2fab48; // 0x2fab98 - g_ps2RecompiledFunctionTable[518885] = DTR_Stop_0x2fab48; // 0x2fab9c - g_ps2RecompiledFunctionTable[518886] = DTR_Stop_0x2fab48; // 0x2faba0 - g_ps2RecompiledFunctionTable[518887] = DTR_Stop_0x2fab48; // 0x2faba4 - g_ps2RecompiledFunctionTable[518888] = DTR_Stop_0x2fab48; // 0x2faba8 - g_ps2RecompiledFunctionTable[518889] = DTR_Stop_0x2fab48; // 0x2fabac - g_ps2RecompiledFunctionTable[518890] = DTR_Stop_0x2fab48; // 0x2fabb0 - g_ps2RecompiledFunctionTable[518891] = DTR_Stop_0x2fab48; // 0x2fabb4 - g_ps2RecompiledFunctionTable[518892] = DTR_Stop_0x2fab48; // 0x2fabb8 - g_ps2RecompiledFunctionTable[518894] = dtx_rpc_func_0x2fabc0; // 0x2fabc0 - g_ps2RecompiledFunctionTable[518895] = dtx_rpc_func_0x2fabc0; // 0x2fabc4 - g_ps2RecompiledFunctionTable[518896] = dtx_rpc_func_0x2fabc0; // 0x2fabc8 - g_ps2RecompiledFunctionTable[518897] = dtx_rpc_func_0x2fabc0; // 0x2fabcc - g_ps2RecompiledFunctionTable[518898] = dtx_rpc_func_0x2fabc0; // 0x2fabd0 - g_ps2RecompiledFunctionTable[518899] = dtx_rpc_func_0x2fabc0; // 0x2fabd4 - g_ps2RecompiledFunctionTable[518900] = dtx_rpc_func_0x2fabc0; // 0x2fabd8 - g_ps2RecompiledFunctionTable[518901] = dtx_rpc_func_0x2fabc0; // 0x2fabdc - g_ps2RecompiledFunctionTable[518902] = dtx_rpc_func_0x2fabc0; // 0x2fabe0 - g_ps2RecompiledFunctionTable[518903] = dtx_rpc_func_0x2fabc0; // 0x2fabe4 - g_ps2RecompiledFunctionTable[518904] = dtx_rpc_func_0x2fabc0; // 0x2fabe8 - g_ps2RecompiledFunctionTable[518905] = dtx_rpc_func_0x2fabc0; // 0x2fabec - g_ps2RecompiledFunctionTable[518906] = dtx_rpc_func_0x2fabc0; // 0x2fabf0 - g_ps2RecompiledFunctionTable[518907] = dtx_rpc_func_0x2fabc0; // 0x2fabf4 - g_ps2RecompiledFunctionTable[518908] = dtx_rpc_func_0x2fabc0; // 0x2fabf8 - g_ps2RecompiledFunctionTable[518909] = dtx_rpc_func_0x2fabc0; // 0x2fabfc - g_ps2RecompiledFunctionTable[518910] = dtx_rpc_func_0x2fabc0; // 0x2fac00 - g_ps2RecompiledFunctionTable[518911] = dtx_rpc_func_0x2fabc0; // 0x2fac04 - g_ps2RecompiledFunctionTable[518912] = dtx_rpc_func_0x2fabc0; // 0x2fac08 - g_ps2RecompiledFunctionTable[518913] = dtx_rpc_func_0x2fabc0; // 0x2fac0c - g_ps2RecompiledFunctionTable[518914] = dtx_rpc_func_0x2fabc0; // 0x2fac10 - g_ps2RecompiledFunctionTable[518915] = dtx_rpc_func_0x2fabc0; // 0x2fac14 - g_ps2RecompiledFunctionTable[518916] = dtx_rpc_func_0x2fabc0; // 0x2fac18 - g_ps2RecompiledFunctionTable[518917] = dtx_rpc_func_0x2fabc0; // 0x2fac1c - g_ps2RecompiledFunctionTable[518918] = dtx_rpc_func_0x2fabc0; // 0x2fac20 - g_ps2RecompiledFunctionTable[518919] = dtx_rpc_func_0x2fabc0; // 0x2fac24 - g_ps2RecompiledFunctionTable[518920] = dtx_rpc_func_0x2fabc0; // 0x2fac28 - g_ps2RecompiledFunctionTable[518921] = dtx_rpc_func_0x2fabc0; // 0x2fac2c - g_ps2RecompiledFunctionTable[518922] = dtx_rpc_func_0x2fabc0; // 0x2fac30 - g_ps2RecompiledFunctionTable[518923] = dtx_rpc_func_0x2fabc0; // 0x2fac34 - g_ps2RecompiledFunctionTable[518924] = dtx_rpc_func_0x2fabc0; // 0x2fac38 - g_ps2RecompiledFunctionTable[518925] = dtx_rpc_func_0x2fabc0; // 0x2fac3c - g_ps2RecompiledFunctionTable[518926] = dtx_rpc_func_0x2fabc0; // 0x2fac40 - g_ps2RecompiledFunctionTable[518927] = dtx_rpc_func_0x2fabc0; // 0x2fac44 - g_ps2RecompiledFunctionTable[518928] = dtx_rpc_func_0x2fabc0; // 0x2fac48 - g_ps2RecompiledFunctionTable[518929] = dtx_rpc_func_0x2fabc0; // 0x2fac4c - g_ps2RecompiledFunctionTable[518930] = dtx_rpc_func_0x2fabc0; // 0x2fac50 - g_ps2RecompiledFunctionTable[518931] = dtx_rpc_func_0x2fabc0; // 0x2fac54 - g_ps2RecompiledFunctionTable[518932] = dtx_rpc_func_0x2fabc0; // 0x2fac58 - g_ps2RecompiledFunctionTable[518933] = dtx_rpc_func_0x2fabc0; // 0x2fac5c - g_ps2RecompiledFunctionTable[518934] = dtx_rpc_func_0x2fabc0; // 0x2fac60 - g_ps2RecompiledFunctionTable[518935] = dtx_rpc_func_0x2fabc0; // 0x2fac64 - g_ps2RecompiledFunctionTable[518936] = dtx_rpc_func_0x2fabc0; // 0x2fac68 - g_ps2RecompiledFunctionTable[518937] = dtx_rpc_func_0x2fabc0; // 0x2fac6c - g_ps2RecompiledFunctionTable[518938] = dtx_rpc_func_0x2fabc0; // 0x2fac70 - g_ps2RecompiledFunctionTable[518939] = dtx_rpc_func_0x2fabc0; // 0x2fac74 - g_ps2RecompiledFunctionTable[518940] = dtx_rpc_func_0x2fabc0; // 0x2fac78 - g_ps2RecompiledFunctionTable[518941] = dtx_rpc_func_0x2fabc0; // 0x2fac7c - g_ps2RecompiledFunctionTable[518942] = dtx_rpc_func_0x2fabc0; // 0x2fac80 - g_ps2RecompiledFunctionTable[518943] = dtx_rpc_func_0x2fabc0; // 0x2fac84 - g_ps2RecompiledFunctionTable[518944] = dtx_rpc_func_0x2fabc0; // 0x2fac88 - g_ps2RecompiledFunctionTable[518946] = dtx_svr_proc_0x2fac90; // 0x2fac90 - g_ps2RecompiledFunctionTable[518951] = dtx_svr_proc_0x2fac90; // 0x2faca4 - g_ps2RecompiledFunctionTable[518954] = dtx_svr_proc_0x2fac90; // 0x2facb0 - g_ps2RecompiledFunctionTable[518956] = dtx_svr_proc_0x2fac90; // 0x2facb8 - g_ps2RecompiledFunctionTable[518959] = dtx_svr_proc_0x2fac90; // 0x2facc4 - g_ps2RecompiledFunctionTable[518970] = dtx_svr_proc_0x2fac90; // 0x2facf0 - g_ps2RecompiledFunctionTable[518975] = dtx_svr_proc_0x2fac90; // 0x2fad04 - g_ps2RecompiledFunctionTable[518980] = dtx_create_rmt_0x2fad18; // 0x2fad18 - g_ps2RecompiledFunctionTable[519001] = dtx_create_rmt_0x2fad18; // 0x2fad6c - g_ps2RecompiledFunctionTable[519006] = dtx_destroy_rmt_0x2fad80; // 0x2fad80 - g_ps2RecompiledFunctionTable[519022] = dtx_destroy_rmt_0x2fad80; // 0x2fadc0 - g_ps2RecompiledFunctionTable[519026] = dtx_def_rcvcbf_0x2fadd0; // 0x2fadd0 - g_ps2RecompiledFunctionTable[519030] = dtx_def_sndcbf_0x2fade0; // 0x2fade0 - g_ps2RecompiledFunctionTable[519036] = dtx_def_sndcbf_0x2fade0; // 0x2fadf8 - g_ps2RecompiledFunctionTable[519050] = dtx_def_sndcbf_0x2fade0; // 0x2fae30 - g_ps2RecompiledFunctionTable[519056] = DTX_Open_0x2fae48; // 0x2fae48 - g_ps2RecompiledFunctionTable[519066] = DTX_Close_0x2fae70; // 0x2fae70 - g_ps2RecompiledFunctionTable[519072] = DTX_Create_0x2fae88; // 0x2fae88 - g_ps2RecompiledFunctionTable[519105] = DTX_Create_0x2fae88; // 0x2faf0c - g_ps2RecompiledFunctionTable[519119] = DTX_Create_0x2fae88; // 0x2faf44 - g_ps2RecompiledFunctionTable[519125] = DTX_Create_0x2fae88; // 0x2faf5c - g_ps2RecompiledFunctionTable[519142] = DTX_Create_0x2fae88; // 0x2fafa0 - g_ps2RecompiledFunctionTable[519148] = DTX_Create_0x2fae88; // 0x2fafb8 - g_ps2RecompiledFunctionTable[519154] = DTX_Create_0x2fae88; // 0x2fafd0 - g_ps2RecompiledFunctionTable[519172] = DTX_Destroy_0x2fb018; // 0x2fb018 - g_ps2RecompiledFunctionTable[519178] = DTX_Destroy_0x2fb018; // 0x2fb030 - g_ps2RecompiledFunctionTable[519186] = DTX_SetRcvCbf_0x2fb050; // 0x2fb050 - g_ps2RecompiledFunctionTable[519190] = DTX_SetSndCbf_0x2fb060; // 0x2fb060 - g_ps2RecompiledFunctionTable[519194] = DTX_ExecHndl_0x2fb070; // 0x2fb070 - g_ps2RecompiledFunctionTable[519195] = DTX_ExecHndl_0x2fb070; // 0x2fb074 - g_ps2RecompiledFunctionTable[519196] = DTX_ExecHndl_0x2fb070; // 0x2fb078 - g_ps2RecompiledFunctionTable[519197] = DTX_ExecHndl_0x2fb070; // 0x2fb07c - g_ps2RecompiledFunctionTable[519198] = DTX_ExecHndl_0x2fb070; // 0x2fb080 - g_ps2RecompiledFunctionTable[519199] = DTX_ExecHndl_0x2fb070; // 0x2fb084 - g_ps2RecompiledFunctionTable[519200] = DTX_ExecHndl_0x2fb070; // 0x2fb088 - g_ps2RecompiledFunctionTable[519201] = DTX_ExecHndl_0x2fb070; // 0x2fb08c - g_ps2RecompiledFunctionTable[519202] = DTX_ExecHndl_0x2fb070; // 0x2fb090 - g_ps2RecompiledFunctionTable[519203] = DTX_ExecHndl_0x2fb070; // 0x2fb094 - g_ps2RecompiledFunctionTable[519204] = DTX_ExecHndl_0x2fb070; // 0x2fb098 - g_ps2RecompiledFunctionTable[519205] = DTX_ExecHndl_0x2fb070; // 0x2fb09c - g_ps2RecompiledFunctionTable[519206] = DTX_ExecHndl_0x2fb070; // 0x2fb0a0 - g_ps2RecompiledFunctionTable[519207] = DTX_ExecHndl_0x2fb070; // 0x2fb0a4 - g_ps2RecompiledFunctionTable[519208] = DTX_ExecHndl_0x2fb070; // 0x2fb0a8 - g_ps2RecompiledFunctionTable[519209] = DTX_ExecHndl_0x2fb070; // 0x2fb0ac - g_ps2RecompiledFunctionTable[519210] = DTX_ExecHndl_0x2fb070; // 0x2fb0b0 - g_ps2RecompiledFunctionTable[519211] = DTX_ExecHndl_0x2fb070; // 0x2fb0b4 - g_ps2RecompiledFunctionTable[519212] = DTX_ExecHndl_0x2fb070; // 0x2fb0b8 - g_ps2RecompiledFunctionTable[519213] = DTX_ExecHndl_0x2fb070; // 0x2fb0bc - g_ps2RecompiledFunctionTable[519214] = DTX_ExecHndl_0x2fb070; // 0x2fb0c0 - g_ps2RecompiledFunctionTable[519215] = DTX_ExecHndl_0x2fb070; // 0x2fb0c4 - g_ps2RecompiledFunctionTable[519216] = DTX_ExecHndl_0x2fb070; // 0x2fb0c8 - g_ps2RecompiledFunctionTable[519217] = DTX_ExecHndl_0x2fb070; // 0x2fb0cc - g_ps2RecompiledFunctionTable[519218] = DTX_ExecHndl_0x2fb070; // 0x2fb0d0 - g_ps2RecompiledFunctionTable[519219] = DTX_ExecHndl_0x2fb070; // 0x2fb0d4 - g_ps2RecompiledFunctionTable[519220] = DTX_ExecHndl_0x2fb070; // 0x2fb0d8 - g_ps2RecompiledFunctionTable[519221] = DTX_ExecHndl_0x2fb070; // 0x2fb0dc - g_ps2RecompiledFunctionTable[519222] = DTX_ExecHndl_0x2fb070; // 0x2fb0e0 - g_ps2RecompiledFunctionTable[519223] = DTX_ExecHndl_0x2fb070; // 0x2fb0e4 - g_ps2RecompiledFunctionTable[519224] = DTX_ExecHndl_0x2fb070; // 0x2fb0e8 - g_ps2RecompiledFunctionTable[519225] = DTX_ExecHndl_0x2fb070; // 0x2fb0ec - g_ps2RecompiledFunctionTable[519226] = DTX_ExecHndl_0x2fb070; // 0x2fb0f0 - g_ps2RecompiledFunctionTable[519227] = DTX_ExecHndl_0x2fb070; // 0x2fb0f4 - g_ps2RecompiledFunctionTable[519228] = DTX_ExecHndl_0x2fb070; // 0x2fb0f8 - g_ps2RecompiledFunctionTable[519229] = DTX_ExecHndl_0x2fb070; // 0x2fb0fc - g_ps2RecompiledFunctionTable[519230] = DTX_ExecHndl_0x2fb070; // 0x2fb100 - g_ps2RecompiledFunctionTable[519231] = DTX_ExecHndl_0x2fb070; // 0x2fb104 - g_ps2RecompiledFunctionTable[519232] = DTX_ExecHndl_0x2fb070; // 0x2fb108 - g_ps2RecompiledFunctionTable[519233] = DTX_ExecHndl_0x2fb070; // 0x2fb10c - g_ps2RecompiledFunctionTable[519234] = DTX_ExecHndl_0x2fb070; // 0x2fb110 - g_ps2RecompiledFunctionTable[519235] = DTX_ExecHndl_0x2fb070; // 0x2fb114 - g_ps2RecompiledFunctionTable[519236] = DTX_ExecHndl_0x2fb070; // 0x2fb118 - g_ps2RecompiledFunctionTable[519237] = DTX_ExecHndl_0x2fb070; // 0x2fb11c - g_ps2RecompiledFunctionTable[519238] = DTX_ExecHndl_0x2fb070; // 0x2fb120 - g_ps2RecompiledFunctionTable[519239] = DTX_ExecHndl_0x2fb070; // 0x2fb124 - g_ps2RecompiledFunctionTable[519240] = DTX_ExecHndl_0x2fb070; // 0x2fb128 - g_ps2RecompiledFunctionTable[519241] = DTX_ExecHndl_0x2fb070; // 0x2fb12c - g_ps2RecompiledFunctionTable[519242] = DTX_ExecHndl_0x2fb070; // 0x2fb130 - g_ps2RecompiledFunctionTable[519243] = DTX_ExecHndl_0x2fb070; // 0x2fb134 - g_ps2RecompiledFunctionTable[519244] = DTX_ExecHndl_0x2fb070; // 0x2fb138 - g_ps2RecompiledFunctionTable[519245] = DTX_ExecHndl_0x2fb070; // 0x2fb13c - g_ps2RecompiledFunctionTable[519246] = DTX_ExecHndl_0x2fb070; // 0x2fb140 - g_ps2RecompiledFunctionTable[519247] = DTX_ExecHndl_0x2fb070; // 0x2fb144 - g_ps2RecompiledFunctionTable[519248] = DTX_ExecHndl_0x2fb070; // 0x2fb148 - g_ps2RecompiledFunctionTable[519249] = DTX_ExecHndl_0x2fb070; // 0x2fb14c - g_ps2RecompiledFunctionTable[519250] = DTX_ExecHndl_0x2fb070; // 0x2fb150 - g_ps2RecompiledFunctionTable[519251] = DTX_ExecHndl_0x2fb070; // 0x2fb154 - g_ps2RecompiledFunctionTable[519252] = DTX_ExecHndl_0x2fb070; // 0x2fb158 - g_ps2RecompiledFunctionTable[519253] = DTX_ExecHndl_0x2fb070; // 0x2fb15c - g_ps2RecompiledFunctionTable[519254] = DTX_ExecHndl_0x2fb070; // 0x2fb160 - g_ps2RecompiledFunctionTable[519255] = DTX_ExecHndl_0x2fb070; // 0x2fb164 - g_ps2RecompiledFunctionTable[519256] = DTX_ExecHndl_0x2fb070; // 0x2fb168 - g_ps2RecompiledFunctionTable[519257] = DTX_ExecHndl_0x2fb070; // 0x2fb16c - g_ps2RecompiledFunctionTable[519258] = DTX_ExecHndl_0x2fb070; // 0x2fb170 - g_ps2RecompiledFunctionTable[519259] = DTX_ExecHndl_0x2fb070; // 0x2fb174 - g_ps2RecompiledFunctionTable[519260] = DTX_ExecHndl_0x2fb070; // 0x2fb178 - g_ps2RecompiledFunctionTable[519261] = DTX_ExecHndl_0x2fb070; // 0x2fb17c - g_ps2RecompiledFunctionTable[519262] = DTX_ExecHndl_0x2fb070; // 0x2fb180 - g_ps2RecompiledFunctionTable[519263] = DTX_ExecHndl_0x2fb070; // 0x2fb184 - g_ps2RecompiledFunctionTable[519264] = DTX_ExecHndl_0x2fb070; // 0x2fb188 - g_ps2RecompiledFunctionTable[519265] = DTX_ExecHndl_0x2fb070; // 0x2fb18c - g_ps2RecompiledFunctionTable[519266] = DTX_ExecHndl_0x2fb070; // 0x2fb190 - g_ps2RecompiledFunctionTable[519267] = DTX_ExecHndl_0x2fb070; // 0x2fb194 - g_ps2RecompiledFunctionTable[519268] = DTX_ExecHndl_0x2fb070; // 0x2fb198 - g_ps2RecompiledFunctionTable[519269] = DTX_ExecHndl_0x2fb070; // 0x2fb19c - g_ps2RecompiledFunctionTable[519270] = DTX_Init_0x2fb1a0; // 0x2fb1a0 - g_ps2RecompiledFunctionTable[519278] = DTX_Init_0x2fb1a0; // 0x2fb1c0 - g_ps2RecompiledFunctionTable[519280] = DTX_Init_0x2fb1a0; // 0x2fb1c8 - g_ps2RecompiledFunctionTable[519291] = DTX_Init_0x2fb1a0; // 0x2fb1f4 - g_ps2RecompiledFunctionTable[519296] = DTX_Init_0x2fb1a0; // 0x2fb208 - g_ps2RecompiledFunctionTable[519312] = DTX_Finish_0x2fb248; // 0x2fb248 - g_ps2RecompiledFunctionTable[519328] = DTX_Finish_0x2fb248; // 0x2fb288 - g_ps2RecompiledFunctionTable[519332] = DTX_Finish_0x2fb248; // 0x2fb298 - g_ps2RecompiledFunctionTable[519342] = DTX_CallUrpc_0x2fb2c0; // 0x2fb2c0 - g_ps2RecompiledFunctionTable[519360] = DTX_CallUrpc_0x2fb2c0; // 0x2fb308 - g_ps2RecompiledFunctionTable[519386] = DTX_CallUrpc_0x2fb2c0; // 0x2fb370 - g_ps2RecompiledFunctionTable[519392] = DTX_CallUrpc_0x2fb2c0; // 0x2fb388 - g_ps2RecompiledFunctionTable[519408] = DTX_ExecServer_0x2fb3c8; // 0x2fb3c8 - g_ps2RecompiledFunctionTable[519415] = DTX_ExecServer_0x2fb3c8; // 0x2fb3e4 - g_ps2RecompiledFunctionTable[519420] = DTX_ExecServer_0x2fb3c8; // 0x2fb3f8 - g_ps2RecompiledFunctionTable[519424] = DTX_ExecServer_0x2fb3c8; // 0x2fb408 - g_ps2RecompiledFunctionTable[519434] = dvCiGetInterface_0x2fb430; // 0x2fb430 - g_ps2RecompiledFunctionTable[519438] = dvci_wait_0x2fb440; // 0x2fb440 - g_ps2RecompiledFunctionTable[519440] = dvci_wait_0x2fb440; // 0x2fb448 - g_ps2RecompiledFunctionTable[519450] = dvci_call_errfn_0x2fb470; // 0x2fb470 - g_ps2RecompiledFunctionTable[519451] = dvci_call_errfn_0x2fb470; // 0x2fb474 - g_ps2RecompiledFunctionTable[519452] = dvci_call_errfn_0x2fb470; // 0x2fb478 - g_ps2RecompiledFunctionTable[519453] = dvci_call_errfn_0x2fb470; // 0x2fb47c - g_ps2RecompiledFunctionTable[519454] = dvci_call_errfn_0x2fb470; // 0x2fb480 - g_ps2RecompiledFunctionTable[519455] = dvci_call_errfn_0x2fb470; // 0x2fb484 - g_ps2RecompiledFunctionTable[519456] = dvci_call_errfn_0x2fb470; // 0x2fb488 - g_ps2RecompiledFunctionTable[519457] = dvci_call_errfn_0x2fb470; // 0x2fb48c - g_ps2RecompiledFunctionTable[519458] = dvci_call_errfn_0x2fb470; // 0x2fb490 - g_ps2RecompiledFunctionTable[519459] = dvci_call_errfn_0x2fb470; // 0x2fb494 - g_ps2RecompiledFunctionTable[519460] = dvci_call_errfn_0x2fb470; // 0x2fb498 - g_ps2RecompiledFunctionTable[519461] = dvci_call_errfn_0x2fb470; // 0x2fb49c - g_ps2RecompiledFunctionTable[519462] = dvCiExecHndl_0x2fb4a0; // 0x2fb4a0 - g_ps2RecompiledFunctionTable[519473] = dvCiExecHndl_0x2fb4a0; // 0x2fb4cc - g_ps2RecompiledFunctionTable[519475] = dvCiExecHndl_0x2fb4a0; // 0x2fb4d4 - g_ps2RecompiledFunctionTable[519506] = dvCiExecHndl_0x2fb4a0; // 0x2fb550 - g_ps2RecompiledFunctionTable[519518] = dvCiExecServer_0x2fb580; // 0x2fb580 - g_ps2RecompiledFunctionTable[519528] = dvCiExecServer_0x2fb580; // 0x2fb5a8 - g_ps2RecompiledFunctionTable[519534] = dvCiExecServer_0x2fb580; // 0x2fb5c0 - g_ps2RecompiledFunctionTable[519542] = dvCiEntryErrFunc_0x2fb5e0; // 0x2fb5e0 - g_ps2RecompiledFunctionTable[519548] = dvci_to_large_to_yen_0x2fb5f8; // 0x2fb5f8 - g_ps2RecompiledFunctionTable[519553] = dvci_to_large_to_yen_0x2fb5f8; // 0x2fb60c - g_ps2RecompiledFunctionTable[519560] = dvci_to_large_to_yen_0x2fb5f8; // 0x2fb628 - g_ps2RecompiledFunctionTable[519578] = dvci_conv_fname_0x2fb670; // 0x2fb670 - g_ps2RecompiledFunctionTable[519589] = dvci_conv_fname_0x2fb670; // 0x2fb69c - g_ps2RecompiledFunctionTable[519592] = dvci_conv_fname_0x2fb670; // 0x2fb6a8 - g_ps2RecompiledFunctionTable[519594] = dvci_conv_fname_0x2fb670; // 0x2fb6b0 - g_ps2RecompiledFunctionTable[519600] = dvci_conv_fname_0x2fb670; // 0x2fb6c8 - g_ps2RecompiledFunctionTable[519604] = dvci_conv_fname_0x2fb670; // 0x2fb6d8 - g_ps2RecompiledFunctionTable[519612] = dvCiGetFileSize_0x2fb6f8; // 0x2fb6f8 - g_ps2RecompiledFunctionTable[519625] = dvCiGetFileSize_0x2fb6f8; // 0x2fb72c - g_ps2RecompiledFunctionTable[519630] = dvCiGetFileSize_0x2fb6f8; // 0x2fb740 - g_ps2RecompiledFunctionTable[519635] = dvCiGetFileSize_0x2fb6f8; // 0x2fb754 - g_ps2RecompiledFunctionTable[519638] = dvCiGetFileSize_0x2fb6f8; // 0x2fb760 - g_ps2RecompiledFunctionTable[519645] = dvCiGetFileSize_0x2fb6f8; // 0x2fb77c - g_ps2RecompiledFunctionTable[519652] = dvci_alloc_0x2fb798; // 0x2fb798 - g_ps2RecompiledFunctionTable[519656] = dvci_alloc_0x2fb798; // 0x2fb7a8 - g_ps2RecompiledFunctionTable[519666] = dvci_free_0x2fb7d0; // 0x2fb7d0 - g_ps2RecompiledFunctionTable[519670] = dvCiOpen_0x2fb7e0; // 0x2fb7e0 - g_ps2RecompiledFunctionTable[519689] = dvCiOpen_0x2fb7e0; // 0x2fb82c - g_ps2RecompiledFunctionTable[519697] = dvCiOpen_0x2fb7e0; // 0x2fb84c - g_ps2RecompiledFunctionTable[519702] = dvCiOpen_0x2fb7e0; // 0x2fb860 - g_ps2RecompiledFunctionTable[519710] = dvCiOpen_0x2fb7e0; // 0x2fb880 - g_ps2RecompiledFunctionTable[519712] = dvCiOpen_0x2fb7e0; // 0x2fb888 - g_ps2RecompiledFunctionTable[519715] = dvCiOpen_0x2fb7e0; // 0x2fb894 - g_ps2RecompiledFunctionTable[519721] = dvCiOpen_0x2fb7e0; // 0x2fb8ac - g_ps2RecompiledFunctionTable[519723] = dvCiOpen_0x2fb7e0; // 0x2fb8b4 - g_ps2RecompiledFunctionTable[519750] = dvCiClose_0x2fb920; // 0x2fb920 - g_ps2RecompiledFunctionTable[519761] = dvCiClose_0x2fb920; // 0x2fb94c - g_ps2RecompiledFunctionTable[519772] = dvCiSeek_0x2fb978; // 0x2fb978 - g_ps2RecompiledFunctionTable[519780] = dvCiSeek_0x2fb978; // 0x2fb998 - g_ps2RecompiledFunctionTable[519810] = dvCiTell_0x2fba10; // 0x2fba10 - g_ps2RecompiledFunctionTable[519817] = dvCiTell_0x2fba10; // 0x2fba2c - g_ps2RecompiledFunctionTable[519824] = dvCiReqRd_0x2fba48; // 0x2fba48 - g_ps2RecompiledFunctionTable[519849] = dvCiReqRd_0x2fba48; // 0x2fbaac - g_ps2RecompiledFunctionTable[519876] = dvCiReqRd_0x2fba48; // 0x2fbb18 - g_ps2RecompiledFunctionTable[519881] = dvCiReqRd_0x2fba48; // 0x2fbb2c - g_ps2RecompiledFunctionTable[519890] = dvCiReqRd_0x2fba48; // 0x2fbb50 - g_ps2RecompiledFunctionTable[519895] = dvCiReqRd_0x2fba48; // 0x2fbb64 - g_ps2RecompiledFunctionTable[519906] = dvCiStopTr_0x2fbb90; // 0x2fbb90 - g_ps2RecompiledFunctionTable[519927] = dvCiStopTr_0x2fbb90; // 0x2fbbe4 - g_ps2RecompiledFunctionTable[519934] = dvCiStopTr_0x2fbb90; // 0x2fbc00 - g_ps2RecompiledFunctionTable[519936] = dvCiStopTr_0x2fbb90; // 0x2fbc08 - g_ps2RecompiledFunctionTable[519941] = dvCiStopTr_0x2fbb90; // 0x2fbc1c - g_ps2RecompiledFunctionTable[519947] = dvCiStopTr_0x2fbb90; // 0x2fbc34 - g_ps2RecompiledFunctionTable[519953] = dvCiStopTr_0x2fbb90; // 0x2fbc4c - g_ps2RecompiledFunctionTable[519960] = dvCiGetStat_0x2fbc68; // 0x2fbc68 - g_ps2RecompiledFunctionTable[519967] = dvCiGetStat_0x2fbc68; // 0x2fbc84 - g_ps2RecompiledFunctionTable[519974] = dvCiGetSctLen_0x2fbca0; // 0x2fbca0 - g_ps2RecompiledFunctionTable[519976] = dvCiGetNumTr_0x2fbca8; // 0x2fbca8 - g_ps2RecompiledFunctionTable[519983] = dvCiGetNumTr_0x2fbca8; // 0x2fbcc4 - g_ps2RecompiledFunctionTable[519990] = conv_to_tpath_0x2fbce0; // 0x2fbce0 - g_ps2RecompiledFunctionTable[519996] = conv_to_tpath_0x2fbce0; // 0x2fbcf8 - g_ps2RecompiledFunctionTable[519998] = conv_to_tpath_0x2fbce0; // 0x2fbd00 - g_ps2RecompiledFunctionTable[520004] = conv_to_tpath_0x2fbce0; // 0x2fbd18 - g_ps2RecompiledFunctionTable[520008] = conv_to_tpath_0x2fbce0; // 0x2fbd28 - g_ps2RecompiledFunctionTable[520014] = analysis_flist_0x2fbd40; // 0x2fbd40 - g_ps2RecompiledFunctionTable[520036] = analysis_flist_0x2fbd40; // 0x2fbd98 - g_ps2RecompiledFunctionTable[520050] = analysis_flist_0x2fbd40; // 0x2fbdd0 - g_ps2RecompiledFunctionTable[520052] = analysis_flist_0x2fbd40; // 0x2fbdd8 - g_ps2RecompiledFunctionTable[520082] = load_flist_0x2fbe50; // 0x2fbe50 - g_ps2RecompiledFunctionTable[520089] = load_flist_0x2fbe50; // 0x2fbe6c - g_ps2RecompiledFunctionTable[520100] = load_flist_0x2fbe50; // 0x2fbe98 - g_ps2RecompiledFunctionTable[520106] = load_flist_0x2fbe50; // 0x2fbeb0 - g_ps2RecompiledFunctionTable[520112] = search_fstate_0x2fbec8; // 0x2fbec8 - g_ps2RecompiledFunctionTable[520129] = search_fstate_0x2fbec8; // 0x2fbf0c - g_ps2RecompiledFunctionTable[520132] = search_fstate_0x2fbec8; // 0x2fbf18 - g_ps2RecompiledFunctionTable[520137] = search_fstate_0x2fbec8; // 0x2fbf2c - g_ps2RecompiledFunctionTable[520142] = search_fstate_0x2fbec8; // 0x2fbf40 - g_ps2RecompiledFunctionTable[520148] = search_fstate_0x2fbec8; // 0x2fbf58 - g_ps2RecompiledFunctionTable[520152] = search_fstate_0x2fbec8; // 0x2fbf68 - g_ps2RecompiledFunctionTable[520155] = search_fstate_0x2fbec8; // 0x2fbf74 - g_ps2RecompiledFunctionTable[520167] = search_fstate_0x2fbec8; // 0x2fbfa4 - g_ps2RecompiledFunctionTable[520172] = search_fstate_0x2fbec8; // 0x2fbfb8 - g_ps2RecompiledFunctionTable[520181] = search_fstate_0x2fbec8; // 0x2fbfdc - g_ps2RecompiledFunctionTable[520192] = get_fp_from_fname_0x2fc008; // 0x2fc008 - g_ps2RecompiledFunctionTable[520206] = get_fp_from_fname_0x2fc008; // 0x2fc040 - g_ps2RecompiledFunctionTable[520209] = get_fp_from_fname_0x2fc008; // 0x2fc04c - g_ps2RecompiledFunctionTable[520230] = dvci_init_flist_0x2fc0a0; // 0x2fc0a0 - g_ps2RecompiledFunctionTable[520234] = dvci_get_fstate_0x2fc0b0; // 0x2fc0b0 - g_ps2RecompiledFunctionTable[520248] = dvCiLoadFpCache_0x2fc0e8; // 0x2fc0e8 - g_ps2RecompiledFunctionTable[520261] = dvCiLoadFpCache_0x2fc0e8; // 0x2fc11c - g_ps2RecompiledFunctionTable[520267] = dvCiLoadFpCache_0x2fc0e8; // 0x2fc134 - g_ps2RecompiledFunctionTable[520273] = dvCiLoadFpCache_0x2fc0e8; // 0x2fc14c - g_ps2RecompiledFunctionTable[520281] = dvCiLoadFpCache_0x2fc0e8; // 0x2fc16c - g_ps2RecompiledFunctionTable[520285] = dvCiLoadFpCache_0x2fc0e8; // 0x2fc17c - g_ps2RecompiledFunctionTable[520288] = dvCiLoadFpCache_0x2fc0e8; // 0x2fc188 - g_ps2RecompiledFunctionTable[520294] = dvCiLoadFpCache_0x2fc0e8; // 0x2fc1a0 - g_ps2RecompiledFunctionTable[520303] = dvCiLoadFpCache_0x2fc0e8; // 0x2fc1c4 - g_ps2RecompiledFunctionTable[520306] = dvCiLoadFpCache_0x2fc0e8; // 0x2fc1d0 - g_ps2RecompiledFunctionTable[520314] = dvCiSetRdMode_0x2fc1f0; // 0x2fc1f0 - g_ps2RecompiledFunctionTable[520320] = htCiGetInterface_0x2fc208; // 0x2fc208 - g_ps2RecompiledFunctionTable[520324] = htci_wait_0x2fc218; // 0x2fc218 - g_ps2RecompiledFunctionTable[520326] = htci_wait_0x2fc218; // 0x2fc220 - g_ps2RecompiledFunctionTable[520336] = htci_call_errfn_0x2fc248; // 0x2fc248 - g_ps2RecompiledFunctionTable[520337] = htci_call_errfn_0x2fc248; // 0x2fc24c - g_ps2RecompiledFunctionTable[520338] = htci_call_errfn_0x2fc248; // 0x2fc250 - g_ps2RecompiledFunctionTable[520339] = htci_call_errfn_0x2fc248; // 0x2fc254 - g_ps2RecompiledFunctionTable[520340] = htci_call_errfn_0x2fc248; // 0x2fc258 - g_ps2RecompiledFunctionTable[520341] = htci_call_errfn_0x2fc248; // 0x2fc25c - g_ps2RecompiledFunctionTable[520342] = htci_call_errfn_0x2fc248; // 0x2fc260 - g_ps2RecompiledFunctionTable[520343] = htci_call_errfn_0x2fc248; // 0x2fc264 - g_ps2RecompiledFunctionTable[520344] = htci_call_errfn_0x2fc248; // 0x2fc268 - g_ps2RecompiledFunctionTable[520345] = htci_call_errfn_0x2fc248; // 0x2fc26c - g_ps2RecompiledFunctionTable[520346] = htci_call_errfn_0x2fc248; // 0x2fc270 - g_ps2RecompiledFunctionTable[520347] = htci_call_errfn_0x2fc248; // 0x2fc274 - g_ps2RecompiledFunctionTable[520348] = htci_is_one_excute_0x2fc278; // 0x2fc278 - g_ps2RecompiledFunctionTable[520356] = htci_is_one_excute_0x2fc278; // 0x2fc298 - g_ps2RecompiledFunctionTable[520366] = htci_is_all_excute_0x2fc2c0; // 0x2fc2c0 - g_ps2RecompiledFunctionTable[520376] = htci_is_all_excute_0x2fc2c0; // 0x2fc2e8 - g_ps2RecompiledFunctionTable[520380] = htci_is_all_excute_0x2fc2c0; // 0x2fc2f8 - g_ps2RecompiledFunctionTable[520394] = htci_wait_io_0x2fc330; // 0x2fc330 - g_ps2RecompiledFunctionTable[520396] = htci_wait_io_0x2fc330; // 0x2fc338 - g_ps2RecompiledFunctionTable[520398] = htci_wait_io_0x2fc330; // 0x2fc340 - g_ps2RecompiledFunctionTable[520402] = htci_wait_by_fd_0x2fc350; // 0x2fc350 - g_ps2RecompiledFunctionTable[520412] = htci_wait_by_fd_0x2fc350; // 0x2fc378 - g_ps2RecompiledFunctionTable[520415] = htci_wait_by_fd_0x2fc350; // 0x2fc384 - g_ps2RecompiledFunctionTable[520420] = htci_wait_by_fd_0x2fc350; // 0x2fc398 - g_ps2RecompiledFunctionTable[520426] = htCiExecHndl_0x2fc3b0; // 0x2fc3b0 - g_ps2RecompiledFunctionTable[520437] = htCiExecHndl_0x2fc3b0; // 0x2fc3dc - g_ps2RecompiledFunctionTable[520492] = htCiExecServer_0x2fc4b8; // 0x2fc4b8 - g_ps2RecompiledFunctionTable[520502] = htCiExecServer_0x2fc4b8; // 0x2fc4e0 - g_ps2RecompiledFunctionTable[520506] = htCiExecServer_0x2fc4b8; // 0x2fc4f0 - g_ps2RecompiledFunctionTable[520516] = htCiEntryErrFunc_0x2fc518; // 0x2fc518 - g_ps2RecompiledFunctionTable[520522] = htci_conv_fname_0x2fc530; // 0x2fc530 - g_ps2RecompiledFunctionTable[520543] = htci_conv_fname_0x2fc530; // 0x2fc584 - g_ps2RecompiledFunctionTable[520555] = htci_conv_fname_0x2fc530; // 0x2fc5b4 - g_ps2RecompiledFunctionTable[520558] = htci_conv_fname_0x2fc530; // 0x2fc5c0 - g_ps2RecompiledFunctionTable[520562] = htci_conv_fname_0x2fc530; // 0x2fc5d0 - g_ps2RecompiledFunctionTable[520573] = htci_conv_fname_0x2fc530; // 0x2fc5fc - g_ps2RecompiledFunctionTable[520598] = htCiGetFileSize_0x2fc660; // 0x2fc660 - g_ps2RecompiledFunctionTable[520611] = htCiGetFileSize_0x2fc660; // 0x2fc694 - g_ps2RecompiledFunctionTable[520614] = htCiGetFileSize_0x2fc660; // 0x2fc6a0 - g_ps2RecompiledFunctionTable[520619] = htCiGetFileSize_0x2fc660; // 0x2fc6b4 - g_ps2RecompiledFunctionTable[520622] = htCiGetFileSize_0x2fc660; // 0x2fc6c0 - g_ps2RecompiledFunctionTable[520630] = htCiGetFileSize_0x2fc660; // 0x2fc6e0 - g_ps2RecompiledFunctionTable[520634] = htCiGetFileSize_0x2fc660; // 0x2fc6f0 - g_ps2RecompiledFunctionTable[520640] = htCiGetFileSize_0x2fc660; // 0x2fc708 - g_ps2RecompiledFunctionTable[520642] = htCiGetFileSize_0x2fc660; // 0x2fc710 - g_ps2RecompiledFunctionTable[520646] = htCiGetFileSize_0x2fc660; // 0x2fc720 - g_ps2RecompiledFunctionTable[520648] = htCiGetFileSize_0x2fc660; // 0x2fc728 - g_ps2RecompiledFunctionTable[520655] = htCiGetFileSize_0x2fc660; // 0x2fc744 - g_ps2RecompiledFunctionTable[520664] = htci_get_fsize_opened_0x2fc768; // 0x2fc768 - g_ps2RecompiledFunctionTable[520669] = htci_get_fsize_opened_0x2fc768; // 0x2fc77c - g_ps2RecompiledFunctionTable[520673] = htci_get_fsize_opened_0x2fc768; // 0x2fc78c - g_ps2RecompiledFunctionTable[520677] = htci_get_fsize_opened_0x2fc768; // 0x2fc79c - g_ps2RecompiledFunctionTable[520681] = htci_get_fsize_opened_0x2fc768; // 0x2fc7ac - g_ps2RecompiledFunctionTable[520688] = htci_alloc_0x2fc7c8; // 0x2fc7c8 - g_ps2RecompiledFunctionTable[520692] = htci_alloc_0x2fc7c8; // 0x2fc7d8 - g_ps2RecompiledFunctionTable[520702] = htci_free_0x2fc800; // 0x2fc800 - g_ps2RecompiledFunctionTable[520706] = htCiOpen_0x2fc810; // 0x2fc810 - g_ps2RecompiledFunctionTable[520717] = htCiOpen_0x2fc810; // 0x2fc83c - g_ps2RecompiledFunctionTable[520729] = htCiOpen_0x2fc810; // 0x2fc86c - g_ps2RecompiledFunctionTable[520737] = htCiOpen_0x2fc810; // 0x2fc88c - g_ps2RecompiledFunctionTable[520743] = htCiOpen_0x2fc810; // 0x2fc8a4 - g_ps2RecompiledFunctionTable[520746] = htCiOpen_0x2fc810; // 0x2fc8b0 - g_ps2RecompiledFunctionTable[520751] = htCiOpen_0x2fc810; // 0x2fc8c4 - g_ps2RecompiledFunctionTable[520757] = htCiOpen_0x2fc810; // 0x2fc8dc - g_ps2RecompiledFunctionTable[520759] = htCiOpen_0x2fc810; // 0x2fc8e4 - g_ps2RecompiledFunctionTable[520763] = htCiOpen_0x2fc810; // 0x2fc8f4 - g_ps2RecompiledFunctionTable[520766] = htCiOpen_0x2fc810; // 0x2fc900 - g_ps2RecompiledFunctionTable[520772] = htCiOpen_0x2fc810; // 0x2fc918 - g_ps2RecompiledFunctionTable[520774] = htCiOpen_0x2fc810; // 0x2fc920 - g_ps2RecompiledFunctionTable[520778] = htCiOpen_0x2fc810; // 0x2fc930 - g_ps2RecompiledFunctionTable[520808] = htCiClose_0x2fc9a8; // 0x2fc9a8 - g_ps2RecompiledFunctionTable[520819] = htCiClose_0x2fc9a8; // 0x2fc9d4 - g_ps2RecompiledFunctionTable[520824] = htCiClose_0x2fc9a8; // 0x2fc9e8 - g_ps2RecompiledFunctionTable[520826] = htCiClose_0x2fc9a8; // 0x2fc9f0 - g_ps2RecompiledFunctionTable[520831] = htCiClose_0x2fc9a8; // 0x2fca04 - g_ps2RecompiledFunctionTable[520842] = htCiSeek_0x2fca30; // 0x2fca30 - g_ps2RecompiledFunctionTable[520850] = htCiSeek_0x2fca30; // 0x2fca50 - g_ps2RecompiledFunctionTable[520880] = htCiTell_0x2fcac8; // 0x2fcac8 - g_ps2RecompiledFunctionTable[520887] = htCiTell_0x2fcac8; // 0x2fcae4 - g_ps2RecompiledFunctionTable[520894] = htCiReqRd_0x2fcb00; // 0x2fcb00 - g_ps2RecompiledFunctionTable[520914] = htCiReqRd_0x2fcb00; // 0x2fcb50 - g_ps2RecompiledFunctionTable[520938] = htCiStopTr_0x2fcbb0; // 0x2fcbb0 - g_ps2RecompiledFunctionTable[520964] = htCiStopTr_0x2fcbb0; // 0x2fcc18 - g_ps2RecompiledFunctionTable[520966] = htCiStopTr_0x2fcbb0; // 0x2fcc20 - g_ps2RecompiledFunctionTable[520972] = htCiStopTr_0x2fcbb0; // 0x2fcc38 - g_ps2RecompiledFunctionTable[520982] = htCiGetStat_0x2fcc60; // 0x2fcc60 - g_ps2RecompiledFunctionTable[520989] = htCiGetStat_0x2fcc60; // 0x2fcc7c - g_ps2RecompiledFunctionTable[520996] = htCiGetSctLen_0x2fcc98; // 0x2fcc98 - g_ps2RecompiledFunctionTable[520998] = htCiGetNumTr_0x2fcca0; // 0x2fcca0 - g_ps2RecompiledFunctionTable[521005] = htCiGetNumTr_0x2fcca0; // 0x2fccbc - g_ps2RecompiledFunctionTable[521012] = conv_to_tpath_0x2fccd8; // 0x2fccd8 - g_ps2RecompiledFunctionTable[521028] = conv_to_tpath_0x2fccd8; // 0x2fcd18 - g_ps2RecompiledFunctionTable[521030] = conv_to_tpath_0x2fccd8; // 0x2fcd20 - g_ps2RecompiledFunctionTable[521040] = conv_to_tpath_0x2fccd8; // 0x2fcd48 - g_ps2RecompiledFunctionTable[521046] = conv_to_tpath_0x2fccd8; // 0x2fcd60 - g_ps2RecompiledFunctionTable[521058] = analysis_flist_0x2fcd90; // 0x2fcd90 - g_ps2RecompiledFunctionTable[521078] = analysis_flist_0x2fcd90; // 0x2fcde0 - g_ps2RecompiledFunctionTable[521099] = analysis_flist_0x2fcd90; // 0x2fce34 - g_ps2RecompiledFunctionTable[521123] = analysis_flist_0x2fcd90; // 0x2fce94 - g_ps2RecompiledFunctionTable[521140] = load_flist_0x2fced8; // 0x2fced8 - g_ps2RecompiledFunctionTable[521148] = load_flist_0x2fced8; // 0x2fcef8 - g_ps2RecompiledFunctionTable[521154] = load_flist_0x2fced8; // 0x2fcf10 - g_ps2RecompiledFunctionTable[521160] = load_flist_0x2fced8; // 0x2fcf28 - g_ps2RecompiledFunctionTable[521167] = load_flist_0x2fced8; // 0x2fcf44 - g_ps2RecompiledFunctionTable[521171] = load_flist_0x2fced8; // 0x2fcf54 - g_ps2RecompiledFunctionTable[521175] = load_flist_0x2fced8; // 0x2fcf64 - g_ps2RecompiledFunctionTable[521182] = open_file_all_0x2fcf80; // 0x2fcf80 - g_ps2RecompiledFunctionTable[521199] = open_file_all_0x2fcf80; // 0x2fcfc4 - g_ps2RecompiledFunctionTable[521206] = open_file_all_0x2fcf80; // 0x2fcfe0 - g_ps2RecompiledFunctionTable[521211] = open_file_all_0x2fcf80; // 0x2fcff4 - g_ps2RecompiledFunctionTable[521216] = open_file_all_0x2fcf80; // 0x2fd008 - g_ps2RecompiledFunctionTable[521223] = open_file_all_0x2fcf80; // 0x2fd024 - g_ps2RecompiledFunctionTable[521228] = open_file_all_0x2fcf80; // 0x2fd038 - g_ps2RecompiledFunctionTable[521233] = open_file_all_0x2fcf80; // 0x2fd04c - g_ps2RecompiledFunctionTable[521235] = open_file_all_0x2fcf80; // 0x2fd054 - g_ps2RecompiledFunctionTable[521239] = open_file_all_0x2fcf80; // 0x2fd064 - g_ps2RecompiledFunctionTable[521241] = open_file_all_0x2fcf80; // 0x2fd06c - g_ps2RecompiledFunctionTable[521250] = open_file_all_0x2fcf80; // 0x2fd090 - g_ps2RecompiledFunctionTable[521262] = close_file_all_0x2fd0c0; // 0x2fd0c0 - g_ps2RecompiledFunctionTable[521283] = close_file_all_0x2fd0c0; // 0x2fd114 - g_ps2RecompiledFunctionTable[521292] = close_file_all_0x2fd0c0; // 0x2fd138 - g_ps2RecompiledFunctionTable[521297] = close_file_all_0x2fd0c0; // 0x2fd14c - g_ps2RecompiledFunctionTable[521302] = close_file_all_0x2fd0c0; // 0x2fd160 - g_ps2RecompiledFunctionTable[521308] = close_file_all_0x2fd0c0; // 0x2fd178 - g_ps2RecompiledFunctionTable[521314] = close_file_all_0x2fd0c0; // 0x2fd190 - g_ps2RecompiledFunctionTable[521325] = close_file_all_0x2fd0c0; // 0x2fd1bc - g_ps2RecompiledFunctionTable[521327] = close_file_all_0x2fd0c0; // 0x2fd1c4 - g_ps2RecompiledFunctionTable[521338] = get_fstate_0x2fd1f0; // 0x2fd1f0 - g_ps2RecompiledFunctionTable[521352] = get_fstate_0x2fd1f0; // 0x2fd228 - g_ps2RecompiledFunctionTable[521355] = get_fstate_0x2fd1f0; // 0x2fd234 - g_ps2RecompiledFunctionTable[521376] = htci_init_flist_0x2fd288; // 0x2fd288 - g_ps2RecompiledFunctionTable[521382] = htci_get_finf_0x2fd2a0; // 0x2fd2a0 - g_ps2RecompiledFunctionTable[521396] = htCiLoadFpCache_0x2fd2d8; // 0x2fd2d8 - g_ps2RecompiledFunctionTable[521409] = htCiLoadFpCache_0x2fd2d8; // 0x2fd30c - g_ps2RecompiledFunctionTable[521415] = htCiLoadFpCache_0x2fd2d8; // 0x2fd324 - g_ps2RecompiledFunctionTable[521421] = htCiLoadFpCache_0x2fd2d8; // 0x2fd33c - g_ps2RecompiledFunctionTable[521423] = htCiLoadFpCache_0x2fd2d8; // 0x2fd344 - g_ps2RecompiledFunctionTable[521425] = htCiLoadFpCache_0x2fd2d8; // 0x2fd34c - g_ps2RecompiledFunctionTable[521434] = htCiLoadFpCache_0x2fd2d8; // 0x2fd370 - g_ps2RecompiledFunctionTable[521437] = htCiLoadFpCache_0x2fd2d8; // 0x2fd37c - g_ps2RecompiledFunctionTable[521443] = htCiLoadFpCache_0x2fd2d8; // 0x2fd394 - g_ps2RecompiledFunctionTable[521452] = htCiLoadFpCache_0x2fd2d8; // 0x2fd3b8 - g_ps2RecompiledFunctionTable[521455] = htCiLoadFpCache_0x2fd2d8; // 0x2fd3c4 - g_ps2RecompiledFunctionTable[521464] = htCiSetOpenMode_0x2fd3e8; // 0x2fd3e8 - g_ps2RecompiledFunctionTable[521476] = lsc_Alloc_0x2fd418; // 0x2fd418 - g_ps2RecompiledFunctionTable[521485] = lsc_Alloc_0x2fd418; // 0x2fd43c - g_ps2RecompiledFunctionTable[521498] = LSC_Create_0x2fd470; // 0x2fd470 - g_ps2RecompiledFunctionTable[521499] = LSC_Create_0x2fd470; // 0x2fd474 - g_ps2RecompiledFunctionTable[521500] = LSC_Create_0x2fd470; // 0x2fd478 - g_ps2RecompiledFunctionTable[521501] = LSC_Create_0x2fd470; // 0x2fd47c - g_ps2RecompiledFunctionTable[521502] = LSC_Create_0x2fd470; // 0x2fd480 - g_ps2RecompiledFunctionTable[521503] = LSC_Create_0x2fd470; // 0x2fd484 - g_ps2RecompiledFunctionTable[521504] = LSC_Create_0x2fd470; // 0x2fd488 - g_ps2RecompiledFunctionTable[521505] = LSC_Create_0x2fd470; // 0x2fd48c - g_ps2RecompiledFunctionTable[521506] = LSC_Create_0x2fd470; // 0x2fd490 - g_ps2RecompiledFunctionTable[521507] = LSC_Create_0x2fd470; // 0x2fd494 - g_ps2RecompiledFunctionTable[521508] = LSC_Create_0x2fd470; // 0x2fd498 - g_ps2RecompiledFunctionTable[521509] = LSC_Create_0x2fd470; // 0x2fd49c - g_ps2RecompiledFunctionTable[521510] = LSC_Create_0x2fd470; // 0x2fd4a0 - g_ps2RecompiledFunctionTable[521511] = LSC_Create_0x2fd470; // 0x2fd4a4 - g_ps2RecompiledFunctionTable[521512] = LSC_Create_0x2fd470; // 0x2fd4a8 - g_ps2RecompiledFunctionTable[521513] = LSC_Create_0x2fd470; // 0x2fd4ac - g_ps2RecompiledFunctionTable[521514] = LSC_Create_0x2fd470; // 0x2fd4b0 - g_ps2RecompiledFunctionTable[521515] = LSC_Create_0x2fd470; // 0x2fd4b4 - g_ps2RecompiledFunctionTable[521516] = LSC_Create_0x2fd470; // 0x2fd4b8 - g_ps2RecompiledFunctionTable[521517] = LSC_Create_0x2fd470; // 0x2fd4bc - g_ps2RecompiledFunctionTable[521518] = LSC_Create_0x2fd470; // 0x2fd4c0 - g_ps2RecompiledFunctionTable[521519] = LSC_Create_0x2fd470; // 0x2fd4c4 - g_ps2RecompiledFunctionTable[521520] = LSC_Create_0x2fd470; // 0x2fd4c8 - g_ps2RecompiledFunctionTable[521521] = LSC_Create_0x2fd470; // 0x2fd4cc - g_ps2RecompiledFunctionTable[521522] = LSC_Create_0x2fd470; // 0x2fd4d0 - g_ps2RecompiledFunctionTable[521523] = LSC_Create_0x2fd470; // 0x2fd4d4 - g_ps2RecompiledFunctionTable[521524] = LSC_Create_0x2fd470; // 0x2fd4d8 - g_ps2RecompiledFunctionTable[521525] = LSC_Create_0x2fd470; // 0x2fd4dc - g_ps2RecompiledFunctionTable[521526] = LSC_Create_0x2fd470; // 0x2fd4e0 - g_ps2RecompiledFunctionTable[521527] = LSC_Create_0x2fd470; // 0x2fd4e4 - g_ps2RecompiledFunctionTable[521528] = LSC_Create_0x2fd470; // 0x2fd4e8 - g_ps2RecompiledFunctionTable[521529] = LSC_Create_0x2fd470; // 0x2fd4ec - g_ps2RecompiledFunctionTable[521530] = LSC_Create_0x2fd470; // 0x2fd4f0 - g_ps2RecompiledFunctionTable[521531] = LSC_Create_0x2fd470; // 0x2fd4f4 - g_ps2RecompiledFunctionTable[521532] = LSC_Create_0x2fd470; // 0x2fd4f8 - g_ps2RecompiledFunctionTable[521533] = LSC_Create_0x2fd470; // 0x2fd4fc - g_ps2RecompiledFunctionTable[521534] = LSC_Create_0x2fd470; // 0x2fd500 - g_ps2RecompiledFunctionTable[521535] = LSC_Create_0x2fd470; // 0x2fd504 - g_ps2RecompiledFunctionTable[521536] = LSC_Create_0x2fd470; // 0x2fd508 - g_ps2RecompiledFunctionTable[521537] = LSC_Create_0x2fd470; // 0x2fd50c - g_ps2RecompiledFunctionTable[521538] = LSC_Create_0x2fd470; // 0x2fd510 - g_ps2RecompiledFunctionTable[521539] = LSC_Create_0x2fd470; // 0x2fd514 - g_ps2RecompiledFunctionTable[521540] = LSC_Create_0x2fd470; // 0x2fd518 - g_ps2RecompiledFunctionTable[521541] = LSC_Create_0x2fd470; // 0x2fd51c - g_ps2RecompiledFunctionTable[521542] = LSC_Create_0x2fd470; // 0x2fd520 - g_ps2RecompiledFunctionTable[521543] = LSC_Create_0x2fd470; // 0x2fd524 - g_ps2RecompiledFunctionTable[521544] = LSC_Create_0x2fd470; // 0x2fd528 - g_ps2RecompiledFunctionTable[521545] = LSC_Create_0x2fd470; // 0x2fd52c - g_ps2RecompiledFunctionTable[521546] = LSC_Create_0x2fd470; // 0x2fd530 - g_ps2RecompiledFunctionTable[521547] = LSC_Create_0x2fd470; // 0x2fd534 - g_ps2RecompiledFunctionTable[521548] = LSC_Create_0x2fd470; // 0x2fd538 - g_ps2RecompiledFunctionTable[521549] = LSC_Create_0x2fd470; // 0x2fd53c - g_ps2RecompiledFunctionTable[521550] = LSC_Create_0x2fd470; // 0x2fd540 - g_ps2RecompiledFunctionTable[521551] = LSC_Create_0x2fd470; // 0x2fd544 - g_ps2RecompiledFunctionTable[521552] = LSC_Create_0x2fd470; // 0x2fd548 - g_ps2RecompiledFunctionTable[521553] = LSC_Create_0x2fd470; // 0x2fd54c - g_ps2RecompiledFunctionTable[521554] = LSC_Create_0x2fd470; // 0x2fd550 - g_ps2RecompiledFunctionTable[521555] = LSC_Create_0x2fd470; // 0x2fd554 - g_ps2RecompiledFunctionTable[521556] = LSC_Create_0x2fd470; // 0x2fd558 - g_ps2RecompiledFunctionTable[521557] = LSC_Create_0x2fd470; // 0x2fd55c - g_ps2RecompiledFunctionTable[521558] = LSC_Create_0x2fd470; // 0x2fd560 - g_ps2RecompiledFunctionTable[521559] = LSC_Create_0x2fd470; // 0x2fd564 - g_ps2RecompiledFunctionTable[521560] = LSC_Create_0x2fd470; // 0x2fd568 - g_ps2RecompiledFunctionTable[521561] = LSC_Create_0x2fd470; // 0x2fd56c - g_ps2RecompiledFunctionTable[521562] = LSC_Create_0x2fd470; // 0x2fd570 - g_ps2RecompiledFunctionTable[521563] = LSC_Create_0x2fd470; // 0x2fd574 - g_ps2RecompiledFunctionTable[521564] = LSC_Destroy_0x2fd578; // 0x2fd578 - g_ps2RecompiledFunctionTable[521571] = LSC_Destroy_0x2fd578; // 0x2fd594 - g_ps2RecompiledFunctionTable[521573] = LSC_Destroy_0x2fd578; // 0x2fd59c - g_ps2RecompiledFunctionTable[521578] = LSC_Destroy_0x2fd578; // 0x2fd5b0 - g_ps2RecompiledFunctionTable[521580] = LSC_Destroy_0x2fd578; // 0x2fd5b8 - g_ps2RecompiledFunctionTable[521584] = LSC_EntryFname_0x2fd5c8; // 0x2fd5c8 - g_ps2RecompiledFunctionTable[521595] = LSC_EntryFname_0x2fd5c8; // 0x2fd5f4 - g_ps2RecompiledFunctionTable[521601] = LSC_EntryFname_0x2fd5c8; // 0x2fd60c - g_ps2RecompiledFunctionTable[521603] = LSC_EntryFname_0x2fd5c8; // 0x2fd614 - g_ps2RecompiledFunctionTable[521612] = LSC_EntryFname_0x2fd5c8; // 0x2fd638 - g_ps2RecompiledFunctionTable[521618] = LSC_EntryFname_0x2fd5c8; // 0x2fd650 - g_ps2RecompiledFunctionTable[521626] = LSC_EntryFileRange_0x2fd670; // 0x2fd670 - g_ps2RecompiledFunctionTable[521643] = LSC_EntryFileRange_0x2fd670; // 0x2fd6b4 - g_ps2RecompiledFunctionTable[521655] = LSC_EntryFileRange_0x2fd670; // 0x2fd6e4 - g_ps2RecompiledFunctionTable[521680] = LSC_EntryFileRange_0x2fd670; // 0x2fd748 - g_ps2RecompiledFunctionTable[521714] = LSC_Start_0x2fd7d0; // 0x2fd7d0 - g_ps2RecompiledFunctionTable[521722] = LSC_Start_0x2fd7d0; // 0x2fd7f0 - g_ps2RecompiledFunctionTable[521726] = LSC_Start_0x2fd7d0; // 0x2fd800 - g_ps2RecompiledFunctionTable[521731] = LSC_Start_0x2fd7d0; // 0x2fd814 - g_ps2RecompiledFunctionTable[521738] = LSC_Start_0x2fd7d0; // 0x2fd830 - g_ps2RecompiledFunctionTable[521742] = LSC_Stop_0x2fd840; // 0x2fd840 - g_ps2RecompiledFunctionTable[521750] = LSC_Stop_0x2fd840; // 0x2fd860 - g_ps2RecompiledFunctionTable[521754] = LSC_Stop_0x2fd840; // 0x2fd870 - g_ps2RecompiledFunctionTable[521762] = LSC_Stop_0x2fd840; // 0x2fd890 - g_ps2RecompiledFunctionTable[521765] = LSC_Stop_0x2fd840; // 0x2fd89c - g_ps2RecompiledFunctionTable[521774] = LSC_Stop_0x2fd840; // 0x2fd8c0 - g_ps2RecompiledFunctionTable[521778] = LSC_Pause_0x2fd8d0; // 0x2fd8d0 - g_ps2RecompiledFunctionTable[521790] = LSC_ExecServer_0x2fd900; // 0x2fd900 - g_ps2RecompiledFunctionTable[521798] = LSC_ExecServer_0x2fd900; // 0x2fd920 - g_ps2RecompiledFunctionTable[521802] = LSC_ExecServer_0x2fd900; // 0x2fd930 - g_ps2RecompiledFunctionTable[521806] = LSC_ExecServer_0x2fd900; // 0x2fd940 - g_ps2RecompiledFunctionTable[521812] = LSC_ExecServer_0x2fd900; // 0x2fd958 - g_ps2RecompiledFunctionTable[521818] = LSC_GetStat_0x2fd970; // 0x2fd970 - g_ps2RecompiledFunctionTable[521824] = LSC_GetStat_0x2fd970; // 0x2fd988 - g_ps2RecompiledFunctionTable[521830] = LSC_GetNumStm_0x2fd9a0; // 0x2fd9a0 - g_ps2RecompiledFunctionTable[521836] = LSC_GetNumStm_0x2fd9a0; // 0x2fd9b8 - g_ps2RecompiledFunctionTable[521842] = LSC_GetStmId_0x2fd9d0; // 0x2fd9d0 - g_ps2RecompiledFunctionTable[521850] = LSC_GetStmId_0x2fd9d0; // 0x2fd9f0 - g_ps2RecompiledFunctionTable[521862] = LSC_GetStmId_0x2fd9d0; // 0x2fda20 - g_ps2RecompiledFunctionTable[521878] = LSC_GetStmFname_0x2fda60; // 0x2fda60 - g_ps2RecompiledFunctionTable[521884] = LSC_GetStmFname_0x2fda60; // 0x2fda78 - g_ps2RecompiledFunctionTable[521892] = LSC_GetStmFname_0x2fda60; // 0x2fda98 - g_ps2RecompiledFunctionTable[521904] = LSC_GetStmFname_0x2fda60; // 0x2fdac8 - g_ps2RecompiledFunctionTable[521912] = LSC_GetStmStat_0x2fdae8; // 0x2fdae8 - g_ps2RecompiledFunctionTable[521918] = LSC_GetStmStat_0x2fdae8; // 0x2fdb00 - g_ps2RecompiledFunctionTable[521926] = LSC_GetStmStat_0x2fdae8; // 0x2fdb20 - g_ps2RecompiledFunctionTable[521938] = LSC_GetStmStat_0x2fdae8; // 0x2fdb50 - g_ps2RecompiledFunctionTable[521946] = LSC_GetStmRdSct_0x2fdb70; // 0x2fdb70 - g_ps2RecompiledFunctionTable[521952] = LSC_GetStmRdSct_0x2fdb70; // 0x2fdb88 - g_ps2RecompiledFunctionTable[521960] = LSC_GetStmRdSct_0x2fdb70; // 0x2fdba8 - g_ps2RecompiledFunctionTable[521972] = LSC_GetStmRdSct_0x2fdb70; // 0x2fdbd8 - g_ps2RecompiledFunctionTable[521980] = LSC_SetFlowLimit_0x2fdbf8; // 0x2fdbf8 - g_ps2RecompiledFunctionTable[521996] = LSC_GetFlowLimit_0x2fdc38; // 0x2fdc38 - g_ps2RecompiledFunctionTable[522002] = LSC_GetFlowLimit_0x2fdc38; // 0x2fdc50 - g_ps2RecompiledFunctionTable[522008] = LSC_EntryChgStatFunc_0x2fdc68; // 0x2fdc68 - g_ps2RecompiledFunctionTable[522018] = LSC_CallStatFunc_0x2fdc90; // 0x2fdc90 - g_ps2RecompiledFunctionTable[522019] = LSC_CallStatFunc_0x2fdc90; // 0x2fdc94 - g_ps2RecompiledFunctionTable[522020] = LSC_CallStatFunc_0x2fdc90; // 0x2fdc98 - g_ps2RecompiledFunctionTable[522021] = LSC_CallStatFunc_0x2fdc90; // 0x2fdc9c - g_ps2RecompiledFunctionTable[522022] = LSC_CallStatFunc_0x2fdc90; // 0x2fdca0 - g_ps2RecompiledFunctionTable[522023] = LSC_CallStatFunc_0x2fdc90; // 0x2fdca4 - g_ps2RecompiledFunctionTable[522024] = LSC_CallStatFunc_0x2fdc90; // 0x2fdca8 - g_ps2RecompiledFunctionTable[522025] = LSC_CallStatFunc_0x2fdc90; // 0x2fdcac - g_ps2RecompiledFunctionTable[522026] = LSC_CallStatFunc_0x2fdc90; // 0x2fdcb0 - g_ps2RecompiledFunctionTable[522027] = LSC_CallStatFunc_0x2fdc90; // 0x2fdcb4 - g_ps2RecompiledFunctionTable[522028] = LSC_SetLpFlg_0x2fdcb8; // 0x2fdcb8 - g_ps2RecompiledFunctionTable[522036] = LSC_LockCrs_0x2fdcd8; // 0x2fdcd8 - g_ps2RecompiledFunctionTable[522040] = LSC_LockCrs_0x2fdcd8; // 0x2fdce8 - g_ps2RecompiledFunctionTable[522044] = LSC_UnlockCrs_0x2fdcf8; // 0x2fdcf8 - g_ps2RecompiledFunctionTable[522046] = LSC_EntryErrFunc_0x2fdd00; // 0x2fdd00 - g_ps2RecompiledFunctionTable[522054] = LSC_CallErrFunc_0x2fdd20; // 0x2fdd20 - g_ps2RecompiledFunctionTable[522055] = LSC_CallErrFunc_0x2fdd20; // 0x2fdd24 - g_ps2RecompiledFunctionTable[522056] = LSC_CallErrFunc_0x2fdd20; // 0x2fdd28 - g_ps2RecompiledFunctionTable[522057] = LSC_CallErrFunc_0x2fdd20; // 0x2fdd2c - g_ps2RecompiledFunctionTable[522058] = LSC_CallErrFunc_0x2fdd20; // 0x2fdd30 - g_ps2RecompiledFunctionTable[522059] = LSC_CallErrFunc_0x2fdd20; // 0x2fdd34 - g_ps2RecompiledFunctionTable[522060] = LSC_CallErrFunc_0x2fdd20; // 0x2fdd38 - g_ps2RecompiledFunctionTable[522061] = LSC_CallErrFunc_0x2fdd20; // 0x2fdd3c - g_ps2RecompiledFunctionTable[522062] = LSC_CallErrFunc_0x2fdd20; // 0x2fdd40 - g_ps2RecompiledFunctionTable[522063] = LSC_CallErrFunc_0x2fdd20; // 0x2fdd44 - g_ps2RecompiledFunctionTable[522064] = LSC_CallErrFunc_0x2fdd20; // 0x2fdd48 - g_ps2RecompiledFunctionTable[522065] = LSC_CallErrFunc_0x2fdd20; // 0x2fdd4c - g_ps2RecompiledFunctionTable[522066] = LSC_CallErrFunc_0x2fdd20; // 0x2fdd50 - g_ps2RecompiledFunctionTable[522067] = LSC_CallErrFunc_0x2fdd20; // 0x2fdd54 - g_ps2RecompiledFunctionTable[522068] = LSC_CallErrFunc_0x2fdd20; // 0x2fdd58 - g_ps2RecompiledFunctionTable[522069] = LSC_CallErrFunc_0x2fdd20; // 0x2fdd5c - g_ps2RecompiledFunctionTable[522070] = LSC_CallErrFunc_0x2fdd20; // 0x2fdd60 - g_ps2RecompiledFunctionTable[522071] = LSC_CallErrFunc_0x2fdd20; // 0x2fdd64 - g_ps2RecompiledFunctionTable[522072] = LSC_CallErrFunc_0x2fdd20; // 0x2fdd68 - g_ps2RecompiledFunctionTable[522073] = LSC_CallErrFunc_0x2fdd20; // 0x2fdd6c - g_ps2RecompiledFunctionTable[522074] = LSC_CallErrFunc_0x2fdd20; // 0x2fdd70 - g_ps2RecompiledFunctionTable[522075] = LSC_CallErrFunc_0x2fdd20; // 0x2fdd74 - g_ps2RecompiledFunctionTable[522076] = LSC_CallErrFunc_0x2fdd20; // 0x2fdd78 - g_ps2RecompiledFunctionTable[522077] = LSC_CallErrFunc_0x2fdd20; // 0x2fdd7c - g_ps2RecompiledFunctionTable[522078] = LSC_CallErrFunc_0x2fdd20; // 0x2fdd80 - g_ps2RecompiledFunctionTable[522080] = lsc_EntrySvrInt_0x2fdd88; // 0x2fdd88 - g_ps2RecompiledFunctionTable[522082] = lsc_DeleteSvrInt_0x2fdd90; // 0x2fdd90 - g_ps2RecompiledFunctionTable[522084] = LSC_Init_0x2fdd98; // 0x2fdd98 - g_ps2RecompiledFunctionTable[522088] = LSC_Init_0x2fdd98; // 0x2fdda8 - g_ps2RecompiledFunctionTable[522096] = LSC_Init_0x2fdd98; // 0x2fddc8 - g_ps2RecompiledFunctionTable[522098] = LSC_Init_0x2fdd98; // 0x2fddd0 - g_ps2RecompiledFunctionTable[522101] = LSC_Init_0x2fdd98; // 0x2fdddc - g_ps2RecompiledFunctionTable[522106] = LSC_Init_0x2fdd98; // 0x2fddf0 - g_ps2RecompiledFunctionTable[522110] = LSC_Finish_0x2fde00; // 0x2fde00 - g_ps2RecompiledFunctionTable[522118] = LSC_Finish_0x2fde00; // 0x2fde20 - g_ps2RecompiledFunctionTable[522128] = LSC_Finish_0x2fde00; // 0x2fde48 - g_ps2RecompiledFunctionTable[522132] = LSC_Finish_0x2fde00; // 0x2fde58 - g_ps2RecompiledFunctionTable[522140] = LSC_Finish_0x2fde00; // 0x2fde78 - g_ps2RecompiledFunctionTable[522142] = LSC_Finish_0x2fde00; // 0x2fde80 - g_ps2RecompiledFunctionTable[522145] = LSC_Finish_0x2fde00; // 0x2fde8c - g_ps2RecompiledFunctionTable[522147] = LSC_Finish_0x2fde00; // 0x2fde94 - g_ps2RecompiledFunctionTable[522154] = lsc_StatWait_0x2fdeb0; // 0x2fdeb0 - g_ps2RecompiledFunctionTable[522176] = lsc_StatWait_0x2fdeb0; // 0x2fdf08 - g_ps2RecompiledFunctionTable[522182] = lsc_StatWait_0x2fdeb0; // 0x2fdf20 - g_ps2RecompiledFunctionTable[522184] = lsc_StatWait_0x2fdeb0; // 0x2fdf28 - g_ps2RecompiledFunctionTable[522200] = lsc_StatWait_0x2fdeb0; // 0x2fdf68 - g_ps2RecompiledFunctionTable[522203] = lsc_StatWait_0x2fdeb0; // 0x2fdf74 - g_ps2RecompiledFunctionTable[522205] = lsc_StatWait_0x2fdeb0; // 0x2fdf7c - g_ps2RecompiledFunctionTable[522226] = lsc_StatRead_0x2fdfd0; // 0x2fdfd0 - g_ps2RecompiledFunctionTable[522245] = lsc_StatRead_0x2fdfd0; // 0x2fe01c - g_ps2RecompiledFunctionTable[522256] = lsc_StatRead_0x2fdfd0; // 0x2fe048 - g_ps2RecompiledFunctionTable[522268] = lsc_StatEnd_0x2fe078; // 0x2fe078 - g_ps2RecompiledFunctionTable[522283] = lsc_StatEnd_0x2fe078; // 0x2fe0b4 - g_ps2RecompiledFunctionTable[522337] = lsc_StatEnd_0x2fe078; // 0x2fe18c - g_ps2RecompiledFunctionTable[522362] = lsc_ExecHndl_0x2fe1f0; // 0x2fe1f0 - g_ps2RecompiledFunctionTable[522386] = lsc_ExecHndl_0x2fe1f0; // 0x2fe250 - g_ps2RecompiledFunctionTable[522394] = lsc_ExecHndl_0x2fe1f0; // 0x2fe270 - g_ps2RecompiledFunctionTable[522412] = ps2rna_init_psj_0x2fe2b8; // 0x2fe2b8 - g_ps2RecompiledFunctionTable[522413] = ps2rna_init_psj_0x2fe2b8; // 0x2fe2bc - g_ps2RecompiledFunctionTable[522414] = ps2rna_init_psj_0x2fe2b8; // 0x2fe2c0 - g_ps2RecompiledFunctionTable[522415] = ps2rna_init_psj_0x2fe2b8; // 0x2fe2c4 - g_ps2RecompiledFunctionTable[522416] = ps2rna_init_psj_0x2fe2b8; // 0x2fe2c8 - g_ps2RecompiledFunctionTable[522417] = ps2rna_init_psj_0x2fe2b8; // 0x2fe2cc - g_ps2RecompiledFunctionTable[522418] = ps2rna_init_psj_0x2fe2b8; // 0x2fe2d0 - g_ps2RecompiledFunctionTable[522419] = ps2rna_init_psj_0x2fe2b8; // 0x2fe2d4 - g_ps2RecompiledFunctionTable[522420] = ps2rna_init_psj_0x2fe2b8; // 0x2fe2d8 - g_ps2RecompiledFunctionTable[522421] = ps2rna_init_psj_0x2fe2b8; // 0x2fe2dc - g_ps2RecompiledFunctionTable[522422] = ps2rna_init_psj_0x2fe2b8; // 0x2fe2e0 - g_ps2RecompiledFunctionTable[522423] = ps2rna_init_psj_0x2fe2b8; // 0x2fe2e4 - g_ps2RecompiledFunctionTable[522424] = ps2rna_init_psj_0x2fe2b8; // 0x2fe2e8 - g_ps2RecompiledFunctionTable[522425] = ps2rna_init_psj_0x2fe2b8; // 0x2fe2ec - g_ps2RecompiledFunctionTable[522426] = ps2rna_init_psj_0x2fe2b8; // 0x2fe2f0 - g_ps2RecompiledFunctionTable[522427] = ps2rna_init_psj_0x2fe2b8; // 0x2fe2f4 - g_ps2RecompiledFunctionTable[522428] = ps2rna_init_psj_0x2fe2b8; // 0x2fe2f8 - g_ps2RecompiledFunctionTable[522429] = ps2rna_init_psj_0x2fe2b8; // 0x2fe2fc - g_ps2RecompiledFunctionTable[522430] = ps2rna_init_psj_0x2fe2b8; // 0x2fe300 - g_ps2RecompiledFunctionTable[522431] = ps2rna_init_psj_0x2fe2b8; // 0x2fe304 - g_ps2RecompiledFunctionTable[522432] = ps2rna_init_psj_0x2fe2b8; // 0x2fe308 - g_ps2RecompiledFunctionTable[522433] = ps2rna_init_psj_0x2fe2b8; // 0x2fe30c - g_ps2RecompiledFunctionTable[522434] = ps2rna_init_psj_0x2fe2b8; // 0x2fe310 - g_ps2RecompiledFunctionTable[522435] = ps2rna_init_psj_0x2fe2b8; // 0x2fe314 - g_ps2RecompiledFunctionTable[522436] = ps2rna_init_psj_0x2fe2b8; // 0x2fe318 - g_ps2RecompiledFunctionTable[522437] = ps2rna_init_psj_0x2fe2b8; // 0x2fe31c - g_ps2RecompiledFunctionTable[522438] = ps2rna_init_psj_0x2fe2b8; // 0x2fe320 - g_ps2RecompiledFunctionTable[522439] = ps2rna_init_psj_0x2fe2b8; // 0x2fe324 - g_ps2RecompiledFunctionTable[522440] = ps2rna_init_psj_0x2fe2b8; // 0x2fe328 - g_ps2RecompiledFunctionTable[522441] = ps2rna_init_psj_0x2fe2b8; // 0x2fe32c - g_ps2RecompiledFunctionTable[522442] = ps2rna_init_psj_0x2fe2b8; // 0x2fe330 - g_ps2RecompiledFunctionTable[522443] = ps2rna_init_psj_0x2fe2b8; // 0x2fe334 - g_ps2RecompiledFunctionTable[522444] = ps2rna_init_psj_0x2fe2b8; // 0x2fe338 - g_ps2RecompiledFunctionTable[522445] = ps2rna_init_psj_0x2fe2b8; // 0x2fe33c - g_ps2RecompiledFunctionTable[522446] = ps2rna_init_psj_0x2fe2b8; // 0x2fe340 - g_ps2RecompiledFunctionTable[522447] = ps2rna_init_psj_0x2fe2b8; // 0x2fe344 - g_ps2RecompiledFunctionTable[522448] = ps2rna_init_psj_0x2fe2b8; // 0x2fe348 - g_ps2RecompiledFunctionTable[522449] = ps2rna_init_psj_0x2fe2b8; // 0x2fe34c - g_ps2RecompiledFunctionTable[522450] = ps2rna_init_psj_0x2fe2b8; // 0x2fe350 - g_ps2RecompiledFunctionTable[522451] = ps2rna_init_psj_0x2fe2b8; // 0x2fe354 - g_ps2RecompiledFunctionTable[522452] = ps2rna_init_psj_0x2fe2b8; // 0x2fe358 - g_ps2RecompiledFunctionTable[522453] = ps2rna_init_psj_0x2fe2b8; // 0x2fe35c - g_ps2RecompiledFunctionTable[522454] = ps2rna_init_psj_0x2fe2b8; // 0x2fe360 - g_ps2RecompiledFunctionTable[522455] = ps2rna_init_psj_0x2fe2b8; // 0x2fe364 - g_ps2RecompiledFunctionTable[522456] = ps2rna_init_psj_0x2fe2b8; // 0x2fe368 - g_ps2RecompiledFunctionTable[522457] = ps2rna_init_psj_0x2fe2b8; // 0x2fe36c - g_ps2RecompiledFunctionTable[522458] = ps2rna_init_psj_0x2fe2b8; // 0x2fe370 - g_ps2RecompiledFunctionTable[522459] = ps2rna_init_psj_0x2fe2b8; // 0x2fe374 - g_ps2RecompiledFunctionTable[522460] = ps2rna_init_psj_0x2fe2b8; // 0x2fe378 - g_ps2RecompiledFunctionTable[522461] = ps2rna_init_psj_0x2fe2b8; // 0x2fe37c - g_ps2RecompiledFunctionTable[522462] = ps2rna_init_psj_0x2fe2b8; // 0x2fe380 - g_ps2RecompiledFunctionTable[522463] = ps2rna_init_psj_0x2fe2b8; // 0x2fe384 - g_ps2RecompiledFunctionTable[522464] = ps2rna_init_psj_0x2fe2b8; // 0x2fe388 - g_ps2RecompiledFunctionTable[522465] = ps2rna_init_psj_0x2fe2b8; // 0x2fe38c - g_ps2RecompiledFunctionTable[522466] = ps2rna_init_psj_0x2fe2b8; // 0x2fe390 - g_ps2RecompiledFunctionTable[522467] = ps2rna_init_psj_0x2fe2b8; // 0x2fe394 - g_ps2RecompiledFunctionTable[522468] = ps2rna_init_psj_0x2fe2b8; // 0x2fe398 - g_ps2RecompiledFunctionTable[522469] = ps2rna_init_psj_0x2fe2b8; // 0x2fe39c - g_ps2RecompiledFunctionTable[522470] = ps2rna_init_psj_0x2fe2b8; // 0x2fe3a0 - g_ps2RecompiledFunctionTable[522471] = ps2rna_init_psj_0x2fe2b8; // 0x2fe3a4 - g_ps2RecompiledFunctionTable[522472] = ps2rna_init_psj_0x2fe2b8; // 0x2fe3a8 - g_ps2RecompiledFunctionTable[522473] = ps2rna_init_psj_0x2fe2b8; // 0x2fe3ac - g_ps2RecompiledFunctionTable[522474] = ps2rna_init_psj_0x2fe2b8; // 0x2fe3b0 - g_ps2RecompiledFunctionTable[522475] = ps2rna_init_psj_0x2fe2b8; // 0x2fe3b4 - g_ps2RecompiledFunctionTable[522476] = ps2rna_init_psj_0x2fe2b8; // 0x2fe3b8 - g_ps2RecompiledFunctionTable[522477] = ps2rna_init_psj_0x2fe2b8; // 0x2fe3bc - g_ps2RecompiledFunctionTable[522478] = ps2rna_init_psj_0x2fe2b8; // 0x2fe3c0 - g_ps2RecompiledFunctionTable[522479] = ps2rna_init_psj_0x2fe2b8; // 0x2fe3c4 - g_ps2RecompiledFunctionTable[522480] = ps2rna_init_psj_0x2fe2b8; // 0x2fe3c8 - g_ps2RecompiledFunctionTable[522481] = ps2rna_init_psj_0x2fe2b8; // 0x2fe3cc - g_ps2RecompiledFunctionTable[522482] = ps2rna_init_psj_0x2fe2b8; // 0x2fe3d0 - g_ps2RecompiledFunctionTable[522483] = ps2rna_init_psj_0x2fe2b8; // 0x2fe3d4 - g_ps2RecompiledFunctionTable[522484] = ps2rna_init_psj_0x2fe2b8; // 0x2fe3d8 - g_ps2RecompiledFunctionTable[522485] = ps2rna_init_psj_0x2fe2b8; // 0x2fe3dc - g_ps2RecompiledFunctionTable[522486] = ps2rna_init_psj_0x2fe2b8; // 0x2fe3e0 - g_ps2RecompiledFunctionTable[522487] = ps2rna_init_psj_0x2fe2b8; // 0x2fe3e4 - g_ps2RecompiledFunctionTable[522488] = ps2rna_init_psj_0x2fe2b8; // 0x2fe3e8 - g_ps2RecompiledFunctionTable[522489] = ps2rna_init_psj_0x2fe2b8; // 0x2fe3ec - g_ps2RecompiledFunctionTable[522490] = ps2rna_init_psj_0x2fe2b8; // 0x2fe3f0 - g_ps2RecompiledFunctionTable[522491] = ps2rna_init_psj_0x2fe2b8; // 0x2fe3f4 - g_ps2RecompiledFunctionTable[522492] = ps2rna_init_psj_0x2fe2b8; // 0x2fe3f8 - g_ps2RecompiledFunctionTable[522493] = ps2rna_init_psj_0x2fe2b8; // 0x2fe3fc - g_ps2RecompiledFunctionTable[522494] = ps2rna_init_psj_0x2fe2b8; // 0x2fe400 - g_ps2RecompiledFunctionTable[522495] = ps2rna_init_psj_0x2fe2b8; // 0x2fe404 - g_ps2RecompiledFunctionTable[522496] = ps2rna_init_psj_0x2fe2b8; // 0x2fe408 - g_ps2RecompiledFunctionTable[522497] = ps2rna_init_psj_0x2fe2b8; // 0x2fe40c - g_ps2RecompiledFunctionTable[522498] = ps2rna_init_psj_0x2fe2b8; // 0x2fe410 - g_ps2RecompiledFunctionTable[522499] = ps2rna_init_psj_0x2fe2b8; // 0x2fe414 - g_ps2RecompiledFunctionTable[522500] = ps2rna_init_psj_0x2fe2b8; // 0x2fe418 - g_ps2RecompiledFunctionTable[522501] = ps2rna_init_psj_0x2fe2b8; // 0x2fe41c - g_ps2RecompiledFunctionTable[522502] = ps2rna_init_psj_0x2fe2b8; // 0x2fe420 - g_ps2RecompiledFunctionTable[522503] = ps2rna_init_psj_0x2fe2b8; // 0x2fe424 - g_ps2RecompiledFunctionTable[522504] = ps2rna_init_psj_0x2fe2b8; // 0x2fe428 - g_ps2RecompiledFunctionTable[522505] = ps2rna_init_psj_0x2fe2b8; // 0x2fe42c - g_ps2RecompiledFunctionTable[522506] = ps2rna_init_psj_0x2fe2b8; // 0x2fe430 - g_ps2RecompiledFunctionTable[522507] = ps2rna_init_psj_0x2fe2b8; // 0x2fe434 - g_ps2RecompiledFunctionTable[522508] = ps2rna_init_psj_0x2fe2b8; // 0x2fe438 - g_ps2RecompiledFunctionTable[522509] = ps2rna_init_psj_0x2fe2b8; // 0x2fe43c - g_ps2RecompiledFunctionTable[522510] = ps2rna_init_psj_0x2fe2b8; // 0x2fe440 - g_ps2RecompiledFunctionTable[522511] = ps2rna_init_psj_0x2fe2b8; // 0x2fe444 - g_ps2RecompiledFunctionTable[522512] = ps2rna_init_psj_0x2fe2b8; // 0x2fe448 - g_ps2RecompiledFunctionTable[522513] = ps2rna_init_psj_0x2fe2b8; // 0x2fe44c - g_ps2RecompiledFunctionTable[522514] = ps2rna_init_psj_0x2fe2b8; // 0x2fe450 - g_ps2RecompiledFunctionTable[522515] = ps2rna_init_psj_0x2fe2b8; // 0x2fe454 - g_ps2RecompiledFunctionTable[522516] = ps2rna_init_psj_0x2fe2b8; // 0x2fe458 - g_ps2RecompiledFunctionTable[522517] = ps2rna_init_psj_0x2fe2b8; // 0x2fe45c - g_ps2RecompiledFunctionTable[522518] = ps2rna_init_psj_0x2fe2b8; // 0x2fe460 - g_ps2RecompiledFunctionTable[522519] = ps2rna_init_psj_0x2fe2b8; // 0x2fe464 - g_ps2RecompiledFunctionTable[522520] = ps2rna_init_psj_0x2fe2b8; // 0x2fe468 - g_ps2RecompiledFunctionTable[522521] = ps2rna_init_psj_0x2fe2b8; // 0x2fe46c - g_ps2RecompiledFunctionTable[522522] = ps2rna_init_psj_0x2fe2b8; // 0x2fe470 - g_ps2RecompiledFunctionTable[522523] = ps2rna_init_psj_0x2fe2b8; // 0x2fe474 - g_ps2RecompiledFunctionTable[522524] = ps2rna_init_psj_0x2fe2b8; // 0x2fe478 - g_ps2RecompiledFunctionTable[522525] = ps2rna_init_psj_0x2fe2b8; // 0x2fe47c - g_ps2RecompiledFunctionTable[522526] = ps2rna_init_psj_0x2fe2b8; // 0x2fe480 - g_ps2RecompiledFunctionTable[522527] = ps2rna_init_psj_0x2fe2b8; // 0x2fe484 - g_ps2RecompiledFunctionTable[522528] = ps2rna_init_psj_0x2fe2b8; // 0x2fe488 - g_ps2RecompiledFunctionTable[522529] = ps2rna_init_psj_0x2fe2b8; // 0x2fe48c - g_ps2RecompiledFunctionTable[522530] = ps2rna_init_psj_0x2fe2b8; // 0x2fe490 - g_ps2RecompiledFunctionTable[522531] = ps2rna_init_psj_0x2fe2b8; // 0x2fe494 - g_ps2RecompiledFunctionTable[522532] = ps2rna_init_psj_0x2fe2b8; // 0x2fe498 - g_ps2RecompiledFunctionTable[522533] = ps2rna_init_psj_0x2fe2b8; // 0x2fe49c - g_ps2RecompiledFunctionTable[522534] = ps2rna_init_psj_0x2fe2b8; // 0x2fe4a0 - g_ps2RecompiledFunctionTable[522535] = ps2rna_init_psj_0x2fe2b8; // 0x2fe4a4 - g_ps2RecompiledFunctionTable[522536] = ps2rna_init_psj_0x2fe2b8; // 0x2fe4a8 - g_ps2RecompiledFunctionTable[522537] = ps2rna_init_psj_0x2fe2b8; // 0x2fe4ac - g_ps2RecompiledFunctionTable[522538] = ps2rna_init_psj_0x2fe2b8; // 0x2fe4b0 - g_ps2RecompiledFunctionTable[522539] = ps2rna_init_psj_0x2fe2b8; // 0x2fe4b4 - g_ps2RecompiledFunctionTable[522540] = ps2rna_init_psj_0x2fe2b8; // 0x2fe4b8 - g_ps2RecompiledFunctionTable[522541] = ps2rna_init_psj_0x2fe2b8; // 0x2fe4bc - g_ps2RecompiledFunctionTable[522542] = ps2rna_init_psj_0x2fe2b8; // 0x2fe4c0 - g_ps2RecompiledFunctionTable[522543] = ps2rna_init_psj_0x2fe2b8; // 0x2fe4c4 - g_ps2RecompiledFunctionTable[522544] = ps2rna_init_psj_0x2fe2b8; // 0x2fe4c8 - g_ps2RecompiledFunctionTable[522545] = ps2rna_init_psj_0x2fe2b8; // 0x2fe4cc - g_ps2RecompiledFunctionTable[522546] = ps2rna_init_psj_0x2fe2b8; // 0x2fe4d0 - g_ps2RecompiledFunctionTable[522547] = ps2rna_init_psj_0x2fe2b8; // 0x2fe4d4 - g_ps2RecompiledFunctionTable[522548] = ps2rna_finish_psj_0x2fe4d8; // 0x2fe4d8 - g_ps2RecompiledFunctionTable[522549] = ps2rna_finish_psj_0x2fe4d8; // 0x2fe4dc - g_ps2RecompiledFunctionTable[522550] = ps2rna_finish_psj_0x2fe4d8; // 0x2fe4e0 - g_ps2RecompiledFunctionTable[522551] = ps2rna_finish_psj_0x2fe4d8; // 0x2fe4e4 - g_ps2RecompiledFunctionTable[522552] = ps2rna_finish_psj_0x2fe4d8; // 0x2fe4e8 - g_ps2RecompiledFunctionTable[522553] = ps2rna_finish_psj_0x2fe4d8; // 0x2fe4ec - g_ps2RecompiledFunctionTable[522554] = ps2rna_finish_psj_0x2fe4d8; // 0x2fe4f0 - g_ps2RecompiledFunctionTable[522555] = ps2rna_finish_psj_0x2fe4d8; // 0x2fe4f4 - g_ps2RecompiledFunctionTable[522556] = ps2rna_finish_psj_0x2fe4d8; // 0x2fe4f8 - g_ps2RecompiledFunctionTable[522557] = ps2rna_finish_psj_0x2fe4d8; // 0x2fe4fc - g_ps2RecompiledFunctionTable[522558] = ps2rna_finish_psj_0x2fe4d8; // 0x2fe500 - g_ps2RecompiledFunctionTable[522559] = ps2rna_finish_psj_0x2fe4d8; // 0x2fe504 - g_ps2RecompiledFunctionTable[522560] = ps2rna_finish_psj_0x2fe4d8; // 0x2fe508 - g_ps2RecompiledFunctionTable[522561] = ps2rna_finish_psj_0x2fe4d8; // 0x2fe50c - g_ps2RecompiledFunctionTable[522562] = ps2rna_finish_psj_0x2fe4d8; // 0x2fe510 - g_ps2RecompiledFunctionTable[522563] = ps2rna_finish_psj_0x2fe4d8; // 0x2fe514 - g_ps2RecompiledFunctionTable[522564] = ps2rna_finish_psj_0x2fe4d8; // 0x2fe518 - g_ps2RecompiledFunctionTable[522565] = ps2rna_finish_psj_0x2fe4d8; // 0x2fe51c - g_ps2RecompiledFunctionTable[522566] = ps2rna_finish_psj_0x2fe4d8; // 0x2fe520 - g_ps2RecompiledFunctionTable[522567] = ps2rna_finish_psj_0x2fe4d8; // 0x2fe524 - g_ps2RecompiledFunctionTable[522568] = ps2rna_finish_psj_0x2fe4d8; // 0x2fe528 - g_ps2RecompiledFunctionTable[522569] = ps2rna_finish_psj_0x2fe4d8; // 0x2fe52c - g_ps2RecompiledFunctionTable[522570] = ps2rna_finish_psj_0x2fe4d8; // 0x2fe530 - g_ps2RecompiledFunctionTable[522571] = ps2rna_finish_psj_0x2fe4d8; // 0x2fe534 - g_ps2RecompiledFunctionTable[522572] = ps2rna_finish_psj_0x2fe4d8; // 0x2fe538 - g_ps2RecompiledFunctionTable[522573] = ps2rna_finish_psj_0x2fe4d8; // 0x2fe53c - g_ps2RecompiledFunctionTable[522574] = ps2rna_finish_psj_0x2fe4d8; // 0x2fe540 - g_ps2RecompiledFunctionTable[522575] = ps2rna_finish_psj_0x2fe4d8; // 0x2fe544 - g_ps2RecompiledFunctionTable[522576] = ps2rna_finish_psj_0x2fe4d8; // 0x2fe548 - g_ps2RecompiledFunctionTable[522577] = ps2rna_finish_psj_0x2fe4d8; // 0x2fe54c - g_ps2RecompiledFunctionTable[522578] = ps2rna_finish_psj_0x2fe4d8; // 0x2fe550 - g_ps2RecompiledFunctionTable[522579] = ps2rna_finish_psj_0x2fe4d8; // 0x2fe554 - g_ps2RecompiledFunctionTable[522580] = ps2rna_finish_psj_0x2fe4d8; // 0x2fe558 - g_ps2RecompiledFunctionTable[522581] = ps2rna_finish_psj_0x2fe4d8; // 0x2fe55c - g_ps2RecompiledFunctionTable[522582] = ps2rna_finish_psj_0x2fe4d8; // 0x2fe560 - g_ps2RecompiledFunctionTable[522583] = ps2rna_finish_psj_0x2fe4d8; // 0x2fe564 - g_ps2RecompiledFunctionTable[522584] = ps2rna_finish_psj_0x2fe4d8; // 0x2fe568 - g_ps2RecompiledFunctionTable[522585] = ps2rna_finish_psj_0x2fe4d8; // 0x2fe56c - g_ps2RecompiledFunctionTable[522586] = ps2rna_finish_psj_0x2fe4d8; // 0x2fe570 - g_ps2RecompiledFunctionTable[522587] = ps2rna_finish_psj_0x2fe4d8; // 0x2fe574 - g_ps2RecompiledFunctionTable[522588] = ps2rna_finish_psj_0x2fe4d8; // 0x2fe578 - g_ps2RecompiledFunctionTable[522589] = ps2rna_finish_psj_0x2fe4d8; // 0x2fe57c - g_ps2RecompiledFunctionTable[522590] = ps2rna_finish_psj_0x2fe4d8; // 0x2fe580 - g_ps2RecompiledFunctionTable[522591] = ps2rna_finish_psj_0x2fe4d8; // 0x2fe584 - g_ps2RecompiledFunctionTable[522592] = ps2rna_finish_psj_0x2fe4d8; // 0x2fe588 - g_ps2RecompiledFunctionTable[522593] = ps2rna_finish_psj_0x2fe4d8; // 0x2fe58c - g_ps2RecompiledFunctionTable[522594] = ps2rna_finish_psj_0x2fe4d8; // 0x2fe590 - g_ps2RecompiledFunctionTable[522595] = ps2rna_finish_psj_0x2fe4d8; // 0x2fe594 - g_ps2RecompiledFunctionTable[522596] = ps2rna_finish_psj_0x2fe4d8; // 0x2fe598 - g_ps2RecompiledFunctionTable[522597] = ps2rna_finish_psj_0x2fe4d8; // 0x2fe59c - g_ps2RecompiledFunctionTable[522598] = ps2rna_finish_psj_0x2fe4d8; // 0x2fe5a0 - g_ps2RecompiledFunctionTable[522599] = ps2rna_finish_psj_0x2fe4d8; // 0x2fe5a4 - g_ps2RecompiledFunctionTable[522600] = ps2rna_finish_psj_0x2fe4d8; // 0x2fe5a8 - g_ps2RecompiledFunctionTable[522602] = ps2rna_get_psj_0x2fe5b0; // 0x2fe5b0 - g_ps2RecompiledFunctionTable[522603] = ps2rna_get_psj_0x2fe5b0; // 0x2fe5b4 - g_ps2RecompiledFunctionTable[522604] = ps2rna_get_psj_0x2fe5b0; // 0x2fe5b8 - g_ps2RecompiledFunctionTable[522605] = ps2rna_get_psj_0x2fe5b0; // 0x2fe5bc - g_ps2RecompiledFunctionTable[522606] = ps2rna_get_psj_0x2fe5b0; // 0x2fe5c0 - g_ps2RecompiledFunctionTable[522607] = ps2rna_get_psj_0x2fe5b0; // 0x2fe5c4 - g_ps2RecompiledFunctionTable[522608] = ps2rna_get_psj_0x2fe5b0; // 0x2fe5c8 - g_ps2RecompiledFunctionTable[522609] = ps2rna_get_psj_0x2fe5b0; // 0x2fe5cc - g_ps2RecompiledFunctionTable[522610] = ps2rna_get_psj_0x2fe5b0; // 0x2fe5d0 - g_ps2RecompiledFunctionTable[522611] = ps2rna_get_psj_0x2fe5b0; // 0x2fe5d4 - g_ps2RecompiledFunctionTable[522612] = ps2rna_get_psj_0x2fe5b0; // 0x2fe5d8 - g_ps2RecompiledFunctionTable[522613] = ps2rna_get_psj_0x2fe5b0; // 0x2fe5dc - g_ps2RecompiledFunctionTable[522614] = ps2rna_get_psj_0x2fe5b0; // 0x2fe5e0 - g_ps2RecompiledFunctionTable[522615] = ps2rna_get_psj_0x2fe5b0; // 0x2fe5e4 - g_ps2RecompiledFunctionTable[522616] = ps2rna_get_psj_0x2fe5b0; // 0x2fe5e8 - g_ps2RecompiledFunctionTable[522617] = ps2rna_get_psj_0x2fe5b0; // 0x2fe5ec - g_ps2RecompiledFunctionTable[522618] = ps2rna_get_psj_0x2fe5b0; // 0x2fe5f0 - g_ps2RecompiledFunctionTable[522619] = ps2rna_get_psj_0x2fe5b0; // 0x2fe5f4 - g_ps2RecompiledFunctionTable[522620] = ps2rna_get_psj_0x2fe5b0; // 0x2fe5f8 - g_ps2RecompiledFunctionTable[522621] = ps2rna_get_psj_0x2fe5b0; // 0x2fe5fc - g_ps2RecompiledFunctionTable[522622] = ps2rna_get_psj_0x2fe5b0; // 0x2fe600 - g_ps2RecompiledFunctionTable[522623] = ps2rna_get_psj_0x2fe5b0; // 0x2fe604 - g_ps2RecompiledFunctionTable[522624] = ps2rna_get_psj_0x2fe5b0; // 0x2fe608 - g_ps2RecompiledFunctionTable[522625] = ps2rna_get_psj_0x2fe5b0; // 0x2fe60c - g_ps2RecompiledFunctionTable[522626] = ps2rna_get_psj_0x2fe5b0; // 0x2fe610 - g_ps2RecompiledFunctionTable[522627] = ps2rna_get_psj_0x2fe5b0; // 0x2fe614 - g_ps2RecompiledFunctionTable[522628] = ps2rna_get_psj_0x2fe5b0; // 0x2fe618 - g_ps2RecompiledFunctionTable[522629] = ps2rna_get_psj_0x2fe5b0; // 0x2fe61c - g_ps2RecompiledFunctionTable[522630] = ps2rna_get_psj_0x2fe5b0; // 0x2fe620 - g_ps2RecompiledFunctionTable[522631] = ps2rna_get_psj_0x2fe5b0; // 0x2fe624 - g_ps2RecompiledFunctionTable[522632] = ps2rna_get_psj_0x2fe5b0; // 0x2fe628 - g_ps2RecompiledFunctionTable[522633] = ps2rna_get_psj_0x2fe5b0; // 0x2fe62c - g_ps2RecompiledFunctionTable[522634] = ps2rna_get_psj_0x2fe5b0; // 0x2fe630 - g_ps2RecompiledFunctionTable[522635] = ps2rna_get_psj_0x2fe5b0; // 0x2fe634 - g_ps2RecompiledFunctionTable[522636] = ps2rna_get_psj_0x2fe5b0; // 0x2fe638 - g_ps2RecompiledFunctionTable[522637] = ps2rna_get_psj_0x2fe5b0; // 0x2fe63c - g_ps2RecompiledFunctionTable[522638] = ps2rna_get_psj_0x2fe5b0; // 0x2fe640 - g_ps2RecompiledFunctionTable[522639] = ps2rna_get_psj_0x2fe5b0; // 0x2fe644 - g_ps2RecompiledFunctionTable[522640] = ps2rna_get_psj_0x2fe5b0; // 0x2fe648 - g_ps2RecompiledFunctionTable[522641] = ps2rna_get_psj_0x2fe5b0; // 0x2fe64c - g_ps2RecompiledFunctionTable[522642] = ps2rna_get_psj_0x2fe5b0; // 0x2fe650 - g_ps2RecompiledFunctionTable[522643] = ps2rna_get_psj_0x2fe5b0; // 0x2fe654 - g_ps2RecompiledFunctionTable[522644] = ps2rna_get_psj_0x2fe5b0; // 0x2fe658 - g_ps2RecompiledFunctionTable[522645] = ps2rna_get_psj_0x2fe5b0; // 0x2fe65c - g_ps2RecompiledFunctionTable[522646] = ps2rna_get_psj_0x2fe5b0; // 0x2fe660 - g_ps2RecompiledFunctionTable[522647] = ps2rna_get_psj_0x2fe5b0; // 0x2fe664 - g_ps2RecompiledFunctionTable[522648] = ps2rna_release_psj_0x2fe668; // 0x2fe668 - g_ps2RecompiledFunctionTable[522650] = ps2rna_rcvcbf_0x2fe670; // 0x2fe670 - g_ps2RecompiledFunctionTable[522652] = ps2rna_rcvcbf_0x2fe670; // 0x2fe678 - g_ps2RecompiledFunctionTable[522662] = ps2rna_rcvcbf_0x2fe670; // 0x2fe6a0 - g_ps2RecompiledFunctionTable[522672] = ps2rna_sndcbf_0x2fe6c8; // 0x2fe6c8 - g_ps2RecompiledFunctionTable[522686] = ps2rna_sndcbf_0x2fe6c8; // 0x2fe700 - g_ps2RecompiledFunctionTable[522758] = PS2RNA_Init_0x2fe820; // 0x2fe820 - g_ps2RecompiledFunctionTable[522766] = PS2RNA_Init_0x2fe820; // 0x2fe840 - g_ps2RecompiledFunctionTable[522768] = PS2RNA_Init_0x2fe820; // 0x2fe848 - g_ps2RecompiledFunctionTable[522770] = PS2RNA_Init_0x2fe820; // 0x2fe850 - g_ps2RecompiledFunctionTable[522772] = PS2RNA_Init_0x2fe820; // 0x2fe858 - g_ps2RecompiledFunctionTable[522784] = PS2RNA_Init_0x2fe820; // 0x2fe888 - g_ps2RecompiledFunctionTable[522790] = PS2RNA_Init_0x2fe820; // 0x2fe8a0 - g_ps2RecompiledFunctionTable[522808] = PS2RNA_Init_0x2fe820; // 0x2fe8e8 - g_ps2RecompiledFunctionTable[522813] = PS2RNA_Init_0x2fe820; // 0x2fe8fc - g_ps2RecompiledFunctionTable[522814] = PS2RNA_Init_0x2fe820; // 0x2fe900 - g_ps2RecompiledFunctionTable[522826] = PS2RNA_Init_0x2fe820; // 0x2fe930 - g_ps2RecompiledFunctionTable[522831] = PS2RNA_Init_0x2fe820; // 0x2fe944 - g_ps2RecompiledFunctionTable[522838] = PS2RNA_Finish_0x2fe960; // 0x2fe960 - g_ps2RecompiledFunctionTable[522846] = PS2RNA_Finish_0x2fe960; // 0x2fe980 - g_ps2RecompiledFunctionTable[522848] = PS2RNA_Finish_0x2fe960; // 0x2fe988 - g_ps2RecompiledFunctionTable[522854] = PS2RNA_Create_0x2fe9a0; // 0x2fe9a0 - g_ps2RecompiledFunctionTable[522855] = PS2RNA_Create_0x2fe9a0; // 0x2fe9a4 - g_ps2RecompiledFunctionTable[522856] = PS2RNA_Create_0x2fe9a0; // 0x2fe9a8 - g_ps2RecompiledFunctionTable[522857] = PS2RNA_Create_0x2fe9a0; // 0x2fe9ac - g_ps2RecompiledFunctionTable[522858] = PS2RNA_Create_0x2fe9a0; // 0x2fe9b0 - g_ps2RecompiledFunctionTable[522859] = PS2RNA_Create_0x2fe9a0; // 0x2fe9b4 - g_ps2RecompiledFunctionTable[522860] = PS2RNA_Create_0x2fe9a0; // 0x2fe9b8 - g_ps2RecompiledFunctionTable[522861] = PS2RNA_Create_0x2fe9a0; // 0x2fe9bc - g_ps2RecompiledFunctionTable[522862] = PS2RNA_Create_0x2fe9a0; // 0x2fe9c0 - g_ps2RecompiledFunctionTable[522863] = PS2RNA_Create_0x2fe9a0; // 0x2fe9c4 - g_ps2RecompiledFunctionTable[522864] = PS2RNA_Create_0x2fe9a0; // 0x2fe9c8 - g_ps2RecompiledFunctionTable[522865] = PS2RNA_Create_0x2fe9a0; // 0x2fe9cc - g_ps2RecompiledFunctionTable[522866] = PS2RNA_Create_0x2fe9a0; // 0x2fe9d0 - g_ps2RecompiledFunctionTable[522867] = PS2RNA_Create_0x2fe9a0; // 0x2fe9d4 - g_ps2RecompiledFunctionTable[522868] = PS2RNA_Create_0x2fe9a0; // 0x2fe9d8 - g_ps2RecompiledFunctionTable[522869] = PS2RNA_Create_0x2fe9a0; // 0x2fe9dc - g_ps2RecompiledFunctionTable[522870] = PS2RNA_Create_0x2fe9a0; // 0x2fe9e0 - g_ps2RecompiledFunctionTable[522871] = PS2RNA_Create_0x2fe9a0; // 0x2fe9e4 - g_ps2RecompiledFunctionTable[522872] = PS2RNA_Create_0x2fe9a0; // 0x2fe9e8 - g_ps2RecompiledFunctionTable[522873] = PS2RNA_Create_0x2fe9a0; // 0x2fe9ec - g_ps2RecompiledFunctionTable[522874] = PS2RNA_Create_0x2fe9a0; // 0x2fe9f0 - g_ps2RecompiledFunctionTable[522875] = PS2RNA_Create_0x2fe9a0; // 0x2fe9f4 - g_ps2RecompiledFunctionTable[522876] = PS2RNA_Create_0x2fe9a0; // 0x2fe9f8 - g_ps2RecompiledFunctionTable[522877] = PS2RNA_Create_0x2fe9a0; // 0x2fe9fc - g_ps2RecompiledFunctionTable[522878] = PS2RNA_Create_0x2fe9a0; // 0x2fea00 - g_ps2RecompiledFunctionTable[522879] = PS2RNA_Create_0x2fe9a0; // 0x2fea04 - g_ps2RecompiledFunctionTable[522880] = PS2RNA_Create_0x2fe9a0; // 0x2fea08 - g_ps2RecompiledFunctionTable[522881] = PS2RNA_Create_0x2fe9a0; // 0x2fea0c - g_ps2RecompiledFunctionTable[522882] = PS2RNA_Create_0x2fe9a0; // 0x2fea10 - g_ps2RecompiledFunctionTable[522883] = PS2RNA_Create_0x2fe9a0; // 0x2fea14 - g_ps2RecompiledFunctionTable[522884] = PS2RNA_Create_0x2fe9a0; // 0x2fea18 - g_ps2RecompiledFunctionTable[522885] = PS2RNA_Create_0x2fe9a0; // 0x2fea1c - g_ps2RecompiledFunctionTable[522886] = PS2RNA_Create_0x2fe9a0; // 0x2fea20 - g_ps2RecompiledFunctionTable[522887] = PS2RNA_Create_0x2fe9a0; // 0x2fea24 - g_ps2RecompiledFunctionTable[522888] = PS2RNA_Create_0x2fe9a0; // 0x2fea28 - g_ps2RecompiledFunctionTable[522889] = PS2RNA_Create_0x2fe9a0; // 0x2fea2c - g_ps2RecompiledFunctionTable[522890] = PS2RNA_Create_0x2fe9a0; // 0x2fea30 - g_ps2RecompiledFunctionTable[522891] = PS2RNA_Create_0x2fe9a0; // 0x2fea34 - g_ps2RecompiledFunctionTable[522892] = PS2RNA_Create_0x2fe9a0; // 0x2fea38 - g_ps2RecompiledFunctionTable[522893] = PS2RNA_Create_0x2fe9a0; // 0x2fea3c - g_ps2RecompiledFunctionTable[522894] = PS2RNA_Create_0x2fe9a0; // 0x2fea40 - g_ps2RecompiledFunctionTable[522895] = PS2RNA_Create_0x2fe9a0; // 0x2fea44 - g_ps2RecompiledFunctionTable[522896] = PS2RNA_Create_0x2fe9a0; // 0x2fea48 - g_ps2RecompiledFunctionTable[522897] = PS2RNA_Create_0x2fe9a0; // 0x2fea4c - g_ps2RecompiledFunctionTable[522898] = PS2RNA_Create_0x2fe9a0; // 0x2fea50 - g_ps2RecompiledFunctionTable[522899] = PS2RNA_Create_0x2fe9a0; // 0x2fea54 - g_ps2RecompiledFunctionTable[522900] = PS2RNA_Create_0x2fe9a0; // 0x2fea58 - g_ps2RecompiledFunctionTable[522901] = PS2RNA_Create_0x2fe9a0; // 0x2fea5c - g_ps2RecompiledFunctionTable[522902] = PS2RNA_Create_0x2fe9a0; // 0x2fea60 - g_ps2RecompiledFunctionTable[522903] = PS2RNA_Create_0x2fe9a0; // 0x2fea64 - g_ps2RecompiledFunctionTable[522904] = PS2RNA_Create_0x2fe9a0; // 0x2fea68 - g_ps2RecompiledFunctionTable[522905] = PS2RNA_Create_0x2fe9a0; // 0x2fea6c - g_ps2RecompiledFunctionTable[522906] = PS2RNA_Create_0x2fe9a0; // 0x2fea70 - g_ps2RecompiledFunctionTable[522907] = PS2RNA_Create_0x2fe9a0; // 0x2fea74 - g_ps2RecompiledFunctionTable[522908] = PS2RNA_Create_0x2fe9a0; // 0x2fea78 - g_ps2RecompiledFunctionTable[522909] = PS2RNA_Create_0x2fe9a0; // 0x2fea7c - g_ps2RecompiledFunctionTable[522910] = PS2RNA_Create_0x2fe9a0; // 0x2fea80 - g_ps2RecompiledFunctionTable[522911] = PS2RNA_Create_0x2fe9a0; // 0x2fea84 - g_ps2RecompiledFunctionTable[522912] = PS2RNA_Create_0x2fe9a0; // 0x2fea88 - g_ps2RecompiledFunctionTable[522913] = PS2RNA_Create_0x2fe9a0; // 0x2fea8c - g_ps2RecompiledFunctionTable[522914] = PS2RNA_Create_0x2fe9a0; // 0x2fea90 - g_ps2RecompiledFunctionTable[522915] = PS2RNA_Create_0x2fe9a0; // 0x2fea94 - g_ps2RecompiledFunctionTable[522916] = PS2RNA_Create_0x2fe9a0; // 0x2fea98 - g_ps2RecompiledFunctionTable[522917] = PS2RNA_Create_0x2fe9a0; // 0x2fea9c - g_ps2RecompiledFunctionTable[522918] = PS2RNA_Create_0x2fe9a0; // 0x2feaa0 - g_ps2RecompiledFunctionTable[522919] = PS2RNA_Create_0x2fe9a0; // 0x2feaa4 - g_ps2RecompiledFunctionTable[522920] = PS2RNA_Create_0x2fe9a0; // 0x2feaa8 - g_ps2RecompiledFunctionTable[522921] = PS2RNA_Create_0x2fe9a0; // 0x2feaac - g_ps2RecompiledFunctionTable[522922] = PS2RNA_Create_0x2fe9a0; // 0x2feab0 - g_ps2RecompiledFunctionTable[522923] = PS2RNA_Create_0x2fe9a0; // 0x2feab4 - g_ps2RecompiledFunctionTable[522924] = PS2RNA_Create_0x2fe9a0; // 0x2feab8 - g_ps2RecompiledFunctionTable[522925] = PS2RNA_Create_0x2fe9a0; // 0x2feabc - g_ps2RecompiledFunctionTable[522926] = PS2RNA_Create_0x2fe9a0; // 0x2feac0 - g_ps2RecompiledFunctionTable[522927] = PS2RNA_Create_0x2fe9a0; // 0x2feac4 - g_ps2RecompiledFunctionTable[522928] = PS2RNA_Create_0x2fe9a0; // 0x2feac8 - g_ps2RecompiledFunctionTable[522929] = PS2RNA_Create_0x2fe9a0; // 0x2feacc - g_ps2RecompiledFunctionTable[522930] = PS2RNA_Create_0x2fe9a0; // 0x2fead0 - g_ps2RecompiledFunctionTable[522931] = PS2RNA_Create_0x2fe9a0; // 0x2fead4 - g_ps2RecompiledFunctionTable[522932] = PS2RNA_Create_0x2fe9a0; // 0x2fead8 - g_ps2RecompiledFunctionTable[522933] = PS2RNA_Create_0x2fe9a0; // 0x2feadc - g_ps2RecompiledFunctionTable[522934] = PS2RNA_Create_0x2fe9a0; // 0x2feae0 - g_ps2RecompiledFunctionTable[522935] = PS2RNA_Create_0x2fe9a0; // 0x2feae4 - g_ps2RecompiledFunctionTable[522936] = PS2RNA_Create_0x2fe9a0; // 0x2feae8 - g_ps2RecompiledFunctionTable[522937] = PS2RNA_Create_0x2fe9a0; // 0x2feaec - g_ps2RecompiledFunctionTable[522938] = PS2RNA_Create_0x2fe9a0; // 0x2feaf0 - g_ps2RecompiledFunctionTable[522939] = PS2RNA_Create_0x2fe9a0; // 0x2feaf4 - g_ps2RecompiledFunctionTable[522940] = PS2RNA_Create_0x2fe9a0; // 0x2feaf8 - g_ps2RecompiledFunctionTable[522941] = PS2RNA_Create_0x2fe9a0; // 0x2feafc - g_ps2RecompiledFunctionTable[522942] = PS2RNA_Create_0x2fe9a0; // 0x2feb00 - g_ps2RecompiledFunctionTable[522943] = PS2RNA_Create_0x2fe9a0; // 0x2feb04 - g_ps2RecompiledFunctionTable[522944] = PS2RNA_Create_0x2fe9a0; // 0x2feb08 - g_ps2RecompiledFunctionTable[522945] = PS2RNA_Create_0x2fe9a0; // 0x2feb0c - g_ps2RecompiledFunctionTable[522946] = PS2RNA_Create_0x2fe9a0; // 0x2feb10 - g_ps2RecompiledFunctionTable[522947] = PS2RNA_Create_0x2fe9a0; // 0x2feb14 - g_ps2RecompiledFunctionTable[522948] = PS2RNA_Create_0x2fe9a0; // 0x2feb18 - g_ps2RecompiledFunctionTable[522949] = PS2RNA_Create_0x2fe9a0; // 0x2feb1c - g_ps2RecompiledFunctionTable[522950] = PS2RNA_Create_0x2fe9a0; // 0x2feb20 - g_ps2RecompiledFunctionTable[522951] = PS2RNA_Create_0x2fe9a0; // 0x2feb24 - g_ps2RecompiledFunctionTable[522952] = PS2RNA_Create_0x2fe9a0; // 0x2feb28 - g_ps2RecompiledFunctionTable[522953] = PS2RNA_Create_0x2fe9a0; // 0x2feb2c - g_ps2RecompiledFunctionTable[522954] = PS2RNA_Create_0x2fe9a0; // 0x2feb30 - g_ps2RecompiledFunctionTable[522955] = PS2RNA_Create_0x2fe9a0; // 0x2feb34 - g_ps2RecompiledFunctionTable[522956] = PS2RNA_Create_0x2fe9a0; // 0x2feb38 - g_ps2RecompiledFunctionTable[522957] = PS2RNA_Create_0x2fe9a0; // 0x2feb3c - g_ps2RecompiledFunctionTable[522958] = PS2RNA_Create_0x2fe9a0; // 0x2feb40 - g_ps2RecompiledFunctionTable[522959] = PS2RNA_Create_0x2fe9a0; // 0x2feb44 - g_ps2RecompiledFunctionTable[522960] = PS2RNA_Create_0x2fe9a0; // 0x2feb48 - g_ps2RecompiledFunctionTable[522961] = PS2RNA_Create_0x2fe9a0; // 0x2feb4c - g_ps2RecompiledFunctionTable[522962] = PS2RNA_Create_0x2fe9a0; // 0x2feb50 - g_ps2RecompiledFunctionTable[522963] = PS2RNA_Create_0x2fe9a0; // 0x2feb54 - g_ps2RecompiledFunctionTable[522964] = PS2RNA_Create_0x2fe9a0; // 0x2feb58 - g_ps2RecompiledFunctionTable[522965] = PS2RNA_Create_0x2fe9a0; // 0x2feb5c - g_ps2RecompiledFunctionTable[522966] = PS2RNA_Create_0x2fe9a0; // 0x2feb60 - g_ps2RecompiledFunctionTable[522967] = PS2RNA_Create_0x2fe9a0; // 0x2feb64 - g_ps2RecompiledFunctionTable[522968] = PS2RNA_Create_0x2fe9a0; // 0x2feb68 - g_ps2RecompiledFunctionTable[522969] = PS2RNA_Create_0x2fe9a0; // 0x2feb6c - g_ps2RecompiledFunctionTable[522970] = PS2RNA_Create_0x2fe9a0; // 0x2feb70 - g_ps2RecompiledFunctionTable[522971] = PS2RNA_Create_0x2fe9a0; // 0x2feb74 - g_ps2RecompiledFunctionTable[522972] = PS2RNA_Create_0x2fe9a0; // 0x2feb78 - g_ps2RecompiledFunctionTable[522973] = PS2RNA_Create_0x2fe9a0; // 0x2feb7c - g_ps2RecompiledFunctionTable[522974] = PS2RNA_Create_0x2fe9a0; // 0x2feb80 - g_ps2RecompiledFunctionTable[522975] = PS2RNA_Create_0x2fe9a0; // 0x2feb84 - g_ps2RecompiledFunctionTable[522976] = PS2RNA_Create_0x2fe9a0; // 0x2feb88 - g_ps2RecompiledFunctionTable[522977] = PS2RNA_Create_0x2fe9a0; // 0x2feb8c - g_ps2RecompiledFunctionTable[522978] = PS2RNA_Create_0x2fe9a0; // 0x2feb90 - g_ps2RecompiledFunctionTable[522979] = PS2RNA_Create_0x2fe9a0; // 0x2feb94 - g_ps2RecompiledFunctionTable[522980] = PS2RNA_Create_0x2fe9a0; // 0x2feb98 - g_ps2RecompiledFunctionTable[522981] = PS2RNA_Create_0x2fe9a0; // 0x2feb9c - g_ps2RecompiledFunctionTable[522982] = PS2RNA_Create_0x2fe9a0; // 0x2feba0 - g_ps2RecompiledFunctionTable[522983] = PS2RNA_Create_0x2fe9a0; // 0x2feba4 - g_ps2RecompiledFunctionTable[522984] = PS2RNA_Create_0x2fe9a0; // 0x2feba8 - g_ps2RecompiledFunctionTable[522985] = PS2RNA_Create_0x2fe9a0; // 0x2febac - g_ps2RecompiledFunctionTable[522986] = PS2RNA_Create_0x2fe9a0; // 0x2febb0 - g_ps2RecompiledFunctionTable[522987] = PS2RNA_Create_0x2fe9a0; // 0x2febb4 - g_ps2RecompiledFunctionTable[522988] = PS2RNA_Create_0x2fe9a0; // 0x2febb8 - g_ps2RecompiledFunctionTable[522989] = PS2RNA_Create_0x2fe9a0; // 0x2febbc - g_ps2RecompiledFunctionTable[522990] = PS2RNA_Create_0x2fe9a0; // 0x2febc0 - g_ps2RecompiledFunctionTable[522991] = PS2RNA_Create_0x2fe9a0; // 0x2febc4 - g_ps2RecompiledFunctionTable[522992] = PS2RNA_Create_0x2fe9a0; // 0x2febc8 - g_ps2RecompiledFunctionTable[522993] = PS2RNA_Create_0x2fe9a0; // 0x2febcc - g_ps2RecompiledFunctionTable[522994] = PS2RNA_Create_0x2fe9a0; // 0x2febd0 - g_ps2RecompiledFunctionTable[522995] = PS2RNA_Create_0x2fe9a0; // 0x2febd4 - g_ps2RecompiledFunctionTable[522996] = PS2RNA_Create_0x2fe9a0; // 0x2febd8 - g_ps2RecompiledFunctionTable[522997] = PS2RNA_Create_0x2fe9a0; // 0x2febdc - g_ps2RecompiledFunctionTable[522998] = PS2RNA_Create_0x2fe9a0; // 0x2febe0 - g_ps2RecompiledFunctionTable[522999] = PS2RNA_Create_0x2fe9a0; // 0x2febe4 - g_ps2RecompiledFunctionTable[523000] = PS2RNA_Create_0x2fe9a0; // 0x2febe8 - g_ps2RecompiledFunctionTable[523001] = PS2RNA_Create_0x2fe9a0; // 0x2febec - g_ps2RecompiledFunctionTable[523002] = PS2RNA_Create_0x2fe9a0; // 0x2febf0 - g_ps2RecompiledFunctionTable[523003] = PS2RNA_Create_0x2fe9a0; // 0x2febf4 - g_ps2RecompiledFunctionTable[523004] = PS2RNA_Create_0x2fe9a0; // 0x2febf8 - g_ps2RecompiledFunctionTable[523005] = PS2RNA_Create_0x2fe9a0; // 0x2febfc - g_ps2RecompiledFunctionTable[523006] = PS2RNA_Create_0x2fe9a0; // 0x2fec00 - g_ps2RecompiledFunctionTable[523007] = PS2RNA_Create_0x2fe9a0; // 0x2fec04 - g_ps2RecompiledFunctionTable[523008] = PS2RNA_Create_0x2fe9a0; // 0x2fec08 - g_ps2RecompiledFunctionTable[523009] = PS2RNA_Create_0x2fe9a0; // 0x2fec0c - g_ps2RecompiledFunctionTable[523010] = PS2RNA_Create_0x2fe9a0; // 0x2fec10 - g_ps2RecompiledFunctionTable[523012] = PS2RNA_Destroy_0x2fec18; // 0x2fec18 - g_ps2RecompiledFunctionTable[523024] = PS2RNA_Destroy_0x2fec18; // 0x2fec48 - g_ps2RecompiledFunctionTable[523030] = PS2RNA_Destroy_0x2fec18; // 0x2fec60 - g_ps2RecompiledFunctionTable[523043] = PS2RNA_Destroy_0x2fec18; // 0x2fec94 - g_ps2RecompiledFunctionTable[523048] = PS2RNA_Destroy_0x2fec18; // 0x2feca8 - g_ps2RecompiledFunctionTable[523054] = PS2RNA_Destroy_0x2fec18; // 0x2fecc0 - g_ps2RecompiledFunctionTable[523066] = PS2RNA_Start_0x2fecf0; // 0x2fecf0 - g_ps2RecompiledFunctionTable[523071] = PS2RNA_Start_0x2fecf0; // 0x2fed04 - g_ps2RecompiledFunctionTable[523072] = PS2RNA_Start_0x2fecf0; // 0x2fed08 - g_ps2RecompiledFunctionTable[523080] = PS2RNA_Stop_0x2fed28; // 0x2fed28 - g_ps2RecompiledFunctionTable[523086] = PS2RNA_Stop_0x2fed28; // 0x2fed40 - g_ps2RecompiledFunctionTable[523092] = PS2RNA_SetTransSw_0x2fed58; // 0x2fed58 - g_ps2RecompiledFunctionTable[523112] = PS2RNA_SetTransSw_0x2fed58; // 0x2feda8 - g_ps2RecompiledFunctionTable[523116] = PS2RNA_SetTransSw_0x2fed58; // 0x2fedb8 - g_ps2RecompiledFunctionTable[523128] = PS2RNA_SetPlaySw_0x2fede8; // 0x2fede8 - g_ps2RecompiledFunctionTable[523129] = PS2RNA_SetPlaySw_0x2fede8; // 0x2fedec - g_ps2RecompiledFunctionTable[523130] = PS2RNA_SetPlaySw_0x2fede8; // 0x2fedf0 - g_ps2RecompiledFunctionTable[523131] = PS2RNA_SetPlaySw_0x2fede8; // 0x2fedf4 - g_ps2RecompiledFunctionTable[523132] = PS2RNA_SetPlaySw_0x2fede8; // 0x2fedf8 - g_ps2RecompiledFunctionTable[523133] = PS2RNA_SetPlaySw_0x2fede8; // 0x2fedfc - g_ps2RecompiledFunctionTable[523134] = PS2RNA_SetPlaySw_0x2fede8; // 0x2fee00 - g_ps2RecompiledFunctionTable[523135] = PS2RNA_SetPlaySw_0x2fede8; // 0x2fee04 - g_ps2RecompiledFunctionTable[523136] = PS2RNA_SetPlaySw_0x2fede8; // 0x2fee08 - g_ps2RecompiledFunctionTable[523137] = PS2RNA_SetPlaySw_0x2fede8; // 0x2fee0c - g_ps2RecompiledFunctionTable[523138] = PS2RNA_SetPlaySw_0x2fede8; // 0x2fee10 - g_ps2RecompiledFunctionTable[523139] = PS2RNA_SetPlaySw_0x2fede8; // 0x2fee14 - g_ps2RecompiledFunctionTable[523140] = PS2RNA_SetPlaySw_0x2fede8; // 0x2fee18 - g_ps2RecompiledFunctionTable[523141] = PS2RNA_SetPlaySw_0x2fede8; // 0x2fee1c - g_ps2RecompiledFunctionTable[523142] = PS2RNA_SetPlaySw_0x2fede8; // 0x2fee20 - g_ps2RecompiledFunctionTable[523143] = PS2RNA_SetPlaySw_0x2fede8; // 0x2fee24 - g_ps2RecompiledFunctionTable[523144] = PS2RNA_SetPlaySw_0x2fede8; // 0x2fee28 - g_ps2RecompiledFunctionTable[523145] = PS2RNA_SetPlaySw_0x2fede8; // 0x2fee2c - g_ps2RecompiledFunctionTable[523146] = PS2RNA_SetPlaySw_0x2fede8; // 0x2fee30 - g_ps2RecompiledFunctionTable[523147] = PS2RNA_SetPlaySw_0x2fede8; // 0x2fee34 - g_ps2RecompiledFunctionTable[523148] = PS2RNA_SetPlaySw_0x2fede8; // 0x2fee38 - g_ps2RecompiledFunctionTable[523149] = PS2RNA_SetPlaySw_0x2fede8; // 0x2fee3c - g_ps2RecompiledFunctionTable[523150] = PS2RNA_SetPlaySw_0x2fede8; // 0x2fee40 - g_ps2RecompiledFunctionTable[523151] = PS2RNA_SetPlaySw_0x2fede8; // 0x2fee44 - g_ps2RecompiledFunctionTable[523152] = PS2RNA_SetPlaySw_0x2fede8; // 0x2fee48 - g_ps2RecompiledFunctionTable[523153] = PS2RNA_SetPlaySw_0x2fede8; // 0x2fee4c - g_ps2RecompiledFunctionTable[523154] = PS2RNA_SetPlaySw_0x2fede8; // 0x2fee50 - g_ps2RecompiledFunctionTable[523155] = PS2RNA_SetPlaySw_0x2fede8; // 0x2fee54 - g_ps2RecompiledFunctionTable[523156] = PS2RNA_SetPlaySw_0x2fede8; // 0x2fee58 - g_ps2RecompiledFunctionTable[523157] = PS2RNA_SetPlaySw_0x2fede8; // 0x2fee5c - g_ps2RecompiledFunctionTable[523158] = PS2RNA_SetPlaySw_0x2fede8; // 0x2fee60 - g_ps2RecompiledFunctionTable[523159] = PS2RNA_SetPlaySw_0x2fede8; // 0x2fee64 - g_ps2RecompiledFunctionTable[523160] = PS2RNA_SetPlaySw_0x2fede8; // 0x2fee68 - g_ps2RecompiledFunctionTable[523161] = PS2RNA_SetPlaySw_0x2fede8; // 0x2fee6c - g_ps2RecompiledFunctionTable[523162] = PS2RNA_SetPlaySw_0x2fede8; // 0x2fee70 - g_ps2RecompiledFunctionTable[523163] = PS2RNA_SetPlaySw_0x2fede8; // 0x2fee74 - g_ps2RecompiledFunctionTable[523164] = PS2RNA_SetPlaySw_0x2fede8; // 0x2fee78 - g_ps2RecompiledFunctionTable[523165] = PS2RNA_SetPlaySw_0x2fede8; // 0x2fee7c - g_ps2RecompiledFunctionTable[523166] = PS2RNA_SetPlaySw_0x2fede8; // 0x2fee80 - g_ps2RecompiledFunctionTable[523167] = PS2RNA_SetPlaySw_0x2fede8; // 0x2fee84 - g_ps2RecompiledFunctionTable[523168] = PS2RNA_SetPlaySw_0x2fede8; // 0x2fee88 - g_ps2RecompiledFunctionTable[523169] = PS2RNA_SetPlaySw_0x2fede8; // 0x2fee8c - g_ps2RecompiledFunctionTable[523170] = PS2RNA_ClearBuf_0x2fee90; // 0x2fee90 - g_ps2RecompiledFunctionTable[523175] = PS2RNA_ClearBuf_0x2fee90; // 0x2feea4 - g_ps2RecompiledFunctionTable[523176] = PS2RNA_ClearBuf_0x2fee90; // 0x2feea8 - g_ps2RecompiledFunctionTable[523184] = PS2RNA_SetPcmType_0x2feec8; // 0x2feec8 - g_ps2RecompiledFunctionTable[523189] = PS2RNA_SetPcmType_0x2feec8; // 0x2feedc - g_ps2RecompiledFunctionTable[523190] = PS2RNA_SetPcmType_0x2feec8; // 0x2feee0 - g_ps2RecompiledFunctionTable[523198] = PS2RNA_GetTime_0x2fef00; // 0x2fef00 - g_ps2RecompiledFunctionTable[523202] = PS2RNA_GetNumData_0x2fef10; // 0x2fef10 - g_ps2RecompiledFunctionTable[523203] = PS2RNA_GetNumData_0x2fef10; // 0x2fef14 - g_ps2RecompiledFunctionTable[523204] = PS2RNA_GetNumData_0x2fef10; // 0x2fef18 - g_ps2RecompiledFunctionTable[523205] = PS2RNA_GetNumData_0x2fef10; // 0x2fef1c - g_ps2RecompiledFunctionTable[523206] = PS2RNA_GetNumData_0x2fef10; // 0x2fef20 - g_ps2RecompiledFunctionTable[523207] = PS2RNA_GetNumData_0x2fef10; // 0x2fef24 - g_ps2RecompiledFunctionTable[523208] = PS2RNA_GetNumData_0x2fef10; // 0x2fef28 - g_ps2RecompiledFunctionTable[523209] = PS2RNA_GetNumData_0x2fef10; // 0x2fef2c - g_ps2RecompiledFunctionTable[523210] = PS2RNA_GetNumData_0x2fef10; // 0x2fef30 - g_ps2RecompiledFunctionTable[523211] = PS2RNA_GetNumData_0x2fef10; // 0x2fef34 - g_ps2RecompiledFunctionTable[523212] = PS2RNA_GetNumData_0x2fef10; // 0x2fef38 - g_ps2RecompiledFunctionTable[523213] = PS2RNA_GetNumData_0x2fef10; // 0x2fef3c - g_ps2RecompiledFunctionTable[523214] = PS2RNA_GetNumData_0x2fef10; // 0x2fef40 - g_ps2RecompiledFunctionTable[523215] = PS2RNA_GetNumData_0x2fef10; // 0x2fef44 - g_ps2RecompiledFunctionTable[523216] = PS2RNA_GetNumRoom_0x2fef48; // 0x2fef48 - g_ps2RecompiledFunctionTable[523217] = PS2RNA_GetNumRoom_0x2fef48; // 0x2fef4c - g_ps2RecompiledFunctionTable[523218] = PS2RNA_GetNumRoom_0x2fef48; // 0x2fef50 - g_ps2RecompiledFunctionTable[523219] = PS2RNA_GetNumRoom_0x2fef48; // 0x2fef54 - g_ps2RecompiledFunctionTable[523220] = PS2RNA_GetNumRoom_0x2fef48; // 0x2fef58 - g_ps2RecompiledFunctionTable[523221] = PS2RNA_GetNumRoom_0x2fef48; // 0x2fef5c - g_ps2RecompiledFunctionTable[523222] = PS2RNA_GetNumRoom_0x2fef48; // 0x2fef60 - g_ps2RecompiledFunctionTable[523223] = PS2RNA_GetNumRoom_0x2fef48; // 0x2fef64 - g_ps2RecompiledFunctionTable[523224] = PS2RNA_GetNumRoom_0x2fef48; // 0x2fef68 - g_ps2RecompiledFunctionTable[523225] = PS2RNA_GetNumRoom_0x2fef48; // 0x2fef6c - g_ps2RecompiledFunctionTable[523226] = PS2RNA_GetNumRoom_0x2fef48; // 0x2fef70 - g_ps2RecompiledFunctionTable[523227] = PS2RNA_GetNumRoom_0x2fef48; // 0x2fef74 - g_ps2RecompiledFunctionTable[523228] = PS2RNA_ExecHndl_0x2fef78; // 0x2fef78 - g_ps2RecompiledFunctionTable[523229] = PS2RNA_ExecHndl_0x2fef78; // 0x2fef7c - g_ps2RecompiledFunctionTable[523230] = PS2RNA_ExecHndl_0x2fef78; // 0x2fef80 - g_ps2RecompiledFunctionTable[523231] = PS2RNA_ExecHndl_0x2fef78; // 0x2fef84 - g_ps2RecompiledFunctionTable[523232] = PS2RNA_ExecHndl_0x2fef78; // 0x2fef88 - g_ps2RecompiledFunctionTable[523233] = PS2RNA_ExecHndl_0x2fef78; // 0x2fef8c - g_ps2RecompiledFunctionTable[523234] = PS2RNA_ExecHndl_0x2fef78; // 0x2fef90 - g_ps2RecompiledFunctionTable[523235] = PS2RNA_ExecHndl_0x2fef78; // 0x2fef94 - g_ps2RecompiledFunctionTable[523236] = PS2RNA_ExecHndl_0x2fef78; // 0x2fef98 - g_ps2RecompiledFunctionTable[523237] = PS2RNA_ExecHndl_0x2fef78; // 0x2fef9c - g_ps2RecompiledFunctionTable[523238] = PS2RNA_ExecHndl_0x2fef78; // 0x2fefa0 - g_ps2RecompiledFunctionTable[523239] = PS2RNA_ExecHndl_0x2fef78; // 0x2fefa4 - g_ps2RecompiledFunctionTable[523240] = PS2RNA_ExecHndl_0x2fef78; // 0x2fefa8 - g_ps2RecompiledFunctionTable[523241] = PS2RNA_ExecHndl_0x2fef78; // 0x2fefac - g_ps2RecompiledFunctionTable[523242] = PS2RNA_ExecHndl_0x2fef78; // 0x2fefb0 - g_ps2RecompiledFunctionTable[523243] = PS2RNA_ExecHndl_0x2fef78; // 0x2fefb4 - g_ps2RecompiledFunctionTable[523244] = PS2RNA_ExecHndl_0x2fef78; // 0x2fefb8 - g_ps2RecompiledFunctionTable[523245] = PS2RNA_ExecHndl_0x2fef78; // 0x2fefbc - g_ps2RecompiledFunctionTable[523246] = PS2RNA_ExecHndl_0x2fef78; // 0x2fefc0 - g_ps2RecompiledFunctionTable[523247] = PS2RNA_ExecHndl_0x2fef78; // 0x2fefc4 - g_ps2RecompiledFunctionTable[523248] = PS2RNA_ExecHndl_0x2fef78; // 0x2fefc8 - g_ps2RecompiledFunctionTable[523249] = PS2RNA_ExecHndl_0x2fef78; // 0x2fefcc - g_ps2RecompiledFunctionTable[523250] = PS2RNA_ExecHndl_0x2fef78; // 0x2fefd0 - g_ps2RecompiledFunctionTable[523251] = PS2RNA_ExecHndl_0x2fef78; // 0x2fefd4 - g_ps2RecompiledFunctionTable[523252] = PS2RNA_ExecHndl_0x2fef78; // 0x2fefd8 - g_ps2RecompiledFunctionTable[523253] = PS2RNA_ExecHndl_0x2fef78; // 0x2fefdc - g_ps2RecompiledFunctionTable[523254] = PS2RNA_ExecHndl_0x2fef78; // 0x2fefe0 - g_ps2RecompiledFunctionTable[523255] = PS2RNA_ExecHndl_0x2fef78; // 0x2fefe4 - g_ps2RecompiledFunctionTable[523256] = PS2RNA_ExecHndl_0x2fef78; // 0x2fefe8 - g_ps2RecompiledFunctionTable[523257] = PS2RNA_ExecHndl_0x2fef78; // 0x2fefec - g_ps2RecompiledFunctionTable[523258] = PS2RNA_ExecHndl_0x2fef78; // 0x2feff0 - g_ps2RecompiledFunctionTable[523259] = PS2RNA_ExecHndl_0x2fef78; // 0x2feff4 - g_ps2RecompiledFunctionTable[523260] = PS2RNA_ExecHndl_0x2fef78; // 0x2feff8 - g_ps2RecompiledFunctionTable[523261] = PS2RNA_ExecHndl_0x2fef78; // 0x2feffc - g_ps2RecompiledFunctionTable[523262] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff000 - g_ps2RecompiledFunctionTable[523263] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff004 - g_ps2RecompiledFunctionTable[523264] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff008 - g_ps2RecompiledFunctionTable[523265] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff00c - g_ps2RecompiledFunctionTable[523266] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff010 - g_ps2RecompiledFunctionTable[523267] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff014 - g_ps2RecompiledFunctionTable[523268] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff018 - g_ps2RecompiledFunctionTable[523269] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff01c - g_ps2RecompiledFunctionTable[523270] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff020 - g_ps2RecompiledFunctionTable[523271] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff024 - g_ps2RecompiledFunctionTable[523272] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff028 - g_ps2RecompiledFunctionTable[523273] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff02c - g_ps2RecompiledFunctionTable[523274] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff030 - g_ps2RecompiledFunctionTable[523275] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff034 - g_ps2RecompiledFunctionTable[523276] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff038 - g_ps2RecompiledFunctionTable[523277] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff03c - g_ps2RecompiledFunctionTable[523278] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff040 - g_ps2RecompiledFunctionTable[523279] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff044 - g_ps2RecompiledFunctionTable[523280] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff048 - g_ps2RecompiledFunctionTable[523281] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff04c - g_ps2RecompiledFunctionTable[523282] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff050 - g_ps2RecompiledFunctionTable[523283] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff054 - g_ps2RecompiledFunctionTable[523284] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff058 - g_ps2RecompiledFunctionTable[523285] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff05c - g_ps2RecompiledFunctionTable[523286] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff060 - g_ps2RecompiledFunctionTable[523287] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff064 - g_ps2RecompiledFunctionTable[523288] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff068 - g_ps2RecompiledFunctionTable[523289] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff06c - g_ps2RecompiledFunctionTable[523290] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff070 - g_ps2RecompiledFunctionTable[523291] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff074 - g_ps2RecompiledFunctionTable[523292] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff078 - g_ps2RecompiledFunctionTable[523293] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff07c - g_ps2RecompiledFunctionTable[523294] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff080 - g_ps2RecompiledFunctionTable[523295] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff084 - g_ps2RecompiledFunctionTable[523296] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff088 - g_ps2RecompiledFunctionTable[523297] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff08c - g_ps2RecompiledFunctionTable[523298] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff090 - g_ps2RecompiledFunctionTable[523299] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff094 - g_ps2RecompiledFunctionTable[523300] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff098 - g_ps2RecompiledFunctionTable[523301] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff09c - g_ps2RecompiledFunctionTable[523302] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff0a0 - g_ps2RecompiledFunctionTable[523303] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff0a4 - g_ps2RecompiledFunctionTable[523304] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff0a8 - g_ps2RecompiledFunctionTable[523305] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff0ac - g_ps2RecompiledFunctionTable[523306] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff0b0 - g_ps2RecompiledFunctionTable[523307] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff0b4 - g_ps2RecompiledFunctionTable[523308] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff0b8 - g_ps2RecompiledFunctionTable[523309] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff0bc - g_ps2RecompiledFunctionTable[523310] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff0c0 - g_ps2RecompiledFunctionTable[523311] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff0c4 - g_ps2RecompiledFunctionTable[523312] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff0c8 - g_ps2RecompiledFunctionTable[523313] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff0cc - g_ps2RecompiledFunctionTable[523314] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff0d0 - g_ps2RecompiledFunctionTable[523315] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff0d4 - g_ps2RecompiledFunctionTable[523316] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff0d8 - g_ps2RecompiledFunctionTable[523317] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff0dc - g_ps2RecompiledFunctionTable[523318] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff0e0 - g_ps2RecompiledFunctionTable[523319] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff0e4 - g_ps2RecompiledFunctionTable[523320] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff0e8 - g_ps2RecompiledFunctionTable[523321] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff0ec - g_ps2RecompiledFunctionTable[523322] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff0f0 - g_ps2RecompiledFunctionTable[523323] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff0f4 - g_ps2RecompiledFunctionTable[523324] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff0f8 - g_ps2RecompiledFunctionTable[523325] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff0fc - g_ps2RecompiledFunctionTable[523326] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff100 - g_ps2RecompiledFunctionTable[523327] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff104 - g_ps2RecompiledFunctionTable[523328] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff108 - g_ps2RecompiledFunctionTable[523329] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff10c - g_ps2RecompiledFunctionTable[523330] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff110 - g_ps2RecompiledFunctionTable[523331] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff114 - g_ps2RecompiledFunctionTable[523332] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff118 - g_ps2RecompiledFunctionTable[523333] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff11c - g_ps2RecompiledFunctionTable[523334] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff120 - g_ps2RecompiledFunctionTable[523335] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff124 - g_ps2RecompiledFunctionTable[523336] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff128 - g_ps2RecompiledFunctionTable[523337] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff12c - g_ps2RecompiledFunctionTable[523338] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff130 - g_ps2RecompiledFunctionTable[523339] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff134 - g_ps2RecompiledFunctionTable[523340] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff138 - g_ps2RecompiledFunctionTable[523341] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff13c - g_ps2RecompiledFunctionTable[523342] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff140 - g_ps2RecompiledFunctionTable[523343] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff144 - g_ps2RecompiledFunctionTable[523344] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff148 - g_ps2RecompiledFunctionTable[523345] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff14c - g_ps2RecompiledFunctionTable[523346] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff150 - g_ps2RecompiledFunctionTable[523347] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff154 - g_ps2RecompiledFunctionTable[523348] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff158 - g_ps2RecompiledFunctionTable[523349] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff15c - g_ps2RecompiledFunctionTable[523350] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff160 - g_ps2RecompiledFunctionTable[523351] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff164 - g_ps2RecompiledFunctionTable[523352] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff168 - g_ps2RecompiledFunctionTable[523353] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff16c - g_ps2RecompiledFunctionTable[523354] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff170 - g_ps2RecompiledFunctionTable[523355] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff174 - g_ps2RecompiledFunctionTable[523356] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff178 - g_ps2RecompiledFunctionTable[523357] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff17c - g_ps2RecompiledFunctionTable[523358] = PS2RNA_ExecHndl_0x2fef78; // 0x2ff180 - g_ps2RecompiledFunctionTable[523360] = PS2RNA_ExecServer_0x2ff188; // 0x2ff188 - g_ps2RecompiledFunctionTable[523367] = PS2RNA_ExecServer_0x2ff188; // 0x2ff1a4 - g_ps2RecompiledFunctionTable[523369] = PS2RNA_ExecServer_0x2ff188; // 0x2ff1ac - g_ps2RecompiledFunctionTable[523371] = PS2RNA_ExecServer_0x2ff188; // 0x2ff1b4 - g_ps2RecompiledFunctionTable[523376] = PS2RNA_ExecServer_0x2ff188; // 0x2ff1c8 - g_ps2RecompiledFunctionTable[523380] = PS2RNA_ExecServer_0x2ff188; // 0x2ff1d8 - g_ps2RecompiledFunctionTable[523390] = PS2RNA_SetStartSmpl_0x2ff200; // 0x2ff200 - g_ps2RecompiledFunctionTable[523395] = PS2RNA_SetStartSmpl_0x2ff200; // 0x2ff214 - g_ps2RecompiledFunctionTable[523396] = PS2RNA_SetStartSmpl_0x2ff200; // 0x2ff218 - g_ps2RecompiledFunctionTable[523404] = PS2RNA_SetNumChan_0x2ff238; // 0x2ff238 - g_ps2RecompiledFunctionTable[523406] = PS2RNA_SetSfreq_0x2ff240; // 0x2ff240 - g_ps2RecompiledFunctionTable[523408] = PS2RNA_SetOutVol_0x2ff248; // 0x2ff248 - g_ps2RecompiledFunctionTable[523416] = PS2RNA_SetOutPan_0x2ff268; // 0x2ff268 - g_ps2RecompiledFunctionTable[523428] = PS2RNA_SetBitPerSmpl_0x2ff298; // 0x2ff298 - g_ps2RecompiledFunctionTable[523435] = PS2RNA_SetBitPerSmpl_0x2ff298; // 0x2ff2b4 - g_ps2RecompiledFunctionTable[523436] = PS2RNA_SetBitPerSmpl_0x2ff298; // 0x2ff2b8 - g_ps2RecompiledFunctionTable[523446] = PS2RNA_GetStartSmpl_0x2ff2e0; // 0x2ff2e0 - g_ps2RecompiledFunctionTable[523451] = PS2RNA_GetStartSmpl_0x2ff2e0; // 0x2ff2f4 - g_ps2RecompiledFunctionTable[523452] = PS2RNA_GetStartSmpl_0x2ff2e0; // 0x2ff2f8 - g_ps2RecompiledFunctionTable[523460] = PS2RNA_GetSfreq_0x2ff318; // 0x2ff318 - g_ps2RecompiledFunctionTable[523462] = PS2RNA_GetOutVol_0x2ff320; // 0x2ff320 - g_ps2RecompiledFunctionTable[523464] = PS2RNA_GetOutPan_0x2ff328; // 0x2ff328 - g_ps2RecompiledFunctionTable[523468] = PS2RNA_GetBitPerSmpl_0x2ff338; // 0x2ff338 - g_ps2RecompiledFunctionTable[523470] = PS2RNA_IsOverflow_0x2ff340; // 0x2ff340 - g_ps2RecompiledFunctionTable[523475] = PS2RNA_IsOverflow_0x2ff340; // 0x2ff354 - g_ps2RecompiledFunctionTable[523476] = PS2RNA_IsOverflow_0x2ff340; // 0x2ff358 - g_ps2RecompiledFunctionTable[523484] = PS2RNA_ClearOverflow_0x2ff378; // 0x2ff378 - g_ps2RecompiledFunctionTable[523489] = PS2RNA_ClearOverflow_0x2ff378; // 0x2ff38c - g_ps2RecompiledFunctionTable[523490] = PS2RNA_ClearOverflow_0x2ff378; // 0x2ff390 - g_ps2RecompiledFunctionTable[523498] = PS2RNA_Flush_0x2ff3b0; // 0x2ff3b0 - g_ps2RecompiledFunctionTable[523503] = PS2RNA_Flush_0x2ff3b0; // 0x2ff3c4 - g_ps2RecompiledFunctionTable[523504] = PS2RNA_Flush_0x2ff3b0; // 0x2ff3c8 - g_ps2RecompiledFunctionTable[523512] = PS2RNA_DiscardData_0x2ff3e8; // 0x2ff3e8 - g_ps2RecompiledFunctionTable[523517] = PS2RNA_DiscardData_0x2ff3e8; // 0x2ff3fc - g_ps2RecompiledFunctionTable[523518] = PS2RNA_DiscardData_0x2ff3e8; // 0x2ff400 - g_ps2RecompiledFunctionTable[523526] = PS2RNA_SetTotalNumSmpl_0x2ff420; // 0x2ff420 - g_ps2RecompiledFunctionTable[523531] = PS2RNA_SetTotalNumSmpl_0x2ff420; // 0x2ff434 - g_ps2RecompiledFunctionTable[523532] = PS2RNA_SetTotalNumSmpl_0x2ff420; // 0x2ff438 - g_ps2RecompiledFunctionTable[523540] = PS2RNA_SetStmHdInfo_0x2ff458; // 0x2ff458 - g_ps2RecompiledFunctionTable[523545] = PS2RNA_SetStmHdInfo_0x2ff458; // 0x2ff46c - g_ps2RecompiledFunctionTable[523546] = PS2RNA_SetStmHdInfo_0x2ff458; // 0x2ff470 - g_ps2RecompiledFunctionTable[523554] = PS2RNA_IsPlySwOff_0x2ff490; // 0x2ff490 - g_ps2RecompiledFunctionTable[523561] = PS2RNA_IsPlySwOff_0x2ff490; // 0x2ff4ac - g_ps2RecompiledFunctionTable[523572] = PS2RNA_GetSjtmp_0x2ff4d8; // 0x2ff4d8 - g_ps2RecompiledFunctionTable[523578] = PS2RNA_GetSjiop_0x2ff4f0; // 0x2ff4f0 - g_ps2RecompiledFunctionTable[523584] = RNACRS_Init_0x2ff508; // 0x2ff508 - g_ps2RecompiledFunctionTable[523586] = RNACRS_Finish_0x2ff510; // 0x2ff510 - g_ps2RecompiledFunctionTable[523588] = RNACRS_Lock_0x2ff518; // 0x2ff518 - g_ps2RecompiledFunctionTable[523592] = RNACRS_Unlock_0x2ff528; // 0x2ff528 - g_ps2RecompiledFunctionTable[523596] = SJCRS_Init_0x2ff538; // 0x2ff538 - g_ps2RecompiledFunctionTable[523598] = SJCRS_Lock_0x2ff540; // 0x2ff540 - g_ps2RecompiledFunctionTable[523602] = SJCRS_Unlock_0x2ff550; // 0x2ff550 - g_ps2RecompiledFunctionTable[523606] = SJMEM_Error_0x2ff560; // 0x2ff560 - g_ps2RecompiledFunctionTable[523614] = SJMEM_Init_0x2ff580; // 0x2ff580 - g_ps2RecompiledFunctionTable[523623] = SJMEM_Init_0x2ff580; // 0x2ff5a4 - g_ps2RecompiledFunctionTable[523630] = SJMEM_Finish_0x2ff5c0; // 0x2ff5c0 - g_ps2RecompiledFunctionTable[523642] = SJMEM_Create_0x2ff5f0; // 0x2ff5f0 - g_ps2RecompiledFunctionTable[523654] = SJMEM_Create_0x2ff5f0; // 0x2ff620 - g_ps2RecompiledFunctionTable[523684] = SJMEM_Create_0x2ff5f0; // 0x2ff698 - g_ps2RecompiledFunctionTable[523690] = SJMEM_Destroy_0x2ff6b0; // 0x2ff6b0 - g_ps2RecompiledFunctionTable[523698] = SJMEM_Destroy_0x2ff6b0; // 0x2ff6d0 - g_ps2RecompiledFunctionTable[523704] = SJMEM_GetUuid_0x2ff6e8; // 0x2ff6e8 - g_ps2RecompiledFunctionTable[523706] = SJMEM_EntryErrFunc_0x2ff6f0; // 0x2ff6f0 - g_ps2RecompiledFunctionTable[523710] = SJMEM_Reset_0x2ff700; // 0x2ff700 - g_ps2RecompiledFunctionTable[523714] = SJMEM_GetNumData_0x2ff710; // 0x2ff710 - g_ps2RecompiledFunctionTable[523715] = SJMEM_GetNumData_0x2ff710; // 0x2ff714 - g_ps2RecompiledFunctionTable[523716] = SJMEM_GetNumData_0x2ff710; // 0x2ff718 - g_ps2RecompiledFunctionTable[523717] = SJMEM_GetNumData_0x2ff710; // 0x2ff71c - g_ps2RecompiledFunctionTable[523718] = SJMEM_GetNumData_0x2ff710; // 0x2ff720 - g_ps2RecompiledFunctionTable[523719] = SJMEM_GetNumData_0x2ff710; // 0x2ff724 - g_ps2RecompiledFunctionTable[523720] = SJMEM_GetNumData_0x2ff710; // 0x2ff728 - g_ps2RecompiledFunctionTable[523721] = SJMEM_GetNumData_0x2ff710; // 0x2ff72c - g_ps2RecompiledFunctionTable[523722] = SJMEM_GetNumData_0x2ff710; // 0x2ff730 - g_ps2RecompiledFunctionTable[523723] = SJMEM_GetNumData_0x2ff710; // 0x2ff734 - g_ps2RecompiledFunctionTable[523724] = SJMEM_GetNumData_0x2ff710; // 0x2ff738 - g_ps2RecompiledFunctionTable[523725] = SJMEM_GetNumData_0x2ff710; // 0x2ff73c - g_ps2RecompiledFunctionTable[523726] = SJMEM_GetNumData_0x2ff710; // 0x2ff740 - g_ps2RecompiledFunctionTable[523727] = SJMEM_GetNumData_0x2ff710; // 0x2ff744 - g_ps2RecompiledFunctionTable[523728] = SJMEM_GetNumData_0x2ff710; // 0x2ff748 - g_ps2RecompiledFunctionTable[523729] = SJMEM_GetNumData_0x2ff710; // 0x2ff74c - g_ps2RecompiledFunctionTable[523730] = SJMEM_GetNumData_0x2ff710; // 0x2ff750 - g_ps2RecompiledFunctionTable[523731] = SJMEM_GetNumData_0x2ff710; // 0x2ff754 - g_ps2RecompiledFunctionTable[523732] = SJMEM_GetChunk_0x2ff758; // 0x2ff758 - g_ps2RecompiledFunctionTable[523733] = SJMEM_GetChunk_0x2ff758; // 0x2ff75c - g_ps2RecompiledFunctionTable[523734] = SJMEM_GetChunk_0x2ff758; // 0x2ff760 - g_ps2RecompiledFunctionTable[523735] = SJMEM_GetChunk_0x2ff758; // 0x2ff764 - g_ps2RecompiledFunctionTable[523736] = SJMEM_GetChunk_0x2ff758; // 0x2ff768 - g_ps2RecompiledFunctionTable[523737] = SJMEM_GetChunk_0x2ff758; // 0x2ff76c - g_ps2RecompiledFunctionTable[523738] = SJMEM_GetChunk_0x2ff758; // 0x2ff770 - g_ps2RecompiledFunctionTable[523739] = SJMEM_GetChunk_0x2ff758; // 0x2ff774 - g_ps2RecompiledFunctionTable[523740] = SJMEM_GetChunk_0x2ff758; // 0x2ff778 - g_ps2RecompiledFunctionTable[523741] = SJMEM_GetChunk_0x2ff758; // 0x2ff77c - g_ps2RecompiledFunctionTable[523742] = SJMEM_GetChunk_0x2ff758; // 0x2ff780 - g_ps2RecompiledFunctionTable[523743] = SJMEM_GetChunk_0x2ff758; // 0x2ff784 - g_ps2RecompiledFunctionTable[523744] = SJMEM_GetChunk_0x2ff758; // 0x2ff788 - g_ps2RecompiledFunctionTable[523745] = SJMEM_GetChunk_0x2ff758; // 0x2ff78c - g_ps2RecompiledFunctionTable[523746] = SJMEM_GetChunk_0x2ff758; // 0x2ff790 - g_ps2RecompiledFunctionTable[523747] = SJMEM_GetChunk_0x2ff758; // 0x2ff794 - g_ps2RecompiledFunctionTable[523748] = SJMEM_GetChunk_0x2ff758; // 0x2ff798 - g_ps2RecompiledFunctionTable[523749] = SJMEM_GetChunk_0x2ff758; // 0x2ff79c - g_ps2RecompiledFunctionTable[523750] = SJMEM_GetChunk_0x2ff758; // 0x2ff7a0 - g_ps2RecompiledFunctionTable[523751] = SJMEM_GetChunk_0x2ff758; // 0x2ff7a4 - g_ps2RecompiledFunctionTable[523752] = SJMEM_GetChunk_0x2ff758; // 0x2ff7a8 - g_ps2RecompiledFunctionTable[523753] = SJMEM_GetChunk_0x2ff758; // 0x2ff7ac - g_ps2RecompiledFunctionTable[523754] = SJMEM_GetChunk_0x2ff758; // 0x2ff7b0 - g_ps2RecompiledFunctionTable[523755] = SJMEM_GetChunk_0x2ff758; // 0x2ff7b4 - g_ps2RecompiledFunctionTable[523756] = SJMEM_GetChunk_0x2ff758; // 0x2ff7b8 - g_ps2RecompiledFunctionTable[523757] = SJMEM_GetChunk_0x2ff758; // 0x2ff7bc - g_ps2RecompiledFunctionTable[523758] = SJMEM_GetChunk_0x2ff758; // 0x2ff7c0 - g_ps2RecompiledFunctionTable[523759] = SJMEM_GetChunk_0x2ff758; // 0x2ff7c4 - g_ps2RecompiledFunctionTable[523760] = SJMEM_GetChunk_0x2ff758; // 0x2ff7c8 - g_ps2RecompiledFunctionTable[523761] = SJMEM_GetChunk_0x2ff758; // 0x2ff7cc - g_ps2RecompiledFunctionTable[523762] = SJMEM_GetChunk_0x2ff758; // 0x2ff7d0 - g_ps2RecompiledFunctionTable[523763] = SJMEM_GetChunk_0x2ff758; // 0x2ff7d4 - g_ps2RecompiledFunctionTable[523764] = SJMEM_GetChunk_0x2ff758; // 0x2ff7d8 - g_ps2RecompiledFunctionTable[523765] = SJMEM_GetChunk_0x2ff758; // 0x2ff7dc - g_ps2RecompiledFunctionTable[523766] = SJMEM_GetChunk_0x2ff758; // 0x2ff7e0 - g_ps2RecompiledFunctionTable[523767] = SJMEM_GetChunk_0x2ff758; // 0x2ff7e4 - g_ps2RecompiledFunctionTable[523768] = SJMEM_GetChunk_0x2ff758; // 0x2ff7e8 - g_ps2RecompiledFunctionTable[523769] = SJMEM_GetChunk_0x2ff758; // 0x2ff7ec - g_ps2RecompiledFunctionTable[523770] = SJMEM_GetChunk_0x2ff758; // 0x2ff7f0 - g_ps2RecompiledFunctionTable[523771] = SJMEM_GetChunk_0x2ff758; // 0x2ff7f4 - g_ps2RecompiledFunctionTable[523772] = SJMEM_GetChunk_0x2ff758; // 0x2ff7f8 - g_ps2RecompiledFunctionTable[523773] = SJMEM_GetChunk_0x2ff758; // 0x2ff7fc - g_ps2RecompiledFunctionTable[523774] = SJMEM_GetChunk_0x2ff758; // 0x2ff800 - g_ps2RecompiledFunctionTable[523775] = SJMEM_GetChunk_0x2ff758; // 0x2ff804 - g_ps2RecompiledFunctionTable[523776] = SJMEM_GetChunk_0x2ff758; // 0x2ff808 - g_ps2RecompiledFunctionTable[523777] = SJMEM_GetChunk_0x2ff758; // 0x2ff80c - g_ps2RecompiledFunctionTable[523778] = SJMEM_PutChunk_0x2ff810; // 0x2ff810 - g_ps2RecompiledFunctionTable[523779] = SJMEM_PutChunk_0x2ff810; // 0x2ff814 - g_ps2RecompiledFunctionTable[523780] = SJMEM_PutChunk_0x2ff810; // 0x2ff818 - g_ps2RecompiledFunctionTable[523781] = SJMEM_PutChunk_0x2ff810; // 0x2ff81c - g_ps2RecompiledFunctionTable[523782] = SJMEM_PutChunk_0x2ff810; // 0x2ff820 - g_ps2RecompiledFunctionTable[523783] = SJMEM_PutChunk_0x2ff810; // 0x2ff824 - g_ps2RecompiledFunctionTable[523784] = SJMEM_PutChunk_0x2ff810; // 0x2ff828 - g_ps2RecompiledFunctionTable[523785] = SJMEM_PutChunk_0x2ff810; // 0x2ff82c - g_ps2RecompiledFunctionTable[523786] = SJMEM_PutChunk_0x2ff810; // 0x2ff830 - g_ps2RecompiledFunctionTable[523787] = SJMEM_PutChunk_0x2ff810; // 0x2ff834 - g_ps2RecompiledFunctionTable[523788] = SJMEM_PutChunk_0x2ff810; // 0x2ff838 - g_ps2RecompiledFunctionTable[523789] = SJMEM_PutChunk_0x2ff810; // 0x2ff83c - g_ps2RecompiledFunctionTable[523790] = SJMEM_PutChunk_0x2ff810; // 0x2ff840 - g_ps2RecompiledFunctionTable[523791] = SJMEM_PutChunk_0x2ff810; // 0x2ff844 - g_ps2RecompiledFunctionTable[523792] = SJMEM_PutChunk_0x2ff810; // 0x2ff848 - g_ps2RecompiledFunctionTable[523793] = SJMEM_PutChunk_0x2ff810; // 0x2ff84c - g_ps2RecompiledFunctionTable[523794] = SJMEM_PutChunk_0x2ff810; // 0x2ff850 - g_ps2RecompiledFunctionTable[523795] = SJMEM_PutChunk_0x2ff810; // 0x2ff854 - g_ps2RecompiledFunctionTable[523796] = SJMEM_PutChunk_0x2ff810; // 0x2ff858 - g_ps2RecompiledFunctionTable[523797] = SJMEM_PutChunk_0x2ff810; // 0x2ff85c - g_ps2RecompiledFunctionTable[523798] = SJMEM_PutChunk_0x2ff810; // 0x2ff860 - g_ps2RecompiledFunctionTable[523799] = SJMEM_PutChunk_0x2ff810; // 0x2ff864 - g_ps2RecompiledFunctionTable[523800] = SJMEM_PutChunk_0x2ff810; // 0x2ff868 - g_ps2RecompiledFunctionTable[523801] = SJMEM_PutChunk_0x2ff810; // 0x2ff86c - g_ps2RecompiledFunctionTable[523802] = SJMEM_PutChunk_0x2ff810; // 0x2ff870 - g_ps2RecompiledFunctionTable[523803] = SJMEM_PutChunk_0x2ff810; // 0x2ff874 - g_ps2RecompiledFunctionTable[523804] = SJMEM_PutChunk_0x2ff810; // 0x2ff878 - g_ps2RecompiledFunctionTable[523805] = SJMEM_PutChunk_0x2ff810; // 0x2ff87c - g_ps2RecompiledFunctionTable[523806] = SJMEM_PutChunk_0x2ff810; // 0x2ff880 - g_ps2RecompiledFunctionTable[523807] = SJMEM_PutChunk_0x2ff810; // 0x2ff884 - g_ps2RecompiledFunctionTable[523808] = SJMEM_PutChunk_0x2ff810; // 0x2ff888 - g_ps2RecompiledFunctionTable[523809] = SJMEM_PutChunk_0x2ff810; // 0x2ff88c - g_ps2RecompiledFunctionTable[523810] = SJMEM_PutChunk_0x2ff810; // 0x2ff890 - g_ps2RecompiledFunctionTable[523811] = SJMEM_PutChunk_0x2ff810; // 0x2ff894 - g_ps2RecompiledFunctionTable[523812] = SJMEM_PutChunk_0x2ff810; // 0x2ff898 - g_ps2RecompiledFunctionTable[523813] = SJMEM_PutChunk_0x2ff810; // 0x2ff89c - g_ps2RecompiledFunctionTable[523814] = SJMEM_PutChunk_0x2ff810; // 0x2ff8a0 - g_ps2RecompiledFunctionTable[523815] = SJMEM_PutChunk_0x2ff810; // 0x2ff8a4 - g_ps2RecompiledFunctionTable[523816] = SJMEM_UngetChunk_0x2ff8a8; // 0x2ff8a8 - g_ps2RecompiledFunctionTable[523817] = SJMEM_UngetChunk_0x2ff8a8; // 0x2ff8ac - g_ps2RecompiledFunctionTable[523818] = SJMEM_UngetChunk_0x2ff8a8; // 0x2ff8b0 - g_ps2RecompiledFunctionTable[523819] = SJMEM_UngetChunk_0x2ff8a8; // 0x2ff8b4 - g_ps2RecompiledFunctionTable[523820] = SJMEM_UngetChunk_0x2ff8a8; // 0x2ff8b8 - g_ps2RecompiledFunctionTable[523821] = SJMEM_UngetChunk_0x2ff8a8; // 0x2ff8bc - g_ps2RecompiledFunctionTable[523822] = SJMEM_UngetChunk_0x2ff8a8; // 0x2ff8c0 - g_ps2RecompiledFunctionTable[523823] = SJMEM_UngetChunk_0x2ff8a8; // 0x2ff8c4 - g_ps2RecompiledFunctionTable[523824] = SJMEM_UngetChunk_0x2ff8a8; // 0x2ff8c8 - g_ps2RecompiledFunctionTable[523825] = SJMEM_UngetChunk_0x2ff8a8; // 0x2ff8cc - g_ps2RecompiledFunctionTable[523826] = SJMEM_UngetChunk_0x2ff8a8; // 0x2ff8d0 - g_ps2RecompiledFunctionTable[523827] = SJMEM_UngetChunk_0x2ff8a8; // 0x2ff8d4 - g_ps2RecompiledFunctionTable[523828] = SJMEM_UngetChunk_0x2ff8a8; // 0x2ff8d8 - g_ps2RecompiledFunctionTable[523829] = SJMEM_UngetChunk_0x2ff8a8; // 0x2ff8dc - g_ps2RecompiledFunctionTable[523830] = SJMEM_UngetChunk_0x2ff8a8; // 0x2ff8e0 - g_ps2RecompiledFunctionTable[523831] = SJMEM_UngetChunk_0x2ff8a8; // 0x2ff8e4 - g_ps2RecompiledFunctionTable[523832] = SJMEM_UngetChunk_0x2ff8a8; // 0x2ff8e8 - g_ps2RecompiledFunctionTable[523833] = SJMEM_UngetChunk_0x2ff8a8; // 0x2ff8ec - g_ps2RecompiledFunctionTable[523834] = SJMEM_UngetChunk_0x2ff8a8; // 0x2ff8f0 - g_ps2RecompiledFunctionTable[523835] = SJMEM_UngetChunk_0x2ff8a8; // 0x2ff8f4 - g_ps2RecompiledFunctionTable[523836] = SJMEM_UngetChunk_0x2ff8a8; // 0x2ff8f8 - g_ps2RecompiledFunctionTable[523837] = SJMEM_UngetChunk_0x2ff8a8; // 0x2ff8fc - g_ps2RecompiledFunctionTable[523838] = SJMEM_UngetChunk_0x2ff8a8; // 0x2ff900 - g_ps2RecompiledFunctionTable[523839] = SJMEM_UngetChunk_0x2ff8a8; // 0x2ff904 - g_ps2RecompiledFunctionTable[523840] = SJMEM_UngetChunk_0x2ff8a8; // 0x2ff908 - g_ps2RecompiledFunctionTable[523841] = SJMEM_UngetChunk_0x2ff8a8; // 0x2ff90c - g_ps2RecompiledFunctionTable[523842] = SJMEM_UngetChunk_0x2ff8a8; // 0x2ff910 - g_ps2RecompiledFunctionTable[523843] = SJMEM_UngetChunk_0x2ff8a8; // 0x2ff914 - g_ps2RecompiledFunctionTable[523844] = SJMEM_UngetChunk_0x2ff8a8; // 0x2ff918 - g_ps2RecompiledFunctionTable[523845] = SJMEM_UngetChunk_0x2ff8a8; // 0x2ff91c - g_ps2RecompiledFunctionTable[523846] = SJMEM_UngetChunk_0x2ff8a8; // 0x2ff920 - g_ps2RecompiledFunctionTable[523847] = SJMEM_UngetChunk_0x2ff8a8; // 0x2ff924 - g_ps2RecompiledFunctionTable[523848] = SJMEM_UngetChunk_0x2ff8a8; // 0x2ff928 - g_ps2RecompiledFunctionTable[523849] = SJMEM_UngetChunk_0x2ff8a8; // 0x2ff92c - g_ps2RecompiledFunctionTable[523850] = SJMEM_UngetChunk_0x2ff8a8; // 0x2ff930 - g_ps2RecompiledFunctionTable[523851] = SJMEM_UngetChunk_0x2ff8a8; // 0x2ff934 - g_ps2RecompiledFunctionTable[523852] = SJMEM_UngetChunk_0x2ff8a8; // 0x2ff938 - g_ps2RecompiledFunctionTable[523853] = SJMEM_UngetChunk_0x2ff8a8; // 0x2ff93c - g_ps2RecompiledFunctionTable[523854] = SJMEM_UngetChunk_0x2ff8a8; // 0x2ff940 - g_ps2RecompiledFunctionTable[523855] = SJMEM_UngetChunk_0x2ff8a8; // 0x2ff944 - g_ps2RecompiledFunctionTable[523856] = SJMEM_UngetChunk_0x2ff8a8; // 0x2ff948 - g_ps2RecompiledFunctionTable[523857] = SJMEM_UngetChunk_0x2ff8a8; // 0x2ff94c - g_ps2RecompiledFunctionTable[523858] = SJMEM_UngetChunk_0x2ff8a8; // 0x2ff950 - g_ps2RecompiledFunctionTable[523859] = SJMEM_UngetChunk_0x2ff8a8; // 0x2ff954 - g_ps2RecompiledFunctionTable[523860] = SJMEM_UngetChunk_0x2ff8a8; // 0x2ff958 - g_ps2RecompiledFunctionTable[523861] = SJMEM_UngetChunk_0x2ff8a8; // 0x2ff95c - g_ps2RecompiledFunctionTable[523862] = SJMEM_UngetChunk_0x2ff8a8; // 0x2ff960 - g_ps2RecompiledFunctionTable[523863] = SJMEM_UngetChunk_0x2ff8a8; // 0x2ff964 - g_ps2RecompiledFunctionTable[523864] = SJMEM_UngetChunk_0x2ff8a8; // 0x2ff968 - g_ps2RecompiledFunctionTable[523865] = SJMEM_UngetChunk_0x2ff8a8; // 0x2ff96c - g_ps2RecompiledFunctionTable[523866] = SJMEM_UngetChunk_0x2ff8a8; // 0x2ff970 - g_ps2RecompiledFunctionTable[523867] = SJMEM_UngetChunk_0x2ff8a8; // 0x2ff974 - g_ps2RecompiledFunctionTable[523868] = SJMEM_UngetChunk_0x2ff8a8; // 0x2ff978 - g_ps2RecompiledFunctionTable[523869] = SJMEM_UngetChunk_0x2ff8a8; // 0x2ff97c - g_ps2RecompiledFunctionTable[523870] = SJMEM_UngetChunk_0x2ff8a8; // 0x2ff980 - g_ps2RecompiledFunctionTable[523871] = SJMEM_UngetChunk_0x2ff8a8; // 0x2ff984 - g_ps2RecompiledFunctionTable[523872] = SJMEM_UngetChunk_0x2ff8a8; // 0x2ff988 - g_ps2RecompiledFunctionTable[523873] = SJMEM_UngetChunk_0x2ff8a8; // 0x2ff98c - g_ps2RecompiledFunctionTable[523874] = SJMEM_UngetChunk_0x2ff8a8; // 0x2ff990 - g_ps2RecompiledFunctionTable[523875] = SJMEM_UngetChunk_0x2ff8a8; // 0x2ff994 - g_ps2RecompiledFunctionTable[523876] = SJMEM_UngetChunk_0x2ff8a8; // 0x2ff998 - g_ps2RecompiledFunctionTable[523877] = SJMEM_UngetChunk_0x2ff8a8; // 0x2ff99c - g_ps2RecompiledFunctionTable[523878] = SJMEM_UngetChunk_0x2ff8a8; // 0x2ff9a0 - g_ps2RecompiledFunctionTable[523880] = SJMEM_IsGetChunk_0x2ff9a8; // 0x2ff9a8 - g_ps2RecompiledFunctionTable[523881] = SJMEM_IsGetChunk_0x2ff9a8; // 0x2ff9ac - g_ps2RecompiledFunctionTable[523882] = SJMEM_IsGetChunk_0x2ff9a8; // 0x2ff9b0 - g_ps2RecompiledFunctionTable[523883] = SJMEM_IsGetChunk_0x2ff9a8; // 0x2ff9b4 - g_ps2RecompiledFunctionTable[523884] = SJMEM_IsGetChunk_0x2ff9a8; // 0x2ff9b8 - g_ps2RecompiledFunctionTable[523885] = SJMEM_IsGetChunk_0x2ff9a8; // 0x2ff9bc - g_ps2RecompiledFunctionTable[523886] = SJMEM_IsGetChunk_0x2ff9a8; // 0x2ff9c0 - g_ps2RecompiledFunctionTable[523887] = SJMEM_IsGetChunk_0x2ff9a8; // 0x2ff9c4 - g_ps2RecompiledFunctionTable[523888] = SJMEM_IsGetChunk_0x2ff9a8; // 0x2ff9c8 - g_ps2RecompiledFunctionTable[523889] = SJMEM_IsGetChunk_0x2ff9a8; // 0x2ff9cc - g_ps2RecompiledFunctionTable[523890] = SJMEM_IsGetChunk_0x2ff9a8; // 0x2ff9d0 - g_ps2RecompiledFunctionTable[523891] = SJMEM_IsGetChunk_0x2ff9a8; // 0x2ff9d4 - g_ps2RecompiledFunctionTable[523892] = SJMEM_IsGetChunk_0x2ff9a8; // 0x2ff9d8 - g_ps2RecompiledFunctionTable[523893] = SJMEM_IsGetChunk_0x2ff9a8; // 0x2ff9dc - g_ps2RecompiledFunctionTable[523894] = SJMEM_IsGetChunk_0x2ff9a8; // 0x2ff9e0 - g_ps2RecompiledFunctionTable[523895] = SJMEM_IsGetChunk_0x2ff9a8; // 0x2ff9e4 - g_ps2RecompiledFunctionTable[523896] = SJMEM_IsGetChunk_0x2ff9a8; // 0x2ff9e8 - g_ps2RecompiledFunctionTable[523897] = SJMEM_IsGetChunk_0x2ff9a8; // 0x2ff9ec - g_ps2RecompiledFunctionTable[523898] = SJMEM_IsGetChunk_0x2ff9a8; // 0x2ff9f0 - g_ps2RecompiledFunctionTable[523899] = SJMEM_IsGetChunk_0x2ff9a8; // 0x2ff9f4 - g_ps2RecompiledFunctionTable[523900] = SJMEM_IsGetChunk_0x2ff9a8; // 0x2ff9f8 - g_ps2RecompiledFunctionTable[523901] = SJMEM_IsGetChunk_0x2ff9a8; // 0x2ff9fc - g_ps2RecompiledFunctionTable[523902] = SJMEM_IsGetChunk_0x2ff9a8; // 0x2ffa00 - g_ps2RecompiledFunctionTable[523903] = SJMEM_IsGetChunk_0x2ff9a8; // 0x2ffa04 - g_ps2RecompiledFunctionTable[523904] = SJMEM_IsGetChunk_0x2ff9a8; // 0x2ffa08 - g_ps2RecompiledFunctionTable[523905] = SJMEM_IsGetChunk_0x2ff9a8; // 0x2ffa0c - g_ps2RecompiledFunctionTable[523906] = SJMEM_IsGetChunk_0x2ff9a8; // 0x2ffa10 - g_ps2RecompiledFunctionTable[523907] = SJMEM_IsGetChunk_0x2ff9a8; // 0x2ffa14 - g_ps2RecompiledFunctionTable[523908] = SJMEM_IsGetChunk_0x2ff9a8; // 0x2ffa18 - g_ps2RecompiledFunctionTable[523909] = SJMEM_IsGetChunk_0x2ff9a8; // 0x2ffa1c - g_ps2RecompiledFunctionTable[523910] = SJMEM_IsGetChunk_0x2ff9a8; // 0x2ffa20 - g_ps2RecompiledFunctionTable[523911] = SJMEM_IsGetChunk_0x2ff9a8; // 0x2ffa24 - g_ps2RecompiledFunctionTable[523912] = SJMEM_IsGetChunk_0x2ff9a8; // 0x2ffa28 - g_ps2RecompiledFunctionTable[523913] = SJMEM_IsGetChunk_0x2ff9a8; // 0x2ffa2c - g_ps2RecompiledFunctionTable[523914] = SJMEM_IsGetChunk_0x2ff9a8; // 0x2ffa30 - g_ps2RecompiledFunctionTable[523915] = SJMEM_IsGetChunk_0x2ff9a8; // 0x2ffa34 - g_ps2RecompiledFunctionTable[523916] = SJMEM_IsGetChunk_0x2ff9a8; // 0x2ffa38 - g_ps2RecompiledFunctionTable[523917] = SJMEM_IsGetChunk_0x2ff9a8; // 0x2ffa3c - g_ps2RecompiledFunctionTable[523918] = SJMEM_GetBufPtr_0x2ffa40; // 0x2ffa40 - g_ps2RecompiledFunctionTable[523920] = SJMEM_GetBufSize_0x2ffa48; // 0x2ffa48 - g_ps2RecompiledFunctionTable[523922] = SJRBF_Error_0x2ffa50; // 0x2ffa50 - g_ps2RecompiledFunctionTable[523930] = SJRBF_Init_0x2ffa70; // 0x2ffa70 - g_ps2RecompiledFunctionTable[523939] = SJRBF_Init_0x2ffa70; // 0x2ffa94 - g_ps2RecompiledFunctionTable[523946] = SJRBF_Finish_0x2ffab0; // 0x2ffab0 - g_ps2RecompiledFunctionTable[523958] = SJRBF_Create_0x2ffae0; // 0x2ffae0 - g_ps2RecompiledFunctionTable[523968] = SJRBF_Create_0x2ffae0; // 0x2ffb08 - g_ps2RecompiledFunctionTable[523976] = SJRBF_Create_0x2ffae0; // 0x2ffb28 - g_ps2RecompiledFunctionTable[524007] = SJRBF_Create_0x2ffae0; // 0x2ffba4 - g_ps2RecompiledFunctionTable[524009] = SJRBF_Create_0x2ffae0; // 0x2ffbac - g_ps2RecompiledFunctionTable[524018] = SJRBF_Destroy_0x2ffbd0; // 0x2ffbd0 - g_ps2RecompiledFunctionTable[524023] = SJRBF_Destroy_0x2ffbd0; // 0x2ffbe4 - g_ps2RecompiledFunctionTable[524028] = SJRBF_Destroy_0x2ffbd0; // 0x2ffbf8 - g_ps2RecompiledFunctionTable[524034] = SJRBF_GetUuid_0x2ffc10; // 0x2ffc10 - g_ps2RecompiledFunctionTable[524036] = SJRBF_EntryErrFunc_0x2ffc18; // 0x2ffc18 - g_ps2RecompiledFunctionTable[524040] = SJRBF_Reset_0x2ffc28; // 0x2ffc28 - g_ps2RecompiledFunctionTable[524046] = SJRBF_GetNumData_0x2ffc40; // 0x2ffc40 - g_ps2RecompiledFunctionTable[524047] = SJRBF_GetNumData_0x2ffc40; // 0x2ffc44 - g_ps2RecompiledFunctionTable[524048] = SJRBF_GetNumData_0x2ffc40; // 0x2ffc48 - g_ps2RecompiledFunctionTable[524049] = SJRBF_GetNumData_0x2ffc40; // 0x2ffc4c - g_ps2RecompiledFunctionTable[524050] = SJRBF_GetNumData_0x2ffc40; // 0x2ffc50 - g_ps2RecompiledFunctionTable[524051] = SJRBF_GetNumData_0x2ffc40; // 0x2ffc54 - g_ps2RecompiledFunctionTable[524052] = SJRBF_GetNumData_0x2ffc40; // 0x2ffc58 - g_ps2RecompiledFunctionTable[524053] = SJRBF_GetNumData_0x2ffc40; // 0x2ffc5c - g_ps2RecompiledFunctionTable[524054] = SJRBF_GetNumData_0x2ffc40; // 0x2ffc60 - g_ps2RecompiledFunctionTable[524055] = SJRBF_GetNumData_0x2ffc40; // 0x2ffc64 - g_ps2RecompiledFunctionTable[524056] = SJRBF_GetNumData_0x2ffc40; // 0x2ffc68 - g_ps2RecompiledFunctionTable[524057] = SJRBF_GetNumData_0x2ffc40; // 0x2ffc6c - g_ps2RecompiledFunctionTable[524058] = SJRBF_GetNumData_0x2ffc40; // 0x2ffc70 - g_ps2RecompiledFunctionTable[524059] = SJRBF_GetNumData_0x2ffc40; // 0x2ffc74 - g_ps2RecompiledFunctionTable[524060] = SJRBF_GetNumData_0x2ffc40; // 0x2ffc78 - g_ps2RecompiledFunctionTable[524061] = SJRBF_GetNumData_0x2ffc40; // 0x2ffc7c - g_ps2RecompiledFunctionTable[524062] = SJRBF_GetNumData_0x2ffc40; // 0x2ffc80 - g_ps2RecompiledFunctionTable[524063] = SJRBF_GetNumData_0x2ffc40; // 0x2ffc84 - g_ps2RecompiledFunctionTable[524064] = SJRBF_GetNumData_0x2ffc40; // 0x2ffc88 - g_ps2RecompiledFunctionTable[524066] = SJRBF_GetChunk_0x2ffc90; // 0x2ffc90 - g_ps2RecompiledFunctionTable[524067] = SJRBF_GetChunk_0x2ffc90; // 0x2ffc94 - g_ps2RecompiledFunctionTable[524068] = SJRBF_GetChunk_0x2ffc90; // 0x2ffc98 - g_ps2RecompiledFunctionTable[524069] = SJRBF_GetChunk_0x2ffc90; // 0x2ffc9c - g_ps2RecompiledFunctionTable[524070] = SJRBF_GetChunk_0x2ffc90; // 0x2ffca0 - g_ps2RecompiledFunctionTable[524071] = SJRBF_GetChunk_0x2ffc90; // 0x2ffca4 - g_ps2RecompiledFunctionTable[524072] = SJRBF_GetChunk_0x2ffc90; // 0x2ffca8 - g_ps2RecompiledFunctionTable[524073] = SJRBF_GetChunk_0x2ffc90; // 0x2ffcac - g_ps2RecompiledFunctionTable[524074] = SJRBF_GetChunk_0x2ffc90; // 0x2ffcb0 - g_ps2RecompiledFunctionTable[524075] = SJRBF_GetChunk_0x2ffc90; // 0x2ffcb4 - g_ps2RecompiledFunctionTable[524076] = SJRBF_GetChunk_0x2ffc90; // 0x2ffcb8 - g_ps2RecompiledFunctionTable[524077] = SJRBF_GetChunk_0x2ffc90; // 0x2ffcbc - g_ps2RecompiledFunctionTable[524078] = SJRBF_GetChunk_0x2ffc90; // 0x2ffcc0 - g_ps2RecompiledFunctionTable[524079] = SJRBF_GetChunk_0x2ffc90; // 0x2ffcc4 - g_ps2RecompiledFunctionTable[524080] = SJRBF_GetChunk_0x2ffc90; // 0x2ffcc8 - g_ps2RecompiledFunctionTable[524081] = SJRBF_GetChunk_0x2ffc90; // 0x2ffccc - g_ps2RecompiledFunctionTable[524082] = SJRBF_GetChunk_0x2ffc90; // 0x2ffcd0 - g_ps2RecompiledFunctionTable[524083] = SJRBF_GetChunk_0x2ffc90; // 0x2ffcd4 - g_ps2RecompiledFunctionTable[524084] = SJRBF_GetChunk_0x2ffc90; // 0x2ffcd8 - g_ps2RecompiledFunctionTable[524085] = SJRBF_GetChunk_0x2ffc90; // 0x2ffcdc - g_ps2RecompiledFunctionTable[524086] = SJRBF_GetChunk_0x2ffc90; // 0x2ffce0 - g_ps2RecompiledFunctionTable[524087] = SJRBF_GetChunk_0x2ffc90; // 0x2ffce4 - g_ps2RecompiledFunctionTable[524088] = SJRBF_GetChunk_0x2ffc90; // 0x2ffce8 - g_ps2RecompiledFunctionTable[524089] = SJRBF_GetChunk_0x2ffc90; // 0x2ffcec - g_ps2RecompiledFunctionTable[524090] = SJRBF_GetChunk_0x2ffc90; // 0x2ffcf0 - g_ps2RecompiledFunctionTable[524091] = SJRBF_GetChunk_0x2ffc90; // 0x2ffcf4 - g_ps2RecompiledFunctionTable[524092] = SJRBF_GetChunk_0x2ffc90; // 0x2ffcf8 - g_ps2RecompiledFunctionTable[524093] = SJRBF_GetChunk_0x2ffc90; // 0x2ffcfc - g_ps2RecompiledFunctionTable[524094] = SJRBF_GetChunk_0x2ffc90; // 0x2ffd00 - g_ps2RecompiledFunctionTable[524095] = SJRBF_GetChunk_0x2ffc90; // 0x2ffd04 - g_ps2RecompiledFunctionTable[524096] = SJRBF_GetChunk_0x2ffc90; // 0x2ffd08 - g_ps2RecompiledFunctionTable[524097] = SJRBF_GetChunk_0x2ffc90; // 0x2ffd0c - g_ps2RecompiledFunctionTable[524098] = SJRBF_GetChunk_0x2ffc90; // 0x2ffd10 - g_ps2RecompiledFunctionTable[524099] = SJRBF_GetChunk_0x2ffc90; // 0x2ffd14 - g_ps2RecompiledFunctionTable[524100] = SJRBF_GetChunk_0x2ffc90; // 0x2ffd18 - g_ps2RecompiledFunctionTable[524101] = SJRBF_GetChunk_0x2ffc90; // 0x2ffd1c - g_ps2RecompiledFunctionTable[524102] = SJRBF_GetChunk_0x2ffc90; // 0x2ffd20 - g_ps2RecompiledFunctionTable[524103] = SJRBF_GetChunk_0x2ffc90; // 0x2ffd24 - g_ps2RecompiledFunctionTable[524104] = SJRBF_GetChunk_0x2ffc90; // 0x2ffd28 - g_ps2RecompiledFunctionTable[524105] = SJRBF_GetChunk_0x2ffc90; // 0x2ffd2c - g_ps2RecompiledFunctionTable[524106] = SJRBF_GetChunk_0x2ffc90; // 0x2ffd30 - g_ps2RecompiledFunctionTable[524107] = SJRBF_GetChunk_0x2ffc90; // 0x2ffd34 - g_ps2RecompiledFunctionTable[524108] = SJRBF_GetChunk_0x2ffc90; // 0x2ffd38 - g_ps2RecompiledFunctionTable[524109] = SJRBF_GetChunk_0x2ffc90; // 0x2ffd3c - g_ps2RecompiledFunctionTable[524110] = SJRBF_GetChunk_0x2ffc90; // 0x2ffd40 - g_ps2RecompiledFunctionTable[524111] = SJRBF_GetChunk_0x2ffc90; // 0x2ffd44 - g_ps2RecompiledFunctionTable[524112] = SJRBF_GetChunk_0x2ffc90; // 0x2ffd48 - g_ps2RecompiledFunctionTable[524113] = SJRBF_GetChunk_0x2ffc90; // 0x2ffd4c - g_ps2RecompiledFunctionTable[524114] = SJRBF_GetChunk_0x2ffc90; // 0x2ffd50 - g_ps2RecompiledFunctionTable[524115] = SJRBF_GetChunk_0x2ffc90; // 0x2ffd54 - g_ps2RecompiledFunctionTable[524116] = SJRBF_GetChunk_0x2ffc90; // 0x2ffd58 - g_ps2RecompiledFunctionTable[524117] = SJRBF_GetChunk_0x2ffc90; // 0x2ffd5c - g_ps2RecompiledFunctionTable[524118] = SJRBF_GetChunk_0x2ffc90; // 0x2ffd60 - g_ps2RecompiledFunctionTable[524119] = SJRBF_GetChunk_0x2ffc90; // 0x2ffd64 - g_ps2RecompiledFunctionTable[524120] = SJRBF_GetChunk_0x2ffc90; // 0x2ffd68 - g_ps2RecompiledFunctionTable[524121] = SJRBF_GetChunk_0x2ffc90; // 0x2ffd6c - g_ps2RecompiledFunctionTable[524122] = SJRBF_GetChunk_0x2ffc90; // 0x2ffd70 - g_ps2RecompiledFunctionTable[524123] = SJRBF_GetChunk_0x2ffc90; // 0x2ffd74 - g_ps2RecompiledFunctionTable[524124] = SJRBF_GetChunk_0x2ffc90; // 0x2ffd78 - g_ps2RecompiledFunctionTable[524125] = SJRBF_GetChunk_0x2ffc90; // 0x2ffd7c - g_ps2RecompiledFunctionTable[524126] = SJRBF_GetChunk_0x2ffc90; // 0x2ffd80 - g_ps2RecompiledFunctionTable[524127] = SJRBF_GetChunk_0x2ffc90; // 0x2ffd84 - g_ps2RecompiledFunctionTable[524128] = SJRBF_GetChunk_0x2ffc90; // 0x2ffd88 - g_ps2RecompiledFunctionTable[524129] = SJRBF_GetChunk_0x2ffc90; // 0x2ffd8c - g_ps2RecompiledFunctionTable[524130] = SJRBF_GetChunk_0x2ffc90; // 0x2ffd90 - g_ps2RecompiledFunctionTable[524131] = SJRBF_GetChunk_0x2ffc90; // 0x2ffd94 - g_ps2RecompiledFunctionTable[524132] = SJRBF_GetChunk_0x2ffc90; // 0x2ffd98 - g_ps2RecompiledFunctionTable[524133] = SJRBF_GetChunk_0x2ffc90; // 0x2ffd9c - g_ps2RecompiledFunctionTable[524134] = SJRBF_GetChunk_0x2ffc90; // 0x2ffda0 - g_ps2RecompiledFunctionTable[524135] = SJRBF_GetChunk_0x2ffc90; // 0x2ffda4 - g_ps2RecompiledFunctionTable[524136] = SJRBF_GetChunk_0x2ffc90; // 0x2ffda8 - g_ps2RecompiledFunctionTable[524137] = SJRBF_GetChunk_0x2ffc90; // 0x2ffdac - g_ps2RecompiledFunctionTable[524138] = SJRBF_GetChunk_0x2ffc90; // 0x2ffdb0 - g_ps2RecompiledFunctionTable[524139] = SJRBF_GetChunk_0x2ffc90; // 0x2ffdb4 - g_ps2RecompiledFunctionTable[524140] = SJRBF_GetChunk_0x2ffc90; // 0x2ffdb8 - g_ps2RecompiledFunctionTable[524141] = SJRBF_GetChunk_0x2ffc90; // 0x2ffdbc - g_ps2RecompiledFunctionTable[524142] = SJRBF_GetChunk_0x2ffc90; // 0x2ffdc0 - g_ps2RecompiledFunctionTable[524143] = SJRBF_GetChunk_0x2ffc90; // 0x2ffdc4 - g_ps2RecompiledFunctionTable[524144] = SJRBF_GetChunk_0x2ffc90; // 0x2ffdc8 - g_ps2RecompiledFunctionTable[524145] = SJRBF_GetChunk_0x2ffc90; // 0x2ffdcc - g_ps2RecompiledFunctionTable[524146] = SJRBF_GetChunk_0x2ffc90; // 0x2ffdd0 - g_ps2RecompiledFunctionTable[524147] = SJRBF_GetChunk_0x2ffc90; // 0x2ffdd4 - g_ps2RecompiledFunctionTable[524148] = SJRBF_PutChunk_0x2ffdd8; // 0x2ffdd8 - g_ps2RecompiledFunctionTable[524149] = SJRBF_PutChunk_0x2ffdd8; // 0x2ffddc - g_ps2RecompiledFunctionTable[524150] = SJRBF_PutChunk_0x2ffdd8; // 0x2ffde0 - g_ps2RecompiledFunctionTable[524151] = SJRBF_PutChunk_0x2ffdd8; // 0x2ffde4 - g_ps2RecompiledFunctionTable[524152] = SJRBF_PutChunk_0x2ffdd8; // 0x2ffde8 - g_ps2RecompiledFunctionTable[524153] = SJRBF_PutChunk_0x2ffdd8; // 0x2ffdec - g_ps2RecompiledFunctionTable[524154] = SJRBF_PutChunk_0x2ffdd8; // 0x2ffdf0 - g_ps2RecompiledFunctionTable[524155] = SJRBF_PutChunk_0x2ffdd8; // 0x2ffdf4 - g_ps2RecompiledFunctionTable[524156] = SJRBF_PutChunk_0x2ffdd8; // 0x2ffdf8 - g_ps2RecompiledFunctionTable[524157] = SJRBF_PutChunk_0x2ffdd8; // 0x2ffdfc - g_ps2RecompiledFunctionTable[524158] = SJRBF_PutChunk_0x2ffdd8; // 0x2ffe00 - g_ps2RecompiledFunctionTable[524159] = SJRBF_PutChunk_0x2ffdd8; // 0x2ffe04 - g_ps2RecompiledFunctionTable[524160] = SJRBF_PutChunk_0x2ffdd8; // 0x2ffe08 - g_ps2RecompiledFunctionTable[524161] = SJRBF_PutChunk_0x2ffdd8; // 0x2ffe0c - g_ps2RecompiledFunctionTable[524162] = SJRBF_PutChunk_0x2ffdd8; // 0x2ffe10 - g_ps2RecompiledFunctionTable[524163] = SJRBF_PutChunk_0x2ffdd8; // 0x2ffe14 - g_ps2RecompiledFunctionTable[524164] = SJRBF_PutChunk_0x2ffdd8; // 0x2ffe18 - g_ps2RecompiledFunctionTable[524165] = SJRBF_PutChunk_0x2ffdd8; // 0x2ffe1c - g_ps2RecompiledFunctionTable[524166] = SJRBF_PutChunk_0x2ffdd8; // 0x2ffe20 - g_ps2RecompiledFunctionTable[524167] = SJRBF_PutChunk_0x2ffdd8; // 0x2ffe24 - g_ps2RecompiledFunctionTable[524168] = SJRBF_PutChunk_0x2ffdd8; // 0x2ffe28 - g_ps2RecompiledFunctionTable[524169] = SJRBF_PutChunk_0x2ffdd8; // 0x2ffe2c - g_ps2RecompiledFunctionTable[524170] = SJRBF_PutChunk_0x2ffdd8; // 0x2ffe30 - g_ps2RecompiledFunctionTable[524171] = SJRBF_PutChunk_0x2ffdd8; // 0x2ffe34 - g_ps2RecompiledFunctionTable[524172] = SJRBF_PutChunk_0x2ffdd8; // 0x2ffe38 - g_ps2RecompiledFunctionTable[524173] = SJRBF_PutChunk_0x2ffdd8; // 0x2ffe3c - g_ps2RecompiledFunctionTable[524174] = SJRBF_PutChunk_0x2ffdd8; // 0x2ffe40 - g_ps2RecompiledFunctionTable[524175] = SJRBF_PutChunk_0x2ffdd8; // 0x2ffe44 - g_ps2RecompiledFunctionTable[524176] = SJRBF_PutChunk_0x2ffdd8; // 0x2ffe48 - g_ps2RecompiledFunctionTable[524177] = SJRBF_PutChunk_0x2ffdd8; // 0x2ffe4c - g_ps2RecompiledFunctionTable[524178] = SJRBF_PutChunk_0x2ffdd8; // 0x2ffe50 - g_ps2RecompiledFunctionTable[524179] = SJRBF_PutChunk_0x2ffdd8; // 0x2ffe54 - g_ps2RecompiledFunctionTable[524180] = SJRBF_PutChunk_0x2ffdd8; // 0x2ffe58 - g_ps2RecompiledFunctionTable[524181] = SJRBF_PutChunk_0x2ffdd8; // 0x2ffe5c - g_ps2RecompiledFunctionTable[524182] = SJRBF_PutChunk_0x2ffdd8; // 0x2ffe60 - g_ps2RecompiledFunctionTable[524183] = SJRBF_PutChunk_0x2ffdd8; // 0x2ffe64 - g_ps2RecompiledFunctionTable[524184] = SJRBF_PutChunk_0x2ffdd8; // 0x2ffe68 - g_ps2RecompiledFunctionTable[524185] = SJRBF_PutChunk_0x2ffdd8; // 0x2ffe6c - g_ps2RecompiledFunctionTable[524186] = SJRBF_PutChunk_0x2ffdd8; // 0x2ffe70 - g_ps2RecompiledFunctionTable[524187] = SJRBF_PutChunk_0x2ffdd8; // 0x2ffe74 - g_ps2RecompiledFunctionTable[524188] = SJRBF_PutChunk_0x2ffdd8; // 0x2ffe78 - g_ps2RecompiledFunctionTable[524189] = SJRBF_PutChunk_0x2ffdd8; // 0x2ffe7c - g_ps2RecompiledFunctionTable[524190] = SJRBF_PutChunk_0x2ffdd8; // 0x2ffe80 - g_ps2RecompiledFunctionTable[524191] = SJRBF_PutChunk_0x2ffdd8; // 0x2ffe84 - g_ps2RecompiledFunctionTable[524192] = SJRBF_PutChunk_0x2ffdd8; // 0x2ffe88 - g_ps2RecompiledFunctionTable[524193] = SJRBF_PutChunk_0x2ffdd8; // 0x2ffe8c - g_ps2RecompiledFunctionTable[524194] = SJRBF_PutChunk_0x2ffdd8; // 0x2ffe90 - g_ps2RecompiledFunctionTable[524195] = SJRBF_PutChunk_0x2ffdd8; // 0x2ffe94 - g_ps2RecompiledFunctionTable[524196] = SJRBF_PutChunk_0x2ffdd8; // 0x2ffe98 - g_ps2RecompiledFunctionTable[524197] = SJRBF_PutChunk_0x2ffdd8; // 0x2ffe9c - g_ps2RecompiledFunctionTable[524198] = SJRBF_PutChunk_0x2ffdd8; // 0x2ffea0 - g_ps2RecompiledFunctionTable[524199] = SJRBF_PutChunk_0x2ffdd8; // 0x2ffea4 - g_ps2RecompiledFunctionTable[524200] = SJRBF_PutChunk_0x2ffdd8; // 0x2ffea8 - g_ps2RecompiledFunctionTable[524201] = SJRBF_PutChunk_0x2ffdd8; // 0x2ffeac - g_ps2RecompiledFunctionTable[524202] = SJRBF_PutChunk_0x2ffdd8; // 0x2ffeb0 - g_ps2RecompiledFunctionTable[524203] = SJRBF_PutChunk_0x2ffdd8; // 0x2ffeb4 - g_ps2RecompiledFunctionTable[524204] = SJRBF_PutChunk_0x2ffdd8; // 0x2ffeb8 - g_ps2RecompiledFunctionTable[524205] = SJRBF_PutChunk_0x2ffdd8; // 0x2ffebc - g_ps2RecompiledFunctionTable[524206] = SJRBF_PutChunk_0x2ffdd8; // 0x2ffec0 - g_ps2RecompiledFunctionTable[524207] = SJRBF_PutChunk_0x2ffdd8; // 0x2ffec4 - g_ps2RecompiledFunctionTable[524208] = SJRBF_PutChunk_0x2ffdd8; // 0x2ffec8 - g_ps2RecompiledFunctionTable[524209] = SJRBF_PutChunk_0x2ffdd8; // 0x2ffecc - g_ps2RecompiledFunctionTable[524210] = SJRBF_PutChunk_0x2ffdd8; // 0x2ffed0 - g_ps2RecompiledFunctionTable[524211] = SJRBF_PutChunk_0x2ffdd8; // 0x2ffed4 - g_ps2RecompiledFunctionTable[524212] = SJRBF_PutChunk_0x2ffdd8; // 0x2ffed8 - g_ps2RecompiledFunctionTable[524213] = SJRBF_PutChunk_0x2ffdd8; // 0x2ffedc - g_ps2RecompiledFunctionTable[524214] = SJRBF_PutChunk_0x2ffdd8; // 0x2ffee0 - g_ps2RecompiledFunctionTable[524215] = SJRBF_PutChunk_0x2ffdd8; // 0x2ffee4 - g_ps2RecompiledFunctionTable[524216] = SJRBF_PutChunk_0x2ffdd8; // 0x2ffee8 - g_ps2RecompiledFunctionTable[524217] = SJRBF_PutChunk_0x2ffdd8; // 0x2ffeec - g_ps2RecompiledFunctionTable[524218] = SJRBF_PutChunk_0x2ffdd8; // 0x2ffef0 - g_ps2RecompiledFunctionTable[524219] = SJRBF_PutChunk_0x2ffdd8; // 0x2ffef4 - g_ps2RecompiledFunctionTable[524220] = SJRBF_PutChunk_0x2ffdd8; // 0x2ffef8 - g_ps2RecompiledFunctionTable[524221] = SJRBF_PutChunk_0x2ffdd8; // 0x2ffefc - g_ps2RecompiledFunctionTable[524222] = SJRBF_PutChunk_0x2ffdd8; // 0x2fff00 - g_ps2RecompiledFunctionTable[524223] = SJRBF_PutChunk_0x2ffdd8; // 0x2fff04 - g_ps2RecompiledFunctionTable[524224] = SJRBF_PutChunk_0x2ffdd8; // 0x2fff08 - g_ps2RecompiledFunctionTable[524225] = SJRBF_PutChunk_0x2ffdd8; // 0x2fff0c - g_ps2RecompiledFunctionTable[524226] = SJRBF_UngetChunk_0x2fff10; // 0x2fff10 - g_ps2RecompiledFunctionTable[524227] = SJRBF_UngetChunk_0x2fff10; // 0x2fff14 - g_ps2RecompiledFunctionTable[524228] = SJRBF_UngetChunk_0x2fff10; // 0x2fff18 - g_ps2RecompiledFunctionTable[524229] = SJRBF_UngetChunk_0x2fff10; // 0x2fff1c - g_ps2RecompiledFunctionTable[524230] = SJRBF_UngetChunk_0x2fff10; // 0x2fff20 - g_ps2RecompiledFunctionTable[524231] = SJRBF_UngetChunk_0x2fff10; // 0x2fff24 - g_ps2RecompiledFunctionTable[524232] = SJRBF_UngetChunk_0x2fff10; // 0x2fff28 - g_ps2RecompiledFunctionTable[524233] = SJRBF_UngetChunk_0x2fff10; // 0x2fff2c - g_ps2RecompiledFunctionTable[524234] = SJRBF_UngetChunk_0x2fff10; // 0x2fff30 - g_ps2RecompiledFunctionTable[524235] = SJRBF_UngetChunk_0x2fff10; // 0x2fff34 - g_ps2RecompiledFunctionTable[524236] = SJRBF_UngetChunk_0x2fff10; // 0x2fff38 - g_ps2RecompiledFunctionTable[524237] = SJRBF_UngetChunk_0x2fff10; // 0x2fff3c - g_ps2RecompiledFunctionTable[524238] = SJRBF_UngetChunk_0x2fff10; // 0x2fff40 - g_ps2RecompiledFunctionTable[524239] = SJRBF_UngetChunk_0x2fff10; // 0x2fff44 - g_ps2RecompiledFunctionTable[524240] = SJRBF_UngetChunk_0x2fff10; // 0x2fff48 - g_ps2RecompiledFunctionTable[524241] = SJRBF_UngetChunk_0x2fff10; // 0x2fff4c - g_ps2RecompiledFunctionTable[524242] = SJRBF_UngetChunk_0x2fff10; // 0x2fff50 - g_ps2RecompiledFunctionTable[524243] = SJRBF_UngetChunk_0x2fff10; // 0x2fff54 - g_ps2RecompiledFunctionTable[524244] = SJRBF_UngetChunk_0x2fff10; // 0x2fff58 - g_ps2RecompiledFunctionTable[524245] = SJRBF_UngetChunk_0x2fff10; // 0x2fff5c - g_ps2RecompiledFunctionTable[524246] = SJRBF_UngetChunk_0x2fff10; // 0x2fff60 - g_ps2RecompiledFunctionTable[524247] = SJRBF_UngetChunk_0x2fff10; // 0x2fff64 - g_ps2RecompiledFunctionTable[524248] = SJRBF_UngetChunk_0x2fff10; // 0x2fff68 - g_ps2RecompiledFunctionTable[524249] = SJRBF_UngetChunk_0x2fff10; // 0x2fff6c - g_ps2RecompiledFunctionTable[524250] = SJRBF_UngetChunk_0x2fff10; // 0x2fff70 - g_ps2RecompiledFunctionTable[524251] = SJRBF_UngetChunk_0x2fff10; // 0x2fff74 - g_ps2RecompiledFunctionTable[524252] = SJRBF_UngetChunk_0x2fff10; // 0x2fff78 - g_ps2RecompiledFunctionTable[524253] = SJRBF_UngetChunk_0x2fff10; // 0x2fff7c - g_ps2RecompiledFunctionTable[524254] = SJRBF_UngetChunk_0x2fff10; // 0x2fff80 - g_ps2RecompiledFunctionTable[524255] = SJRBF_UngetChunk_0x2fff10; // 0x2fff84 - g_ps2RecompiledFunctionTable[524256] = SJRBF_UngetChunk_0x2fff10; // 0x2fff88 - g_ps2RecompiledFunctionTable[524257] = SJRBF_UngetChunk_0x2fff10; // 0x2fff8c - g_ps2RecompiledFunctionTable[524258] = SJRBF_UngetChunk_0x2fff10; // 0x2fff90 - g_ps2RecompiledFunctionTable[524259] = SJRBF_UngetChunk_0x2fff10; // 0x2fff94 - g_ps2RecompiledFunctionTable[524260] = SJRBF_UngetChunk_0x2fff10; // 0x2fff98 - g_ps2RecompiledFunctionTable[524261] = SJRBF_UngetChunk_0x2fff10; // 0x2fff9c - g_ps2RecompiledFunctionTable[524262] = SJRBF_UngetChunk_0x2fff10; // 0x2fffa0 - g_ps2RecompiledFunctionTable[524263] = SJRBF_UngetChunk_0x2fff10; // 0x2fffa4 - g_ps2RecompiledFunctionTable[524264] = SJRBF_UngetChunk_0x2fff10; // 0x2fffa8 - g_ps2RecompiledFunctionTable[524265] = SJRBF_UngetChunk_0x2fff10; // 0x2fffac - g_ps2RecompiledFunctionTable[524266] = SJRBF_UngetChunk_0x2fff10; // 0x2fffb0 - g_ps2RecompiledFunctionTable[524267] = SJRBF_UngetChunk_0x2fff10; // 0x2fffb4 - g_ps2RecompiledFunctionTable[524268] = SJRBF_UngetChunk_0x2fff10; // 0x2fffb8 - g_ps2RecompiledFunctionTable[524269] = SJRBF_UngetChunk_0x2fff10; // 0x2fffbc - g_ps2RecompiledFunctionTable[524270] = SJRBF_UngetChunk_0x2fff10; // 0x2fffc0 - g_ps2RecompiledFunctionTable[524271] = SJRBF_UngetChunk_0x2fff10; // 0x2fffc4 - g_ps2RecompiledFunctionTable[524272] = SJRBF_UngetChunk_0x2fff10; // 0x2fffc8 - g_ps2RecompiledFunctionTable[524273] = SJRBF_UngetChunk_0x2fff10; // 0x2fffcc - g_ps2RecompiledFunctionTable[524274] = SJRBF_UngetChunk_0x2fff10; // 0x2fffd0 - g_ps2RecompiledFunctionTable[524275] = SJRBF_UngetChunk_0x2fff10; // 0x2fffd4 - g_ps2RecompiledFunctionTable[524276] = SJRBF_UngetChunk_0x2fff10; // 0x2fffd8 - g_ps2RecompiledFunctionTable[524277] = SJRBF_UngetChunk_0x2fff10; // 0x2fffdc - g_ps2RecompiledFunctionTable[524278] = SJRBF_UngetChunk_0x2fff10; // 0x2fffe0 - g_ps2RecompiledFunctionTable[524279] = SJRBF_UngetChunk_0x2fff10; // 0x2fffe4 - g_ps2RecompiledFunctionTable[524280] = SJRBF_UngetChunk_0x2fff10; // 0x2fffe8 - g_ps2RecompiledFunctionTable[524281] = SJRBF_UngetChunk_0x2fff10; // 0x2fffec - g_ps2RecompiledFunctionTable[524282] = SJRBF_UngetChunk_0x2fff10; // 0x2ffff0 - g_ps2RecompiledFunctionTable[524283] = SJRBF_UngetChunk_0x2fff10; // 0x2ffff4 - g_ps2RecompiledFunctionTable[524284] = SJRBF_UngetChunk_0x2fff10; // 0x2ffff8 - g_ps2RecompiledFunctionTable[524285] = SJRBF_UngetChunk_0x2fff10; // 0x2ffffc - g_ps2RecompiledFunctionTable[524286] = SJRBF_UngetChunk_0x2fff10; // 0x300000 - g_ps2RecompiledFunctionTable[524287] = SJRBF_UngetChunk_0x2fff10; // 0x300004 - g_ps2RecompiledFunctionTable[524288] = SJRBF_UngetChunk_0x2fff10; // 0x300008 - g_ps2RecompiledFunctionTable[524289] = SJRBF_UngetChunk_0x2fff10; // 0x30000c - g_ps2RecompiledFunctionTable[524290] = SJRBF_UngetChunk_0x2fff10; // 0x300010 - g_ps2RecompiledFunctionTable[524291] = SJRBF_UngetChunk_0x2fff10; // 0x300014 - g_ps2RecompiledFunctionTable[524292] = SJRBF_UngetChunk_0x2fff10; // 0x300018 - g_ps2RecompiledFunctionTable[524293] = SJRBF_UngetChunk_0x2fff10; // 0x30001c - g_ps2RecompiledFunctionTable[524294] = SJRBF_UngetChunk_0x2fff10; // 0x300020 - g_ps2RecompiledFunctionTable[524295] = SJRBF_UngetChunk_0x2fff10; // 0x300024 - g_ps2RecompiledFunctionTable[524296] = SJRBF_UngetChunk_0x2fff10; // 0x300028 - g_ps2RecompiledFunctionTable[524297] = SJRBF_UngetChunk_0x2fff10; // 0x30002c - g_ps2RecompiledFunctionTable[524298] = SJRBF_UngetChunk_0x2fff10; // 0x300030 - g_ps2RecompiledFunctionTable[524299] = SJRBF_UngetChunk_0x2fff10; // 0x300034 - g_ps2RecompiledFunctionTable[524300] = SJRBF_UngetChunk_0x2fff10; // 0x300038 - g_ps2RecompiledFunctionTable[524301] = SJRBF_UngetChunk_0x2fff10; // 0x30003c - g_ps2RecompiledFunctionTable[524302] = SJRBF_UngetChunk_0x2fff10; // 0x300040 - g_ps2RecompiledFunctionTable[524303] = SJRBF_UngetChunk_0x2fff10; // 0x300044 - g_ps2RecompiledFunctionTable[524304] = SJRBF_UngetChunk_0x2fff10; // 0x300048 - g_ps2RecompiledFunctionTable[524305] = SJRBF_UngetChunk_0x2fff10; // 0x30004c - g_ps2RecompiledFunctionTable[524306] = SJRBF_UngetChunk_0x2fff10; // 0x300050 - g_ps2RecompiledFunctionTable[524307] = SJRBF_UngetChunk_0x2fff10; // 0x300054 - g_ps2RecompiledFunctionTable[524308] = SJRBF_UngetChunk_0x2fff10; // 0x300058 - g_ps2RecompiledFunctionTable[524309] = SJRBF_UngetChunk_0x2fff10; // 0x30005c - g_ps2RecompiledFunctionTable[524310] = SJRBF_UngetChunk_0x2fff10; // 0x300060 - g_ps2RecompiledFunctionTable[524311] = SJRBF_UngetChunk_0x2fff10; // 0x300064 - g_ps2RecompiledFunctionTable[524312] = SJRBF_UngetChunk_0x2fff10; // 0x300068 - g_ps2RecompiledFunctionTable[524313] = SJRBF_UngetChunk_0x2fff10; // 0x30006c - g_ps2RecompiledFunctionTable[524314] = SJRBF_IsGetChunk_0x300070; // 0x300070 - g_ps2RecompiledFunctionTable[524315] = SJRBF_IsGetChunk_0x300070; // 0x300074 - g_ps2RecompiledFunctionTable[524316] = SJRBF_IsGetChunk_0x300070; // 0x300078 - g_ps2RecompiledFunctionTable[524317] = SJRBF_IsGetChunk_0x300070; // 0x30007c - g_ps2RecompiledFunctionTable[524318] = SJRBF_IsGetChunk_0x300070; // 0x300080 - g_ps2RecompiledFunctionTable[524319] = SJRBF_IsGetChunk_0x300070; // 0x300084 - g_ps2RecompiledFunctionTable[524320] = SJRBF_IsGetChunk_0x300070; // 0x300088 - g_ps2RecompiledFunctionTable[524321] = SJRBF_IsGetChunk_0x300070; // 0x30008c - g_ps2RecompiledFunctionTable[524322] = SJRBF_IsGetChunk_0x300070; // 0x300090 - g_ps2RecompiledFunctionTable[524323] = SJRBF_IsGetChunk_0x300070; // 0x300094 - g_ps2RecompiledFunctionTable[524324] = SJRBF_IsGetChunk_0x300070; // 0x300098 - g_ps2RecompiledFunctionTable[524325] = SJRBF_IsGetChunk_0x300070; // 0x30009c - g_ps2RecompiledFunctionTable[524326] = SJRBF_IsGetChunk_0x300070; // 0x3000a0 - g_ps2RecompiledFunctionTable[524327] = SJRBF_IsGetChunk_0x300070; // 0x3000a4 - g_ps2RecompiledFunctionTable[524328] = SJRBF_IsGetChunk_0x300070; // 0x3000a8 - g_ps2RecompiledFunctionTable[524329] = SJRBF_IsGetChunk_0x300070; // 0x3000ac - g_ps2RecompiledFunctionTable[524330] = SJRBF_IsGetChunk_0x300070; // 0x3000b0 - g_ps2RecompiledFunctionTable[524331] = SJRBF_IsGetChunk_0x300070; // 0x3000b4 - g_ps2RecompiledFunctionTable[524332] = SJRBF_IsGetChunk_0x300070; // 0x3000b8 - g_ps2RecompiledFunctionTable[524333] = SJRBF_IsGetChunk_0x300070; // 0x3000bc - g_ps2RecompiledFunctionTable[524334] = SJRBF_IsGetChunk_0x300070; // 0x3000c0 - g_ps2RecompiledFunctionTable[524335] = SJRBF_IsGetChunk_0x300070; // 0x3000c4 - g_ps2RecompiledFunctionTable[524336] = SJRBF_IsGetChunk_0x300070; // 0x3000c8 - g_ps2RecompiledFunctionTable[524337] = SJRBF_IsGetChunk_0x300070; // 0x3000cc - g_ps2RecompiledFunctionTable[524338] = SJRBF_IsGetChunk_0x300070; // 0x3000d0 - g_ps2RecompiledFunctionTable[524339] = SJRBF_IsGetChunk_0x300070; // 0x3000d4 - g_ps2RecompiledFunctionTable[524340] = SJRBF_IsGetChunk_0x300070; // 0x3000d8 - g_ps2RecompiledFunctionTable[524341] = SJRBF_IsGetChunk_0x300070; // 0x3000dc - g_ps2RecompiledFunctionTable[524342] = SJRBF_IsGetChunk_0x300070; // 0x3000e0 - g_ps2RecompiledFunctionTable[524343] = SJRBF_IsGetChunk_0x300070; // 0x3000e4 - g_ps2RecompiledFunctionTable[524344] = SJRBF_IsGetChunk_0x300070; // 0x3000e8 - g_ps2RecompiledFunctionTable[524345] = SJRBF_IsGetChunk_0x300070; // 0x3000ec - g_ps2RecompiledFunctionTable[524346] = SJRBF_IsGetChunk_0x300070; // 0x3000f0 - g_ps2RecompiledFunctionTable[524347] = SJRBF_IsGetChunk_0x300070; // 0x3000f4 - g_ps2RecompiledFunctionTable[524348] = SJRBF_IsGetChunk_0x300070; // 0x3000f8 - g_ps2RecompiledFunctionTable[524349] = SJRBF_IsGetChunk_0x300070; // 0x3000fc - g_ps2RecompiledFunctionTable[524350] = SJRBF_IsGetChunk_0x300070; // 0x300100 - g_ps2RecompiledFunctionTable[524351] = SJRBF_IsGetChunk_0x300070; // 0x300104 - g_ps2RecompiledFunctionTable[524352] = SJRBF_IsGetChunk_0x300070; // 0x300108 - g_ps2RecompiledFunctionTable[524353] = SJRBF_IsGetChunk_0x300070; // 0x30010c - g_ps2RecompiledFunctionTable[524354] = SJRBF_IsGetChunk_0x300070; // 0x300110 - g_ps2RecompiledFunctionTable[524355] = SJRBF_IsGetChunk_0x300070; // 0x300114 - g_ps2RecompiledFunctionTable[524356] = SJRBF_IsGetChunk_0x300070; // 0x300118 - g_ps2RecompiledFunctionTable[524357] = SJRBF_IsGetChunk_0x300070; // 0x30011c - g_ps2RecompiledFunctionTable[524358] = SJRBF_IsGetChunk_0x300070; // 0x300120 - g_ps2RecompiledFunctionTable[524359] = SJRBF_IsGetChunk_0x300070; // 0x300124 - g_ps2RecompiledFunctionTable[524360] = SJRBF_IsGetChunk_0x300070; // 0x300128 - g_ps2RecompiledFunctionTable[524361] = SJRBF_IsGetChunk_0x300070; // 0x30012c - g_ps2RecompiledFunctionTable[524362] = SJRBF_GetBufPtr_0x300130; // 0x300130 - g_ps2RecompiledFunctionTable[524364] = SJRBF_GetBufSize_0x300138; // 0x300138 - g_ps2RecompiledFunctionTable[524366] = SJRBF_GetXtrSize_0x300140; // 0x300140 - g_ps2RecompiledFunctionTable[524368] = SJUNI_Error_0x300148; // 0x300148 - g_ps2RecompiledFunctionTable[524376] = SJUNI_Init_0x300168; // 0x300168 - g_ps2RecompiledFunctionTable[524385] = SJUNI_Init_0x300168; // 0x30018c - g_ps2RecompiledFunctionTable[524392] = SJUNI_Finish_0x3001a8; // 0x3001a8 - g_ps2RecompiledFunctionTable[524404] = SJUNI_Create_0x3001d8; // 0x3001d8 - g_ps2RecompiledFunctionTable[524418] = SJUNI_Create_0x3001d8; // 0x300210 - g_ps2RecompiledFunctionTable[524450] = SJUNI_Create_0x3001d8; // 0x300290 - g_ps2RecompiledFunctionTable[524456] = SJUNI_Destroy_0x3002a8; // 0x3002a8 - g_ps2RecompiledFunctionTable[524464] = SJUNI_Destroy_0x3002a8; // 0x3002c8 - g_ps2RecompiledFunctionTable[524470] = SJUNI_GetUuid_0x3002e0; // 0x3002e0 - g_ps2RecompiledFunctionTable[524472] = SJUNI_EntryErrFunc_0x3002e8; // 0x3002e8 - g_ps2RecompiledFunctionTable[524476] = SJUNI_Reset_0x3002f8; // 0x3002f8 - g_ps2RecompiledFunctionTable[524484] = SJUNI_Reset_0x3002f8; // 0x300318 - g_ps2RecompiledFunctionTable[524506] = SJUNI_Reset_0x3002f8; // 0x300370 - g_ps2RecompiledFunctionTable[524516] = SJUNI_GetNumData_0x300398; // 0x300398 - g_ps2RecompiledFunctionTable[524517] = SJUNI_GetNumData_0x300398; // 0x30039c - g_ps2RecompiledFunctionTable[524518] = SJUNI_GetNumData_0x300398; // 0x3003a0 - g_ps2RecompiledFunctionTable[524519] = SJUNI_GetNumData_0x300398; // 0x3003a4 - g_ps2RecompiledFunctionTable[524520] = SJUNI_GetNumData_0x300398; // 0x3003a8 - g_ps2RecompiledFunctionTable[524521] = SJUNI_GetNumData_0x300398; // 0x3003ac - g_ps2RecompiledFunctionTable[524522] = SJUNI_GetNumData_0x300398; // 0x3003b0 - g_ps2RecompiledFunctionTable[524523] = SJUNI_GetNumData_0x300398; // 0x3003b4 - g_ps2RecompiledFunctionTable[524524] = SJUNI_GetNumData_0x300398; // 0x3003b8 - g_ps2RecompiledFunctionTable[524525] = SJUNI_GetNumData_0x300398; // 0x3003bc - g_ps2RecompiledFunctionTable[524526] = SJUNI_GetNumData_0x300398; // 0x3003c0 - g_ps2RecompiledFunctionTable[524527] = SJUNI_GetNumData_0x300398; // 0x3003c4 - g_ps2RecompiledFunctionTable[524528] = SJUNI_GetNumData_0x300398; // 0x3003c8 - g_ps2RecompiledFunctionTable[524529] = SJUNI_GetNumData_0x300398; // 0x3003cc - g_ps2RecompiledFunctionTable[524530] = SJUNI_GetNumData_0x300398; // 0x3003d0 - g_ps2RecompiledFunctionTable[524531] = SJUNI_GetNumData_0x300398; // 0x3003d4 - g_ps2RecompiledFunctionTable[524532] = SJUNI_GetNumData_0x300398; // 0x3003d8 - g_ps2RecompiledFunctionTable[524533] = SJUNI_GetNumData_0x300398; // 0x3003dc - g_ps2RecompiledFunctionTable[524534] = SJUNI_GetNumData_0x300398; // 0x3003e0 - g_ps2RecompiledFunctionTable[524535] = SJUNI_GetNumData_0x300398; // 0x3003e4 - g_ps2RecompiledFunctionTable[524536] = SJUNI_GetNumData_0x300398; // 0x3003e8 - g_ps2RecompiledFunctionTable[524537] = SJUNI_GetNumData_0x300398; // 0x3003ec - g_ps2RecompiledFunctionTable[524538] = SJUNI_GetNumData_0x300398; // 0x3003f0 - g_ps2RecompiledFunctionTable[524539] = SJUNI_GetNumData_0x300398; // 0x3003f4 - g_ps2RecompiledFunctionTable[524540] = SJUNI_GetNumData_0x300398; // 0x3003f8 - g_ps2RecompiledFunctionTable[524541] = SJUNI_GetNumData_0x300398; // 0x3003fc - g_ps2RecompiledFunctionTable[524542] = SJUNI_GetNumData_0x300398; // 0x300400 - g_ps2RecompiledFunctionTable[524543] = SJUNI_GetNumData_0x300398; // 0x300404 - g_ps2RecompiledFunctionTable[524544] = SJUNI_GetNumData_0x300398; // 0x300408 - g_ps2RecompiledFunctionTable[524546] = SJUNI_GetChunk_0x300410; // 0x300410 - g_ps2RecompiledFunctionTable[524547] = SJUNI_GetChunk_0x300410; // 0x300414 - g_ps2RecompiledFunctionTable[524548] = SJUNI_GetChunk_0x300410; // 0x300418 - g_ps2RecompiledFunctionTable[524549] = SJUNI_GetChunk_0x300410; // 0x30041c - g_ps2RecompiledFunctionTable[524550] = SJUNI_GetChunk_0x300410; // 0x300420 - g_ps2RecompiledFunctionTable[524551] = SJUNI_GetChunk_0x300410; // 0x300424 - g_ps2RecompiledFunctionTable[524552] = SJUNI_GetChunk_0x300410; // 0x300428 - g_ps2RecompiledFunctionTable[524553] = SJUNI_GetChunk_0x300410; // 0x30042c - g_ps2RecompiledFunctionTable[524554] = SJUNI_GetChunk_0x300410; // 0x300430 - g_ps2RecompiledFunctionTable[524555] = SJUNI_GetChunk_0x300410; // 0x300434 - g_ps2RecompiledFunctionTable[524556] = SJUNI_GetChunk_0x300410; // 0x300438 - g_ps2RecompiledFunctionTable[524557] = SJUNI_GetChunk_0x300410; // 0x30043c - g_ps2RecompiledFunctionTable[524558] = SJUNI_GetChunk_0x300410; // 0x300440 - g_ps2RecompiledFunctionTable[524559] = SJUNI_GetChunk_0x300410; // 0x300444 - g_ps2RecompiledFunctionTable[524560] = SJUNI_GetChunk_0x300410; // 0x300448 - g_ps2RecompiledFunctionTable[524561] = SJUNI_GetChunk_0x300410; // 0x30044c - g_ps2RecompiledFunctionTable[524562] = SJUNI_GetChunk_0x300410; // 0x300450 - g_ps2RecompiledFunctionTable[524563] = SJUNI_GetChunk_0x300410; // 0x300454 - g_ps2RecompiledFunctionTable[524564] = SJUNI_GetChunk_0x300410; // 0x300458 - g_ps2RecompiledFunctionTable[524565] = SJUNI_GetChunk_0x300410; // 0x30045c - g_ps2RecompiledFunctionTable[524566] = SJUNI_GetChunk_0x300410; // 0x300460 - g_ps2RecompiledFunctionTable[524567] = SJUNI_GetChunk_0x300410; // 0x300464 - g_ps2RecompiledFunctionTable[524568] = SJUNI_GetChunk_0x300410; // 0x300468 - g_ps2RecompiledFunctionTable[524569] = SJUNI_GetChunk_0x300410; // 0x30046c - g_ps2RecompiledFunctionTable[524570] = SJUNI_GetChunk_0x300410; // 0x300470 - g_ps2RecompiledFunctionTable[524571] = SJUNI_GetChunk_0x300410; // 0x300474 - g_ps2RecompiledFunctionTable[524572] = SJUNI_GetChunk_0x300410; // 0x300478 - g_ps2RecompiledFunctionTable[524573] = SJUNI_GetChunk_0x300410; // 0x30047c - g_ps2RecompiledFunctionTable[524574] = SJUNI_GetChunk_0x300410; // 0x300480 - g_ps2RecompiledFunctionTable[524575] = SJUNI_GetChunk_0x300410; // 0x300484 - g_ps2RecompiledFunctionTable[524576] = SJUNI_GetChunk_0x300410; // 0x300488 - g_ps2RecompiledFunctionTable[524577] = SJUNI_GetChunk_0x300410; // 0x30048c - g_ps2RecompiledFunctionTable[524578] = SJUNI_GetChunk_0x300410; // 0x300490 - g_ps2RecompiledFunctionTable[524579] = SJUNI_GetChunk_0x300410; // 0x300494 - g_ps2RecompiledFunctionTable[524580] = SJUNI_GetChunk_0x300410; // 0x300498 - g_ps2RecompiledFunctionTable[524581] = SJUNI_GetChunk_0x300410; // 0x30049c - g_ps2RecompiledFunctionTable[524582] = SJUNI_GetChunk_0x300410; // 0x3004a0 - g_ps2RecompiledFunctionTable[524583] = SJUNI_GetChunk_0x300410; // 0x3004a4 - g_ps2RecompiledFunctionTable[524584] = SJUNI_GetChunk_0x300410; // 0x3004a8 - g_ps2RecompiledFunctionTable[524585] = SJUNI_GetChunk_0x300410; // 0x3004ac - g_ps2RecompiledFunctionTable[524586] = SJUNI_GetChunk_0x300410; // 0x3004b0 - g_ps2RecompiledFunctionTable[524587] = SJUNI_GetChunk_0x300410; // 0x3004b4 - g_ps2RecompiledFunctionTable[524588] = SJUNI_GetChunk_0x300410; // 0x3004b8 - g_ps2RecompiledFunctionTable[524589] = SJUNI_GetChunk_0x300410; // 0x3004bc - g_ps2RecompiledFunctionTable[524590] = SJUNI_GetChunk_0x300410; // 0x3004c0 - g_ps2RecompiledFunctionTable[524591] = SJUNI_GetChunk_0x300410; // 0x3004c4 - g_ps2RecompiledFunctionTable[524592] = SJUNI_GetChunk_0x300410; // 0x3004c8 - g_ps2RecompiledFunctionTable[524593] = SJUNI_GetChunk_0x300410; // 0x3004cc - g_ps2RecompiledFunctionTable[524594] = SJUNI_GetChunk_0x300410; // 0x3004d0 - g_ps2RecompiledFunctionTable[524595] = SJUNI_GetChunk_0x300410; // 0x3004d4 - g_ps2RecompiledFunctionTable[524596] = SJUNI_GetChunk_0x300410; // 0x3004d8 - g_ps2RecompiledFunctionTable[524597] = SJUNI_GetChunk_0x300410; // 0x3004dc - g_ps2RecompiledFunctionTable[524598] = SJUNI_GetChunk_0x300410; // 0x3004e0 - g_ps2RecompiledFunctionTable[524599] = SJUNI_GetChunk_0x300410; // 0x3004e4 - g_ps2RecompiledFunctionTable[524600] = SJUNI_GetChunk_0x300410; // 0x3004e8 - g_ps2RecompiledFunctionTable[524601] = SJUNI_GetChunk_0x300410; // 0x3004ec - g_ps2RecompiledFunctionTable[524602] = SJUNI_GetChunk_0x300410; // 0x3004f0 - g_ps2RecompiledFunctionTable[524603] = SJUNI_GetChunk_0x300410; // 0x3004f4 - g_ps2RecompiledFunctionTable[524604] = SJUNI_GetChunk_0x300410; // 0x3004f8 - g_ps2RecompiledFunctionTable[524605] = SJUNI_GetChunk_0x300410; // 0x3004fc - g_ps2RecompiledFunctionTable[524606] = SJUNI_GetChunk_0x300410; // 0x300500 - g_ps2RecompiledFunctionTable[524607] = SJUNI_GetChunk_0x300410; // 0x300504 - g_ps2RecompiledFunctionTable[524608] = SJUNI_GetChunk_0x300410; // 0x300508 - g_ps2RecompiledFunctionTable[524609] = SJUNI_GetChunk_0x300410; // 0x30050c - g_ps2RecompiledFunctionTable[524610] = SJUNI_GetChunk_0x300410; // 0x300510 - g_ps2RecompiledFunctionTable[524611] = SJUNI_GetChunk_0x300410; // 0x300514 - g_ps2RecompiledFunctionTable[524612] = SJUNI_GetChunk_0x300410; // 0x300518 - g_ps2RecompiledFunctionTable[524613] = SJUNI_GetChunk_0x300410; // 0x30051c - g_ps2RecompiledFunctionTable[524614] = SJUNI_GetChunk_0x300410; // 0x300520 - g_ps2RecompiledFunctionTable[524615] = SJUNI_GetChunk_0x300410; // 0x300524 - g_ps2RecompiledFunctionTable[524616] = SJUNI_GetChunk_0x300410; // 0x300528 - g_ps2RecompiledFunctionTable[524617] = SJUNI_GetChunk_0x300410; // 0x30052c - g_ps2RecompiledFunctionTable[524618] = SJUNI_GetChunk_0x300410; // 0x300530 - g_ps2RecompiledFunctionTable[524619] = SJUNI_GetChunk_0x300410; // 0x300534 - g_ps2RecompiledFunctionTable[524620] = SJUNI_GetChunk_0x300410; // 0x300538 - g_ps2RecompiledFunctionTable[524622] = SJUNI_PutChunk_0x300540; // 0x300540 - g_ps2RecompiledFunctionTable[524623] = SJUNI_PutChunk_0x300540; // 0x300544 - g_ps2RecompiledFunctionTable[524624] = SJUNI_PutChunk_0x300540; // 0x300548 - g_ps2RecompiledFunctionTable[524625] = SJUNI_PutChunk_0x300540; // 0x30054c - g_ps2RecompiledFunctionTable[524626] = SJUNI_PutChunk_0x300540; // 0x300550 - g_ps2RecompiledFunctionTable[524627] = SJUNI_PutChunk_0x300540; // 0x300554 - g_ps2RecompiledFunctionTable[524628] = SJUNI_PutChunk_0x300540; // 0x300558 - g_ps2RecompiledFunctionTable[524629] = SJUNI_PutChunk_0x300540; // 0x30055c - g_ps2RecompiledFunctionTable[524630] = SJUNI_PutChunk_0x300540; // 0x300560 - g_ps2RecompiledFunctionTable[524631] = SJUNI_PutChunk_0x300540; // 0x300564 - g_ps2RecompiledFunctionTable[524632] = SJUNI_PutChunk_0x300540; // 0x300568 - g_ps2RecompiledFunctionTable[524633] = SJUNI_PutChunk_0x300540; // 0x30056c - g_ps2RecompiledFunctionTable[524634] = SJUNI_PutChunk_0x300540; // 0x300570 - g_ps2RecompiledFunctionTable[524635] = SJUNI_PutChunk_0x300540; // 0x300574 - g_ps2RecompiledFunctionTable[524636] = SJUNI_PutChunk_0x300540; // 0x300578 - g_ps2RecompiledFunctionTable[524637] = SJUNI_PutChunk_0x300540; // 0x30057c - g_ps2RecompiledFunctionTable[524638] = SJUNI_PutChunk_0x300540; // 0x300580 - g_ps2RecompiledFunctionTable[524639] = SJUNI_PutChunk_0x300540; // 0x300584 - g_ps2RecompiledFunctionTable[524640] = SJUNI_PutChunk_0x300540; // 0x300588 - g_ps2RecompiledFunctionTable[524641] = SJUNI_PutChunk_0x300540; // 0x30058c - g_ps2RecompiledFunctionTable[524642] = SJUNI_PutChunk_0x300540; // 0x300590 - g_ps2RecompiledFunctionTable[524643] = SJUNI_PutChunk_0x300540; // 0x300594 - g_ps2RecompiledFunctionTable[524644] = SJUNI_PutChunk_0x300540; // 0x300598 - g_ps2RecompiledFunctionTable[524645] = SJUNI_PutChunk_0x300540; // 0x30059c - g_ps2RecompiledFunctionTable[524646] = SJUNI_PutChunk_0x300540; // 0x3005a0 - g_ps2RecompiledFunctionTable[524647] = SJUNI_PutChunk_0x300540; // 0x3005a4 - g_ps2RecompiledFunctionTable[524648] = SJUNI_PutChunk_0x300540; // 0x3005a8 - g_ps2RecompiledFunctionTable[524649] = SJUNI_PutChunk_0x300540; // 0x3005ac - g_ps2RecompiledFunctionTable[524650] = SJUNI_PutChunk_0x300540; // 0x3005b0 - g_ps2RecompiledFunctionTable[524651] = SJUNI_PutChunk_0x300540; // 0x3005b4 - g_ps2RecompiledFunctionTable[524652] = SJUNI_PutChunk_0x300540; // 0x3005b8 - g_ps2RecompiledFunctionTable[524653] = SJUNI_PutChunk_0x300540; // 0x3005bc - g_ps2RecompiledFunctionTable[524654] = SJUNI_PutChunk_0x300540; // 0x3005c0 - g_ps2RecompiledFunctionTable[524655] = SJUNI_PutChunk_0x300540; // 0x3005c4 - g_ps2RecompiledFunctionTable[524656] = SJUNI_PutChunk_0x300540; // 0x3005c8 - g_ps2RecompiledFunctionTable[524657] = SJUNI_PutChunk_0x300540; // 0x3005cc - g_ps2RecompiledFunctionTable[524658] = SJUNI_PutChunk_0x300540; // 0x3005d0 - g_ps2RecompiledFunctionTable[524659] = SJUNI_PutChunk_0x300540; // 0x3005d4 - g_ps2RecompiledFunctionTable[524660] = SJUNI_PutChunk_0x300540; // 0x3005d8 - g_ps2RecompiledFunctionTable[524661] = SJUNI_PutChunk_0x300540; // 0x3005dc - g_ps2RecompiledFunctionTable[524662] = SJUNI_PutChunk_0x300540; // 0x3005e0 - g_ps2RecompiledFunctionTable[524663] = SJUNI_PutChunk_0x300540; // 0x3005e4 - g_ps2RecompiledFunctionTable[524664] = SJUNI_PutChunk_0x300540; // 0x3005e8 - g_ps2RecompiledFunctionTable[524665] = SJUNI_PutChunk_0x300540; // 0x3005ec - g_ps2RecompiledFunctionTable[524666] = SJUNI_PutChunk_0x300540; // 0x3005f0 - g_ps2RecompiledFunctionTable[524667] = SJUNI_PutChunk_0x300540; // 0x3005f4 - g_ps2RecompiledFunctionTable[524668] = SJUNI_PutChunk_0x300540; // 0x3005f8 - g_ps2RecompiledFunctionTable[524669] = SJUNI_PutChunk_0x300540; // 0x3005fc - g_ps2RecompiledFunctionTable[524670] = SJUNI_PutChunk_0x300540; // 0x300600 - g_ps2RecompiledFunctionTable[524671] = SJUNI_PutChunk_0x300540; // 0x300604 - g_ps2RecompiledFunctionTable[524672] = SJUNI_PutChunk_0x300540; // 0x300608 - g_ps2RecompiledFunctionTable[524673] = SJUNI_PutChunk_0x300540; // 0x30060c - g_ps2RecompiledFunctionTable[524674] = SJUNI_PutChunk_0x300540; // 0x300610 - g_ps2RecompiledFunctionTable[524675] = SJUNI_PutChunk_0x300540; // 0x300614 - g_ps2RecompiledFunctionTable[524676] = SJUNI_PutChunk_0x300540; // 0x300618 - g_ps2RecompiledFunctionTable[524677] = SJUNI_PutChunk_0x300540; // 0x30061c - g_ps2RecompiledFunctionTable[524678] = SJUNI_PutChunk_0x300540; // 0x300620 - g_ps2RecompiledFunctionTable[524679] = SJUNI_PutChunk_0x300540; // 0x300624 - g_ps2RecompiledFunctionTable[524680] = SJUNI_PutChunk_0x300540; // 0x300628 - g_ps2RecompiledFunctionTable[524681] = SJUNI_PutChunk_0x300540; // 0x30062c - g_ps2RecompiledFunctionTable[524682] = SJUNI_PutChunk_0x300540; // 0x300630 - g_ps2RecompiledFunctionTable[524683] = SJUNI_PutChunk_0x300540; // 0x300634 - g_ps2RecompiledFunctionTable[524684] = SJUNI_PutChunk_0x300540; // 0x300638 - g_ps2RecompiledFunctionTable[524685] = SJUNI_PutChunk_0x300540; // 0x30063c - g_ps2RecompiledFunctionTable[524686] = SJUNI_PutChunk_0x300540; // 0x300640 - g_ps2RecompiledFunctionTable[524687] = SJUNI_PutChunk_0x300540; // 0x300644 - g_ps2RecompiledFunctionTable[524688] = SJUNI_PutChunk_0x300540; // 0x300648 - g_ps2RecompiledFunctionTable[524689] = SJUNI_PutChunk_0x300540; // 0x30064c - g_ps2RecompiledFunctionTable[524690] = SJUNI_PutChunk_0x300540; // 0x300650 - g_ps2RecompiledFunctionTable[524691] = SJUNI_PutChunk_0x300540; // 0x300654 - g_ps2RecompiledFunctionTable[524692] = SJUNI_PutChunk_0x300540; // 0x300658 - g_ps2RecompiledFunctionTable[524693] = SJUNI_PutChunk_0x300540; // 0x30065c - g_ps2RecompiledFunctionTable[524694] = SJUNI_PutChunk_0x300540; // 0x300660 - g_ps2RecompiledFunctionTable[524695] = SJUNI_PutChunk_0x300540; // 0x300664 - g_ps2RecompiledFunctionTable[524696] = SJUNI_PutChunk_0x300540; // 0x300668 - g_ps2RecompiledFunctionTable[524697] = SJUNI_PutChunk_0x300540; // 0x30066c - g_ps2RecompiledFunctionTable[524698] = SJUNI_PutChunk_0x300540; // 0x300670 - g_ps2RecompiledFunctionTable[524699] = SJUNI_PutChunk_0x300540; // 0x300674 - g_ps2RecompiledFunctionTable[524700] = SJUNI_PutChunk_0x300540; // 0x300678 - g_ps2RecompiledFunctionTable[524701] = SJUNI_PutChunk_0x300540; // 0x30067c - g_ps2RecompiledFunctionTable[524702] = SJUNI_PutChunk_0x300540; // 0x300680 - g_ps2RecompiledFunctionTable[524703] = SJUNI_PutChunk_0x300540; // 0x300684 - g_ps2RecompiledFunctionTable[524704] = SJUNI_PutChunk_0x300540; // 0x300688 - g_ps2RecompiledFunctionTable[524705] = SJUNI_PutChunk_0x300540; // 0x30068c - g_ps2RecompiledFunctionTable[524706] = SJUNI_PutChunk_0x300540; // 0x300690 - g_ps2RecompiledFunctionTable[524707] = SJUNI_PutChunk_0x300540; // 0x300694 - g_ps2RecompiledFunctionTable[524708] = SJUNI_PutChunk_0x300540; // 0x300698 - g_ps2RecompiledFunctionTable[524709] = SJUNI_PutChunk_0x300540; // 0x30069c - g_ps2RecompiledFunctionTable[524710] = SJUNI_PutChunk_0x300540; // 0x3006a0 - g_ps2RecompiledFunctionTable[524712] = SJUNI_UngetChunk_0x3006a8; // 0x3006a8 - g_ps2RecompiledFunctionTable[524713] = SJUNI_UngetChunk_0x3006a8; // 0x3006ac - g_ps2RecompiledFunctionTable[524714] = SJUNI_UngetChunk_0x3006a8; // 0x3006b0 - g_ps2RecompiledFunctionTable[524715] = SJUNI_UngetChunk_0x3006a8; // 0x3006b4 - g_ps2RecompiledFunctionTable[524716] = SJUNI_UngetChunk_0x3006a8; // 0x3006b8 - g_ps2RecompiledFunctionTable[524717] = SJUNI_UngetChunk_0x3006a8; // 0x3006bc - g_ps2RecompiledFunctionTable[524718] = SJUNI_UngetChunk_0x3006a8; // 0x3006c0 - g_ps2RecompiledFunctionTable[524719] = SJUNI_UngetChunk_0x3006a8; // 0x3006c4 - g_ps2RecompiledFunctionTable[524720] = SJUNI_UngetChunk_0x3006a8; // 0x3006c8 - g_ps2RecompiledFunctionTable[524721] = SJUNI_UngetChunk_0x3006a8; // 0x3006cc - g_ps2RecompiledFunctionTable[524722] = SJUNI_UngetChunk_0x3006a8; // 0x3006d0 - g_ps2RecompiledFunctionTable[524723] = SJUNI_UngetChunk_0x3006a8; // 0x3006d4 - g_ps2RecompiledFunctionTable[524724] = SJUNI_UngetChunk_0x3006a8; // 0x3006d8 - g_ps2RecompiledFunctionTable[524725] = SJUNI_UngetChunk_0x3006a8; // 0x3006dc - g_ps2RecompiledFunctionTable[524726] = SJUNI_UngetChunk_0x3006a8; // 0x3006e0 - g_ps2RecompiledFunctionTable[524727] = SJUNI_UngetChunk_0x3006a8; // 0x3006e4 - g_ps2RecompiledFunctionTable[524728] = SJUNI_UngetChunk_0x3006a8; // 0x3006e8 - g_ps2RecompiledFunctionTable[524729] = SJUNI_UngetChunk_0x3006a8; // 0x3006ec - g_ps2RecompiledFunctionTable[524730] = SJUNI_UngetChunk_0x3006a8; // 0x3006f0 - g_ps2RecompiledFunctionTable[524731] = SJUNI_UngetChunk_0x3006a8; // 0x3006f4 - g_ps2RecompiledFunctionTable[524732] = SJUNI_UngetChunk_0x3006a8; // 0x3006f8 - g_ps2RecompiledFunctionTable[524733] = SJUNI_UngetChunk_0x3006a8; // 0x3006fc - g_ps2RecompiledFunctionTable[524734] = SJUNI_UngetChunk_0x3006a8; // 0x300700 - g_ps2RecompiledFunctionTable[524735] = SJUNI_UngetChunk_0x3006a8; // 0x300704 - g_ps2RecompiledFunctionTable[524736] = SJUNI_UngetChunk_0x3006a8; // 0x300708 - g_ps2RecompiledFunctionTable[524737] = SJUNI_UngetChunk_0x3006a8; // 0x30070c - g_ps2RecompiledFunctionTable[524738] = SJUNI_UngetChunk_0x3006a8; // 0x300710 - g_ps2RecompiledFunctionTable[524739] = SJUNI_UngetChunk_0x3006a8; // 0x300714 - g_ps2RecompiledFunctionTable[524740] = SJUNI_UngetChunk_0x3006a8; // 0x300718 - g_ps2RecompiledFunctionTable[524741] = SJUNI_UngetChunk_0x3006a8; // 0x30071c - g_ps2RecompiledFunctionTable[524742] = SJUNI_UngetChunk_0x3006a8; // 0x300720 - g_ps2RecompiledFunctionTable[524743] = SJUNI_UngetChunk_0x3006a8; // 0x300724 - g_ps2RecompiledFunctionTable[524744] = SJUNI_UngetChunk_0x3006a8; // 0x300728 - g_ps2RecompiledFunctionTable[524745] = SJUNI_UngetChunk_0x3006a8; // 0x30072c - g_ps2RecompiledFunctionTable[524746] = SJUNI_UngetChunk_0x3006a8; // 0x300730 - g_ps2RecompiledFunctionTable[524747] = SJUNI_UngetChunk_0x3006a8; // 0x300734 - g_ps2RecompiledFunctionTable[524748] = SJUNI_UngetChunk_0x3006a8; // 0x300738 - g_ps2RecompiledFunctionTable[524749] = SJUNI_UngetChunk_0x3006a8; // 0x30073c - g_ps2RecompiledFunctionTable[524750] = SJUNI_UngetChunk_0x3006a8; // 0x300740 - g_ps2RecompiledFunctionTable[524751] = SJUNI_UngetChunk_0x3006a8; // 0x300744 - g_ps2RecompiledFunctionTable[524752] = SJUNI_UngetChunk_0x3006a8; // 0x300748 - g_ps2RecompiledFunctionTable[524753] = SJUNI_UngetChunk_0x3006a8; // 0x30074c - g_ps2RecompiledFunctionTable[524754] = SJUNI_UngetChunk_0x3006a8; // 0x300750 - g_ps2RecompiledFunctionTable[524755] = SJUNI_UngetChunk_0x3006a8; // 0x300754 - g_ps2RecompiledFunctionTable[524756] = SJUNI_UngetChunk_0x3006a8; // 0x300758 - g_ps2RecompiledFunctionTable[524757] = SJUNI_UngetChunk_0x3006a8; // 0x30075c - g_ps2RecompiledFunctionTable[524758] = SJUNI_UngetChunk_0x3006a8; // 0x300760 - g_ps2RecompiledFunctionTable[524759] = SJUNI_UngetChunk_0x3006a8; // 0x300764 - g_ps2RecompiledFunctionTable[524760] = SJUNI_UngetChunk_0x3006a8; // 0x300768 - g_ps2RecompiledFunctionTable[524761] = SJUNI_UngetChunk_0x3006a8; // 0x30076c - g_ps2RecompiledFunctionTable[524762] = SJUNI_UngetChunk_0x3006a8; // 0x300770 - g_ps2RecompiledFunctionTable[524763] = SJUNI_UngetChunk_0x3006a8; // 0x300774 - g_ps2RecompiledFunctionTable[524764] = SJUNI_UngetChunk_0x3006a8; // 0x300778 - g_ps2RecompiledFunctionTable[524765] = SJUNI_UngetChunk_0x3006a8; // 0x30077c - g_ps2RecompiledFunctionTable[524766] = SJUNI_UngetChunk_0x3006a8; // 0x300780 - g_ps2RecompiledFunctionTable[524767] = SJUNI_UngetChunk_0x3006a8; // 0x300784 - g_ps2RecompiledFunctionTable[524768] = SJUNI_UngetChunk_0x3006a8; // 0x300788 - g_ps2RecompiledFunctionTable[524769] = SJUNI_UngetChunk_0x3006a8; // 0x30078c - g_ps2RecompiledFunctionTable[524770] = SJUNI_UngetChunk_0x3006a8; // 0x300790 - g_ps2RecompiledFunctionTable[524771] = SJUNI_UngetChunk_0x3006a8; // 0x300794 - g_ps2RecompiledFunctionTable[524772] = SJUNI_UngetChunk_0x3006a8; // 0x300798 - g_ps2RecompiledFunctionTable[524773] = SJUNI_UngetChunk_0x3006a8; // 0x30079c - g_ps2RecompiledFunctionTable[524774] = SJUNI_UngetChunk_0x3006a8; // 0x3007a0 - g_ps2RecompiledFunctionTable[524775] = SJUNI_UngetChunk_0x3006a8; // 0x3007a4 - g_ps2RecompiledFunctionTable[524776] = SJUNI_UngetChunk_0x3006a8; // 0x3007a8 - g_ps2RecompiledFunctionTable[524777] = SJUNI_UngetChunk_0x3006a8; // 0x3007ac - g_ps2RecompiledFunctionTable[524778] = SJUNI_UngetChunk_0x3006a8; // 0x3007b0 - g_ps2RecompiledFunctionTable[524779] = SJUNI_UngetChunk_0x3006a8; // 0x3007b4 - g_ps2RecompiledFunctionTable[524780] = SJUNI_UngetChunk_0x3006a8; // 0x3007b8 - g_ps2RecompiledFunctionTable[524781] = SJUNI_UngetChunk_0x3006a8; // 0x3007bc - g_ps2RecompiledFunctionTable[524782] = SJUNI_UngetChunk_0x3006a8; // 0x3007c0 - g_ps2RecompiledFunctionTable[524783] = SJUNI_UngetChunk_0x3006a8; // 0x3007c4 - g_ps2RecompiledFunctionTable[524784] = SJUNI_UngetChunk_0x3006a8; // 0x3007c8 - g_ps2RecompiledFunctionTable[524785] = SJUNI_UngetChunk_0x3006a8; // 0x3007cc - g_ps2RecompiledFunctionTable[524786] = SJUNI_UngetChunk_0x3006a8; // 0x3007d0 - g_ps2RecompiledFunctionTable[524787] = SJUNI_UngetChunk_0x3006a8; // 0x3007d4 - g_ps2RecompiledFunctionTable[524788] = SJUNI_UngetChunk_0x3006a8; // 0x3007d8 - g_ps2RecompiledFunctionTable[524789] = SJUNI_UngetChunk_0x3006a8; // 0x3007dc - g_ps2RecompiledFunctionTable[524790] = SJUNI_IsGetChunk_0x3007e0; // 0x3007e0 - g_ps2RecompiledFunctionTable[524791] = SJUNI_IsGetChunk_0x3007e0; // 0x3007e4 - g_ps2RecompiledFunctionTable[524792] = SJUNI_IsGetChunk_0x3007e0; // 0x3007e8 - g_ps2RecompiledFunctionTable[524793] = SJUNI_IsGetChunk_0x3007e0; // 0x3007ec - g_ps2RecompiledFunctionTable[524794] = SJUNI_IsGetChunk_0x3007e0; // 0x3007f0 - g_ps2RecompiledFunctionTable[524795] = SJUNI_IsGetChunk_0x3007e0; // 0x3007f4 - g_ps2RecompiledFunctionTable[524796] = SJUNI_IsGetChunk_0x3007e0; // 0x3007f8 - g_ps2RecompiledFunctionTable[524797] = SJUNI_IsGetChunk_0x3007e0; // 0x3007fc - g_ps2RecompiledFunctionTable[524798] = SJUNI_IsGetChunk_0x3007e0; // 0x300800 - g_ps2RecompiledFunctionTable[524799] = SJUNI_IsGetChunk_0x3007e0; // 0x300804 - g_ps2RecompiledFunctionTable[524800] = SJUNI_IsGetChunk_0x3007e0; // 0x300808 - g_ps2RecompiledFunctionTable[524801] = SJUNI_IsGetChunk_0x3007e0; // 0x30080c - g_ps2RecompiledFunctionTable[524802] = SJUNI_IsGetChunk_0x3007e0; // 0x300810 - g_ps2RecompiledFunctionTable[524803] = SJUNI_IsGetChunk_0x3007e0; // 0x300814 - g_ps2RecompiledFunctionTable[524804] = SJUNI_IsGetChunk_0x3007e0; // 0x300818 - g_ps2RecompiledFunctionTable[524805] = SJUNI_IsGetChunk_0x3007e0; // 0x30081c - g_ps2RecompiledFunctionTable[524806] = SJUNI_IsGetChunk_0x3007e0; // 0x300820 - g_ps2RecompiledFunctionTable[524807] = SJUNI_IsGetChunk_0x3007e0; // 0x300824 - g_ps2RecompiledFunctionTable[524808] = SJUNI_IsGetChunk_0x3007e0; // 0x300828 - g_ps2RecompiledFunctionTable[524809] = SJUNI_IsGetChunk_0x3007e0; // 0x30082c - g_ps2RecompiledFunctionTable[524810] = SJUNI_IsGetChunk_0x3007e0; // 0x300830 - g_ps2RecompiledFunctionTable[524811] = SJUNI_IsGetChunk_0x3007e0; // 0x300834 - g_ps2RecompiledFunctionTable[524812] = SJUNI_IsGetChunk_0x3007e0; // 0x300838 - g_ps2RecompiledFunctionTable[524813] = SJUNI_IsGetChunk_0x3007e0; // 0x30083c - g_ps2RecompiledFunctionTable[524814] = SJUNI_IsGetChunk_0x3007e0; // 0x300840 - g_ps2RecompiledFunctionTable[524815] = SJUNI_IsGetChunk_0x3007e0; // 0x300844 - g_ps2RecompiledFunctionTable[524816] = SJUNI_IsGetChunk_0x3007e0; // 0x300848 - g_ps2RecompiledFunctionTable[524817] = SJUNI_IsGetChunk_0x3007e0; // 0x30084c - g_ps2RecompiledFunctionTable[524818] = SJUNI_IsGetChunk_0x3007e0; // 0x300850 - g_ps2RecompiledFunctionTable[524819] = SJUNI_IsGetChunk_0x3007e0; // 0x300854 - g_ps2RecompiledFunctionTable[524820] = SJUNI_IsGetChunk_0x3007e0; // 0x300858 - g_ps2RecompiledFunctionTable[524821] = SJUNI_IsGetChunk_0x3007e0; // 0x30085c - g_ps2RecompiledFunctionTable[524822] = SJUNI_IsGetChunk_0x3007e0; // 0x300860 - g_ps2RecompiledFunctionTable[524823] = SJUNI_IsGetChunk_0x3007e0; // 0x300864 - g_ps2RecompiledFunctionTable[524824] = SJUNI_IsGetChunk_0x3007e0; // 0x300868 - g_ps2RecompiledFunctionTable[524825] = SJUNI_IsGetChunk_0x3007e0; // 0x30086c - g_ps2RecompiledFunctionTable[524826] = SJUNI_IsGetChunk_0x3007e0; // 0x300870 - g_ps2RecompiledFunctionTable[524827] = SJUNI_IsGetChunk_0x3007e0; // 0x300874 - g_ps2RecompiledFunctionTable[524828] = SJUNI_IsGetChunk_0x3007e0; // 0x300878 - g_ps2RecompiledFunctionTable[524830] = SJUNI_GetNumChunk_0x300880; // 0x300880 - g_ps2RecompiledFunctionTable[524836] = SJUNI_GetNumChunk_0x300880; // 0x300898 - g_ps2RecompiledFunctionTable[524846] = SJUNI_GetNumChainPool_0x3008c0; // 0x3008c0 - g_ps2RecompiledFunctionTable[524850] = SJUNI_GetNumChainPool_0x3008c0; // 0x3008d0 - g_ps2RecompiledFunctionTable[524860] = SJ_SplitChunk_0x3008f8; // 0x3008f8 - g_ps2RecompiledFunctionTable[524884] = SJRBF_CreateRmt_0x300958; // 0x300958 - g_ps2RecompiledFunctionTable[524899] = SJRBF_CreateRmt_0x300958; // 0x300994 - g_ps2RecompiledFunctionTable[524904] = SJMEM_CreateRmt_0x3009a8; // 0x3009a8 - g_ps2RecompiledFunctionTable[524918] = SJMEM_CreateRmt_0x3009a8; // 0x3009e0 - g_ps2RecompiledFunctionTable[524924] = SJUNI_CreateRmt_0x3009f8; // 0x3009f8 - g_ps2RecompiledFunctionTable[524939] = SJUNI_CreateRmt_0x3009f8; // 0x300a34 - g_ps2RecompiledFunctionTable[524944] = SJRMT_Destroy_0x300a48; // 0x300a48 - g_ps2RecompiledFunctionTable[524952] = SJRMT_GetUuid_0x300a68; // 0x300a68 - g_ps2RecompiledFunctionTable[524966] = SJRMT_GetUuid_0x300a68; // 0x300aa0 - g_ps2RecompiledFunctionTable[524982] = SJRMT_Reset_0x300ae0; // 0x300ae0 - g_ps2RecompiledFunctionTable[524990] = SJRMT_GetChunk_0x300b00; // 0x300b00 - g_ps2RecompiledFunctionTable[525009] = SJRMT_GetChunk_0x300b00; // 0x300b4c - g_ps2RecompiledFunctionTable[525020] = SJRMT_UngetChunk_0x300b78; // 0x300b78 - g_ps2RecompiledFunctionTable[525036] = SJRMT_PutChunk_0x300bb8; // 0x300bb8 - g_ps2RecompiledFunctionTable[525052] = SJRMT_GetNumData_0x300bf8; // 0x300bf8 - g_ps2RecompiledFunctionTable[525066] = SJRMT_GetNumData_0x300bf8; // 0x300c30 - g_ps2RecompiledFunctionTable[525072] = SJRMT_IsGetChunk_0x300c48; // 0x300c48 - g_ps2RecompiledFunctionTable[525091] = SJRMT_IsGetChunk_0x300c48; // 0x300c94 - g_ps2RecompiledFunctionTable[525100] = SJRMT_Init_0x300cb8; // 0x300cb8 - g_ps2RecompiledFunctionTable[525109] = SJRMT_Init_0x300cb8; // 0x300cdc - g_ps2RecompiledFunctionTable[525116] = SJRMT_Finish_0x300cf8; // 0x300cf8 - g_ps2RecompiledFunctionTable[525126] = sjx_rcvcbf_0x300d20; // 0x300d20 - g_ps2RecompiledFunctionTable[525127] = sjx_rcvcbf_0x300d20; // 0x300d24 - g_ps2RecompiledFunctionTable[525128] = sjx_rcvcbf_0x300d20; // 0x300d28 - g_ps2RecompiledFunctionTable[525129] = sjx_rcvcbf_0x300d20; // 0x300d2c - g_ps2RecompiledFunctionTable[525130] = sjx_rcvcbf_0x300d20; // 0x300d30 - g_ps2RecompiledFunctionTable[525131] = sjx_rcvcbf_0x300d20; // 0x300d34 - g_ps2RecompiledFunctionTable[525132] = sjx_rcvcbf_0x300d20; // 0x300d38 - g_ps2RecompiledFunctionTable[525133] = sjx_rcvcbf_0x300d20; // 0x300d3c - g_ps2RecompiledFunctionTable[525134] = sjx_rcvcbf_0x300d20; // 0x300d40 - g_ps2RecompiledFunctionTable[525135] = sjx_rcvcbf_0x300d20; // 0x300d44 - g_ps2RecompiledFunctionTable[525136] = sjx_rcvcbf_0x300d20; // 0x300d48 - g_ps2RecompiledFunctionTable[525137] = sjx_rcvcbf_0x300d20; // 0x300d4c - g_ps2RecompiledFunctionTable[525138] = sjx_rcvcbf_0x300d20; // 0x300d50 - g_ps2RecompiledFunctionTable[525139] = sjx_rcvcbf_0x300d20; // 0x300d54 - g_ps2RecompiledFunctionTable[525140] = sjx_rcvcbf_0x300d20; // 0x300d58 - g_ps2RecompiledFunctionTable[525141] = sjx_rcvcbf_0x300d20; // 0x300d5c - g_ps2RecompiledFunctionTable[525142] = sjx_rcvcbf_0x300d20; // 0x300d60 - g_ps2RecompiledFunctionTable[525143] = sjx_rcvcbf_0x300d20; // 0x300d64 - g_ps2RecompiledFunctionTable[525144] = sjx_rcvcbf_0x300d20; // 0x300d68 - g_ps2RecompiledFunctionTable[525145] = sjx_rcvcbf_0x300d20; // 0x300d6c - g_ps2RecompiledFunctionTable[525146] = sjx_rcvcbf_0x300d20; // 0x300d70 - g_ps2RecompiledFunctionTable[525147] = sjx_rcvcbf_0x300d20; // 0x300d74 - g_ps2RecompiledFunctionTable[525148] = sjx_rcvcbf_0x300d20; // 0x300d78 - g_ps2RecompiledFunctionTable[525149] = sjx_rcvcbf_0x300d20; // 0x300d7c - g_ps2RecompiledFunctionTable[525150] = sjx_rcvcbf_0x300d20; // 0x300d80 - g_ps2RecompiledFunctionTable[525151] = sjx_rcvcbf_0x300d20; // 0x300d84 - g_ps2RecompiledFunctionTable[525152] = sjx_rcvcbf_0x300d20; // 0x300d88 - g_ps2RecompiledFunctionTable[525153] = sjx_rcvcbf_0x300d20; // 0x300d8c - g_ps2RecompiledFunctionTable[525154] = sjx_rcvcbf_0x300d20; // 0x300d90 - g_ps2RecompiledFunctionTable[525155] = sjx_rcvcbf_0x300d20; // 0x300d94 - g_ps2RecompiledFunctionTable[525156] = sjx_rcvcbf_0x300d20; // 0x300d98 - g_ps2RecompiledFunctionTable[525157] = sjx_rcvcbf_0x300d20; // 0x300d9c - g_ps2RecompiledFunctionTable[525158] = sjx_rcvcbf_0x300d20; // 0x300da0 - g_ps2RecompiledFunctionTable[525159] = sjx_rcvcbf_0x300d20; // 0x300da4 - g_ps2RecompiledFunctionTable[525160] = sjx_rcvcbf_0x300d20; // 0x300da8 - g_ps2RecompiledFunctionTable[525161] = sjx_rcvcbf_0x300d20; // 0x300dac - g_ps2RecompiledFunctionTable[525162] = sjx_rcvcbf_0x300d20; // 0x300db0 - g_ps2RecompiledFunctionTable[525163] = sjx_rcvcbf_0x300d20; // 0x300db4 - g_ps2RecompiledFunctionTable[525164] = sjx_rcvcbf_0x300d20; // 0x300db8 - g_ps2RecompiledFunctionTable[525165] = sjx_rcvcbf_0x300d20; // 0x300dbc - g_ps2RecompiledFunctionTable[525166] = sjx_sndcbf_0x300dc0; // 0x300dc0 - g_ps2RecompiledFunctionTable[525167] = sjx_sndcbf_0x300dc0; // 0x300dc4 - g_ps2RecompiledFunctionTable[525168] = sjx_sndcbf_0x300dc0; // 0x300dc8 - g_ps2RecompiledFunctionTable[525169] = sjx_sndcbf_0x300dc0; // 0x300dcc - g_ps2RecompiledFunctionTable[525170] = sjx_sndcbf_0x300dc0; // 0x300dd0 - g_ps2RecompiledFunctionTable[525171] = sjx_sndcbf_0x300dc0; // 0x300dd4 - g_ps2RecompiledFunctionTable[525172] = sjx_sndcbf_0x300dc0; // 0x300dd8 - g_ps2RecompiledFunctionTable[525173] = sjx_sndcbf_0x300dc0; // 0x300ddc - g_ps2RecompiledFunctionTable[525174] = sjx_sndcbf_0x300dc0; // 0x300de0 - g_ps2RecompiledFunctionTable[525175] = sjx_sndcbf_0x300dc0; // 0x300de4 - g_ps2RecompiledFunctionTable[525176] = sjx_sndcbf_0x300dc0; // 0x300de8 - g_ps2RecompiledFunctionTable[525177] = sjx_sndcbf_0x300dc0; // 0x300dec - g_ps2RecompiledFunctionTable[525178] = sjx_sndcbf_0x300dc0; // 0x300df0 - g_ps2RecompiledFunctionTable[525179] = sjx_sndcbf_0x300dc0; // 0x300df4 - g_ps2RecompiledFunctionTable[525180] = sjx_sndcbf_0x300dc0; // 0x300df8 - g_ps2RecompiledFunctionTable[525181] = sjx_sndcbf_0x300dc0; // 0x300dfc - g_ps2RecompiledFunctionTable[525182] = sjx_sndcbf_0x300dc0; // 0x300e00 - g_ps2RecompiledFunctionTable[525183] = sjx_sndcbf_0x300dc0; // 0x300e04 - g_ps2RecompiledFunctionTable[525184] = sjx_sndcbf_0x300dc0; // 0x300e08 - g_ps2RecompiledFunctionTable[525185] = sjx_sndcbf_0x300dc0; // 0x300e0c - g_ps2RecompiledFunctionTable[525186] = sjx_sndcbf_0x300dc0; // 0x300e10 - g_ps2RecompiledFunctionTable[525187] = sjx_sndcbf_0x300dc0; // 0x300e14 - g_ps2RecompiledFunctionTable[525188] = sjx_sndcbf_0x300dc0; // 0x300e18 - g_ps2RecompiledFunctionTable[525189] = sjx_sndcbf_0x300dc0; // 0x300e1c - g_ps2RecompiledFunctionTable[525190] = sjx_sndcbf_0x300dc0; // 0x300e20 - g_ps2RecompiledFunctionTable[525191] = sjx_sndcbf_0x300dc0; // 0x300e24 - g_ps2RecompiledFunctionTable[525192] = sjx_sndcbf_0x300dc0; // 0x300e28 - g_ps2RecompiledFunctionTable[525193] = sjx_sndcbf_0x300dc0; // 0x300e2c - g_ps2RecompiledFunctionTable[525194] = sjx_sndcbf_0x300dc0; // 0x300e30 - g_ps2RecompiledFunctionTable[525195] = sjx_sndcbf_0x300dc0; // 0x300e34 - g_ps2RecompiledFunctionTable[525196] = sjx_sndcbf_0x300dc0; // 0x300e38 - g_ps2RecompiledFunctionTable[525197] = sjx_sndcbf_0x300dc0; // 0x300e3c - g_ps2RecompiledFunctionTable[525198] = sjx_sndcbf_0x300dc0; // 0x300e40 - g_ps2RecompiledFunctionTable[525199] = sjx_sndcbf_0x300dc0; // 0x300e44 - g_ps2RecompiledFunctionTable[525200] = sjx_sndcbf_0x300dc0; // 0x300e48 - g_ps2RecompiledFunctionTable[525201] = sjx_sndcbf_0x300dc0; // 0x300e4c - g_ps2RecompiledFunctionTable[525202] = sjx_sndcbf_0x300dc0; // 0x300e50 - g_ps2RecompiledFunctionTable[525203] = sjx_sndcbf_0x300dc0; // 0x300e54 - g_ps2RecompiledFunctionTable[525204] = sjx_sndcbf_0x300dc0; // 0x300e58 - g_ps2RecompiledFunctionTable[525205] = sjx_sndcbf_0x300dc0; // 0x300e5c - g_ps2RecompiledFunctionTable[525206] = sjx_sndcbf_0x300dc0; // 0x300e60 - g_ps2RecompiledFunctionTable[525207] = sjx_sndcbf_0x300dc0; // 0x300e64 - g_ps2RecompiledFunctionTable[525208] = sjx_sndcbf_0x300dc0; // 0x300e68 - g_ps2RecompiledFunctionTable[525209] = sjx_sndcbf_0x300dc0; // 0x300e6c - g_ps2RecompiledFunctionTable[525210] = sjx_sndcbf_0x300dc0; // 0x300e70 - g_ps2RecompiledFunctionTable[525211] = sjx_sndcbf_0x300dc0; // 0x300e74 - g_ps2RecompiledFunctionTable[525212] = sjx_sndcbf_0x300dc0; // 0x300e78 - g_ps2RecompiledFunctionTable[525213] = sjx_sndcbf_0x300dc0; // 0x300e7c - g_ps2RecompiledFunctionTable[525214] = sjx_sndcbf_0x300dc0; // 0x300e80 - g_ps2RecompiledFunctionTable[525215] = sjx_sndcbf_0x300dc0; // 0x300e84 - g_ps2RecompiledFunctionTable[525216] = sjx_sndcbf_0x300dc0; // 0x300e88 - g_ps2RecompiledFunctionTable[525217] = sjx_sndcbf_0x300dc0; // 0x300e8c - g_ps2RecompiledFunctionTable[525218] = sjx_sndcbf_0x300dc0; // 0x300e90 - g_ps2RecompiledFunctionTable[525219] = sjx_sndcbf_0x300dc0; // 0x300e94 - g_ps2RecompiledFunctionTable[525220] = sjx_sndcbf_0x300dc0; // 0x300e98 - g_ps2RecompiledFunctionTable[525221] = sjx_sndcbf_0x300dc0; // 0x300e9c - g_ps2RecompiledFunctionTable[525222] = sjx_sndcbf_0x300dc0; // 0x300ea0 - g_ps2RecompiledFunctionTable[525223] = sjx_sndcbf_0x300dc0; // 0x300ea4 - g_ps2RecompiledFunctionTable[525224] = sjx_sndcbf_0x300dc0; // 0x300ea8 - g_ps2RecompiledFunctionTable[525225] = sjx_sndcbf_0x300dc0; // 0x300eac - g_ps2RecompiledFunctionTable[525226] = sjx_sndcbf_0x300dc0; // 0x300eb0 - g_ps2RecompiledFunctionTable[525227] = sjx_sndcbf_0x300dc0; // 0x300eb4 - g_ps2RecompiledFunctionTable[525228] = sjx_sndcbf_0x300dc0; // 0x300eb8 - g_ps2RecompiledFunctionTable[525229] = sjx_sndcbf_0x300dc0; // 0x300ebc - g_ps2RecompiledFunctionTable[525230] = sjx_sndcbf_0x300dc0; // 0x300ec0 - g_ps2RecompiledFunctionTable[525231] = sjx_sndcbf_0x300dc0; // 0x300ec4 - g_ps2RecompiledFunctionTable[525232] = sjx_sndcbf_0x300dc0; // 0x300ec8 - g_ps2RecompiledFunctionTable[525233] = sjx_sndcbf_0x300dc0; // 0x300ecc - g_ps2RecompiledFunctionTable[525234] = SJX_ExecServer_0x300ed0; // 0x300ed0 - g_ps2RecompiledFunctionTable[525236] = SJX_Init_0x300ed8; // 0x300ed8 - g_ps2RecompiledFunctionTable[525242] = SJX_Init_0x300ed8; // 0x300ef0 - g_ps2RecompiledFunctionTable[525254] = SJX_Init_0x300ed8; // 0x300f20 - g_ps2RecompiledFunctionTable[525260] = SJX_Init_0x300ed8; // 0x300f38 - g_ps2RecompiledFunctionTable[525278] = SJX_Init_0x300ed8; // 0x300f80 - g_ps2RecompiledFunctionTable[525283] = SJX_Init_0x300ed8; // 0x300f94 - g_ps2RecompiledFunctionTable[525284] = SJX_Init_0x300ed8; // 0x300f98 - g_ps2RecompiledFunctionTable[525296] = SJX_Init_0x300ed8; // 0x300fc8 - g_ps2RecompiledFunctionTable[525301] = SJX_Init_0x300ed8; // 0x300fdc - g_ps2RecompiledFunctionTable[525308] = SJX_Finish_0x300ff8; // 0x300ff8 - g_ps2RecompiledFunctionTable[525312] = SJX_Create_0x301008; // 0x301008 - g_ps2RecompiledFunctionTable[525328] = SJX_Create_0x301008; // 0x301048 - g_ps2RecompiledFunctionTable[525344] = SJX_Create_0x301008; // 0x301088 - g_ps2RecompiledFunctionTable[525357] = SJX_Create_0x301008; // 0x3010bc - g_ps2RecompiledFunctionTable[525362] = SJX_Create_0x301008; // 0x3010d0 - g_ps2RecompiledFunctionTable[525374] = SJX_Destroy_0x301100; // 0x301100 - g_ps2RecompiledFunctionTable[525386] = SJX_Destroy_0x301100; // 0x301130 - g_ps2RecompiledFunctionTable[525392] = SJX_Reset_0x301148; // 0x301148 - g_ps2RecompiledFunctionTable[525409] = SJX_Reset_0x301148; // 0x30118c - g_ps2RecompiledFunctionTable[525414] = Tim2_Format_Check_0x3011a0; // 0x3011a0 - g_ps2RecompiledFunctionTable[525440] = Tim2_Format_Check_0x3011a0; // 0x301208 - g_ps2RecompiledFunctionTable[525442] = Tim2_Format_Check_0x3011a0; // 0x301210 - g_ps2RecompiledFunctionTable[525451] = Tim2_Format_Check_0x3011a0; // 0x301234 - g_ps2RecompiledFunctionTable[525461] = Tim2_Format_Check_0x3011a0; // 0x30125c - g_ps2RecompiledFunctionTable[525466] = Tim2_Format_Check_0x3011a0; // 0x301270 - g_ps2RecompiledFunctionTable[525468] = Tim2_Format_Check_0x3011a0; // 0x301278 - g_ps2RecompiledFunctionTable[525472] = Tim2_Format_Check_0x3011a0; // 0x301288 - g_ps2RecompiledFunctionTable[525478] = BlockConv4to32_0x3012a0; // 0x3012a0 - g_ps2RecompiledFunctionTable[525488] = BlockConv4to32_0x3012a0; // 0x3012c8 - g_ps2RecompiledFunctionTable[525495] = BlockConv4to32_0x3012a0; // 0x3012e4 - g_ps2RecompiledFunctionTable[525496] = BlockConv4to32_0x3012a0; // 0x3012e8 - g_ps2RecompiledFunctionTable[525546] = BlockConv8to32_0x3013b0; // 0x3013b0 - g_ps2RecompiledFunctionTable[525550] = BlockConv8to32_0x3013b0; // 0x3013c0 - g_ps2RecompiledFunctionTable[525557] = BlockConv8to32_0x3013b0; // 0x3013dc - g_ps2RecompiledFunctionTable[525558] = BlockConv8to32_0x3013b0; // 0x3013e0 - g_ps2RecompiledFunctionTable[525582] = PageConv4to32_0x301440; // 0x301440 - g_ps2RecompiledFunctionTable[525599] = PageConv4to32_0x301440; // 0x301484 - g_ps2RecompiledFunctionTable[525611] = PageConv4to32_0x301440; // 0x3014b4 - g_ps2RecompiledFunctionTable[525624] = PageConv4to32_0x301440; // 0x3014e8 - g_ps2RecompiledFunctionTable[525626] = PageConv4to32_0x301440; // 0x3014f0 - g_ps2RecompiledFunctionTable[525651] = PageConv4to32_0x301440; // 0x301554 - g_ps2RecompiledFunctionTable[525658] = PageConv4to32_0x301440; // 0x301570 - g_ps2RecompiledFunctionTable[525666] = PageConv4to32_0x301440; // 0x301590 - g_ps2RecompiledFunctionTable[525670] = PageConv4to32_0x301440; // 0x3015a0 - g_ps2RecompiledFunctionTable[525678] = PageConv4to32_0x301440; // 0x3015c0 - g_ps2RecompiledFunctionTable[525688] = PageConv4to32_0x301440; // 0x3015e8 - g_ps2RecompiledFunctionTable[525692] = PageConv4to32_0x301440; // 0x3015f8 - g_ps2RecompiledFunctionTable[525730] = PageConv8to32_0x301690; // 0x301690 - g_ps2RecompiledFunctionTable[525748] = PageConv8to32_0x301690; // 0x3016d8 - g_ps2RecompiledFunctionTable[525750] = PageConv8to32_0x301690; // 0x3016e0 - g_ps2RecompiledFunctionTable[525775] = PageConv8to32_0x301690; // 0x301744 - g_ps2RecompiledFunctionTable[525782] = PageConv8to32_0x301690; // 0x301760 - g_ps2RecompiledFunctionTable[525790] = PageConv8to32_0x301690; // 0x301780 - g_ps2RecompiledFunctionTable[525794] = PageConv8to32_0x301690; // 0x301790 - g_ps2RecompiledFunctionTable[525802] = PageConv8to32_0x301690; // 0x3017b0 - g_ps2RecompiledFunctionTable[525812] = PageConv8to32_0x301690; // 0x3017d8 - g_ps2RecompiledFunctionTable[525816] = PageConv8to32_0x301690; // 0x3017e8 - g_ps2RecompiledFunctionTable[525854] = Conv4to32_0x301880; // 0x301880 - g_ps2RecompiledFunctionTable[525871] = Conv4to32_0x301880; // 0x3018c4 - g_ps2RecompiledFunctionTable[525883] = Conv4to32_0x301880; // 0x3018f4 - g_ps2RecompiledFunctionTable[525894] = Conv4to32_0x301880; // 0x301920 - g_ps2RecompiledFunctionTable[525908] = Conv4to32_0x301880; // 0x301958 - g_ps2RecompiledFunctionTable[525917] = Conv4to32_0x301880; // 0x30197c - g_ps2RecompiledFunctionTable[525972] = Conv4to32_0x301880; // 0x301a58 - g_ps2RecompiledFunctionTable[525986] = Conv4to32_0x301880; // 0x301a90 - g_ps2RecompiledFunctionTable[525994] = Conv4to32_0x301880; // 0x301ab0 - g_ps2RecompiledFunctionTable[525998] = Conv4to32_0x301880; // 0x301ac0 - g_ps2RecompiledFunctionTable[526009] = Conv4to32_0x301880; // 0x301aec - g_ps2RecompiledFunctionTable[526016] = Conv4to32_0x301880; // 0x301b08 - g_ps2RecompiledFunctionTable[526020] = Conv4to32_0x301880; // 0x301b18 - g_ps2RecompiledFunctionTable[526070] = Conv8to32_0x301be0; // 0x301be0 - g_ps2RecompiledFunctionTable[526087] = Conv8to32_0x301be0; // 0x301c24 - g_ps2RecompiledFunctionTable[526099] = Conv8to32_0x301be0; // 0x301c54 - g_ps2RecompiledFunctionTable[526110] = Conv8to32_0x301be0; // 0x301c80 - g_ps2RecompiledFunctionTable[526124] = Conv8to32_0x301be0; // 0x301cb8 - g_ps2RecompiledFunctionTable[526178] = Conv8to32_0x301be0; // 0x301d90 - g_ps2RecompiledFunctionTable[526192] = Conv8to32_0x301be0; // 0x301dc8 - g_ps2RecompiledFunctionTable[526200] = Conv8to32_0x301be0; // 0x301de8 - g_ps2RecompiledFunctionTable[526204] = Conv8to32_0x301be0; // 0x301df8 - g_ps2RecompiledFunctionTable[526215] = Conv8to32_0x301be0; // 0x301e24 - g_ps2RecompiledFunctionTable[526222] = Conv8to32_0x301be0; // 0x301e40 - g_ps2RecompiledFunctionTable[526226] = Conv8to32_0x301be0; // 0x301e50 - } -}; -static const GeneratedFunctionTableInitializer g_generatedFunctionTableInitializer; -} +extern const uint32_t g_ps2RecompiledFunctionTableBase = 0x00000000u; +extern const uint32_t g_ps2RecompiledFunctionTableEnd = 0x01000000u; +extern const uint32_t g_ps2RecompiledFunctionTableSlotCount = (g_ps2RecompiledFunctionTableEnd - g_ps2RecompiledFunctionTableBase) >> 2; +PS2Runtime::RecompiledFunction g_ps2RecompiledFunctionTable[g_ps2RecompiledFunctionTableSlotCount] = {}; \ No newline at end of file From 3b9b14c61813ac9be92659c993ddb8f7f686bc76 Mon Sep 17 00:00:00 2001 From: Ran-j Date: Thu, 13 Aug 2026 09:33:49 -0300 Subject: [PATCH 8/8] refactor: change GS architecture --- ps2xRuntime/CMakeLists.txt | 8 +- ps2xRuntime/include/ps2_runtime.h | 4 +- ps2xRuntime/include/runtime/gs/gs_backend.h | 33 + .../include/runtime/gs/gs_cpu_backend.h | 75 + .../{ps2_gs_gpu.h => gs/gs_frontend.h} | 290 +- ps2xRuntime/include/runtime/gs/gs_types.h | 315 ++ .../runtime/{ => gs}/ps2_gif_arbiter.h | 0 .../include/runtime/{ => gs}/ps2_gs_common.h | 2 +- .../include/runtime/{ => gs}/ps2_gs_memory.h | 0 .../include/runtime/{ => gs}/ps2_gs_psmct16.h | 0 .../include/runtime/{ => gs}/ps2_gs_psmct32.h | 0 .../include/runtime/{ => gs}/ps2_gs_psmt4.h | 0 .../include/runtime/{ => gs}/ps2_gs_psmt8.h | 0 .../include/runtime/ps2_gs_rasterizer.h | 22 - ps2xRuntime/include/runtime/ps2_memory.h | 2 +- ps2xRuntime/src/lib/Kernel/Stubs/GS.cpp | 4 +- ps2xRuntime/src/lib/gs/gs_cpu_backend.cpp | 1894 +++++++++++ ps2xRuntime/src/lib/gs/gs_frontend.cpp | 1733 ++++++++++ .../src/lib/{ => gs}/ps2_gif_arbiter.cpp | 2 +- .../src/lib/{ => gs}/ps2_gs_memory.cpp | 2 +- ps2xRuntime/src/lib/ps2_gs_gpu.cpp | 2961 ----------------- ps2xRuntime/src/lib/ps2_gs_rasterizer.cpp | 1102 ------ ps2xRuntime/src/lib/ps2_memory.cpp | 2 +- ps2xRuntime/src/lib/ps2_runtime.cpp | 2 +- ps2xRuntime/src/lib/ps2_vu1.cpp | 1 - ps2xRuntime/src/lib/vu/ps2_vu1_core.cpp | 4 +- ps2xRuntime/src/lib/vu/ps2_vu1_lower.cpp | 4 +- ps2xTest/src/ps2_gs_tests.cpp | 58 +- ps2xTest/src/ps2_memory_tests.cpp | 4 +- ps2xTest/src/ps2_runtime_expansion_tests.cpp | 4 +- ps2xTest/src/ps2_vu1_tests.cpp | 6 +- 31 files changed, 4146 insertions(+), 4388 deletions(-) create mode 100644 ps2xRuntime/include/runtime/gs/gs_backend.h create mode 100644 ps2xRuntime/include/runtime/gs/gs_cpu_backend.h rename ps2xRuntime/include/runtime/{ps2_gs_gpu.h => gs/gs_frontend.h} (56%) create mode 100644 ps2xRuntime/include/runtime/gs/gs_types.h rename ps2xRuntime/include/runtime/{ => gs}/ps2_gif_arbiter.h (100%) rename ps2xRuntime/include/runtime/{ => gs}/ps2_gs_common.h (97%) rename ps2xRuntime/include/runtime/{ => gs}/ps2_gs_memory.h (100%) rename ps2xRuntime/include/runtime/{ => gs}/ps2_gs_psmct16.h (100%) rename ps2xRuntime/include/runtime/{ => gs}/ps2_gs_psmct32.h (100%) rename ps2xRuntime/include/runtime/{ => gs}/ps2_gs_psmt4.h (100%) rename ps2xRuntime/include/runtime/{ => gs}/ps2_gs_psmt8.h (100%) delete mode 100644 ps2xRuntime/include/runtime/ps2_gs_rasterizer.h create mode 100644 ps2xRuntime/src/lib/gs/gs_cpu_backend.cpp create mode 100644 ps2xRuntime/src/lib/gs/gs_frontend.cpp rename ps2xRuntime/src/lib/{ => gs}/ps2_gif_arbiter.cpp (98%) rename ps2xRuntime/src/lib/{ => gs}/ps2_gs_memory.cpp (99%) delete mode 100644 ps2xRuntime/src/lib/ps2_gs_gpu.cpp delete mode 100644 ps2xRuntime/src/lib/ps2_gs_rasterizer.cpp delete mode 100644 ps2xRuntime/src/lib/ps2_vu1.cpp diff --git a/ps2xRuntime/CMakeLists.txt b/ps2xRuntime/CMakeLists.txt index 0a80a984b..e4dc1956d 100644 --- a/ps2xRuntime/CMakeLists.txt +++ b/ps2xRuntime/CMakeLists.txt @@ -377,12 +377,12 @@ endfunction() add_library(ps2_runtime STATIC src/lib/game_overrides.cpp - src/lib/ps2_gif_arbiter.cpp + src/lib/gs/ps2_gif_arbiter.cpp src/lib/ps2_audio.cpp src/lib/ps2_audio_vag.cpp - src/lib/ps2_gs_gpu.cpp - src/lib/ps2_gs_memory.cpp - src/lib/ps2_gs_rasterizer.cpp + src/lib/gs/ps2_gs_memory.cpp + src/lib/gs/gs_frontend.cpp + src/lib/gs/gs_cpu_backend.cpp src/lib/ps2_iop_host.cpp src/lib/ps2_memory.cpp src/lib/ps2_pad.cpp diff --git a/ps2xRuntime/include/ps2_runtime.h b/ps2xRuntime/include/ps2_runtime.h index 4259e12d2..a899408aa 100644 --- a/ps2xRuntime/include/ps2_runtime.h +++ b/ps2xRuntime/include/ps2_runtime.h @@ -24,9 +24,9 @@ #include "ps2_log.h" #include "runtime/ps2_address.h" -#include "runtime/ps2_gif_arbiter.h" +#include "runtime/gs/ps2_gif_arbiter.h" #include "runtime/ps2_memory.h" -#include "runtime/ps2_gs_gpu.h" +#include "runtime/gs/gs_frontend.h" #include "runtime/ps2_vu1.h" #include "runtime/ps2_audio.h" #include "runtime/ps2_pad.h" diff --git a/ps2xRuntime/include/runtime/gs/gs_backend.h b/ps2xRuntime/include/runtime/gs/gs_backend.h new file mode 100644 index 000000000..9419cc23a --- /dev/null +++ b/ps2xRuntime/include/runtime/gs/gs_backend.h @@ -0,0 +1,33 @@ +#pragma once + +#include "runtime/gs/gs_types.h" + +#include +#include + +class GSRasterBackend +{ +public: + virtual ~GSRasterBackend() = default; + + virtual void Initialize(uint8_t *vram, uint32_t vramSize) = 0; + virtual void Reset() = 0; + + virtual void Submit(const GSPrimitiveBatch &batch) = 0; + + virtual void BeginTransfer(const GSTransferCommand &command) = 0; + virtual void UploadImage(const uint8_t *data, uint32_t sizeBytes) = 0; + + virtual void Flush() = 0; + virtual void TextureFlush() = 0; + virtual void Sync(GSSyncReason reason) = 0; + virtual PresentationFrame Present(const GSPresentationRequest &request) = 0; + + virtual bool ClearFramebuffer(const GSContext &context, uint32_t rgba) = 0; + virtual uint32_t ConsumeLocalToHostBytes(uint8_t *dst, uint32_t maxBytes) = 0; + + virtual uint32_t ReadVram(uint32_t psm, uint32_t base, uint32_t bw, uint32_t x, uint32_t y) const = 0; + virtual void WriteVram(uint32_t psm, uint32_t base, uint32_t bw, uint32_t x, uint32_t y, uint32_t value) = 0; + virtual void SnapshotVram(std::vector &out) const = 0; + virtual GSTransferSnapshot GetTransferSnapshot() const = 0; +}; diff --git a/ps2xRuntime/include/runtime/gs/gs_cpu_backend.h b/ps2xRuntime/include/runtime/gs/gs_cpu_backend.h new file mode 100644 index 000000000..71e80324f --- /dev/null +++ b/ps2xRuntime/include/runtime/gs/gs_cpu_backend.h @@ -0,0 +1,75 @@ +#pragma once + +#include "runtime/gs/gs_backend.h" + +#include +#include +#include +#include + +class GSCpuBackend final : public GSRasterBackend +{ +public: + GSCpuBackend(); + + void Initialize(uint8_t *vram, uint32_t vramSize) override; + void Reset() override; + + void Submit(const GSPrimitiveBatch &batch) override; + void BeginTransfer(const GSTransferCommand &command) override; + void UploadImage(const uint8_t *data, uint32_t sizeBytes) override; + + void Flush() override; + void TextureFlush() override; + void Sync(GSSyncReason reason) override; + PresentationFrame Present(const GSPresentationRequest &request) override; + + bool ClearFramebuffer(const GSContext &context, uint32_t rgba) override; + uint32_t ConsumeLocalToHostBytes(uint8_t *dst, uint32_t maxBytes) override; + + uint32_t ReadVram(uint32_t psm, uint32_t base, uint32_t bw, uint32_t x, uint32_t y) const override; + void WriteVram(uint32_t psm, uint32_t base, uint32_t bw, uint32_t x, uint32_t y, uint32_t value) override; + void SnapshotVram(std::vector &out) const override; + GSTransferSnapshot GetTransferSnapshot() const override; + +private: + void ResetUnlocked(); + uint32_t ReadVramUnlocked(uint32_t psm, uint32_t base, uint32_t bw, uint32_t x, uint32_t y) const; + void WriteVramUnlocked(uint32_t psm, uint32_t base, uint32_t bw, uint32_t x, uint32_t y, uint32_t value); + + void DrawPrimitive(const GSPrimitiveBatch &batch); + void DrawSprite(const GSPrimitiveBatch &batch); + void DrawTriangle(const GSPrimitiveBatch &batch); + void DrawLine(const GSPrimitiveBatch &batch); + void WritePixel(const GSDrawState &state, int x, int y, int z, uint8_t r, uint8_t g, uint8_t b, uint8_t a, uint8_t fog); + uint32_t SampleTexture(const GSDrawState &state, float s, float t, float q, uint16_t u, uint16_t v); + uint32_t LookupCLUT(const GSDrawState &state, uint8_t index, uint32_t cbp, uint8_t cpsm, uint8_t csm, uint8_t csa, uint8_t sourcePsm); + + void PerformLocalToLocalTransfer(); + void PerformLocalToHostTransfer(); + PresentationFrame PresentFromLocalMemory(const GSPresentationRequest &request); + bool CopyFrameToHostRgba(const GSFrameReg &frame, + uint32_t width, + uint32_t height, + std::vector &outPixels, + bool preserveAlpha, + bool useLocalMemoryLayout, + bool frameBaseIsPages, + uint32_t sourceOriginX, + uint32_t sourceOriginY) const; + + using WriteVramFunc = std::function; + using ReadVramFunc = std::function; + + static constexpr size_t kPsmHandlerCount = 1u << 6u; + mutable std::mutex m_mutex; + uint8_t *m_vram = nullptr; + uint32_t m_vramSize = 0; + std::array m_readVramFuncs{}; + std::array m_writeVramFuncs{}; + + GSTransferCommand m_transfer{}; + GSTransferSnapshot m_transferState{}; + std::vector m_localToHostBuffer; + size_t m_localToHostReadPos = 0; +}; diff --git a/ps2xRuntime/include/runtime/ps2_gs_gpu.h b/ps2xRuntime/include/runtime/gs/gs_frontend.h similarity index 56% rename from ps2xRuntime/include/runtime/ps2_gs_gpu.h rename to ps2xRuntime/include/runtime/gs/gs_frontend.h index d968326f8..4c3f6410a 100644 --- a/ps2xRuntime/include/runtime/ps2_gs_gpu.h +++ b/ps2xRuntime/include/runtime/gs/gs_frontend.h @@ -1,229 +1,14 @@ -#ifndef PS2_GS_GPU_H -#define PS2_GS_GPU_H +#ifndef PS2_GS_FRONTEND_H +#define PS2_GS_FRONTEND_H #include #include -#include #include -#include +#include #include #include -#include "ps2_gs_rasterizer.h" -#include "ps2_gs_memory.h" - -enum GSPrimType : uint8_t -{ - GS_PRIM_POINT = 0, - GS_PRIM_LINE = 1, - GS_PRIM_LINESTRIP = 2, - GS_PRIM_TRIANGLE = 3, - GS_PRIM_TRISTRIP = 4, - GS_PRIM_TRIFAN = 5, - GS_PRIM_SPRITE = 6, -}; - -enum GSPsm : uint8_t -{ - GS_PSM_CT32 = 0, - GS_PSM_CT24 = 1, - GS_PSM_CT16 = 2, - GS_PSM_CT16S = 10, - GS_PSM_T8 = 19, - GS_PSM_T4 = 20, - GS_PSM_T8H = 27, - GS_PSM_T4HL = 36, - GS_PSM_T4HH = 44, - GS_PSM_Z32 = 48, - GS_PSM_Z24 = 49, - GS_PSM_Z16 = 50, - GS_PSM_Z16S = 58, -}; - -enum GSGifFormat : uint8_t -{ - GIF_FMT_PACKED = 0, - GIF_FMT_REGLIST = 1, - GIF_FMT_IMAGE = 2, - GIF_FMT_DISABLED = 3, -}; - -enum GSRegId : uint8_t -{ - GS_REG_PRIM = 0x00, - GS_REG_RGBAQ = 0x01, - GS_REG_ST = 0x02, - GS_REG_UV = 0x03, - GS_REG_XYZF2 = 0x04, - GS_REG_XYZ2 = 0x05, - GS_REG_TEX0_1 = 0x06, - GS_REG_TEX0_2 = 0x07, - GS_REG_CLAMP_1 = 0x08, - GS_REG_CLAMP_2 = 0x09, - GS_REG_FOG = 0x0A, - GS_REG_XYZF3 = 0x0C, - GS_REG_XYZ3 = 0x0D, - GS_REG_AD = 0x0F, - - GS_REG_TEX1_1 = 0x14, - GS_REG_TEX1_2 = 0x15, - GS_REG_TEX2_1 = 0x16, - GS_REG_TEX2_2 = 0x17, - GS_REG_XYOFFSET_1 = 0x18, - GS_REG_XYOFFSET_2 = 0x19, - GS_REG_PRMODECONT = 0x1A, - GS_REG_PRMODE = 0x1B, - GS_REG_TEXCLUT = 0x1C, - GS_REG_SCANMSK = 0x22, - GS_REG_MIPTBP1_1 = 0x34, - GS_REG_MIPTBP1_2 = 0x35, - GS_REG_MIPTBP2_1 = 0x36, - GS_REG_MIPTBP2_2 = 0x37, - GS_REG_TEXA = 0x3B, - GS_REG_FOGCOL = 0x3D, - GS_REG_TEXFLUSH = 0x3F, - GS_REG_SCISSOR_1 = 0x40, - GS_REG_SCISSOR_2 = 0x41, - GS_REG_ALPHA_1 = 0x42, - GS_REG_ALPHA_2 = 0x43, - GS_REG_DIMX = 0x44, - GS_REG_DTHE = 0x45, - GS_REG_COLCLAMP = 0x46, - GS_REG_TEST_1 = 0x47, - GS_REG_TEST_2 = 0x48, - GS_REG_PABE = 0x49, - GS_REG_FBA_1 = 0x4A, - GS_REG_FBA_2 = 0x4B, - GS_REG_FRAME_1 = 0x4C, - GS_REG_FRAME_2 = 0x4D, - GS_REG_ZBUF_1 = 0x4E, - GS_REG_ZBUF_2 = 0x4F, - GS_REG_BITBLTBUF = 0x50, - GS_REG_TRXPOS = 0x51, - GS_REG_TRXREG = 0x52, - GS_REG_TRXDIR = 0x53, - GS_REG_HWREG = 0x54, - GS_REG_SIGNAL = 0x60, - GS_REG_FINISH = 0x61, - GS_REG_LABEL = 0x62, -}; - -struct GSVertex -{ - float x, y; - // double because float isnt accurate enough for values near UINT32_MAX - double z; - uint8_t r, g, b, a; - float q; - float s, t; - uint16_t u, v; - uint8_t fog; -}; - -struct GSFrameReg -{ - uint32_t fbp; - uint32_t fbw; - uint8_t psm; - uint32_t fbmsk; -}; - -struct GSZbufReg -{ - u32 zbp; - u8 psm; - bool zmask; -}; - -struct GSScissorReg -{ - uint16_t x0, x1, y0, y1; -}; - -struct GSTex0Reg -{ - uint32_t tbp0; - uint8_t tbw; - uint8_t psm; - uint8_t tw; - uint8_t th; - uint8_t tcc; - uint8_t tfx; - uint32_t cbp; - uint8_t cpsm; - uint8_t csm; - uint8_t csa; - uint8_t cld; -}; - -struct GSXYOffsetReg -{ - uint16_t ofx; - uint16_t ofy; -}; - -struct GSTexaReg -{ - uint8_t ta0; - bool aem; - uint8_t ta1; -}; - -struct GSTexClutReg -{ - uint8_t cbw; - uint8_t cou; - uint16_t cov; -}; - -struct GSContext -{ - GSFrameReg frame; - GSScissorReg scissor; - GSTex0Reg tex0; - GSXYOffsetReg xyoffset; - GSZbufReg zbuf; - uint64_t tex1; - uint64_t clamp; - uint64_t alpha; - uint64_t test; - uint64_t fba; -}; - -struct GSPrimReg -{ - GSPrimType type; - bool iip; - bool tme; - bool fge; - bool abe; - bool aa1; - bool fst; - bool ctxt; - bool fix; -}; - -struct GSBitBltBuf -{ - uint32_t sbp; - uint8_t sbw; - uint8_t spsm; - uint32_t dbp; - uint8_t dbw; - uint8_t dpsm; -}; - -struct GSTrxPos -{ - uint16_t ssax, ssay; - uint16_t dsax, dsay; - uint8_t dir; -}; - -struct GSTrxReg -{ - uint16_t rrw, rrh; -}; +#include "runtime/gs/gs_backend.h" struct GSDebugSnapshot { @@ -231,6 +16,10 @@ struct GSDebugSnapshot GSPrimReg prim{}; GSTexaReg texa{}; GSTexClutReg texclut{}; + uint64_t scanmsk = 0; + uint64_t dimx = 0; + uint64_t dthe = 0; + uint64_t colclamp = 0; GSBitBltBuf bitbltbuf{}; GSTrxPos trxpos{}; GSTrxReg trxreg{}; @@ -307,18 +96,15 @@ struct GSDebugHistoryEntry bool usedPreferred = false; }; -class GSRasterizer; - class GS { - friend class GSRasterizer; - public: GS(); ~GS() = default; void init(uint8_t *vram, uint32_t vramSize, struct GSRegisters *privRegs = nullptr); void reset(); + void setRasterBackend(std::unique_ptr backend); void processGIFPacket(const uint8_t *data, uint32_t sizeBytes); bool processNativePackedGIFPacket(const uint8_t *data, uint32_t sizeBytes); @@ -359,8 +145,8 @@ class GS void refreshDisplaySnapshot(); - inline void WriteVram(u32 psm, uint32_t base, uint32_t bw, uint32_t x, uint32_t y, uint32_t value); - inline u32 ReadVram(u32 psm, u32 base, u32 bw, u32 x, u32 y) const; + void WriteVram(uint32_t psm, uint32_t base, uint32_t bw, uint32_t x, uint32_t y, uint32_t value); + uint32_t ReadVram(uint32_t psm, uint32_t base, uint32_t bw, uint32_t x, uint32_t y) const; private: void snapshotVRAM(); @@ -373,7 +159,6 @@ class GS const uint8_t *data, uint32_t sizeBytes); void vertexKick(bool drawing); - void latchHostPresentationFrameUnlocked(); void recordDebugEventUnlocked(GSDebugHistoryEntry entry); GSDebugHistoryEntry makeDebugEventUnlocked(GSDebugEventKind kind) const; @@ -385,24 +170,18 @@ class GS void processImageData(const uint8_t *data, uint32_t sizeBytes); bool tryProcessNativeImageUploadPacket(const uint8_t *data, uint32_t sizeBytes); - void performLocalToLocalTransfer(); - void performLocalToHostToBuffer(); - bool copyFrameToHostRgbaUnlocked(const GSFrameReg &frame, - uint32_t width, - uint32_t height, - std::vector &outPixels, - bool preserveAlpha = false, - bool useLocalMemoryLayout = false, - bool frameBaseIsPages = true, - uint32_t sourceOriginX = 0u, - uint32_t sourceOriginY = 0u) const; + GSPrimitiveBatch buildDrawBatch(int vertexCount) const; + void updatePreferredDisplaySourceForDraw(const GSPrimitiveBatch &batch); + GSPresentationRequest buildPresentationRequestUnlocked() const; + GSContext &activeContext(); - uint8_t *m_vram = nullptr; - uint32_t m_vramSize = 0; + uint8_t *m_localMemoryStorage = nullptr; + uint32_t m_localMemorySize = 0u; struct GSRegisters *m_privRegs = nullptr; mutable std::recursive_mutex m_stateMutex; + mutable std::mutex m_backendLifetimeMutex; mutable std::mutex m_presentationMutex; GSContext m_ctx[2]; @@ -419,6 +198,10 @@ class GS bool m_prmodecont = true; bool m_pabe = false; + uint64_t m_scanmsk = 0; + uint64_t m_dimx = 0; + uint64_t m_dthe = 0; + uint64_t m_colclamp = 0; GSTexaReg m_texa{0u, false, 0u}; GSTexClutReg m_texclut{0u, 0u, 0u}; @@ -427,13 +210,6 @@ class GS GSTrxReg m_trxreg{}; uint32_t m_trxdir = 3; - struct - { - uint32_t x{ 0 }; - uint32_t y{ 0 }; - uint32_t total_pixels{ 0 }; - uint32_t copied_pixels{ 0 }; - } m_transferState; static constexpr int kMaxVerts = 6; GSVertex m_vtxQueue[kMaxVerts]; @@ -456,9 +232,6 @@ class GS uint64_t m_nativeImageUploadCount = 0; uint64_t m_nativePackedGIFPacketCount = 0; - std::vector m_localToHostBuffer; - size_t m_localToHostReadPos = 0; - static constexpr size_t kDebugHistoryCapacity = 512; std::array m_debugHistory{}; size_t m_debugHistoryWrite = 0; @@ -468,24 +241,7 @@ class GS uint64_t m_debugLastVsyncTick = UINT64_MAX; bool m_debugHistoryPaused = true; - GSRasterizer m_rasterizer; - - using WriteVramFunc = std::function; - using ReadVramFunc = std::function; - - static constexpr size_t kPsmHandlerCount = 1u << 6u; - std::array m_read_vram_funcs{ }; - std::array m_write_vram_funcs{ }; + std::unique_ptr m_backend; }; -inline u32 GS::ReadVram(u32 psm, u32 base, u32 bw, u32 x, u32 y) const -{ - return m_read_vram_funcs[psm & 0x3F](m_vram, base, bw, x, y); -} - -inline void GS::WriteVram(u32 psm, u32 base, u32 bw, u32 x, u32 y, u32 value) -{ - m_write_vram_funcs[psm & 0x3F](m_vram, base, bw, x, y, value); -} - #endif diff --git a/ps2xRuntime/include/runtime/gs/gs_types.h b/ps2xRuntime/include/runtime/gs/gs_types.h new file mode 100644 index 000000000..836a3ff49 --- /dev/null +++ b/ps2xRuntime/include/runtime/gs/gs_types.h @@ -0,0 +1,315 @@ +#pragma once + +#include +#include +#include +#include + +enum GSPrimType : uint8_t +{ + GS_PRIM_POINT = 0, + GS_PRIM_LINE = 1, + GS_PRIM_LINESTRIP = 2, + GS_PRIM_TRIANGLE = 3, + GS_PRIM_TRISTRIP = 4, + GS_PRIM_TRIFAN = 5, + GS_PRIM_SPRITE = 6, +}; + +enum GSPsm : uint8_t +{ + GS_PSM_CT32 = 0, + GS_PSM_CT24 = 1, + GS_PSM_CT16 = 2, + GS_PSM_CT16S = 10, + GS_PSM_T8 = 19, + GS_PSM_T4 = 20, + GS_PSM_T8H = 27, + GS_PSM_T4HL = 36, + GS_PSM_T4HH = 44, + GS_PSM_Z32 = 48, + GS_PSM_Z24 = 49, + GS_PSM_Z16 = 50, + GS_PSM_Z16S = 58, +}; + +enum GSGifFormat : uint8_t +{ + GIF_FMT_PACKED = 0, + GIF_FMT_REGLIST = 1, + GIF_FMT_IMAGE = 2, + GIF_FMT_DISABLED = 3, +}; + +enum GSRegId : uint8_t +{ + GS_REG_PRIM = 0x00, + GS_REG_RGBAQ = 0x01, + GS_REG_ST = 0x02, + GS_REG_UV = 0x03, + GS_REG_XYZF2 = 0x04, + GS_REG_XYZ2 = 0x05, + GS_REG_TEX0_1 = 0x06, + GS_REG_TEX0_2 = 0x07, + GS_REG_CLAMP_1 = 0x08, + GS_REG_CLAMP_2 = 0x09, + GS_REG_FOG = 0x0A, + GS_REG_XYZF3 = 0x0C, + GS_REG_XYZ3 = 0x0D, + GS_REG_AD = 0x0F, + GS_REG_TEX1_1 = 0x14, + GS_REG_TEX1_2 = 0x15, + GS_REG_TEX2_1 = 0x16, + GS_REG_TEX2_2 = 0x17, + GS_REG_XYOFFSET_1 = 0x18, + GS_REG_XYOFFSET_2 = 0x19, + GS_REG_PRMODECONT = 0x1A, + GS_REG_PRMODE = 0x1B, + GS_REG_TEXCLUT = 0x1C, + GS_REG_SCANMSK = 0x22, + GS_REG_MIPTBP1_1 = 0x34, + GS_REG_MIPTBP1_2 = 0x35, + GS_REG_MIPTBP2_1 = 0x36, + GS_REG_MIPTBP2_2 = 0x37, + GS_REG_TEXA = 0x3B, + GS_REG_FOGCOL = 0x3D, + GS_REG_TEXFLUSH = 0x3F, + GS_REG_SCISSOR_1 = 0x40, + GS_REG_SCISSOR_2 = 0x41, + GS_REG_ALPHA_1 = 0x42, + GS_REG_ALPHA_2 = 0x43, + GS_REG_DIMX = 0x44, + GS_REG_DTHE = 0x45, + GS_REG_COLCLAMP = 0x46, + GS_REG_TEST_1 = 0x47, + GS_REG_TEST_2 = 0x48, + GS_REG_PABE = 0x49, + GS_REG_FBA_1 = 0x4A, + GS_REG_FBA_2 = 0x4B, + GS_REG_FRAME_1 = 0x4C, + GS_REG_FRAME_2 = 0x4D, + GS_REG_ZBUF_1 = 0x4E, + GS_REG_ZBUF_2 = 0x4F, + GS_REG_BITBLTBUF = 0x50, + GS_REG_TRXPOS = 0x51, + GS_REG_TRXREG = 0x52, + GS_REG_TRXDIR = 0x53, + GS_REG_HWREG = 0x54, + GS_REG_SIGNAL = 0x60, + GS_REG_FINISH = 0x61, + GS_REG_LABEL = 0x62, +}; + +struct GSVertex +{ + float x = 0.0f; + float y = 0.0f; + double z = 0.0; + uint8_t r = 0; + uint8_t g = 0; + uint8_t b = 0; + uint8_t a = 0; + float q = 1.0f; + float s = 0.0f; + float t = 0.0f; + uint16_t u = 0; + uint16_t v = 0; + uint8_t fog = 0; +}; + +struct GSFrameReg +{ + uint32_t fbp = 0; + uint32_t fbw = 0; + uint8_t psm = 0; + uint32_t fbmsk = 0; +}; + +struct GSZbufReg +{ + uint32_t zbp = 0; + uint8_t psm = 0; + bool zmask = false; +}; + +struct GSScissorReg +{ + uint16_t x0 = 0; + uint16_t x1 = 0; + uint16_t y0 = 0; + uint16_t y1 = 0; +}; + +struct GSTex0Reg +{ + uint32_t tbp0 = 0; + uint8_t tbw = 0; + uint8_t psm = 0; + uint8_t tw = 0; + uint8_t th = 0; + uint8_t tcc = 0; + uint8_t tfx = 0; + uint32_t cbp = 0; + uint8_t cpsm = 0; + uint8_t csm = 0; + uint8_t csa = 0; + uint8_t cld = 0; +}; + +struct GSXYOffsetReg +{ + uint16_t ofx = 0; + uint16_t ofy = 0; +}; + +struct GSTexaReg +{ + uint8_t ta0 = 0; + bool aem = false; + uint8_t ta1 = 0; +}; + +struct GSTexClutReg +{ + uint8_t cbw = 0; + uint8_t cou = 0; + uint16_t cov = 0; +}; + +struct GSContext +{ + GSFrameReg frame; + GSScissorReg scissor; + GSTex0Reg tex0; + GSXYOffsetReg xyoffset; + GSZbufReg zbuf; + uint64_t tex1 = 0; + uint64_t miptbp1 = 0; + uint64_t miptbp2 = 0; + uint64_t clamp = 0; + uint64_t alpha = 0; + uint64_t test = 0; + uint64_t fba = 0; +}; + +struct GSPrimReg +{ + GSPrimType type = GS_PRIM_POINT; + bool iip = false; + bool tme = false; + bool fge = false; + bool abe = false; + bool aa1 = false; + bool fst = false; + bool ctxt = false; + bool fix = false; +}; + +struct GSBitBltBuf +{ + uint32_t sbp = 0; + uint8_t sbw = 0; + uint8_t spsm = 0; + uint32_t dbp = 0; + uint8_t dbw = 0; + uint8_t dpsm = 0; +}; + +struct GSTrxPos +{ + uint16_t ssax = 0; + uint16_t ssay = 0; + uint16_t dsax = 0; + uint16_t dsay = 0; + uint8_t dir = 0; +}; + +struct GSTrxReg +{ + uint16_t rrw = 0; + uint16_t rrh = 0; +}; + +struct GSDrawState +{ + GSContext context{}; + GSPrimReg prim{}; + GSTexaReg texa{}; + GSTexClutReg texclut{}; + bool pabe = false; + uint64_t scanmsk = 0; + uint64_t dimx = 0; + uint64_t dthe = 0; + uint64_t colclamp = 0; + uint8_t fogR = 0; + uint8_t fogG = 0; + uint8_t fogB = 0; + uint16_t textureWidth = 1; + uint16_t textureHeight = 1; + bool linearFilter = false; +}; + +struct GSPrimitiveBatch +{ + std::array vertices{}; + uint8_t vertexCount = 0; + GSDrawState state{}; +}; + +struct GSTransferCommand +{ + GSBitBltBuf bitbltbuf{}; + GSTrxPos trxpos{}; + GSTrxReg trxreg{}; + uint32_t direction = 3; +}; + +struct GSTransferSnapshot +{ + uint32_t x = 0; + uint32_t y = 0; + uint32_t totalPixels = 0; + uint32_t copiedPixels = 0; + uint32_t direction = 3; + size_t localToHostPendingBytes = 0; +}; + +struct GSPresentationRequest +{ + uint64_t pmode = 0; + uint64_t smode2 = 0; + uint64_t dispfb1 = 0; + uint64_t display1 = 0; + uint64_t dispfb2 = 0; + uint64_t display2 = 0; + uint64_t bgcolor = 0; + uint64_t vsyncTick = 0; + GSFrameReg contextFrames[2]{}; + GSFrameReg preferredSource{}; + uint32_t preferredDestFbp = 0; + bool hasPreferredSource = false; +}; + +struct PresentationFrame +{ + std::vector pixels; + uint32_t width = 0; + uint32_t height = 0; + uint32_t displayFbp = 0; + uint32_t sourceFbp = 0; + bool usedPreferred = false; + + explicit operator bool() const + { + return !pixels.empty() && width != 0u && height != 0u; + } +}; + +enum class GSSyncReason : uint8_t +{ + Finish, + LocalToHost, + Presentation, + DebugReadback, + Reset, +}; diff --git a/ps2xRuntime/include/runtime/ps2_gif_arbiter.h b/ps2xRuntime/include/runtime/gs/ps2_gif_arbiter.h similarity index 100% rename from ps2xRuntime/include/runtime/ps2_gif_arbiter.h rename to ps2xRuntime/include/runtime/gs/ps2_gif_arbiter.h diff --git a/ps2xRuntime/include/runtime/ps2_gs_common.h b/ps2xRuntime/include/runtime/gs/ps2_gs_common.h similarity index 97% rename from ps2xRuntime/include/runtime/ps2_gs_common.h rename to ps2xRuntime/include/runtime/gs/ps2_gs_common.h index 3dfa8eb17..03306d3b0 100644 --- a/ps2xRuntime/include/runtime/ps2_gs_common.h +++ b/ps2xRuntime/include/runtime/gs/ps2_gs_common.h @@ -1,7 +1,7 @@ #ifndef PS2_GS_COMMON_H #define PS2_GS_COMMON_H -#include "ps2_gs_gpu.h" +#include "runtime/gs/gs_types.h" #include namespace GSInternal diff --git a/ps2xRuntime/include/runtime/ps2_gs_memory.h b/ps2xRuntime/include/runtime/gs/ps2_gs_memory.h similarity index 100% rename from ps2xRuntime/include/runtime/ps2_gs_memory.h rename to ps2xRuntime/include/runtime/gs/ps2_gs_memory.h diff --git a/ps2xRuntime/include/runtime/ps2_gs_psmct16.h b/ps2xRuntime/include/runtime/gs/ps2_gs_psmct16.h similarity index 100% rename from ps2xRuntime/include/runtime/ps2_gs_psmct16.h rename to ps2xRuntime/include/runtime/gs/ps2_gs_psmct16.h diff --git a/ps2xRuntime/include/runtime/ps2_gs_psmct32.h b/ps2xRuntime/include/runtime/gs/ps2_gs_psmct32.h similarity index 100% rename from ps2xRuntime/include/runtime/ps2_gs_psmct32.h rename to ps2xRuntime/include/runtime/gs/ps2_gs_psmct32.h diff --git a/ps2xRuntime/include/runtime/ps2_gs_psmt4.h b/ps2xRuntime/include/runtime/gs/ps2_gs_psmt4.h similarity index 100% rename from ps2xRuntime/include/runtime/ps2_gs_psmt4.h rename to ps2xRuntime/include/runtime/gs/ps2_gs_psmt4.h diff --git a/ps2xRuntime/include/runtime/ps2_gs_psmt8.h b/ps2xRuntime/include/runtime/gs/ps2_gs_psmt8.h similarity index 100% rename from ps2xRuntime/include/runtime/ps2_gs_psmt8.h rename to ps2xRuntime/include/runtime/gs/ps2_gs_psmt8.h diff --git a/ps2xRuntime/include/runtime/ps2_gs_rasterizer.h b/ps2xRuntime/include/runtime/ps2_gs_rasterizer.h deleted file mode 100644 index 17547ded8..000000000 --- a/ps2xRuntime/include/runtime/ps2_gs_rasterizer.h +++ /dev/null @@ -1,22 +0,0 @@ -#ifndef PS2_GS_RASTERIZER_H -#define PS2_GS_RASTERIZER_H - -#include - -class GS; - -class GSRasterizer -{ -public: - void drawPrimitive(GS *gs); - void writePixel(GS *gs, int x, int y, int z, uint8_t r, uint8_t g, uint8_t b, uint8_t a, uint8_t fog); - uint32_t sampleTexture(GS *gs, float s, float t, float q, uint16_t u, uint16_t v); - uint32_t lookupCLUT(GS *gs, uint8_t index, uint32_t cbp, uint8_t cpsm, uint8_t csm, uint8_t csa, uint8_t sourcePsm); - -private: - void drawSprite(GS *gs); - void drawTriangle(GS *gs); - void drawLine(GS *gs); -}; - -#endif diff --git a/ps2xRuntime/include/runtime/ps2_memory.h b/ps2xRuntime/include/runtime/ps2_memory.h index 9972e4221..cea5b98a8 100644 --- a/ps2xRuntime/include/runtime/ps2_memory.h +++ b/ps2xRuntime/include/runtime/ps2_memory.h @@ -11,7 +11,7 @@ #include #include -#include "ps2_gif_arbiter.h" +#include "gs/ps2_gif_arbiter.h" #if defined(_MSC_VER) #include #elif defined(USE_SSE2NEON) diff --git a/ps2xRuntime/src/lib/Kernel/Stubs/GS.cpp b/ps2xRuntime/src/lib/Kernel/Stubs/GS.cpp index b29df1bcd..9c5491990 100644 --- a/ps2xRuntime/src/lib/Kernel/Stubs/GS.cpp +++ b/ps2xRuntime/src/lib/Kernel/Stubs/GS.cpp @@ -1,8 +1,8 @@ #include "Common.h" #include "GS.h" #include "ps2_log.h" -#include "runtime/ps2_gs_common.h" -#include "runtime/ps2_gs_psmct16.h" +#include "runtime/gs/ps2_gs_common.h" +#include "runtime/gs/ps2_gs_psmct16.h" #include "runtime/ee_scheduler.h" namespace ps2_stubs diff --git a/ps2xRuntime/src/lib/gs/gs_cpu_backend.cpp b/ps2xRuntime/src/lib/gs/gs_cpu_backend.cpp new file mode 100644 index 000000000..9c39ae2e7 --- /dev/null +++ b/ps2xRuntime/src/lib/gs/gs_cpu_backend.cpp @@ -0,0 +1,1894 @@ +#include "runtime/gs/gs_cpu_backend.h" +#include "runtime/gs/ps2_gs_common.h" +#include "runtime/gs/ps2_gs_psmct16.h" +#include "runtime/gs/ps2_gs_psmct32.h" +#include "runtime/gs/ps2_gs_psmt4.h" +#include "runtime/gs/ps2_gs_psmt8.h" +#include "runtime/gs/ps2_gs_memory.h" +#include "ps2_log.h" +#include +#include +#include +#include +#include +#include +#include + +using namespace GSInternal; + +namespace +{ + float fabsQ(float q) + { + return (std::fabs(q) > 1.0e-8f) ? q : 1.0f; + } + + u16 Rgba8888ToRgba5551(u32 c) + { + uint32_t r = ((c >> 0) & 0xFF) >> 3; + uint32_t g = ((c >> 8) & 0xFF) >> 3; + uint32_t b = ((c >> 16) & 0xFF) >> 3; + uint32_t a = ((c >> 24) & 0xFF) >> 7; + + return (r | (g << 5) | (b << 10) | (a << 15)); + } + + u32 Rgba5551ToRgba8888(u16 c) + { + u32 r = ((c >> 0) & 0x1F) << 3; + u32 g = ((c >> 5) & 0x1F) << 3; + u32 b = ((c >> 10) & 0x1F) << 3; + u32 a = ((c >> 15) & 0x01) << 7; + + return (r | (g << 8) | (b << 16) | (a << 24)); + } + + u32 pack32(u8 r, u8 g, u8 b, u8 a) + { + return static_cast(r) | (g << 8) | (b << 16) | (a << 24); + } + + uint32_t applyTexa(const GSTexaReg &texa, uint8_t psm, uint32_t texel) + { + if (psm == GS_PSM_CT32) + return texel; + + const uint8_t r = static_cast(texel & 0xFFu); + const uint8_t g = static_cast((texel >> 8) & 0xFFu); + const uint8_t b = static_cast((texel >> 16) & 0xFFu); + const bool rgbZero = r == 0u && g == 0u && b == 0u; + uint8_t a = static_cast((texel >> 24) & 0xFFu); + + switch (psm) + { + case GS_PSM_CT24: + a = (texa.aem && rgbZero) ? 0u : texa.ta0; + break; + case GS_PSM_CT16: + case GS_PSM_CT16S: + if ((a & 0x80u) != 0u) + a = texa.ta1; + else + a = (texa.aem && rgbZero) ? 0u : texa.ta0; + break; + default: + break; + } + + return (texel & 0x00FFFFFFu) | (static_cast(a) << 24); + } + + uint32_t addrPSMCT16Family(uint32_t basePtr, uint32_t width, uint8_t psm, uint32_t x, uint32_t y) + { + switch (psm) + { + case GS_PSM_CT16: + return GSPSMCT16::addrPSMCT16(basePtr, width, x, y); + case GS_PSM_CT16S: + return GSPSMCT16::addrPSMCT16S(basePtr, width, x, y); + case GS_PSM_Z16: + return GSPSMCT16::addrPSMZ16(basePtr, width, x, y); + case GS_PSM_Z16S: + return GSPSMCT16::addrPSMZ16S(basePtr, width, x, y); + default: + return 0u; + } + } + + std::atomic s_debugPrimitiveCount{0}; + std::atomic s_debugPixelCount{0}; + std::atomic s_debugContext1PrimitiveCount{0}; + std::atomic s_debugFbp150PixelCount{0}; + + int wrapTextureCoordinate(int coordinate, + int textureSize, + uint8_t mode, + uint16_t regionMin, + uint16_t regionMax) + { + switch (mode & 0x3u) + { + case 0: // REPEAT + return static_cast(static_cast(coordinate) & static_cast(textureSize - 1)); + case 1: // CLAMP + return clampInt(coordinate, 0, textureSize - 1); + case 2: // REGION_CLAMP + return std::min(std::max(coordinate, static_cast(regionMin)), static_cast(regionMax)); + case 3: // REGION_REPEAT + return static_cast((static_cast(coordinate) & static_cast(regionMin)) | static_cast(regionMax)); + default: + return coordinate; + } + } + + bool passesAlphaTest(uint64_t testReg, uint8_t alpha) + { + if ((testReg & 0x1u) == 0u) + return true; + + const uint8_t atst = static_cast((testReg >> 1) & 0x7u); + const uint8_t aref = static_cast((testReg >> 4) & 0xFFu); + + switch (atst) + { + case 0: + return false; + case 1: + return true; + case 2: + return alpha < aref; + case 3: + return alpha <= aref; + case 4: + return alpha == aref; + case 5: + return alpha >= aref; + case 6: + return alpha > aref; + case 7: + return alpha != aref; + default: + return true; + } + } + + struct PixelWriteMask + { + bool writeRgb = true; + bool writeAlpha = true; + bool writeDepth = true; + + bool writesFramebuffer() const + { + return writeRgb || writeAlpha; + } + + bool writesAnything() const + { + return writesFramebuffer() || writeDepth; + } + }; + + PixelWriteMask classifyAlphaTest(uint64_t testReg, uint8_t alpha, uint8_t framePsm) + { + const bool pass = passesAlphaTest(testReg, alpha); + if (pass) + return {}; + + // TEST.AFAIL controls what happens when the alpha comparison fails. + switch (static_cast((testReg >> 12) & 0x3u)) + { + case 1: // FB_ONLY + return {true, true, false}; + case 2: // ZB_ONLY + return {false, false, true}; + case 3: // RGB_ONLY + // RGB_ONLY is only distinct for RGBA32. The GS treats it as + // FB_ONLY for RGB24 and RGBA16 framebuffers. + if (framePsm == GS_PSM_CT32) + return {true, false, false}; + return {true, true, false}; + case 0: // KEEP + default: + return {false, false, false}; + } + } + + bool passesDestinationAlphaTest(uint64_t testReg, uint8_t framePsm, uint32_t rawFramebufferPixel) + { + const bool date = ((testReg >> 14) & 0x1u) != 0u; + if (!date) + return true; + + const bool datm = ((testReg >> 15) & 0x1u) != 0u; + switch (framePsm) + { + case GS_PSM_CT32: + return (((rawFramebufferPixel >> 31) & 0x1u) != 0u) == datm; + case GS_PSM_CT16: + case GS_PSM_CT16S: + return (((rawFramebufferPixel >> 15) & 0x1u) != 0u) == datm; + case GS_PSM_CT24: + // RGB24 has no destination alpha, so DATE always passes. + return true; + default: + return true; + } + } + + struct TextureCombineResult + { + uint8_t r; + uint8_t g; + uint8_t b; + uint8_t a; + }; + + TextureCombineResult combineTexture(const GSTex0Reg &tex, + uint8_t vr, + uint8_t vg, + uint8_t vb, + uint8_t va, + uint8_t tr, + uint8_t tg, + uint8_t tb, + uint8_t ta) + { + const bool textureHasAlpha = tex.tcc != 0u; + TextureCombineResult out{tr, tg, tb, textureHasAlpha ? ta : va}; + + switch (tex.tfx) + { + case 0: // MODULATE + out.r = clampU8((tr * vr) >> 7); + out.g = clampU8((tg * vg) >> 7); + out.b = clampU8((tb * vb) >> 7); + out.a = textureHasAlpha ? clampU8((ta * va) >> 7) : va; + break; + case 1: // DECAL + out.r = tr; + out.g = tg; + out.b = tb; + out.a = textureHasAlpha ? ta : va; + break; + case 2: // HIGHLIGHT + out.r = clampU8(((tr * vr) >> 7) + va); + out.g = clampU8(((tg * vg) >> 7) + va); + out.b = clampU8(((tb * vb) >> 7) + va); + out.a = textureHasAlpha ? clampU8(ta + va) : va; + break; + case 3: // HIGHLIGHT2 + out.r = clampU8(((tr * vr) >> 7) + va); + out.g = clampU8(((tg * vg) >> 7) + va); + out.b = clampU8(((tb * vb) >> 7) + va); + out.a = textureHasAlpha ? ta : va; + break; + default: + out.r = tr; + out.g = tg; + out.b = tb; + out.a = textureHasAlpha ? ta : va; + break; + } + + return out; + } + + uint32_t swizzleClutIndexCSM1(uint32_t index) + { + // CSM1 swaps address bits 3 and 4. Preserve the remaining bits: + // 16-bit CLUTs expose a ninth address bit through CSA[4]. + return (index & ~0x18u) | ((index & 0x08u) << 1u) | ((index & 0x10u) >> 1u); + } + + // TODO: clut cache + uint32_t resolveClutIndex(uint8_t index, uint8_t cpsm, uint8_t csm, uint8_t csa, uint8_t sourcePsm) + { + uint32_t clutIndex = static_cast(index); + + // CSM2 addresses the source directly through TEXCLUT. CSA is required + // to be zero there, so it must not offset the source coordinates. + if (csm != 0u) + return (sourcePsm == GS_PSM_T4 || + sourcePsm == GS_PSM_T4HH || + sourcePsm == GS_PSM_T4HL) + ? (clutIndex & 0x0Fu) + : clutIndex; + + const bool is16BitClut = cpsm == GS_PSM_CT16 || cpsm == GS_PSM_CT16S; + const uint32_t csaMask = is16BitClut ? 0x1Fu : 0x0Fu; + const uint32_t clutIndexMask = is16BitClut ? 0x1FFu : 0x0FFu; + const uint32_t clutBase = (static_cast(csa) & csaMask) << 4u; + + switch (sourcePsm) + { + case GS_PSM_T4: + case GS_PSM_T4HH: + case GS_PSM_T4HL: + clutIndex = clutBase + (clutIndex & 0x0Fu); + break; + case GS_PSM_T8: + case GS_PSM_T8H: + clutIndex = clutBase + clutIndex; + break; + default: + return clutIndex; + } + + return swizzleClutIndexCSM1(clutIndex & clutIndexMask); + } + + uint8_t lerpChannel(uint8_t c00, uint8_t c10, uint8_t c01, uint8_t c11, float fx, float fy) + { + const float top = static_cast(c00) + (static_cast(c10) - static_cast(c00)) * fx; + const float bottom = static_cast(c01) + (static_cast(c11) - static_cast(c01)) * fx; + return clampU8(static_cast(std::lround(top + (bottom - top) * fy))); + } +} + +namespace +{ + static constexpr uint32_t kDefaultDisplayWidth = 640u; + static constexpr uint32_t kDefaultDisplayHeight = 448u; + static constexpr uint32_t kHostFrameWidth = 640u; + static constexpr uint32_t kHostFrameHeight = 512u; + + uint16_t encodeFramePixelPSMCT16(uint8_t r, uint8_t g, uint8_t b, uint8_t a) + { + return static_cast(((r >> 3) & 0x1Fu) | + (((g >> 3) & 0x1Fu) << 5) | + (((b >> 3) & 0x1Fu) << 10) | + ((a >= 0x40u) ? 0x8000u : 0u)); + } + + void decodeDisplaySize(uint64_t display64, uint32_t &outWidth, uint32_t &outHeight) + { + const uint32_t dw = static_cast((display64 >> 32) & 0x0FFFu); + const uint32_t dh = static_cast((display64 >> 44) & 0x07FFu); + const uint32_t magh = static_cast((display64 >> 23) & 0x0Fu); + + outWidth = (dw + 1u) / (magh + 1u); + outHeight = dh + 1u; + if (outWidth < 64u || outHeight < 64u) + { + outWidth = kDefaultDisplayWidth; + outHeight = kDefaultDisplayHeight; + } + outWidth = std::min(outWidth, kHostFrameWidth); + outHeight = std::min(outHeight, kHostFrameHeight); + } + + GSFrameReg decodeDisplayFrame(uint64_t dispfb64) + { + GSFrameReg frame{}; + frame.fbp = static_cast(dispfb64 & 0x1FFu); + frame.fbw = static_cast((dispfb64 >> 9) & 0x3Fu); + frame.psm = static_cast((dispfb64 >> 15) & 0x1Fu); + return frame; + } + + struct GSDisplayReadOrigin + { + uint32_t x = 0u; + uint32_t y = 0u; + }; + + GSDisplayReadOrigin decodeDisplayReadOrigin(uint64_t dispfb64) + { + return { + static_cast((dispfb64 >> 32) & 0x7FFu), + static_cast((dispfb64 >> 43) & 0x7FFu)}; + } + + bool hasDisplaySetup(uint64_t display64, const GSFrameReg &frame) + { + const uint32_t dw = static_cast((display64 >> 32) & 0x0FFFu); + const uint32_t dh = static_cast((display64 >> 44) & 0x07FFu); + const uint32_t magh = static_cast((display64 >> 23) & 0x0Fu); + return frame.fbw != 0u || dw != 0u || dh != 0u || magh != 0u; + } + + struct GSPmodeState + { + bool enableCrt1 = false; + bool enableCrt2 = false; + bool mmod = false; + bool amod = false; + bool slbg = false; + uint8_t alp = 0u; + }; + + GSPmodeState decodePmode(uint64_t pmode64) + { + return { + (pmode64 & 0x1ull) != 0ull, + (pmode64 & 0x2ull) != 0ull, + ((pmode64 >> 5) & 0x1ull) != 0ull, + ((pmode64 >> 6) & 0x1ull) != 0ull, + ((pmode64 >> 7) & 0x1ull) != 0ull, + static_cast((pmode64 >> 8) & 0xFFu)}; + } + + struct GSSmode2State + { + bool interlaced = false; + bool frameMode = true; + }; + + GSSmode2State decodeSMode2(uint64_t smode2) + { + return {(smode2 & 0x1ull) != 0ull, ((smode2 >> 1) & 0x1ull) != 0ull}; + } + + void applyFieldPresentation(std::vector &pixels, uint32_t width, uint32_t height, bool oddField) + { + if (pixels.empty() || width == 0u || height < 2u) + return; + const std::vector source = pixels; + for (uint32_t y = 0; y < height; ++y) + { + uint32_t sourceY = ((y >> 1u) << 1u) + (oddField ? 1u : 0u); + if (sourceY >= height) + sourceY = height - 1u; + std::memcpy(pixels.data() + y * kHostFrameWidth * 4u, + source.data() + sourceY * kHostFrameWidth * 4u, + width * 4u); + } + } + + void normalizePresentationAlpha(std::vector &pixels, uint32_t width, uint32_t height) + { + for (uint32_t y = 0; y < height; ++y) + { + uint8_t *row = pixels.data() + y * kHostFrameWidth * 4u; + for (uint32_t x = 0; x < width; ++x) + row[x * 4u + 3u] = 255u; + } + } + + uint8_t blendPresentationChannel(uint8_t src, uint8_t dst, uint32_t factor) + { + const int delta = static_cast(src) - static_cast(dst); + return GSInternal::clampU8(static_cast(dst) + ((delta * static_cast(factor)) / 255)); + } + + uint32_t countNonBlackPixels(const std::vector &pixels, uint32_t width, uint32_t height) + { + uint32_t count = 0u; + for (uint32_t y = 0; y < height; ++y) + { + const uint8_t *row = pixels.data() + y * kHostFrameWidth * 4u; + for (uint32_t x = 0; x < width; ++x) + { + if (row[x * 4u] != 0u || row[x * 4u + 1u] != 0u || row[x * 4u + 2u] != 0u) + ++count; + } + } + return count; + } +} + +GSCpuBackend::GSCpuBackend() +{ + using namespace GSMem; + static std::once_flag lookupTablesOnce; + std::call_once(lookupTablesOnce, []() + { InitLookupTables(); }); + for (size_t i = 0; i < kPsmHandlerCount; ++i) + { + switch (i) + { + case GS_PSM_CT32: + m_readVramFuncs[i] = ReadCT32; + m_writeVramFuncs[i] = WriteCT32; + break; + case GS_PSM_CT24: + m_readVramFuncs[i] = ReadCT24; + m_writeVramFuncs[i] = WriteCT24; + break; + case GS_PSM_CT16: + m_readVramFuncs[i] = ReadCT16; + m_writeVramFuncs[i] = WriteCT16; + break; + case GS_PSM_CT16S: + m_readVramFuncs[i] = ReadCT16S; + m_writeVramFuncs[i] = WriteCT16S; + break; + case GS_PSM_T8: + m_readVramFuncs[i] = ReadP8; + m_writeVramFuncs[i] = WriteP8; + break; + case GS_PSM_T8H: + m_readVramFuncs[i] = ReadP8H; + m_writeVramFuncs[i] = WriteP8H; + break; + case GS_PSM_T4: + m_readVramFuncs[i] = ReadP4; + m_writeVramFuncs[i] = WriteP4; + break; + case GS_PSM_T4HH: + m_readVramFuncs[i] = ReadP4HH; + m_writeVramFuncs[i] = WriteP4HH; + break; + case GS_PSM_T4HL: + m_readVramFuncs[i] = ReadP4HL; + m_writeVramFuncs[i] = WriteP4HL; + break; + case GS_PSM_Z32: + m_readVramFuncs[i] = ReadZ32; + m_writeVramFuncs[i] = WriteZ32; + break; + case GS_PSM_Z24: + m_readVramFuncs[i] = ReadZ24; + m_writeVramFuncs[i] = WriteZ24; + break; + case GS_PSM_Z16: + m_readVramFuncs[i] = ReadZ16; + m_writeVramFuncs[i] = WriteZ16; + break; + case GS_PSM_Z16S: + m_readVramFuncs[i] = ReadZ16S; + m_writeVramFuncs[i] = WriteZ16S; + break; + default: + m_readVramFuncs[i] = ReadNull; + m_writeVramFuncs[i] = WriteNull; + break; + } + } + Reset(); +} + +void GSCpuBackend::Initialize(uint8_t *vram, uint32_t vramSize) +{ + std::lock_guard lock(m_mutex); + m_vram = vram; + m_vramSize = vramSize; + ResetUnlocked(); +} + +void GSCpuBackend::Reset() +{ + std::lock_guard lock(m_mutex); + ResetUnlocked(); +} + +void GSCpuBackend::ResetUnlocked() +{ + m_transfer = {}; + m_transfer.direction = 3u; + m_transferState = {}; + m_transferState.direction = 3u; + m_localToHostBuffer.clear(); + m_localToHostReadPos = 0u; +} + +void GSCpuBackend::Submit(const GSPrimitiveBatch &batch) +{ + std::lock_guard lock(m_mutex); + if (!m_vram || batch.vertexCount == 0u) + return; + DrawPrimitive(batch); +} + +void GSCpuBackend::Flush() +{ + // CPU backend is immediate. GPU backends may submit command buffers here. +} + +void GSCpuBackend::TextureFlush() +{ + // CPU texture reads are coherent with local memory. Future cached/GPU + // backends use this boundary to invalidate texture views. +} + +void GSCpuBackend::Sync(GSSyncReason) +{ + // CPU backend is immediate. GPU backends may wait on fences/readbacks here. +} + +uint32_t GSCpuBackend::ReadVram(uint32_t psm, uint32_t base, uint32_t bw, uint32_t x, uint32_t y) const +{ + std::lock_guard lock(m_mutex); + return ReadVramUnlocked(psm, base, bw, x, y); +} + +uint32_t GSCpuBackend::ReadVramUnlocked(uint32_t psm, uint32_t base, uint32_t bw, uint32_t x, uint32_t y) const +{ + if (!m_vram) + return 0u; + return m_readVramFuncs[psm & 0x3Fu](m_vram, base, bw, x, y); +} + +void GSCpuBackend::WriteVram(uint32_t psm, uint32_t base, uint32_t bw, uint32_t x, uint32_t y, uint32_t value) +{ + std::lock_guard lock(m_mutex); + WriteVramUnlocked(psm, base, bw, x, y, value); +} + +void GSCpuBackend::WriteVramUnlocked(uint32_t psm, uint32_t base, uint32_t bw, uint32_t x, uint32_t y, uint32_t value) +{ + if (!m_vram) + return; + m_writeVramFuncs[psm & 0x3Fu](m_vram, base, bw, x, y, value); +} + +void GSCpuBackend::SnapshotVram(std::vector &out) const +{ + std::lock_guard lock(m_mutex); + if (!m_vram || m_vramSize == 0u) + { + out.clear(); + return; + } + out.resize(m_vramSize); + std::memcpy(out.data(), m_vram, m_vramSize); +} + +GSTransferSnapshot GSCpuBackend::GetTransferSnapshot() const +{ + std::lock_guard lock(m_mutex); + GSTransferSnapshot result = m_transferState; + result.localToHostPendingBytes = m_localToHostReadPos < m_localToHostBuffer.size() + ? m_localToHostBuffer.size() - m_localToHostReadPos + : 0u; + return result; +} + +void GSCpuBackend::DrawPrimitive(const GSPrimitiveBatch &batch) +{ + const GSDrawState &state = batch.state; + const auto &ctx = state.context; + PS2_IF_AGRESSIVE_LOGS({ + const uint32_t primitiveIndex = s_debugPrimitiveCount.fetch_add(1u, std::memory_order_relaxed); + if (primitiveIndex < 64u) + { + std::cout << "[gs:prim] idx=" << primitiveIndex + << " type=" << static_cast(state.prim.type) + << " tme=" << static_cast(state.prim.tme) + << " abe=" << static_cast(state.prim.abe) + << " fst=" << static_cast(state.prim.fst) + << " ctxt=" << static_cast(state.prim.ctxt) + << " fbp=" << ctx.frame.fbp + << " fbw=" << ctx.frame.fbw + << " psm=0x" << std::hex << static_cast(ctx.frame.psm) << std::dec + << " tex0=(" + << "tbp0=" << ctx.tex0.tbp0 + << " tbw=" << static_cast(ctx.tex0.tbw) + << " psm=0x" << std::hex << static_cast(ctx.tex0.psm) << std::dec + << " tw=" << static_cast(ctx.tex0.tw) + << " th=" << static_cast(ctx.tex0.th) + << " tcc=" << static_cast(ctx.tex0.tcc) + << " tfx=" << static_cast(ctx.tex0.tfx) + << " cbp=" << ctx.tex0.cbp + << " cpsm=0x" << std::hex << static_cast(ctx.tex0.cpsm) << std::dec + << " csm=" << static_cast(ctx.tex0.csm) + << " csa=" << static_cast(ctx.tex0.csa) + << ")" + << " texclut=(" + << "cbw=" << static_cast(state.texclut.cbw) + << " cou=" << static_cast(state.texclut.cou) + << " cov=" << state.texclut.cov + << ")" + << " ofx=" << (ctx.xyoffset.ofx >> 4) + << " ofy=" << (ctx.xyoffset.ofy >> 4) + << " scissor=(" << ctx.scissor.x0 + << "," << ctx.scissor.y0 + << ")-(" << ctx.scissor.x1 + << "," << ctx.scissor.y1 << ")" + << " test=0x" << std::hex << ctx.test + << " alpha=0x" << ctx.alpha + << std::dec + << " v0=(" << batch.vertices[0].x << "," << batch.vertices[0].y << ")" + << " uv0=(" << (batch.vertices[0].u >> 4) << "," << (batch.vertices[0].v >> 4) << ")" + << " stq0=(" << batch.vertices[0].s << "," << batch.vertices[0].t << "," << batch.vertices[0].q << ")" + << " v1=(" << batch.vertices[1].x << "," << batch.vertices[1].y << ")" + << " uv1=(" << (batch.vertices[1].u >> 4) << "," << (batch.vertices[1].v >> 4) << ")" + << " stq1=(" << batch.vertices[1].s << "," << batch.vertices[1].t << "," << batch.vertices[1].q << ")" + << " v2=(" << batch.vertices[2].x << "," << batch.vertices[2].y << ")" + << " uv2=(" << (batch.vertices[2].u >> 4) << "," << (batch.vertices[2].v >> 4) << ")" + << " stq2=(" << batch.vertices[2].s << "," << batch.vertices[2].t << "," << batch.vertices[2].q << ")" + << " rgba0=(" << static_cast(batch.vertices[0].r) << "," + << static_cast(batch.vertices[0].g) << "," + << static_cast(batch.vertices[0].b) << "," + << static_cast(batch.vertices[0].a) << ")" + << " rgba1=(" << static_cast(batch.vertices[1].r) << "," + << static_cast(batch.vertices[1].g) << "," + << static_cast(batch.vertices[1].b) << "," + << static_cast(batch.vertices[1].a) << ")" + << " rgba2=(" << static_cast(batch.vertices[2].r) << "," + << static_cast(batch.vertices[2].g) << "," + << static_cast(batch.vertices[2].b) << "," + << static_cast(batch.vertices[2].a) << ")" + << std::endl; + } + }); + + PS2_IF_AGRESSIVE_LOGS({ + if ((state.prim.ctxt != 0u || ctx.frame.fbp == 150u) && + s_debugContext1PrimitiveCount.fetch_add(1u, std::memory_order_relaxed) < 32u) + { + std::cout << "[gs:copy-prim]" + << " type=" << static_cast(state.prim.type) + << " tme=" << static_cast(state.prim.tme) + << " abe=" << static_cast(state.prim.abe) + << " fst=" << static_cast(state.prim.fst) + << " ctxt=" << static_cast(state.prim.ctxt) + << " fbp=" << ctx.frame.fbp + << " fbw=" << ctx.frame.fbw + << " psm=0x" << std::hex << static_cast(ctx.frame.psm) << std::dec + << " tex0=(" + << "tbp0=" << ctx.tex0.tbp0 + << " tbw=" << static_cast(ctx.tex0.tbw) + << " psm=0x" << std::hex << static_cast(ctx.tex0.psm) << std::dec + << " tcc=" << static_cast(ctx.tex0.tcc) + << " tfx=" << static_cast(ctx.tex0.tfx) + << " cbp=" << ctx.tex0.cbp + << " cpsm=0x" << std::hex << static_cast(ctx.tex0.cpsm) << std::dec + << " csm=" << static_cast(ctx.tex0.csm) + << " csa=" << static_cast(ctx.tex0.csa) + << ")" + << " texclut=(" + << "cbw=" << static_cast(state.texclut.cbw) + << " cou=" << static_cast(state.texclut.cou) + << " cov=" << state.texclut.cov + << ")" + << " ofx=" << (ctx.xyoffset.ofx >> 4) + << " ofy=" << (ctx.xyoffset.ofy >> 4) + << " scissor=(" << ctx.scissor.x0 + << "," << ctx.scissor.y0 + << ")-(" << ctx.scissor.x1 + << "," << ctx.scissor.y1 << ")" + << " test=0x" << std::hex << ctx.test + << " alpha=0x" << ctx.alpha + << std::dec << std::endl; + } + }); + + switch (state.prim.type) + { + case GS_PRIM_SPRITE: + DrawSprite(batch); + break; + case GS_PRIM_TRIANGLE: + case GS_PRIM_TRISTRIP: + case GS_PRIM_TRIFAN: + DrawTriangle(batch); + break; + case GS_PRIM_LINE: + case GS_PRIM_LINESTRIP: + DrawLine(batch); + break; + case GS_PRIM_POINT: + { + const GSVertex &v = batch.vertices[0]; + const auto &ctx = state.context; + int px = static_cast(v.x) - (ctx.xyoffset.ofx >> 4); + int py = static_cast(v.y) - (ctx.xyoffset.ofy >> 4); + WritePixel(state, px, py, static_cast(v.z), v.r, v.g, v.b, v.a, v.fog); + break; + } + default: + break; + } +} + +void GSCpuBackend::WritePixel(const GSDrawState &state, int x, int y, int z, uint8_t r, uint8_t g, uint8_t b, uint8_t a, uint8_t fog) +{ + const auto &ctx = state.context; + if (x < ctx.scissor.x0 || x > ctx.scissor.x1 || y < ctx.scissor.y0 || y > ctx.scissor.y1) + return; + + if (state.prim.fge) + { + const uint32_t inverseFog = 255u - fog; + auto applyFog = [&](uint8_t input, uint8_t fogColor) -> uint8_t + { + return static_cast(((static_cast(fog) * input) >> 8) + ((inverseFog * fogColor) >> 8)); + }; + + r = applyFog(r, state.fogR); + g = applyFog(g, state.fogG); + b = applyFog(b, state.fogB); + } + + const u32 fbp = GSInternal::framePageBaseToBlock(ctx.frame.fbp); + const u32 fbw = std::max(ctx.frame.fbw, 1u); + const u32 fpsm = ctx.frame.psm; + const u32 zbp = GSInternal::framePageBaseToBlock(ctx.zbuf.zbp); + const u32 zpsm = ctx.zbuf.psm; + + const PixelWriteMask writeMask = classifyAlphaTest(ctx.test, a, static_cast(fpsm)); + if (!writeMask.writesAnything()) + { + return; + } + + const uint32_t ztestMethod = static_cast((ctx.test >> 17) & 3u); + const bool alphaBlendEnabled = state.prim.abe; + const bool preserveDestinationAlpha = writeMask.writeRgb && !writeMask.writeAlpha && fpsm == GS_PSM_CT32; + const bool destinationAlphaTestNeedsRead = ((ctx.test >> 14) & 0x1u) != 0u && (fpsm == GS_PSM_CT32 || fpsm == GS_PSM_CT16 || fpsm == GS_PSM_CT16S); + + // small optimization, avoid reading the framebuffer for simple draws + // TODO: only one address lookup for rmw + const bool frmw = destinationAlphaTestNeedsRead || (writeMask.writesFramebuffer() && ((ctx.frame.fbmsk != 0) || alphaBlendEnabled || preserveDestinationAlpha)); + + u32 rawFramebufferPixel = 0; + u32 fbrgba = 0; + if (frmw) + { + rawFramebufferPixel = ReadVramUnlocked(fpsm, fbp, fbw, x, y); + fbrgba = rawFramebufferPixel; + + if (bitsPerPixel(fpsm) == 16) + { + fbrgba = Rgba5551ToRgba8888(fbrgba); + } + else if (fpsm == GS_PSM_CT24) + { + // The GS supplies 0x80 as destination alpha for RGB24 blending. + fbrgba |= 0x80000000u; + } + } + + if (!passesDestinationAlphaTest(ctx.test, static_cast(fpsm), rawFramebufferPixel)) + { + return; + } + + bool zpass = false; + uint32_t storedZ = 0u; + switch (ztestMethod) + { + case 0: + zpass = false; + break; + case 1: + zpass = true; + break; + case 2: + storedZ = ReadVramUnlocked(zpsm, zbp, fbw, x, y); + zpass = static_cast(z) >= storedZ; + break; + case 3: + storedZ = ReadVramUnlocked(zpsm, zbp, fbw, x, y); + zpass = static_cast(z) > storedZ; + break; + } + + if (!zpass) + { + return; + } + + if (writeMask.writesFramebuffer()) + { + const u8 srcR = r; + const u8 srcG = g; + const u8 srcB = b; + + if (state.prim.abe) + { + uint8_t dr = fbrgba & 0xFF; + uint8_t dg = (fbrgba >> 8) & 0xFF; + uint8_t db = (fbrgba >> 16) & 0xFF; + uint8_t da = (fbrgba >> 24) & 0xFF; + + // PABE disables alpha blending when the source alpha MSB is clear. + if (!(state.pabe && (a & 0x80u) == 0u)) + { + uint64_t alphaReg = ctx.alpha; + uint8_t asel = alphaReg & 3; + uint8_t bsel = (alphaReg >> 2) & 3; + uint8_t csel = (alphaReg >> 4) & 3; + uint8_t dsel = (alphaReg >> 6) & 3; + uint8_t fix = static_cast((alphaReg >> 32) & 0xFF); + + auto pickRGB = [&](uint8_t sel, int cs, int cd) -> int + { + if (sel == 0) + return cs; + if (sel == 1) + return cd; + return 0; + }; + int cAlpha = (csel == 0) ? a : (csel == 1) ? da + : fix; + + r = clampU8(((pickRGB(asel, r, dr) - pickRGB(bsel, r, dr)) * cAlpha >> 7) + pickRGB(dsel, r, dr)); + g = clampU8(((pickRGB(asel, g, dg) - pickRGB(bsel, g, dg)) * cAlpha >> 7) + pickRGB(dsel, g, dg)); + b = clampU8(((pickRGB(asel, b, db) - pickRGB(bsel, b, db)) * cAlpha >> 7) + pickRGB(dsel, b, db)); + } + else + { + r = srcR; + g = srcG; + b = srcB; + } + } + + if (writeMask.writeAlpha && (ctx.fba & 0x1ull) != 0ull && ctx.frame.psm != GS_PSM_CT24) + { + a = static_cast(a | 0x80u); + } + + u32 pixel = pack32(r, g, b, a); + + if (ctx.frame.fbmsk != 0) + { + pixel = (pixel & ~ctx.frame.fbmsk) | (fbrgba & ctx.frame.fbmsk); + } + + if (preserveDestinationAlpha) + { + pixel = (pixel & 0x00FFFFFFu) | (fbrgba & 0xFF000000u); + } + + // format conversion + if (bitsPerPixel(fpsm) == 16) + { + pixel = Rgba8888ToRgba5551(pixel); + } + + WriteVramUnlocked(fpsm, fbp, fbw, x, y, pixel); + } + + if (writeMask.writeDepth && !ctx.zbuf.zmask) + { + WriteVramUnlocked(zpsm, zbp, fbw, x, y, z); + } +} + +uint32_t GSCpuBackend::LookupCLUT(const GSDrawState &state, + uint8_t index, + uint32_t cbp, + uint8_t cpsm, + uint8_t csm, + uint8_t csa, + uint8_t sourcePsm) +{ + const uint32_t clutIndex = resolveClutIndex(index, cpsm, csm, csa, sourcePsm); + const uint32_t clutWidth = (state.texclut.cbw != 0u) ? static_cast(state.texclut.cbw) : 1u; + const uint32_t clutX = static_cast(state.texclut.cou) + (clutIndex & 0x0Fu); + const uint32_t clutY = static_cast(state.texclut.cov) + (clutIndex >> 4); + + switch (cpsm) + { + case GS_PSM_CT32: + return applyTexa(state.texa, cpsm, GSMem::ReadCT32(m_vram, cbp, clutWidth, clutX, clutY)); + case GS_PSM_CT24: + return applyTexa(state.texa, cpsm, GSMem::ReadCT24(m_vram, cbp, clutWidth, clutX, clutY)); + case GS_PSM_CT16: + return applyTexa(state.texa, cpsm, Rgba5551ToRgba8888(GSMem::ReadCT16(m_vram, cbp, clutWidth, clutX, clutY))); + case GS_PSM_CT16S: + return applyTexa(state.texa, cpsm, Rgba5551ToRgba8888(GSMem::ReadCT16S(m_vram, cbp, clutWidth, clutX, clutY))); + default: + break; + } + + return 0xFFFF00FFu; +} + +uint32_t GSCpuBackend::SampleTexture(const GSDrawState &state, float s, float t, float q, uint16_t u, uint16_t v) +{ + const auto &ctx = state.context; + const auto &tex = ctx.tex0; + + const int texW = state.textureWidth; + const int texH = state.textureHeight; + const uint64_t clamp = ctx.clamp; + const uint8_t wrapU = static_cast(clamp & 0x3u); + const uint8_t wrapV = static_cast((clamp >> 2) & 0x3u); + const uint16_t minU = static_cast((clamp >> 4) & 0x3FFu); + const uint16_t maxU = static_cast((clamp >> 14) & 0x3FFu); + const uint16_t minV = static_cast((clamp >> 24) & 0x3FFu); + const uint16_t maxV = static_cast((clamp >> 34) & 0x3FFu); + + float texUf, texVf; + if (state.prim.fst) + { + texUf = static_cast(u) / 16.0f; + texVf = static_cast(v) / 16.0f; + } + else + { + const float invQ = 1.0f / fabsQ(q); + texUf = s * invQ * static_cast(texW); + texVf = t * invQ * static_cast(texH); + } + + auto samplePoint = [&](int sampleU, int sampleV) -> uint32_t + { + sampleU = wrapTextureCoordinate(sampleU, texW, wrapU, minU, maxU); + sampleV = wrapTextureCoordinate(sampleV, texH, wrapV, minV, maxV); + + u32 out = ReadVramUnlocked(tex.psm, tex.tbp0, tex.tbw, sampleU, sampleV); + + switch (tex.psm) + { + case GS_PSM_CT32: + case GS_PSM_Z32: + case GS_PSM_CT24: + case GS_PSM_Z24: + return applyTexa(state.texa, tex.psm, out); + case GS_PSM_CT16: + case GS_PSM_CT16S: + case GS_PSM_Z16: + case GS_PSM_Z16S: + return applyTexa(state.texa, tex.psm, Rgba5551ToRgba8888(out)); + case GS_PSM_T8: + case GS_PSM_T8H: + case GS_PSM_T4: + case GS_PSM_T4HL: + case GS_PSM_T4HH: + return LookupCLUT(state, static_cast(out), tex.cbp, tex.cpsm, tex.csm, tex.csa, tex.psm); + } + + return 0xFFFF00FFu; + }; + + if (!state.linearFilter) + { + return samplePoint(static_cast(texUf), static_cast(texVf)); + } + + const float sampleU = texUf - 0.5f; + const float sampleV = texVf - 0.5f; + const int u0 = static_cast(std::floor(sampleU)); + const int v0 = static_cast(std::floor(sampleV)); + const int u1 = u0 + 1; + const int v1 = v0 + 1; + const float fx = sampleU - static_cast(u0); + const float fy = sampleV - static_cast(v0); + + const uint32_t c00 = samplePoint(u0, v0); + const uint32_t c10 = samplePoint(u1, v0); + const uint32_t c01 = samplePoint(u0, v1); + const uint32_t c11 = samplePoint(u1, v1); + + const uint8_t r = lerpChannel(static_cast(c00 & 0xFFu), + static_cast(c10 & 0xFFu), + static_cast(c01 & 0xFFu), + static_cast(c11 & 0xFFu), + fx, fy); + const uint8_t g = lerpChannel(static_cast((c00 >> 8) & 0xFFu), + static_cast((c10 >> 8) & 0xFFu), + static_cast((c01 >> 8) & 0xFFu), + static_cast((c11 >> 8) & 0xFFu), + fx, fy); + const uint8_t b = lerpChannel(static_cast((c00 >> 16) & 0xFFu), + static_cast((c10 >> 16) & 0xFFu), + static_cast((c01 >> 16) & 0xFFu), + static_cast((c11 >> 16) & 0xFFu), + fx, fy); + const uint8_t a = lerpChannel(static_cast((c00 >> 24) & 0xFFu), + static_cast((c10 >> 24) & 0xFFu), + static_cast((c01 >> 24) & 0xFFu), + static_cast((c11 >> 24) & 0xFFu), + fx, fy); + + return static_cast(r) | + (static_cast(g) << 8) | + (static_cast(b) << 16) | + (static_cast(a) << 24); +} + +void GSCpuBackend::DrawSprite(const GSPrimitiveBatch &batch) +{ + const GSDrawState &state = batch.state; + const GSVertex &v0 = batch.vertices[0]; + const GSVertex &v1 = batch.vertices[1]; + const auto &ctx = state.context; + + int ofx = ctx.xyoffset.ofx >> 4; + int ofy = ctx.xyoffset.ofy >> 4; + + int x0 = static_cast(v0.x) - ofx; + int y0 = static_cast(v0.y) - ofy; + int x1 = static_cast(v1.x) - ofx; + int y1 = static_cast(v1.y) - ofy; + u32 z1 = static_cast(v1.z); + + if (x0 > x1) + std::swap(x0, x1); + if (y0 > y1) + std::swap(y0, y1); + + const int unclippedX0 = x0; + const int unclippedY0 = y0; + const int spanX = std::max(1, x1 - x0); + const int spanY = std::max(1, y1 - y0); + const int unclippedX1 = unclippedX0 + spanX - 1; + const int unclippedY1 = unclippedY0 + spanY - 1; + + // If the sprite rectangle is fully outside scissor, nothing should render. + if (unclippedX1 < ctx.scissor.x0 || unclippedX0 > ctx.scissor.x1 || + unclippedY1 < ctx.scissor.y0 || unclippedY0 > ctx.scissor.y1) + return; + + const int drawX0 = clampInt(unclippedX0, ctx.scissor.x0, ctx.scissor.x1); + const int drawY0 = clampInt(unclippedY0, ctx.scissor.y0, ctx.scissor.y1); + const int drawX1 = clampInt(unclippedX1, ctx.scissor.x0, ctx.scissor.x1); + const int drawY1 = clampInt(unclippedY1, ctx.scissor.y0, ctx.scissor.y1); + + const uint64_t alphaReg = ctx.alpha; + const uint8_t alphaMode = static_cast(alphaReg & 0xFFu); + const uint8_t alphaFix = static_cast((alphaReg >> 32) & 0xFFu); + + uint8_t r = v1.r, g = v1.g, b = v1.b, a = v1.a; + + if (state.prim.tme) + { + const auto &tex = ctx.tex0; + const int texW = state.textureWidth; + const int texH = state.textureHeight; + + float u0f, v0f, u1f, v1f; + if (state.prim.fst) + { + u0f = static_cast(v0.u >> 4); + v0f = static_cast(v0.v >> 4); + u1f = static_cast(v1.u >> 4); + v1f = static_cast(v1.v >> 4); + } + else + { + const float q0 = fabsQ(v0.q); + const float q1 = fabsQ(v1.q); + u0f = (v0.s / q0) * static_cast(texW); + v0f = (v0.t / q0) * static_cast(texH); + u1f = (v1.s / q1) * static_cast(texW); + v1f = (v1.t / q1) * static_cast(texH); + } + + float spriteW = static_cast(spanX); + float spriteH = static_cast(spanY); + if (spriteW < 1.0f) + spriteW = 1.0f; + if (spriteH < 1.0f) + spriteH = 1.0f; + + for (int y = drawY0; y <= drawY1; ++y) + { + float ty = (static_cast(y - unclippedY0) + 0.5f) / spriteH; + float texVf = v0f + (v1f - v0f) * ty; + + for (int x = drawX0; x <= drawX1; ++x) + { + float tx = (static_cast(x - unclippedX0) + 0.5f) / spriteW; + float texUf = u0f + (u1f - u0f) * tx; + uint32_t texel = 0xFFFF00FFu; + if (state.prim.fst) + { + const int fixedU = static_cast((texUf * 16.0f) + 0.5f); + const int fixedV = static_cast((texVf * 16.0f) + 0.5f); + const uint16_t sampleU = static_cast(clampInt(fixedU, 0, 0xFFFF)); + const uint16_t sampleV = static_cast(clampInt(fixedV, 0, 0xFFFF)); + texel = SampleTexture(state, 0.0f, 0.0f, 1.0f, sampleU, sampleV); + } + else + { + texel = SampleTexture(state, texUf / static_cast(texW), texVf / static_cast(texH), 1.0f, 0u, 0u); + } + + uint8_t tr = static_cast(texel & 0xFF); + uint8_t tg = static_cast((texel >> 8) & 0xFF); + uint8_t tb = static_cast((texel >> 16) & 0xFF); + uint8_t ta = static_cast((texel >> 24) & 0xFF); + + const TextureCombineResult color = combineTexture(tex, r, g, b, a, tr, tg, tb, ta); + WritePixel(state, x, y, z1, color.r, color.g, color.b, color.a, v1.fog); + } + } + } + else + { + for (int y = drawY0; y <= drawY1; ++y) + for (int x = drawX0; x <= drawX1; ++x) + WritePixel(state, x, y, z1, r, g, b, a, v1.fog); + } +} + +void GSCpuBackend::DrawTriangle(const GSPrimitiveBatch &batch) +{ + const GSDrawState &state = batch.state; + const GSVertex &v0 = batch.vertices[0]; + const GSVertex &v1 = batch.vertices[1]; + const GSVertex &v2 = batch.vertices[2]; + const auto &ctx = state.context; + + int ofx = ctx.xyoffset.ofx >> 4; + int ofy = ctx.xyoffset.ofy >> 4; + + float fx0 = v0.x - static_cast(ofx); + float fy0 = v0.y - static_cast(ofy); + float fx1 = v1.x - static_cast(ofx); + float fy1 = v1.y - static_cast(ofy); + float fx2 = v2.x - static_cast(ofx); + float fy2 = v2.y - static_cast(ofy); + + int minX = static_cast(std::floor(std::min({fx0, fx1, fx2}))); + int maxX = static_cast(std::ceil(std::max({fx0, fx1, fx2}))); + int minY = static_cast(std::floor(std::min({fy0, fy1, fy2}))); + int maxY = static_cast(std::ceil(std::max({fy0, fy1, fy2}))); + + minX = clampInt(minX, ctx.scissor.x0, ctx.scissor.x1); + maxX = clampInt(maxX, ctx.scissor.x0, ctx.scissor.x1); + minY = clampInt(minY, ctx.scissor.y0, ctx.scissor.y1); + maxY = clampInt(maxY, ctx.scissor.y0, ctx.scissor.y1); + + float denom = (fy1 - fy2) * (fx0 - fx2) + (fx2 - fx1) * (fy0 - fy2); + if (std::fabs(denom) < 0.001f) + return; + + const float winding = (denom < 0.0f) ? -1.0f : 1.0f; + const float invAbsDenom = 1.0f / std::fabs(denom); + constexpr float kEdgeEpsilon = 1.0e-4f; + + for (int y = minY; y <= maxY; ++y) + { + float py = static_cast(y) + 0.5f; + for (int x = minX; x <= maxX; ++x) + { + float px = static_cast(x) + 0.5f; + + float w0 = (((fy1 - fy2) * (px - fx2) + (fx2 - fx1) * (py - fy2)) * winding) * invAbsDenom; + float w1 = (((fy2 - fy0) * (px - fx2) + (fx0 - fx2) * (py - fy2)) * winding) * invAbsDenom; + float w2 = 1.0f - w0 - w1; + + if (w0 < -kEdgeEpsilon || w1 < -kEdgeEpsilon || w2 < -kEdgeEpsilon) + continue; + + double z = v0.z * w0 + v1.z * w1 + v2.z * w2; + + uint8_t r, g, b, a; + if (state.prim.iip) + { + r = clampU8(static_cast(v0.r * w0 + v1.r * w1 + v2.r * w2)); + g = clampU8(static_cast(v0.g * w0 + v1.g * w1 + v2.g * w2)); + b = clampU8(static_cast(v0.b * w0 + v1.b * w1 + v2.b * w2)); + a = clampU8(static_cast(v0.a * w0 + v1.a * w1 + v2.a * w2)); + } + else + { + r = v2.r; + g = v2.g; + b = v2.b; + a = v2.a; + } + + if (state.prim.tme) + { + float is, it, iq; + uint16_t iu, iv; + if (state.prim.fst) + { + iu = static_cast(v0.u * w0 + v1.u * w1 + v2.u * w2); + iv = static_cast(v0.v * w0 + v1.v * w1 + v2.v * w2); + is = 0.0f; + it = 0.0f; + iq = 1.0f; + } + else + { + // The GS DDA interpolates the homogeneous S, T and Q + // values. Texel coordinates are calculated from S/Q and + // T/Q only after interpolation. + is = v0.s * w0 + v1.s * w1 + v2.s * w2; + it = v0.t * w0 + v1.t * w1 + v2.t * w2; + iq = v0.q * w0 + v1.q * w1 + v2.q * w2; + iu = 0; + iv = 0; + } + + uint32_t texel = SampleTexture(state, is, it, iq, iu, iv); + + uint8_t tr = static_cast(texel & 0xFF); + uint8_t tg = static_cast((texel >> 8) & 0xFF); + uint8_t tb = static_cast((texel >> 16) & 0xFF); + uint8_t ta = static_cast((texel >> 24) & 0xFF); + + const auto &tex = ctx.tex0; + const uint8_t shadeR = r; + const uint8_t shadeG = g; + const uint8_t shadeB = b; + const uint8_t shadeA = a; + const TextureCombineResult color = combineTexture(tex, shadeR, shadeG, shadeB, shadeA, tr, tg, tb, ta); + + r = color.r; + g = color.g; + b = color.b; + a = color.a; + } + + const uint8_t fog = clampU8(static_cast(v0.fog * w0 + v1.fog * w1 + v2.fog * w2)); + WritePixel(state, x, y, static_cast(z + 0.5), r, g, b, a, fog); + } + } +} + +void GSCpuBackend::DrawLine(const GSPrimitiveBatch &batch) +{ + const GSDrawState &state = batch.state; + const GSVertex &v0 = batch.vertices[0]; + const GSVertex &v1 = batch.vertices[1]; + const auto &ctx = state.context; + + int ofx = ctx.xyoffset.ofx >> 4; + int ofy = ctx.xyoffset.ofy >> 4; + + int x0 = static_cast(v0.x) - ofx; + int y0 = static_cast(v0.y) - ofy; + int x1 = static_cast(v1.x) - ofx; + int y1 = static_cast(v1.y) - ofy; + + int dx = std::abs(x1 - x0); + int dy = -std::abs(y1 - y0); + int sx = (x0 < x1) ? 1 : -1; + int sy = (y0 < y1) ? 1 : -1; + int err = dx + dy; + + int totalSteps = std::max(std::abs(x1 - x0), std::abs(y1 - y0)); + if (totalSteps == 0) + totalSteps = 1; + int step = 0; + + for (;;) + { + float t = static_cast(step) / static_cast(totalSteps); + uint8_t r, g, b, a; + if (state.prim.iip) + { + r = clampU8(static_cast(v0.r + (v1.r - v0.r) * t)); + g = clampU8(static_cast(v0.g + (v1.g - v0.g) * t)); + b = clampU8(static_cast(v0.b + (v1.b - v0.b) * t)); + a = clampU8(static_cast(v0.a + (v1.a - v0.a) * t)); + } + else + { + r = v1.r; + g = v1.g; + b = v1.b; + a = v1.a; + } + + double z = (v0.z + (v1.z - v0.z) * t); + const uint8_t fog = clampU8(static_cast(v0.fog + (v1.fog - v0.fog) * t)); + WritePixel(state, x0, y0, static_cast(z), r, g, b, a, fog); + + if (x0 == x1 && y0 == y1) + break; + + int e2 = 2 * err; + if (e2 >= dy) + { + err += dy; + x0 += sx; + } + if (e2 <= dx) + { + err += dx; + y0 += sy; + } + ++step; + } +} + +void GSCpuBackend::BeginTransfer(const GSTransferCommand &command) +{ + std::lock_guard lock(m_mutex); + m_transfer = command; + m_transferState.x = command.trxpos.dsax; + m_transferState.y = command.trxpos.dsay; + m_transferState.totalPixels = static_cast(command.trxreg.rrw) * static_cast(command.trxreg.rrh); + m_transferState.copiedPixels = 0u; + m_transferState.direction = command.direction; + m_transferState.localToHostPendingBytes = 0u; + + if (command.direction == 2u) + PerformLocalToLocalTransfer(); + else if (command.direction == 1u) + PerformLocalToHostTransfer(); +} + +void GSCpuBackend::UploadImage(const uint8_t *data, uint32_t sizeBytes) +{ + std::lock_guard lock(m_mutex); + if (!data || sizeBytes == 0u || !m_vram || m_transferState.direction != 0u) + return; + if (m_transfer.trxreg.rrw == 0u || m_transfer.trxreg.rrh == 0u || m_transferState.totalPixels == 0u) + return; + + const uint32_t dbp = m_transfer.bitbltbuf.dbp; + const uint32_t dbw = std::max(m_transfer.bitbltbuf.dbw, 1u); + const uint8_t dpsm = m_transfer.bitbltbuf.dpsm; + const uint32_t rrw = m_transfer.trxreg.rrw; + const uint32_t dsax = m_transfer.trxpos.dsax; + uint32_t offset = 0u; + + auto advancePixel = [&](uint32_t count) + { + const uint32_t totalPixels = m_transferState.totalPixels; + m_transferState.copiedPixels = + std::min(totalPixels, m_transferState.copiedPixels + count); + + if (m_transferState.copiedPixels >= totalPixels) + { + m_transferState.direction = 3u; + m_transferState.totalPixels = 0u; + return; + } + + m_transferState.x = dsax + (m_transferState.copiedPixels % rrw); + m_transferState.y = m_transfer.trxpos.dsay + (m_transferState.copiedPixels / rrw); + }; + + while (offset < sizeBytes && m_transferState.direction == 0u) + { + switch (dpsm) + { + case GS_PSM_CT32: + case GS_PSM_Z32: + { + if (sizeBytes - offset < 4u) + return; + uint32_t value = 0u; + std::memcpy(&value, data + offset, sizeof(value)); + WriteVramUnlocked(dpsm, dbp, dbw, m_transferState.x, m_transferState.y, value); + offset += 4u; + advancePixel(1u); + break; + } + case GS_PSM_CT24: + case GS_PSM_Z24: + { + if (sizeBytes - offset < 3u) + return; + const uint32_t value = static_cast(data[offset]) | + (static_cast(data[offset + 1u]) << 8u) | + (static_cast(data[offset + 2u]) << 16u); + WriteVramUnlocked(dpsm, dbp, dbw, m_transferState.x, m_transferState.y, value); + offset += 3u; + advancePixel(1u); + break; + } + case GS_PSM_CT16: + case GS_PSM_CT16S: + case GS_PSM_Z16: + case GS_PSM_Z16S: + { + if (sizeBytes - offset < 2u) + return; + uint16_t value = 0u; + std::memcpy(&value, data + offset, sizeof(value)); + WriteVramUnlocked(dpsm, dbp, dbw, m_transferState.x, m_transferState.y, value); + offset += 2u; + advancePixel(1u); + break; + } + case GS_PSM_T8: + case GS_PSM_T8H: + WriteVramUnlocked(dpsm, dbp, dbw, m_transferState.x, m_transferState.y, data[offset++]); + advancePixel(1u); + break; + case GS_PSM_T4: + case GS_PSM_T4HL: + case GS_PSM_T4HH: + { + const uint8_t packed = data[offset++]; + const uint32_t firstPixel = m_transferState.copiedPixels; + WriteVramUnlocked(dpsm, dbp, dbw, + dsax + (firstPixel % rrw), + m_transfer.trxpos.dsay + (firstPixel / rrw), + packed & 0x0Fu); + if (firstPixel + 1u < m_transferState.totalPixels) + { + const uint32_t secondPixel = firstPixel + 1u; + WriteVramUnlocked(dpsm, dbp, dbw, + dsax + (secondPixel % rrw), + m_transfer.trxpos.dsay + (secondPixel / rrw), + (packed >> 4u) & 0x0Fu); + } + advancePixel(std::min(2u, m_transferState.totalPixels - firstPixel)); + break; + } + default: + return; + } + } +} + +void GSCpuBackend::PerformLocalToLocalTransfer() +{ + if (!m_vram) + return; + + const uint32_t rrw = m_transfer.trxreg.rrw; + const uint32_t rrh = m_transfer.trxreg.rrh; + const uint32_t total = rrw * rrh; + if (total == 0u) + { + m_transferState.direction = 3u; + return; + } + + for (uint32_t pixel = 0; pixel < total; ++pixel) + { + uint32_t x = pixel % rrw; + uint32_t y = pixel / rrw; + if ((m_transfer.trxpos.dir & 0x2u) != 0u) + x = rrw - x - 1u; + if ((m_transfer.trxpos.dir & 0x1u) != 0u) + y = rrh - y - 1u; + + const uint32_t value = ReadVramUnlocked(m_transfer.bitbltbuf.spsm, + m_transfer.bitbltbuf.sbp, + std::max(m_transfer.bitbltbuf.sbw, 1u), + x + m_transfer.trxpos.ssax, + y + m_transfer.trxpos.ssay); + WriteVramUnlocked(m_transfer.bitbltbuf.dpsm, + m_transfer.bitbltbuf.dbp, + std::max(m_transfer.bitbltbuf.dbw, 1u), + x + m_transfer.trxpos.dsax, + y + m_transfer.trxpos.dsay, + value); + } + + m_transferState.copiedPixels = total; + m_transferState.direction = 3u; +} + +void GSCpuBackend::PerformLocalToHostTransfer() +{ + m_localToHostBuffer.clear(); + m_localToHostReadPos = 0u; + if (!m_vram) + return; + + const uint32_t rrw = m_transfer.trxreg.rrw; + const uint32_t rrh = m_transfer.trxreg.rrh; + const uint32_t sbw = std::max(m_transfer.bitbltbuf.sbw, 1u); + const uint8_t spsm = m_transfer.bitbltbuf.spsm; + const uint32_t bpp = static_cast(GSMem::BitsPerPixel(static_cast(spsm))); + const uint32_t total = rrw * rrh; + m_localToHostBuffer.reserve((static_cast(total) * bpp + 7u) / 8u); + + for (uint32_t pixel = 0u; pixel < total; ++pixel) + { + const uint32_t x = pixel % rrw; + const uint32_t y = pixel / rrw; + const uint32_t value = ReadVramUnlocked(spsm, + m_transfer.bitbltbuf.sbp, + sbw, + x + m_transfer.trxpos.ssax, + y + m_transfer.trxpos.ssay); + switch (bpp) + { + case 32: + m_localToHostBuffer.push_back(static_cast(value)); + m_localToHostBuffer.push_back(static_cast(value >> 8u)); + m_localToHostBuffer.push_back(static_cast(value >> 16u)); + m_localToHostBuffer.push_back(static_cast(value >> 24u)); + break; + case 24: + m_localToHostBuffer.push_back(static_cast(value)); + m_localToHostBuffer.push_back(static_cast(value >> 8u)); + m_localToHostBuffer.push_back(static_cast(value >> 16u)); + break; + case 16: + m_localToHostBuffer.push_back(static_cast(value)); + m_localToHostBuffer.push_back(static_cast(value >> 8u)); + break; + case 8: + m_localToHostBuffer.push_back(static_cast(value)); + break; + case 4: + { + if ((pixel & 1u) != 0u) + break; + uint32_t next = 0u; + if (pixel + 1u < total) + { + const uint32_t nextPixel = pixel + 1u; + const uint32_t nextX = nextPixel % rrw; + const uint32_t nextY = nextPixel / rrw; + next = ReadVramUnlocked(spsm, m_transfer.bitbltbuf.sbp, sbw, + nextX + m_transfer.trxpos.ssax, + nextY + m_transfer.trxpos.ssay); + } + m_localToHostBuffer.push_back(static_cast((value & 0x0Fu) | ((next & 0x0Fu) << 4u))); + break; + } + default: + break; + } + } + + m_transferState.copiedPixels = total; + m_transferState.localToHostPendingBytes = m_localToHostBuffer.size(); +} + +uint32_t GSCpuBackend::ConsumeLocalToHostBytes(uint8_t *dst, uint32_t maxBytes) +{ + std::lock_guard lock(m_mutex); + if (!dst || maxBytes == 0u || m_localToHostReadPos >= m_localToHostBuffer.size()) + return 0u; + const size_t count = std::min(maxBytes, m_localToHostBuffer.size() - m_localToHostReadPos); + std::memcpy(dst, m_localToHostBuffer.data() + m_localToHostReadPos, count); + m_localToHostReadPos += count; + m_transferState.localToHostPendingBytes = m_localToHostBuffer.size() - m_localToHostReadPos; + return static_cast(count); +} + +bool GSCpuBackend::ClearFramebuffer(const GSContext &context, uint32_t rgba) +{ + std::lock_guard lock(m_mutex); + if (!m_vram || context.frame.fbw == 0u) + return false; + + const uint32_t x0 = context.scissor.x0; + const uint32_t x1 = std::max(x0, context.scissor.x1); + const uint32_t y0 = context.scissor.y0; + const uint32_t y1 = std::max(y0, context.scissor.y1); + uint8_t r = static_cast(rgba); + uint8_t g = static_cast(rgba >> 8u); + uint8_t b = static_cast(rgba >> 16u); + uint8_t a = static_cast(rgba >> 24u); + if ((context.fba & 1ull) != 0ull && context.frame.psm != GS_PSM_CT24) + a |= 0x80u; + + const uint32_t fbp = GSInternal::framePageBaseToBlock(context.frame.fbp); + const uint32_t fbw = std::max(context.frame.fbw, 1u); + if (context.frame.psm == GS_PSM_CT32 || context.frame.psm == GS_PSM_CT24) + { + const uint32_t source = static_cast(r) | + (static_cast(g) << 8u) | + (static_cast(b) << 16u) | + (static_cast(a) << 24u); + for (uint32_t y = y0; y <= y1; ++y) + for (uint32_t x = x0; x <= x1; ++x) + { + uint32_t pixel = source; + if (context.frame.fbmsk != 0u) + { + const uint32_t old = ReadVramUnlocked(context.frame.psm, fbp, fbw, x, y); + pixel = (pixel & ~context.frame.fbmsk) | (old & context.frame.fbmsk); + } + WriteVramUnlocked(context.frame.psm, fbp, fbw, x, y, pixel); + } + return true; + } + + if (context.frame.psm == GS_PSM_CT16 || context.frame.psm == GS_PSM_CT16S) + { + const uint16_t source = encodeFramePixelPSMCT16(r, g, b, a); + const uint16_t mask = static_cast(context.frame.fbmsk); + for (uint32_t y = y0; y <= y1; ++y) + for (uint32_t x = x0; x <= x1; ++x) + { + uint16_t pixel = source; + if (mask != 0u) + { + const uint16_t old = static_cast(ReadVramUnlocked(context.frame.psm, fbp, fbw, x, y)); + pixel = static_cast((pixel & ~mask) | (old & mask)); + } + WriteVramUnlocked(context.frame.psm, fbp, fbw, x, y, pixel); + } + return true; + } + return false; +} + +bool GSCpuBackend::CopyFrameToHostRgba(const GSFrameReg &frame, + uint32_t width, + uint32_t height, + std::vector &outPixels, + bool preserveAlpha, + bool useLocalMemoryLayout, + bool frameBaseIsPages, + uint32_t sourceOriginX, + uint32_t sourceOriginY) const +{ + if (!m_vram || m_vramSize == 0u) + return false; + + outPixels.assign(kHostFrameWidth * kHostFrameHeight * 4u, 0u); + const uint32_t baseBytes = frameBaseIsPages ? frame.fbp * 8192u : frame.fbp * 256u; + const uint32_t basePtr = frameBaseIsPages ? GSInternal::framePageBaseToBlock(frame.fbp) : frame.fbp; + const uint32_t fbw = frame.fbw ? frame.fbw : kHostFrameWidth / 64u; + const uint32_t bytesPerPixel = (frame.psm == GS_PSM_CT16 || frame.psm == GS_PSM_CT16S) ? 2u : 4u; + const uint32_t stride = fbw * 64u * bytesPerPixel; + + for (uint32_t y = 0; y < height; ++y) + { + uint8_t *dst = outPixels.data() + y * kHostFrameWidth * 4u; + for (uint32_t x = 0; x < width; ++x) + { + const uint32_t sx = sourceOriginX + x; + const uint32_t sy = sourceOriginY + y; + if (frame.psm == GS_PSM_CT32 || frame.psm == GS_PSM_CT24) + { + uint32_t color = 0u; + if (useLocalMemoryLayout) + color = ReadVramUnlocked(frame.psm, basePtr, fbw, sx, sy); + else + { + const uint32_t pixelBytes = frame.psm == GS_PSM_CT24 ? 3u : 4u; + const uint64_t offset = static_cast(baseBytes) + static_cast(sy) * stride + static_cast(sx) * pixelBytes; + if (offset + pixelBytes > m_vramSize) + return false; + color = m_vram[offset] | (static_cast(m_vram[offset + 1u]) << 8u) | + (static_cast(m_vram[offset + 2u]) << 16u); + if (pixelBytes == 4u) + color |= static_cast(m_vram[offset + 3u]) << 24u; + } + dst[x * 4u] = static_cast(color); + dst[x * 4u + 1u] = static_cast(color >> 8u); + dst[x * 4u + 2u] = static_cast(color >> 16u); + dst[x * 4u + 3u] = preserveAlpha && frame.psm != GS_PSM_CT24 ? static_cast(color >> 24u) : 255u; + } + else if (frame.psm == GS_PSM_CT16 || frame.psm == GS_PSM_CT16S) + { + uint16_t color = 0u; + if (useLocalMemoryLayout) + color = static_cast(ReadVramUnlocked(frame.psm, basePtr, fbw, sx, sy)); + else + { + const uint64_t offset = static_cast(baseBytes) + static_cast(sy) * stride + static_cast(sx) * 2u; + if (offset + 2u > m_vramSize) + return false; + std::memcpy(&color, m_vram + offset, sizeof(color)); + } + const uint32_t r = color & 31u; + const uint32_t g = (color >> 5u) & 31u; + const uint32_t b = (color >> 10u) & 31u; + dst[x * 4u] = static_cast((r << 3u) | (r >> 2u)); + dst[x * 4u + 1u] = static_cast((g << 3u) | (g >> 2u)); + dst[x * 4u + 2u] = static_cast((b << 3u) | (b >> 2u)); + dst[x * 4u + 3u] = preserveAlpha ? ((color & 0x8000u) ? 0x80u : 0u) : 255u; + } + else + { + outPixels.clear(); + return false; + } + } + } + return true; +} + +PresentationFrame GSCpuBackend::Present(const GSPresentationRequest &request) +{ + // Snapshot local memory under the backend lock, then perform the expensive + // display conversion without holding the producer-side raster lock. + thread_local std::vector snapshot; + SnapshotVram(snapshot); + if (snapshot.empty()) + return {}; + + thread_local GSCpuBackend snapshotBackend; + snapshotBackend.Initialize(snapshot.data(), static_cast(snapshot.size())); + return snapshotBackend.PresentFromLocalMemory(request); +} + +PresentationFrame GSCpuBackend::PresentFromLocalMemory(const GSPresentationRequest &request) +{ + PresentationFrame result{}; + const GSPmodeState pmode = decodePmode(request.pmode); + const GSSmode2State smode2 = decodeSMode2(request.smode2); + const bool fieldMode = smode2.interlaced && !smode2.frameMode; + const bool oddField = (request.vsyncTick & 1ull) != 0ull; + const GSFrameReg displayFrame1 = decodeDisplayFrame(request.dispfb1); + const GSFrameReg displayFrame2 = decodeDisplayFrame(request.dispfb2); + const GSDisplayReadOrigin origin1 = decodeDisplayReadOrigin(request.dispfb1); + const GSDisplayReadOrigin origin2 = decodeDisplayReadOrigin(request.dispfb2); + uint32_t width1 = 0u, height1 = 0u, width2 = 0u, height2 = 0u; + decodeDisplaySize(request.display1, width1, height1); + decodeDisplaySize(request.display2, width2, height2); + const bool valid1 = pmode.enableCrt1 && hasDisplaySetup(request.display1, displayFrame1); + const bool valid2 = pmode.enableCrt2 && hasDisplaySetup(request.display2, displayFrame2); + if (!valid1 && !valid2) + return result; + + auto copySource = [&](const GSFrameReg &displayFrame, + const GSDisplayReadOrigin &origin, + uint32_t width, + uint32_t height, + bool allowPreferred, + bool preserveAlpha, + GSFrameReg &selected, + std::vector &pixels, + bool &usedPreferred) -> bool + { + selected = displayFrame; + pixels.clear(); + usedPreferred = false; + if (allowPreferred && request.hasPreferredSource && request.preferredDestFbp == displayFrame.fbp && + (request.preferredSource.fbw != 0u || request.preferredSource.fbp != displayFrame.fbp) && + CopyFrameToHostRgba(request.preferredSource, width, height, pixels, preserveAlpha, true, false, 0u, 0u)) + { + selected = request.preferredSource; + usedPreferred = true; + } + if (pixels.empty() && !CopyFrameToHostRgba(displayFrame, width, height, pixels, preserveAlpha, true, true, origin.x, origin.y)) + return false; + + if (!usedPreferred && displayFrame.fbp == 0u && countNonBlackPixels(pixels, width, height) == 0u) + { + for (const GSFrameReg &candidate : request.contextFrames) + { + if (candidate.fbp == selected.fbp && candidate.fbw == selected.fbw && candidate.psm == selected.psm) + continue; + std::vector candidatePixels; + if (!CopyFrameToHostRgba(candidate, width, height, candidatePixels, preserveAlpha, true, true, 0u, 0u)) + continue; + if (countNonBlackPixels(candidatePixels, width, height) == 0u) + continue; + selected = candidate; + pixels.swap(candidatePixels); + break; + } + } + return true; + }; + + if (valid1 && valid2) + { + GSFrameReg selected1{}, selected2{}; + std::vector crt1, crt2; + bool preferred1 = false, preferred2 = false; + if (copySource(displayFrame1, origin1, width1, height1, false, true, selected1, crt1, preferred1) && + copySource(displayFrame2, origin2, width2, height2, false, true, selected2, crt2, preferred2)) + { + result.width = std::max(width1, width2); + result.height = std::max(height1, height2); + result.pixels.assign(kHostFrameWidth * kHostFrameHeight * 4u, 0u); + const uint8_t bgR = static_cast(request.bgcolor); + const uint8_t bgG = static_cast(request.bgcolor >> 8u); + const uint8_t bgB = static_cast(request.bgcolor >> 16u); + for (uint32_t y = 0; y < result.height; ++y) + for (uint32_t x = 0; x < result.width; ++x) + { + uint8_t *dst = result.pixels.data() + (y * kHostFrameWidth + x) * 4u; + dst[0] = bgR; + dst[1] = bgG; + dst[2] = bgB; + dst[3] = pmode.alp; + } + if (!pmode.slbg) + for (uint32_t y = 0; y < height2; ++y) + std::memcpy(result.pixels.data() + y * kHostFrameWidth * 4u, crt2.data() + y * kHostFrameWidth * 4u, width2 * 4u); + for (uint32_t y = 0; y < height1; ++y) + for (uint32_t x = 0; x < width1; ++x) + { + const uint8_t *src = crt1.data() + (y * kHostFrameWidth + x) * 4u; + uint8_t *dst = result.pixels.data() + (y * kHostFrameWidth + x) * 4u; + const uint32_t factor = pmode.mmod ? pmode.alp : std::min(255u, static_cast(src[3]) * 2u); + dst[0] = blendPresentationChannel(src[0], dst[0], factor); + dst[1] = blendPresentationChannel(src[1], dst[1], factor); + dst[2] = blendPresentationChannel(src[2], dst[2], factor); + dst[3] = pmode.amod ? dst[3] : src[3]; + } + normalizePresentationAlpha(result.pixels, result.width, result.height); + if (fieldMode) + applyFieldPresentation(result.pixels, result.width, result.height, oddField); + result.displayFbp = displayFrame1.fbp; + result.sourceFbp = selected1.fbp; + return result; + } + } + + const GSFrameReg &displayFrame = valid1 ? displayFrame1 : displayFrame2; + const GSDisplayReadOrigin &origin = valid1 ? origin1 : origin2; + result.width = valid1 ? width1 : width2; + result.height = valid1 ? height1 : height2; + GSFrameReg selected = displayFrame; + if (!copySource(displayFrame, origin, result.width, result.height, true, false, selected, result.pixels, result.usedPreferred)) + return {}; + if (fieldMode) + applyFieldPresentation(result.pixels, result.width, result.height, oddField); + normalizePresentationAlpha(result.pixels, result.width, result.height); + result.displayFbp = displayFrame.fbp; + result.sourceFbp = selected.fbp; + return result; +} diff --git a/ps2xRuntime/src/lib/gs/gs_frontend.cpp b/ps2xRuntime/src/lib/gs/gs_frontend.cpp new file mode 100644 index 000000000..fd5a90d28 --- /dev/null +++ b/ps2xRuntime/src/lib/gs/gs_frontend.cpp @@ -0,0 +1,1733 @@ +#include "runtime/gs/gs_frontend.h" +#include "runtime/gs/gs_cpu_backend.h" +#include "ps2_log.h" +#include "runtime/ps2_memory.h" +#include +#include +#include +#include +#include +#include +#include + +namespace +{ + static constexpr uint32_t kHostFrameWidth = 640u; + + GSPrimReg decodePrimRegister(uint64_t value) + { + GSPrimReg prim{}; + prim.type = static_cast(value & 0x7u); + prim.iip = ((value >> 3) & 1u) != 0u; + prim.tme = ((value >> 4) & 1u) != 0u; + prim.fge = ((value >> 5) & 1u) != 0u; + prim.abe = ((value >> 6) & 1u) != 0u; + prim.aa1 = ((value >> 7) & 1u) != 0u; + prim.fst = ((value >> 8) & 1u) != 0u; + prim.ctxt = ((value >> 9) & 1u) != 0u; + prim.fix = ((value >> 10) & 1u) != 0u; + return prim; + } + + static inline uint64_t loadLE64(const uint8_t *p) + { + uint64_t v; + std::memcpy(&v, p, 8); + return v; + } + + struct PackedGifPacketTag + { + uint64_t lo = 0u; + uint64_t hi = 0u; + uint32_t payloadOffset = 0u; + uint32_t nloop = 0u; + uint32_t nreg = 0u; + uint8_t regs[16]{}; + }; + + template + bool visitPackedGifPacket(const uint8_t *data, uint32_t sizeBytes, Visitor &&visitor) + { + uint32_t offset = 0u; + while (offset + 16u <= sizeBytes) + { + PackedGifPacketTag tag{}; + tag.lo = loadLE64(data + offset); + tag.hi = loadLE64(data + offset + 8u); + + const uint8_t flg = static_cast((tag.lo >> 58u) & 0x3u); + if (flg != GIF_FMT_PACKED) + return false; + + tag.nloop = static_cast(tag.lo & 0x7FFFu); + tag.nreg = static_cast((tag.lo >> 60u) & 0xFu); + if (tag.nreg == 0u) + tag.nreg = 16u; + + const uint64_t payloadBytes64 = + static_cast(tag.nloop) * static_cast(tag.nreg) * 16ull; + if (payloadBytes64 > 0xFFFFFFFFull) + return false; + + offset += 16u; + const uint32_t payloadBytes = static_cast(payloadBytes64); + if (payloadBytes > sizeBytes - offset) + return false; + + tag.payloadOffset = offset; + for (uint32_t i = 0u; i < tag.nreg; ++i) + tag.regs[i] = static_cast((tag.hi >> (i * 4u)) & 0xFu); + + if (!visitor(tag)) + return false; + + offset += payloadBytes; + } + + return offset == sizeBytes; + } + + bool validatePackedGifPacket(const uint8_t *data, uint32_t sizeBytes) + { + return visitPackedGifPacket(data, sizeBytes, [](const PackedGifPacketTag &) + { return true; }); + } + + std::atomic s_debugGifPacketCount{0}; + std::atomic s_debugGsRegisterCount{0}; + std::atomic s_debugGsPackedVertexCount{0}; + std::atomic s_debugGsVertexKickCount{0}; + std::atomic s_debugCopyRegCount{0}; + std::atomic s_debugTexaWriteCount{0}; + std::atomic s_debugCvFontUploadCount{0}; + std::atomic s_debugLocalCopyCount{0}; +} + + +GS::GS() + : m_backend(std::make_unique()) +{ + reset(); +} + +void GS::init(uint8_t *vram, uint32_t vramSize, GSRegisters *privRegs) +{ + m_localMemoryStorage = vram; + m_localMemorySize = vramSize; + m_privRegs = privRegs; + if (!m_backend) + m_backend = std::make_unique(); + m_backend->Initialize(vram, vramSize); + reset(); +} + +void GS::reset() +{ + std::lock_guard lock(m_stateMutex); + std::memset(m_ctx, 0, sizeof(m_ctx)); + m_prim = {}; + m_primRegister = {}; + m_prmodeRegister = {}; + m_curR = 0x80; + m_curG = 0x80; + m_curB = 0x80; + m_curA = 0x80; + m_curQ = 1.0f; + m_curS = 0.0f; + m_curT = 0.0f; + m_curU = 0; + m_curV = 0; + m_curFog = 0; + m_fogR = 0; + m_fogG = 0; + m_fogB = 0; + m_prmodecont = true; + m_pabe = false; + m_scanmsk = 0u; + m_dimx = 0u; + m_dthe = 0u; + m_colclamp = 0u; + m_texa = {0u, false, 0u}; + m_texclut = {0u, 0u, 0u}; + m_bitbltbuf = {}; + m_trxpos = {}; + m_trxreg = {}; + m_trxdir = 3; + m_vtxCount = 0; + m_vtxIndex = 0; + m_preferredDisplaySourceFrame = {}; + m_preferredDisplayDestFbp = 0; + m_hasPreferredDisplaySource = false; + if (m_backend) + { + m_backend->Flush(); + m_backend->Sync(GSSyncReason::Reset); + m_backend->Reset(); + } + { + std::lock_guard presentationLock(m_presentationMutex); + m_hostPresentationFrame.clear(); + m_hostPresentationWidth = 0u; + m_hostPresentationHeight = 0u; + m_hostPresentationDisplayFbp = 0u; + m_hostPresentationSourceFbp = 0u; + m_hostPresentationUsedPreferred = false; + m_hasHostPresentationFrame = false; + } + + m_debugHistoryWrite = 0; + m_debugHistoryCount = 0; + m_debugNextSeq = 1; + m_debugFrameIndex = 0; + m_debugLastVsyncTick = UINT64_MAX; + + for (int i = 0; i < 2; ++i) + { + m_ctx[i].frame.fbw = 10; + m_ctx[i].scissor = {0, 639, 0, 447}; + m_ctx[i].xyoffset = {0, 0}; + } +} + +GSContext &GS::activeContext() +{ + return m_ctx[m_prim.ctxt ? 1 : 0]; +} + +void GS::snapshotVRAM() +{ + // Presentation/debug snapshots run outside m_stateMutex so the EE can keep + // feeding the GS while a backend performs host-side conversion. Keep the + // selected backend alive and unswappable for the duration of the call. + std::lock_guard backendLock(m_backendLifetimeMutex); + if (!m_backend) + return; + std::vector snapshot; + m_backend->Sync(GSSyncReason::DebugReadback); + m_backend->SnapshotVram(snapshot); + std::lock_guard lock(m_snapshotMutex); + m_displaySnapshot.swap(snapshot); +} + +const uint8_t *GS::lockDisplaySnapshot(uint32_t &outSize) +{ + m_snapshotMutex.lock(); + if (m_displaySnapshot.empty()) + { + outSize = 0; + return nullptr; + } + + outSize = static_cast(m_displaySnapshot.size()); + return m_displaySnapshot.data(); +} + +GSDebugSnapshot GS::getDebugSnapshot() const +{ + std::lock_guard lock(m_stateMutex); + + GSDebugSnapshot snapshot{}; + snapshot.ctx[0] = m_ctx[0]; + snapshot.ctx[1] = m_ctx[1]; + snapshot.prim = m_prim; + snapshot.texa = m_texa; + snapshot.texclut = m_texclut; + snapshot.scanmsk = m_scanmsk; + snapshot.dimx = m_dimx; + snapshot.dthe = m_dthe; + snapshot.colclamp = m_colclamp; + snapshot.bitbltbuf = m_bitbltbuf; + snapshot.trxpos = m_trxpos; + snapshot.trxreg = m_trxreg; + const GSTransferSnapshot transfer = m_backend ? m_backend->GetTransferSnapshot() : GSTransferSnapshot{}; + snapshot.trxdir = transfer.direction; + snapshot.transferX = transfer.x; + snapshot.transferY = transfer.y; + snapshot.transferTotalPixels = transfer.totalPixels; + snapshot.transferCopiedPixels = transfer.copiedPixels; + snapshot.lastDisplayBaseBytes = m_lastDisplayBaseBytes; + snapshot.preferredDisplaySourceFrame = m_preferredDisplaySourceFrame; + snapshot.preferredDisplayDestFbp = m_preferredDisplayDestFbp; + snapshot.hasPreferredDisplaySource = m_hasPreferredDisplaySource; + { + std::lock_guard presentationLock(m_presentationMutex); + snapshot.hostPresentationWidth = m_hostPresentationWidth; + snapshot.hostPresentationHeight = m_hostPresentationHeight; + snapshot.hostPresentationDisplayFbp = m_hostPresentationDisplayFbp; + snapshot.hostPresentationSourceFbp = m_hostPresentationSourceFbp; + snapshot.hostPresentationUsedPreferred = m_hostPresentationUsedPreferred; + snapshot.hasHostPresentationFrame = m_hasHostPresentationFrame; + } + snapshot.localToHostPendingBytes = transfer.localToHostPendingBytes; + return snapshot; +} + +std::vector GS::getDebugHistory() const +{ + std::lock_guard lock(m_stateMutex); + + std::vector out; + out.reserve(m_debugHistoryCount); + const size_t first = (m_debugHistoryWrite + kDebugHistoryCapacity - m_debugHistoryCount) % kDebugHistoryCapacity; + for (size_t i = 0; i < m_debugHistoryCount; ++i) + { + out.push_back(m_debugHistory[(first + i) % kDebugHistoryCapacity]); + } + return out; +} + +void GS::clearDebugHistory() +{ + std::lock_guard lock(m_stateMutex); + m_debugHistoryWrite = 0; + m_debugHistoryCount = 0; + m_debugNextSeq = 1; + m_debugFrameIndex = 0; + m_debugLastVsyncTick = UINT64_MAX; +} + +bool GS::isDebugHistoryPaused() const +{ + std::lock_guard lock(m_stateMutex); + return m_debugHistoryPaused; +} + +void GS::setDebugHistoryPaused(bool paused) +{ + std::lock_guard lock(m_stateMutex); + m_debugHistoryPaused = paused; +} + +GSDebugHistoryEntry GS::makeDebugEventUnlocked(GSDebugEventKind kind) const +{ + GSDebugHistoryEntry entry{}; + entry.kind = kind; + entry.prim = m_prim; + const uint32_t ci = m_prim.ctxt ? 1u : 0u; + entry.frame = m_ctx[ci].frame; + entry.zbuf = m_ctx[ci].zbuf; + entry.tex0 = m_ctx[ci].tex0; + entry.scissor = m_ctx[ci].scissor; + entry.test = m_ctx[ci].test; + entry.alpha = m_ctx[ci].alpha; + entry.bitbltbuf = m_bitbltbuf; + entry.trxpos = m_trxpos; + entry.trxreg = m_trxreg; + const GSTransferSnapshot transfer = m_backend ? m_backend->GetTransferSnapshot() : GSTransferSnapshot{}; + entry.trxdir = transfer.direction; + entry.transferPixels = transfer.totalPixels; + return entry; +} + +void GS::recordDebugEventUnlocked(GSDebugHistoryEntry entry) +{ + if (m_debugHistoryPaused) + { + return; + } + + const uint64_t tick = m_privRegs ? m_privRegs->vsyncTick.load(std::memory_order_acquire) : 0u; + if (m_debugLastVsyncTick == UINT64_MAX) + { + m_debugLastVsyncTick = tick; + } + else if (tick != m_debugLastVsyncTick) + { + ++m_debugFrameIndex; + m_debugLastVsyncTick = tick; + } + + entry.seq = m_debugNextSeq++; + entry.vsyncTick = tick; + entry.frameIndex = m_debugFrameIndex; + + m_debugHistory[m_debugHistoryWrite] = entry; + m_debugHistoryWrite = (m_debugHistoryWrite + 1u) % kDebugHistoryCapacity; + if (m_debugHistoryCount < kDebugHistoryCapacity) + { + ++m_debugHistoryCount; + } +} + +void GS::recordGifTagDebugEventUnlocked(uint32_t sizeBytes, uint32_t nloop, uint8_t flg, uint32_t nreg) +{ + if (m_debugHistoryPaused) + { + return; + } + + GSDebugHistoryEntry entry = makeDebugEventUnlocked(GSDebugEventKind::GifTag); + entry.gifSizeBytes = sizeBytes; + entry.gifNloop = nloop; + entry.gifFlg = flg; + entry.gifNreg = static_cast(std::min(nreg, 16u)); + recordDebugEventUnlocked(entry); +} + +void GS::recordRegisterDebugEventUnlocked(uint8_t regAddr, uint64_t value) +{ + if (m_debugHistoryPaused) + { + return; + } + + switch (regAddr) + { + case GS_REG_PRIM: + case GS_REG_TEX0_1: + case GS_REG_TEX0_2: + case GS_REG_TEX2_1: + case GS_REG_TEX2_2: + case GS_REG_TEXA: + case GS_REG_TEXCLUT: + case GS_REG_FRAME_1: + case GS_REG_FRAME_2: + case GS_REG_ZBUF_1: + case GS_REG_ZBUF_2: + case GS_REG_ALPHA_1: + case GS_REG_ALPHA_2: + case GS_REG_TEST_1: + case GS_REG_TEST_2: + case GS_REG_SCISSOR_1: + case GS_REG_SCISSOR_2: + case GS_REG_XYOFFSET_1: + case GS_REG_XYOFFSET_2: + case GS_REG_BITBLTBUF: + case GS_REG_TRXPOS: + case GS_REG_TRXREG: + case GS_REG_TRXDIR: + break; + default: + return; + } + + GSDebugHistoryEntry entry = makeDebugEventUnlocked(GSDebugEventKind::Register); + entry.reg = regAddr; + entry.regValue = value; + recordDebugEventUnlocked(entry); +} + +void GS::recordDrawDebugEventUnlocked(int vertexCount) +{ + if (m_debugHistoryPaused) + { + return; + } + + if (vertexCount <= 0) + { + return; + } + + GSDebugHistoryEntry entry = makeDebugEventUnlocked(GSDebugEventKind::Draw); + entry.vertexCount = static_cast(vertexCount); + + const int count = std::min(vertexCount, kMaxVerts); + entry.xMin = entry.xMax = m_vtxQueue[0].x; + entry.yMin = entry.yMax = m_vtxQueue[0].y; + entry.zMin = entry.zMax = m_vtxQueue[0].z; + entry.aMin = entry.aMax = m_vtxQueue[0].a; + + for (int i = 1; i < count; ++i) + { + const GSVertex &v = m_vtxQueue[i]; + entry.xMin = std::min(entry.xMin, v.x); + entry.xMax = std::max(entry.xMax, v.x); + entry.yMin = std::min(entry.yMin, v.y); + entry.yMax = std::max(entry.yMax, v.y); + entry.zMin = std::min(entry.zMin, v.z); + entry.zMax = std::max(entry.zMax, v.z); + entry.aMin = std::min(entry.aMin, v.a); + entry.aMax = std::max(entry.aMax, v.a); + } + + recordDebugEventUnlocked(entry); +} + +void GS::recordTransferDebugEventUnlocked() +{ + if (m_debugHistoryPaused) + { + return; + } + + GSDebugHistoryEntry entry = makeDebugEventUnlocked(GSDebugEventKind::Transfer); + entry.transferPixels = m_backend ? m_backend->GetTransferSnapshot().totalPixels : 0u; + recordDebugEventUnlocked(entry); +} + +void GS::recordPresentDebugEventUnlocked(uint32_t displayFbp, uint32_t sourceFbp, uint32_t width, uint32_t height, bool usedPreferred) +{ + if (m_debugHistoryPaused) + { + return; + } + + GSDebugHistoryEntry entry = makeDebugEventUnlocked(GSDebugEventKind::Present); + entry.displayFbp = displayFbp; + entry.sourceFbp = sourceFbp; + entry.width = width; + entry.height = height; + entry.usedPreferred = usedPreferred; + recordDebugEventUnlocked(entry); +} + +bool GS::getPreferredDisplaySource(GSFrameReg &outSource, uint32_t &outDestFbp) const +{ + std::lock_guard lock(m_stateMutex); + if (!m_hasPreferredDisplaySource) + { + outSource = {}; + outDestFbp = 0u; + return false; + } + + outSource = m_preferredDisplaySourceFrame; + outDestFbp = m_preferredDisplayDestFbp; + return true; +} + +void GS::unlockDisplaySnapshot() +{ + m_snapshotMutex.unlock(); +} + +uint32_t GS::getLastDisplayBaseBytes() const +{ + return m_lastDisplayBaseBytes; +} + +void GS::refreshDisplaySnapshot() +{ + snapshotVRAM(); +} + +GSPresentationRequest GS::buildPresentationRequestUnlocked() const +{ + GSPresentationRequest request{}; + if (!m_privRegs) + return request; + request.pmode = m_privRegs->pmode; + request.smode2 = m_privRegs->smode2; + request.dispfb1 = m_privRegs->dispfb1; + request.display1 = m_privRegs->display1; + request.dispfb2 = m_privRegs->dispfb2; + request.display2 = m_privRegs->display2; + request.bgcolor = m_privRegs->bgcolor; + request.vsyncTick = m_privRegs->vsyncTick.load(std::memory_order_acquire); + request.contextFrames[0] = m_ctx[0].frame; + request.contextFrames[1] = m_ctx[1].frame; + request.preferredSource = m_preferredDisplaySourceFrame; + request.preferredDestFbp = m_preferredDisplayDestFbp; + request.hasPreferredSource = m_hasPreferredDisplaySource; + return request; +} + +void GS::latchHostPresentationFrame() +{ + GSPresentationRequest request{}; + { + std::lock_guard lock(m_stateMutex); + if (!m_backend || !m_privRegs) + { + std::lock_guard presentationLock(m_presentationMutex); + m_hostPresentationFrame.clear(); + m_hasHostPresentationFrame = false; + m_hostPresentationWidth = m_hostPresentationHeight = 0u; + return; + } + request = buildPresentationRequestUnlocked(); + } + + PresentationFrame frame{}; + { + std::lock_guard backendLock(m_backendLifetimeMutex); + if (m_backend) + { + m_backend->Flush(); + m_backend->Sync(GSSyncReason::Presentation); + frame = m_backend->Present(request); + } + } + + const bool hasFrame = static_cast(frame); + const uint32_t displayFbp = frame.displayFbp; + const uint32_t sourceFbp = frame.sourceFbp; + const uint32_t width = frame.width; + const uint32_t height = frame.height; + const bool usedPreferred = frame.usedPreferred; + { + std::lock_guard presentationLock(m_presentationMutex); + m_hostPresentationFrame = std::move(frame.pixels); + m_hostPresentationWidth = width; + m_hostPresentationHeight = height; + m_hostPresentationDisplayFbp = displayFbp; + m_hostPresentationSourceFbp = sourceFbp; + m_hostPresentationUsedPreferred = usedPreferred; + m_hasHostPresentationFrame = hasFrame; + } + + if (hasFrame) + { + std::lock_guard lock(m_stateMutex); + recordPresentDebugEventUnlocked(displayFbp, sourceFbp, width, height, usedPreferred); + } +} + +bool GS::copyLatchedHostPresentationFrame(std::vector &outPixels, + uint32_t &outWidth, + uint32_t &outHeight, + uint32_t *outDisplayFbp, + uint32_t *outSourceFbp, + bool *outUsedPreferred) const +{ + std::lock_guard lock(m_presentationMutex); + if (!m_hasHostPresentationFrame || m_hostPresentationFrame.empty()) + { + outPixels.clear(); + outWidth = 0u; + outHeight = 0u; + if (outDisplayFbp) + *outDisplayFbp = 0u; + if (outSourceFbp) + *outSourceFbp = 0u; + if (outUsedPreferred) + *outUsedPreferred = false; + return false; + } + + outWidth = m_hostPresentationWidth; + outHeight = m_hostPresentationHeight; + if (outDisplayFbp) + *outDisplayFbp = m_hostPresentationDisplayFbp; + if (outSourceFbp) + *outSourceFbp = m_hostPresentationSourceFbp; + if (outUsedPreferred) + *outUsedPreferred = m_hostPresentationUsedPreferred; + + const size_t packedRowBytes = static_cast(outWidth) * 4u; + outPixels.resize(packedRowBytes * static_cast(outHeight)); + if (outWidth != 0u && outHeight != 0u) + { + const size_t sourceRowBytes = static_cast(kHostFrameWidth) * 4u; + for (uint32_t y = 0; y < outHeight; ++y) + { + const size_t srcOffset = static_cast(y) * sourceRowBytes; + const size_t dstOffset = static_cast(y) * packedRowBytes; + if (srcOffset + packedRowBytes > m_hostPresentationFrame.size() || + dstOffset + packedRowBytes > outPixels.size()) + { + outPixels.clear(); + outWidth = 0u; + outHeight = 0u; + if (outDisplayFbp) + *outDisplayFbp = 0u; + if (outSourceFbp) + *outSourceFbp = 0u; + if (outUsedPreferred) + *outUsedPreferred = false; + return false; + } + + std::memcpy(outPixels.data() + dstOffset, + m_hostPresentationFrame.data() + srcOffset, + packedRowBytes); + } + } + return true; +} + +void GS::processGIFPacket(const uint8_t *data, uint32_t sizeBytes) +{ + std::lock_guard lock(m_stateMutex); + if (!data || sizeBytes < 16 || !m_backend) + return; + + if (tryProcessNativeImageUploadPacket(data, sizeBytes)) + return; + + PS2_IF_AGRESSIVE_LOGS({ + const uint32_t packetIndex = s_debugGifPacketCount.fetch_add(1, std::memory_order_relaxed); + if (packetIndex < 48u) + { + const uint64_t tagLo = loadLE64(data); + const uint32_t nloop = static_cast(tagLo & 0x7FFFu); + const uint8_t flg = static_cast((tagLo >> 58) & 0x3u); + uint32_t nreg = static_cast((tagLo >> 60) & 0xFu); + if (nreg == 0u) + nreg = 16u; + RUNTIME_LOG("[gs:gif] idx=" << packetIndex + << " size=" << sizeBytes + << " nloop=" << nloop + << " flg=" << static_cast(flg) + << " nreg=" << nreg + << " ctx0fbp=" << m_ctx[0].frame.fbp + << " ctx1fbp=" << m_ctx[1].frame.fbp + << std::endl); + } + }); + + uint32_t offset = 0; + while (offset + 16 <= sizeBytes) + { + uint64_t tagLo = loadLE64(data + offset); + uint64_t tagHi = loadLE64(data + offset + 8); + offset += 16; + + m_curQ = 1.0f; + + uint32_t nloop = static_cast(tagLo & 0x7FFF); + uint8_t flg = static_cast((tagLo >> 58) & 0x3); + uint32_t nreg = static_cast((tagLo >> 60) & 0xF); + if (nreg == 0) + nreg = 16; + + recordGifTagDebugEventUnlocked(sizeBytes, nloop, flg, nreg); + + bool pre = ((tagLo >> 46) & 1) != 0; + if (pre) + { + writeRegisterUnlocked(GS_REG_PRIM, (tagLo >> 47) & 0x7FF); + } + + uint8_t regs[16]; + for (uint32_t i = 0; i < nreg; ++i) + regs[i] = static_cast((tagHi >> (i * 4)) & 0xF); + + if (flg == GIF_FMT_PACKED) + { + for (uint32_t loop = 0; loop < nloop; ++loop) + { + for (uint32_t r = 0; r < nreg; ++r) + { + if (offset + 16 > sizeBytes) + return; + uint64_t lo = loadLE64(data + offset); + uint64_t hi = loadLE64(data + offset + 8); + offset += 16; + writeRegisterPacked(regs[r], lo, hi); + } + } + } + else if (flg == GIF_FMT_REGLIST) + { + for (uint32_t loop = 0; loop < nloop; ++loop) + { + for (uint32_t r = 0; r < nreg; ++r) + { + if (offset + 8 > sizeBytes) + return; + writeRegisterUnlocked(regs[r], loadLE64(data + offset)); + offset += 8; + } + } + if ((nloop * nreg) & 1) + offset += 8; + } + else if (flg == GIF_FMT_IMAGE) + { + uint32_t imageBytes = nloop * 16; + if (offset + imageBytes > sizeBytes) + imageBytes = sizeBytes - offset; + processImageData(data + offset, imageBytes); + offset += imageBytes; + } + } +} + +bool GS::processNativePackedGIFPacket(const uint8_t *data, uint32_t sizeBytes) +{ + std::lock_guard lock(m_stateMutex); + if (!data || sizeBytes < 16u || !m_backend) + return false; + + if (!validatePackedGifPacket(data, sizeBytes)) + return false; + + const bool processed = visitPackedGifPacket(data, sizeBytes, [&](const PackedGifPacketTag &tag) + { + m_curQ = 1.0f; + + recordGifTagDebugEventUnlocked(sizeBytes, tag.nloop, GIF_FMT_PACKED, tag.nreg); + + const bool pre = ((tag.lo >> 46u) & 1u) != 0u; + if (pre) + writeRegisterUnlocked(GS_REG_PRIM, (tag.lo >> 47u) & 0x7FFu); + + uint32_t offset = tag.payloadOffset; + for (uint32_t loop = 0u; loop < tag.nloop; ++loop) + { + for (uint32_t r = 0u; r < tag.nreg; ++r) + { + const uint64_t lo = loadLE64(data + offset); + const uint64_t hi = loadLE64(data + offset + 8u); + offset += 16u; + writeRegisterPacked(tag.regs[r], lo, hi); + } + } + + return true; }); + + if (!processed) + return false; + + ++m_nativePackedGIFPacketCount; + return true; +} + +void GS::uploadImageNative(uint64_t bitbltbuf, + uint64_t trxpos, + uint64_t trxreg, + uint64_t trxdir, + const uint8_t *data, + uint32_t sizeBytes) +{ + std::lock_guard lock(m_stateMutex); + uploadImageNativeUnlocked(bitbltbuf, trxpos, trxreg, trxdir, data, sizeBytes); +} + +void GS::uploadImageNativeUnlocked(uint64_t bitbltbuf, + uint64_t trxpos, + uint64_t trxreg, + uint64_t trxdir, + const uint8_t *data, + uint32_t sizeBytes) +{ + if (!data || sizeBytes == 0 || !m_backend) + return; + + writeRegisterUnlocked(GS_REG_BITBLTBUF, bitbltbuf); + writeRegisterUnlocked(GS_REG_TRXPOS, trxpos); + writeRegisterUnlocked(GS_REG_TRXREG, trxreg); + writeRegisterUnlocked(GS_REG_TRXDIR, trxdir); + processImageData(data, sizeBytes); + ++m_nativeImageUploadCount; +} + +bool GS::tryProcessNativeImageUploadPacket(const uint8_t *data, uint32_t sizeBytes) +{ + constexpr uint32_t kSetupRegisters = 4u; + constexpr uint32_t kPackedAdPayloadBytes = kSetupRegisters * 16u; + constexpr uint64_t kPackedAdDescriptor = 0x0Eull; + + if (!data || sizeBytes < 16u + kPackedAdPayloadBytes + 16u) + return false; + + const uint64_t setupTagLo = loadLE64(data); + const uint64_t setupTagHi = loadLE64(data + 8u); + const uint32_t setupNloop = static_cast(setupTagLo & 0x7FFFu); + const uint8_t setupFlg = static_cast((setupTagLo >> 58u) & 0x3u); + uint32_t setupNreg = static_cast((setupTagLo >> 60u) & 0xFu); + if (setupNreg == 0u) + setupNreg = 16u; + + if (setupNloop != kSetupRegisters || + setupFlg != GIF_FMT_PACKED || + setupNreg != 1u || + (setupTagHi & 0xFull) != kPackedAdDescriptor) + { + return false; + } + + uint64_t regs[kSetupRegisters] = {}; + uint32_t offset = 16u; + constexpr uint8_t expectedRegs[kSetupRegisters] = { + GS_REG_BITBLTBUF, + GS_REG_TRXPOS, + GS_REG_TRXREG, + GS_REG_TRXDIR, + }; + + for (uint32_t i = 0; i < kSetupRegisters; ++i) + { + regs[i] = loadLE64(data + offset); + const uint64_t reg = loadLE64(data + offset + 8u); + if ((reg & 0xFFu) != expectedRegs[i]) + return false; + offset += 16u; + } + + const uint32_t trxdirMode = static_cast(regs[3] & 0x3ull); + const uint32_t rrw = static_cast(regs[2] & 0xFFFull); + const uint32_t rrh = static_cast((regs[2] >> 32u) & 0xFFFull); + if (trxdirMode != 0u || rrw == 0u || rrh == 0u) + return false; + + if (offset + 16u > sizeBytes) + return false; + + const uint64_t imageTagLo = loadLE64(data + offset); + const uint8_t imageFlg = static_cast((imageTagLo >> 58u) & 0x3u); + const uint32_t imageNloop = static_cast(imageTagLo & 0x7FFFu); + if (imageFlg != GIF_FMT_IMAGE || imageNloop == 0u) + return false; + + offset += 16u; + const uint64_t imageBytes64 = static_cast(imageNloop) * 16ull; + if (imageBytes64 > 0xFFFFFFFFull) + return false; + const uint32_t imageBytes = static_cast(imageBytes64); + if (offset + imageBytes != sizeBytes) + return false; + + uploadImageNativeUnlocked(regs[0], regs[1], regs[2], regs[3], data + offset, imageBytes); + return true; +} + +void GS::writeRegisterPacked(uint8_t regDesc, uint64_t lo, uint64_t hi) +{ + switch (regDesc) + { + case 0x00: + writeRegisterUnlocked(GS_REG_PRIM, lo & 0x7FF); + break; + case 0x01: + m_curR = static_cast(lo & 0xFF); + m_curG = static_cast((lo >> 32) & 0xFF); + m_curB = static_cast(hi & 0xFF); + m_curA = static_cast((hi >> 32) & 0xFF); + break; + case 0x02: + { + uint32_t sBits = static_cast(lo & 0xFFFFFFFF); + uint32_t tBits = static_cast((lo >> 32) & 0xFFFFFFFF); + uint32_t qBits = static_cast(hi & 0xFFFFFFFF); + std::memcpy(&m_curS, &sBits, 4); + std::memcpy(&m_curT, &tBits, 4); + std::memcpy(&m_curQ, &qBits, 4); + if (m_curQ == 0.0f) + m_curQ = 1.0f; + break; + } + case 0x03: + m_curU = static_cast(lo & 0x3FFFu); + m_curV = static_cast((lo >> 32) & 0x3FFFu); + break; + case 0x04: + { + uint16_t x = static_cast(lo & 0xFFFF); + uint16_t y = static_cast((lo >> 32) & 0xFFFF); + uint32_t z = static_cast((hi >> 4) & 0xFFFFFF); + uint8_t f = static_cast((hi >> 36) & 0xFF); + bool adk = ((hi >> 47) & 1) != 0; + PS2_IF_AGRESSIVE_LOGS({ + const uint32_t debugIndex = s_debugGsPackedVertexCount.fetch_add(1, std::memory_order_relaxed); + if (debugIndex < 64u) + { + RUNTIME_LOG("[gs:packed-xyzf] idx=" << debugIndex + << " x=" << x + << " y=" << y + << " z=0x" << std::hex << z + << std::dec + << " fog=" << static_cast(f) + << " kick=" << static_cast(!adk ? 1u : 0u) + << " prim=" << static_cast(m_prim.type) + << std::endl); + } + }); + GSVertex &vtx = m_vtxQueue[m_vtxCount % kMaxVerts]; + vtx.x = static_cast(x) / 16.0f; + vtx.y = static_cast(y) / 16.0f; + vtx.z = static_cast(z); + vtx.r = m_curR; + vtx.g = m_curG; + vtx.b = m_curB; + vtx.a = m_curA; + vtx.q = m_curQ; + vtx.s = m_curS; + vtx.t = m_curT; + vtx.u = m_curU; + vtx.v = m_curV; + vtx.fog = f; + vertexKick(!adk); + break; + } + case 0x05: + { + uint16_t x = static_cast(lo & 0xFFFF); + uint16_t y = static_cast((lo >> 32) & 0xFFFF); + uint32_t z = static_cast(hi & 0xFFFFFFFF); + bool adk = ((hi >> 47) & 1) != 0; + PS2_IF_AGRESSIVE_LOGS({ + const uint32_t debugIndex = s_debugGsPackedVertexCount.fetch_add(1, std::memory_order_relaxed); + if (debugIndex < 64u) + { + RUNTIME_LOG("[gs:packed-xyz] idx=" << debugIndex + << " x=" << x + << " y=" << y + << " z=0x" << std::hex << z + << std::dec + << " kick=" << static_cast(!adk ? 1u : 0u) + << " prim=" << static_cast(m_prim.type) + << std::endl); + } + }); + GSVertex &vtx = m_vtxQueue[m_vtxCount % kMaxVerts]; + vtx.x = static_cast(x) / 16.0f; + vtx.y = static_cast(y) / 16.0f; + vtx.z = static_cast(z); + vtx.r = m_curR; + vtx.g = m_curG; + vtx.b = m_curB; + vtx.a = m_curA; + vtx.q = m_curQ; + vtx.s = m_curS; + vtx.t = m_curT; + vtx.u = m_curU; + vtx.v = m_curV; + vtx.fog = m_curFog; + vertexKick(!adk); + break; + } + case 0x0A: + m_curFog = static_cast((hi >> 36) & 0xFF); + break; + case 0x0C: + { + PS2_IF_AGRESSIVE_LOGS({ + const uint32_t debugIndex = s_debugGsPackedVertexCount.fetch_add(1, std::memory_order_relaxed); + if (debugIndex < 64u) + { + RUNTIME_LOG("[gs:packed-xyzf3] idx=" << debugIndex + << " x=" << static_cast(lo & 0xFFFFu) + << " y=" << static_cast((lo >> 32) & 0xFFFFu) + << " kick=0" + << " prim=" << static_cast(m_prim.type) + << std::endl); + } + }); + GSVertex &vtx = m_vtxQueue[m_vtxCount % kMaxVerts]; + vtx.x = static_cast(lo & 0xFFFF) / 16.0f; + vtx.y = static_cast((lo >> 32) & 0xFFFF) / 16.0f; + vtx.z = static_cast((hi >> 4) & 0xFFFFFF); + vtx.r = m_curR; + vtx.g = m_curG; + vtx.b = m_curB; + vtx.a = m_curA; + vtx.q = m_curQ; + vtx.s = m_curS; + vtx.t = m_curT; + vtx.u = m_curU; + vtx.v = m_curV; + vtx.fog = static_cast((hi >> 36) & 0xFF); + vertexKick(false); + break; + } + case 0x0D: + { + PS2_IF_AGRESSIVE_LOGS({ + const uint32_t debugIndex = s_debugGsPackedVertexCount.fetch_add(1, std::memory_order_relaxed); + if (debugIndex < 64u) + { + RUNTIME_LOG("[gs:packed-xyz3] idx=" << debugIndex + << " x=" << static_cast(lo & 0xFFFFu) + << " y=" << static_cast((lo >> 32) & 0xFFFFu) + << " kick=0" + << " prim=" << static_cast(m_prim.type) + << std::endl); + } + }); + GSVertex &vtx = m_vtxQueue[m_vtxCount % kMaxVerts]; + vtx.x = static_cast(lo & 0xFFFF) / 16.0f; + vtx.y = static_cast((lo >> 32) & 0xFFFF) / 16.0f; + vtx.z = static_cast(hi & 0xFFFFFFFF); + vtx.r = m_curR; + vtx.g = m_curG; + vtx.b = m_curB; + vtx.a = m_curA; + vtx.q = m_curQ; + vtx.s = m_curS; + vtx.t = m_curT; + vtx.u = m_curU; + vtx.v = m_curV; + vtx.fog = m_curFog; + vertexKick(false); + break; + } + case 0x0E: + { + uint8_t addr = static_cast(hi & 0xFF); + writeRegisterUnlocked(addr, lo); + break; + } + case 0x0F: + break; + default: + writeRegisterUnlocked(regDesc, lo); + break; + } +} + +void GS::writeRegister(uint8_t regAddr, uint64_t value) +{ + std::lock_guard lock(m_stateMutex); + writeRegisterUnlocked(regAddr, value); +} + +void GS::writeRegisterUnlocked(uint8_t regAddr, uint64_t value) +{ + const bool interestingReg = + regAddr == GS_REG_PRIM || + regAddr == GS_REG_RGBAQ || + regAddr == GS_REG_ST || + regAddr == GS_REG_UV || + regAddr == GS_REG_XYZ2 || + regAddr == GS_REG_XYZ3 || + regAddr == GS_REG_XYZF2 || + regAddr == GS_REG_XYZF3 || + regAddr == GS_REG_TEX0_1 || + regAddr == GS_REG_TEX0_2 || + regAddr == GS_REG_TEX2_1 || + regAddr == GS_REG_TEX2_2 || + regAddr == GS_REG_TEXCLUT || + regAddr == GS_REG_TEXA || + regAddr == GS_REG_XYOFFSET_1 || + regAddr == GS_REG_XYOFFSET_2 || + regAddr == GS_REG_SCISSOR_1 || + regAddr == GS_REG_SCISSOR_2 || + regAddr == GS_REG_FRAME_1 || + regAddr == GS_REG_FRAME_2 || + regAddr == GS_REG_ALPHA_1 || + regAddr == GS_REG_ALPHA_2 || + regAddr == GS_REG_TEST_1 || + regAddr == GS_REG_TEST_2 || + regAddr == GS_REG_BITBLTBUF || + regAddr == GS_REG_TRXPOS || + regAddr == GS_REG_TRXREG || + regAddr == GS_REG_TRXDIR; + + PS2_IF_AGRESSIVE_LOGS({ + if (interestingReg) + { + const uint32_t debugIndex = s_debugGsRegisterCount.fetch_add(1, std::memory_order_relaxed); + if (debugIndex < 128u) + { + RUNTIME_LOG("[gs:reg] idx=" << debugIndex + << " reg=0x" << std::hex << static_cast(regAddr) + << " value=0x" << value + << std::dec + << std::endl); + } + } + }); + + const bool isCopyRelevantReg = + regAddr == GS_REG_PRIM || + regAddr == GS_REG_TEX0_2 || + regAddr == GS_REG_TEX1_2 || + regAddr == GS_REG_ALPHA_2 || + regAddr == GS_REG_TEST_2 || + regAddr == GS_REG_PABE || + regAddr == GS_REG_FRAME_2 || + regAddr == GS_REG_XYOFFSET_2 || + regAddr == GS_REG_SCISSOR_2; + PS2_IF_AGRESSIVE_LOGS({ + if (isCopyRelevantReg && + s_debugCopyRegCount.fetch_add(1u, std::memory_order_relaxed) < 64u) + { + RUNTIME_LOG("[gs:copy-reg] reg=0x" + << std::hex << static_cast(regAddr) + << " value=0x" << value + << std::dec + << " primCtxt=" << static_cast(m_prim.ctxt) + << " ctx0fbp=" << m_ctx[0].frame.fbp + << " ctx1fbp=" << m_ctx[1].frame.fbp + << std::endl); + } + }); + + switch (regAddr) + { + case GS_REG_PRIM: + { + m_primRegister = decodePrimRegister(value); + if (m_prmodecont) + { + m_prim = m_primRegister; + } + else + { + // PRIM always selects the primitive topology. With AC=0, all + // rendering attributes remain sourced from PRMODE. + m_prim.type = m_primRegister.type; + } + m_vtxCount = 0; + m_vtxIndex = 0; + break; + } + case GS_REG_RGBAQ: + { + m_curR = static_cast(value & 0xFF); + m_curG = static_cast((value >> 8) & 0xFF); + m_curB = static_cast((value >> 16) & 0xFF); + m_curA = static_cast((value >> 24) & 0xFF); + uint32_t qBits = static_cast((value >> 32) & 0xFFFFFFFF); + std::memcpy(&m_curQ, &qBits, 4); + if (m_curQ == 0.0f) + m_curQ = 1.0f; + break; + } + case GS_REG_ST: + { + uint32_t sBits = static_cast(value & 0xFFFFFFFF); + uint32_t tBits = static_cast((value >> 32) & 0xFFFFFFFF); + std::memcpy(&m_curS, &sBits, 4); + std::memcpy(&m_curT, &tBits, 4); + break; + } + case GS_REG_UV: + { + m_curU = static_cast(value & 0x3FFFu); + m_curV = static_cast((value >> 16) & 0x3FFFu); + break; + } + case GS_REG_XYZF2: + case GS_REG_XYZF3: + { + GSVertex &vtx = m_vtxQueue[m_vtxCount % kMaxVerts]; + vtx.x = static_cast(value & 0xFFFF) / 16.0f; + vtx.y = static_cast((value >> 16) & 0xFFFF) / 16.0f; + vtx.z = static_cast((value >> 32) & 0xFFFFFF); + vtx.fog = static_cast((value >> 56) & 0xFF); + vtx.r = m_curR; + vtx.g = m_curG; + vtx.b = m_curB; + vtx.a = m_curA; + vtx.q = m_curQ; + vtx.s = m_curS; + vtx.t = m_curT; + vtx.u = m_curU; + vtx.v = m_curV; + vertexKick(regAddr == GS_REG_XYZF2); + break; + } + case GS_REG_XYZ2: + case GS_REG_XYZ3: + { + GSVertex &vtx = m_vtxQueue[m_vtxCount % kMaxVerts]; + vtx.x = static_cast(value & 0xFFFF) / 16.0f; + vtx.y = static_cast((value >> 16) & 0xFFFF) / 16.0f; + vtx.z = static_cast((value >> 32) & 0xFFFFFFFF); + vtx.r = m_curR; + vtx.g = m_curG; + vtx.b = m_curB; + vtx.a = m_curA; + vtx.q = m_curQ; + vtx.s = m_curS; + vtx.t = m_curT; + vtx.u = m_curU; + vtx.v = m_curV; + vtx.fog = m_curFog; + vertexKick(regAddr == GS_REG_XYZ2); + break; + } + case GS_REG_TEX0_1: + case GS_REG_TEX0_2: + { + int ci = (regAddr == GS_REG_TEX0_2) ? 1 : 0; + auto &t = m_ctx[ci].tex0; + t.tbp0 = static_cast(value & 0x3FFF); + t.tbw = static_cast((value >> 14) & 0x3F); + t.psm = static_cast((value >> 20) & 0x3F); + t.tw = static_cast((value >> 26) & 0xF); + t.th = static_cast((value >> 30) & 0xF); + t.tcc = static_cast((value >> 34) & 0x1); + t.tfx = static_cast((value >> 35) & 0x3); + t.cbp = static_cast((value >> 37) & 0x3FFF); + t.cpsm = static_cast((value >> 51) & 0xF); + t.csm = static_cast((value >> 55) & 0x1); + t.csa = static_cast((value >> 56) & 0x1F); + t.cld = static_cast((value >> 61) & 0x7); + break; + } + case GS_REG_CLAMP_1: + case GS_REG_CLAMP_2: + { + int ci = (regAddr == GS_REG_CLAMP_2) ? 1 : 0; + m_ctx[ci].clamp = value; + break; + } + case GS_REG_FOG: + m_curFog = static_cast((value >> 56) & 0xFF); + break; + case GS_REG_TEX1_1: + case GS_REG_TEX1_2: + { + int ci = (regAddr == GS_REG_TEX1_2) ? 1 : 0; + m_ctx[ci].tex1 = value; + break; + } + case GS_REG_TEX2_1: + case GS_REG_TEX2_2: + { + int ci = (regAddr == GS_REG_TEX2_2) ? 1 : 0; + auto &t = m_ctx[ci].tex0; + t.psm = static_cast((value >> 20) & 0x3F); + t.cbp = static_cast((value >> 37) & 0x3FFF); + t.cpsm = static_cast((value >> 51) & 0xF); + t.csm = static_cast((value >> 55) & 0x1); + t.csa = static_cast((value >> 56) & 0x1F); + t.cld = static_cast((value >> 61) & 0x7); + break; + } + case GS_REG_XYOFFSET_1: + case GS_REG_XYOFFSET_2: + { + int ci = (regAddr == GS_REG_XYOFFSET_2) ? 1 : 0; + m_ctx[ci].xyoffset.ofx = static_cast(value & 0xFFFF); + m_ctx[ci].xyoffset.ofy = static_cast((value >> 32) & 0xFFFF); + break; + } + case GS_REG_PRMODECONT: + { + m_prmodecont = (value & 1) != 0; + const GSPrimType type = m_primRegister.type; + m_prim = m_prmodecont ? m_primRegister : m_prmodeRegister; + m_prim.type = type; + break; + } + case GS_REG_PRMODE: + { + m_prmodeRegister = decodePrimRegister(value); + if (!m_prmodecont) + { + const GSPrimType type = m_primRegister.type; + m_prim = m_prmodeRegister; + m_prim.type = type; + } + break; + } + case GS_REG_TEXCLUT: + m_texclut.cbw = static_cast(value & 0x3Fu); + m_texclut.cou = static_cast((value >> 6) & 0x3Fu); + m_texclut.cov = static_cast((value >> 12) & 0x3FFu); + break; + case GS_REG_SCISSOR_1: + case GS_REG_SCISSOR_2: + { + int ci = (regAddr == GS_REG_SCISSOR_2) ? 1 : 0; + m_ctx[ci].scissor.x0 = static_cast(value & 0x7FF); + m_ctx[ci].scissor.x1 = static_cast((value >> 16) & 0x7FF); + m_ctx[ci].scissor.y0 = static_cast((value >> 32) & 0x7FF); + m_ctx[ci].scissor.y1 = static_cast((value >> 48) & 0x7FF); + break; + } + case GS_REG_ALPHA_1: + case GS_REG_ALPHA_2: + { + int ci = (regAddr == GS_REG_ALPHA_2) ? 1 : 0; + m_ctx[ci].alpha = value; + break; + } + case GS_REG_TEST_1: + case GS_REG_TEST_2: + { + int ci = (regAddr == GS_REG_TEST_2) ? 1 : 0; + m_ctx[ci].test = value; + break; + } + case GS_REG_FRAME_1: + case GS_REG_FRAME_2: + { + int ci = (regAddr == GS_REG_FRAME_2) ? 1 : 0; + m_ctx[ci].frame.fbp = static_cast(value & 0x1FF); + m_ctx[ci].frame.fbw = static_cast((value >> 16) & 0x3F); + m_ctx[ci].frame.psm = static_cast((value >> 24) & 0x3F); + m_ctx[ci].frame.fbmsk = static_cast((value >> 32) & 0xFFFFFFFF); + break; + } + case GS_REG_ZBUF_1: + case GS_REG_ZBUF_2: + { + int ci = (regAddr == GS_REG_ZBUF_2) ? 1 : 0; + m_ctx[ci].zbuf.zbp = value & 0x1FF; + m_ctx[ci].zbuf.psm = ((value >> 24) & 0xF) | 0x30; + m_ctx[ci].zbuf.zmask = (value >> 32) & 1; + break; + } + case GS_REG_FBA_1: + case GS_REG_FBA_2: + { + int ci = (regAddr == GS_REG_FBA_2) ? 1 : 0; + m_ctx[ci].fba = value; + break; + } + case GS_REG_BITBLTBUF: + { + m_bitbltbuf.sbp = static_cast(value & 0x3FFF); + m_bitbltbuf.sbw = static_cast((value >> 16) & 0x3F); + m_bitbltbuf.spsm = static_cast((value >> 24) & 0x3F); + m_bitbltbuf.dbp = static_cast((value >> 32) & 0x3FFF); + m_bitbltbuf.dbw = static_cast((value >> 48) & 0x3F); + m_bitbltbuf.dpsm = static_cast((value >> 56) & 0x3F); + break; + } + case GS_REG_TRXPOS: + { + m_trxpos.ssax = static_cast(value & 0x7FF); + m_trxpos.ssay = static_cast((value >> 16) & 0x7FF); + m_trxpos.dsax = static_cast((value >> 32) & 0x7FF); + m_trxpos.dsay = static_cast((value >> 48) & 0x7FF); + m_trxpos.dir = static_cast((value >> 59) & 0x3); + break; + } + case GS_REG_TRXREG: + { + m_trxreg.rrw = static_cast(value & 0xFFF); + m_trxreg.rrh = static_cast((value >> 32) & 0xFFF); + break; + } + case GS_REG_TRXDIR: + { + m_trxdir = static_cast(value & 0x3); + + if (m_backend) + { + GSTransferCommand command{}; + command.bitbltbuf = m_bitbltbuf; + command.trxpos = m_trxpos; + command.trxreg = m_trxreg; + command.direction = m_trxdir; + m_backend->BeginTransfer(command); + } + recordTransferDebugEventUnlocked(); + break; + } + case GS_REG_HWREG: + { + uint8_t buf[8]; + std::memcpy(buf, &value, 8); + processImageData(buf, 8); + break; + } + case GS_REG_PABE: + m_pabe = (value & 1u) != 0u; + break; + case GS_REG_FOGCOL: + m_fogR = static_cast(value & 0xFFu); + m_fogG = static_cast((value >> 8) & 0xFFu); + m_fogB = static_cast((value >> 16) & 0xFFu); + break; + case GS_REG_TEXFLUSH: + if (m_backend) + m_backend->TextureFlush(); + break; + case GS_REG_SCANMSK: + m_scanmsk = value; + break; + case GS_REG_DIMX: + m_dimx = value; + break; + case GS_REG_DTHE: + m_dthe = value; + break; + case GS_REG_COLCLAMP: + m_colclamp = value; + break; + case GS_REG_MIPTBP1_1: + case GS_REG_MIPTBP1_2: + { + const int ci = (regAddr == GS_REG_MIPTBP1_2) ? 1 : 0; + m_ctx[ci].miptbp1 = value; + break; + } + case GS_REG_MIPTBP2_1: + case GS_REG_MIPTBP2_2: + { + const int ci = (regAddr == GS_REG_MIPTBP2_2) ? 1 : 0; + m_ctx[ci].miptbp2 = value; + break; + } + case GS_REG_TEXA: + { + m_texa.ta0 = static_cast(value & 0xFFu); + m_texa.aem = ((value >> 15) & 0x1u) != 0u; + m_texa.ta1 = static_cast((value >> 32) & 0xFFu); + PS2_IF_AGRESSIVE_LOGS({ + const uint32_t texaIndex = s_debugTexaWriteCount.fetch_add(1u, std::memory_order_relaxed); + if (texaIndex < 24u) + { + RUNTIME_LOG("[gs:texa] idx=" << texaIndex + << " value=0x" << std::hex << value + << " ta0=0x" << ((value >> 0) & 0xFFu) + << " aem=" << ((value >> 15) & 0x1u) + << " ta1=0x" << ((value >> 32) & 0xFFu) + << std::dec + << std::endl); + } + }); + break; + } + case GS_REG_SIGNAL: + { + if (m_privRegs) + { + uint32_t id = static_cast(value & 0xFFFFFFFF); + uint32_t mask = static_cast(value >> 32); + uint32_t lo = static_cast(m_privRegs->siglblid & 0xFFFFFFFF); + lo = (lo & ~mask) | (id & mask); + m_privRegs->siglblid = (m_privRegs->siglblid & 0xFFFFFFFF00000000ULL) | lo; + m_privRegs->csr.fetch_or(0x1); + } + break; + } + case GS_REG_FINISH: + { + if (m_backend) + { + m_backend->Flush(); + m_backend->Sync(GSSyncReason::Finish); + } + if (m_privRegs) + m_privRegs->csr.fetch_or(0x2); + break; + } + case GS_REG_LABEL: + { + if (m_privRegs) + { + uint32_t id = static_cast(value & 0xFFFFFFFF); + uint32_t mask = static_cast(value >> 32); + uint32_t hi = static_cast(m_privRegs->siglblid >> 32); + hi = (hi & ~mask) | (id & mask); + m_privRegs->siglblid = (static_cast(hi) << 32) | (m_privRegs->siglblid & 0xFFFFFFFF); + } + break; + } + case 0x59: + if (m_privRegs) + m_privRegs->dispfb1 = value; + break; + case 0x5a: + if (m_privRegs) + m_privRegs->display1 = value; + break; + case 0x5b: + if (m_privRegs) + m_privRegs->dispfb2 = value; + break; + case 0x5c: + if (m_privRegs) + m_privRegs->display2 = value; + break; + case 0x5f: + if (m_privRegs) + m_privRegs->bgcolor = value; + break; + default: + break; + } + + recordRegisterDebugEventUnlocked(regAddr, value); +} + +void GS::vertexKick(bool drawing) +{ + ++m_vtxCount; + ++m_vtxIndex; + + PS2_IF_AGRESSIVE_LOGS({ + const uint32_t debugIndex = s_debugGsVertexKickCount.fetch_add(1, std::memory_order_relaxed); + if (debugIndex < 96u) + { + RUNTIME_LOG("[gs:kick] idx=" << debugIndex + << " drawing=" << static_cast(drawing ? 1u : 0u) + << " prim=" << static_cast(m_prim.type) + << " vtxCount=" << m_vtxCount + << std::endl); + } + }); + + int needed = 0; + switch (m_prim.type) + { + case GS_PRIM_POINT: + needed = 1; + break; + case GS_PRIM_LINE: + needed = 2; + break; + case GS_PRIM_LINESTRIP: + needed = 2; + break; + case GS_PRIM_TRIANGLE: + needed = 3; + break; + case GS_PRIM_TRISTRIP: + needed = 3; + break; + case GS_PRIM_TRIFAN: + needed = 3; + break; + case GS_PRIM_SPRITE: + needed = 2; + break; + default: + return; + } + + if (m_vtxCount < needed) + return; + + if (drawing && m_backend) + { + GSPrimitiveBatch batch = buildDrawBatch(needed); + updatePreferredDisplaySourceForDraw(batch); + m_backend->Submit(batch); + recordDrawDebugEventUnlocked(needed); + } + + switch (m_prim.type) + { + case GS_PRIM_LINE: + case GS_PRIM_TRIANGLE: + case GS_PRIM_SPRITE: + case GS_PRIM_POINT: + m_vtxCount = 0; + break; + case GS_PRIM_LINESTRIP: + m_vtxQueue[0] = m_vtxQueue[1]; + m_vtxCount = 1; + break; + case GS_PRIM_TRISTRIP: + m_vtxQueue[0] = m_vtxQueue[1]; + m_vtxQueue[1] = m_vtxQueue[2]; + m_vtxCount = 2; + break; + case GS_PRIM_TRIFAN: + m_vtxQueue[1] = m_vtxQueue[2]; + m_vtxCount = 2; + break; + default: + m_vtxCount = 0; + break; + } +} + +void GS::processImageData(const uint8_t *data, uint32_t sizeBytes) +{ + if (m_backend) + m_backend->UploadImage(data, sizeBytes); +} + + +bool GS::clearFramebufferContext(uint32_t contextIndex, uint32_t rgba) +{ + std::lock_guard lock(m_stateMutex); + return m_backend && m_backend->ClearFramebuffer(m_ctx[(contextIndex != 0u) ? 1 : 0], rgba); +} + +bool GS::clearActiveFramebuffer(uint32_t rgba) +{ + std::lock_guard lock(m_stateMutex); + return m_backend && m_backend->ClearFramebuffer(activeContext(), rgba); +} + +uint32_t GS::consumeLocalToHostBytes(uint8_t *dst, uint32_t maxBytes) +{ + std::lock_guard lock(m_stateMutex); + return m_backend ? m_backend->ConsumeLocalToHostBytes(dst, maxBytes) : 0u; +} + +void GS::setRasterBackend(std::unique_ptr backend) +{ + if (!backend) + backend = std::make_unique(); + + std::lock_guard lock(m_stateMutex); + std::lock_guard backendLock(m_backendLifetimeMutex); + if (m_backend) + { + m_backend->Flush(); + m_backend->Sync(GSSyncReason::Reset); + + // The external 4 MiB GS allocation is the backend hand-off format. + // This keeps hot backend replacement deterministic even when a future + // GPU backend keeps a private/mirrored local-memory representation. + if (m_localMemoryStorage && m_localMemorySize != 0u) + { + std::vector localMemory; + m_backend->SnapshotVram(localMemory); + const size_t bytes = std::min(localMemory.size(), m_localMemorySize); + if (bytes != 0u) + std::memcpy(m_localMemoryStorage, localMemory.data(), bytes); + } + } + + m_backend = std::move(backend); + m_backend->Initialize(m_localMemoryStorage, m_localMemorySize); +} + +uint32_t GS::ReadVram(uint32_t psm, uint32_t base, uint32_t bw, uint32_t x, uint32_t y) const +{ + std::lock_guard lock(m_stateMutex); + return m_backend ? m_backend->ReadVram(psm, base, bw, x, y) : 0u; +} + +void GS::WriteVram(uint32_t psm, uint32_t base, uint32_t bw, uint32_t x, uint32_t y, uint32_t value) +{ + std::lock_guard lock(m_stateMutex); + if (m_backend) + m_backend->WriteVram(psm, base, bw, x, y, value); +} + +GSPrimitiveBatch GS::buildDrawBatch(int vertexCount) const +{ + GSPrimitiveBatch batch{}; + batch.vertexCount = static_cast(std::min(vertexCount, 3)); + for (int i = 0; i < batch.vertexCount; ++i) + batch.vertices[static_cast(i)] = m_vtxQueue[i]; + batch.state.context = m_ctx[m_prim.ctxt ? 1 : 0]; + batch.state.prim = m_prim; + batch.state.texa = m_texa; + batch.state.texclut = m_texclut; + batch.state.pabe = m_pabe; + batch.state.scanmsk = m_scanmsk; + batch.state.dimx = m_dimx; + batch.state.dthe = m_dthe; + batch.state.colclamp = m_colclamp; + batch.state.fogR = m_fogR; + batch.state.fogG = m_fogG; + batch.state.fogB = m_fogB; + batch.state.textureWidth = static_cast(1u << std::min(batch.state.context.tex0.tw, 10u)); + batch.state.textureHeight = static_cast(1u << std::min(batch.state.context.tex0.th, 10u)); + const uint64_t tex1 = batch.state.context.tex1; + const uint8_t mmag = static_cast((tex1 >> 5u) & 0x1u); + const uint8_t mmin = static_cast((tex1 >> 6u) & 0x7u); + batch.state.linearFilter = mmag != 0u || mmin == 1u || (mmin & 0x4u) != 0u; + return batch; +} + +void GS::updatePreferredDisplaySourceForDraw(const GSPrimitiveBatch &batch) +{ + const GSDrawState &state = batch.state; + const GSContext &ctx = state.context; + if (m_hasPreferredDisplaySource && ctx.frame.fbp == m_preferredDisplayDestFbp) + m_hasPreferredDisplaySource = false; + if (state.prim.type != GS_PRIM_SPRITE || batch.vertexCount < 2u) + return; + + const GSVertex &v0 = batch.vertices[0]; + const GSVertex &v1 = batch.vertices[1]; + int x0 = static_cast(v0.x) - (ctx.xyoffset.ofx >> 4); + int y0 = static_cast(v0.y) - (ctx.xyoffset.ofy >> 4); + int x1 = static_cast(v1.x) - (ctx.xyoffset.ofx >> 4); + int y1 = static_cast(v1.y) - (ctx.xyoffset.ofy >> 4); + if (x0 > x1) std::swap(x0, x1); + if (y0 > y1) std::swap(y0, y1); + const int xEnd = x0 + std::max(1, x1 - x0) - 1; + const int yEnd = y0 + std::max(1, y1 - y0) - 1; + const uint8_t alphaMode = static_cast(ctx.alpha & 0xFFu); + const uint8_t alphaFix = static_cast((ctx.alpha >> 32u) & 0xFFu); + const bool displayCopy = state.prim.tme && state.prim.abe && state.prim.fst && state.prim.ctxt && + ctx.frame.fbp != ctx.tex0.tbp0 && alphaMode == 0x64u && + (alphaFix == 0x60u || alphaFix == 0x80u) && + x0 <= 0 && y0 <= 0 && xEnd >= 639 && yEnd >= 447; + if (displayCopy) + { + m_preferredDisplaySourceFrame = {ctx.tex0.tbp0, ctx.tex0.tbw, ctx.tex0.psm, 0u}; + m_preferredDisplayDestFbp = ctx.frame.fbp; + m_hasPreferredDisplaySource = true; + } +} diff --git a/ps2xRuntime/src/lib/ps2_gif_arbiter.cpp b/ps2xRuntime/src/lib/gs/ps2_gif_arbiter.cpp similarity index 98% rename from ps2xRuntime/src/lib/ps2_gif_arbiter.cpp rename to ps2xRuntime/src/lib/gs/ps2_gif_arbiter.cpp index 1b83711ae..c289ba0f2 100644 --- a/ps2xRuntime/src/lib/ps2_gif_arbiter.cpp +++ b/ps2xRuntime/src/lib/gs/ps2_gif_arbiter.cpp @@ -1,4 +1,4 @@ -#include "runtime/ps2_gif_arbiter.h" +#include "runtime/gs/ps2_gif_arbiter.h" #include #include diff --git a/ps2xRuntime/src/lib/ps2_gs_memory.cpp b/ps2xRuntime/src/lib/gs/ps2_gs_memory.cpp similarity index 99% rename from ps2xRuntime/src/lib/ps2_gs_memory.cpp rename to ps2xRuntime/src/lib/gs/ps2_gs_memory.cpp index e061953ba..fecf9fd2c 100644 --- a/ps2xRuntime/src/lib/ps2_gs_memory.cpp +++ b/ps2xRuntime/src/lib/gs/ps2_gs_memory.cpp @@ -1,6 +1,6 @@ #include -#include "runtime/ps2_gs_memory.h" +#include "runtime/gs/ps2_gs_memory.h" namespace GSMem { diff --git a/ps2xRuntime/src/lib/ps2_gs_gpu.cpp b/ps2xRuntime/src/lib/ps2_gs_gpu.cpp deleted file mode 100644 index d444ad84c..000000000 --- a/ps2xRuntime/src/lib/ps2_gs_gpu.cpp +++ /dev/null @@ -1,2961 +0,0 @@ -#include "runtime/ps2_gs_gpu.h" -#include "runtime/ps2_gs_common.h" -#include "runtime/ps2_gs_psmct16.h" -#include "runtime/ps2_gs_psmct32.h" -#include "runtime/ps2_gs_psmt4.h" -#include "runtime/ps2_gs_psmt8.h" -#include "ps2_log.h" -#include "ps2_syscalls.h" -#include "runtime/ps2_memory.h" -#include "runtime/ps2_gs_memory.h" -#include -#include -#include -#include -#include -#include -#include - -namespace -{ - static constexpr uint32_t kDefaultDisplayWidth = 640u; - static constexpr uint32_t kDefaultDisplayHeight = 448u; - static constexpr uint32_t kHostFrameWidth = 640u; - static constexpr uint32_t kHostFrameHeight = 512u; - - GSPrimReg decodePrimRegister(uint64_t value) - { - GSPrimReg prim{}; - prim.type = static_cast(value & 0x7u); - prim.iip = ((value >> 3) & 1u) != 0u; - prim.tme = ((value >> 4) & 1u) != 0u; - prim.fge = ((value >> 5) & 1u) != 0u; - prim.abe = ((value >> 6) & 1u) != 0u; - prim.aa1 = ((value >> 7) & 1u) != 0u; - prim.fst = ((value >> 8) & 1u) != 0u; - prim.ctxt = ((value >> 9) & 1u) != 0u; - prim.fix = ((value >> 10) & 1u) != 0u; - return prim; - } - - uint16_t encodeFramePixelPSMCT16(uint8_t r, uint8_t g, uint8_t b, uint8_t a) - { - return static_cast(((r >> 3) & 0x1Fu) | - (((g >> 3) & 0x1Fu) << 5) | - (((b >> 3) & 0x1Fu) << 10) | - ((a >= 0x40u) ? 0x8000u : 0u)); - } - - uint32_t addrPSMCT16Family(uint32_t basePtr, uint32_t width, uint8_t psm, uint32_t x, uint32_t y) - { - switch (psm) - { - case GS_PSM_CT16: - return GSPSMCT16::addrPSMCT16(basePtr, width, x, y); - case GS_PSM_CT16S: - return GSPSMCT16::addrPSMCT16S(basePtr, width, x, y); - case GS_PSM_Z16: - return GSPSMCT16::addrPSMZ16(basePtr, width, x, y); - case GS_PSM_Z16S: - return GSPSMCT16::addrPSMZ16S(basePtr, width, x, y); - default: - return 0u; - } - } - - static inline uint64_t loadLE64(const uint8_t *p) - { - uint64_t v; - std::memcpy(&v, p, 8); - return v; - } - - struct PackedGifPacketTag - { - uint64_t lo = 0u; - uint64_t hi = 0u; - uint32_t payloadOffset = 0u; - uint32_t nloop = 0u; - uint32_t nreg = 0u; - uint8_t regs[16]{}; - }; - - template - bool visitPackedGifPacket(const uint8_t *data, uint32_t sizeBytes, Visitor &&visitor) - { - uint32_t offset = 0u; - while (offset + 16u <= sizeBytes) - { - PackedGifPacketTag tag{}; - tag.lo = loadLE64(data + offset); - tag.hi = loadLE64(data + offset + 8u); - - const uint8_t flg = static_cast((tag.lo >> 58u) & 0x3u); - if (flg != GIF_FMT_PACKED) - return false; - - tag.nloop = static_cast(tag.lo & 0x7FFFu); - tag.nreg = static_cast((tag.lo >> 60u) & 0xFu); - if (tag.nreg == 0u) - tag.nreg = 16u; - - const uint64_t payloadBytes64 = - static_cast(tag.nloop) * static_cast(tag.nreg) * 16ull; - if (payloadBytes64 > 0xFFFFFFFFull) - return false; - - offset += 16u; - const uint32_t payloadBytes = static_cast(payloadBytes64); - if (payloadBytes > sizeBytes - offset) - return false; - - tag.payloadOffset = offset; - for (uint32_t i = 0u; i < tag.nreg; ++i) - tag.regs[i] = static_cast((tag.hi >> (i * 4u)) & 0xFu); - - if (!visitor(tag)) - return false; - - offset += payloadBytes; - } - - return offset == sizeBytes; - } - - bool validatePackedGifPacket(const uint8_t *data, uint32_t sizeBytes) - { - return visitPackedGifPacket(data, sizeBytes, [](const PackedGifPacketTag &) - { return true; }); - } - - void decodeDisplaySize(uint64_t display64, uint32_t &outWidth, uint32_t &outHeight) - { - const uint32_t dx = static_cast((display64 >> 0) & 0x0FFFu); - const uint32_t dy = static_cast((display64 >> 12) & 0x07FFu); - const uint32_t dw = static_cast((display64 >> 32) & 0x0FFFu); - const uint32_t dh = static_cast((display64 >> 44) & 0x07FFu); - const uint32_t magh = static_cast((display64 >> 23) & 0x0Fu); - - outWidth = (dw + 1u) / (magh + 1u); - outHeight = dh + 1u; - - if (outWidth < 64u || outHeight < 64u) - { - outWidth = kDefaultDisplayWidth; - outHeight = kDefaultDisplayHeight; - } - - outWidth = std::min(outWidth, kHostFrameWidth); - outHeight = std::min(outHeight, kHostFrameHeight); - } - - GSFrameReg decodeDisplayFrame(uint64_t dispfb64) - { - GSFrameReg frame{}; - frame.fbp = static_cast(dispfb64 & 0x1FFu); - frame.fbw = static_cast((dispfb64 >> 9) & 0x3Fu); - frame.psm = static_cast((dispfb64 >> 15) & 0x1Fu); - return frame; - } - - struct GSDisplayReadOrigin - { - uint32_t x = 0u; - uint32_t y = 0u; - }; - - GSDisplayReadOrigin decodeDisplayReadOrigin(uint64_t dispfb64) - { - GSDisplayReadOrigin origin{}; - origin.x = static_cast((dispfb64 >> 32) & 0x7FFu); - origin.y = static_cast((dispfb64 >> 43) & 0x7FFu); - return origin; - } - - bool hasDisplaySetup(uint64_t display64, const GSFrameReg &frame) - { - const uint32_t dw = static_cast((display64 >> 32) & 0x0FFFu); - const uint32_t dh = static_cast((display64 >> 44) & 0x07FFu); - const uint32_t magh = static_cast((display64 >> 23) & 0x0Fu); - return frame.fbw != 0u || dw != 0u || dh != 0u || magh != 0u; - } - - struct GSPmodeState - { - bool enableCrt1 = false; - bool enableCrt2 = false; - bool mmod = false; - bool amod = false; - bool slbg = false; - uint8_t alp = 0u; - }; - - GSPmodeState decodePmode(uint64_t pmode64) - { - GSPmodeState pmode{}; - pmode.enableCrt1 = (pmode64 & 0x1ull) != 0ull; - pmode.enableCrt2 = (pmode64 & 0x2ull) != 0ull; - pmode.mmod = ((pmode64 >> 5) & 0x1ull) != 0ull; - pmode.amod = ((pmode64 >> 6) & 0x1ull) != 0ull; - pmode.slbg = ((pmode64 >> 7) & 0x1ull) != 0ull; - pmode.alp = static_cast((pmode64 >> 8) & 0xFFu); - return pmode; - } - - struct GSSmode2State - { - bool interlaced = false; - bool frameMode = true; - }; - - GSSmode2State decodeSMode2(uint64_t smode264) - { - GSSmode2State smode2{}; - smode2.interlaced = (smode264 & 0x1ull) != 0ull; - smode2.frameMode = ((smode264 >> 1) & 0x1ull) != 0ull; - return smode2; - } - - void applyFieldPresentation(std::vector &pixels, uint32_t width, uint32_t height, bool oddField) - { - if (pixels.empty() || width == 0u || height < 2u) - { - return; - } - - const std::vector source = pixels; - for (uint32_t y = 0; y < height; ++y) - { - uint32_t sourceY = ((y >> 1u) << 1u) + (oddField ? 1u : 0u); - if (sourceY >= height) - { - sourceY = height - 1u; - } - - const uint8_t *srcRow = source.data() + (sourceY * kHostFrameWidth * 4u); - uint8_t *dstRow = pixels.data() + (y * kHostFrameWidth * 4u); - std::memcpy(dstRow, srcRow, width * 4u); - } - } - - void normalizePresentationAlpha(std::vector &pixels, uint32_t width, uint32_t height) - { - if (pixels.empty() || width == 0u || height == 0u) - { - return; - } - - for (uint32_t y = 0; y < height; ++y) - { - uint8_t *row = pixels.data() + (y * kHostFrameWidth * 4u); - for (uint32_t x = 0; x < width; ++x) - { - row[x * 4u + 3u] = 255u; - } - } - } - - uint8_t blendPresentationChannel(uint8_t src, uint8_t dst, uint32_t factor) - { - const int delta = static_cast(src) - static_cast(dst); - return GSInternal::clampU8(static_cast(dst) + ((delta * static_cast(factor)) / 255)); - } - - uint32_t countNonBlackPixels(const std::vector &pixels, uint32_t width, uint32_t height) - { - uint32_t count = 0u; - for (uint32_t y = 0; y < height; ++y) - { - const uint8_t *row = pixels.data() + (y * kHostFrameWidth * 4u); - for (uint32_t x = 0; x < width; ++x) - { - const uint8_t r = row[x * 4u + 0u]; - const uint8_t g = row[x * 4u + 1u]; - const uint8_t b = row[x * 4u + 2u]; - if (r != 0u || g != 0u || b != 0u) - { - ++count; - } - } - } - return count; - } - - bool clearFramebufferRect(GS *gs, const GSContext &ctx, uint32_t rgba) - { - if (ctx.frame.fbw == 0u) - { - return false; - } - - const uint32_t stride = GSInternal::fbStride(ctx.frame.fbw, ctx.frame.psm); - if (stride == 0u) - { - return false; - } - - const u32 x0 = static_cast(std::max(0, ctx.scissor.x0)); - const u32 x1 = static_cast(std::max(x0, ctx.scissor.x1)); - const u32 y0 = static_cast(std::max(0, ctx.scissor.y0)); - const u32 y1 = static_cast(std::max(y0, ctx.scissor.y1)); - - uint8_t r = static_cast(rgba & 0xFFu); - uint8_t g = static_cast((rgba >> 8) & 0xFFu); - uint8_t b = static_cast((rgba >> 16) & 0xFFu); - uint8_t a = static_cast((rgba >> 24) & 0xFFu); - - u32 fbp = GSInternal::framePageBaseToBlock(ctx.frame.fbp); - u32 fbw = std::max(ctx.frame.fbw, 1u); - u32 fpsm = ctx.frame.psm; - - if ((ctx.fba & 0x1ull) != 0ull && ctx.frame.psm != GS_PSM_CT24) - { - a = static_cast(a | 0x80u); - } - - if (ctx.frame.psm == GS_PSM_CT32 || ctx.frame.psm == GS_PSM_CT24) - { - const uint32_t srcPixel = - static_cast(r) | - (static_cast(g) << 8) | - (static_cast(b) << 16) | - (static_cast(a) << 24); - - for (int y = y0; y <= y1; ++y) - { - for (int x = x0; x <= x1; ++x) - { - uint32_t pixel = srcPixel; - if (ctx.frame.fbmsk != 0u) - { - const u32 c = gs->ReadVram(fpsm, fbp, fbw, x, y); - pixel = (pixel & ~ctx.frame.fbmsk) | (c & ctx.frame.fbmsk); - } - gs->WriteVram(fpsm, fbp, fbw, x, y, pixel); - } - } - return true; - } - - if (ctx.frame.psm == GS_PSM_CT16 || ctx.frame.psm == GS_PSM_CT16S) - { - const uint16_t srcPixel = encodeFramePixelPSMCT16(r, g, b, a); - const uint16_t mask = static_cast(ctx.frame.fbmsk & 0xFFFFu); - const uint32_t widthBlocks = (ctx.frame.fbw != 0u) ? ctx.frame.fbw : 1u; - const uint32_t basePtr = GSInternal::framePageBaseToBlock(ctx.frame.fbp); - - for (int y = y0; y <= y1; ++y) - { - for (int x = x0; x <= x1; ++x) - { - uint16_t pixel = srcPixel; - if (mask != 0u) - { - const u16 c = gs->ReadVram(fpsm, fbp, fbw, x, y); - pixel = static_cast((pixel & ~mask) | (c & mask)); - } - gs->WriteVram(fpsm, fbp, fbw, x, y, pixel); - } - } - return true; - } - - return false; - } - - std::atomic s_debugGifPacketCount{0}; - std::atomic s_debugGsRegisterCount{0}; - std::atomic s_debugGsPackedVertexCount{0}; - std::atomic s_debugGsVertexKickCount{0}; - std::atomic s_debugCopyRegCount{0}; - std::atomic s_debugTexaWriteCount{0}; - std::atomic s_debugCvFontUploadCount{0}; - std::atomic s_debugLocalCopyCount{0}; -} - -using namespace GSInternal; - -GS::GS() -{ - using namespace GSMem; - - InitLookupTables(); - - for (usz i = 0; i < m_read_vram_funcs.size(); ++i) - { - switch (i) - { - case GS_PSM_CT32: - m_read_vram_funcs[i] = ReadCT32; - m_write_vram_funcs[i] = WriteCT32; - break; - case GS_PSM_CT24: - m_read_vram_funcs[i] = ReadCT24; - m_write_vram_funcs[i] = WriteCT24; - break; - case GS_PSM_CT16: - m_read_vram_funcs[i] = ReadCT16; - m_write_vram_funcs[i] = WriteCT16; - break; - case GS_PSM_CT16S: - m_read_vram_funcs[i] = ReadCT16S; - m_write_vram_funcs[i] = WriteCT16S; - break; - case GS_PSM_T8: - m_read_vram_funcs[i] = ReadP8; - m_write_vram_funcs[i] = WriteP8; - break; - case GS_PSM_T8H: - m_read_vram_funcs[i] = ReadP8H; - m_write_vram_funcs[i] = WriteP8H; - break; - case GS_PSM_T4: - m_read_vram_funcs[i] = ReadP4; - m_write_vram_funcs[i] = WriteP4; - break; - case GS_PSM_T4HH: - m_read_vram_funcs[i] = ReadP4HH; - m_write_vram_funcs[i] = WriteP4HH; - break; - case GS_PSM_T4HL: - m_read_vram_funcs[i] = ReadP4HL; - m_write_vram_funcs[i] = WriteP4HL; - break; - case GS_PSM_Z32: - m_read_vram_funcs[i] = ReadZ32; - m_write_vram_funcs[i] = WriteZ32; - break; - case GS_PSM_Z24: - m_read_vram_funcs[i] = ReadZ24; - m_write_vram_funcs[i] = WriteZ24; - break; - case GS_PSM_Z16: - m_read_vram_funcs[i] = ReadZ16; - m_write_vram_funcs[i] = WriteZ16; - break; - case GS_PSM_Z16S: - m_read_vram_funcs[i] = ReadZ16S; - m_write_vram_funcs[i] = WriteZ16S; - break; - default: - m_read_vram_funcs[i] = ReadNull; - m_write_vram_funcs[i] = WriteNull; - break; - } - } - - reset(); -} - -void GS::init(uint8_t *vram, uint32_t vramSize, GSRegisters *privRegs) -{ - m_vram = vram; - m_vramSize = vramSize; - m_privRegs = privRegs; - reset(); -} - -void GS::reset() -{ - std::lock_guard lock(m_stateMutex); - std::memset(m_ctx, 0, sizeof(m_ctx)); - m_prim = {}; - m_primRegister = {}; - m_prmodeRegister = {}; - m_curR = 0x80; - m_curG = 0x80; - m_curB = 0x80; - m_curA = 0x80; - m_curQ = 1.0f; - m_curS = 0.0f; - m_curT = 0.0f; - m_curU = 0; - m_curV = 0; - m_curFog = 0; - m_fogR = 0; - m_fogG = 0; - m_fogB = 0; - m_prmodecont = true; - m_pabe = false; - m_texa = {0u, false, 0u}; - m_texclut = {0u, 0u, 0u}; - m_bitbltbuf = {}; - m_trxpos = {}; - m_trxreg = {}; - m_trxdir = 3; - m_vtxCount = 0; - m_vtxIndex = 0; - m_localToHostBuffer.clear(); - m_localToHostReadPos = 0; - m_preferredDisplaySourceFrame = {}; - m_preferredDisplayDestFbp = 0; - m_hasPreferredDisplaySource = false; - { - std::lock_guard presentationLock(m_presentationMutex); - m_hostPresentationFrame.clear(); - m_hostPresentationWidth = 0u; - m_hostPresentationHeight = 0u; - m_hostPresentationDisplayFbp = 0u; - m_hostPresentationSourceFbp = 0u; - m_hostPresentationUsedPreferred = false; - m_hasHostPresentationFrame = false; - } - - m_debugHistoryWrite = 0; - m_debugHistoryCount = 0; - m_debugNextSeq = 1; - m_debugFrameIndex = 0; - m_debugLastVsyncTick = UINT64_MAX; - - for (int i = 0; i < 2; ++i) - { - m_ctx[i].frame.fbw = 10; - m_ctx[i].scissor = {0, 639, 0, 447}; - m_ctx[i].xyoffset = {0, 0}; - } -} - -GSContext &GS::activeContext() -{ - return m_ctx[m_prim.ctxt ? 1 : 0]; -} - -void GS::snapshotVRAM() -{ - std::lock_guard stateLock(m_stateMutex); - if (!m_vram || m_vramSize == 0) - return; - std::lock_guard lock(m_snapshotMutex); - m_displaySnapshot.resize(m_vramSize); - std::memcpy(m_displaySnapshot.data(), m_vram, m_vramSize); -} - -const uint8_t *GS::lockDisplaySnapshot(uint32_t &outSize) -{ - m_snapshotMutex.lock(); - if (m_displaySnapshot.empty()) - { - outSize = 0; - return nullptr; - } - - outSize = static_cast(m_displaySnapshot.size()); - return m_displaySnapshot.data(); -} - -GSDebugSnapshot GS::getDebugSnapshot() const -{ - std::lock_guard lock(m_stateMutex); - - GSDebugSnapshot snapshot{}; - snapshot.ctx[0] = m_ctx[0]; - snapshot.ctx[1] = m_ctx[1]; - snapshot.prim = m_prim; - snapshot.texa = m_texa; - snapshot.texclut = m_texclut; - snapshot.bitbltbuf = m_bitbltbuf; - snapshot.trxpos = m_trxpos; - snapshot.trxreg = m_trxreg; - snapshot.trxdir = m_trxdir; - snapshot.transferX = m_transferState.x; - snapshot.transferY = m_transferState.y; - snapshot.transferTotalPixels = m_transferState.total_pixels; - snapshot.transferCopiedPixels = m_transferState.copied_pixels; - snapshot.lastDisplayBaseBytes = m_lastDisplayBaseBytes; - snapshot.preferredDisplaySourceFrame = m_preferredDisplaySourceFrame; - snapshot.preferredDisplayDestFbp = m_preferredDisplayDestFbp; - snapshot.hasPreferredDisplaySource = m_hasPreferredDisplaySource; - { - std::lock_guard presentationLock(m_presentationMutex); - snapshot.hostPresentationWidth = m_hostPresentationWidth; - snapshot.hostPresentationHeight = m_hostPresentationHeight; - snapshot.hostPresentationDisplayFbp = m_hostPresentationDisplayFbp; - snapshot.hostPresentationSourceFbp = m_hostPresentationSourceFbp; - snapshot.hostPresentationUsedPreferred = m_hostPresentationUsedPreferred; - snapshot.hasHostPresentationFrame = m_hasHostPresentationFrame; - } - snapshot.localToHostPendingBytes = (m_localToHostReadPos < m_localToHostBuffer.size()) - ? (m_localToHostBuffer.size() - m_localToHostReadPos) - : 0u; - return snapshot; -} - -std::vector GS::getDebugHistory() const -{ - std::lock_guard lock(m_stateMutex); - - std::vector out; - out.reserve(m_debugHistoryCount); - const size_t first = (m_debugHistoryWrite + kDebugHistoryCapacity - m_debugHistoryCount) % kDebugHistoryCapacity; - for (size_t i = 0; i < m_debugHistoryCount; ++i) - { - out.push_back(m_debugHistory[(first + i) % kDebugHistoryCapacity]); - } - return out; -} - -void GS::clearDebugHistory() -{ - std::lock_guard lock(m_stateMutex); - m_debugHistoryWrite = 0; - m_debugHistoryCount = 0; - m_debugNextSeq = 1; - m_debugFrameIndex = 0; - m_debugLastVsyncTick = UINT64_MAX; -} - -bool GS::isDebugHistoryPaused() const -{ - std::lock_guard lock(m_stateMutex); - return m_debugHistoryPaused; -} - -void GS::setDebugHistoryPaused(bool paused) -{ - std::lock_guard lock(m_stateMutex); - m_debugHistoryPaused = paused; -} - -GSDebugHistoryEntry GS::makeDebugEventUnlocked(GSDebugEventKind kind) const -{ - GSDebugHistoryEntry entry{}; - entry.kind = kind; - entry.prim = m_prim; - const uint32_t ci = m_prim.ctxt ? 1u : 0u; - entry.frame = m_ctx[ci].frame; - entry.zbuf = m_ctx[ci].zbuf; - entry.tex0 = m_ctx[ci].tex0; - entry.scissor = m_ctx[ci].scissor; - entry.test = m_ctx[ci].test; - entry.alpha = m_ctx[ci].alpha; - entry.bitbltbuf = m_bitbltbuf; - entry.trxpos = m_trxpos; - entry.trxreg = m_trxreg; - entry.trxdir = m_trxdir; - entry.transferPixels = m_transferState.total_pixels; - return entry; -} - -void GS::recordDebugEventUnlocked(GSDebugHistoryEntry entry) -{ - if (m_debugHistoryPaused) - { - return; - } - - const uint64_t tick = m_privRegs ? m_privRegs->vsyncTick.load(std::memory_order_acquire) : 0u; - if (m_debugLastVsyncTick == UINT64_MAX) - { - m_debugLastVsyncTick = tick; - } - else if (tick != m_debugLastVsyncTick) - { - ++m_debugFrameIndex; - m_debugLastVsyncTick = tick; - } - - entry.seq = m_debugNextSeq++; - entry.vsyncTick = tick; - entry.frameIndex = m_debugFrameIndex; - - m_debugHistory[m_debugHistoryWrite] = entry; - m_debugHistoryWrite = (m_debugHistoryWrite + 1u) % kDebugHistoryCapacity; - if (m_debugHistoryCount < kDebugHistoryCapacity) - { - ++m_debugHistoryCount; - } -} - -void GS::recordGifTagDebugEventUnlocked(uint32_t sizeBytes, uint32_t nloop, uint8_t flg, uint32_t nreg) -{ - if (m_debugHistoryPaused) - { - return; - } - - GSDebugHistoryEntry entry = makeDebugEventUnlocked(GSDebugEventKind::GifTag); - entry.gifSizeBytes = sizeBytes; - entry.gifNloop = nloop; - entry.gifFlg = flg; - entry.gifNreg = static_cast(std::min(nreg, 16u)); - recordDebugEventUnlocked(entry); -} - -void GS::recordRegisterDebugEventUnlocked(uint8_t regAddr, uint64_t value) -{ - if (m_debugHistoryPaused) - { - return; - } - - switch (regAddr) - { - case GS_REG_PRIM: - case GS_REG_TEX0_1: - case GS_REG_TEX0_2: - case GS_REG_TEX2_1: - case GS_REG_TEX2_2: - case GS_REG_TEXA: - case GS_REG_TEXCLUT: - case GS_REG_FRAME_1: - case GS_REG_FRAME_2: - case GS_REG_ZBUF_1: - case GS_REG_ZBUF_2: - case GS_REG_ALPHA_1: - case GS_REG_ALPHA_2: - case GS_REG_TEST_1: - case GS_REG_TEST_2: - case GS_REG_SCISSOR_1: - case GS_REG_SCISSOR_2: - case GS_REG_XYOFFSET_1: - case GS_REG_XYOFFSET_2: - case GS_REG_BITBLTBUF: - case GS_REG_TRXPOS: - case GS_REG_TRXREG: - case GS_REG_TRXDIR: - break; - default: - return; - } - - GSDebugHistoryEntry entry = makeDebugEventUnlocked(GSDebugEventKind::Register); - entry.reg = regAddr; - entry.regValue = value; - recordDebugEventUnlocked(entry); -} - -void GS::recordDrawDebugEventUnlocked(int vertexCount) -{ - if (m_debugHistoryPaused) - { - return; - } - - if (vertexCount <= 0) - { - return; - } - - GSDebugHistoryEntry entry = makeDebugEventUnlocked(GSDebugEventKind::Draw); - entry.vertexCount = static_cast(vertexCount); - - const int count = std::min(vertexCount, kMaxVerts); - entry.xMin = entry.xMax = m_vtxQueue[0].x; - entry.yMin = entry.yMax = m_vtxQueue[0].y; - entry.zMin = entry.zMax = m_vtxQueue[0].z; - entry.aMin = entry.aMax = m_vtxQueue[0].a; - - for (int i = 1; i < count; ++i) - { - const GSVertex &v = m_vtxQueue[i]; - entry.xMin = std::min(entry.xMin, v.x); - entry.xMax = std::max(entry.xMax, v.x); - entry.yMin = std::min(entry.yMin, v.y); - entry.yMax = std::max(entry.yMax, v.y); - entry.zMin = std::min(entry.zMin, v.z); - entry.zMax = std::max(entry.zMax, v.z); - entry.aMin = std::min(entry.aMin, v.a); - entry.aMax = std::max(entry.aMax, v.a); - } - - recordDebugEventUnlocked(entry); -} - -void GS::recordTransferDebugEventUnlocked() -{ - if (m_debugHistoryPaused) - { - return; - } - - GSDebugHistoryEntry entry = makeDebugEventUnlocked(GSDebugEventKind::Transfer); - entry.transferPixels = m_transferState.total_pixels; - recordDebugEventUnlocked(entry); -} - -void GS::recordPresentDebugEventUnlocked(uint32_t displayFbp, uint32_t sourceFbp, uint32_t width, uint32_t height, bool usedPreferred) -{ - if (m_debugHistoryPaused) - { - return; - } - - GSDebugHistoryEntry entry = makeDebugEventUnlocked(GSDebugEventKind::Present); - entry.displayFbp = displayFbp; - entry.sourceFbp = sourceFbp; - entry.width = width; - entry.height = height; - entry.usedPreferred = usedPreferred; - recordDebugEventUnlocked(entry); -} - -bool GS::getPreferredDisplaySource(GSFrameReg &outSource, uint32_t &outDestFbp) const -{ - std::lock_guard lock(m_stateMutex); - if (!m_hasPreferredDisplaySource) - { - outSource = {}; - outDestFbp = 0u; - return false; - } - - outSource = m_preferredDisplaySourceFrame; - outDestFbp = m_preferredDisplayDestFbp; - return true; -} - -void GS::unlockDisplaySnapshot() -{ - m_snapshotMutex.unlock(); -} - -uint32_t GS::getLastDisplayBaseBytes() const -{ - return m_lastDisplayBaseBytes; -} - -void GS::refreshDisplaySnapshot() -{ - snapshotVRAM(); -} - -bool GS::copyFrameToHostRgbaUnlocked(const GSFrameReg &frame, - uint32_t width, - uint32_t height, - std::vector &outPixels, - bool preserveAlpha, - bool useLocalMemoryLayout, - bool frameBaseIsPages, - uint32_t sourceOriginX, - uint32_t sourceOriginY) const -{ - if (!m_vram || m_vramSize == 0u) - { - return false; - } - - outPixels.resize(kHostFrameWidth * kHostFrameHeight * 4u); - auto failCopy = [&outPixels]() -> bool - { - outPixels.clear(); - return false; - }; - - const uint32_t baseBytes = frameBaseIsPages ? (frame.fbp * 8192u) : (frame.fbp * 256u); - const uint32_t basePtr = frameBaseIsPages ? GSInternal::framePageBaseToBlock(frame.fbp) : frame.fbp; - const uint32_t fbwBlocks = frame.fbw ? frame.fbw : (kHostFrameWidth / 64u); - const uint32_t bytesPerPixel = (frame.psm == GS_PSM_CT16 || frame.psm == GS_PSM_CT16S) ? 2u : 4u; - const uint32_t strideBytes = fbwBlocks * 64u * bytesPerPixel; - - if (frame.psm == GS_PSM_CT32 || frame.psm == GS_PSM_CT24) - { - const uint32_t srcPixelBytes = (frame.psm == GS_PSM_CT24) ? 3u : 4u; - if (useLocalMemoryLayout) - { - for (uint32_t y = 0; y < height; ++y) - { - uint8_t *dstRow = outPixels.data() + (y * kHostFrameWidth * 4u); - for (uint32_t x = 0; x < width; ++x) - { - const uint32_t srcX = sourceOriginX + x; - const uint32_t srcY = sourceOriginY + y; - - const u32 c = ReadVram(frame.psm, basePtr, fbwBlocks, srcX, srcY); - - const u32 r = c & 0xFF; - const u32 g = (c >> 8) & 0xFF; - const u32 b = (c >> 16) & 0xFF; - - u32 a = 0xFF; - if (preserveAlpha && frame.psm != GS_PSM_CT24) - { - a = (c >> 24) & 0xFF; - } - - dstRow[x * 4u + 0u] = r; - dstRow[x * 4u + 1u] = g; - dstRow[x * 4u + 2u] = b; - dstRow[x * 4u + 3u] = a; - } - } - return true; - } - - for (uint32_t y = 0; y < height; ++y) - { - const uint32_t dstOff = y * kHostFrameWidth * 4u; - uint8_t *dstRow = outPixels.data() + dstOff; - for (uint32_t x = 0; x < width; ++x) - { - const uint32_t srcX = sourceOriginX + x; - const uint32_t srcY = sourceOriginY + y; - const uint32_t srcOff = baseBytes + (srcY * strideBytes) + (srcX * srcPixelBytes); - if (srcOff + srcPixelBytes > m_vramSize) - { - return failCopy(); - } - - dstRow[x * 4u + 0u] = m_vram[srcOff + 0u]; - dstRow[x * 4u + 1u] = m_vram[srcOff + 1u]; - dstRow[x * 4u + 2u] = m_vram[srcOff + 2u]; - dstRow[x * 4u + 3u] = - (preserveAlpha && frame.psm != GS_PSM_CT24) ? m_vram[srcOff + 3u] : 255u; - } - } - return true; - } - - if (frame.psm == GS_PSM_CT16 || frame.psm == GS_PSM_CT16S) - { - if (useLocalMemoryLayout) - { - for (uint32_t y = 0; y < height; ++y) - { - const uint32_t dstOff = y * kHostFrameWidth * 4u; - uint8_t *dst = outPixels.data() + dstOff; - for (uint32_t x = 0; x < width; ++x) - { - const uint32_t srcX = sourceOriginX + x; - const uint32_t srcY = sourceOriginY + y; - - const u16 c = ReadVram(frame.psm, basePtr, fbwBlocks, srcX, srcY); - - const uint32_t r = c & 31u; - const uint32_t g = (c >> 5) & 31u; - const uint32_t b = (c >> 10) & 31u; - dst[x * 4u + 0u] = static_cast((r << 3) | (r >> 2)); - dst[x * 4u + 1u] = static_cast((g << 3) | (g >> 2)); - dst[x * 4u + 2u] = static_cast((b << 3) | (b >> 2)); - dst[x * 4u + 3u] = preserveAlpha ? ((c & 0x8000u) ? 0x80u : 0x00u) : 255u; - } - } - return true; - } - - for (uint32_t y = 0; y < height; ++y) - { - const uint32_t dstOff = y * kHostFrameWidth * 4u; - uint8_t *dst = outPixels.data() + dstOff; - for (uint32_t x = 0; x < width; ++x) - { - const uint32_t srcX = sourceOriginX + x; - const uint32_t srcY = sourceOriginY + y; - const uint32_t srcOff = baseBytes + (srcY * strideBytes) + (srcX * 2u); - if (srcOff + sizeof(uint16_t) > m_vramSize) - { - return failCopy(); - } - - uint16_t pixel = 0u; - std::memcpy(&pixel, m_vram + srcOff, sizeof(pixel)); - const uint32_t r = pixel & 31u; - const uint32_t g = (pixel >> 5) & 31u; - const uint32_t b = (pixel >> 10) & 31u; - dst[x * 4u + 0u] = static_cast((r << 3) | (r >> 2)); - dst[x * 4u + 1u] = static_cast((g << 3) | (g >> 2)); - dst[x * 4u + 2u] = static_cast((b << 3) | (b >> 2)); - dst[x * 4u + 3u] = preserveAlpha ? ((pixel & 0x8000u) ? 0x80u : 0x00u) : 255u; - } - } - return true; - } - - return failCopy(); -} - -void GS::latchHostPresentationFrame() -{ - thread_local std::vector vramSnapshot; - thread_local GS presentationGs; - - thread_local GSRegisters privateRegisters{}; - GSFrameReg contextFrames[2]{}; - GSFrameReg preferredSource{}; - uint32_t preferredDestFbp = 0u; - bool hasPreferredSource = false; - uint32_t vramSize = 0u; - - { - std::lock_guard lock(m_stateMutex); - if (!m_privRegs || !m_vram || m_vramSize == 0u) - { - std::lock_guard presentationLock(m_presentationMutex); - m_hostPresentationFrame.clear(); - m_hostPresentationWidth = 0u; - m_hostPresentationHeight = 0u; - m_hostPresentationDisplayFbp = 0u; - m_hostPresentationSourceFbp = 0u; - m_hostPresentationUsedPreferred = false; - m_hasHostPresentationFrame = false; - return; - } - - vramSize = m_vramSize; - vramSnapshot.resize(vramSize); - std::memcpy(vramSnapshot.data(), m_vram, vramSize); - - privateRegisters.pmode = m_privRegs->pmode; - privateRegisters.smode1 = m_privRegs->smode1; - privateRegisters.smode2 = m_privRegs->smode2; - privateRegisters.srfsh = m_privRegs->srfsh; - privateRegisters.synch1 = m_privRegs->synch1; - privateRegisters.synch2 = m_privRegs->synch2; - privateRegisters.syncv = m_privRegs->syncv; - privateRegisters.dispfb1 = m_privRegs->dispfb1; - privateRegisters.display1 = m_privRegs->display1; - privateRegisters.dispfb2 = m_privRegs->dispfb2; - privateRegisters.display2 = m_privRegs->display2; - privateRegisters.extbuf = m_privRegs->extbuf; - privateRegisters.extdata = m_privRegs->extdata; - privateRegisters.extwrite = m_privRegs->extwrite; - privateRegisters.bgcolor = m_privRegs->bgcolor; - privateRegisters.csr.store(m_privRegs->csr.load(std::memory_order_acquire), std::memory_order_relaxed); - privateRegisters.vsyncTick.store(m_privRegs->vsyncTick.load(std::memory_order_acquire), std::memory_order_relaxed); - privateRegisters.imr = m_privRegs->imr; - privateRegisters.busdir = m_privRegs->busdir; - privateRegisters.siglblid = m_privRegs->siglblid; - - contextFrames[0] = m_ctx[0].frame; - contextFrames[1] = m_ctx[1].frame; - preferredSource = m_preferredDisplaySourceFrame; - preferredDestFbp = m_preferredDisplayDestFbp; - hasPreferredSource = m_hasPreferredDisplaySource; - } - - presentationGs.init(vramSnapshot.data(), vramSize, &privateRegisters); - presentationGs.m_ctx[0].frame = contextFrames[0]; - presentationGs.m_ctx[1].frame = contextFrames[1]; - presentationGs.m_preferredDisplaySourceFrame = preferredSource; - presentationGs.m_preferredDisplayDestFbp = preferredDestFbp; - presentationGs.m_hasPreferredDisplaySource = hasPreferredSource; - presentationGs.latchHostPresentationFrameUnlocked(); - - uint32_t displayFbp = 0u; - uint32_t sourceFbp = 0u; - uint32_t width = 0u; - uint32_t height = 0u; - bool usedPreferred = false; - bool hasFrame = false; - { - std::lock_guard presentationLock(m_presentationMutex); - m_hostPresentationFrame.swap(presentationGs.m_hostPresentationFrame); - m_hostPresentationWidth = presentationGs.m_hostPresentationWidth; - m_hostPresentationHeight = presentationGs.m_hostPresentationHeight; - m_hostPresentationDisplayFbp = presentationGs.m_hostPresentationDisplayFbp; - m_hostPresentationSourceFbp = presentationGs.m_hostPresentationSourceFbp; - m_hostPresentationUsedPreferred = presentationGs.m_hostPresentationUsedPreferred; - m_hasHostPresentationFrame = presentationGs.m_hasHostPresentationFrame; - - displayFbp = m_hostPresentationDisplayFbp; - sourceFbp = m_hostPresentationSourceFbp; - width = m_hostPresentationWidth; - height = m_hostPresentationHeight; - usedPreferred = m_hostPresentationUsedPreferred; - hasFrame = m_hasHostPresentationFrame; - } - - if (hasFrame) - { - std::lock_guard lock(m_stateMutex); - recordPresentDebugEventUnlocked(displayFbp, sourceFbp, width, height, usedPreferred); - } -} - -void GS::latchHostPresentationFrameUnlocked() -{ - if (!m_privRegs || !m_vram || m_vramSize == 0u) - { - m_hostPresentationFrame.clear(); - m_hostPresentationWidth = 0u; - m_hostPresentationHeight = 0u; - m_hostPresentationDisplayFbp = 0u; - m_hostPresentationSourceFbp = 0u; - m_hostPresentationUsedPreferred = false; - m_hasHostPresentationFrame = false; - return; - } - - const GSPmodeState pmode = decodePmode(m_privRegs->pmode); - const GSSmode2State smode2 = decodeSMode2(m_privRegs->smode2); - const bool applyFieldMode = smode2.interlaced && !smode2.frameMode; - const bool oddField = (m_privRegs->vsyncTick.load(std::memory_order_acquire) & 1ull) != 0ull; - const GSFrameReg displayFrame1 = decodeDisplayFrame(m_privRegs->dispfb1); - const GSFrameReg displayFrame2 = decodeDisplayFrame(m_privRegs->dispfb2); - const GSDisplayReadOrigin displayOrigin1 = decodeDisplayReadOrigin(m_privRegs->dispfb1); - const GSDisplayReadOrigin displayOrigin2 = decodeDisplayReadOrigin(m_privRegs->dispfb2); - - uint32_t width1 = 0u; - uint32_t height1 = 0u; - uint32_t width2 = 0u; - uint32_t height2 = 0u; - decodeDisplaySize(m_privRegs->display1, width1, height1); - decodeDisplaySize(m_privRegs->display2, width2, height2); - - const bool validCrt1 = pmode.enableCrt1 && hasDisplaySetup(m_privRegs->display1, displayFrame1); - const bool validCrt2 = pmode.enableCrt2 && hasDisplaySetup(m_privRegs->display2, displayFrame2); - - auto copyDisplaySource = [&](const GSFrameReg &displayFrame, - const GSDisplayReadOrigin &displayOrigin, - uint32_t width, - uint32_t height, - bool allowPreferred, - bool preserveAlpha, - GSFrameReg &selectedFrame, - std::vector &scratch, - bool &usedPreferred) -> bool - { - selectedFrame = displayFrame; - scratch.clear(); - usedPreferred = false; - - if (allowPreferred && - m_hasPreferredDisplaySource && - m_preferredDisplayDestFbp == displayFrame.fbp && - (m_preferredDisplaySourceFrame.fbw != 0u || m_preferredDisplaySourceFrame.fbp != displayFrame.fbp)) - { - if (copyFrameToHostRgbaUnlocked(m_preferredDisplaySourceFrame, - width, - height, - scratch, - preserveAlpha, - true, - false, - 0u, - 0u)) - { - selectedFrame = m_preferredDisplaySourceFrame; - usedPreferred = true; - } - } - - if (scratch.empty() && - !copyFrameToHostRgbaUnlocked(displayFrame, - width, - height, - scratch, - preserveAlpha, - true, - true, - displayOrigin.x, - displayOrigin.y)) - { - return false; - } - - if (!usedPreferred && displayFrame.fbp == 0u && countNonBlackPixels(scratch, width, height) == 0u) - { - for (int contextIndex = 0; contextIndex < 2; ++contextIndex) - { - const GSFrameReg &candidate = m_ctx[contextIndex].frame; - if (candidate.fbp == selectedFrame.fbp && - candidate.fbw == selectedFrame.fbw && - candidate.psm == selectedFrame.psm) - { - continue; - } - - std::vector candidatePixels; - if (!copyFrameToHostRgbaUnlocked(candidate, - width, - height, - candidatePixels, - preserveAlpha, - true, - true, - 0u, - 0u)) - { - continue; - } - - if (countNonBlackPixels(candidatePixels, width, height) == 0u) - { - continue; - } - - selectedFrame = candidate; - scratch.swap(candidatePixels); - break; - } - } - - return true; - }; - - if (!validCrt1 && !validCrt2) - { - m_hostPresentationFrame.clear(); - m_hostPresentationWidth = 0u; - m_hostPresentationHeight = 0u; - m_hostPresentationDisplayFbp = 0u; - m_hostPresentationSourceFbp = 0u; - m_hostPresentationUsedPreferred = false; - m_hasHostPresentationFrame = false; - return; - } - - if (validCrt1 && validCrt2) - { - GSFrameReg selectedFrame1{}; - GSFrameReg selectedFrame2{}; - std::vector rc1; - std::vector rc2; - bool usedPreferred1 = false; - bool usedPreferred2 = false; - - const bool copiedCrt1 = copyDisplaySource(displayFrame1, displayOrigin1, width1, height1, false, true, selectedFrame1, rc1, usedPreferred1); - const bool copiedCrt2 = copyDisplaySource(displayFrame2, displayOrigin2, width2, height2, false, true, selectedFrame2, rc2, usedPreferred2); - - if (copiedCrt1 && copiedCrt2) - { - const uint32_t width = std::max(width1, width2); - const uint32_t height = std::max(height1, height2); - const uint8_t bgR = static_cast(m_privRegs->bgcolor & 0xFFu); - const uint8_t bgG = static_cast((m_privRegs->bgcolor >> 8) & 0xFFu); - const uint8_t bgB = static_cast((m_privRegs->bgcolor >> 16) & 0xFFu); - const uint8_t bgA = pmode.alp; - - std::vector merged(kHostFrameWidth * kHostFrameHeight * 4u, 0u); - for (uint32_t y = 0; y < height; ++y) - { - uint8_t *dstRow = merged.data() + (y * kHostFrameWidth * 4u); - for (uint32_t x = 0; x < width; ++x) - { - dstRow[x * 4u + 0u] = bgR; - dstRow[x * 4u + 1u] = bgG; - dstRow[x * 4u + 2u] = bgB; - dstRow[x * 4u + 3u] = bgA; - } - } - - if (!pmode.slbg) - { - for (uint32_t y = 0; y < height2; ++y) - { - const uint8_t *srcRow = rc2.data() + (y * kHostFrameWidth * 4u); - uint8_t *dstRow = merged.data() + (y * kHostFrameWidth * 4u); - for (uint32_t x = 0; x < width2; ++x) - { - dstRow[x * 4u + 0u] = srcRow[x * 4u + 0u]; - dstRow[x * 4u + 1u] = srcRow[x * 4u + 1u]; - dstRow[x * 4u + 2u] = srcRow[x * 4u + 2u]; - dstRow[x * 4u + 3u] = srcRow[x * 4u + 3u]; - } - } - } - - for (uint32_t y = 0; y < height1; ++y) - { - const uint8_t *srcRow = rc1.data() + (y * kHostFrameWidth * 4u); - uint8_t *dstRow = merged.data() + (y * kHostFrameWidth * 4u); - for (uint32_t x = 0; x < width1; ++x) - { - const uint8_t srcR = srcRow[x * 4u + 0u]; - const uint8_t srcG = srcRow[x * 4u + 1u]; - const uint8_t srcB = srcRow[x * 4u + 2u]; - const uint8_t srcA = srcRow[x * 4u + 3u]; - const uint8_t dstR = dstRow[x * 4u + 0u]; - const uint8_t dstG = dstRow[x * 4u + 1u]; - const uint8_t dstB = dstRow[x * 4u + 2u]; - const uint8_t dstA = dstRow[x * 4u + 3u]; - const uint32_t factor = pmode.mmod - ? static_cast(pmode.alp) - : std::min(255u, static_cast(srcA) * 2u); - - dstRow[x * 4u + 0u] = blendPresentationChannel(srcR, dstR, factor); - dstRow[x * 4u + 1u] = blendPresentationChannel(srcG, dstG, factor); - dstRow[x * 4u + 2u] = blendPresentationChannel(srcB, dstB, factor); - dstRow[x * 4u + 3u] = pmode.amod ? dstA : srcA; - } - } - - for (uint32_t y = 0; y < height; ++y) - { - uint8_t *row = merged.data() + (y * kHostFrameWidth * 4u); - for (uint32_t x = 0; x < width; ++x) - { - row[x * 4u + 3u] = 255u; - } - } - - if (applyFieldMode) - { - applyFieldPresentation(merged, width, height, oddField); - } - - m_hostPresentationFrame.swap(merged); - m_hostPresentationWidth = width; - m_hostPresentationHeight = height; - m_hostPresentationDisplayFbp = displayFrame1.fbp; - m_hostPresentationSourceFbp = selectedFrame1.fbp; - m_hostPresentationUsedPreferred = false; - m_hasHostPresentationFrame = true; - recordPresentDebugEventUnlocked(m_hostPresentationDisplayFbp, - m_hostPresentationSourceFbp, - m_hostPresentationWidth, - m_hostPresentationHeight, - m_hostPresentationUsedPreferred); - return; - } - } - - const GSFrameReg &displayFrame = validCrt1 ? displayFrame1 : displayFrame2; - const uint32_t width = validCrt1 ? width1 : width2; - const uint32_t height = validCrt1 ? height1 : height2; - - GSFrameReg selectedFrame = displayFrame; - std::vector scratch; - bool usedPreferred = false; - const GSDisplayReadOrigin &displayOrigin = validCrt1 ? displayOrigin1 : displayOrigin2; - if (!copyDisplaySource(displayFrame, displayOrigin, width, height, true, false, selectedFrame, scratch, usedPreferred)) - { - m_hostPresentationFrame.clear(); - m_hostPresentationWidth = 0u; - m_hostPresentationHeight = 0u; - m_hostPresentationDisplayFbp = displayFrame.fbp; - m_hostPresentationSourceFbp = 0u; - m_hostPresentationUsedPreferred = false; - m_hasHostPresentationFrame = false; - return; - } - - if (applyFieldMode) - { - applyFieldPresentation(scratch, width, height, oddField); - } - - normalizePresentationAlpha(scratch, width, height); - - m_hostPresentationFrame.swap(scratch); - m_hostPresentationWidth = width; - m_hostPresentationHeight = height; - m_hostPresentationDisplayFbp = displayFrame.fbp; - m_hostPresentationSourceFbp = selectedFrame.fbp; - m_hostPresentationUsedPreferred = usedPreferred; - m_hasHostPresentationFrame = true; - recordPresentDebugEventUnlocked(m_hostPresentationDisplayFbp, - m_hostPresentationSourceFbp, - m_hostPresentationWidth, - m_hostPresentationHeight, - m_hostPresentationUsedPreferred); -} - -bool GS::copyLatchedHostPresentationFrame(std::vector &outPixels, - uint32_t &outWidth, - uint32_t &outHeight, - uint32_t *outDisplayFbp, - uint32_t *outSourceFbp, - bool *outUsedPreferred) const -{ - std::lock_guard lock(m_presentationMutex); - if (!m_hasHostPresentationFrame || m_hostPresentationFrame.empty()) - { - outPixels.clear(); - outWidth = 0u; - outHeight = 0u; - if (outDisplayFbp) - *outDisplayFbp = 0u; - if (outSourceFbp) - *outSourceFbp = 0u; - if (outUsedPreferred) - *outUsedPreferred = false; - return false; - } - - outWidth = m_hostPresentationWidth; - outHeight = m_hostPresentationHeight; - if (outDisplayFbp) - *outDisplayFbp = m_hostPresentationDisplayFbp; - if (outSourceFbp) - *outSourceFbp = m_hostPresentationSourceFbp; - if (outUsedPreferred) - *outUsedPreferred = m_hostPresentationUsedPreferred; - - const size_t packedRowBytes = static_cast(outWidth) * 4u; - outPixels.resize(packedRowBytes * static_cast(outHeight)); - if (outWidth != 0u && outHeight != 0u) - { - const size_t sourceRowBytes = static_cast(kHostFrameWidth) * 4u; - for (uint32_t y = 0; y < outHeight; ++y) - { - const size_t srcOffset = static_cast(y) * sourceRowBytes; - const size_t dstOffset = static_cast(y) * packedRowBytes; - if (srcOffset + packedRowBytes > m_hostPresentationFrame.size() || - dstOffset + packedRowBytes > outPixels.size()) - { - outPixels.clear(); - outWidth = 0u; - outHeight = 0u; - if (outDisplayFbp) - *outDisplayFbp = 0u; - if (outSourceFbp) - *outSourceFbp = 0u; - if (outUsedPreferred) - *outUsedPreferred = false; - return false; - } - - std::memcpy(outPixels.data() + dstOffset, - m_hostPresentationFrame.data() + srcOffset, - packedRowBytes); - } - } - return true; -} - -void GS::processGIFPacket(const uint8_t *data, uint32_t sizeBytes) -{ - std::lock_guard lock(m_stateMutex); - if (!data || sizeBytes < 16 || !m_vram) - return; - - if (tryProcessNativeImageUploadPacket(data, sizeBytes)) - return; - - PS2_IF_AGRESSIVE_LOGS({ - const uint32_t packetIndex = s_debugGifPacketCount.fetch_add(1, std::memory_order_relaxed); - if (packetIndex < 48u) - { - const uint64_t tagLo = loadLE64(data); - const uint32_t nloop = static_cast(tagLo & 0x7FFFu); - const uint8_t flg = static_cast((tagLo >> 58) & 0x3u); - uint32_t nreg = static_cast((tagLo >> 60) & 0xFu); - if (nreg == 0u) - nreg = 16u; - RUNTIME_LOG("[gs:gif] idx=" << packetIndex - << " size=" << sizeBytes - << " nloop=" << nloop - << " flg=" << static_cast(flg) - << " nreg=" << nreg - << " ctx0fbp=" << m_ctx[0].frame.fbp - << " ctx1fbp=" << m_ctx[1].frame.fbp - << std::endl); - } - }); - - uint32_t offset = 0; - while (offset + 16 <= sizeBytes) - { - uint64_t tagLo = loadLE64(data + offset); - uint64_t tagHi = loadLE64(data + offset + 8); - offset += 16; - - m_curQ = 1.0f; - - uint32_t nloop = static_cast(tagLo & 0x7FFF); - uint8_t flg = static_cast((tagLo >> 58) & 0x3); - uint32_t nreg = static_cast((tagLo >> 60) & 0xF); - if (nreg == 0) - nreg = 16; - - recordGifTagDebugEventUnlocked(sizeBytes, nloop, flg, nreg); - - bool pre = ((tagLo >> 46) & 1) != 0; - if (pre) - { - writeRegisterUnlocked(GS_REG_PRIM, (tagLo >> 47) & 0x7FF); - } - - uint8_t regs[16]; - for (uint32_t i = 0; i < nreg; ++i) - regs[i] = static_cast((tagHi >> (i * 4)) & 0xF); - - if (flg == GIF_FMT_PACKED) - { - for (uint32_t loop = 0; loop < nloop; ++loop) - { - for (uint32_t r = 0; r < nreg; ++r) - { - if (offset + 16 > sizeBytes) - return; - uint64_t lo = loadLE64(data + offset); - uint64_t hi = loadLE64(data + offset + 8); - offset += 16; - writeRegisterPacked(regs[r], lo, hi); - } - } - } - else if (flg == GIF_FMT_REGLIST) - { - for (uint32_t loop = 0; loop < nloop; ++loop) - { - for (uint32_t r = 0; r < nreg; ++r) - { - if (offset + 8 > sizeBytes) - return; - writeRegisterUnlocked(regs[r], loadLE64(data + offset)); - offset += 8; - } - } - if ((nloop * nreg) & 1) - offset += 8; - } - else if (flg == GIF_FMT_IMAGE) - { - uint32_t imageBytes = nloop * 16; - if (offset + imageBytes > sizeBytes) - imageBytes = sizeBytes - offset; - processImageData(data + offset, imageBytes); - offset += imageBytes; - } - } -} - -bool GS::processNativePackedGIFPacket(const uint8_t *data, uint32_t sizeBytes) -{ - std::lock_guard lock(m_stateMutex); - if (!data || sizeBytes < 16u || !m_vram) - return false; - - if (!validatePackedGifPacket(data, sizeBytes)) - return false; - - const bool processed = visitPackedGifPacket(data, sizeBytes, [&](const PackedGifPacketTag &tag) - { - m_curQ = 1.0f; - - recordGifTagDebugEventUnlocked(sizeBytes, tag.nloop, GIF_FMT_PACKED, tag.nreg); - - const bool pre = ((tag.lo >> 46u) & 1u) != 0u; - if (pre) - writeRegisterUnlocked(GS_REG_PRIM, (tag.lo >> 47u) & 0x7FFu); - - uint32_t offset = tag.payloadOffset; - for (uint32_t loop = 0u; loop < tag.nloop; ++loop) - { - for (uint32_t r = 0u; r < tag.nreg; ++r) - { - const uint64_t lo = loadLE64(data + offset); - const uint64_t hi = loadLE64(data + offset + 8u); - offset += 16u; - writeRegisterPacked(tag.regs[r], lo, hi); - } - } - - return true; }); - - if (!processed) - return false; - - ++m_nativePackedGIFPacketCount; - return true; -} - -void GS::uploadImageNative(uint64_t bitbltbuf, - uint64_t trxpos, - uint64_t trxreg, - uint64_t trxdir, - const uint8_t *data, - uint32_t sizeBytes) -{ - std::lock_guard lock(m_stateMutex); - uploadImageNativeUnlocked(bitbltbuf, trxpos, trxreg, trxdir, data, sizeBytes); -} - -void GS::uploadImageNativeUnlocked(uint64_t bitbltbuf, - uint64_t trxpos, - uint64_t trxreg, - uint64_t trxdir, - const uint8_t *data, - uint32_t sizeBytes) -{ - if (!data || sizeBytes == 0 || !m_vram) - return; - - writeRegisterUnlocked(GS_REG_BITBLTBUF, bitbltbuf); - writeRegisterUnlocked(GS_REG_TRXPOS, trxpos); - writeRegisterUnlocked(GS_REG_TRXREG, trxreg); - writeRegisterUnlocked(GS_REG_TRXDIR, trxdir); - processImageData(data, sizeBytes); - ++m_nativeImageUploadCount; -} - -bool GS::tryProcessNativeImageUploadPacket(const uint8_t *data, uint32_t sizeBytes) -{ - constexpr uint32_t kSetupRegisters = 4u; - constexpr uint32_t kPackedAdPayloadBytes = kSetupRegisters * 16u; - constexpr uint64_t kPackedAdDescriptor = 0x0Eull; - - if (!data || sizeBytes < 16u + kPackedAdPayloadBytes + 16u) - return false; - - const uint64_t setupTagLo = loadLE64(data); - const uint64_t setupTagHi = loadLE64(data + 8u); - const uint32_t setupNloop = static_cast(setupTagLo & 0x7FFFu); - const uint8_t setupFlg = static_cast((setupTagLo >> 58u) & 0x3u); - uint32_t setupNreg = static_cast((setupTagLo >> 60u) & 0xFu); - if (setupNreg == 0u) - setupNreg = 16u; - - if (setupNloop != kSetupRegisters || - setupFlg != GIF_FMT_PACKED || - setupNreg != 1u || - (setupTagHi & 0xFull) != kPackedAdDescriptor) - { - return false; - } - - uint64_t regs[kSetupRegisters] = {}; - uint32_t offset = 16u; - constexpr uint8_t expectedRegs[kSetupRegisters] = { - GS_REG_BITBLTBUF, - GS_REG_TRXPOS, - GS_REG_TRXREG, - GS_REG_TRXDIR, - }; - - for (uint32_t i = 0; i < kSetupRegisters; ++i) - { - regs[i] = loadLE64(data + offset); - const uint64_t reg = loadLE64(data + offset + 8u); - if ((reg & 0xFFu) != expectedRegs[i]) - return false; - offset += 16u; - } - - const uint32_t trxdirMode = static_cast(regs[3] & 0x3ull); - const uint32_t rrw = static_cast(regs[2] & 0xFFFull); - const uint32_t rrh = static_cast((regs[2] >> 32u) & 0xFFFull); - if (trxdirMode != 0u || rrw == 0u || rrh == 0u) - return false; - - if (offset + 16u > sizeBytes) - return false; - - const uint64_t imageTagLo = loadLE64(data + offset); - const uint8_t imageFlg = static_cast((imageTagLo >> 58u) & 0x3u); - const uint32_t imageNloop = static_cast(imageTagLo & 0x7FFFu); - if (imageFlg != GIF_FMT_IMAGE || imageNloop == 0u) - return false; - - offset += 16u; - const uint64_t imageBytes64 = static_cast(imageNloop) * 16ull; - if (imageBytes64 > 0xFFFFFFFFull) - return false; - const uint32_t imageBytes = static_cast(imageBytes64); - if (offset + imageBytes != sizeBytes) - return false; - - uploadImageNativeUnlocked(regs[0], regs[1], regs[2], regs[3], data + offset, imageBytes); - return true; -} - -void GS::writeRegisterPacked(uint8_t regDesc, uint64_t lo, uint64_t hi) -{ - switch (regDesc) - { - case 0x00: - writeRegisterUnlocked(GS_REG_PRIM, lo & 0x7FF); - break; - case 0x01: - m_curR = static_cast(lo & 0xFF); - m_curG = static_cast((lo >> 32) & 0xFF); - m_curB = static_cast(hi & 0xFF); - m_curA = static_cast((hi >> 32) & 0xFF); - break; - case 0x02: - { - uint32_t sBits = static_cast(lo & 0xFFFFFFFF); - uint32_t tBits = static_cast((lo >> 32) & 0xFFFFFFFF); - uint32_t qBits = static_cast(hi & 0xFFFFFFFF); - std::memcpy(&m_curS, &sBits, 4); - std::memcpy(&m_curT, &tBits, 4); - std::memcpy(&m_curQ, &qBits, 4); - if (m_curQ == 0.0f) - m_curQ = 1.0f; - break; - } - case 0x03: - m_curU = static_cast(lo & 0x3FFFu); - m_curV = static_cast((lo >> 32) & 0x3FFFu); - break; - case 0x04: - { - uint16_t x = static_cast(lo & 0xFFFF); - uint16_t y = static_cast((lo >> 32) & 0xFFFF); - uint32_t z = static_cast((hi >> 4) & 0xFFFFFF); - uint8_t f = static_cast((hi >> 36) & 0xFF); - bool adk = ((hi >> 47) & 1) != 0; - PS2_IF_AGRESSIVE_LOGS({ - const uint32_t debugIndex = s_debugGsPackedVertexCount.fetch_add(1, std::memory_order_relaxed); - if (debugIndex < 64u) - { - RUNTIME_LOG("[gs:packed-xyzf] idx=" << debugIndex - << " x=" << x - << " y=" << y - << " z=0x" << std::hex << z - << std::dec - << " fog=" << static_cast(f) - << " kick=" << static_cast(!adk ? 1u : 0u) - << " prim=" << static_cast(m_prim.type) - << std::endl); - } - }); - GSVertex &vtx = m_vtxQueue[m_vtxCount % kMaxVerts]; - vtx.x = static_cast(x) / 16.0f; - vtx.y = static_cast(y) / 16.0f; - vtx.z = static_cast(z); - vtx.r = m_curR; - vtx.g = m_curG; - vtx.b = m_curB; - vtx.a = m_curA; - vtx.q = m_curQ; - vtx.s = m_curS; - vtx.t = m_curT; - vtx.u = m_curU; - vtx.v = m_curV; - vtx.fog = f; - vertexKick(!adk); - break; - } - case 0x05: - { - uint16_t x = static_cast(lo & 0xFFFF); - uint16_t y = static_cast((lo >> 32) & 0xFFFF); - uint32_t z = static_cast(hi & 0xFFFFFFFF); - bool adk = ((hi >> 47) & 1) != 0; - PS2_IF_AGRESSIVE_LOGS({ - const uint32_t debugIndex = s_debugGsPackedVertexCount.fetch_add(1, std::memory_order_relaxed); - if (debugIndex < 64u) - { - RUNTIME_LOG("[gs:packed-xyz] idx=" << debugIndex - << " x=" << x - << " y=" << y - << " z=0x" << std::hex << z - << std::dec - << " kick=" << static_cast(!adk ? 1u : 0u) - << " prim=" << static_cast(m_prim.type) - << std::endl); - } - }); - GSVertex &vtx = m_vtxQueue[m_vtxCount % kMaxVerts]; - vtx.x = static_cast(x) / 16.0f; - vtx.y = static_cast(y) / 16.0f; - vtx.z = static_cast(z); - vtx.r = m_curR; - vtx.g = m_curG; - vtx.b = m_curB; - vtx.a = m_curA; - vtx.q = m_curQ; - vtx.s = m_curS; - vtx.t = m_curT; - vtx.u = m_curU; - vtx.v = m_curV; - vtx.fog = m_curFog; - vertexKick(!adk); - break; - } - case 0x0A: - m_curFog = static_cast((hi >> 36) & 0xFF); - break; - case 0x0C: - { - PS2_IF_AGRESSIVE_LOGS({ - const uint32_t debugIndex = s_debugGsPackedVertexCount.fetch_add(1, std::memory_order_relaxed); - if (debugIndex < 64u) - { - RUNTIME_LOG("[gs:packed-xyzf3] idx=" << debugIndex - << " x=" << static_cast(lo & 0xFFFFu) - << " y=" << static_cast((lo >> 32) & 0xFFFFu) - << " kick=0" - << " prim=" << static_cast(m_prim.type) - << std::endl); - } - }); - GSVertex &vtx = m_vtxQueue[m_vtxCount % kMaxVerts]; - vtx.x = static_cast(lo & 0xFFFF) / 16.0f; - vtx.y = static_cast((lo >> 32) & 0xFFFF) / 16.0f; - vtx.z = static_cast((hi >> 4) & 0xFFFFFF); - vtx.r = m_curR; - vtx.g = m_curG; - vtx.b = m_curB; - vtx.a = m_curA; - vtx.q = m_curQ; - vtx.s = m_curS; - vtx.t = m_curT; - vtx.u = m_curU; - vtx.v = m_curV; - vtx.fog = static_cast((hi >> 36) & 0xFF); - vertexKick(false); - break; - } - case 0x0D: - { - PS2_IF_AGRESSIVE_LOGS({ - const uint32_t debugIndex = s_debugGsPackedVertexCount.fetch_add(1, std::memory_order_relaxed); - if (debugIndex < 64u) - { - RUNTIME_LOG("[gs:packed-xyz3] idx=" << debugIndex - << " x=" << static_cast(lo & 0xFFFFu) - << " y=" << static_cast((lo >> 32) & 0xFFFFu) - << " kick=0" - << " prim=" << static_cast(m_prim.type) - << std::endl); - } - }); - GSVertex &vtx = m_vtxQueue[m_vtxCount % kMaxVerts]; - vtx.x = static_cast(lo & 0xFFFF) / 16.0f; - vtx.y = static_cast((lo >> 32) & 0xFFFF) / 16.0f; - vtx.z = static_cast(hi & 0xFFFFFFFF); - vtx.r = m_curR; - vtx.g = m_curG; - vtx.b = m_curB; - vtx.a = m_curA; - vtx.q = m_curQ; - vtx.s = m_curS; - vtx.t = m_curT; - vtx.u = m_curU; - vtx.v = m_curV; - vtx.fog = m_curFog; - vertexKick(false); - break; - } - case 0x0E: - { - uint8_t addr = static_cast(hi & 0xFF); - writeRegisterUnlocked(addr, lo); - break; - } - case 0x0F: - break; - default: - writeRegisterUnlocked(regDesc, lo); - break; - } -} - -void GS::writeRegister(uint8_t regAddr, uint64_t value) -{ - std::lock_guard lock(m_stateMutex); - writeRegisterUnlocked(regAddr, value); -} - -void GS::writeRegisterUnlocked(uint8_t regAddr, uint64_t value) -{ - const bool interestingReg = - regAddr == GS_REG_PRIM || - regAddr == GS_REG_RGBAQ || - regAddr == GS_REG_ST || - regAddr == GS_REG_UV || - regAddr == GS_REG_XYZ2 || - regAddr == GS_REG_XYZ3 || - regAddr == GS_REG_XYZF2 || - regAddr == GS_REG_XYZF3 || - regAddr == GS_REG_TEX0_1 || - regAddr == GS_REG_TEX0_2 || - regAddr == GS_REG_TEX2_1 || - regAddr == GS_REG_TEX2_2 || - regAddr == GS_REG_TEXCLUT || - regAddr == GS_REG_TEXA || - regAddr == GS_REG_XYOFFSET_1 || - regAddr == GS_REG_XYOFFSET_2 || - regAddr == GS_REG_SCISSOR_1 || - regAddr == GS_REG_SCISSOR_2 || - regAddr == GS_REG_FRAME_1 || - regAddr == GS_REG_FRAME_2 || - regAddr == GS_REG_ALPHA_1 || - regAddr == GS_REG_ALPHA_2 || - regAddr == GS_REG_TEST_1 || - regAddr == GS_REG_TEST_2 || - regAddr == GS_REG_BITBLTBUF || - regAddr == GS_REG_TRXPOS || - regAddr == GS_REG_TRXREG || - regAddr == GS_REG_TRXDIR; - - PS2_IF_AGRESSIVE_LOGS({ - if (interestingReg) - { - const uint32_t debugIndex = s_debugGsRegisterCount.fetch_add(1, std::memory_order_relaxed); - if (debugIndex < 128u) - { - RUNTIME_LOG("[gs:reg] idx=" << debugIndex - << " reg=0x" << std::hex << static_cast(regAddr) - << " value=0x" << value - << std::dec - << std::endl); - } - } - }); - - const bool isCopyRelevantReg = - regAddr == GS_REG_PRIM || - regAddr == GS_REG_TEX0_2 || - regAddr == GS_REG_TEX1_2 || - regAddr == GS_REG_ALPHA_2 || - regAddr == GS_REG_TEST_2 || - regAddr == GS_REG_PABE || - regAddr == GS_REG_FRAME_2 || - regAddr == GS_REG_XYOFFSET_2 || - regAddr == GS_REG_SCISSOR_2; - PS2_IF_AGRESSIVE_LOGS({ - if (isCopyRelevantReg && - s_debugCopyRegCount.fetch_add(1u, std::memory_order_relaxed) < 64u) - { - RUNTIME_LOG("[gs:copy-reg] reg=0x" - << std::hex << static_cast(regAddr) - << " value=0x" << value - << std::dec - << " primCtxt=" << static_cast(m_prim.ctxt) - << " ctx0fbp=" << m_ctx[0].frame.fbp - << " ctx1fbp=" << m_ctx[1].frame.fbp - << std::endl); - } - }); - - switch (regAddr) - { - case GS_REG_PRIM: - { - m_primRegister = decodePrimRegister(value); - if (m_prmodecont) - { - m_prim = m_primRegister; - } - else - { - // PRIM always selects the primitive topology. With AC=0, all - // rendering attributes remain sourced from PRMODE. - m_prim.type = m_primRegister.type; - } - m_vtxCount = 0; - m_vtxIndex = 0; - break; - } - case GS_REG_RGBAQ: - { - m_curR = static_cast(value & 0xFF); - m_curG = static_cast((value >> 8) & 0xFF); - m_curB = static_cast((value >> 16) & 0xFF); - m_curA = static_cast((value >> 24) & 0xFF); - uint32_t qBits = static_cast((value >> 32) & 0xFFFFFFFF); - std::memcpy(&m_curQ, &qBits, 4); - if (m_curQ == 0.0f) - m_curQ = 1.0f; - break; - } - case GS_REG_ST: - { - uint32_t sBits = static_cast(value & 0xFFFFFFFF); - uint32_t tBits = static_cast((value >> 32) & 0xFFFFFFFF); - std::memcpy(&m_curS, &sBits, 4); - std::memcpy(&m_curT, &tBits, 4); - break; - } - case GS_REG_UV: - { - m_curU = static_cast(value & 0x3FFFu); - m_curV = static_cast((value >> 16) & 0x3FFFu); - break; - } - case GS_REG_XYZF2: - case GS_REG_XYZF3: - { - GSVertex &vtx = m_vtxQueue[m_vtxCount % kMaxVerts]; - vtx.x = static_cast(value & 0xFFFF) / 16.0f; - vtx.y = static_cast((value >> 16) & 0xFFFF) / 16.0f; - vtx.z = static_cast((value >> 32) & 0xFFFFFF); - vtx.fog = static_cast((value >> 56) & 0xFF); - vtx.r = m_curR; - vtx.g = m_curG; - vtx.b = m_curB; - vtx.a = m_curA; - vtx.q = m_curQ; - vtx.s = m_curS; - vtx.t = m_curT; - vtx.u = m_curU; - vtx.v = m_curV; - vertexKick(regAddr == GS_REG_XYZF2); - break; - } - case GS_REG_XYZ2: - case GS_REG_XYZ3: - { - GSVertex &vtx = m_vtxQueue[m_vtxCount % kMaxVerts]; - vtx.x = static_cast(value & 0xFFFF) / 16.0f; - vtx.y = static_cast((value >> 16) & 0xFFFF) / 16.0f; - vtx.z = static_cast((value >> 32) & 0xFFFFFFFF); - vtx.r = m_curR; - vtx.g = m_curG; - vtx.b = m_curB; - vtx.a = m_curA; - vtx.q = m_curQ; - vtx.s = m_curS; - vtx.t = m_curT; - vtx.u = m_curU; - vtx.v = m_curV; - vtx.fog = m_curFog; - vertexKick(regAddr == GS_REG_XYZ2); - break; - } - case GS_REG_TEX0_1: - case GS_REG_TEX0_2: - { - int ci = (regAddr == GS_REG_TEX0_2) ? 1 : 0; - auto &t = m_ctx[ci].tex0; - t.tbp0 = static_cast(value & 0x3FFF); - t.tbw = static_cast((value >> 14) & 0x3F); - t.psm = static_cast((value >> 20) & 0x3F); - t.tw = static_cast((value >> 26) & 0xF); - t.th = static_cast((value >> 30) & 0xF); - t.tcc = static_cast((value >> 34) & 0x1); - t.tfx = static_cast((value >> 35) & 0x3); - t.cbp = static_cast((value >> 37) & 0x3FFF); - t.cpsm = static_cast((value >> 51) & 0xF); - t.csm = static_cast((value >> 55) & 0x1); - t.csa = static_cast((value >> 56) & 0x1F); - t.cld = static_cast((value >> 61) & 0x7); - break; - } - case GS_REG_CLAMP_1: - case GS_REG_CLAMP_2: - { - int ci = (regAddr == GS_REG_CLAMP_2) ? 1 : 0; - m_ctx[ci].clamp = value; - break; - } - case GS_REG_FOG: - m_curFog = static_cast((value >> 56) & 0xFF); - break; - case GS_REG_TEX1_1: - case GS_REG_TEX1_2: - { - int ci = (regAddr == GS_REG_TEX1_2) ? 1 : 0; - m_ctx[ci].tex1 = value; - break; - } - case GS_REG_TEX2_1: - case GS_REG_TEX2_2: - { - int ci = (regAddr == GS_REG_TEX2_2) ? 1 : 0; - auto &t = m_ctx[ci].tex0; - t.psm = static_cast((value >> 20) & 0x3F); - t.cbp = static_cast((value >> 37) & 0x3FFF); - t.cpsm = static_cast((value >> 51) & 0xF); - t.csm = static_cast((value >> 55) & 0x1); - t.csa = static_cast((value >> 56) & 0x1F); - t.cld = static_cast((value >> 61) & 0x7); - break; - } - case GS_REG_XYOFFSET_1: - case GS_REG_XYOFFSET_2: - { - int ci = (regAddr == GS_REG_XYOFFSET_2) ? 1 : 0; - m_ctx[ci].xyoffset.ofx = static_cast(value & 0xFFFF); - m_ctx[ci].xyoffset.ofy = static_cast((value >> 32) & 0xFFFF); - break; - } - case GS_REG_PRMODECONT: - { - m_prmodecont = (value & 1) != 0; - const GSPrimType type = m_primRegister.type; - m_prim = m_prmodecont ? m_primRegister : m_prmodeRegister; - m_prim.type = type; - break; - } - case GS_REG_PRMODE: - { - m_prmodeRegister = decodePrimRegister(value); - if (!m_prmodecont) - { - const GSPrimType type = m_primRegister.type; - m_prim = m_prmodeRegister; - m_prim.type = type; - } - break; - } - case GS_REG_TEXCLUT: - m_texclut.cbw = static_cast(value & 0x3Fu); - m_texclut.cou = static_cast((value >> 6) & 0x3Fu); - m_texclut.cov = static_cast((value >> 12) & 0x3FFu); - break; - case GS_REG_SCISSOR_1: - case GS_REG_SCISSOR_2: - { - int ci = (regAddr == GS_REG_SCISSOR_2) ? 1 : 0; - m_ctx[ci].scissor.x0 = static_cast(value & 0x7FF); - m_ctx[ci].scissor.x1 = static_cast((value >> 16) & 0x7FF); - m_ctx[ci].scissor.y0 = static_cast((value >> 32) & 0x7FF); - m_ctx[ci].scissor.y1 = static_cast((value >> 48) & 0x7FF); - break; - } - case GS_REG_ALPHA_1: - case GS_REG_ALPHA_2: - { - int ci = (regAddr == GS_REG_ALPHA_2) ? 1 : 0; - m_ctx[ci].alpha = value; - break; - } - case GS_REG_TEST_1: - case GS_REG_TEST_2: - { - int ci = (regAddr == GS_REG_TEST_2) ? 1 : 0; - m_ctx[ci].test = value; - break; - } - case GS_REG_FRAME_1: - case GS_REG_FRAME_2: - { - int ci = (regAddr == GS_REG_FRAME_2) ? 1 : 0; - m_ctx[ci].frame.fbp = static_cast(value & 0x1FF); - m_ctx[ci].frame.fbw = static_cast((value >> 16) & 0x3F); - m_ctx[ci].frame.psm = static_cast((value >> 24) & 0x3F); - m_ctx[ci].frame.fbmsk = static_cast((value >> 32) & 0xFFFFFFFF); - break; - } - case GS_REG_ZBUF_1: - case GS_REG_ZBUF_2: - { - int ci = (regAddr == GS_REG_ZBUF_2) ? 1 : 0; - m_ctx[ci].zbuf.zbp = value & 0x1FF; - m_ctx[ci].zbuf.psm = ((value >> 24) & 0xF) | 0x30; - m_ctx[ci].zbuf.zmask = (value >> 32) & 1; - break; - } - case GS_REG_FBA_1: - case GS_REG_FBA_2: - { - int ci = (regAddr == GS_REG_FBA_2) ? 1 : 0; - m_ctx[ci].fba = value; - break; - } - case GS_REG_BITBLTBUF: - { - m_bitbltbuf.sbp = static_cast(value & 0x3FFF); - m_bitbltbuf.sbw = static_cast((value >> 16) & 0x3F); - m_bitbltbuf.spsm = static_cast((value >> 24) & 0x3F); - m_bitbltbuf.dbp = static_cast((value >> 32) & 0x3FFF); - m_bitbltbuf.dbw = static_cast((value >> 48) & 0x3F); - m_bitbltbuf.dpsm = static_cast((value >> 56) & 0x3F); - break; - } - case GS_REG_TRXPOS: - { - m_trxpos.ssax = static_cast(value & 0x7FF); - m_trxpos.ssay = static_cast((value >> 16) & 0x7FF); - m_trxpos.dsax = static_cast((value >> 32) & 0x7FF); - m_trxpos.dsay = static_cast((value >> 48) & 0x7FF); - m_trxpos.dir = static_cast((value >> 59) & 0x3); - break; - } - case GS_REG_TRXREG: - { - m_trxreg.rrw = static_cast(value & 0xFFF); - m_trxreg.rrh = static_cast((value >> 32) & 0xFFF); - break; - } - case GS_REG_TRXDIR: - { - m_trxdir = static_cast(value & 0x3); - - // We need the transfer state to survive the call to performLocalTo*Transfer - // This is because transfers can be broken into multiple IMAGE tags and we - // don't want to start all over again from the initial state - // The transfer starts officially when TRXDIR is accessed - m_transferState.x = m_trxpos.dsax; - m_transferState.y = m_trxpos.dsay; - m_transferState.total_pixels = m_trxreg.rrw * m_trxreg.rrh; - m_transferState.copied_pixels = 0; - - if (m_trxdir == 2 && m_vram) - { - performLocalToLocalTransfer(); - } - else if (m_trxdir == 1 && m_vram) - { - performLocalToHostToBuffer(); - } - recordTransferDebugEventUnlocked(); - break; - } - case GS_REG_HWREG: - { - uint8_t buf[8]; - std::memcpy(buf, &value, 8); - processImageData(buf, 8); - break; - } - case GS_REG_PABE: - m_pabe = (value & 1u) != 0u; - break; - case GS_REG_FOGCOL: - m_fogR = static_cast(value & 0xFFu); - m_fogG = static_cast((value >> 8) & 0xFFu); - m_fogB = static_cast((value >> 16) & 0xFFu); - break; - case GS_REG_TEXFLUSH: - case GS_REG_SCANMSK: - case GS_REG_DIMX: - case GS_REG_DTHE: - case GS_REG_COLCLAMP: - case GS_REG_MIPTBP1_1: - case GS_REG_MIPTBP1_2: - case GS_REG_MIPTBP2_1: - case GS_REG_MIPTBP2_2: - break; - case GS_REG_TEXA: - { - m_texa.ta0 = static_cast(value & 0xFFu); - m_texa.aem = ((value >> 15) & 0x1u) != 0u; - m_texa.ta1 = static_cast((value >> 32) & 0xFFu); - PS2_IF_AGRESSIVE_LOGS({ - const uint32_t texaIndex = s_debugTexaWriteCount.fetch_add(1u, std::memory_order_relaxed); - if (texaIndex < 24u) - { - RUNTIME_LOG("[gs:texa] idx=" << texaIndex - << " value=0x" << std::hex << value - << " ta0=0x" << ((value >> 0) & 0xFFu) - << " aem=" << ((value >> 15) & 0x1u) - << " ta1=0x" << ((value >> 32) & 0xFFu) - << std::dec - << std::endl); - } - }); - break; - } - case GS_REG_SIGNAL: - { - if (m_privRegs) - { - uint32_t id = static_cast(value & 0xFFFFFFFF); - uint32_t mask = static_cast(value >> 32); - uint32_t lo = static_cast(m_privRegs->siglblid & 0xFFFFFFFF); - lo = (lo & ~mask) | (id & mask); - m_privRegs->siglblid = (m_privRegs->siglblid & 0xFFFFFFFF00000000ULL) | lo; - m_privRegs->csr.fetch_or(0x1); - } - break; - } - case GS_REG_FINISH: - { - if (m_privRegs) - m_privRegs->csr.fetch_or(0x2); - break; - } - case GS_REG_LABEL: - { - if (m_privRegs) - { - uint32_t id = static_cast(value & 0xFFFFFFFF); - uint32_t mask = static_cast(value >> 32); - uint32_t hi = static_cast(m_privRegs->siglblid >> 32); - hi = (hi & ~mask) | (id & mask); - m_privRegs->siglblid = (static_cast(hi) << 32) | (m_privRegs->siglblid & 0xFFFFFFFF); - } - break; - } - case 0x59: - if (m_privRegs) - m_privRegs->dispfb1 = value; - break; - case 0x5a: - if (m_privRegs) - m_privRegs->display1 = value; - break; - case 0x5b: - if (m_privRegs) - m_privRegs->dispfb2 = value; - break; - case 0x5c: - if (m_privRegs) - m_privRegs->display2 = value; - break; - case 0x5f: - if (m_privRegs) - m_privRegs->bgcolor = value; - break; - default: - break; - } - - recordRegisterDebugEventUnlocked(regAddr, value); -} - -void GS::performLocalToLocalTransfer() -{ - if (!m_vram) - return; - - const u32 sbp = m_bitbltbuf.sbp; - const u8 sbw = m_bitbltbuf.sbw; - const u8 spsm = m_bitbltbuf.spsm; - const u32 dbp = m_bitbltbuf.dbp; - const u8 dbw = m_bitbltbuf.dbw; - const u8 dpsm = m_bitbltbuf.dpsm; - const u32 rrw = m_trxreg.rrw; - const u32 rrh = m_trxreg.rrh; - const u32 ssax = m_trxpos.ssax; - const u32 ssay = m_trxpos.ssay; - const u32 dsax = m_trxpos.dsax; - const u32 dsay = m_trxpos.dsay; - const u32 dir = m_trxpos.dir; - - const u32 total_pixels = rrw * rrh; - - if (total_pixels == 0) - { - m_trxdir = 3; - return; - } - - // TODO: clean this up / optimize - switch (dir) - { - case 0: // left -> right top -> bottom - { - u32 pixel_count = 0; - while (pixel_count < total_pixels) - { - const u32 x = pixel_count % rrw; - const u32 y = pixel_count / rrw; - - const u32 sx = x + ssax; - const u32 sy = y + ssay; - const u32 dx = x + dsax; - const u32 dy = y + dsay; - - WriteVram(dpsm, dbp, dbw, dx, dy, ReadVram(spsm, sbp, sbw, sx, sy)); - - pixel_count++; - } - } - break; - - // left -> right - // bottom -> top (invert y) - case 1: - { - u32 pixel_count = 0; - while (pixel_count < total_pixels) - { - const u32 x = pixel_count % rrw; - const u32 y = rrh - (pixel_count / rrw) - 1; - - const u32 sx = x + ssax; - const u32 sy = y + ssay; - const u32 dx = x + dsax; - const u32 dy = y + dsay; - - WriteVram(dpsm, dbp, dbw, dx, dy, ReadVram(spsm, sbp, sbw, sx, sy)); - - pixel_count++; - } - } - break; - - // right -> left (invert x) - // top -> bottom - case 2: - { - u32 pixel_count = 0; - while (pixel_count < total_pixels) - { - const u32 x = rrw - (pixel_count % rrw) - 1; - const u32 y = pixel_count / rrw; - - const u32 sx = x + ssax; - const u32 sy = y + ssay; - const u32 dx = x + dsax; - const u32 dy = y + dsay; - - WriteVram(dpsm, dbp, dbw, dx, dy, ReadVram(spsm, sbp, sbw, sx, sy)); - - pixel_count++; - } - } - break; - - // right to left (invert x) - // bottom to top (invert y) - case 3: - { - u32 pixel_count = 0; - while (pixel_count < total_pixels) - { - const u32 x = rrw - (pixel_count % rrw) - 1; - const u32 y = rrh - (pixel_count / rrw) - 1; - - const u32 sx = x + ssax; - const u32 sy = y + ssay; - const u32 dx = x + dsax; - const u32 dy = y + dsay; - - WriteVram(dpsm, dbp, dbw, dx, dy, ReadVram(spsm, sbp, sbw, sx, sy)); - - pixel_count++; - } - } - break; - - default: - break; - } - - m_trxdir = 3; -} - -void GS::vertexKick(bool drawing) -{ - ++m_vtxCount; - ++m_vtxIndex; - - PS2_IF_AGRESSIVE_LOGS({ - const uint32_t debugIndex = s_debugGsVertexKickCount.fetch_add(1, std::memory_order_relaxed); - if (debugIndex < 96u) - { - RUNTIME_LOG("[gs:kick] idx=" << debugIndex - << " drawing=" << static_cast(drawing ? 1u : 0u) - << " prim=" << static_cast(m_prim.type) - << " vtxCount=" << m_vtxCount - << std::endl); - } - }); - - int needed = 0; - switch (m_prim.type) - { - case GS_PRIM_POINT: - needed = 1; - break; - case GS_PRIM_LINE: - needed = 2; - break; - case GS_PRIM_LINESTRIP: - needed = 2; - break; - case GS_PRIM_TRIANGLE: - needed = 3; - break; - case GS_PRIM_TRISTRIP: - needed = 3; - break; - case GS_PRIM_TRIFAN: - needed = 3; - break; - case GS_PRIM_SPRITE: - needed = 2; - break; - default: - return; - } - - if (m_vtxCount < needed) - return; - - if (drawing) - { - m_rasterizer.drawPrimitive(this); - recordDrawDebugEventUnlocked(needed); - } - - switch (m_prim.type) - { - case GS_PRIM_LINE: - case GS_PRIM_TRIANGLE: - case GS_PRIM_SPRITE: - case GS_PRIM_POINT: - m_vtxCount = 0; - break; - case GS_PRIM_LINESTRIP: - m_vtxQueue[0] = m_vtxQueue[1]; - m_vtxCount = 1; - break; - case GS_PRIM_TRISTRIP: - m_vtxQueue[0] = m_vtxQueue[1]; - m_vtxQueue[1] = m_vtxQueue[2]; - m_vtxCount = 2; - break; - case GS_PRIM_TRIFAN: - m_vtxQueue[1] = m_vtxQueue[2]; - m_vtxCount = 2; - break; - default: - m_vtxCount = 0; - break; - } -} - -void GS::processImageData(const uint8_t *data, uint32_t sizeBytes) -{ - // wrong direction set - if (m_trxdir != 0 || !m_vram) - { - return; - } - - // no height and width means transfer is invalid - if (m_trxreg.rrw == 0 || m_trxreg.rrh == 0) - { - return; - } - - u32 dbp = m_bitbltbuf.dbp; - u8 dbw = std::max(m_bitbltbuf.dbw, 1u); - u8 dpsm = m_bitbltbuf.dpsm; - - u32 rrw = m_trxreg.rrw; - u32 rrh = m_trxreg.rrh; - u32 dsax = m_trxpos.dsax; - u32 dsay = m_trxpos.dsay; - - u32 data_offset = 0; - - // remove the format branching from the loops - // TODO: fixup copypasta - switch (dpsm) - { - case GS_PSM_CT32: - while (data_offset < sizeBytes) - { - u32 c; - std::memcpy(&c, &data[data_offset], sizeof(u32)); - - GSMem::WriteCT32(m_vram, dbp, dbw, m_transferState.x, m_transferState.y, c); - - m_transferState.x++; - m_transferState.copied_pixels++; - data_offset += 4; - - if ((m_transferState.copied_pixels % rrw) == 0) - { - m_transferState.x = dsax; - m_transferState.y++; - } - - if (m_transferState.copied_pixels >= m_transferState.total_pixels) - { - // deactivate the transfer - m_trxdir = 3; - m_transferState.total_pixels = 0; - break; - } - } - break; - - case GS_PSM_Z32: - while (data_offset < sizeBytes) - { - u32 c; - std::memcpy(&c, &data[data_offset], sizeof(u32)); - - GSMem::WriteZ32(m_vram, dbp, dbw, m_transferState.x, m_transferState.y, c); - - m_transferState.x++; - m_transferState.copied_pixels++; - data_offset += 4; - - if ((m_transferState.copied_pixels % rrw) == 0) - { - m_transferState.x = dsax; - m_transferState.y++; - } - - if (m_transferState.copied_pixels >= m_transferState.total_pixels) - { - // deactivate the transfer - m_trxdir = 3; - m_transferState.total_pixels = 0; - break; - } - } - break; - - case GS_PSM_CT24: - while (data_offset < sizeBytes) - { - u32 c; - std::memcpy(&c, &data[data_offset], sizeof(u32)); - - GSMem::WriteCT24(m_vram, dbp, dbw, m_transferState.x, m_transferState.y, c); - - m_transferState.x++; - m_transferState.copied_pixels++; - data_offset += 3; - - if ((m_transferState.copied_pixels % rrw) == 0) - { - m_transferState.x = dsax; - m_transferState.y++; - } - - if (m_transferState.copied_pixels >= m_transferState.total_pixels) - { - // deactivate the transfer - m_trxdir = 3; - m_transferState.total_pixels = 0; - break; - } - } - break; - - case GS_PSM_Z24: - while (data_offset < sizeBytes) - { - u32 c; - std::memcpy(&c, &data[data_offset], sizeof(u32)); - - GSMem::WriteZ24(m_vram, dbp, dbw, m_transferState.x, m_transferState.y, c); - - m_transferState.x++; - m_transferState.copied_pixels++; - data_offset += 3; - - if ((m_transferState.copied_pixels % rrw) == 0) - { - m_transferState.x = dsax; - m_transferState.y++; - } - - if (m_transferState.copied_pixels >= m_transferState.total_pixels) - { - // deactivate the transfer - m_trxdir = 3; - m_transferState.total_pixels = 0; - break; - } - } - break; - - case GS_PSM_CT16: - while (data_offset < sizeBytes) - { - u16 c; - std::memcpy(&c, &data[data_offset], sizeof(u16)); - - GSMem::WriteCT16(m_vram, dbp, dbw, m_transferState.x, m_transferState.y, c); - - m_transferState.x++; - m_transferState.copied_pixels++; - data_offset += 2; - - if ((m_transferState.copied_pixels % rrw) == 0) - { - m_transferState.x = dsax; - m_transferState.y++; - } - - if (m_transferState.copied_pixels >= m_transferState.total_pixels) - { - // deactivate the transfer - m_trxdir = 3; - m_transferState.total_pixels = 0; - break; - } - } - break; - - case GS_PSM_Z16: - while (data_offset < sizeBytes) - { - u16 c; - std::memcpy(&c, &data[data_offset], sizeof(u16)); - - GSMem::WriteZ16(m_vram, dbp, dbw, m_transferState.x, m_transferState.y, c); - - m_transferState.x++; - m_transferState.copied_pixels++; - data_offset += 2; - - if ((m_transferState.copied_pixels % rrw) == 0) - { - m_transferState.x = dsax; - m_transferState.y++; - } - - if (m_transferState.copied_pixels >= m_transferState.total_pixels) - { - // deactivate the transfer - m_trxdir = 3; - m_transferState.total_pixels = 0; - break; - } - } - break; - - case GS_PSM_CT16S: - while (data_offset < sizeBytes) - { - u16 c; - std::memcpy(&c, &data[data_offset], sizeof(u16)); - - GSMem::WriteCT16S(m_vram, dbp, dbw, m_transferState.x, m_transferState.y, c); - - m_transferState.x++; - m_transferState.copied_pixels++; - data_offset += 2; - - if ((m_transferState.copied_pixels % rrw) == 0) - { - m_transferState.x = dsax; - m_transferState.y++; - } - - if (m_transferState.copied_pixels >= m_transferState.total_pixels) - { - // deactivate the transfer - m_trxdir = 3; - m_transferState.total_pixels = 0; - break; - } - } - break; - - case GS_PSM_Z16S: - while (data_offset < sizeBytes) - { - u16 c; - std::memcpy(&c, &data[data_offset], sizeof(u16)); - - GSMem::WriteZ16S(m_vram, dbp, dbw, m_transferState.x, m_transferState.y, c); - - m_transferState.x++; - m_transferState.copied_pixels++; - data_offset += 2; - - if ((m_transferState.copied_pixels % rrw) == 0) - { - m_transferState.x = dsax; - m_transferState.y++; - } - - if (m_transferState.copied_pixels >= m_transferState.total_pixels) - { - // deactivate the transfer - m_trxdir = 3; - m_transferState.total_pixels = 0; - break; - } - } - break; - - case GS_PSM_T8: - while (data_offset < sizeBytes) - { - u8 c = data[data_offset]; - - GSMem::WriteP8(m_vram, dbp, dbw, m_transferState.x, m_transferState.y, c); - - m_transferState.x++; - m_transferState.copied_pixels++; - data_offset += 1; - - if ((m_transferState.copied_pixels % rrw) == 0) - { - m_transferState.x = dsax; - m_transferState.y++; - } - - if (m_transferState.copied_pixels >= m_transferState.total_pixels) - { - // deactivate the transfer - m_trxdir = 3; - m_transferState.total_pixels = 0; - break; - } - } - break; - - case GS_PSM_T8H: - while (data_offset < sizeBytes) - { - u8 c = data[data_offset]; - - GSMem::WriteP8H(m_vram, dbp, dbw, m_transferState.x, m_transferState.y, c); - - m_transferState.x++; - m_transferState.copied_pixels++; - data_offset += 1; - - if ((m_transferState.copied_pixels % rrw) == 0) - { - m_transferState.x = dsax; - m_transferState.y++; - } - - if (m_transferState.copied_pixels >= m_transferState.total_pixels) - { - // deactivate the transfer - m_trxdir = 3; - m_transferState.total_pixels = 0; - break; - } - } - break; - case GS_PSM_T4: - while (data_offset < sizeBytes) - { - u8 c0 = data[data_offset] & 0xF; - u8 c1 = (data[data_offset] >> 4) & 0xF; - - GSMem::WriteP4(m_vram, dbp, dbw, m_transferState.x, m_transferState.y, c0); - GSMem::WriteP4(m_vram, dbp, dbw, m_transferState.x + 1, m_transferState.y, c1); - - m_transferState.x += 2; - m_transferState.copied_pixels += 2; - data_offset += 1; - - if ((m_transferState.copied_pixels % rrw) == 0) - { - m_transferState.x = dsax; - m_transferState.y++; - } - - if (m_transferState.copied_pixels >= m_transferState.total_pixels) - { - // deactivate the transfer - m_trxdir = 3; - m_transferState.total_pixels = 0; - break; - } - } - break; - case GS_PSM_T4HL: - while (data_offset < sizeBytes) - { - u8 c0 = data[data_offset] & 0xF; - u8 c1 = (data[data_offset] >> 4) & 0xF; - - GSMem::WriteP4HL(m_vram, dbp, dbw, m_transferState.x, m_transferState.y, c0); - GSMem::WriteP4HL(m_vram, dbp, dbw, m_transferState.x + 1, m_transferState.y, c1); - - m_transferState.x += 2; - m_transferState.copied_pixels += 2; - data_offset += 1; - - if ((m_transferState.copied_pixels % rrw) == 0) - { - m_transferState.x = dsax; - m_transferState.y++; - } - - if (m_transferState.copied_pixels >= m_transferState.total_pixels) - { - // deactivate the transfer - m_trxdir = 3; - m_transferState.total_pixels = 0; - break; - } - } - break; - case GS_PSM_T4HH: - while (data_offset < sizeBytes) - { - u8 c0 = data[data_offset] & 0xF; - u8 c1 = (data[data_offset] >> 4) & 0xF; - - GSMem::WriteP4HH(m_vram, dbp, dbw, m_transferState.x, m_transferState.y, c0); - GSMem::WriteP4HH(m_vram, dbp, dbw, m_transferState.x + 1, m_transferState.y, c1); - - m_transferState.x += 2; - m_transferState.copied_pixels += 2; - data_offset += 1; - - if ((m_transferState.copied_pixels % rrw) == 0) - { - m_transferState.x = dsax; - m_transferState.y++; - } - - if (m_transferState.copied_pixels >= m_transferState.total_pixels) - { - // deactivate the transfer - m_trxdir = 3; - m_transferState.total_pixels = 0; - break; - } - } - break; - } -} - -void GS::performLocalToHostToBuffer() -{ - m_localToHostBuffer.clear(); - m_localToHostReadPos = 0; - - if (!m_vram) - return; - - uint32_t sbp = m_bitbltbuf.sbp; - uint8_t sbw = std::max(m_bitbltbuf.sbw, 1u); - uint8_t spsm = m_bitbltbuf.spsm; - uint32_t rrw = m_trxreg.rrw; - uint32_t rrh = m_trxreg.rrh; - uint32_t ssax = m_trxpos.ssax; - uint32_t ssay = m_trxpos.ssay; - - u32 bpp = GSMem::BitsPerPixel(static_cast(spsm)); - - u32 pixel_total = rrw * rrh; - u32 bytes_total = (pixel_total * bpp) / 8; - - m_localToHostBuffer.reserve(bytes_total); - - u32 pixel_count = 0; - while (pixel_count < pixel_total) - { - const u32 x = pixel_count % rrw; - const u32 y = pixel_count / rrw; - - const u32 v = ReadVram(spsm, sbp, sbw, x + ssax, y + ssay); - - switch (bpp) - { - case 32: - m_localToHostBuffer.push_back(v & 0xFF); - m_localToHostBuffer.push_back((v >> 8) & 0xFF); - m_localToHostBuffer.push_back((v >> 16) & 0xFF); - m_localToHostBuffer.push_back((v >> 24) & 0xFF); - break; - case 24: - m_localToHostBuffer.push_back(v & 0xFF); - m_localToHostBuffer.push_back((v >> 8) & 0xFF); - m_localToHostBuffer.push_back((v >> 16) & 0xFF); - break; - case 16: - m_localToHostBuffer.push_back(v & 0xFF); - m_localToHostBuffer.push_back((v >> 8) & 0xFF); - break; - case 8: - m_localToHostBuffer.push_back(v); - break; - case 4: - { - const u32 v2 = ReadVram(spsm, sbp, sbw, x + ssax + 1, y + ssay); - - m_localToHostBuffer.push_back(v | ((v2 & 0xF) << 4)); - pixel_count++; - break; - } - default: - break; - } - - pixel_count++; - } -} - -bool GS::clearFramebufferContext(uint32_t contextIndex, uint32_t rgba) -{ - std::lock_guard lock(m_stateMutex); - return clearFramebufferRect(this, m_ctx[(contextIndex != 0u) ? 1 : 0], rgba); -} - -bool GS::clearActiveFramebuffer(uint32_t rgba) -{ - std::lock_guard lock(m_stateMutex); - return clearFramebufferRect(this, activeContext(), rgba); -} - -uint32_t GS::consumeLocalToHostBytes(uint8_t *dst, uint32_t maxBytes) -{ - std::lock_guard lock(m_stateMutex); - if (!dst || maxBytes == 0) - return 0; - size_t avail = m_localToHostBuffer.size() - m_localToHostReadPos; - if (avail == 0) - return 0; - size_t toCopy = (avail < maxBytes) ? avail : static_cast(maxBytes); - std::memcpy(dst, m_localToHostBuffer.data() + m_localToHostReadPos, toCopy); - m_localToHostReadPos += toCopy; - return static_cast(toCopy); -} diff --git a/ps2xRuntime/src/lib/ps2_gs_rasterizer.cpp b/ps2xRuntime/src/lib/ps2_gs_rasterizer.cpp deleted file mode 100644 index 96cff26da..000000000 --- a/ps2xRuntime/src/lib/ps2_gs_rasterizer.cpp +++ /dev/null @@ -1,1102 +0,0 @@ -#include "runtime/ps2_gs_rasterizer.h" -#include "runtime/ps2_gs_gpu.h" -#include "runtime/ps2_gs_common.h" -#include "runtime/ps2_gs_psmct16.h" -#include "runtime/ps2_gs_psmct32.h" -#include "runtime/ps2_gs_psmt4.h" -#include "runtime/ps2_gs_psmt8.h" -#include "runtime/ps2_gs_memory.h" -#include "ps2_log.h" -#include -#include -#include -#include -#include -#include -#include - -using namespace GSInternal; - -namespace -{ - float fabsQ(float q) - { - return (std::fabs(q) > 1.0e-8f) ? q : 1.0f; - } - - u16 Rgba8888ToRgba5551(u32 c) - { - uint32_t r = ((c >> 0) & 0xFF) >> 3; - uint32_t g = ((c >> 8) & 0xFF) >> 3; - uint32_t b = ((c >> 16) & 0xFF) >> 3; - uint32_t a = ((c >> 24) & 0xFF) >> 7; - - return (r | (g << 5) | (b << 10) | (a << 15)); - } - - u32 Rgba5551ToRgba8888(u16 c) - { - u32 r = ((c >> 0) & 0x1F) << 3; - u32 g = ((c >> 5) & 0x1F) << 3; - u32 b = ((c >> 10) & 0x1F) << 3; - u32 a = ((c >> 15) & 0x01) << 7; - - return (r | (g << 8) | (b << 16) | (a << 24)); - } - - u32 pack32(u8 r, u8 g, u8 b, u8 a) - { - return static_cast(r) | (g << 8) | (b << 16) | (a << 24); - } - - uint32_t applyTexa(const GSTexaReg &texa, uint8_t psm, uint32_t texel) - { - if (psm == GS_PSM_CT32) - return texel; - - const uint8_t r = static_cast(texel & 0xFFu); - const uint8_t g = static_cast((texel >> 8) & 0xFFu); - const uint8_t b = static_cast((texel >> 16) & 0xFFu); - const bool rgbZero = r == 0u && g == 0u && b == 0u; - uint8_t a = static_cast((texel >> 24) & 0xFFu); - - switch (psm) - { - case GS_PSM_CT24: - a = (texa.aem && rgbZero) ? 0u : texa.ta0; - break; - case GS_PSM_CT16: - case GS_PSM_CT16S: - if ((a & 0x80u) != 0u) - a = texa.ta1; - else - a = (texa.aem && rgbZero) ? 0u : texa.ta0; - break; - default: - break; - } - - return (texel & 0x00FFFFFFu) | (static_cast(a) << 24); - } - - uint32_t addrPSMCT16Family(uint32_t basePtr, uint32_t width, uint8_t psm, uint32_t x, uint32_t y) - { - switch (psm) - { - case GS_PSM_CT16: - return GSPSMCT16::addrPSMCT16(basePtr, width, x, y); - case GS_PSM_CT16S: - return GSPSMCT16::addrPSMCT16S(basePtr, width, x, y); - case GS_PSM_Z16: - return GSPSMCT16::addrPSMZ16(basePtr, width, x, y); - case GS_PSM_Z16S: - return GSPSMCT16::addrPSMZ16S(basePtr, width, x, y); - default: - return 0u; - } - } - - std::atomic s_debugPrimitiveCount{0}; - std::atomic s_debugPixelCount{0}; - std::atomic s_debugContext1PrimitiveCount{0}; - std::atomic s_debugFbp150PixelCount{0}; - - int wrapTextureCoordinate(int coordinate, - int textureSize, - uint8_t mode, - uint16_t regionMin, - uint16_t regionMax) - { - switch (mode & 0x3u) - { - case 0: // REPEAT - return static_cast(static_cast(coordinate) & static_cast(textureSize - 1)); - case 1: // CLAMP - return clampInt(coordinate, 0, textureSize - 1); - case 2: // REGION_CLAMP - return std::min(std::max(coordinate, static_cast(regionMin)), static_cast(regionMax)); - case 3: // REGION_REPEAT - return static_cast((static_cast(coordinate) & static_cast(regionMin)) | static_cast(regionMax)); - default: - return coordinate; - } - } - - bool passesAlphaTest(uint64_t testReg, uint8_t alpha) - { - if ((testReg & 0x1u) == 0u) - return true; - - const uint8_t atst = static_cast((testReg >> 1) & 0x7u); - const uint8_t aref = static_cast((testReg >> 4) & 0xFFu); - - switch (atst) - { - case 0: - return false; - case 1: - return true; - case 2: - return alpha < aref; - case 3: - return alpha <= aref; - case 4: - return alpha == aref; - case 5: - return alpha >= aref; - case 6: - return alpha > aref; - case 7: - return alpha != aref; - default: - return true; - } - } - - struct PixelWriteMask - { - bool writeRgb = true; - bool writeAlpha = true; - bool writeDepth = true; - - bool writesFramebuffer() const - { - return writeRgb || writeAlpha; - } - - bool writesAnything() const - { - return writesFramebuffer() || writeDepth; - } - }; - - PixelWriteMask classifyAlphaTest(uint64_t testReg, uint8_t alpha, uint8_t framePsm) - { - const bool pass = passesAlphaTest(testReg, alpha); - if (pass) - return {}; - - // TEST.AFAIL controls what happens when the alpha comparison fails. - switch (static_cast((testReg >> 12) & 0x3u)) - { - case 1: // FB_ONLY - return {true, true, false}; - case 2: // ZB_ONLY - return {false, false, true}; - case 3: // RGB_ONLY - // RGB_ONLY is only distinct for RGBA32. The GS treats it as - // FB_ONLY for RGB24 and RGBA16 framebuffers. - if (framePsm == GS_PSM_CT32) - return {true, false, false}; - return {true, true, false}; - case 0: // KEEP - default: - return {false, false, false}; - } - } - - bool passesDestinationAlphaTest(uint64_t testReg, uint8_t framePsm, uint32_t rawFramebufferPixel) - { - const bool date = ((testReg >> 14) & 0x1u) != 0u; - if (!date) - return true; - - const bool datm = ((testReg >> 15) & 0x1u) != 0u; - switch (framePsm) - { - case GS_PSM_CT32: - return (((rawFramebufferPixel >> 31) & 0x1u) != 0u) == datm; - case GS_PSM_CT16: - case GS_PSM_CT16S: - return (((rawFramebufferPixel >> 15) & 0x1u) != 0u) == datm; - case GS_PSM_CT24: - // RGB24 has no destination alpha, so DATE always passes. - return true; - default: - return true; - } - } - - struct TextureCombineResult - { - uint8_t r; - uint8_t g; - uint8_t b; - uint8_t a; - }; - - TextureCombineResult combineTexture(const GSTex0Reg &tex, - uint8_t vr, - uint8_t vg, - uint8_t vb, - uint8_t va, - uint8_t tr, - uint8_t tg, - uint8_t tb, - uint8_t ta) - { - const bool textureHasAlpha = tex.tcc != 0u; - TextureCombineResult out{tr, tg, tb, textureHasAlpha ? ta : va}; - - switch (tex.tfx) - { - case 0: // MODULATE - out.r = clampU8((tr * vr) >> 7); - out.g = clampU8((tg * vg) >> 7); - out.b = clampU8((tb * vb) >> 7); - out.a = textureHasAlpha ? clampU8((ta * va) >> 7) : va; - break; - case 1: // DECAL - out.r = tr; - out.g = tg; - out.b = tb; - out.a = textureHasAlpha ? ta : va; - break; - case 2: // HIGHLIGHT - out.r = clampU8(((tr * vr) >> 7) + va); - out.g = clampU8(((tg * vg) >> 7) + va); - out.b = clampU8(((tb * vb) >> 7) + va); - out.a = textureHasAlpha ? clampU8(ta + va) : va; - break; - case 3: // HIGHLIGHT2 - out.r = clampU8(((tr * vr) >> 7) + va); - out.g = clampU8(((tg * vg) >> 7) + va); - out.b = clampU8(((tb * vb) >> 7) + va); - out.a = textureHasAlpha ? ta : va; - break; - default: - out.r = tr; - out.g = tg; - out.b = tb; - out.a = textureHasAlpha ? ta : va; - break; - } - - return out; - } - - uint32_t swizzleClutIndexCSM1(uint32_t index) - { - // CSM1 swaps address bits 3 and 4. Preserve the remaining bits: - // 16-bit CLUTs expose a ninth address bit through CSA[4]. - return (index & ~0x18u) | ((index & 0x08u) << 1u) | ((index & 0x10u) >> 1u); - } - - // TODO: clut cache - uint32_t resolveClutIndex(uint8_t index, uint8_t cpsm, uint8_t csm, uint8_t csa, uint8_t sourcePsm) - { - uint32_t clutIndex = static_cast(index); - - // CSM2 addresses the source directly through TEXCLUT. CSA is required - // to be zero there, so it must not offset the source coordinates. - if (csm != 0u) - return (sourcePsm == GS_PSM_T4 || - sourcePsm == GS_PSM_T4HH || - sourcePsm == GS_PSM_T4HL) - ? (clutIndex & 0x0Fu) - : clutIndex; - - const bool is16BitClut = cpsm == GS_PSM_CT16 || cpsm == GS_PSM_CT16S; - const uint32_t csaMask = is16BitClut ? 0x1Fu : 0x0Fu; - const uint32_t clutIndexMask = is16BitClut ? 0x1FFu : 0x0FFu; - const uint32_t clutBase = (static_cast(csa) & csaMask) << 4u; - - switch (sourcePsm) - { - case GS_PSM_T4: - case GS_PSM_T4HH: - case GS_PSM_T4HL: - clutIndex = clutBase + (clutIndex & 0x0Fu); - break; - case GS_PSM_T8: - case GS_PSM_T8H: - clutIndex = clutBase + clutIndex; - break; - default: - return clutIndex; - } - - return swizzleClutIndexCSM1(clutIndex & clutIndexMask); - } - - int textureDimension(uint8_t exponent) - { - // TEX0.TW/TH saturate at 1024 pixels on the GS. - return 1 << std::min(exponent, 10u); - } - - bool tex1UsesLinearFilter(uint64_t tex1) - { - const uint8_t mmag = static_cast((tex1 >> 5) & 0x1u); - const uint8_t mmin = static_cast((tex1 >> 6) & 0x7u); - return mmag != 0u || mmin == 1u || (mmin & 0x4u) != 0u; - } - - uint8_t lerpChannel(uint8_t c00, uint8_t c10, uint8_t c01, uint8_t c11, float fx, float fy) - { - const float top = static_cast(c00) + (static_cast(c10) - static_cast(c00)) * fx; - const float bottom = static_cast(c01) + (static_cast(c11) - static_cast(c01)) * fx; - return clampU8(static_cast(std::lround(top + (bottom - top) * fy))); - } -} - -void GSRasterizer::drawPrimitive(GS *gs) -{ - const auto &ctx = gs->activeContext(); - PS2_IF_AGRESSIVE_LOGS({ - const uint32_t primitiveIndex = s_debugPrimitiveCount.fetch_add(1u, std::memory_order_relaxed); - if (primitiveIndex < 64u) - { - std::cout << "[gs:prim] idx=" << primitiveIndex - << " type=" << static_cast(gs->m_prim.type) - << " tme=" << static_cast(gs->m_prim.tme) - << " abe=" << static_cast(gs->m_prim.abe) - << " fst=" << static_cast(gs->m_prim.fst) - << " ctxt=" << static_cast(gs->m_prim.ctxt) - << " fbp=" << ctx.frame.fbp - << " fbw=" << ctx.frame.fbw - << " psm=0x" << std::hex << static_cast(ctx.frame.psm) << std::dec - << " tex0=(" - << "tbp0=" << ctx.tex0.tbp0 - << " tbw=" << static_cast(ctx.tex0.tbw) - << " psm=0x" << std::hex << static_cast(ctx.tex0.psm) << std::dec - << " tw=" << static_cast(ctx.tex0.tw) - << " th=" << static_cast(ctx.tex0.th) - << " tcc=" << static_cast(ctx.tex0.tcc) - << " tfx=" << static_cast(ctx.tex0.tfx) - << " cbp=" << ctx.tex0.cbp - << " cpsm=0x" << std::hex << static_cast(ctx.tex0.cpsm) << std::dec - << " csm=" << static_cast(ctx.tex0.csm) - << " csa=" << static_cast(ctx.tex0.csa) - << ")" - << " texclut=(" - << "cbw=" << static_cast(gs->m_texclut.cbw) - << " cou=" << static_cast(gs->m_texclut.cou) - << " cov=" << gs->m_texclut.cov - << ")" - << " ofx=" << (ctx.xyoffset.ofx >> 4) - << " ofy=" << (ctx.xyoffset.ofy >> 4) - << " scissor=(" << ctx.scissor.x0 - << "," << ctx.scissor.y0 - << ")-(" << ctx.scissor.x1 - << "," << ctx.scissor.y1 << ")" - << " test=0x" << std::hex << ctx.test - << " alpha=0x" << ctx.alpha - << std::dec - << " v0=(" << gs->m_vtxQueue[0].x << "," << gs->m_vtxQueue[0].y << ")" - << " uv0=(" << (gs->m_vtxQueue[0].u >> 4) << "," << (gs->m_vtxQueue[0].v >> 4) << ")" - << " stq0=(" << gs->m_vtxQueue[0].s << "," << gs->m_vtxQueue[0].t << "," << gs->m_vtxQueue[0].q << ")" - << " v1=(" << gs->m_vtxQueue[1].x << "," << gs->m_vtxQueue[1].y << ")" - << " uv1=(" << (gs->m_vtxQueue[1].u >> 4) << "," << (gs->m_vtxQueue[1].v >> 4) << ")" - << " stq1=(" << gs->m_vtxQueue[1].s << "," << gs->m_vtxQueue[1].t << "," << gs->m_vtxQueue[1].q << ")" - << " v2=(" << gs->m_vtxQueue[2].x << "," << gs->m_vtxQueue[2].y << ")" - << " uv2=(" << (gs->m_vtxQueue[2].u >> 4) << "," << (gs->m_vtxQueue[2].v >> 4) << ")" - << " stq2=(" << gs->m_vtxQueue[2].s << "," << gs->m_vtxQueue[2].t << "," << gs->m_vtxQueue[2].q << ")" - << " rgba0=(" << static_cast(gs->m_vtxQueue[0].r) << "," - << static_cast(gs->m_vtxQueue[0].g) << "," - << static_cast(gs->m_vtxQueue[0].b) << "," - << static_cast(gs->m_vtxQueue[0].a) << ")" - << " rgba1=(" << static_cast(gs->m_vtxQueue[1].r) << "," - << static_cast(gs->m_vtxQueue[1].g) << "," - << static_cast(gs->m_vtxQueue[1].b) << "," - << static_cast(gs->m_vtxQueue[1].a) << ")" - << " rgba2=(" << static_cast(gs->m_vtxQueue[2].r) << "," - << static_cast(gs->m_vtxQueue[2].g) << "," - << static_cast(gs->m_vtxQueue[2].b) << "," - << static_cast(gs->m_vtxQueue[2].a) << ")" - << std::endl; - } - }); - - PS2_IF_AGRESSIVE_LOGS({ - if ((gs->m_prim.ctxt != 0u || ctx.frame.fbp == 150u) && - s_debugContext1PrimitiveCount.fetch_add(1u, std::memory_order_relaxed) < 32u) - { - std::cout << "[gs:copy-prim]" - << " type=" << static_cast(gs->m_prim.type) - << " tme=" << static_cast(gs->m_prim.tme) - << " abe=" << static_cast(gs->m_prim.abe) - << " fst=" << static_cast(gs->m_prim.fst) - << " ctxt=" << static_cast(gs->m_prim.ctxt) - << " fbp=" << ctx.frame.fbp - << " fbw=" << ctx.frame.fbw - << " psm=0x" << std::hex << static_cast(ctx.frame.psm) << std::dec - << " tex0=(" - << "tbp0=" << ctx.tex0.tbp0 - << " tbw=" << static_cast(ctx.tex0.tbw) - << " psm=0x" << std::hex << static_cast(ctx.tex0.psm) << std::dec - << " tcc=" << static_cast(ctx.tex0.tcc) - << " tfx=" << static_cast(ctx.tex0.tfx) - << " cbp=" << ctx.tex0.cbp - << " cpsm=0x" << std::hex << static_cast(ctx.tex0.cpsm) << std::dec - << " csm=" << static_cast(ctx.tex0.csm) - << " csa=" << static_cast(ctx.tex0.csa) - << ")" - << " texclut=(" - << "cbw=" << static_cast(gs->m_texclut.cbw) - << " cou=" << static_cast(gs->m_texclut.cou) - << " cov=" << gs->m_texclut.cov - << ")" - << " ofx=" << (ctx.xyoffset.ofx >> 4) - << " ofy=" << (ctx.xyoffset.ofy >> 4) - << " scissor=(" << ctx.scissor.x0 - << "," << ctx.scissor.y0 - << ")-(" << ctx.scissor.x1 - << "," << ctx.scissor.y1 << ")" - << " test=0x" << std::hex << ctx.test - << " alpha=0x" << ctx.alpha - << std::dec << std::endl; - } - }); - - if (gs->m_hasPreferredDisplaySource && ctx.frame.fbp == gs->m_preferredDisplayDestFbp) - { - gs->m_hasPreferredDisplaySource = false; - } - - switch (gs->m_prim.type) - { - case GS_PRIM_SPRITE: - drawSprite(gs); - break; - case GS_PRIM_TRIANGLE: - case GS_PRIM_TRISTRIP: - case GS_PRIM_TRIFAN: - drawTriangle(gs); - break; - case GS_PRIM_LINE: - case GS_PRIM_LINESTRIP: - drawLine(gs); - break; - case GS_PRIM_POINT: - { - const GSVertex &v = gs->m_vtxQueue[0]; - const auto &ctx = gs->activeContext(); - int px = static_cast(v.x) - (ctx.xyoffset.ofx >> 4); - int py = static_cast(v.y) - (ctx.xyoffset.ofy >> 4); - writePixel(gs, px, py, static_cast(v.z), v.r, v.g, v.b, v.a, v.fog); - break; - } - default: - break; - } -} - -void GSRasterizer::writePixel(GS *gs, int x, int y, int z, uint8_t r, uint8_t g, uint8_t b, uint8_t a, uint8_t fog) -{ - const auto &ctx = gs->activeContext(); - if (x < ctx.scissor.x0 || x > ctx.scissor.x1 || y < ctx.scissor.y0 || y > ctx.scissor.y1) - return; - - if (gs->m_prim.fge) - { - const uint32_t inverseFog = 255u - fog; - auto applyFog = [&](uint8_t input, uint8_t fogColor) -> uint8_t - { - return static_cast(((static_cast(fog) * input) >> 8) + ((inverseFog * fogColor) >> 8)); - }; - - r = applyFog(r, gs->m_fogR); - g = applyFog(g, gs->m_fogG); - b = applyFog(b, gs->m_fogB); - } - - const u32 fbp = GSInternal::framePageBaseToBlock(ctx.frame.fbp); - const u32 fbw = std::max(ctx.frame.fbw, 1u); - const u32 fpsm = ctx.frame.psm; - const u32 zbp = GSInternal::framePageBaseToBlock(ctx.zbuf.zbp); - const u32 zpsm = ctx.zbuf.psm; - - const PixelWriteMask writeMask = classifyAlphaTest(ctx.test, a, static_cast(fpsm)); - if (!writeMask.writesAnything()) - { - return; - } - - const uint32_t ztestMethod = static_cast((ctx.test >> 17) & 3u); - const bool alphaBlendEnabled = gs->m_prim.abe; - const bool preserveDestinationAlpha = writeMask.writeRgb && !writeMask.writeAlpha && fpsm == GS_PSM_CT32; - const bool destinationAlphaTestNeedsRead = ((ctx.test >> 14) & 0x1u) != 0u && (fpsm == GS_PSM_CT32 || fpsm == GS_PSM_CT16 || fpsm == GS_PSM_CT16S); - - // small optimization, avoid reading the framebuffer for simple draws - // TODO: only one address lookup for rmw - const bool frmw = destinationAlphaTestNeedsRead || (writeMask.writesFramebuffer() && ((ctx.frame.fbmsk != 0) || alphaBlendEnabled || preserveDestinationAlpha)); - - u32 rawFramebufferPixel = 0; - u32 fbrgba = 0; - if (frmw) - { - rawFramebufferPixel = gs->ReadVram(fpsm, fbp, fbw, x, y); - fbrgba = rawFramebufferPixel; - - if (bitsPerPixel(fpsm) == 16) - { - fbrgba = Rgba5551ToRgba8888(fbrgba); - } - else if (fpsm == GS_PSM_CT24) - { - // The GS supplies 0x80 as destination alpha for RGB24 blending. - fbrgba |= 0x80000000u; - } - } - - if (!passesDestinationAlphaTest(ctx.test, static_cast(fpsm), rawFramebufferPixel)) - { - return; - } - - bool zpass = false; - uint32_t storedZ = 0u; - switch (ztestMethod) - { - case 0: - zpass = false; - break; - case 1: - zpass = true; - break; - case 2: - storedZ = gs->ReadVram(zpsm, zbp, fbw, x, y); - zpass = static_cast(z) >= storedZ; - break; - case 3: - storedZ = gs->ReadVram(zpsm, zbp, fbw, x, y); - zpass = static_cast(z) > storedZ; - break; - } - - if (!zpass) - { - return; - } - - if (writeMask.writesFramebuffer()) - { - const u8 srcR = r; - const u8 srcG = g; - const u8 srcB = b; - - if (gs->m_prim.abe) - { - uint8_t dr = fbrgba & 0xFF; - uint8_t dg = (fbrgba >> 8) & 0xFF; - uint8_t db = (fbrgba >> 16) & 0xFF; - uint8_t da = (fbrgba >> 24) & 0xFF; - - // PABE disables alpha blending when the source alpha MSB is clear. - if (!(gs->m_pabe && (a & 0x80u) == 0u)) - { - uint64_t alphaReg = ctx.alpha; - uint8_t asel = alphaReg & 3; - uint8_t bsel = (alphaReg >> 2) & 3; - uint8_t csel = (alphaReg >> 4) & 3; - uint8_t dsel = (alphaReg >> 6) & 3; - uint8_t fix = static_cast((alphaReg >> 32) & 0xFF); - - auto pickRGB = [&](uint8_t sel, int cs, int cd) -> int - { - if (sel == 0) - return cs; - if (sel == 1) - return cd; - return 0; - }; - int cAlpha = (csel == 0) ? a : (csel == 1) ? da - : fix; - - r = clampU8(((pickRGB(asel, r, dr) - pickRGB(bsel, r, dr)) * cAlpha >> 7) + pickRGB(dsel, r, dr)); - g = clampU8(((pickRGB(asel, g, dg) - pickRGB(bsel, g, dg)) * cAlpha >> 7) + pickRGB(dsel, g, dg)); - b = clampU8(((pickRGB(asel, b, db) - pickRGB(bsel, b, db)) * cAlpha >> 7) + pickRGB(dsel, b, db)); - } - else - { - r = srcR; - g = srcG; - b = srcB; - } - } - - if (writeMask.writeAlpha && (ctx.fba & 0x1ull) != 0ull && ctx.frame.psm != GS_PSM_CT24) - { - a = static_cast(a | 0x80u); - } - - u32 pixel = pack32(r, g, b, a); - - if (ctx.frame.fbmsk != 0) - { - pixel = (pixel & ~ctx.frame.fbmsk) | (fbrgba & ctx.frame.fbmsk); - } - - if (preserveDestinationAlpha) - { - pixel = (pixel & 0x00FFFFFFu) | (fbrgba & 0xFF000000u); - } - - // format conversion - if (bitsPerPixel(fpsm) == 16) - { - pixel = Rgba8888ToRgba5551(pixel); - } - - gs->WriteVram(fpsm, fbp, fbw, x, y, pixel); - } - - if (writeMask.writeDepth && !ctx.zbuf.zmask) - { - gs->WriteVram(zpsm, zbp, fbw, x, y, z); - } -} - -uint32_t GSRasterizer::lookupCLUT(GS *gs, - uint8_t index, - uint32_t cbp, - uint8_t cpsm, - uint8_t csm, - uint8_t csa, - uint8_t sourcePsm) -{ - const uint32_t clutIndex = resolveClutIndex(index, cpsm, csm, csa, sourcePsm); - const uint32_t clutWidth = (gs->m_texclut.cbw != 0u) ? static_cast(gs->m_texclut.cbw) : 1u; - const uint32_t clutX = static_cast(gs->m_texclut.cou) + (clutIndex & 0x0Fu); - const uint32_t clutY = static_cast(gs->m_texclut.cov) + (clutIndex >> 4); - - switch (cpsm) - { - case GS_PSM_CT32: - return applyTexa(gs->m_texa, cpsm, GSMem::ReadCT32(gs->m_vram, cbp, clutWidth, clutX, clutY)); - case GS_PSM_CT24: - return applyTexa(gs->m_texa, cpsm, GSMem::ReadCT24(gs->m_vram, cbp, clutWidth, clutX, clutY)); - case GS_PSM_CT16: - return applyTexa(gs->m_texa, cpsm, Rgba5551ToRgba8888(GSMem::ReadCT16(gs->m_vram, cbp, clutWidth, clutX, clutY))); - case GS_PSM_CT16S: - return applyTexa(gs->m_texa, cpsm, Rgba5551ToRgba8888(GSMem::ReadCT16S(gs->m_vram, cbp, clutWidth, clutX, clutY))); - default: - break; - } - - return 0xFFFF00FFu; -} - -uint32_t GSRasterizer::sampleTexture(GS *gs, float s, float t, float q, uint16_t u, uint16_t v) -{ - const auto &ctx = gs->activeContext(); - const auto &tex = ctx.tex0; - - const int texW = textureDimension(tex.tw); - const int texH = textureDimension(tex.th); - const uint64_t clamp = ctx.clamp; - const uint8_t wrapU = static_cast(clamp & 0x3u); - const uint8_t wrapV = static_cast((clamp >> 2) & 0x3u); - const uint16_t minU = static_cast((clamp >> 4) & 0x3FFu); - const uint16_t maxU = static_cast((clamp >> 14) & 0x3FFu); - const uint16_t minV = static_cast((clamp >> 24) & 0x3FFu); - const uint16_t maxV = static_cast((clamp >> 34) & 0x3FFu); - - float texUf, texVf; - if (gs->m_prim.fst) - { - texUf = static_cast(u) / 16.0f; - texVf = static_cast(v) / 16.0f; - } - else - { - const float invQ = 1.0f / fabsQ(q); - texUf = s * invQ * static_cast(texW); - texVf = t * invQ * static_cast(texH); - } - - auto samplePoint = [&](int sampleU, int sampleV) -> uint32_t - { - sampleU = wrapTextureCoordinate(sampleU, texW, wrapU, minU, maxU); - sampleV = wrapTextureCoordinate(sampleV, texH, wrapV, minV, maxV); - - u32 out = gs->ReadVram(tex.psm, tex.tbp0, tex.tbw, sampleU, sampleV); - - switch (tex.psm) - { - case GS_PSM_CT32: - case GS_PSM_Z32: - case GS_PSM_CT24: - case GS_PSM_Z24: - return applyTexa(gs->m_texa, tex.psm, out); - case GS_PSM_CT16: - case GS_PSM_CT16S: - case GS_PSM_Z16: - case GS_PSM_Z16S: - return applyTexa(gs->m_texa, tex.psm, Rgba5551ToRgba8888(out)); - case GS_PSM_T8: - case GS_PSM_T8H: - case GS_PSM_T4: - case GS_PSM_T4HL: - case GS_PSM_T4HH: - return lookupCLUT(gs, static_cast(out), tex.cbp, tex.cpsm, tex.csm, tex.csa, tex.psm); - } - - return 0xFFFF00FFu; - }; - - if (!tex1UsesLinearFilter(ctx.tex1)) - { - return samplePoint(static_cast(texUf), static_cast(texVf)); - } - - const float sampleU = texUf - 0.5f; - const float sampleV = texVf - 0.5f; - const int u0 = static_cast(std::floor(sampleU)); - const int v0 = static_cast(std::floor(sampleV)); - const int u1 = u0 + 1; - const int v1 = v0 + 1; - const float fx = sampleU - static_cast(u0); - const float fy = sampleV - static_cast(v0); - - const uint32_t c00 = samplePoint(u0, v0); - const uint32_t c10 = samplePoint(u1, v0); - const uint32_t c01 = samplePoint(u0, v1); - const uint32_t c11 = samplePoint(u1, v1); - - const uint8_t r = lerpChannel(static_cast(c00 & 0xFFu), - static_cast(c10 & 0xFFu), - static_cast(c01 & 0xFFu), - static_cast(c11 & 0xFFu), - fx, fy); - const uint8_t g = lerpChannel(static_cast((c00 >> 8) & 0xFFu), - static_cast((c10 >> 8) & 0xFFu), - static_cast((c01 >> 8) & 0xFFu), - static_cast((c11 >> 8) & 0xFFu), - fx, fy); - const uint8_t b = lerpChannel(static_cast((c00 >> 16) & 0xFFu), - static_cast((c10 >> 16) & 0xFFu), - static_cast((c01 >> 16) & 0xFFu), - static_cast((c11 >> 16) & 0xFFu), - fx, fy); - const uint8_t a = lerpChannel(static_cast((c00 >> 24) & 0xFFu), - static_cast((c10 >> 24) & 0xFFu), - static_cast((c01 >> 24) & 0xFFu), - static_cast((c11 >> 24) & 0xFFu), - fx, fy); - - return static_cast(r) | - (static_cast(g) << 8) | - (static_cast(b) << 16) | - (static_cast(a) << 24); -} - -void GSRasterizer::drawSprite(GS *gs) -{ - const GSVertex &v0 = gs->m_vtxQueue[0]; - const GSVertex &v1 = gs->m_vtxQueue[1]; - const auto &ctx = gs->activeContext(); - - int ofx = ctx.xyoffset.ofx >> 4; - int ofy = ctx.xyoffset.ofy >> 4; - - int x0 = static_cast(v0.x) - ofx; - int y0 = static_cast(v0.y) - ofy; - int x1 = static_cast(v1.x) - ofx; - int y1 = static_cast(v1.y) - ofy; - u32 z1 = static_cast(v1.z); - - if (x0 > x1) - std::swap(x0, x1); - if (y0 > y1) - std::swap(y0, y1); - - const int unclippedX0 = x0; - const int unclippedY0 = y0; - const int spanX = std::max(1, x1 - x0); - const int spanY = std::max(1, y1 - y0); - const int unclippedX1 = unclippedX0 + spanX - 1; - const int unclippedY1 = unclippedY0 + spanY - 1; - - // If the sprite rectangle is fully outside scissor, nothing should render. - if (unclippedX1 < ctx.scissor.x0 || unclippedX0 > ctx.scissor.x1 || - unclippedY1 < ctx.scissor.y0 || unclippedY0 > ctx.scissor.y1) - { - // maybe a log here idk ? - return; - } - - const int drawX0 = clampInt(unclippedX0, ctx.scissor.x0, ctx.scissor.x1); - const int drawY0 = clampInt(unclippedY0, ctx.scissor.y0, ctx.scissor.y1); - const int drawX1 = clampInt(unclippedX1, ctx.scissor.x0, ctx.scissor.x1); - const int drawY1 = clampInt(unclippedY1, ctx.scissor.y0, ctx.scissor.y1); - - const uint64_t alphaReg = ctx.alpha; - const uint8_t alphaMode = static_cast(alphaReg & 0xFFu); - const uint8_t alphaFix = static_cast((alphaReg >> 32) & 0xFFu); - const bool looksLikeDisplayCopy = - gs->m_prim.tme && - gs->m_prim.abe && - gs->m_prim.fst && - gs->m_prim.ctxt && - ctx.frame.fbp != ctx.tex0.tbp0 && - alphaMode == 0x64u && - (alphaFix == 0x60u || alphaFix == 0x80u) && - unclippedX0 <= 0 && - unclippedY0 <= 0 && - unclippedX1 >= 639 && - unclippedY1 >= 447; - if (looksLikeDisplayCopy) - { - gs->m_preferredDisplaySourceFrame = {ctx.tex0.tbp0, ctx.tex0.tbw, ctx.tex0.psm, 0u}; - gs->m_preferredDisplayDestFbp = ctx.frame.fbp; - gs->m_hasPreferredDisplaySource = true; - } - - uint8_t r = v1.r, g = v1.g, b = v1.b, a = v1.a; - - if (gs->m_prim.tme) - { - const auto &tex = ctx.tex0; - const int texW = textureDimension(tex.tw); - const int texH = textureDimension(tex.th); - - float u0f, v0f, u1f, v1f; - if (gs->m_prim.fst) - { - u0f = static_cast(v0.u >> 4); - v0f = static_cast(v0.v >> 4); - u1f = static_cast(v1.u >> 4); - v1f = static_cast(v1.v >> 4); - } - else - { - const float q0 = fabsQ(v0.q); - const float q1 = fabsQ(v1.q); - u0f = (v0.s / q0) * static_cast(texW); - v0f = (v0.t / q0) * static_cast(texH); - u1f = (v1.s / q1) * static_cast(texW); - v1f = (v1.t / q1) * static_cast(texH); - } - - float spriteW = static_cast(spanX); - float spriteH = static_cast(spanY); - if (spriteW < 1.0f) - spriteW = 1.0f; - if (spriteH < 1.0f) - spriteH = 1.0f; - - for (int y = drawY0; y <= drawY1; ++y) - { - float ty = (static_cast(y - unclippedY0) + 0.5f) / spriteH; - float texVf = v0f + (v1f - v0f) * ty; - - for (int x = drawX0; x <= drawX1; ++x) - { - float tx = (static_cast(x - unclippedX0) + 0.5f) / spriteW; - float texUf = u0f + (u1f - u0f) * tx; - uint32_t texel = 0xFFFF00FFu; - if (gs->m_prim.fst) - { - const int fixedU = static_cast((texUf * 16.0f) + 0.5f); - const int fixedV = static_cast((texVf * 16.0f) + 0.5f); - const uint16_t sampleU = static_cast(clampInt(fixedU, 0, 0xFFFF)); - const uint16_t sampleV = static_cast(clampInt(fixedV, 0, 0xFFFF)); - texel = sampleTexture(gs, 0.0f, 0.0f, 1.0f, sampleU, sampleV); - } - else - { - texel = sampleTexture(gs, texUf / static_cast(texW), texVf / static_cast(texH), 1.0f, 0u, 0u); - } - - uint8_t tr = static_cast(texel & 0xFF); - uint8_t tg = static_cast((texel >> 8) & 0xFF); - uint8_t tb = static_cast((texel >> 16) & 0xFF); - uint8_t ta = static_cast((texel >> 24) & 0xFF); - - const TextureCombineResult color = combineTexture(tex, r, g, b, a, tr, tg, tb, ta); - writePixel(gs, x, y, z1, color.r, color.g, color.b, color.a, v1.fog); - } - } - } - else - { - for (int y = drawY0; y <= drawY1; ++y) - for (int x = drawX0; x <= drawX1; ++x) - writePixel(gs, x, y, z1, r, g, b, a, v1.fog); - } -} - -void GSRasterizer::drawTriangle(GS *gs) -{ - const GSVertex &v0 = gs->m_vtxQueue[0]; - const GSVertex &v1 = gs->m_vtxQueue[1]; - const GSVertex &v2 = gs->m_vtxQueue[2]; - const auto &ctx = gs->activeContext(); - - int ofx = ctx.xyoffset.ofx >> 4; - int ofy = ctx.xyoffset.ofy >> 4; - - float fx0 = v0.x - static_cast(ofx); - float fy0 = v0.y - static_cast(ofy); - float fx1 = v1.x - static_cast(ofx); - float fy1 = v1.y - static_cast(ofy); - float fx2 = v2.x - static_cast(ofx); - float fy2 = v2.y - static_cast(ofy); - - int minX = static_cast(std::floor(std::min({fx0, fx1, fx2}))); - int maxX = static_cast(std::ceil(std::max({fx0, fx1, fx2}))); - int minY = static_cast(std::floor(std::min({fy0, fy1, fy2}))); - int maxY = static_cast(std::ceil(std::max({fy0, fy1, fy2}))); - - minX = clampInt(minX, ctx.scissor.x0, ctx.scissor.x1); - maxX = clampInt(maxX, ctx.scissor.x0, ctx.scissor.x1); - minY = clampInt(minY, ctx.scissor.y0, ctx.scissor.y1); - maxY = clampInt(maxY, ctx.scissor.y0, ctx.scissor.y1); - - float denom = (fy1 - fy2) * (fx0 - fx2) + (fx2 - fx1) * (fy0 - fy2); - if (std::fabs(denom) < 0.001f) - return; - - const float winding = (denom < 0.0f) ? -1.0f : 1.0f; - const float invAbsDenom = 1.0f / std::fabs(denom); - constexpr float kEdgeEpsilon = 1.0e-4f; - - for (int y = minY; y <= maxY; ++y) - { - float py = static_cast(y) + 0.5f; - for (int x = minX; x <= maxX; ++x) - { - float px = static_cast(x) + 0.5f; - - float w0 = (((fy1 - fy2) * (px - fx2) + (fx2 - fx1) * (py - fy2)) * winding) * invAbsDenom; - float w1 = (((fy2 - fy0) * (px - fx2) + (fx0 - fx2) * (py - fy2)) * winding) * invAbsDenom; - float w2 = 1.0f - w0 - w1; - - if (w0 < -kEdgeEpsilon || w1 < -kEdgeEpsilon || w2 < -kEdgeEpsilon) - continue; - - double z = v0.z * w0 + v1.z * w1 + v2.z * w2; - - uint8_t r, g, b, a; - if (gs->m_prim.iip) - { - r = clampU8(static_cast(v0.r * w0 + v1.r * w1 + v2.r * w2)); - g = clampU8(static_cast(v0.g * w0 + v1.g * w1 + v2.g * w2)); - b = clampU8(static_cast(v0.b * w0 + v1.b * w1 + v2.b * w2)); - a = clampU8(static_cast(v0.a * w0 + v1.a * w1 + v2.a * w2)); - } - else - { - r = v2.r; - g = v2.g; - b = v2.b; - a = v2.a; - } - - if (gs->m_prim.tme) - { - float is, it, iq; - uint16_t iu, iv; - if (gs->m_prim.fst) - { - iu = static_cast(v0.u * w0 + v1.u * w1 + v2.u * w2); - iv = static_cast(v0.v * w0 + v1.v * w1 + v2.v * w2); - is = 0.0f; - it = 0.0f; - iq = 1.0f; - } - else - { - // The GS DDA interpolates the homogeneous S, T and Q - // values. Texel coordinates are calculated from S/Q and - // T/Q only after interpolation. - is = v0.s * w0 + v1.s * w1 + v2.s * w2; - it = v0.t * w0 + v1.t * w1 + v2.t * w2; - iq = v0.q * w0 + v1.q * w1 + v2.q * w2; - iu = 0; - iv = 0; - } - - uint32_t texel = sampleTexture(gs, is, it, iq, iu, iv); - - uint8_t tr = static_cast(texel & 0xFF); - uint8_t tg = static_cast((texel >> 8) & 0xFF); - uint8_t tb = static_cast((texel >> 16) & 0xFF); - uint8_t ta = static_cast((texel >> 24) & 0xFF); - - const auto &tex = ctx.tex0; - const uint8_t shadeR = r; - const uint8_t shadeG = g; - const uint8_t shadeB = b; - const uint8_t shadeA = a; - const TextureCombineResult color = combineTexture(tex, shadeR, shadeG, shadeB, shadeA, tr, tg, tb, ta); - - r = color.r; - g = color.g; - b = color.b; - a = color.a; - } - - const uint8_t fog = clampU8(static_cast(v0.fog * w0 + v1.fog * w1 + v2.fog * w2)); - writePixel(gs, x, y, static_cast(z + 0.5), r, g, b, a, fog); - } - } -} - -void GSRasterizer::drawLine(GS *gs) -{ - const GSVertex &v0 = gs->m_vtxQueue[0]; - const GSVertex &v1 = gs->m_vtxQueue[1]; - const auto &ctx = gs->activeContext(); - - int ofx = ctx.xyoffset.ofx >> 4; - int ofy = ctx.xyoffset.ofy >> 4; - - int x0 = static_cast(v0.x) - ofx; - int y0 = static_cast(v0.y) - ofy; - int x1 = static_cast(v1.x) - ofx; - int y1 = static_cast(v1.y) - ofy; - - int dx = std::abs(x1 - x0); - int dy = -std::abs(y1 - y0); - int sx = (x0 < x1) ? 1 : -1; - int sy = (y0 < y1) ? 1 : -1; - int err = dx + dy; - - int totalSteps = std::max(std::abs(x1 - x0), std::abs(y1 - y0)); - if (totalSteps == 0) - totalSteps = 1; - int step = 0; - - for (;;) - { - float t = static_cast(step) / static_cast(totalSteps); - uint8_t r, g, b, a; - if (gs->m_prim.iip) - { - r = clampU8(static_cast(v0.r + (v1.r - v0.r) * t)); - g = clampU8(static_cast(v0.g + (v1.g - v0.g) * t)); - b = clampU8(static_cast(v0.b + (v1.b - v0.b) * t)); - a = clampU8(static_cast(v0.a + (v1.a - v0.a) * t)); - } - else - { - r = v1.r; - g = v1.g; - b = v1.b; - a = v1.a; - } - - double z = (v0.z + (v1.z - v0.z) * t); - const uint8_t fog = clampU8(static_cast(v0.fog + (v1.fog - v0.fog) * t)); - writePixel(gs, x0, y0, static_cast(z), r, g, b, a, fog); - - if (x0 == x1 && y0 == y1) - break; - - int e2 = 2 * err; - if (e2 >= dy) - { - err += dy; - x0 += sx; - } - if (e2 <= dx) - { - err += dx; - y0 += sy; - } - ++step; - } -} diff --git a/ps2xRuntime/src/lib/ps2_memory.cpp b/ps2xRuntime/src/lib/ps2_memory.cpp index 01bbcc25f..7cb2ba463 100644 --- a/ps2xRuntime/src/lib/ps2_memory.cpp +++ b/ps2xRuntime/src/lib/ps2_memory.cpp @@ -1,6 +1,6 @@ #include "runtime/ps2_memory.h" #include "runtime/ps2_address.h" -#include "runtime/ps2_gs_gpu.h" +#include "runtime/gs/gs_frontend.h" #include "ps2_log.h" #include #include diff --git a/ps2xRuntime/src/lib/ps2_runtime.cpp b/ps2xRuntime/src/lib/ps2_runtime.cpp index a6ed05b27..ddacb0c7d 100644 --- a/ps2xRuntime/src/lib/ps2_runtime.cpp +++ b/ps2xRuntime/src/lib/ps2_runtime.cpp @@ -4,7 +4,7 @@ #include "ps2_syscalls.h" #include "game_overrides.h" #include "ps2_runtime_macros.h" -#include "runtime/ps2_gs_gpu.h" +#include "runtime/gs/gs_frontend.h" #include "runtime/ee_scheduler.h" #include "ThreadNaming.h" #include "Kernel/Stubs/Audio.h" diff --git a/ps2xRuntime/src/lib/ps2_vu1.cpp b/ps2xRuntime/src/lib/ps2_vu1.cpp deleted file mode 100644 index 2c22cc27e..000000000 --- a/ps2xRuntime/src/lib/ps2_vu1.cpp +++ /dev/null @@ -1 +0,0 @@ -// VU1 interpreter implementation has been split into src/lib/vu/*.cpp. diff --git a/ps2xRuntime/src/lib/vu/ps2_vu1_core.cpp b/ps2xRuntime/src/lib/vu/ps2_vu1_core.cpp index dbaead44b..bd75bba31 100644 --- a/ps2xRuntime/src/lib/vu/ps2_vu1_core.cpp +++ b/ps2xRuntime/src/lib/vu/ps2_vu1_core.cpp @@ -1,6 +1,6 @@ #include "runtime/ps2_vu1.h" -#include "runtime/ps2_gif_arbiter.h" -#include "runtime/ps2_gs_gpu.h" +#include "runtime/gs/ps2_gif_arbiter.h" +#include "runtime/gs/gs_frontend.h" #include "runtime/ps2_memory.h" #include "ps2_vu1_detail.h" diff --git a/ps2xRuntime/src/lib/vu/ps2_vu1_lower.cpp b/ps2xRuntime/src/lib/vu/ps2_vu1_lower.cpp index 7d235d7b4..94be78914 100644 --- a/ps2xRuntime/src/lib/vu/ps2_vu1_lower.cpp +++ b/ps2xRuntime/src/lib/vu/ps2_vu1_lower.cpp @@ -1,6 +1,6 @@ #include "runtime/ps2_vu1.h" -#include "runtime/ps2_gif_arbiter.h" -#include "runtime/ps2_gs_gpu.h" +#include "runtime/gs/ps2_gif_arbiter.h" +#include "runtime/gs/gs_frontend.h" #include "runtime/ps2_memory.h" #include "ps2_vu1_detail.h" diff --git a/ps2xTest/src/ps2_gs_tests.cpp b/ps2xTest/src/ps2_gs_tests.cpp index 5f6915d70..8343775cb 100644 --- a/ps2xTest/src/ps2_gs_tests.cpp +++ b/ps2xTest/src/ps2_gs_tests.cpp @@ -3,13 +3,12 @@ #include "ps2_runtime.h" #include "ps2_stubs.h" #include "ps2_syscalls.h" -#include "runtime/ps2_gs_gpu.h" +#include "runtime/gs/gs_frontend.h" #include "runtime/ee_scheduler.h" -#include "runtime/ps2_gs_memory.h" -#include "runtime/ps2_gs_rasterizer.h" -#include "runtime/ps2_gs_psmct32.h" -#include "runtime/ps2_gs_psmt4.h" -#include "runtime/ps2_gs_psmt8.h" +#include "runtime/gs/ps2_gs_memory.h" +#include "runtime/gs/ps2_gs_psmct32.h" +#include "runtime/gs/ps2_gs_psmt4.h" +#include "runtime/gs/ps2_gs_psmt8.h" #include "Stubs/Helpers/Support.h" #include "Stubs/GS.h" @@ -2861,9 +2860,13 @@ void register_ps2_gs_tests() std::vector vram(PS2_GS_VRAM_SIZE, 0u); GS gs; gs.init(vram.data(), static_cast(vram.size()), nullptr); - GSRasterizer rasterizer; constexpr uint32_t kTexTbp = 64u; + constexpr uint64_t kFrameReg = + (0ull << 0) | + (1ull << 16) | + (static_cast(GS_PSM_CT32) << 24); + constexpr uint64_t kZbuf = (1ull << 32); constexpr uint64_t kTex0 = (static_cast(kTexTbp) << 0) | (16ull << 14) | @@ -2873,22 +2876,57 @@ void register_ps2_gs_tests() (1ull << 34) | (1ull << 35); constexpr uint64_t kPrim = - static_cast(GS_PRIM_TRIANGLE) | + static_cast(GS_PRIM_SPRITE) | (1ull << 4); constexpr uint32_t kExpectedColor = 0xFF3366CCu; constexpr uint32_t kUnsaturatedColor = 0xFF00FF00u; + auto packFloat = [](float value) -> uint32_t + { + uint32_t bits = 0u; + std::memcpy(&bits, &value, sizeof(bits)); + return bits; + }; + auto packSt = [&](float s, float tValue) -> uint64_t + { + return static_cast(packFloat(s)) | + (static_cast(packFloat(tValue)) << 32u); + }; + gs.WriteVram(GS_PSM_CT32, kTexTbp, 16u, 1u, 0u, kExpectedColor); gs.WriteVram(GS_PSM_CT32, kTexTbp, 16u, 32u, 0u, kUnsaturatedColor); + gs.writeRegister(GS_REG_FRAME_1, kFrameReg); + gs.writeRegister(GS_REG_ZBUF_1, kZbuf); + gs.writeRegister(GS_REG_SCISSOR_1, 0ull); + gs.writeRegister(GS_REG_XYOFFSET_1, 0ull); + gs.writeRegister(GS_REG_TEST_1, 0x30000ull); gs.writeRegister(GS_REG_TEX0_1, kTex0); gs.writeRegister(GS_REG_PRIM, kPrim); + gs.writeRegister(GS_REG_RGBAQ, 0x3F80000080808080ull); + gs.writeRegister(GS_REG_ST, packSt(1.0f / 1024.0f, 0.0f)); + gs.writeRegister(GS_REG_XYZ2, 0ull); + gs.writeRegister(GS_REG_ST, packSt(1.0f / 1024.0f, 0.0f)); + gs.writeRegister(GS_REG_XYZ2, (16ull << 0) | (16ull << 16)); - const uint32_t sampled = - rasterizer.sampleTexture(&gs, 1.0f / 1024.0f, 0.0f, 1.0f, 0u, 0u); + const uint32_t sampled = gs.ReadVram(GS_PSM_CT32, 0u, 1u, 0u, 0u); t.Equals(sampled, kExpectedColor, "TW/TH values above 10 should address a 1024-pixel texture instead of growing beyond GS limits"); }); + tc.Run("GS backend replacement preserves canonical local memory", [](TestCase &t) + { + std::vector vram(PS2_GS_VRAM_SIZE, 0u); + GS gs; + gs.init(vram.data(), static_cast(vram.size()), nullptr); + + constexpr uint32_t kColor = 0xA55A33CCu; + gs.WriteVram(GS_PSM_CT32, 64u, 1u, 3u, 2u, kColor); + gs.setRasterBackend(nullptr); + + t.Equals(gs.ReadVram(GS_PSM_CT32, 64u, 1u, 3u, 2u), kColor, + "switching raster backends must retain the logical 4 MiB GS local memory"); + }); + tc.Run("GS TEX2 updates CLUT state independently from TEX0", [](TestCase &t) { std::vector vram(PS2_GS_VRAM_SIZE, 0u); diff --git a/ps2xTest/src/ps2_memory_tests.cpp b/ps2xTest/src/ps2_memory_tests.cpp index aa8013c4b..7c3e8ea5d 100644 --- a/ps2xTest/src/ps2_memory_tests.cpp +++ b/ps2xTest/src/ps2_memory_tests.cpp @@ -1,7 +1,7 @@ #include "MiniTest.h" #include "runtime/ps2_memory.h" -#include "runtime/ps2_gs_gpu.h" -#include "runtime/ps2_gs_psmct32.h" +#include "runtime/gs/gs_frontend.h" +#include "runtime/gs/ps2_gs_psmct32.h" #include "ps2_runtime.h" #include "ps2_runtime_macros.h" #include "Stubs/DMA.h" diff --git a/ps2xTest/src/ps2_runtime_expansion_tests.cpp b/ps2xTest/src/ps2_runtime_expansion_tests.cpp index cbf64342e..ad7df4660 100644 --- a/ps2xTest/src/ps2_runtime_expansion_tests.cpp +++ b/ps2xTest/src/ps2_runtime_expansion_tests.cpp @@ -7,9 +7,9 @@ #include "runtime/ps2_memory.h" #include "ps2_syscalls.h" #include "ps2_stubs.h" -#include "runtime/ps2_gs_gpu.h" +#include "runtime/gs/gs_frontend.h" #include "runtime/ee_scheduler.h" -#include "runtime/ps2_gs_psmct32.h" +#include "runtime/gs/ps2_gs_psmct32.h" #include "ps2_runtime_macros.h" #include "Stubs/MPEG.h" #include "Stubs/CD.h" diff --git a/ps2xTest/src/ps2_vu1_tests.cpp b/ps2xTest/src/ps2_vu1_tests.cpp index 8c0ff0d3e..0754b69fc 100644 --- a/ps2xTest/src/ps2_vu1_tests.cpp +++ b/ps2xTest/src/ps2_vu1_tests.cpp @@ -1,7 +1,7 @@ #include "MiniTest.h" -#include "runtime/ps2_gif_arbiter.h" -#include "runtime/ps2_gs_gpu.h" -#include "runtime/ps2_gs_psmct32.h" +#include "runtime/gs/ps2_gif_arbiter.h" +#include "runtime/gs/gs_frontend.h" +#include "runtime/gs/ps2_gs_psmct32.h" #include "runtime/ps2_memory.h" #include "runtime/ps2_vu1.h"